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