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 
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 */