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