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