FFmpeg
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 "libavutil/mem_internal.h"
34 #include "libavutil/thread.h"
35 #include "get_bits.h"
36 #include "internal.h"
37 #include "libavutil/crc.h"
38 #include "parser.h"
39 #include "mlp_parse.h"
40 #include "mlpdsp.h"
41 #include "mlp.h"
42 #include "config.h"
43 
44 /** number of bits used for VLC lookup - longest Huffman code is 9 */
45 #if ARCH_ARM
46 #define VLC_BITS 5
47 #define VLC_STATIC_SIZE 64
48 #else
49 #define VLC_BITS 9
50 #define VLC_STATIC_SIZE 512
51 #endif
52 
53 typedef struct SubStream {
54  /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
55  uint8_t restart_seen;
56  /// Set if end of stream is encountered
57  uint8_t end_of_stream;
58 
59  //@{
60  /** restart header data */
61  /// The type of noise to be used in the rematrix stage.
62  uint16_t noise_type;
63 
64  /// The index of the first channel coded in this substream.
65  uint8_t min_channel;
66  /// The index of the last channel coded in this substream.
67  uint8_t max_channel;
68  /// The number of channels input into the rematrix stage.
70  /// For each channel output by the matrix, the output channel to map it to
72  /// The channel layout for this substream
73  uint64_t mask;
74  /// The matrix encoding mode for this substream
77 
78  /// Channel coding parameters for channels in the substream
80 
81  /// The left shift applied to random noise in 0x31ea substreams.
82  uint8_t noise_shift;
83  /// The current seed value for the pseudorandom noise generator(s).
84  uint32_t noisegen_seed;
85 
86  /// Set if the substream contains extra info to check the size of VLC blocks.
88 
89  /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
91 #define PARAM_BLOCKSIZE (1 << 7)
92 #define PARAM_MATRIX (1 << 6)
93 #define PARAM_OUTSHIFT (1 << 5)
94 #define PARAM_QUANTSTEP (1 << 4)
95 #define PARAM_FIR (1 << 3)
96 #define PARAM_IIR (1 << 2)
97 #define PARAM_HUFFOFFSET (1 << 1)
98 #define PARAM_PRESENCE (1 << 0)
99  //@}
100 
101  //@{
102  /** matrix data */
103 
104  /// Number of matrices to be applied.
106 
107  /// matrix output channel
109 
110  /// Whether the LSBs of the matrix output are encoded in the bitstream.
112  /// Matrix coefficients, stored as 2.14 fixed point.
114  /// Left shift to apply to noise values in 0x31eb substreams.
116  //@}
117 
118  /// Left shift to apply to Huffman-decoded residuals.
120 
121  /// number of PCM samples in current audio block
122  uint16_t blocksize;
123  /// Number of PCM samples decoded so far in this frame.
124  uint16_t blockpos;
125 
126  /// Left shift to apply to decoded PCM values to get final 24-bit output.
128 
129  /// Running XOR of all output samples.
131 
132 } SubStream;
133 
134 typedef struct MLPDecodeContext {
136 
137  /// Current access unit being read has a major sync.
139 
140  /// Size of the major sync unit, in bytes
142 
143  /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
144  uint8_t params_valid;
145 
146  /// Number of substreams contained within this stream.
147  uint8_t num_substreams;
148 
149  /// Index of the last substream to decode - further substreams are skipped.
151 
152  /// Stream needs channel reordering to comply with FFmpeg's channel order
154 
155  /// number of PCM samples contained in each frame
157  /// next power of two above the number of samples in each frame
159 
161 
164 
168 
171 
172 static const uint64_t thd_channel_order[] = {
174  AV_CH_FRONT_CENTER, // C
175  AV_CH_LOW_FREQUENCY, // LFE
180  AV_CH_BACK_CENTER, // Cs
181  AV_CH_TOP_CENTER, // Ts
184  AV_CH_TOP_FRONT_CENTER, // Cvh
185  AV_CH_LOW_FREQUENCY_2, // LFE2
186 };
187 
188 static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
189 {
190  return channel_layout && ((channel_layout & mask) == channel_layout);
191 }
192 
193 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
194  int index)
195 {
196  int i;
197 
198  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
199  return 0;
200 
201  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
202  if (channel_layout & thd_channel_order[i] && !index--)
203  return thd_channel_order[i];
204  return 0;
205 }
206 
207 static VLC huff_vlc[3];
208 
209 /** Initialize static data, constant between all invocations of the codec. */
210 
211 static av_cold void init_static(void)
212 {
213  for (int i = 0; i < 3; i++) {
214  static VLC_TYPE vlc_buf[3 * VLC_STATIC_SIZE][2];
217  init_vlc(&huff_vlc[i], VLC_BITS, 18,
218  &ff_mlp_huffman_tables[i][0][1], 2, 1,
220  }
221 
222  ff_mlp_init_crc();
223 }
224 
226  unsigned int substr, unsigned int ch)
227 {
228  SubStream *s = &m->substream[substr];
229  ChannelParams *cp = &s->channel_params[ch];
230  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
231  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
232  int32_t sign_huff_offset = cp->huff_offset;
233 
234  if (cp->codebook > 0)
235  sign_huff_offset -= 7 << lsb_bits;
236 
237  if (sign_shift >= 0)
238  sign_huff_offset -= 1 << sign_shift;
239 
240  return sign_huff_offset;
241 }
242 
243 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
244  * and plain LSBs. */
245 
247  unsigned int substr, unsigned int pos)
248 {
249  SubStream *s = &m->substream[substr];
250  unsigned int mat, channel;
251 
252  for (mat = 0; mat < s->num_primitive_matrices; mat++)
253  if (s->lsb_bypass[mat])
254  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
255 
256  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
257  ChannelParams *cp = &s->channel_params[channel];
258  int codebook = cp->codebook;
259  int quant_step_size = s->quant_step_size[channel];
260  int lsb_bits = cp->huff_lsbs - quant_step_size;
261  int result = 0;
262 
263  if (codebook > 0)
265  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
266 
267  if (result < 0)
268  return AVERROR_INVALIDDATA;
269 
270  if (lsb_bits > 0)
271  result = (result << lsb_bits) + get_bits_long(gbp, lsb_bits);
272 
273  result += cp->sign_huff_offset;
274  result *= 1 << quant_step_size;
275 
276  m->sample_buffer[pos + s->blockpos][channel] = result;
277  }
278 
279  return 0;
280 }
281 
283 {
284  static AVOnce init_static_once = AV_ONCE_INIT;
285  MLPDecodeContext *m = avctx->priv_data;
286  int substr;
287 
288  m->avctx = avctx;
289  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
290  m->substream[substr].lossless_check_data = 0xffffffff;
291  ff_mlpdsp_init(&m->dsp);
292 
293  ff_thread_once(&init_static_once, init_static);
294 
295  return 0;
296 }
297 
298 /** Read a major sync info header - contains high level information about
299  * the stream - sample rate, channel arrangement etc. Most of this
300  * information is not actually necessary for decoding, only for playback.
301  */
302 
304 {
306  int substr, ret;
307 
308  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
309  return ret;
310 
311  if (mh.group1_bits == 0) {
312  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
313  return AVERROR_INVALIDDATA;
314  }
315  if (mh.group2_bits > mh.group1_bits) {
317  "Channel group 2 cannot have more bits per sample than group 1.\n");
318  return AVERROR_INVALIDDATA;
319  }
320 
321  if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
323  "Channel groups with differing sample rates are not currently supported.\n");
324  return AVERROR_INVALIDDATA;
325  }
326 
327  if (mh.group1_samplerate == 0) {
328  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
329  return AVERROR_INVALIDDATA;
330  }
331  if (mh.group1_samplerate > MAX_SAMPLERATE) {
333  "Sampling rate %d is greater than the supported maximum (%d).\n",
334  mh.group1_samplerate, MAX_SAMPLERATE);
335  return AVERROR_INVALIDDATA;
336  }
337  if (mh.access_unit_size > MAX_BLOCKSIZE) {
339  "Block size %d is greater than the supported maximum (%d).\n",
340  mh.access_unit_size, MAX_BLOCKSIZE);
341  return AVERROR_INVALIDDATA;
342  }
343  if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
345  "Block size pow2 %d is greater than the supported maximum (%d).\n",
346  mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
347  return AVERROR_INVALIDDATA;
348  }
349 
350  if (mh.num_substreams == 0)
351  return AVERROR_INVALIDDATA;
352  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
353  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
354  return AVERROR_INVALIDDATA;
355  }
356  if (mh.num_substreams > MAX_SUBSTREAMS) {
358  "%d substreams (more than the "
359  "maximum supported by the decoder)",
360  mh.num_substreams);
361  return AVERROR_PATCHWELCOME;
362  }
363 
364  m->major_sync_header_size = mh.header_size;
365 
366  m->access_unit_size = mh.access_unit_size;
367  m->access_unit_size_pow2 = mh.access_unit_size_pow2;
368 
369  m->num_substreams = mh.num_substreams;
370 
371  /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
373 
374  m->avctx->sample_rate = mh.group1_samplerate;
375  m->avctx->frame_size = mh.access_unit_size;
376 
377  m->avctx->bits_per_raw_sample = mh.group1_bits;
378  if (mh.group1_bits > 16)
380  else
386 
387  m->params_valid = 1;
388  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
389  m->substream[substr].restart_seen = 0;
390 
391  /* Set the layout for each substream. When there's more than one, the first
392  * substream is Stereo. Subsequent substreams' layouts are indicated in the
393  * major sync. */
394  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
395  if (mh.stream_type != SYNC_MLP) {
397  "unexpected stream_type %X in MLP",
398  mh.stream_type);
399  return AVERROR_PATCHWELCOME;
400  }
401  if ((substr = (mh.num_substreams > 1)))
403  m->substream[substr].mask = mh.channel_layout_mlp;
404  } else {
405  if (mh.stream_type != SYNC_TRUEHD) {
407  "unexpected stream_type %X in !MLP",
408  mh.stream_type);
409  return AVERROR_PATCHWELCOME;
410  }
411  if (mh.channel_modifier_thd_stream0 == THD_CH_MODIFIER_STEREO)
413  if ((substr = (mh.num_substreams > 1)))
415  if (mh.num_substreams > 2)
416  if (mh.channel_layout_thd_stream2)
417  m->substream[2].mask = mh.channel_layout_thd_stream2;
418  else
419  m->substream[2].mask = mh.channel_layout_thd_stream1;
420  if (m->avctx->channels > 2)
421  m->substream[mh.num_substreams > 1].mask = mh.channel_layout_thd_stream1;
422 
423  if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
424  av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
425  m->max_decoded_substream = 0;
426  if (m->avctx->channels==2)
428  }
429  }
430 
431  m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
432 
433  /* Parse the TrueHD decoder channel modifiers and set each substream's
434  * AVMatrixEncoding accordingly.
435  *
436  * The meaning of the modifiers depends on the channel layout:
437  *
438  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
439  *
440  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
441  *
442  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
443  * layouts with an Ls/Rs channel pair
444  */
445  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
448  if (mh.num_substreams > 2 &&
449  mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
450  mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
451  mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
453 
454  if (mh.num_substreams > 1 &&
455  mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
456  mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
457  mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
459 
460  if (mh.num_substreams > 0)
461  switch (mh.channel_modifier_thd_stream0) {
464  break;
467  break;
468  default:
469  break;
470  }
471  }
472 
473  return 0;
474 }
475 
476 /** Read a restart header from a block in a substream. This contains parameters
477  * required to decode the audio that do not change very often. Generally
478  * (always) present only in blocks following a major sync. */
479 
481  const uint8_t *buf, unsigned int substr)
482 {
483  SubStream *s = &m->substream[substr];
484  unsigned int ch;
485  int sync_word, tmp;
486  uint8_t checksum;
487  uint8_t lossless_check;
488  int start_count = get_bits_count(gbp);
489  int min_channel, max_channel, max_matrix_channel, noise_type;
490  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
493 
494  sync_word = get_bits(gbp, 13);
495 
496  if (sync_word != 0x31ea >> 1) {
498  "restart header sync incorrect (got 0x%04x)\n", sync_word);
499  return AVERROR_INVALIDDATA;
500  }
501 
502  noise_type = get_bits1(gbp);
503 
504  if (m->avctx->codec_id == AV_CODEC_ID_MLP && noise_type) {
505  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
506  return AVERROR_INVALIDDATA;
507  }
508 
509  skip_bits(gbp, 16); /* Output timestamp */
510 
511  min_channel = get_bits(gbp, 4);
512  max_channel = get_bits(gbp, 4);
513  max_matrix_channel = get_bits(gbp, 4);
514 
515  if (max_matrix_channel > std_max_matrix_channel) {
517  "Max matrix channel cannot be greater than %d.\n",
518  std_max_matrix_channel);
519  return AVERROR_INVALIDDATA;
520  }
521 
522  if (max_channel != max_matrix_channel) {
524  "Max channel must be equal max matrix channel.\n");
525  return AVERROR_INVALIDDATA;
526  }
527 
528  /* This should happen for TrueHD streams with >6 channels and MLP's noise
529  * type. It is not yet known if this is allowed. */
530  if (max_channel > MAX_MATRIX_CHANNEL_MLP && !noise_type) {
532  "%d channels (more than the "
533  "maximum supported by the decoder)",
534  max_channel + 2);
535  return AVERROR_PATCHWELCOME;
536  }
537 
538  if (min_channel > max_channel) {
540  "Substream min channel cannot be greater than max channel.\n");
541  return AVERROR_INVALIDDATA;
542  }
543 
544  s->min_channel = min_channel;
545  s->max_channel = max_channel;
546  s->max_matrix_channel = max_matrix_channel;
547  s->noise_type = noise_type;
548 
550  m->max_decoded_substream > substr) {
552  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
553  "Further substreams will be skipped.\n",
554  s->max_channel + 1, s->mask, 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) {
567  tmp = xor_32_to_8(s->lossless_check_data);
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) {
582  ch_assign);
583  ch_assign = av_get_channel_layout_channel_index(s->mask,
584  channel);
585  }
586  if (ch_assign < 0 || 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->mask;
626  m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
627  s->output_shift,
628  s->max_matrix_channel,
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];
656  FilterParams *fp = &s->channel_params[channel].filter_params[filter];
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) * (1 << 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) * (1 << 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  goto error;
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  goto error;
759  }
760  if (frac_bits > 14) {
762  "Too many fractional bits specified.\n");
763  goto error;
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 * (1 << (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 error:
786  s->num_primitive_matrices = 0;
787  memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
788 
789  return AVERROR_INVALIDDATA;
790 }
791 
792 /** Read channel parameters. */
793 
794 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
795  GetBitContext *gbp, unsigned int ch)
796 {
797  SubStream *s = &m->substream[substr];
798  ChannelParams *cp = &s->channel_params[ch];
799  FilterParams *fir = &cp->filter_params[FIR];
800  FilterParams *iir = &cp->filter_params[IIR];
801  int ret;
802 
803  if (s->param_presence_flags & PARAM_FIR)
804  if (get_bits1(gbp))
805  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
806  return ret;
807 
808  if (s->param_presence_flags & PARAM_IIR)
809  if (get_bits1(gbp))
810  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
811  return ret;
812 
813  if (fir->order + iir->order > 8) {
814  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
815  return AVERROR_INVALIDDATA;
816  }
817 
818  if (fir->order && iir->order &&
819  fir->shift != iir->shift) {
821  "FIR and IIR filters must use the same precision.\n");
822  return AVERROR_INVALIDDATA;
823  }
824  /* The FIR and IIR filters must have the same precision.
825  * To simplify the filtering code, only the precision of the
826  * FIR filter is considered. If only the IIR filter is employed,
827  * the FIR filter precision is set to that of the IIR filter, so
828  * that the filtering code can use it. */
829  if (!fir->order && iir->order)
830  fir->shift = iir->shift;
831 
832  if (s->param_presence_flags & PARAM_HUFFOFFSET)
833  if (get_bits1(gbp))
834  cp->huff_offset = get_sbits(gbp, 15);
835 
836  cp->codebook = get_bits(gbp, 2);
837  cp->huff_lsbs = get_bits(gbp, 5);
838 
839  if (cp->codebook > 0 && cp->huff_lsbs > 24) {
840  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
841  cp->huff_lsbs = 0;
842  return AVERROR_INVALIDDATA;
843  }
844 
845  return 0;
846 }
847 
848 /** Read decoding parameters that change more often than those in the restart
849  * header. */
850 
852  unsigned int substr)
853 {
854  SubStream *s = &m->substream[substr];
855  unsigned int ch;
856  int ret = 0;
857  unsigned recompute_sho = 0;
858 
859  if (s->param_presence_flags & PARAM_PRESENCE)
860  if (get_bits1(gbp))
861  s->param_presence_flags = get_bits(gbp, 8);
862 
863  if (s->param_presence_flags & PARAM_BLOCKSIZE)
864  if (get_bits1(gbp)) {
865  s->blocksize = get_bits(gbp, 9);
866  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
867  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
868  s->blocksize = 0;
869  return AVERROR_INVALIDDATA;
870  }
871  }
872 
873  if (s->param_presence_flags & PARAM_MATRIX)
874  if (get_bits1(gbp))
875  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
876  return ret;
877 
878  if (s->param_presence_flags & PARAM_OUTSHIFT)
879  if (get_bits1(gbp)) {
880  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
881  s->output_shift[ch] = get_sbits(gbp, 4);
882  if (s->output_shift[ch] < 0) {
883  avpriv_request_sample(m->avctx, "Negative output_shift");
884  s->output_shift[ch] = 0;
885  }
886  }
887  if (substr == m->max_decoded_substream)
888  m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
889  s->output_shift,
890  s->max_matrix_channel,
892  }
893 
894  if (s->param_presence_flags & PARAM_QUANTSTEP)
895  if (get_bits1(gbp))
896  for (ch = 0; ch <= s->max_channel; ch++) {
897  s->quant_step_size[ch] = get_bits(gbp, 4);
898 
899  recompute_sho |= 1<<ch;
900  }
901 
902  for (ch = s->min_channel; ch <= s->max_channel; ch++)
903  if (get_bits1(gbp)) {
904  recompute_sho |= 1<<ch;
905  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
906  goto fail;
907  }
908 
909 
910 fail:
911  for (ch = 0; ch <= s->max_channel; ch++) {
912  if (recompute_sho & (1<<ch)) {
913  ChannelParams *cp = &s->channel_params[ch];
914 
915  if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
916  if (ret >= 0) {
917  av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
919  }
920  s->quant_step_size[ch] = 0;
921  }
922 
923  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
924  }
925  }
926  return ret;
927 }
928 
929 #define MSB_MASK(bits) (-(1 << (bits)))
930 
931 /** Generate PCM samples using the prediction filters and residual values
932  * read from the data stream, and update the filter state. */
933 
934 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
935  unsigned int channel)
936 {
937  SubStream *s = &m->substream[substr];
938  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
940  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
941  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
942  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
943  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
944  unsigned int filter_shift = fir->shift;
945  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
946 
947  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
948  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
949 
950  m->dsp.mlp_filter_channel(firbuf, fircoeff,
951  fir->order, iir->order,
952  filter_shift, mask, s->blocksize,
953  &m->sample_buffer[s->blockpos][channel]);
954 
955  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
956  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
957 }
958 
959 /** Read a block of PCM residual data (or actual if no filtering active). */
960 
962  unsigned int substr)
963 {
964  SubStream *s = &m->substream[substr];
965  unsigned int i, ch, expected_stream_pos = 0;
966  int ret;
967 
968  if (s->data_check_present) {
969  expected_stream_pos = get_bits_count(gbp);
970  expected_stream_pos += get_bits(gbp, 16);
972  "Substreams with VLC block size check info");
973  }
974 
975  if (s->blockpos + s->blocksize > m->access_unit_size) {
976  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
977  return AVERROR_INVALIDDATA;
978  }
979 
980  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
981  s->blocksize * sizeof(m->bypassed_lsbs[0]));
982 
983  for (i = 0; i < s->blocksize; i++)
984  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
985  return ret;
986 
987  for (ch = s->min_channel; ch <= s->max_channel; ch++)
988  filter_channel(m, substr, ch);
989 
990  s->blockpos += s->blocksize;
991 
992  if (s->data_check_present) {
993  if (get_bits_count(gbp) != expected_stream_pos)
994  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
995  skip_bits(gbp, 8);
996  }
997 
998  return 0;
999 }
1000 
1001 /** Data table used for TrueHD noise generation function. */
1002 
1003 static const int8_t noise_table[256] = {
1004  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
1005  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
1006  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
1007  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
1008  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
1009  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
1010  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
1011  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
1012  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1013  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1014  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1015  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1016  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1017  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1018  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1019  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1020 };
1021 
1022 /** Noise generation functions.
1023  * I'm not sure what these are for - they seem to be some kind of pseudorandom
1024  * sequence generators, used to generate noise data which is used when the
1025  * channels are rematrixed. I'm not sure if they provide a practical benefit
1026  * to compression, or just obfuscate the decoder. Are they for some kind of
1027  * dithering? */
1028 
1029 /** Generate two channels of noise, used in the matrix when
1030  * restart sync word == 0x31ea. */
1031 
1032 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1033 {
1034  SubStream *s = &m->substream[substr];
1035  unsigned int i;
1036  uint32_t seed = s->noisegen_seed;
1037  unsigned int maxchan = s->max_matrix_channel;
1038 
1039  for (i = 0; i < s->blockpos; i++) {
1040  uint16_t seed_shr7 = seed >> 7;
1041  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1042  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1043 
1044  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1045  }
1046 
1047  s->noisegen_seed = seed;
1048 }
1049 
1050 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1051 
1052 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1053 {
1054  SubStream *s = &m->substream[substr];
1055  unsigned int i;
1056  uint32_t seed = s->noisegen_seed;
1057 
1058  for (i = 0; i < m->access_unit_size_pow2; i++) {
1059  uint8_t seed_shr15 = seed >> 15;
1060  m->noise_buffer[i] = noise_table[seed_shr15];
1061  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1062  }
1063 
1064  s->noisegen_seed = seed;
1065 }
1066 
1067 /** Write the audio data into the output buffer. */
1068 
1069 static int output_data(MLPDecodeContext *m, unsigned int substr,
1070  AVFrame *frame, int *got_frame_ptr)
1071 {
1072  AVCodecContext *avctx = m->avctx;
1073  SubStream *s = &m->substream[substr];
1074  unsigned int mat;
1075  unsigned int maxchan;
1076  int ret;
1077  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1078 
1079  if (m->avctx->channels != s->max_matrix_channel + 1) {
1080  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1081  return AVERROR_INVALIDDATA;
1082  }
1083 
1084  if (!s->blockpos) {
1085  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1086  return AVERROR_INVALIDDATA;
1087  }
1088 
1089  maxchan = s->max_matrix_channel;
1090  if (!s->noise_type) {
1091  generate_2_noise_channels(m, substr);
1092  maxchan += 2;
1093  } else {
1094  fill_noise_buffer(m, substr);
1095  }
1096 
1097  /* Apply the channel matrices in turn to reconstruct the original audio
1098  * samples. */
1099  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1100  unsigned int dest_ch = s->matrix_out_ch[mat];
1101  m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1102  s->matrix_coeff[mat],
1103  &m->bypassed_lsbs[0][mat],
1104  m->noise_buffer,
1105  s->num_primitive_matrices - mat,
1106  dest_ch,
1107  s->blockpos,
1108  maxchan,
1109  s->matrix_noise_shift[mat],
1111  MSB_MASK(s->quant_step_size[dest_ch]));
1112  }
1113 
1114  /* get output buffer */
1115  frame->nb_samples = s->blockpos;
1116  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1117  return ret;
1118  s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1119  s->blockpos,
1120  m->sample_buffer,
1121  frame->data[0],
1122  s->ch_assign,
1123  s->output_shift,
1124  s->max_matrix_channel,
1125  is32);
1126 
1127  /* Update matrix encoding side data */
1128  if (s->matrix_encoding != s->prev_matrix_encoding) {
1129  if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1130  return ret;
1131 
1132  s->prev_matrix_encoding = s->matrix_encoding;
1133  }
1134 
1135  *got_frame_ptr = 1;
1136 
1137  return 0;
1138 }
1139 
1140 /** Read an access unit from the stream.
1141  * @return negative on error, 0 if not enough data is present in the input stream,
1142  * otherwise the number of bytes consumed. */
1143 
1144 static int read_access_unit(AVCodecContext *avctx, void* data,
1145  int *got_frame_ptr, AVPacket *avpkt)
1146 {
1147  const uint8_t *buf = avpkt->data;
1148  int buf_size = avpkt->size;
1149  MLPDecodeContext *m = avctx->priv_data;
1150  GetBitContext gb;
1151  unsigned int length, substr;
1152  unsigned int substream_start;
1153  unsigned int header_size = 4;
1154  unsigned int substr_header_size = 0;
1155  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1156  uint16_t substream_data_len[MAX_SUBSTREAMS];
1157  uint8_t parity_bits;
1158  int ret;
1159 
1160  if (buf_size < 4)
1161  return AVERROR_INVALIDDATA;
1162 
1163  length = (AV_RB16(buf) & 0xfff) * 2;
1164 
1165  if (length < 4 || length > buf_size)
1166  return AVERROR_INVALIDDATA;
1167 
1168  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1169 
1170  m->is_major_sync_unit = 0;
1171  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1172  if (read_major_sync(m, &gb) < 0)
1173  goto error;
1174  m->is_major_sync_unit = 1;
1175  header_size += m->major_sync_header_size;
1176  }
1177 
1178  if (!m->params_valid) {
1180  "Stream parameters not seen; skipping frame.\n");
1181  *got_frame_ptr = 0;
1182  return length;
1183  }
1184 
1185  substream_start = 0;
1186 
1187  for (substr = 0; substr < m->num_substreams; substr++) {
1188  int extraword_present, checkdata_present, end, nonrestart_substr;
1189 
1190  extraword_present = get_bits1(&gb);
1191  nonrestart_substr = get_bits1(&gb);
1192  checkdata_present = get_bits1(&gb);
1193  skip_bits1(&gb);
1194 
1195  end = get_bits(&gb, 12) * 2;
1196 
1197  substr_header_size += 2;
1198 
1199  if (extraword_present) {
1200  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1201  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1202  goto error;
1203  }
1204  skip_bits(&gb, 16);
1205  substr_header_size += 2;
1206  }
1207 
1208  if (length < header_size + substr_header_size) {
1209  av_log(m->avctx, AV_LOG_ERROR, "Insufficient data for headers\n");
1210  goto error;
1211  }
1212 
1213  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1214  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1215  goto error;
1216  }
1217 
1218  if (end + header_size + substr_header_size > length) {
1220  "Indicated length of substream %d data goes off end of "
1221  "packet.\n", substr);
1222  end = length - header_size - substr_header_size;
1223  }
1224 
1225  if (end < substream_start) {
1226  av_log(avctx, AV_LOG_ERROR,
1227  "Indicated end offset of substream %d data "
1228  "is smaller than calculated start offset.\n",
1229  substr);
1230  goto error;
1231  }
1232 
1233  if (substr > m->max_decoded_substream)
1234  continue;
1235 
1236  substream_parity_present[substr] = checkdata_present;
1237  substream_data_len[substr] = end - substream_start;
1238  substream_start = end;
1239  }
1240 
1241  parity_bits = ff_mlp_calculate_parity(buf, 4);
1242  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1243 
1244  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1245  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1246  goto error;
1247  }
1248 
1249  buf += header_size + substr_header_size;
1250 
1251  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1252  SubStream *s = &m->substream[substr];
1253 
1254  if (substr != m->max_decoded_substream &&
1256  m->substream[m->max_decoded_substream].max_channel == avctx->channels - 1)
1257  goto skip_substr;
1258 
1259  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1260 
1261  m->matrix_changed = 0;
1262  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1263 
1264  s->blockpos = 0;
1265  do {
1266  if (get_bits1(&gb)) {
1267  if (get_bits1(&gb)) {
1268  /* A restart header should be present. */
1269  if (read_restart_header(m, &gb, buf, substr) < 0)
1270  goto next_substr;
1271  s->restart_seen = 1;
1272  }
1273 
1274  if (!s->restart_seen)
1275  goto next_substr;
1276  if (read_decoding_params(m, &gb, substr) < 0)
1277  goto next_substr;
1278  }
1279 
1280  if (!s->restart_seen)
1281  goto next_substr;
1282 
1283  if ((ret = read_block_data(m, &gb, substr)) < 0)
1284  return ret;
1285 
1286  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1287  goto substream_length_mismatch;
1288 
1289  } while (!get_bits1(&gb));
1290 
1291  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1292 
1293  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1294  int shorten_by;
1295 
1296  if (get_bits(&gb, 16) != 0xD234)
1297  return AVERROR_INVALIDDATA;
1298 
1299  shorten_by = get_bits(&gb, 16);
1300  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1301  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1302  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1303  return AVERROR_INVALIDDATA;
1304 
1305  av_log(m->avctx, AV_LOG_DEBUG, "End of stream indicated.\n");
1306  s->end_of_stream = 1;
1307  }
1308 
1309  if (substream_parity_present[substr]) {
1310  uint8_t parity, checksum;
1311 
1312  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1313  goto substream_length_mismatch;
1314 
1315  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1316  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1317 
1318  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1319  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1320  if ( get_bits(&gb, 8) != checksum)
1321  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1322  }
1323 
1324  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1325  goto substream_length_mismatch;
1326 
1327 next_substr:
1328  if (!s->restart_seen)
1330  "No restart header present in substream %d.\n", substr);
1331 
1332 skip_substr:
1333  buf += substream_data_len[substr];
1334  }
1335 
1336  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1337  return ret;
1338 
1339  for (substr = 0; substr <= m->max_decoded_substream; substr++){
1340  SubStream *s = &m->substream[substr];
1341 
1342  if (s->end_of_stream) {
1343  s->lossless_check_data = 0xffffffff;
1344  s->end_of_stream = 0;
1345  m->params_valid = 0;
1346  }
1347  }
1348 
1349  return length;
1350 
1351 substream_length_mismatch:
1352  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1353  return AVERROR_INVALIDDATA;
1354 
1355 error:
1356  m->params_valid = 0;
1357  return AVERROR_INVALIDDATA;
1358 }
1359 
1361 {
1362  MLPDecodeContext *m = avctx->priv_data;
1363 
1364  m->params_valid = 0;
1365  for (int substr = 0; substr <= m->max_decoded_substream; substr++){
1366  SubStream *s = &m->substream[substr];
1367 
1368  s->lossless_check_data = 0xffffffff;
1369  s->prev_matrix_encoding = 0;
1370  }
1371 }
1372 
1373 #if CONFIG_MLP_DECODER
1374 const AVCodec ff_mlp_decoder = {
1375  .name = "mlp",
1376  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1377  .type = AVMEDIA_TYPE_AUDIO,
1378  .id = AV_CODEC_ID_MLP,
1379  .priv_data_size = sizeof(MLPDecodeContext),
1380  .init = mlp_decode_init,
1383  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1384  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1385 };
1386 #endif
1387 #if CONFIG_TRUEHD_DECODER
1388 const AVCodec ff_truehd_decoder = {
1389  .name = "truehd",
1390  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1391  .type = AVMEDIA_TYPE_AUDIO,
1392  .id = AV_CODEC_ID_TRUEHD,
1393  .priv_data_size = sizeof(MLPDecodeContext),
1394  .init = mlp_decode_init,
1397  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1398  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1399 };
1400 #endif /* CONFIG_TRUEHD_DECODER */
MLPDecodeContext::params_valid
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible.
Definition: mlpdec.c:144
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1012
PARAM_QUANTSTEP
#define PARAM_QUANTSTEP
Definition: mlpdec.c:94
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
noise_table
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:1003
AV_CH_LAYOUT_5POINT0_BACK
#define AV_CH_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:102
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:603
ChannelParams::codebook
uint8_t codebook
Which VLC codebook to use to read residuals.
Definition: mlp.h:92
PARAM_IIR
#define PARAM_IIR
Definition: mlpdec.c:96
xor_32_to_8
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
Definition: mlp.h:161
SubStream::matrix_coeff
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
Definition: mlpdec.c:113
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
mem_internal.h
SubStream::prev_matrix_encoding
enum AVMatrixEncoding prev_matrix_encoding
Definition: mlpdec.c:76
AV_CH_TOP_FRONT_CENTER
#define AV_CH_TOP_FRONT_CENTER
Definition: channel_layout.h:62
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
AV_CH_LOW_FREQUENCY_2
#define AV_CH_LOW_FREQUENCY_2
Definition: channel_layout.h:73
thd_channel_order
static const uint64_t thd_channel_order[]
Definition: mlpdec.c:172
thread.h
SubStream::end_of_stream
uint8_t end_of_stream
Set if end of stream is encountered.
Definition: mlpdec.c:57
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
SubStream::output_shift
int8_t output_shift[MAX_CHANNELS]
Left shift to apply to decoded PCM values to get final 24-bit output.
Definition: mlpdec.c:127
THD_CH_MODIFIER_SURROUNDEX
@ THD_CH_MODIFIER_SURROUNDEX
Definition: mlp.h:175
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
read_decoding_params
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr)
Read decoding parameters that change more often than those in the restart header.
Definition: mlpdec.c:851
MAX_SAMPLERATE
#define MAX_SAMPLERATE
maximum sample frequency seen in files
Definition: mlp.h:54
AV_CH_TOP_FRONT_RIGHT
#define AV_CH_TOP_FRONT_RIGHT
Definition: channel_layout.h:63
init_static
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:211
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:167
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
ff_mlp_calculate_parity
uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size)
XOR together all the bytes of a buffer.
Definition: mlp.c:124
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
mh
#define mh
Definition: vf_colormatrix.c:107
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:143
filter_channel
static void filter_channel(MLPDecodeContext *m, unsigned int substr, unsigned int channel)
Generate PCM samples using the prediction filters and residual values read from the data stream,...
Definition: mlpdec.c:934
SubStream::restart_seen
uint8_t restart_seen
Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
Definition: mlpdec.c:55
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:798
output_data
static int output_data(MLPDecodeContext *m, unsigned int substr, AVFrame *frame, int *got_frame_ptr)
Write the audio data into the output buffer.
Definition: mlpdec.c:1069
SubStream::mask
uint64_t mask
The channel layout for this substream.
Definition: mlpdec.c:73
SubStream::min_channel
uint8_t min_channel
The index of the first channel coded in this substream.
Definition: mlpdec.c:65
AV_CH_TOP_FRONT_LEFT
#define AV_CH_TOP_FRONT_LEFT
Definition: channel_layout.h:61
MLPDecodeContext::major_sync_header_size
int major_sync_header_size
Size of the major sync unit, in bytes.
Definition: mlpdec.c:141
SubStream
Definition: mlpdec.c:53
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVCodecContext::request_channel_layout
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1050
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:467
AV_CH_WIDE_LEFT
#define AV_CH_WIDE_LEFT
Definition: channel_layout.h:69
ff_mlpdsp_init
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
Definition: mlpdsp.c:128
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
SubStream::max_channel
uint8_t max_channel
The index of the last channel coded in this substream.
Definition: mlpdec.c:67
SubStream::ch_assign
uint8_t ch_assign[MAX_CHANNELS]
For each channel output by the matrix, the output channel to map it to.
Definition: mlpdec.c:71
AV_CH_SURROUND_DIRECT_RIGHT
#define AV_CH_SURROUND_DIRECT_RIGHT
Definition: channel_layout.h:72
AV_CH_WIDE_RIGHT
#define AV_CH_WIDE_RIGHT
Definition: channel_layout.h:70
MLPDSPContext::mlp_pack_output
int32_t(* mlp_pack_output)(int32_t lossless_check_data, uint16_t blockpos, int32_t(*sample_buffer)[MAX_CHANNELS], void *data, uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32)
Definition: mlpdsp.h:69
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
ChannelParams::filter_params
FilterParams filter_params[NUM_FILTERS]
Definition: mlp.h:87
ff_mlp_checksum8
uint8_t ff_mlp_checksum8(const uint8_t *buf, unsigned int buf_size)
MLP uses checksums that seem to be based on the standard CRC algorithm, but are not (in implementatio...
Definition: mlp.c:98
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
fail
#define fail()
Definition: checkasm.h:127
MAX_MATRICES
#define MAX_MATRICES
Definition: mlp.h:44
ChannelParams::huff_lsbs
uint8_t huff_lsbs
Size of residual suffix not encoded using VLC.
Definition: mlp.h:93
GetBitContext
Definition: get_bits.h:62
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:53
MAX_IIR_ORDER
#define MAX_IIR_ORDER
Definition: mlp.h:66
SYNC_TRUEHD
#define SYNC_TRUEHD
Definition: mlp.h:28
calculate_sign_huff
static int32_t calculate_sign_huff(MLPDecodeContext *m, unsigned int substr, unsigned int ch)
Definition: mlpdec.c:225
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
AV_CH_LAYOUT_QUAD
#define AV_CH_LAYOUT_QUAD
Definition: channel_layout.h:99
MAX_MATRICES_MLP
#define MAX_MATRICES_MLP
Maximum number of matrices used in decoding; most streams have one matrix per output channel,...
Definition: mlp.h:42
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
MLPDecodeContext::needs_reordering
uint8_t needs_reordering
Stream needs channel reordering to comply with FFmpeg's channel order.
Definition: mlpdec.c:153
FIR
#define FIR
Definition: mlp.h:71
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_MATRIX_ENCODING_DOLBY
@ AV_MATRIX_ENCODING_DOLBY
Definition: channel_layout.h:122
MLPDecodeContext::dsp
MLPDSPContext dsp
Definition: mlpdec.c:169
SubStream::channel_params
ChannelParams channel_params[MAX_CHANNELS]
Channel coding parameters for channels in the substream.
Definition: mlpdec.c:79
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:52
mask
static const uint16_t mask[17]
Definition: lzw.c:38
PARAM_MATRIX
#define PARAM_MATRIX
Definition: mlpdec.c:92
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
PARAM_FIR
#define PARAM_FIR
Definition: mlpdec.c:95
MLPDecodeContext::matrix_changed
int matrix_changed
Definition: mlpdec.c:162
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
MLPDSPContext::mlp_filter_channel
void(* mlp_filter_channel)(int32_t *state, const int32_t *coeff, int firorder, int iirorder, unsigned int filter_shift, int32_t mask, int blocksize, int32_t *sample_buffer)
Definition: mlpdsp.h:50
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:360
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
THD_CH_MODIFIER_LTRT
@ THD_CH_MODIFIER_LTRT
Definition: mlp.h:171
MLPDSPContext::mlp_select_pack_output
int32_t(*(* mlp_select_pack_output)(uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32))(int32_t
Definition: mlpdsp.h:65
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
if
if(ret)
Definition: filter_design.txt:179
AVMatrixEncoding
AVMatrixEncoding
Definition: channel_layout.h:120
AV_MATRIX_ENCODING_DOLBYHEADPHONE
@ AV_MATRIX_ENCODING_DOLBYHEADPHONE
Definition: channel_layout.h:127
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
AV_CH_TOP_CENTER
#define AV_CH_TOP_CENTER
Definition: channel_layout.h:60
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
thd_channel_layout_extract_channel
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout, int index)
Definition: mlpdec.c:193
SubStream::lossless_check_data
int32_t lossless_check_data
Running XOR of all output samples.
Definition: mlpdec.c:130
MLPDecodeContext::bypassed_lsbs
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:166
SubStream::quant_step_size
uint8_t quant_step_size[MAX_CHANNELS]
Left shift to apply to Huffman-decoded residuals.
Definition: mlpdec.c:119
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
quant_step_size
static const float quant_step_size[]
Definition: hca_data.h:125
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
MLPDecodeContext::filter_changed
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:163
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:51
fp
#define fp
Definition: regdef.h:44
seed
static unsigned int seed
Definition: videogen.c:78
AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:55
AVOnce
#define AVOnce
Definition: thread.h:172
MLPDecodeContext::access_unit_size
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:156
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
SubStream::max_matrix_channel
uint8_t max_matrix_channel
The number of channels input into the rematrix stage.
Definition: mlpdec.c:69
THD_CH_MODIFIER_LBINRBIN
@ THD_CH_MODIFIER_LBINRBIN
Definition: mlp.h:172
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
FilterParams
filter data
Definition: mlp.h:75
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
MLPDecodeContext::sample_buffer
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:167
huff_vlc
static VLC huff_vlc[3]
Definition: mlpdec.c:207
ff_mlp_restart_checksum
uint8_t ff_mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size)
Calculate an 8-bit checksum over a restart header – a non-multiple-of-8 number of bits,...
Definition: mlp.c:105
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1649
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
MAX_MATRIX_CHANNEL_MLP
#define MAX_MATRIX_CHANNEL_MLP
Last possible matrix channel for each codec.
Definition: mlp.h:31
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
SubStream::noise_type
uint16_t noise_type
restart header data
Definition: mlpdec.c:62
MLPDecodeContext::num_substreams
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:147
MLPDecodeContext::avctx
AVCodecContext * avctx
Definition: mlpdec.c:135
MLPDecodeContext::substream
SubStream substream[MAX_SUBSTREAMS]
Definition: mlpdec.c:160
MSB_MASK
#define MSB_MASK(bits)
Definition: mlpdec.c:929
AV_MATRIX_ENCODING_NONE
@ AV_MATRIX_ENCODING_NONE
Definition: channel_layout.h:121
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
mlpdsp.h
MAX_SUBSTREAMS
#define MAX_SUBSTREAMS
Maximum number of substreams that can be decoded.
Definition: mlp.h:49
MLPDecodeContext::is_major_sync_unit
int is_major_sync_unit
Current access unit being read has a major sync.
Definition: mlpdec.c:138
MAX_MATRIX_CHANNEL_TRUEHD
#define MAX_MATRIX_CHANNEL_TRUEHD
Definition: mlp.h:32
mlp_decode_init
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:282
ff_mlp_decoder
const AVCodec ff_mlp_decoder
parity
mcdeint parity
Definition: vf_mcdeint.c:266
MAX_MATRICES_TRUEHD
#define MAX_MATRICES_TRUEHD
Definition: mlp.h:43
NUM_FILTERS
#define NUM_FILTERS
number of allowed filters
Definition: mlp.h:62
FilterParams::order
uint8_t order
number of taps in filter
Definition: mlp.h:76
MLPDecodeContext
Definition: mlpdec.c:134
ff_mlp_read_major_sync
int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
Read a major sync info header - contains high level information about the stream - sample rate,...
Definition: mlp_parse.c:86
AV_CH_LAYOUT_5POINT1_BACK
#define AV_CH_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:103
ChannelParams::huff_offset
int16_t huff_offset
Offset to apply to residual values.
Definition: mlp.h:90
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
AV_CH_FRONT_RIGHT_OF_CENTER
#define AV_CH_FRONT_RIGHT_OF_CENTER
Definition: channel_layout.h:56
SubStream::noisegen_seed
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:84
MLPDecodeContext::max_decoded_substream
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
Definition: mlpdec.c:150
SubStream::lsb_bypass
uint8_t lsb_bypass[MAX_MATRICES]
Whether the LSBs of the matrix output are encoded in the bitstream.
Definition: mlpdec.c:111
SubStream::matrix_out_ch
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:108
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:48
MAX_FIR_ORDER
#define MAX_FIR_ORDER
The maximum number of taps in IIR and FIR filters.
Definition: mlp.h:65
MLPDSPContext::mlp_rematrix_channel
void(* mlp_rematrix_channel)(int32_t *samples, const int32_t *coeffs, const uint8_t *bypassed_lsbs, const int8_t *noise_buffer, int index, unsigned int dest_ch, uint16_t blockpos, unsigned int maxchan, int matrix_noise_shift, int access_unit_size_pow2, int32_t mask)
Definition: mlpdsp.h:54
mlp_channel_layout_subset
static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
Definition: mlpdec.c:188
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
read_restart_header
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, const uint8_t *buf, unsigned int substr)
Read a restart header from a block in a substream.
Definition: mlpdec.c:480
mlp_parse.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
SubStream::blockpos
uint16_t blockpos
Number of PCM samples decoded so far in this frame.
Definition: mlpdec.c:124
SubStream::noise_shift
uint8_t noise_shift
The left shift applied to random noise in 0x31ea substreams.
Definition: mlpdec.c:82
SubStream::blocksize
uint16_t blocksize
number of PCM samples in current audio block
Definition: mlpdec.c:122
internal.h
av_get_channel_layout_channel_index
int av_get_channel_layout_channel_index(uint64_t channel_layout, uint64_t channel)
Get the index of a channel in channel_layout.
Definition: channel_layout.c:239
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:57
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
MLPHeaderInfo
Definition: mlp_parse.h:30
AV_CH_FRONT_LEFT
#define AV_CH_FRONT_LEFT
Definition: channel_layout.h:49
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
read_channel_params
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:794
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
parser.h
ChannelParams
sample data coding information
Definition: mlp.h:86
AV_CH_SIDE_RIGHT
#define AV_CH_SIDE_RIGHT
Definition: channel_layout.h:59
MAX_BLOCKSIZE
#define MAX_BLOCKSIZE
Definition: diracdec.c:55
fill_noise_buffer
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
Definition: mlpdec.c:1052
ff_mlp_init_crc
av_cold void ff_mlp_init_crc(void)
Definition: mlp.c:83
ChannelParams::sign_huff_offset
int32_t sign_huff_offset
sign/rounding-corrected version of huff_offset
Definition: mlp.h:91
MLPDecodeContext::access_unit_size_pow2
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:158
avcodec.h
PARAM_HUFFOFFSET
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:97
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
mlp_decode_flush
static void mlp_decode_flush(AVCodecContext *avctx)
Definition: mlpdec.c:1360
SubStream::num_primitive_matrices
uint8_t num_primitive_matrices
matrix data
Definition: mlpdec.c:105
pos
unsigned int pos
Definition: spdifenc.c:412
checksum
static volatile int checksum
Definition: adler32.c:30
FilterParams::state
int32_t state[MAX_FIR_ORDER]
Definition: mlp.h:79
SYNC_MLP
#define SYNC_MLP
Definition: mlp.h:27
PARAM_PRESENCE
#define PARAM_PRESENCE
Definition: mlpdec.c:98
SubStream::data_check_present
uint8_t data_check_present
Set if the substream contains extra info to check the size of VLC blocks.
Definition: mlpdec.c:87
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
SubStream::matrix_noise_shift
uint8_t matrix_noise_shift[MAX_MATRICES]
Left shift to apply to noise values in 0x31eb substreams.
Definition: mlpdec.c:115
AVCodecContext
main external API structure.
Definition: avcodec.h:383
PARAM_OUTSHIFT
#define PARAM_OUTSHIFT
Definition: mlpdec.c:93
ff_truehd_decoder
const AVCodec ff_truehd_decoder
VLC_BITS
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
Definition: mlpdec.c:49
PARAM_BLOCKSIZE
#define PARAM_BLOCKSIZE
Definition: mlpdec.c:91
THD_CH_MODIFIER_STEREO
@ THD_CH_MODIFIER_STEREO
Definition: mlp.h:170
channel_layout.h
read_access_unit
static int read_access_unit(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Read an access unit from the stream.
Definition: mlpdec.c:1144
VLC_STATIC_SIZE
#define VLC_STATIC_SIZE
Definition: mlpdec.c:50
AV_MATRIX_ENCODING_DOLBYEX
@ AV_MATRIX_ENCODING_DOLBYEX
Definition: channel_layout.h:126
VLC
Definition: vlc.h:26
IIR
#define IIR
Definition: mlp.h:72
AV_CH_SURROUND_DIRECT_LEFT
#define AV_CH_SURROUND_DIRECT_LEFT
Definition: channel_layout.h:71
AV_CH_FRONT_RIGHT
#define AV_CH_FRONT_RIGHT
Definition: channel_layout.h:50
ff_side_data_update_matrix_encoding
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:116
read_filter_params
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int channel, unsigned int filter)
Read parameters for one of the prediction filters.
Definition: mlpdec.c:651
read_huff_channels
static int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int pos)
Read a sample, consisting of either, both or neither of entropy-coded MSBs and plain LSBs.
Definition: mlpdec.c:246
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
read_major_sync
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
Read a major sync info header - contains high level information about the stream - sample rate,...
Definition: mlpdec.c:303
mlp.h
ff_mlp_huffman_tables
const uint8_t ff_mlp_huffman_tables[3][18][2]
Tables defining the Huffman codes.
Definition: mlp.c:30
SubStream::param_presence_flags
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
Definition: mlpdec.c:90
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
read_matrix_params
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:726
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:54
MLPDSPContext
Definition: mlpdsp.h:49
FilterParams::shift
uint8_t shift
Right shift to apply to output of filter.
Definition: mlp.h:77
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
generate_2_noise_channels
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
Definition: mlpdec.c:1032
SubStream::matrix_encoding
enum AVMatrixEncoding matrix_encoding
The matrix encoding mode for this substream.
Definition: mlpdec.c:75
channel
channel
Definition: ebur128.h:39
MAX_BLOCKSIZE_POW2
#define MAX_BLOCKSIZE_POW2
next power of two greater than MAX_BLOCKSIZE
Definition: mlp.h:59
MLPDecodeContext::noise_buffer
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
Definition: mlpdec.c:165
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:452
AV_CH_SIDE_LEFT
#define AV_CH_SIDE_LEFT
Definition: channel_layout.h:58
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
read_block_data
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr)
Read a block of PCM residual data (or actual if no filtering active).
Definition: mlpdec.c:961