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