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