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