FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mlpdec.c
Go to the documentation of this file.
1 /*
2  * MLP decoder
3  * Copyright (c) 2007-2008 Ian Caulfield
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * MLP decoder
25  */
26 
27 #include <stdint.h>
28 
29 #include "avcodec.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/intreadwrite.h"
33 #include "get_bits.h"
34 #include "internal.h"
35 #include "libavutil/crc.h"
36 #include "parser.h"
37 #include "mlp_parser.h"
38 #include "mlpdsp.h"
39 #include "mlp.h"
40 #include "config.h"
41 
42 /** number of bits used for VLC lookup - longest Huffman code is 9 */
43 #if ARCH_ARM
44 #define VLC_BITS 5
45 #define VLC_STATIC_SIZE 64
46 #else
47 #define VLC_BITS 9
48 #define VLC_STATIC_SIZE 512
49 #endif
50 
51 typedef struct SubStream {
52  /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
54 
55  //@{
56  /** restart header data */
57  /// The type of noise to be used in the rematrix stage.
58  uint16_t noise_type;
59 
60  /// The index of the first channel coded in this substream.
62  /// The index of the last channel coded in this substream.
64  /// The number of channels input into the rematrix stage.
66  /// For each channel output by the matrix, the output channel to map it to
68  /// The channel layout for this substream
69  uint64_t ch_layout;
70  /// The matrix encoding mode for this substream
72 
73  /// Channel coding parameters for channels in the substream
75 
76  /// The left shift applied to random noise in 0x31ea substreams.
78  /// The current seed value for the pseudorandom noise generator(s).
79  uint32_t noisegen_seed;
80 
81  /// Set if the substream contains extra info to check the size of VLC blocks.
83 
84  /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
86 #define PARAM_BLOCKSIZE (1 << 7)
87 #define PARAM_MATRIX (1 << 6)
88 #define PARAM_OUTSHIFT (1 << 5)
89 #define PARAM_QUANTSTEP (1 << 4)
90 #define PARAM_FIR (1 << 3)
91 #define PARAM_IIR (1 << 2)
92 #define PARAM_HUFFOFFSET (1 << 1)
93 #define PARAM_PRESENCE (1 << 0)
94  //@}
95 
96  //@{
97  /** matrix data */
98 
99  /// Number of matrices to be applied.
101 
102  /// matrix output channel
104 
105  /// Whether the LSBs of the matrix output are encoded in the bitstream.
107  /// Matrix coefficients, stored as 2.14 fixed point.
109  /// Left shift to apply to noise values in 0x31eb substreams.
111  //@}
112 
113  /// Left shift to apply to Huffman-decoded residuals.
115 
116  /// number of PCM samples in current audio block
117  uint16_t blocksize;
118  /// Number of PCM samples decoded so far in this frame.
119  uint16_t blockpos;
120 
121  /// Left shift to apply to decoded PCM values to get final 24-bit output.
123 
124  /// Running XOR of all output samples.
126 
127 } SubStream;
128 
129 typedef struct MLPDecodeContext {
131 
132  /// Current access unit being read has a major sync.
134 
135  /// Size of the major sync unit, in bytes
137 
138  /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
140 
141  /// Number of substreams contained within this stream.
143 
144  /// Index of the last substream to decode - further substreams are skipped.
146 
147  /// Stream needs channel reordering to comply with FFmpeg's channel order
149 
150  /// number of PCM samples contained in each frame
152  /// next power of two above the number of samples in each frame
154 
156 
159 
163 
166 
167 static const uint64_t thd_channel_order[] = {
169  AV_CH_FRONT_CENTER, // C
170  AV_CH_LOW_FREQUENCY, // LFE
175  AV_CH_BACK_CENTER, // Cs
176  AV_CH_TOP_CENTER, // Ts
179  AV_CH_TOP_FRONT_CENTER, // Cvh
180  AV_CH_LOW_FREQUENCY_2, // LFE2
181 };
182 
183 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
184  int index)
185 {
186  int i;
187 
188  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
189  return 0;
190 
191  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
192  if (channel_layout & thd_channel_order[i] && !index--)
193  return thd_channel_order[i];
194  return 0;
195 }
196 
197 static VLC huff_vlc[3];
198 
199 /** Initialize static data, constant between all invocations of the codec. */
200 
201 static av_cold void init_static(void)
202 {
203  if (!huff_vlc[0].bits) {
204  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
205  &ff_mlp_huffman_tables[0][0][1], 2, 1,
206  &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
207  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
208  &ff_mlp_huffman_tables[1][0][1], 2, 1,
209  &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
210  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
211  &ff_mlp_huffman_tables[2][0][1], 2, 1,
212  &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
213  }
214 
215  ff_mlp_init_crc();
216 }
217 
219  unsigned int substr, unsigned int ch)
220 {
221  SubStream *s = &m->substream[substr];
222  ChannelParams *cp = &s->channel_params[ch];
223  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
224  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
225  int32_t sign_huff_offset = cp->huff_offset;
226 
227  if (cp->codebook > 0)
228  sign_huff_offset -= 7 << lsb_bits;
229 
230  if (sign_shift >= 0)
231  sign_huff_offset -= 1 << sign_shift;
232 
233  return sign_huff_offset;
234 }
235 
236 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
237  * and plain LSBs. */
238 
240  unsigned int substr, unsigned int pos)
241 {
242  SubStream *s = &m->substream[substr];
243  unsigned int mat, channel;
244 
245  for (mat = 0; mat < s->num_primitive_matrices; mat++)
246  if (s->lsb_bypass[mat])
247  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
248 
249  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
250  ChannelParams *cp = &s->channel_params[channel];
251  int codebook = cp->codebook;
252  int quant_step_size = s->quant_step_size[channel];
253  int lsb_bits = cp->huff_lsbs - quant_step_size;
254  int result = 0;
255 
256  if (codebook > 0)
257  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
258  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
259 
260  if (result < 0)
261  return AVERROR_INVALIDDATA;
262 
263  if (lsb_bits > 0)
264  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
265 
266  result += cp->sign_huff_offset;
267  result <<= quant_step_size;
268 
269  m->sample_buffer[pos + s->blockpos][channel] = result;
270  }
271 
272  return 0;
273 }
274 
276 {
277  MLPDecodeContext *m = avctx->priv_data;
278  int substr;
279 
280  init_static();
281  m->avctx = avctx;
282  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
283  m->substream[substr].lossless_check_data = 0xffffffff;
284  ff_mlpdsp_init(&m->dsp);
285 
286  return 0;
287 }
288 
289 /** Read a major sync info header - contains high level information about
290  * the stream - sample rate, channel arrangement etc. Most of this
291  * information is not actually necessary for decoding, only for playback.
292  */
293 
295 {
297  int substr, ret;
298 
299  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
300  return ret;
301 
302  if (mh.group1_bits == 0) {
303  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
304  return AVERROR_INVALIDDATA;
305  }
306  if (mh.group2_bits > mh.group1_bits) {
308  "Channel group 2 cannot have more bits per sample than group 1.\n");
309  return AVERROR_INVALIDDATA;
310  }
311 
314  "Channel groups with differing sample rates are not currently supported.\n");
315  return AVERROR_INVALIDDATA;
316  }
317 
318  if (mh.group1_samplerate == 0) {
319  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
320  return AVERROR_INVALIDDATA;
321  }
324  "Sampling rate %d is greater than the supported maximum (%d).\n",
326  return AVERROR_INVALIDDATA;
327  }
328  if (mh.access_unit_size > MAX_BLOCKSIZE) {
330  "Block size %d is greater than the supported maximum (%d).\n",
332  return AVERROR_INVALIDDATA;
333  }
336  "Block size pow2 %d is greater than the supported maximum (%d).\n",
338  return AVERROR_INVALIDDATA;
339  }
340 
341  if (mh.num_substreams == 0)
342  return AVERROR_INVALIDDATA;
343  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
344  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
345  return AVERROR_INVALIDDATA;
346  }
347  if (mh.num_substreams > MAX_SUBSTREAMS) {
349  "%d substreams (more than the "
350  "maximum supported by the decoder)",
351  mh.num_substreams);
352  return AVERROR_PATCHWELCOME;
353  }
354 
356 
359 
361 
362  /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
364 
367 
369  if (mh.group1_bits > 16)
371  else
377 
378  m->params_valid = 1;
379  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
380  m->substream[substr].restart_seen = 0;
381 
382  /* Set the layout for each substream. When there's more than one, the first
383  * substream is Stereo. Subsequent substreams' layouts are indicated in the
384  * major sync. */
385  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
386  if (mh.stream_type != 0xbb) {
388  "unexpected stream_type %X in MLP",
389  mh.stream_type);
390  return AVERROR_PATCHWELCOME;
391  }
392  if ((substr = (mh.num_substreams > 1)))
394  m->substream[substr].ch_layout = mh.channel_layout_mlp;
395  } else {
396  if (mh.stream_type != 0xba) {
398  "unexpected stream_type %X in !MLP",
399  mh.stream_type);
400  return AVERROR_PATCHWELCOME;
401  }
402  if ((substr = (mh.num_substreams > 1)))
404  if (mh.num_substreams > 2)
407  else
410 
411  if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
412  av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
413  m->max_decoded_substream = 0;
414  if (m->avctx->channels==2)
416  }
417  }
418 
419  m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
420 
421  /* Parse the TrueHD decoder channel modifiers and set each substream's
422  * AVMatrixEncoding accordingly.
423  *
424  * The meaning of the modifiers depends on the channel layout:
425  *
426  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
427  *
428  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
429  *
430  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
431  * layouts with an Ls/Rs channel pair
432  */
433  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
436  if (mh.num_substreams > 2 &&
441 
442  if (mh.num_substreams > 1 &&
447 
448  if (mh.num_substreams > 0)
449  switch (mh.channel_modifier_thd_stream0) {
452  break;
455  break;
456  default:
457  break;
458  }
459  }
460 
461  return 0;
462 }
463 
464 /** Read a restart header from a block in a substream. This contains parameters
465  * required to decode the audio that do not change very often. Generally
466  * (always) present only in blocks following a major sync. */
467 
469  const uint8_t *buf, unsigned int substr)
470 {
471  SubStream *s = &m->substream[substr];
472  unsigned int ch;
473  int sync_word, tmp;
474  uint8_t checksum;
475  uint8_t lossless_check;
476  int start_count = get_bits_count(gbp);
477  int min_channel, max_channel, max_matrix_channel;
478  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
481 
482  sync_word = get_bits(gbp, 13);
483 
484  if (sync_word != 0x31ea >> 1) {
486  "restart header sync incorrect (got 0x%04x)\n", sync_word);
487  return AVERROR_INVALIDDATA;
488  }
489 
490  s->noise_type = get_bits1(gbp);
491 
492  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
493  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
494  return AVERROR_INVALIDDATA;
495  }
496 
497  skip_bits(gbp, 16); /* Output timestamp */
498 
499  min_channel = get_bits(gbp, 4);
500  max_channel = get_bits(gbp, 4);
501  max_matrix_channel = get_bits(gbp, 4);
502 
503  if (max_matrix_channel > std_max_matrix_channel) {
505  "Max matrix channel cannot be greater than %d.\n",
506  std_max_matrix_channel);
507  return AVERROR_INVALIDDATA;
508  }
509 
510  if (max_channel != max_matrix_channel) {
512  "Max channel must be equal max matrix channel.\n");
513  return AVERROR_INVALIDDATA;
514  }
515 
516  /* This should happen for TrueHD streams with >6 channels and MLP's noise
517  * type. It is not yet known if this is allowed. */
518  if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
520  "%d channels (more than the "
521  "maximum supported by the decoder)",
522  max_channel + 2);
523  return AVERROR_PATCHWELCOME;
524  }
525 
526  if (min_channel > max_channel) {
528  "Substream min channel cannot be greater than max channel.\n");
529  return AVERROR_INVALIDDATA;
530  }
531 
532  s->min_channel = min_channel;
533  s->max_channel = max_channel;
534  s->max_matrix_channel = max_matrix_channel;
535 
536 #if FF_API_REQUEST_CHANNELS
538  if (m->avctx->request_channels > 0 &&
539  m->avctx->request_channels <= s->max_channel + 1 &&
540  m->max_decoded_substream > substr) {
542  "Extracting %d-channel downmix from substream %d. "
543  "Further substreams will be skipped.\n",
544  s->max_channel + 1, substr);
545  m->max_decoded_substream = substr;
547  } else
548 #endif
552  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
553  "Further substreams will be skipped.\n",
554  s->max_channel + 1, s->ch_layout, substr);
555  m->max_decoded_substream = substr;
556  }
557 
558  s->noise_shift = get_bits(gbp, 4);
559  s->noisegen_seed = get_bits(gbp, 23);
560 
561  skip_bits(gbp, 19);
562 
563  s->data_check_present = get_bits1(gbp);
564  lossless_check = get_bits(gbp, 8);
565  if (substr == m->max_decoded_substream
566  && s->lossless_check_data != 0xffffffff) {
568  if (tmp != lossless_check)
570  "Lossless check failed - expected %02x, calculated %02x.\n",
571  lossless_check, tmp);
572  }
573 
574  skip_bits(gbp, 16);
575 
576  memset(s->ch_assign, 0, sizeof(s->ch_assign));
577 
578  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
579  int ch_assign = get_bits(gbp, 6);
580  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
581  uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
582  ch_assign);
584  channel);
585  }
586  if ((unsigned)ch_assign > s->max_matrix_channel) {
588  "Assignment of matrix channel %d to invalid output channel %d",
589  ch, ch_assign);
590  return AVERROR_PATCHWELCOME;
591  }
592  s->ch_assign[ch_assign] = ch;
593  }
594 
595  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
596 
597  if (checksum != get_bits(gbp, 8))
598  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
599 
600  /* Set default decoding parameters. */
601  s->param_presence_flags = 0xff;
602  s->num_primitive_matrices = 0;
603  s->blocksize = 8;
604  s->lossless_check_data = 0;
605 
606  memset(s->output_shift , 0, sizeof(s->output_shift ));
607  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
608 
609  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
610  ChannelParams *cp = &s->channel_params[ch];
611  cp->filter_params[FIR].order = 0;
612  cp->filter_params[IIR].order = 0;
613  cp->filter_params[FIR].shift = 0;
614  cp->filter_params[IIR].shift = 0;
615 
616  /* Default audio coding is 24-bit raw PCM. */
617  cp->huff_offset = 0;
618  cp->sign_huff_offset = (-1) << 23;
619  cp->codebook = 0;
620  cp->huff_lsbs = 24;
621  }
622 
623  if (substr == m->max_decoded_substream) {
624  m->avctx->channels = s->max_matrix_channel + 1;
625  m->avctx->channel_layout = s->ch_layout;
627  s->output_shift,
630 
631  if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
634  int i = s->ch_assign[4];
635  s->ch_assign[4] = s->ch_assign[3];
636  s->ch_assign[3] = s->ch_assign[2];
637  s->ch_assign[2] = i;
638  } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
639  FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
640  FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
641  }
642  }
643 
644  }
645 
646  return 0;
647 }
648 
649 /** Read parameters for one of the prediction filters. */
650 
652  unsigned int substr, unsigned int channel,
653  unsigned int filter)
654 {
655  SubStream *s = &m->substream[substr];
657  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
658  const char fchar = filter ? 'I' : 'F';
659  int i, order;
660 
661  // Filter is 0 for FIR, 1 for IIR.
662  av_assert0(filter < 2);
663 
664  if (m->filter_changed[channel][filter]++ > 1) {
665  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
666  return AVERROR_INVALIDDATA;
667  }
668 
669  order = get_bits(gbp, 4);
670  if (order > max_order) {
672  "%cIR filter order %d is greater than maximum %d.\n",
673  fchar, order, max_order);
674  return AVERROR_INVALIDDATA;
675  }
676  fp->order = order;
677 
678  if (order > 0) {
679  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
680  int coeff_bits, coeff_shift;
681 
682  fp->shift = get_bits(gbp, 4);
683 
684  coeff_bits = get_bits(gbp, 5);
685  coeff_shift = get_bits(gbp, 3);
686  if (coeff_bits < 1 || coeff_bits > 16) {
688  "%cIR filter coeff_bits must be between 1 and 16.\n",
689  fchar);
690  return AVERROR_INVALIDDATA;
691  }
692  if (coeff_bits + coeff_shift > 16) {
694  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
695  fchar);
696  return AVERROR_INVALIDDATA;
697  }
698 
699  for (i = 0; i < order; i++)
700  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
701 
702  if (get_bits1(gbp)) {
703  int state_bits, state_shift;
704 
705  if (filter == FIR) {
707  "FIR filter has state data specified.\n");
708  return AVERROR_INVALIDDATA;
709  }
710 
711  state_bits = get_bits(gbp, 4);
712  state_shift = get_bits(gbp, 4);
713 
714  /* TODO: Check validity of state data. */
715 
716  for (i = 0; i < order; i++)
717  fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
718  }
719  }
720 
721  return 0;
722 }
723 
724 /** Read parameters for primitive matrices. */
725 
726 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
727 {
728  SubStream *s = &m->substream[substr];
729  unsigned int mat, ch;
730  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
733 
734  if (m->matrix_changed++ > 1) {
735  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
736  return AVERROR_INVALIDDATA;
737  }
738 
739  s->num_primitive_matrices = get_bits(gbp, 4);
740 
741  if (s->num_primitive_matrices > max_primitive_matrices) {
743  "Number of primitive matrices cannot be greater than %d.\n",
744  max_primitive_matrices);
745  return AVERROR_INVALIDDATA;
746  }
747 
748  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
749  int frac_bits, max_chan;
750  s->matrix_out_ch[mat] = get_bits(gbp, 4);
751  frac_bits = get_bits(gbp, 4);
752  s->lsb_bypass [mat] = get_bits1(gbp);
753 
754  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
756  "Invalid channel %d specified as output from matrix.\n",
757  s->matrix_out_ch[mat]);
758  return AVERROR_INVALIDDATA;
759  }
760  if (frac_bits > 14) {
762  "Too many fractional bits specified.\n");
763  return AVERROR_INVALIDDATA;
764  }
765 
766  max_chan = s->max_matrix_channel;
767  if (!s->noise_type)
768  max_chan+=2;
769 
770  for (ch = 0; ch <= max_chan; ch++) {
771  int coeff_val = 0;
772  if (get_bits1(gbp))
773  coeff_val = get_sbits(gbp, frac_bits + 2);
774 
775  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
776  }
777 
778  if (s->noise_type)
779  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
780  else
781  s->matrix_noise_shift[mat] = 0;
782  }
783 
784  return 0;
785 }
786 
787 /** Read channel parameters. */
788 
789 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
790  GetBitContext *gbp, unsigned int ch)
791 {
792  SubStream *s = &m->substream[substr];
793  ChannelParams *cp = &s->channel_params[ch];
794  FilterParams *fir = &cp->filter_params[FIR];
795  FilterParams *iir = &cp->filter_params[IIR];
796  int ret;
797 
799  if (get_bits1(gbp))
800  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
801  return ret;
802 
804  if (get_bits1(gbp))
805  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
806  return ret;
807 
808  if (fir->order + iir->order > 8) {
809  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
810  return AVERROR_INVALIDDATA;
811  }
812 
813  if (fir->order && iir->order &&
814  fir->shift != iir->shift) {
816  "FIR and IIR filters must use the same precision.\n");
817  return AVERROR_INVALIDDATA;
818  }
819  /* The FIR and IIR filters must have the same precision.
820  * To simplify the filtering code, only the precision of the
821  * FIR filter is considered. If only the IIR filter is employed,
822  * the FIR filter precision is set to that of the IIR filter, so
823  * that the filtering code can use it. */
824  if (!fir->order && iir->order)
825  fir->shift = iir->shift;
826 
828  if (get_bits1(gbp))
829  cp->huff_offset = get_sbits(gbp, 15);
830 
831  cp->codebook = get_bits(gbp, 2);
832  cp->huff_lsbs = get_bits(gbp, 5);
833 
834  if (cp->huff_lsbs > 24) {
835  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
836  cp->huff_lsbs = 0;
837  return AVERROR_INVALIDDATA;
838  }
839 
840  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
841 
842  return 0;
843 }
844 
845 /** Read decoding parameters that change more often than those in the restart
846  * header. */
847 
849  unsigned int substr)
850 {
851  SubStream *s = &m->substream[substr];
852  unsigned int ch;
853  int ret;
854 
856  if (get_bits1(gbp))
857  s->param_presence_flags = get_bits(gbp, 8);
858 
860  if (get_bits1(gbp)) {
861  s->blocksize = get_bits(gbp, 9);
862  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
863  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
864  s->blocksize = 0;
865  return AVERROR_INVALIDDATA;
866  }
867  }
868 
870  if (get_bits1(gbp))
871  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
872  return ret;
873 
875  if (get_bits1(gbp)) {
876  for (ch = 0; ch <= s->max_matrix_channel; ch++)
877  s->output_shift[ch] = get_sbits(gbp, 4);
878  if (substr == m->max_decoded_substream)
880  s->output_shift,
883  }
884 
886  if (get_bits1(gbp))
887  for (ch = 0; ch <= s->max_channel; ch++) {
888  ChannelParams *cp = &s->channel_params[ch];
889 
890  s->quant_step_size[ch] = get_bits(gbp, 4);
891 
892  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
893  }
894 
895  for (ch = s->min_channel; ch <= s->max_channel; ch++)
896  if (get_bits1(gbp))
897  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
898  return ret;
899 
900  return 0;
901 }
902 
903 #define MSB_MASK(bits) (-1u << (bits))
904 
905 /** Generate PCM samples using the prediction filters and residual values
906  * read from the data stream, and update the filter state. */
907 
908 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
909  unsigned int channel)
910 {
911  SubStream *s = &m->substream[substr];
912  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
914  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
915  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
916  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
917  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
918  unsigned int filter_shift = fir->shift;
919  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
920 
921  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
922  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
923 
924  m->dsp.mlp_filter_channel(firbuf, fircoeff,
925  fir->order, iir->order,
926  filter_shift, mask, s->blocksize,
927  &m->sample_buffer[s->blockpos][channel]);
928 
929  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
930  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
931 }
932 
933 /** Read a block of PCM residual data (or actual if no filtering active). */
934 
936  unsigned int substr)
937 {
938  SubStream *s = &m->substream[substr];
939  unsigned int i, ch, expected_stream_pos = 0;
940  int ret;
941 
942  if (s->data_check_present) {
943  expected_stream_pos = get_bits_count(gbp);
944  expected_stream_pos += get_bits(gbp, 16);
946  "Substreams with VLC block size check info");
947  }
948 
949  if (s->blockpos + s->blocksize > m->access_unit_size) {
950  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
951  return AVERROR_INVALIDDATA;
952  }
953 
954  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
955  s->blocksize * sizeof(m->bypassed_lsbs[0]));
956 
957  for (i = 0; i < s->blocksize; i++)
958  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
959  return ret;
960 
961  for (ch = s->min_channel; ch <= s->max_channel; ch++)
962  filter_channel(m, substr, ch);
963 
964  s->blockpos += s->blocksize;
965 
966  if (s->data_check_present) {
967  if (get_bits_count(gbp) != expected_stream_pos)
968  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
969  skip_bits(gbp, 8);
970  }
971 
972  return 0;
973 }
974 
975 /** Data table used for TrueHD noise generation function. */
976 
977 static const int8_t noise_table[256] = {
978  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
979  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
980  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
981  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
982  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
983  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
984  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
985  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
986  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
987  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
988  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
989  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
990  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
991  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
992  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
993  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
994 };
995 
996 /** Noise generation functions.
997  * I'm not sure what these are for - they seem to be some kind of pseudorandom
998  * sequence generators, used to generate noise data which is used when the
999  * channels are rematrixed. I'm not sure if they provide a practical benefit
1000  * to compression, or just obfuscate the decoder. Are they for some kind of
1001  * dithering? */
1002 
1003 /** Generate two channels of noise, used in the matrix when
1004  * restart sync word == 0x31ea. */
1005 
1006 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1007 {
1008  SubStream *s = &m->substream[substr];
1009  unsigned int i;
1010  uint32_t seed = s->noisegen_seed;
1011  unsigned int maxchan = s->max_matrix_channel;
1012 
1013  for (i = 0; i < s->blockpos; i++) {
1014  uint16_t seed_shr7 = seed >> 7;
1015  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
1016  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
1017 
1018  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1019  }
1020 
1021  s->noisegen_seed = seed;
1022 }
1023 
1024 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1025 
1026 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1027 {
1028  SubStream *s = &m->substream[substr];
1029  unsigned int i;
1030  uint32_t seed = s->noisegen_seed;
1031 
1032  for (i = 0; i < m->access_unit_size_pow2; i++) {
1033  uint8_t seed_shr15 = seed >> 15;
1034  m->noise_buffer[i] = noise_table[seed_shr15];
1035  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1036  }
1037 
1038  s->noisegen_seed = seed;
1039 }
1040 
1041 /** Write the audio data into the output buffer. */
1042 
1043 static int output_data(MLPDecodeContext *m, unsigned int substr,
1044  AVFrame *frame, int *got_frame_ptr)
1045 {
1046  AVCodecContext *avctx = m->avctx;
1047  SubStream *s = &m->substream[substr];
1048  unsigned int mat;
1049  unsigned int maxchan;
1050  int ret;
1051  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1052 
1053  if (m->avctx->channels != s->max_matrix_channel + 1) {
1054  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1055  return AVERROR_INVALIDDATA;
1056  }
1057 
1058  if (!s->blockpos) {
1059  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1060  return AVERROR_INVALIDDATA;
1061  }
1062 
1063  maxchan = s->max_matrix_channel;
1064  if (!s->noise_type) {
1065  generate_2_noise_channels(m, substr);
1066  maxchan += 2;
1067  } else {
1068  fill_noise_buffer(m, substr);
1069  }
1070 
1071  /* Apply the channel matrices in turn to reconstruct the original audio
1072  * samples. */
1073  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1074  unsigned int dest_ch = s->matrix_out_ch[mat];
1075  m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1076  s->matrix_coeff[mat],
1077  &m->bypassed_lsbs[0][mat],
1078  m->noise_buffer,
1079  s->num_primitive_matrices - mat,
1080  dest_ch,
1081  s->blockpos,
1082  maxchan,
1083  s->matrix_noise_shift[mat],
1085  MSB_MASK(s->quant_step_size[dest_ch]));
1086  }
1087 
1088  /* get output buffer */
1089  frame->nb_samples = s->blockpos;
1090  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1091  return ret;
1093  s->blockpos,
1094  m->sample_buffer,
1095  frame->data[0],
1096  s->ch_assign,
1097  s->output_shift,
1098  s->max_matrix_channel,
1099  is32);
1100 
1101  /* Update matrix encoding side data */
1102  if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1103  return ret;
1104 
1105  *got_frame_ptr = 1;
1106 
1107  return 0;
1108 }
1109 
1110 /** Read an access unit from the stream.
1111  * @return negative on error, 0 if not enough data is present in the input stream,
1112  * otherwise the number of bytes consumed. */
1113 
1114 static int read_access_unit(AVCodecContext *avctx, void* data,
1115  int *got_frame_ptr, AVPacket *avpkt)
1116 {
1117  const uint8_t *buf = avpkt->data;
1118  int buf_size = avpkt->size;
1119  MLPDecodeContext *m = avctx->priv_data;
1120  GetBitContext gb;
1121  unsigned int length, substr;
1122  unsigned int substream_start;
1123  unsigned int header_size = 4;
1124  unsigned int substr_header_size = 0;
1125  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1126  uint16_t substream_data_len[MAX_SUBSTREAMS];
1127  uint8_t parity_bits;
1128  int ret;
1129 
1130  if (buf_size < 4)
1131  return AVERROR_INVALIDDATA;
1132 
1133  length = (AV_RB16(buf) & 0xfff) * 2;
1134 
1135  if (length < 4 || length > buf_size)
1136  return AVERROR_INVALIDDATA;
1137 
1138  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1139 
1140  m->is_major_sync_unit = 0;
1141  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1142  if (read_major_sync(m, &gb) < 0)
1143  goto error;
1144  m->is_major_sync_unit = 1;
1145  header_size += m->major_sync_header_size;
1146  }
1147 
1148  if (!m->params_valid) {
1150  "Stream parameters not seen; skipping frame.\n");
1151  *got_frame_ptr = 0;
1152  return length;
1153  }
1154 
1155  substream_start = 0;
1156 
1157  for (substr = 0; substr < m->num_substreams; substr++) {
1158  int extraword_present, checkdata_present, end, nonrestart_substr;
1159 
1160  extraword_present = get_bits1(&gb);
1161  nonrestart_substr = get_bits1(&gb);
1162  checkdata_present = get_bits1(&gb);
1163  skip_bits1(&gb);
1164 
1165  end = get_bits(&gb, 12) * 2;
1166 
1167  substr_header_size += 2;
1168 
1169  if (extraword_present) {
1170  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1171  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1172  goto error;
1173  }
1174  skip_bits(&gb, 16);
1175  substr_header_size += 2;
1176  }
1177 
1178  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1179  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1180  goto error;
1181  }
1182 
1183  if (end + header_size + substr_header_size > length) {
1185  "Indicated length of substream %d data goes off end of "
1186  "packet.\n", substr);
1187  end = length - header_size - substr_header_size;
1188  }
1189 
1190  if (end < substream_start) {
1191  av_log(avctx, AV_LOG_ERROR,
1192  "Indicated end offset of substream %d data "
1193  "is smaller than calculated start offset.\n",
1194  substr);
1195  goto error;
1196  }
1197 
1198  if (substr > m->max_decoded_substream)
1199  continue;
1200 
1201  substream_parity_present[substr] = checkdata_present;
1202  substream_data_len[substr] = end - substream_start;
1203  substream_start = end;
1204  }
1205 
1206  parity_bits = ff_mlp_calculate_parity(buf, 4);
1207  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1208 
1209  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1210  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1211  goto error;
1212  }
1213 
1214  buf += header_size + substr_header_size;
1215 
1216  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1217  SubStream *s = &m->substream[substr];
1218  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1219 
1220  m->matrix_changed = 0;
1221  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1222 
1223  s->blockpos = 0;
1224  do {
1225  if (get_bits1(&gb)) {
1226  if (get_bits1(&gb)) {
1227  /* A restart header should be present. */
1228  if (read_restart_header(m, &gb, buf, substr) < 0)
1229  goto next_substr;
1230  s->restart_seen = 1;
1231  }
1232 
1233  if (!s->restart_seen)
1234  goto next_substr;
1235  if (read_decoding_params(m, &gb, substr) < 0)
1236  goto next_substr;
1237  }
1238 
1239  if (!s->restart_seen)
1240  goto next_substr;
1241 
1242  if ((ret = read_block_data(m, &gb, substr)) < 0)
1243  return ret;
1244 
1245  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1246  goto substream_length_mismatch;
1247 
1248  } while (!get_bits1(&gb));
1249 
1250  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1251 
1252  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1253  int shorten_by;
1254 
1255  if (get_bits(&gb, 16) != 0xD234)
1256  return AVERROR_INVALIDDATA;
1257 
1258  shorten_by = get_bits(&gb, 16);
1259  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1260  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1261  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1262  return AVERROR_INVALIDDATA;
1263 
1264  if (substr == m->max_decoded_substream)
1265  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1266  }
1267 
1268  if (substream_parity_present[substr]) {
1269  uint8_t parity, checksum;
1270 
1271  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1272  goto substream_length_mismatch;
1273 
1274  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1275  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1276 
1277  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1278  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1279  if ( get_bits(&gb, 8) != checksum)
1280  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1281  }
1282 
1283  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1284  goto substream_length_mismatch;
1285 
1286 next_substr:
1287  if (!s->restart_seen)
1289  "No restart header present in substream %d.\n", substr);
1290 
1291  buf += substream_data_len[substr];
1292  }
1293 
1294  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1295  return ret;
1296 
1297  return length;
1298 
1299 substream_length_mismatch:
1300  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1301  return AVERROR_INVALIDDATA;
1302 
1303 error:
1304  m->params_valid = 0;
1305  return AVERROR_INVALIDDATA;
1306 }
1307 
1308 #if CONFIG_MLP_DECODER
1309 AVCodec ff_mlp_decoder = {
1310  .name = "mlp",
1311  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1312  .type = AVMEDIA_TYPE_AUDIO,
1313  .id = AV_CODEC_ID_MLP,
1314  .priv_data_size = sizeof(MLPDecodeContext),
1315  .init = mlp_decode_init,
1317  .capabilities = CODEC_CAP_DR1,
1318 };
1319 #endif
1320 #if CONFIG_TRUEHD_DECODER
1321 AVCodec ff_truehd_decoder = {
1322  .name = "truehd",
1323  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1324  .type = AVMEDIA_TYPE_AUDIO,
1325  .id = AV_CODEC_ID_TRUEHD,
1326  .priv_data_size = sizeof(MLPDecodeContext),
1327  .init = mlp_decode_init,
1329  .capabilities = CODEC_CAP_DR1,
1330 };
1331 #endif /* CONFIG_TRUEHD_DECODER */