FFmpeg  2.1.1
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"
32 #include "libavutil/channel_layout.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 
41 /** number of bits used for VLC lookup - longest Huffman code is 9 */
42 #define VLC_BITS 9
43 
44 typedef struct SubStream {
45  /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
47 
48  //@{
49  /** restart header data */
50  /// The type of noise to be used in the rematrix stage.
51  uint16_t noise_type;
52 
53  /// The index of the first channel coded in this substream.
55  /// The index of the last channel coded in this substream.
57  /// The number of channels input into the rematrix stage.
59  /// For each channel output by the matrix, the output channel to map it to
61  /// The channel layout for this substream
62  uint64_t ch_layout;
63 
64  /// Channel coding parameters for channels in the substream
66 
67  /// The left shift applied to random noise in 0x31ea substreams.
69  /// The current seed value for the pseudorandom noise generator(s).
70  uint32_t noisegen_seed;
71 
72  /// Set if the substream contains extra info to check the size of VLC blocks.
74 
75  /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
77 #define PARAM_BLOCKSIZE (1 << 7)
78 #define PARAM_MATRIX (1 << 6)
79 #define PARAM_OUTSHIFT (1 << 5)
80 #define PARAM_QUANTSTEP (1 << 4)
81 #define PARAM_FIR (1 << 3)
82 #define PARAM_IIR (1 << 2)
83 #define PARAM_HUFFOFFSET (1 << 1)
84 #define PARAM_PRESENCE (1 << 0)
85  //@}
86 
87  //@{
88  /** matrix data */
89 
90  /// Number of matrices to be applied.
92 
93  /// matrix output channel
95 
96  /// Whether the LSBs of the matrix output are encoded in the bitstream.
98  /// Matrix coefficients, stored as 2.14 fixed point.
100  /// Left shift to apply to noise values in 0x31eb substreams.
102  //@}
103 
104  /// Left shift to apply to Huffman-decoded residuals.
106 
107  /// number of PCM samples in current audio block
108  uint16_t blocksize;
109  /// Number of PCM samples decoded so far in this frame.
110  uint16_t blockpos;
111 
112  /// Left shift to apply to decoded PCM values to get final 24-bit output.
114 
115  /// Running XOR of all output samples.
117 
118 } SubStream;
119 
120 typedef struct MLPDecodeContext {
122 
123  /// Current access unit being read has a major sync.
125 
126  /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
128 
129  /// Number of substreams contained within this stream.
131 
132  /// Index of the last substream to decode - further substreams are skipped.
134 
135  /// Stream needs channel reordering to comply with FFmpeg's channel order
137 
138  /// number of PCM samples contained in each frame
140  /// next power of two above the number of samples in each frame
142 
144 
147 
151 
154 
155 static const uint64_t thd_channel_order[] = {
157  AV_CH_FRONT_CENTER, // C
158  AV_CH_LOW_FREQUENCY, // LFE
163  AV_CH_BACK_CENTER, // Cs
164  AV_CH_TOP_CENTER, // Ts
167  AV_CH_TOP_FRONT_CENTER, // Cvh
168  AV_CH_LOW_FREQUENCY_2, // LFE2
169 };
170 
171 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
172  int index)
173 {
174  int i;
175 
176  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
177  return 0;
178 
179  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
180  if (channel_layout & thd_channel_order[i] && !index--)
181  return thd_channel_order[i];
182  return 0;
183 }
184 
185 static VLC huff_vlc[3];
186 
187 /** Initialize static data, constant between all invocations of the codec. */
188 
189 static av_cold void init_static(void)
190 {
191  if (!huff_vlc[0].bits) {
192  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
193  &ff_mlp_huffman_tables[0][0][1], 2, 1,
194  &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
195  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
196  &ff_mlp_huffman_tables[1][0][1], 2, 1,
197  &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
198  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
199  &ff_mlp_huffman_tables[2][0][1], 2, 1,
200  &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
201  }
202 
203  ff_mlp_init_crc();
204 }
205 
207  unsigned int substr, unsigned int ch)
208 {
209  SubStream *s = &m->substream[substr];
210  ChannelParams *cp = &s->channel_params[ch];
211  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
212  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
213  int32_t sign_huff_offset = cp->huff_offset;
214 
215  if (cp->codebook > 0)
216  sign_huff_offset -= 7 << lsb_bits;
217 
218  if (sign_shift >= 0)
219  sign_huff_offset -= 1 << sign_shift;
220 
221  return sign_huff_offset;
222 }
223 
224 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
225  * and plain LSBs. */
226 
228  unsigned int substr, unsigned int pos)
229 {
230  SubStream *s = &m->substream[substr];
231  unsigned int mat, channel;
232 
233  for (mat = 0; mat < s->num_primitive_matrices; mat++)
234  if (s->lsb_bypass[mat])
235  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
236 
237  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
238  ChannelParams *cp = &s->channel_params[channel];
239  int codebook = cp->codebook;
240  int quant_step_size = s->quant_step_size[channel];
241  int lsb_bits = cp->huff_lsbs - quant_step_size;
242  int result = 0;
243 
244  if (codebook > 0)
245  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
246  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
247 
248  if (result < 0)
249  return AVERROR_INVALIDDATA;
250 
251  if (lsb_bits > 0)
252  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
253 
254  result += cp->sign_huff_offset;
255  result <<= quant_step_size;
256 
257  m->sample_buffer[pos + s->blockpos][channel] = result;
258  }
259 
260  return 0;
261 }
262 
264 {
265  MLPDecodeContext *m = avctx->priv_data;
266  int substr;
267 
268  init_static();
269  m->avctx = avctx;
270  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
271  m->substream[substr].lossless_check_data = 0xffffffff;
272  ff_mlpdsp_init(&m->dsp);
273 
274  return 0;
275 }
276 
277 /** Read a major sync info header - contains high level information about
278  * the stream - sample rate, channel arrangement etc. Most of this
279  * information is not actually necessary for decoding, only for playback.
280  */
281 
283 {
285  int substr, ret;
286 
287  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
288  return ret;
289 
290  if (mh.group1_bits == 0) {
291  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
292  return AVERROR_INVALIDDATA;
293  }
294  if (mh.group2_bits > mh.group1_bits) {
296  "Channel group 2 cannot have more bits per sample than group 1.\n");
297  return AVERROR_INVALIDDATA;
298  }
299 
302  "Channel groups with differing sample rates are not currently supported.\n");
303  return AVERROR_INVALIDDATA;
304  }
305 
306  if (mh.group1_samplerate == 0) {
307  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
308  return AVERROR_INVALIDDATA;
309  }
312  "Sampling rate %d is greater than the supported maximum (%d).\n",
314  return AVERROR_INVALIDDATA;
315  }
316  if (mh.access_unit_size > MAX_BLOCKSIZE) {
318  "Block size %d is greater than the supported maximum (%d).\n",
320  return AVERROR_INVALIDDATA;
321  }
324  "Block size pow2 %d is greater than the supported maximum (%d).\n",
326  return AVERROR_INVALIDDATA;
327  }
328 
329  if (mh.num_substreams == 0)
330  return AVERROR_INVALIDDATA;
331  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
332  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
333  return AVERROR_INVALIDDATA;
334  }
335  if (mh.num_substreams > MAX_SUBSTREAMS) {
337  "%d substreams (more than the "
338  "maximum supported by the decoder)",
339  mh.num_substreams);
340  return AVERROR_PATCHWELCOME;
341  }
342 
345 
348 
351 
353  if (mh.group1_bits > 16)
355  else
357 
358  m->params_valid = 1;
359  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
360  m->substream[substr].restart_seen = 0;
361 
362  /* Set the layout for each substream. When there's more than one, the first
363  * substream is Stereo. Subsequent substreams' layouts are indicated in the
364  * major sync. */
365  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
366  if ((substr = (mh.num_substreams > 1)))
368  m->substream[substr].ch_layout = mh.channel_layout_mlp;
369  } else {
370  if ((substr = (mh.num_substreams > 1)))
372  if (mh.num_substreams > 2)
375  else
378 
379  if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
380  av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
381  m->max_decoded_substream = 0;
382  if (m->avctx->channels==2)
384  }
385  }
386 
387  m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
388 
389  return 0;
390 }
391 
392 /** Read a restart header from a block in a substream. This contains parameters
393  * required to decode the audio that do not change very often. Generally
394  * (always) present only in blocks following a major sync. */
395 
397  const uint8_t *buf, unsigned int substr)
398 {
399  SubStream *s = &m->substream[substr];
400  unsigned int ch;
401  int sync_word, tmp;
402  uint8_t checksum;
403  uint8_t lossless_check;
404  int start_count = get_bits_count(gbp);
405  int min_channel, max_channel, max_matrix_channel;
406  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
409 
410  sync_word = get_bits(gbp, 13);
411 
412  if (sync_word != 0x31ea >> 1) {
414  "restart header sync incorrect (got 0x%04x)\n", sync_word);
415  return AVERROR_INVALIDDATA;
416  }
417 
418  s->noise_type = get_bits1(gbp);
419 
420  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
421  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
422  return AVERROR_INVALIDDATA;
423  }
424 
425  skip_bits(gbp, 16); /* Output timestamp */
426 
427  min_channel = get_bits(gbp, 4);
428  max_channel = get_bits(gbp, 4);
429  max_matrix_channel = get_bits(gbp, 4);
430 
431  if (max_matrix_channel > std_max_matrix_channel) {
433  "Max matrix channel cannot be greater than %d.\n",
434  std_max_matrix_channel);
435  return AVERROR_INVALIDDATA;
436  }
437 
438  if (max_channel != max_matrix_channel) {
440  "Max channel must be equal max matrix channel.\n");
441  return AVERROR_INVALIDDATA;
442  }
443 
444  /* This should happen for TrueHD streams with >6 channels and MLP's noise
445  * type. It is not yet known if this is allowed. */
446  if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
448  "%d channels (more than the "
449  "maximum supported by the decoder)",
450  max_channel + 2);
451  return AVERROR_PATCHWELCOME;
452  }
453 
454  if (min_channel > max_channel) {
456  "Substream min channel cannot be greater than max channel.\n");
457  return AVERROR_INVALIDDATA;
458  }
459 
460  s->min_channel = min_channel;
461  s->max_channel = max_channel;
462  s->max_matrix_channel = max_matrix_channel;
463 
464 #if FF_API_REQUEST_CHANNELS
466  if (m->avctx->request_channels > 0 &&
467  m->avctx->request_channels <= s->max_channel + 1 &&
468  m->max_decoded_substream > substr) {
470  "Extracting %d-channel downmix from substream %d. "
471  "Further substreams will be skipped.\n",
472  s->max_channel + 1, substr);
473  m->max_decoded_substream = substr;
475  } else
476 #endif
477  if (m->avctx->request_channel_layout == s->ch_layout &&
478  m->max_decoded_substream > substr) {
480  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
481  "Further substreams will be skipped.\n",
482  s->max_channel + 1, s->ch_layout, substr);
483  m->max_decoded_substream = substr;
484  }
485 
486  s->noise_shift = get_bits(gbp, 4);
487  s->noisegen_seed = get_bits(gbp, 23);
488 
489  skip_bits(gbp, 19);
490 
491  s->data_check_present = get_bits1(gbp);
492  lossless_check = get_bits(gbp, 8);
493  if (substr == m->max_decoded_substream
494  && s->lossless_check_data != 0xffffffff) {
496  if (tmp != lossless_check)
498  "Lossless check failed - expected %02x, calculated %02x.\n",
499  lossless_check, tmp);
500  }
501 
502  skip_bits(gbp, 16);
503 
504  memset(s->ch_assign, 0, sizeof(s->ch_assign));
505 
506  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
507  int ch_assign = get_bits(gbp, 6);
508  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
509  uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
510  ch_assign);
512  channel);
513  }
514  if ((unsigned)ch_assign > s->max_matrix_channel) {
516  "Assignment of matrix channel %d to invalid output channel %d",
517  ch, ch_assign);
518  return AVERROR_PATCHWELCOME;
519  }
520  s->ch_assign[ch_assign] = ch;
521  }
522 
523  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
524 
525  if (checksum != get_bits(gbp, 8))
526  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
527 
528  /* Set default decoding parameters. */
529  s->param_presence_flags = 0xff;
530  s->num_primitive_matrices = 0;
531  s->blocksize = 8;
532  s->lossless_check_data = 0;
533 
534  memset(s->output_shift , 0, sizeof(s->output_shift ));
535  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
536 
537  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
538  ChannelParams *cp = &s->channel_params[ch];
539  cp->filter_params[FIR].order = 0;
540  cp->filter_params[IIR].order = 0;
541  cp->filter_params[FIR].shift = 0;
542  cp->filter_params[IIR].shift = 0;
543 
544  /* Default audio coding is 24-bit raw PCM. */
545  cp->huff_offset = 0;
546  cp->sign_huff_offset = (-1) << 23;
547  cp->codebook = 0;
548  cp->huff_lsbs = 24;
549  }
550 
551  if (substr == m->max_decoded_substream) {
552  m->avctx->channels = s->max_matrix_channel + 1;
553  m->avctx->channel_layout = s->ch_layout;
554 
555  if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
558  int i = s->ch_assign[4];
559  s->ch_assign[4] = s->ch_assign[3];
560  s->ch_assign[3] = s->ch_assign[2];
561  s->ch_assign[2] = i;
562  } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
563  FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
564  FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
565  }
566  }
567 
568  }
569 
570  return 0;
571 }
572 
573 /** Read parameters for one of the prediction filters. */
574 
576  unsigned int substr, unsigned int channel,
577  unsigned int filter)
578 {
579  SubStream *s = &m->substream[substr];
581  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
582  const char fchar = filter ? 'I' : 'F';
583  int i, order;
584 
585  // Filter is 0 for FIR, 1 for IIR.
586  av_assert0(filter < 2);
587 
588  if (m->filter_changed[channel][filter]++ > 1) {
589  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
590  return AVERROR_INVALIDDATA;
591  }
592 
593  order = get_bits(gbp, 4);
594  if (order > max_order) {
596  "%cIR filter order %d is greater than maximum %d.\n",
597  fchar, order, max_order);
598  return AVERROR_INVALIDDATA;
599  }
600  fp->order = order;
601 
602  if (order > 0) {
603  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
604  int coeff_bits, coeff_shift;
605 
606  fp->shift = get_bits(gbp, 4);
607 
608  coeff_bits = get_bits(gbp, 5);
609  coeff_shift = get_bits(gbp, 3);
610  if (coeff_bits < 1 || coeff_bits > 16) {
612  "%cIR filter coeff_bits must be between 1 and 16.\n",
613  fchar);
614  return AVERROR_INVALIDDATA;
615  }
616  if (coeff_bits + coeff_shift > 16) {
618  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
619  fchar);
620  return AVERROR_INVALIDDATA;
621  }
622 
623  for (i = 0; i < order; i++)
624  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
625 
626  if (get_bits1(gbp)) {
627  int state_bits, state_shift;
628 
629  if (filter == FIR) {
631  "FIR filter has state data specified.\n");
632  return AVERROR_INVALIDDATA;
633  }
634 
635  state_bits = get_bits(gbp, 4);
636  state_shift = get_bits(gbp, 4);
637 
638  /* TODO: Check validity of state data. */
639 
640  for (i = 0; i < order; i++)
641  fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
642  }
643  }
644 
645  return 0;
646 }
647 
648 /** Read parameters for primitive matrices. */
649 
650 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
651 {
652  SubStream *s = &m->substream[substr];
653  unsigned int mat, ch;
654  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
657 
658  if (m->matrix_changed++ > 1) {
659  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
660  return AVERROR_INVALIDDATA;
661  }
662 
663  s->num_primitive_matrices = get_bits(gbp, 4);
664 
665  if (s->num_primitive_matrices > max_primitive_matrices) {
667  "Number of primitive matrices cannot be greater than %d.\n",
668  max_primitive_matrices);
669  return AVERROR_INVALIDDATA;
670  }
671 
672  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
673  int frac_bits, max_chan;
674  s->matrix_out_ch[mat] = get_bits(gbp, 4);
675  frac_bits = get_bits(gbp, 4);
676  s->lsb_bypass [mat] = get_bits1(gbp);
677 
678  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
680  "Invalid channel %d specified as output from matrix.\n",
681  s->matrix_out_ch[mat]);
682  return AVERROR_INVALIDDATA;
683  }
684  if (frac_bits > 14) {
686  "Too many fractional bits specified.\n");
687  return AVERROR_INVALIDDATA;
688  }
689 
690  max_chan = s->max_matrix_channel;
691  if (!s->noise_type)
692  max_chan+=2;
693 
694  for (ch = 0; ch <= max_chan; ch++) {
695  int coeff_val = 0;
696  if (get_bits1(gbp))
697  coeff_val = get_sbits(gbp, frac_bits + 2);
698 
699  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
700  }
701 
702  if (s->noise_type)
703  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
704  else
705  s->matrix_noise_shift[mat] = 0;
706  }
707 
708  return 0;
709 }
710 
711 /** Read channel parameters. */
712 
713 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
714  GetBitContext *gbp, unsigned int ch)
715 {
716  SubStream *s = &m->substream[substr];
717  ChannelParams *cp = &s->channel_params[ch];
718  FilterParams *fir = &cp->filter_params[FIR];
719  FilterParams *iir = &cp->filter_params[IIR];
720  int ret;
721 
723  if (get_bits1(gbp))
724  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
725  return ret;
726 
728  if (get_bits1(gbp))
729  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
730  return ret;
731 
732  if (fir->order + iir->order > 8) {
733  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
734  return AVERROR_INVALIDDATA;
735  }
736 
737  if (fir->order && iir->order &&
738  fir->shift != iir->shift) {
740  "FIR and IIR filters must use the same precision.\n");
741  return AVERROR_INVALIDDATA;
742  }
743  /* The FIR and IIR filters must have the same precision.
744  * To simplify the filtering code, only the precision of the
745  * FIR filter is considered. If only the IIR filter is employed,
746  * the FIR filter precision is set to that of the IIR filter, so
747  * that the filtering code can use it. */
748  if (!fir->order && iir->order)
749  fir->shift = iir->shift;
750 
752  if (get_bits1(gbp))
753  cp->huff_offset = get_sbits(gbp, 15);
754 
755  cp->codebook = get_bits(gbp, 2);
756  cp->huff_lsbs = get_bits(gbp, 5);
757 
758  if (cp->huff_lsbs > 24) {
759  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
760  cp->huff_lsbs = 0;
761  return AVERROR_INVALIDDATA;
762  }
763 
764  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
765 
766  return 0;
767 }
768 
769 /** Read decoding parameters that change more often than those in the restart
770  * header. */
771 
773  unsigned int substr)
774 {
775  SubStream *s = &m->substream[substr];
776  unsigned int ch;
777  int ret;
778 
780  if (get_bits1(gbp))
781  s->param_presence_flags = get_bits(gbp, 8);
782 
784  if (get_bits1(gbp)) {
785  s->blocksize = get_bits(gbp, 9);
786  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
787  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
788  s->blocksize = 0;
789  return AVERROR_INVALIDDATA;
790  }
791  }
792 
794  if (get_bits1(gbp))
795  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
796  return ret;
797 
799  if (get_bits1(gbp))
800  for (ch = 0; ch <= s->max_matrix_channel; ch++)
801  s->output_shift[ch] = get_sbits(gbp, 4);
802 
804  if (get_bits1(gbp))
805  for (ch = 0; ch <= s->max_channel; ch++) {
806  ChannelParams *cp = &s->channel_params[ch];
807 
808  s->quant_step_size[ch] = get_bits(gbp, 4);
809 
810  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
811  }
812 
813  for (ch = s->min_channel; ch <= s->max_channel; ch++)
814  if (get_bits1(gbp))
815  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
816  return ret;
817 
818  return 0;
819 }
820 
821 #define MSB_MASK(bits) (-1u << bits)
822 
823 /** Generate PCM samples using the prediction filters and residual values
824  * read from the data stream, and update the filter state. */
825 
826 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
827  unsigned int channel)
828 {
829  SubStream *s = &m->substream[substr];
830  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
832  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
833  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
834  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
835  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
836  unsigned int filter_shift = fir->shift;
837  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
838 
839  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
840  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
841 
842  m->dsp.mlp_filter_channel(firbuf, fircoeff,
843  fir->order, iir->order,
844  filter_shift, mask, s->blocksize,
845  &m->sample_buffer[s->blockpos][channel]);
846 
847  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
848  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
849 }
850 
851 /** Read a block of PCM residual data (or actual if no filtering active). */
852 
854  unsigned int substr)
855 {
856  SubStream *s = &m->substream[substr];
857  unsigned int i, ch, expected_stream_pos = 0;
858  int ret;
859 
860  if (s->data_check_present) {
861  expected_stream_pos = get_bits_count(gbp);
862  expected_stream_pos += get_bits(gbp, 16);
864  "Substreams with VLC block size check info");
865  }
866 
867  if (s->blockpos + s->blocksize > m->access_unit_size) {
868  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
869  return AVERROR_INVALIDDATA;
870  }
871 
872  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
873  s->blocksize * sizeof(m->bypassed_lsbs[0]));
874 
875  for (i = 0; i < s->blocksize; i++)
876  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
877  return ret;
878 
879  for (ch = s->min_channel; ch <= s->max_channel; ch++)
880  filter_channel(m, substr, ch);
881 
882  s->blockpos += s->blocksize;
883 
884  if (s->data_check_present) {
885  if (get_bits_count(gbp) != expected_stream_pos)
886  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
887  skip_bits(gbp, 8);
888  }
889 
890  return 0;
891 }
892 
893 /** Data table used for TrueHD noise generation function. */
894 
895 static const int8_t noise_table[256] = {
896  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
897  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
898  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
899  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
900  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
901  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
902  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
903  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
904  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
905  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
906  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
907  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
908  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
909  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
910  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
911  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
912 };
913 
914 /** Noise generation functions.
915  * I'm not sure what these are for - they seem to be some kind of pseudorandom
916  * sequence generators, used to generate noise data which is used when the
917  * channels are rematrixed. I'm not sure if they provide a practical benefit
918  * to compression, or just obfuscate the decoder. Are they for some kind of
919  * dithering? */
920 
921 /** Generate two channels of noise, used in the matrix when
922  * restart sync word == 0x31ea. */
923 
924 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
925 {
926  SubStream *s = &m->substream[substr];
927  unsigned int i;
928  uint32_t seed = s->noisegen_seed;
929  unsigned int maxchan = s->max_matrix_channel;
930 
931  for (i = 0; i < s->blockpos; i++) {
932  uint16_t seed_shr7 = seed >> 7;
933  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
934  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
935 
936  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
937  }
938 
939  s->noisegen_seed = seed;
940 }
941 
942 /** Generate a block of noise, used when restart sync word == 0x31eb. */
943 
944 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
945 {
946  SubStream *s = &m->substream[substr];
947  unsigned int i;
948  uint32_t seed = s->noisegen_seed;
949 
950  for (i = 0; i < m->access_unit_size_pow2; i++) {
951  uint8_t seed_shr15 = seed >> 15;
952  m->noise_buffer[i] = noise_table[seed_shr15];
953  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
954  }
955 
956  s->noisegen_seed = seed;
957 }
958 
959 
960 /** Apply the channel matrices in turn to reconstruct the original audio
961  * samples. */
962 
963 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
964 {
965  SubStream *s = &m->substream[substr];
966  unsigned int mat, src_ch, i;
967  unsigned int maxchan;
968 
969  maxchan = s->max_matrix_channel;
970  if (!s->noise_type) {
971  generate_2_noise_channels(m, substr);
972  maxchan += 2;
973  } else {
974  fill_noise_buffer(m, substr);
975  }
976 
977  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
978  int matrix_noise_shift = s->matrix_noise_shift[mat];
979  unsigned int dest_ch = s->matrix_out_ch[mat];
980  int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
981  int32_t *coeffs = s->matrix_coeff[mat];
982  int index = s->num_primitive_matrices - mat;
983  int index2 = 2 * index + 1;
984 
985  /* TODO: DSPContext? */
986 
987  for (i = 0; i < s->blockpos; i++) {
988  int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
989  int32_t *samples = m->sample_buffer[i];
990  int64_t accum = 0;
991 
992  for (src_ch = 0; src_ch <= maxchan; src_ch++)
993  accum += (int64_t) samples[src_ch] * coeffs[src_ch];
994 
995  if (matrix_noise_shift) {
996  index &= m->access_unit_size_pow2 - 1;
997  accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
998  index += index2;
999  }
1000 
1001  samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1002  }
1003  }
1004 }
1005 
1006 /** Write the audio data into the output buffer. */
1007 
1008 static int output_data(MLPDecodeContext *m, unsigned int substr,
1009  AVFrame *frame, int *got_frame_ptr)
1010 {
1011  AVCodecContext *avctx = m->avctx;
1012  SubStream *s = &m->substream[substr];
1013  unsigned int i, out_ch = 0;
1014  int32_t *data_32;
1015  int16_t *data_16;
1016  int ret;
1017  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1018 
1019  if (m->avctx->channels != s->max_matrix_channel + 1) {
1020  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1021  return AVERROR_INVALIDDATA;
1022  }
1023 
1024  if (!s->blockpos) {
1025  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1026  return AVERROR_INVALIDDATA;
1027  }
1028 
1029  /* get output buffer */
1030  frame->nb_samples = s->blockpos;
1031  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1032  return ret;
1033  data_32 = (int32_t *)frame->data[0];
1034  data_16 = (int16_t *)frame->data[0];
1035 
1036  for (i = 0; i < s->blockpos; i++) {
1037  for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1038  int mat_ch = s->ch_assign[out_ch];
1039  int32_t sample = m->sample_buffer[i][mat_ch]
1040  << s->output_shift[mat_ch];
1041  s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1042  if (is32) *data_32++ = sample << 8;
1043  else *data_16++ = sample >> 8;
1044  }
1045  }
1046 
1047  *got_frame_ptr = 1;
1048 
1049  return 0;
1050 }
1051 
1052 /** Read an access unit from the stream.
1053  * @return negative on error, 0 if not enough data is present in the input stream,
1054  * otherwise the number of bytes consumed. */
1055 
1056 static int read_access_unit(AVCodecContext *avctx, void* data,
1057  int *got_frame_ptr, AVPacket *avpkt)
1058 {
1059  const uint8_t *buf = avpkt->data;
1060  int buf_size = avpkt->size;
1061  MLPDecodeContext *m = avctx->priv_data;
1062  GetBitContext gb;
1063  unsigned int length, substr;
1064  unsigned int substream_start;
1065  unsigned int header_size = 4;
1066  unsigned int substr_header_size = 0;
1067  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1068  uint16_t substream_data_len[MAX_SUBSTREAMS];
1069  uint8_t parity_bits;
1070  int ret;
1071 
1072  if (buf_size < 4)
1073  return AVERROR_INVALIDDATA;
1074 
1075  length = (AV_RB16(buf) & 0xfff) * 2;
1076 
1077  if (length < 4 || length > buf_size)
1078  return AVERROR_INVALIDDATA;
1079 
1080  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1081 
1082  m->is_major_sync_unit = 0;
1083  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1084  if (read_major_sync(m, &gb) < 0)
1085  goto error;
1086  m->is_major_sync_unit = 1;
1087  header_size += 28;
1088  }
1089 
1090  if (!m->params_valid) {
1092  "Stream parameters not seen; skipping frame.\n");
1093  *got_frame_ptr = 0;
1094  return length;
1095  }
1096 
1097  substream_start = 0;
1098 
1099  for (substr = 0; substr < m->num_substreams; substr++) {
1100  int extraword_present, checkdata_present, end, nonrestart_substr;
1101 
1102  extraword_present = get_bits1(&gb);
1103  nonrestart_substr = get_bits1(&gb);
1104  checkdata_present = get_bits1(&gb);
1105  skip_bits1(&gb);
1106 
1107  end = get_bits(&gb, 12) * 2;
1108 
1109  substr_header_size += 2;
1110 
1111  if (extraword_present) {
1112  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1113  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1114  goto error;
1115  }
1116  skip_bits(&gb, 16);
1117  substr_header_size += 2;
1118  }
1119 
1120  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1121  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1122  goto error;
1123  }
1124 
1125  if (end + header_size + substr_header_size > length) {
1127  "Indicated length of substream %d data goes off end of "
1128  "packet.\n", substr);
1129  end = length - header_size - substr_header_size;
1130  }
1131 
1132  if (end < substream_start) {
1133  av_log(avctx, AV_LOG_ERROR,
1134  "Indicated end offset of substream %d data "
1135  "is smaller than calculated start offset.\n",
1136  substr);
1137  goto error;
1138  }
1139 
1140  if (substr > m->max_decoded_substream)
1141  continue;
1142 
1143  substream_parity_present[substr] = checkdata_present;
1144  substream_data_len[substr] = end - substream_start;
1145  substream_start = end;
1146  }
1147 
1148  parity_bits = ff_mlp_calculate_parity(buf, 4);
1149  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1150 
1151  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1152  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1153  goto error;
1154  }
1155 
1156  buf += header_size + substr_header_size;
1157 
1158  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1159  SubStream *s = &m->substream[substr];
1160  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1161 
1162  m->matrix_changed = 0;
1163  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1164 
1165  s->blockpos = 0;
1166  do {
1167  if (get_bits1(&gb)) {
1168  if (get_bits1(&gb)) {
1169  /* A restart header should be present. */
1170  if (read_restart_header(m, &gb, buf, substr) < 0)
1171  goto next_substr;
1172  s->restart_seen = 1;
1173  }
1174 
1175  if (!s->restart_seen)
1176  goto next_substr;
1177  if (read_decoding_params(m, &gb, substr) < 0)
1178  goto next_substr;
1179  }
1180 
1181  if (!s->restart_seen)
1182  goto next_substr;
1183 
1184  if ((ret = read_block_data(m, &gb, substr)) < 0)
1185  return ret;
1186 
1187  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1188  goto substream_length_mismatch;
1189 
1190  } while (!get_bits1(&gb));
1191 
1192  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1193 
1194  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1195  int shorten_by;
1196 
1197  if (get_bits(&gb, 16) != 0xD234)
1198  return AVERROR_INVALIDDATA;
1199 
1200  shorten_by = get_bits(&gb, 16);
1201  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1202  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1203  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1204  return AVERROR_INVALIDDATA;
1205 
1206  if (substr == m->max_decoded_substream)
1207  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1208  }
1209 
1210  if (substream_parity_present[substr]) {
1211  uint8_t parity, checksum;
1212 
1213  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1214  goto substream_length_mismatch;
1215 
1216  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1217  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1218 
1219  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1220  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1221  if ( get_bits(&gb, 8) != checksum)
1222  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1223  }
1224 
1225  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1226  goto substream_length_mismatch;
1227 
1228 next_substr:
1229  if (!s->restart_seen)
1231  "No restart header present in substream %d.\n", substr);
1232 
1233  buf += substream_data_len[substr];
1234  }
1235 
1237 
1238  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1239  return ret;
1240 
1241  return length;
1242 
1243 substream_length_mismatch:
1244  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1245  return AVERROR_INVALIDDATA;
1246 
1247 error:
1248  m->params_valid = 0;
1249  return AVERROR_INVALIDDATA;
1250 }
1251 
1252 #if CONFIG_MLP_DECODER
1253 AVCodec ff_mlp_decoder = {
1254  .name = "mlp",
1255  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1256  .type = AVMEDIA_TYPE_AUDIO,
1257  .id = AV_CODEC_ID_MLP,
1258  .priv_data_size = sizeof(MLPDecodeContext),
1259  .init = mlp_decode_init,
1261  .capabilities = CODEC_CAP_DR1,
1262 };
1263 #endif
1264 #if CONFIG_TRUEHD_DECODER
1265 AVCodec ff_truehd_decoder = {
1266  .name = "truehd",
1267  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1268  .type = AVMEDIA_TYPE_AUDIO,
1269  .id = AV_CODEC_ID_TRUEHD,
1270  .priv_data_size = sizeof(MLPDecodeContext),
1271  .init = mlp_decode_init,
1273  .capabilities = CODEC_CAP_DR1,
1274 };
1275 #endif /* CONFIG_TRUEHD_DECODER */
uint8_t shift
Right shift to apply to output of filter.
Definition: mlp.h:76
static const uint64_t thd_channel_order[]
Definition: mlpdec.c:155
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:378
static const int16_t coeffs[28]
const char * s
Definition: avisynth_c.h:668
#define MAX_IIR_ORDER
Definition: mlp.h:65
#define AVERROR_PATCHWELCOME
FilterParams filter_params[NUM_FILTERS]
Definition: mlp.h:83
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
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:772
#define AV_CH_TOP_FRONT_RIGHT
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
Definition: mlpdec.c:148
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
Definition: mlpdec.c:76
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
Definition: mlpdec.c:924
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible. ...
Definition: mlpdec.c:127
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
attribute_deprecated int request_channels
Decoder should decode to this many channels if it can (0 for default)
Definition: avcodec.h:1926
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static struct endianess table[]
#define AV_CH_TOP_FRONT_LEFT
int num_substreams
Number of substreams within stream.
Definition: mlp_parser.h:56
#define AV_CH_TOP_FRONT_CENTER
int size
Definition: avcodec.h:1064
#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
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
#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:46
int8_t output_shift[MAX_CHANNELS]
Left shift to apply to decoded PCM values to get final 24-bit output.
Definition: mlpdec.c:113
#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:2570
#define sample
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:240
int access_unit_size
Number of samples per coded frame.
Definition: mlp_parser.h:50
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
Definition: avfilter.c:965
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
Definition: mlpdec.c:99
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:83
#define PARAM_OUTSHIFT
Definition: mlpdec.c:79
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:145
#define AV_CH_WIDE_LEFT
#define AV_RB16(x)
Definition: intreadwrite.h:232
uint8_t bits
Definition: crc.c:260
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1881
uint8_t
MLPDSPContext dsp
Definition: mlpdec.c:152
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:471
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
Definition: mlp.h:120
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
#define MAX_FIR_ORDER
The maximum number of taps in IIR and FIR filters.
Definition: mlp.h:64
uint8_t ch_assign[MAX_CHANNELS]
For each channel output by the matrix, the output channel to map it to.
Definition: mlpdec.c:60
#define AV_CH_WIDE_RIGHT
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
#define AV_CH_LOW_FREQUENCY
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:742
const char data[16]
Definition: mxf.c:68
signed 32 bits
Definition: samplefmt.h:53
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:207
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
Definition: mlpdec.c:944
#define PARAM_FIR
Definition: mlpdec.c:81
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 restart_seen
Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
Definition: mlpdec.c:46
bitstream reader API header.
#define AV_CH_BACK_LEFT
int channel_arrangement
Definition: mlp_parser.h:42
uint8_t min_channel
The index of the first channel coded in this substream.
Definition: mlpdec.c:54
#define FFSWAP(type, a, b)
Definition: avcodec.h:928
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:575
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:396
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:650
#define PARAM_BLOCKSIZE
Definition: mlpdec.c:77
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:1056
int16_t huff_offset
Offset to apply to residual values.
Definition: mlp.h:86
signed 16 bits
Definition: samplefmt.h:52
static AVFrame * frame
Definition: demuxing.c:51
#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:56
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:99
#define MAX_MATRICES
Definition: mlp.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
ChannelParams channel_params[MAX_CHANNELS]
Channel coding parameters for channels in the substream.
Definition: mlpdec.c:65
#define MAX_MATRIX_CHANNEL_TRUEHD
Definition: mlp.h:31
static const uint16_t mask[17]
Definition: lzw.c:37
unsigned m
Definition: audioconvert.c:186
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout, int index)
Definition: mlpdec.c:171
uint8_t needs_reordering
Stream needs channel reordering to comply with FFmpeg&#39;s channel order.
Definition: mlpdec.c:136
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:149
uint8_t quant_step_size[MAX_CHANNELS]
Left shift to apply to Huffman-decoded residuals.
Definition: mlpdec.c:105
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: avcodec.h:4168
static VLC huff_vlc[3]
Definition: mlpdec.c:185
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define PARAM_MATRIX
Definition: mlpdec.c:78
#define AV_CH_LAYOUT_QUAD
#define PARAM_QUANTSTEP
Definition: mlpdec.c:80
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:130
Libavcodec external API header.
Definition: get_bits.h:63
uint8_t max_matrix_channel
The number of channels input into the rematrix stage.
Definition: mlpdec.c:58
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1934
#define MAX_BLOCKSIZE
Definition: diracdec.c:60
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:263
common internal API header
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:312
#define FF_ARRAY_ELEMS(a)
Definition: avcodec.h:929
#define AV_CH_TOP_CENTER
#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:80
uint16_t noise_type
restart header data
Definition: mlpdec.c:51
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:713
ret
Definition: avfilter.c:961
int32_t
int32_t lossless_check_data
Running XOR of all output samples.
Definition: mlpdec.c:116
#define FFMIN(a, b)
Definition: avcodec.h:925
MLP parser prototypes.
mcdeint parity
Definition: vf_mcdeint.c:276
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:550
#define AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_CENTER
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:146
uint8_t lsb_bypass[MAX_MATRICES]
Whether the LSBs of the matrix output are encoded in the bitstream.
Definition: mlpdec.c:97
int32_t coeff[NUM_FILTERS][MAX_FIR_ORDER]
Definition: mlp.h:84
#define AV_CH_LAYOUT_5POINT1_BACK
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:227
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:139
#define AV_CH_FRONT_RIGHT_OF_CENTER
static int32_t calculate_sign_huff(MLPDecodeContext *m, unsigned int substr, unsigned int ch)
Definition: mlpdec.c:206
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1893
#define AV_LOG_INFO
Standard information.
Definition: avcodec.h:4158
int access_unit_size_pow2
Next power of two above number of samples per frame.
Definition: mlp_parser.h:51
uint16_t blocksize
number of PCM samples in current audio block
Definition: mlpdec.c:108
uint8_t codebook
Which VLC codebook to use to read residuals.
Definition: mlp.h:88
#define MAX_MATRICES_TRUEHD
Definition: mlp.h:42
uint8_t data_check_present
Set if the substream contains extra info to check the size of VLC blocks.
Definition: mlpdec.c:73
int32_t state[MAX_FIR_ORDER]
Definition: mlp.h:78
enum AVCodecID codec_id
Definition: avcodec.h:1157
int sample_rate
samples per second
Definition: avcodec.h:1873
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
Definition: mlpdsp.c:60
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
Definition: mlpdec.c:42
SubStream substream[MAX_SUBSTREAMS]
Definition: mlpdec.c:143
uint8_t order
number of taps in filter
Definition: mlp.h:75
main external API structure.
Definition: avcodec.h:1146
#define AV_CH_FRONT_LEFT
int is_major_sync_unit
Current access unit being read has a major sync.
Definition: mlpdec.c:124
static unsigned int seed
Definition: videogen.c:78
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:941
#define fp
Definition: regdef.h:44
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:150
void * buf
Definition: avisynth_c.h:594
filter data
Definition: mlp.h:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:324
#define IIR
Definition: mlp.h:71
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
AVCodecContext * avctx
Definition: mlpdec.c:121
int index
Definition: gxfenc.c:89
uint64_t ch_layout
The channel layout for this substream.
Definition: mlpdec.c:62
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
Apply the channel matrices in turn to reconstruct the original audio samples.
Definition: mlpdec.c:963
uint8_t * data
Definition: avcodec.h:1063
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:853
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:405
uint8_t num_primitive_matrices
matrix data
Definition: mlpdec.c:91
#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:133
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:895
#define MAX_CHANNELS
Definition: aac.h:42
#define FIR
Definition: mlp.h:70
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:282
uint8_t huff_lsbs
Size of residual suffix not encoded using VLC.
Definition: mlp.h:89
void * priv_data
Definition: avcodec.h:1182
uint16_t blockpos
Number of PCM samples decoded so far in this frame.
Definition: mlpdec.c:110
int group2_bits
Bit depth of the second substream (MLP only)
Definition: mlp_parser.h:37
#define AV_CH_BACK_CENTER
#define AV_CH_SIDE_RIGHT
#define MSB_MASK(bits)
Definition: mlpdec.c:821
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:189
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:70
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:78
common internal api header.
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:94
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:141
uint64_t channel_layout_thd_stream1
Channel layout for substream 1 of TrueHD streams (&quot;6-channel presentation&quot;)
Definition: mlp_parser.h:47
#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 (&quot;8-channel presentation&quot;)
Definition: mlp_parser.h:48
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:128
uint8_t matrix_noise_shift[MAX_MATRICES]
Left shift to apply to noise values in 0x31eb substreams.
Definition: mlpdec.c:101
uint8_t noise_shift
The left shift applied to random noise in 0x31ea substreams.
Definition: mlpdec.c:68
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:1008
#define AVERROR_INVALIDDATA
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:79
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:826
sample data coding information
Definition: mlp.h:82
int channels
number of audio channels
Definition: avcodec.h:1874
int group1_bits
The bit depth of the first substream.
Definition: mlp_parser.h:36
av_cold void ff_mlp_init_crc(void)
Definition: mlp.c:54
#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:28
#define AV_CH_FRONT_RIGHT
#define PARAM_IIR
Definition: mlpdec.c:82
#define MAX_MATRICES_MLP
Maximum number of matrices used in decoding; most streams have one matrix per output channel...
Definition: mlp.h:41
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AV_CH_SIDE_LEFT
const char int length
Definition: avisynth_c.h:668
int group1_samplerate
Sample rate of first substream.
Definition: mlp_parser.h:39
#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:1941
#define PARAM_PRESENCE
Definition: mlpdec.c:84
This structure stores compressed data.
Definition: avcodec.h:1040
int group2_samplerate
Sample rate of second substream (MLP only)
Definition: mlp_parser.h:40
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:150
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
#define mh
#define AV_CH_BACK_RIGHT
int32_t sign_huff_offset
sign/rounding-corrected version of huff_offset
Definition: mlp.h:87
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:73