Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
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 
42 #define VLC_BITS 9
43 
44 typedef struct SubStream {
47 
49 
50 
51  uint16_t noise_type;
52 
62  uint64_t ch_layout;
65 
68 
72  uint32_t noisegen_seed;
73 
76 
79 #define PARAM_BLOCKSIZE (1 << 7)
80 #define PARAM_MATRIX (1 << 6)
81 #define PARAM_OUTSHIFT (1 << 5)
82 #define PARAM_QUANTSTEP (1 << 4)
83 #define PARAM_FIR (1 << 3)
84 #define PARAM_IIR (1 << 2)
85 #define PARAM_HUFFOFFSET (1 << 1)
86 #define PARAM_PRESENCE (1 << 0)
87 
88 
90 
92 
94 
97 
105 
108 
110  uint16_t blocksize;
112  uint16_t blockpos;
113 
116 
119 
120 } SubStream;
121 
122 typedef struct MLPDecodeContext {
124 
127 
130 
133 
136 
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 
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 
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 
282 {
283  MLPHeaderInfo mh;
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 
379  /* Parse the TrueHD decoder channel modifiers and set each substream's
380  * AVMatrixEncoding accordingly.
381  *
382  * The meaning of the modifiers depends on the channel layout:
383  *
384  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
385  *
386  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
387  *
388  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
389  * layouts with an Ls/Rs channel pair
390  */
391  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
394  if (mh.num_substreams > 2 &&
399 
400  if (mh.num_substreams > 1 &&
405 
406  if (mh.num_substreams > 0)
407  switch (mh.channel_modifier_thd_stream0) {
410  break;
413  break;
414  default:
415  break;
416  }
417  }
418 
419  return 0;
420 }
421 
427  const uint8_t *buf, unsigned int substr)
428 {
429  SubStream *s = &m->substream[substr];
430  unsigned int ch;
431  int sync_word, tmp;
432  uint8_t checksum;
433  uint8_t lossless_check;
434  int start_count = get_bits_count(gbp);
435  int min_channel, max_channel, max_matrix_channel;
436  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
439 
440  sync_word = get_bits(gbp, 13);
441 
442  if (sync_word != 0x31ea >> 1) {
444  "restart header sync incorrect (got 0x%04x)\n", sync_word);
445  return AVERROR_INVALIDDATA;
446  }
447 
448  s->noise_type = get_bits1(gbp);
449 
450  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
451  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
452  return AVERROR_INVALIDDATA;
453  }
454 
455  skip_bits(gbp, 16); /* Output timestamp */
456 
457  min_channel = get_bits(gbp, 4);
458  max_channel = get_bits(gbp, 4);
459  max_matrix_channel = get_bits(gbp, 4);
460 
461  if (max_matrix_channel > std_max_matrix_channel) {
463  "Max matrix channel cannot be greater than %d.\n",
464  max_matrix_channel);
465  return AVERROR_INVALIDDATA;
466  }
467 
468  if (max_channel != max_matrix_channel) {
470  "Max channel must be equal max matrix channel.\n");
471  return AVERROR_INVALIDDATA;
472  }
473 
474  /* This should happen for TrueHD streams with >6 channels and MLP's noise
475  * type. It is not yet known if this is allowed. */
478  "%d channels (more than the "
479  "maximum supported by the decoder)",
480  s->max_channel + 2);
481  return AVERROR_PATCHWELCOME;
482  }
483 
484  if (min_channel > max_channel) {
486  "Substream min channel cannot be greater than max channel.\n");
487  return AVERROR_INVALIDDATA;
488  }
489 
490  s->min_channel = min_channel;
491  s->max_channel = max_channel;
492  s->max_matrix_channel = max_matrix_channel;
493 
494 #if FF_API_REQUEST_CHANNELS
496  if (m->avctx->request_channels > 0 &&
497  m->avctx->request_channels <= s->max_channel + 1 &&
498  m->max_decoded_substream > substr) {
500  "Extracting %d-channel downmix from substream %d. "
501  "Further substreams will be skipped.\n",
502  s->max_channel + 1, substr);
503  m->max_decoded_substream = substr;
504  } else
506 #endif
510  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
511  "Further substreams will be skipped.\n",
512  s->max_channel + 1, s->ch_layout, substr);
513  m->max_decoded_substream = substr;
514  }
515 
516  s->noise_shift = get_bits(gbp, 4);
517  s->noisegen_seed = get_bits(gbp, 23);
518 
519  skip_bits(gbp, 19);
520 
521  s->data_check_present = get_bits1(gbp);
522  lossless_check = get_bits(gbp, 8);
523  if (substr == m->max_decoded_substream
524  && s->lossless_check_data != 0xffffffff) {
526  if (tmp != lossless_check)
528  "Lossless check failed - expected %02x, calculated %02x.\n",
529  lossless_check, tmp);
530  }
531 
532  skip_bits(gbp, 16);
533 
534  memset(s->ch_assign, 0, sizeof(s->ch_assign));
535 
536  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
537  int ch_assign = get_bits(gbp, 6);
538  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
539  uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
540  ch_assign);
542  channel);
543  }
544  if (ch_assign > s->max_matrix_channel) {
546  "Assignment of matrix channel %d to invalid output channel %d",
547  ch, ch_assign);
548  return AVERROR_PATCHWELCOME;
549  }
550  s->ch_assign[ch_assign] = ch;
551  }
552 
553  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
554 
555  if (checksum != get_bits(gbp, 8))
556  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
557 
558  /* Set default decoding parameters. */
559  s->param_presence_flags = 0xff;
560  s->num_primitive_matrices = 0;
561  s->blocksize = 8;
562  s->lossless_check_data = 0;
563 
564  memset(s->output_shift , 0, sizeof(s->output_shift ));
565  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
566 
567  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
568  ChannelParams *cp = &s->channel_params[ch];
569  cp->filter_params[FIR].order = 0;
570  cp->filter_params[IIR].order = 0;
571  cp->filter_params[FIR].shift = 0;
572  cp->filter_params[IIR].shift = 0;
573 
574  /* Default audio coding is 24-bit raw PCM. */
575  cp->huff_offset = 0;
576  cp->sign_huff_offset = (-1) << 23;
577  cp->codebook = 0;
578  cp->huff_lsbs = 24;
579  }
580 
581  if (substr == m->max_decoded_substream) {
582  m->avctx->channels = s->max_matrix_channel + 1;
583  m->avctx->channel_layout = s->ch_layout;
584  }
585 
586  return 0;
587 }
588 
592  unsigned int substr, unsigned int channel,
593  unsigned int filter)
594 {
595  SubStream *s = &m->substream[substr];
596  FilterParams *fp = &s->channel_params[channel].filter_params[filter];
597  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
598  const char fchar = filter ? 'I' : 'F';
599  int i, order;
600 
601  // Filter is 0 for FIR, 1 for IIR.
602  assert(filter < 2);
603 
604  if (m->filter_changed[channel][filter]++ > 1) {
605  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
606  return AVERROR_INVALIDDATA;
607  }
608 
609  order = get_bits(gbp, 4);
610  if (order > max_order) {
612  "%cIR filter order %d is greater than maximum %d.\n",
613  fchar, order, max_order);
614  return AVERROR_INVALIDDATA;
615  }
616  fp->order = order;
617 
618  if (order > 0) {
619  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
620  int coeff_bits, coeff_shift;
621 
622  fp->shift = get_bits(gbp, 4);
623 
624  coeff_bits = get_bits(gbp, 5);
625  coeff_shift = get_bits(gbp, 3);
626  if (coeff_bits < 1 || coeff_bits > 16) {
628  "%cIR filter coeff_bits must be between 1 and 16.\n",
629  fchar);
630  return AVERROR_INVALIDDATA;
631  }
632  if (coeff_bits + coeff_shift > 16) {
634  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
635  fchar);
636  return AVERROR_INVALIDDATA;
637  }
638 
639  for (i = 0; i < order; i++)
640  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
641 
642  if (get_bits1(gbp)) {
643  int state_bits, state_shift;
644 
645  if (filter == FIR) {
647  "FIR filter has state data specified.\n");
648  return AVERROR_INVALIDDATA;
649  }
650 
651  state_bits = get_bits(gbp, 4);
652  state_shift = get_bits(gbp, 4);
653 
654  /* TODO: Check validity of state data. */
655 
656  for (i = 0; i < order; i++)
657  fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
658  }
659  }
660 
661  return 0;
662 }
663 
666 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
667 {
668  SubStream *s = &m->substream[substr];
669  unsigned int mat, ch;
670  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
673 
674  if (m->matrix_changed++ > 1) {
675  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
676  return AVERROR_INVALIDDATA;
677  }
678 
679  s->num_primitive_matrices = get_bits(gbp, 4);
680 
681  if (s->num_primitive_matrices > max_primitive_matrices) {
683  "Number of primitive matrices cannot be greater than %d.\n",
684  max_primitive_matrices);
685  return AVERROR_INVALIDDATA;
686  }
687 
688  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
689  int frac_bits, max_chan;
690  s->matrix_out_ch[mat] = get_bits(gbp, 4);
691  frac_bits = get_bits(gbp, 4);
692  s->lsb_bypass [mat] = get_bits1(gbp);
693 
694  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
696  "Invalid channel %d specified as output from matrix.\n",
697  s->matrix_out_ch[mat]);
698  return AVERROR_INVALIDDATA;
699  }
700  if (frac_bits > 14) {
702  "Too many fractional bits specified.\n");
703  return AVERROR_INVALIDDATA;
704  }
705 
706  max_chan = s->max_matrix_channel;
707  if (!s->noise_type)
708  max_chan+=2;
709 
710  for (ch = 0; ch <= max_chan; ch++) {
711  int coeff_val = 0;
712  if (get_bits1(gbp))
713  coeff_val = get_sbits(gbp, frac_bits + 2);
714 
715  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
716  }
717 
718  if (s->noise_type)
719  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
720  else
721  s->matrix_noise_shift[mat] = 0;
722  }
723 
724  return 0;
725 }
726 
729 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
730  GetBitContext *gbp, unsigned int ch)
731 {
732  SubStream *s = &m->substream[substr];
733  ChannelParams *cp = &s->channel_params[ch];
734  FilterParams *fir = &cp->filter_params[FIR];
735  FilterParams *iir = &cp->filter_params[IIR];
736  int ret;
737 
739  if (get_bits1(gbp))
740  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
741  return ret;
742 
744  if (get_bits1(gbp))
745  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
746  return ret;
747 
748  if (fir->order + iir->order > 8) {
749  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
750  return AVERROR_INVALIDDATA;
751  }
752 
753  if (fir->order && iir->order &&
754  fir->shift != iir->shift) {
756  "FIR and IIR filters must use the same precision.\n");
757  return AVERROR_INVALIDDATA;
758  }
759  /* The FIR and IIR filters must have the same precision.
760  * To simplify the filtering code, only the precision of the
761  * FIR filter is considered. If only the IIR filter is employed,
762  * the FIR filter precision is set to that of the IIR filter, so
763  * that the filtering code can use it. */
764  if (!fir->order && iir->order)
765  fir->shift = iir->shift;
766 
768  if (get_bits1(gbp))
769  cp->huff_offset = get_sbits(gbp, 15);
770 
771  cp->codebook = get_bits(gbp, 2);
772  cp->huff_lsbs = get_bits(gbp, 5);
773 
774  if (cp->huff_lsbs > 24) {
775  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
776  return AVERROR_INVALIDDATA;
777  }
778 
779  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
780 
781  return 0;
782 }
783 
788  unsigned int substr)
789 {
790  SubStream *s = &m->substream[substr];
791  unsigned int ch;
792  int ret;
793 
795  if (get_bits1(gbp))
796  s->param_presence_flags = get_bits(gbp, 8);
797 
799  if (get_bits1(gbp)) {
800  s->blocksize = get_bits(gbp, 9);
801  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
802  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
803  s->blocksize = 0;
804  return AVERROR_INVALIDDATA;
805  }
806  }
807 
809  if (get_bits1(gbp))
810  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
811  return ret;
812 
814  if (get_bits1(gbp))
815  for (ch = 0; ch <= s->max_matrix_channel; ch++)
816  s->output_shift[ch] = get_sbits(gbp, 4);
817 
819  if (get_bits1(gbp))
820  for (ch = 0; ch <= s->max_channel; ch++) {
821  ChannelParams *cp = &s->channel_params[ch];
822 
823  s->quant_step_size[ch] = get_bits(gbp, 4);
824 
825  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
826  }
827 
828  for (ch = s->min_channel; ch <= s->max_channel; ch++)
829  if (get_bits1(gbp))
830  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
831  return ret;
832 
833  return 0;
834 }
835 
836 #define MSB_MASK(bits) (-1u << bits)
837 
841 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
842  unsigned int channel)
843 {
844  SubStream *s = &m->substream[substr];
845  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
847  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
848  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
849  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
850  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
851  unsigned int filter_shift = fir->shift;
852  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
853 
854  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
855  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
856 
857  m->dsp.mlp_filter_channel(firbuf, fircoeff,
858  fir->order, iir->order,
859  filter_shift, mask, s->blocksize,
860  &m->sample_buffer[s->blockpos][channel]);
861 
862  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
863  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
864 }
865 
869  unsigned int substr)
870 {
871  SubStream *s = &m->substream[substr];
872  unsigned int i, ch, expected_stream_pos = 0;
873  int ret;
874 
875  if (s->data_check_present) {
876  expected_stream_pos = get_bits_count(gbp);
877  expected_stream_pos += get_bits(gbp, 16);
879  "Substreams with VLC block size check info");
880  }
881 
882  if (s->blockpos + s->blocksize > m->access_unit_size) {
883  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
884  return AVERROR_INVALIDDATA;
885  }
886 
887  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
888  s->blocksize * sizeof(m->bypassed_lsbs[0]));
889 
890  for (i = 0; i < s->blocksize; i++)
891  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
892  return ret;
893 
894  for (ch = s->min_channel; ch <= s->max_channel; ch++)
895  filter_channel(m, substr, ch);
896 
897  s->blockpos += s->blocksize;
898 
899  if (s->data_check_present) {
900  if (get_bits_count(gbp) != expected_stream_pos)
901  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
902  skip_bits(gbp, 8);
903  }
904 
905  return 0;
906 }
907 
910 static const int8_t noise_table[256] = {
911  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
912  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
913  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
914  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
915  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
916  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
917  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
918  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
919  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
920  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
921  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
922  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
923  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
924  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
925  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
926  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
927 };
928 
939 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
940 {
941  SubStream *s = &m->substream[substr];
942  unsigned int i;
943  uint32_t seed = s->noisegen_seed;
944  unsigned int maxchan = s->max_matrix_channel;
945 
946  for (i = 0; i < s->blockpos; i++) {
947  uint16_t seed_shr7 = seed >> 7;
948  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
949  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
950 
951  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
952  }
953 
954  s->noisegen_seed = seed;
955 }
956 
959 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
960 {
961  SubStream *s = &m->substream[substr];
962  unsigned int i;
963  uint32_t seed = s->noisegen_seed;
964 
965  for (i = 0; i < m->access_unit_size_pow2; i++) {
966  uint8_t seed_shr15 = seed >> 15;
967  m->noise_buffer[i] = noise_table[seed_shr15];
968  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
969  }
970 
971  s->noisegen_seed = seed;
972 }
973 
974 
978 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
979 {
980  SubStream *s = &m->substream[substr];
981  unsigned int mat, src_ch, i;
982  unsigned int maxchan;
983 
984  maxchan = s->max_matrix_channel;
985  if (!s->noise_type) {
986  generate_2_noise_channels(m, substr);
987  maxchan += 2;
988  } else {
989  fill_noise_buffer(m, substr);
990  }
991 
992  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
993  int matrix_noise_shift = s->matrix_noise_shift[mat];
994  unsigned int dest_ch = s->matrix_out_ch[mat];
995  int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
996  int32_t *coeffs = s->matrix_coeff[mat];
997  int index = s->num_primitive_matrices - mat;
998  int index2 = 2 * index + 1;
999 
1000  /* TODO: DSPContext? */
1001 
1002  for (i = 0; i < s->blockpos; i++) {
1003  int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1004  int32_t *samples = m->sample_buffer[i];
1005  int64_t accum = 0;
1006 
1007  for (src_ch = 0; src_ch <= maxchan; src_ch++)
1008  accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1009 
1010  if (matrix_noise_shift) {
1011  index &= m->access_unit_size_pow2 - 1;
1012  accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1013  index += index2;
1014  }
1015 
1016  samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1017  }
1018  }
1019 }
1020 
1023 static int output_data(MLPDecodeContext *m, unsigned int substr,
1024  AVFrame *frame, int *got_frame_ptr)
1025 {
1026  AVCodecContext *avctx = m->avctx;
1027  SubStream *s = &m->substream[substr];
1028  unsigned int i, out_ch = 0;
1029  int32_t *data_32;
1030  int16_t *data_16;
1031  int ret;
1032  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1033 
1034  if (m->avctx->channels != s->max_matrix_channel + 1) {
1035  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1036  return AVERROR_INVALIDDATA;
1037  }
1038 
1039  if (!s->blockpos) {
1040  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1041  return AVERROR_INVALIDDATA;
1042  }
1043 
1044  /* get output buffer */
1045  frame->nb_samples = s->blockpos;
1046  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1047  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1048  return ret;
1049  }
1050  data_32 = (int32_t *)frame->data[0];
1051  data_16 = (int16_t *)frame->data[0];
1052 
1053  for (i = 0; i < s->blockpos; i++) {
1054  for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1055  int mat_ch = s->ch_assign[out_ch];
1056  int32_t sample = m->sample_buffer[i][mat_ch]
1057  << s->output_shift[mat_ch];
1058  s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1059  if (is32) *data_32++ = sample << 8;
1060  else *data_16++ = sample >> 8;
1061  }
1062  }
1063 
1064  /* Update matrix encoding side data */
1065  if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1066  return ret;
1067 
1068  *got_frame_ptr = 1;
1069 
1070  return 0;
1071 }
1072 
1077 static int read_access_unit(AVCodecContext *avctx, void* data,
1078  int *got_frame_ptr, AVPacket *avpkt)
1079 {
1080  const uint8_t *buf = avpkt->data;
1081  int buf_size = avpkt->size;
1082  MLPDecodeContext *m = avctx->priv_data;
1083  GetBitContext gb;
1084  unsigned int length, substr;
1085  unsigned int substream_start;
1086  unsigned int header_size = 4;
1087  unsigned int substr_header_size = 0;
1088  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1089  uint16_t substream_data_len[MAX_SUBSTREAMS];
1090  uint8_t parity_bits;
1091  int ret;
1092 
1093  if (buf_size < 4)
1094  return 0;
1095 
1096  length = (AV_RB16(buf) & 0xfff) * 2;
1097 
1098  if (length < 4 || length > buf_size)
1099  return AVERROR_INVALIDDATA;
1100 
1101  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1102 
1103  m->is_major_sync_unit = 0;
1104  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1105  if (read_major_sync(m, &gb) < 0)
1106  goto error;
1107  m->is_major_sync_unit = 1;
1108  header_size += 28;
1109  }
1110 
1111  if (!m->params_valid) {
1113  "Stream parameters not seen; skipping frame.\n");
1114  *got_frame_ptr = 0;
1115  return length;
1116  }
1117 
1118  substream_start = 0;
1119 
1120  for (substr = 0; substr < m->num_substreams; substr++) {
1121  int extraword_present, checkdata_present, end, nonrestart_substr;
1122 
1123  extraword_present = get_bits1(&gb);
1124  nonrestart_substr = get_bits1(&gb);
1125  checkdata_present = get_bits1(&gb);
1126  skip_bits1(&gb);
1127 
1128  end = get_bits(&gb, 12) * 2;
1129 
1130  substr_header_size += 2;
1131 
1132  if (extraword_present) {
1133  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1134  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1135  goto error;
1136  }
1137  skip_bits(&gb, 16);
1138  substr_header_size += 2;
1139  }
1140 
1141  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1142  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1143  goto error;
1144  }
1145 
1146  if (end + header_size + substr_header_size > length) {
1148  "Indicated length of substream %d data goes off end of "
1149  "packet.\n", substr);
1150  end = length - header_size - substr_header_size;
1151  }
1152 
1153  if (end < substream_start) {
1154  av_log(avctx, AV_LOG_ERROR,
1155  "Indicated end offset of substream %d data "
1156  "is smaller than calculated start offset.\n",
1157  substr);
1158  goto error;
1159  }
1160 
1161  if (substr > m->max_decoded_substream)
1162  continue;
1163 
1164  substream_parity_present[substr] = checkdata_present;
1165  substream_data_len[substr] = end - substream_start;
1166  substream_start = end;
1167  }
1168 
1169  parity_bits = ff_mlp_calculate_parity(buf, 4);
1170  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1171 
1172  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1173  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1174  goto error;
1175  }
1176 
1177  buf += header_size + substr_header_size;
1178 
1179  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1180  SubStream *s = &m->substream[substr];
1181  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1182 
1183  m->matrix_changed = 0;
1184  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1185 
1186  s->blockpos = 0;
1187  do {
1188  if (get_bits1(&gb)) {
1189  if (get_bits1(&gb)) {
1190  /* A restart header should be present. */
1191  if (read_restart_header(m, &gb, buf, substr) < 0)
1192  goto next_substr;
1193  s->restart_seen = 1;
1194  }
1195 
1196  if (!s->restart_seen)
1197  goto next_substr;
1198  if (read_decoding_params(m, &gb, substr) < 0)
1199  goto next_substr;
1200  }
1201 
1202  if (!s->restart_seen)
1203  goto next_substr;
1204 
1205  if ((ret = read_block_data(m, &gb, substr)) < 0)
1206  return ret;
1207 
1208  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1209  goto substream_length_mismatch;
1210 
1211  } while (!get_bits1(&gb));
1212 
1213  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1214 
1215  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1216  int shorten_by;
1217 
1218  if (get_bits(&gb, 16) != 0xD234)
1219  return AVERROR_INVALIDDATA;
1220 
1221  shorten_by = get_bits(&gb, 16);
1222  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1223  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1224  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1225  return AVERROR_INVALIDDATA;
1226 
1227  if (substr == m->max_decoded_substream)
1228  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1229  }
1230 
1231  if (substream_parity_present[substr]) {
1232  uint8_t parity, checksum;
1233 
1234  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1235  goto substream_length_mismatch;
1236 
1237  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1238  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1239 
1240  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1241  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1242  if ( get_bits(&gb, 8) != checksum)
1243  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1244  }
1245 
1246  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1247  goto substream_length_mismatch;
1248 
1249 next_substr:
1250  if (!s->restart_seen)
1252  "No restart header present in substream %d.\n", substr);
1253 
1254  buf += substream_data_len[substr];
1255  }
1256 
1258 
1259  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1260  return ret;
1261 
1262  return length;
1263 
1264 substream_length_mismatch:
1265  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1266  return AVERROR_INVALIDDATA;
1267 
1268 error:
1269  m->params_valid = 0;
1270  return AVERROR_INVALIDDATA;
1271 }
1272 
1274  .name = "mlp",
1275  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1276  .type = AVMEDIA_TYPE_AUDIO,
1277  .id = AV_CODEC_ID_MLP,
1278  .priv_data_size = sizeof(MLPDecodeContext),
1279  .init = mlp_decode_init,
1281  .capabilities = CODEC_CAP_DR1,
1282 };
1283 
1284 #if CONFIG_TRUEHD_DECODER
1285 AVCodec ff_truehd_decoder = {
1286  .name = "truehd",
1287  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1288  .type = AVMEDIA_TYPE_AUDIO,
1289  .id = AV_CODEC_ID_TRUEHD,
1290  .priv_data_size = sizeof(MLPDecodeContext),
1291  .init = mlp_decode_init,
1293  .capabilities = CODEC_CAP_DR1,
1294 };
1295 #endif /* CONFIG_TRUEHD_DECODER */