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