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 "dsputil.h"
31 #include "libavutil/intreadwrite.h"
32 #include "get_bits.h"
33 #include "libavutil/crc.h"
34 #include "parser.h"
35 #include "mlp_parser.h"
36 #include "mlp.h"
37 
39 #define VLC_BITS 9
40 
41 
42 static const char* sample_message =
43  "Please file a bug report following the instructions at "
44  "http://libav.org/bugreports.html and include "
45  "a sample of this file.";
46 
47 typedef struct SubStream {
49  uint8_t restart_seen;
50 
52 
53 
54  uint16_t noise_type;
55 
57  uint8_t min_channel;
59  uint8_t max_channel;
64 
67 
69  uint8_t noise_shift;
71  uint32_t noisegen_seed;
72 
75 
78 #define PARAM_BLOCKSIZE (1 << 7)
79 #define PARAM_MATRIX (1 << 6)
80 #define PARAM_OUTSHIFT (1 << 5)
81 #define PARAM_QUANTSTEP (1 << 4)
82 #define PARAM_FIR (1 << 3)
83 #define PARAM_IIR (1 << 2)
84 #define PARAM_HUFFOFFSET (1 << 1)
85 #define PARAM_PRESENCE (1 << 0)
86 
87 
89 
91 
93 
96 
104 
107 
109  uint16_t blocksize;
111  uint16_t blockpos;
112 
115 
118 
119 } SubStream;
120 
121 typedef struct MLPDecodeContext {
124 
127 
129  uint8_t params_valid;
130 
132  uint8_t num_substreams;
133 
136 
141 
143 
146 
150 
153 
154 static VLC huff_vlc[3];
155 
158 static av_cold void init_static(void)
159 {
160  if (!huff_vlc[0].bits) {
161  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
162  &ff_mlp_huffman_tables[0][0][1], 2, 1,
163  &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
164  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
165  &ff_mlp_huffman_tables[1][0][1], 2, 1,
166  &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
167  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
168  &ff_mlp_huffman_tables[2][0][1], 2, 1,
169  &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
170  }
171 
172  ff_mlp_init_crc();
173 }
174 
175 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
176  unsigned int substr, unsigned int ch)
177 {
178  SubStream *s = &m->substream[substr];
179  ChannelParams *cp = &s->channel_params[ch];
180  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
181  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
182  int32_t sign_huff_offset = cp->huff_offset;
183 
184  if (cp->codebook > 0)
185  sign_huff_offset -= 7 << lsb_bits;
186 
187  if (sign_shift >= 0)
188  sign_huff_offset -= 1 << sign_shift;
189 
190  return sign_huff_offset;
191 }
192 
197  unsigned int substr, unsigned int pos)
198 {
199  SubStream *s = &m->substream[substr];
200  unsigned int mat, channel;
201 
202  for (mat = 0; mat < s->num_primitive_matrices; mat++)
203  if (s->lsb_bypass[mat])
204  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
205 
206  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
207  ChannelParams *cp = &s->channel_params[channel];
208  int codebook = cp->codebook;
209  int quant_step_size = s->quant_step_size[channel];
210  int lsb_bits = cp->huff_lsbs - quant_step_size;
211  int result = 0;
212 
213  if (codebook > 0)
214  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
215  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
216 
217  if (result < 0)
218  return AVERROR_INVALIDDATA;
219 
220  if (lsb_bits > 0)
221  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
222 
223  result += cp->sign_huff_offset;
224  result <<= quant_step_size;
225 
226  m->sample_buffer[pos + s->blockpos][channel] = result;
227  }
228 
229  return 0;
230 }
231 
233 {
234  MLPDecodeContext *m = avctx->priv_data;
235  int substr;
236 
237  init_static();
238  m->avctx = avctx;
239  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
240  m->substream[substr].lossless_check_data = 0xffffffff;
241  dsputil_init(&m->dsp, avctx);
242 
244  avctx->coded_frame = &m->frame;
245 
246  return 0;
247 }
248 
255 {
256  MLPHeaderInfo mh;
257  int substr, ret;
258 
259  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
260  return ret;
261 
262  if (mh.group1_bits == 0) {
263  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
264  return AVERROR_INVALIDDATA;
265  }
266  if (mh.group2_bits > mh.group1_bits) {
268  "Channel group 2 cannot have more bits per sample than group 1.\n");
269  return AVERROR_INVALIDDATA;
270  }
271 
274  "Channel groups with differing sample rates are not currently supported.\n");
275  return AVERROR_INVALIDDATA;
276  }
277 
278  if (mh.group1_samplerate == 0) {
279  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
280  return AVERROR_INVALIDDATA;
281  }
284  "Sampling rate %d is greater than the supported maximum (%d).\n",
286  return AVERROR_INVALIDDATA;
287  }
288  if (mh.access_unit_size > MAX_BLOCKSIZE) {
290  "Block size %d is greater than the supported maximum (%d).\n",
292  return AVERROR_INVALIDDATA;
293  }
296  "Block size pow2 %d is greater than the supported maximum (%d).\n",
298  return AVERROR_INVALIDDATA;
299  }
300 
301  if (mh.num_substreams == 0)
302  return AVERROR_INVALIDDATA;
303  if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
304  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
305  return AVERROR_INVALIDDATA;
306  }
307  if (mh.num_substreams > MAX_SUBSTREAMS) {
309  "Number of substreams %d is larger than the maximum supported "
310  "by the decoder. %s\n", mh.num_substreams, sample_message);
311  return AVERROR_INVALIDDATA;
312  }
313 
316 
319 
322 
324  if (mh.group1_bits > 16)
326  else
328 
329  m->params_valid = 1;
330  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
331  m->substream[substr].restart_seen = 0;
332 
333  return 0;
334 }
335 
341  const uint8_t *buf, unsigned int substr)
342 {
343  SubStream *s = &m->substream[substr];
344  unsigned int ch;
345  int sync_word, tmp;
346  uint8_t checksum;
347  uint8_t lossless_check;
348  int start_count = get_bits_count(gbp);
349  const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
352 
353  sync_word = get_bits(gbp, 13);
354 
355  if (sync_word != 0x31ea >> 1) {
357  "restart header sync incorrect (got 0x%04x)\n", sync_word);
358  return AVERROR_INVALIDDATA;
359  }
360 
361  s->noise_type = get_bits1(gbp);
362 
363  if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
364  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
365  return AVERROR_INVALIDDATA;
366  }
367 
368  skip_bits(gbp, 16); /* Output timestamp */
369 
370  s->min_channel = get_bits(gbp, 4);
371  s->max_channel = get_bits(gbp, 4);
372  s->max_matrix_channel = get_bits(gbp, 4);
373 
374  if (s->max_matrix_channel > max_matrix_channel) {
376  "Max matrix channel cannot be greater than %d.\n",
377  max_matrix_channel);
378  return AVERROR_INVALIDDATA;
379  }
380 
381  if (s->max_channel != s->max_matrix_channel) {
383  "Max channel must be equal max matrix channel.\n");
384  return AVERROR_INVALIDDATA;
385  }
386 
387  /* This should happen for TrueHD streams with >6 channels and MLP's noise
388  * type. It is not yet known if this is allowed. */
391  "Number of channels %d is larger than the maximum supported "
392  "by the decoder. %s\n", s->max_channel+2, sample_message);
393  return AVERROR_INVALIDDATA;
394  }
395 
396  if (s->min_channel > s->max_channel) {
398  "Substream min channel cannot be greater than max channel.\n");
399  return AVERROR_INVALIDDATA;
400  }
401 
402  if (m->avctx->request_channels > 0
403  && s->max_channel + 1 >= m->avctx->request_channels
404  && substr < m->max_decoded_substream) {
406  "Extracting %d channel downmix from substream %d. "
407  "Further substreams will be skipped.\n",
408  s->max_channel + 1, substr);
409  m->max_decoded_substream = substr;
410  }
411 
412  s->noise_shift = get_bits(gbp, 4);
413  s->noisegen_seed = get_bits(gbp, 23);
414 
415  skip_bits(gbp, 19);
416 
417  s->data_check_present = get_bits1(gbp);
418  lossless_check = get_bits(gbp, 8);
419  if (substr == m->max_decoded_substream
420  && s->lossless_check_data != 0xffffffff) {
422  if (tmp != lossless_check)
424  "Lossless check failed - expected %02x, calculated %02x.\n",
425  lossless_check, tmp);
426  }
427 
428  skip_bits(gbp, 16);
429 
430  memset(s->ch_assign, 0, sizeof(s->ch_assign));
431 
432  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
433  int ch_assign = get_bits(gbp, 6);
434  if (ch_assign > s->max_matrix_channel) {
436  "Assignment of matrix channel %d to invalid output channel %d. %s\n",
437  ch, ch_assign, sample_message);
438  return AVERROR_INVALIDDATA;
439  }
440  s->ch_assign[ch_assign] = ch;
441  }
442 
443  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
444 
445  if (checksum != get_bits(gbp, 8))
446  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
447 
448  /* Set default decoding parameters. */
449  s->param_presence_flags = 0xff;
450  s->num_primitive_matrices = 0;
451  s->blocksize = 8;
452  s->lossless_check_data = 0;
453 
454  memset(s->output_shift , 0, sizeof(s->output_shift ));
455  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
456 
457  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
458  ChannelParams *cp = &s->channel_params[ch];
459  cp->filter_params[FIR].order = 0;
460  cp->filter_params[IIR].order = 0;
461  cp->filter_params[FIR].shift = 0;
462  cp->filter_params[IIR].shift = 0;
463 
464  /* Default audio coding is 24-bit raw PCM. */
465  cp->huff_offset = 0;
466  cp->sign_huff_offset = (-1) << 23;
467  cp->codebook = 0;
468  cp->huff_lsbs = 24;
469  }
470 
471  if (substr == m->max_decoded_substream)
472  m->avctx->channels = s->max_matrix_channel + 1;
473 
474  return 0;
475 }
476 
480  unsigned int substr, unsigned int channel,
481  unsigned int filter)
482 {
483  SubStream *s = &m->substream[substr];
485  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
486  const char fchar = filter ? 'I' : 'F';
487  int i, order;
488 
489  // Filter is 0 for FIR, 1 for IIR.
490  assert(filter < 2);
491 
492  if (m->filter_changed[channel][filter]++ > 1) {
493  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
494  return AVERROR_INVALIDDATA;
495  }
496 
497  order = get_bits(gbp, 4);
498  if (order > max_order) {
500  "%cIR filter order %d is greater than maximum %d.\n",
501  fchar, order, max_order);
502  return AVERROR_INVALIDDATA;
503  }
504  fp->order = order;
505 
506  if (order > 0) {
507  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
508  int coeff_bits, coeff_shift;
509 
510  fp->shift = get_bits(gbp, 4);
511 
512  coeff_bits = get_bits(gbp, 5);
513  coeff_shift = get_bits(gbp, 3);
514  if (coeff_bits < 1 || coeff_bits > 16) {
516  "%cIR filter coeff_bits must be between 1 and 16.\n",
517  fchar);
518  return AVERROR_INVALIDDATA;
519  }
520  if (coeff_bits + coeff_shift > 16) {
522  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
523  fchar);
524  return AVERROR_INVALIDDATA;
525  }
526 
527  for (i = 0; i < order; i++)
528  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
529 
530  if (get_bits1(gbp)) {
531  int state_bits, state_shift;
532 
533  if (filter == FIR) {
535  "FIR filter has state data specified.\n");
536  return AVERROR_INVALIDDATA;
537  }
538 
539  state_bits = get_bits(gbp, 4);
540  state_shift = get_bits(gbp, 4);
541 
542  /* TODO: Check validity of state data. */
543 
544  for (i = 0; i < order; i++)
545  fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
546  }
547  }
548 
549  return 0;
550 }
551 
554 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
555 {
556  SubStream *s = &m->substream[substr];
557  unsigned int mat, ch;
558  const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
561 
562  if (m->matrix_changed++ > 1) {
563  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
564  return AVERROR_INVALIDDATA;
565  }
566 
567  s->num_primitive_matrices = get_bits(gbp, 4);
568 
569  if (s->num_primitive_matrices > max_primitive_matrices) {
571  "Number of primitive matrices cannot be greater than %d.\n",
572  max_primitive_matrices);
573  return AVERROR_INVALIDDATA;
574  }
575 
576  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
577  int frac_bits, max_chan;
578  s->matrix_out_ch[mat] = get_bits(gbp, 4);
579  frac_bits = get_bits(gbp, 4);
580  s->lsb_bypass [mat] = get_bits1(gbp);
581 
582  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
584  "Invalid channel %d specified as output from matrix.\n",
585  s->matrix_out_ch[mat]);
586  return AVERROR_INVALIDDATA;
587  }
588  if (frac_bits > 14) {
590  "Too many fractional bits specified.\n");
591  return AVERROR_INVALIDDATA;
592  }
593 
594  max_chan = s->max_matrix_channel;
595  if (!s->noise_type)
596  max_chan+=2;
597 
598  for (ch = 0; ch <= max_chan; ch++) {
599  int coeff_val = 0;
600  if (get_bits1(gbp))
601  coeff_val = get_sbits(gbp, frac_bits + 2);
602 
603  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
604  }
605 
606  if (s->noise_type)
607  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
608  else
609  s->matrix_noise_shift[mat] = 0;
610  }
611 
612  return 0;
613 }
614 
617 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
618  GetBitContext *gbp, unsigned int ch)
619 {
620  SubStream *s = &m->substream[substr];
621  ChannelParams *cp = &s->channel_params[ch];
622  FilterParams *fir = &cp->filter_params[FIR];
623  FilterParams *iir = &cp->filter_params[IIR];
624  int ret;
625 
627  if (get_bits1(gbp))
628  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
629  return ret;
630 
632  if (get_bits1(gbp))
633  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
634  return ret;
635 
636  if (fir->order + iir->order > 8) {
637  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
638  return AVERROR_INVALIDDATA;
639  }
640 
641  if (fir->order && iir->order &&
642  fir->shift != iir->shift) {
644  "FIR and IIR filters must use the same precision.\n");
645  return AVERROR_INVALIDDATA;
646  }
647  /* The FIR and IIR filters must have the same precision.
648  * To simplify the filtering code, only the precision of the
649  * FIR filter is considered. If only the IIR filter is employed,
650  * the FIR filter precision is set to that of the IIR filter, so
651  * that the filtering code can use it. */
652  if (!fir->order && iir->order)
653  fir->shift = iir->shift;
654 
656  if (get_bits1(gbp))
657  cp->huff_offset = get_sbits(gbp, 15);
658 
659  cp->codebook = get_bits(gbp, 2);
660  cp->huff_lsbs = get_bits(gbp, 5);
661 
662  if (cp->huff_lsbs > 24) {
663  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
664  return AVERROR_INVALIDDATA;
665  }
666 
667  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
668 
669  return 0;
670 }
671 
676  unsigned int substr)
677 {
678  SubStream *s = &m->substream[substr];
679  unsigned int ch;
680  int ret;
681 
683  if (get_bits1(gbp))
684  s->param_presence_flags = get_bits(gbp, 8);
685 
687  if (get_bits1(gbp)) {
688  s->blocksize = get_bits(gbp, 9);
689  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
690  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
691  s->blocksize = 0;
692  return AVERROR_INVALIDDATA;
693  }
694  }
695 
697  if (get_bits1(gbp))
698  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
699  return ret;
700 
702  if (get_bits1(gbp))
703  for (ch = 0; ch <= s->max_matrix_channel; ch++)
704  s->output_shift[ch] = get_sbits(gbp, 4);
705 
707  if (get_bits1(gbp))
708  for (ch = 0; ch <= s->max_channel; ch++) {
709  ChannelParams *cp = &s->channel_params[ch];
710 
711  s->quant_step_size[ch] = get_bits(gbp, 4);
712 
713  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
714  }
715 
716  for (ch = s->min_channel; ch <= s->max_channel; ch++)
717  if (get_bits1(gbp))
718  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
719  return ret;
720 
721  return 0;
722 }
723 
724 #define MSB_MASK(bits) (-1u << bits)
725 
729 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
730  unsigned int channel)
731 {
732  SubStream *s = &m->substream[substr];
733  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
734  int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
735  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
736  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
737  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
738  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
739  unsigned int filter_shift = fir->shift;
740  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
741 
742  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
743  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
744 
745  m->dsp.mlp_filter_channel(firbuf, fircoeff,
746  fir->order, iir->order,
747  filter_shift, mask, s->blocksize,
748  &m->sample_buffer[s->blockpos][channel]);
749 
750  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
751  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
752 }
753 
757  unsigned int substr)
758 {
759  SubStream *s = &m->substream[substr];
760  unsigned int i, ch, expected_stream_pos = 0;
761  int ret;
762 
763  if (s->data_check_present) {
764  expected_stream_pos = get_bits_count(gbp);
765  expected_stream_pos += get_bits(gbp, 16);
766  av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
767  "we have not tested yet. %s\n", sample_message);
768  }
769 
770  if (s->blockpos + s->blocksize > m->access_unit_size) {
771  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
772  return AVERROR_INVALIDDATA;
773  }
774 
775  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
776  s->blocksize * sizeof(m->bypassed_lsbs[0]));
777 
778  for (i = 0; i < s->blocksize; i++)
779  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
780  return ret;
781 
782  for (ch = s->min_channel; ch <= s->max_channel; ch++)
783  filter_channel(m, substr, ch);
784 
785  s->blockpos += s->blocksize;
786 
787  if (s->data_check_present) {
788  if (get_bits_count(gbp) != expected_stream_pos)
789  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
790  skip_bits(gbp, 8);
791  }
792 
793  return 0;
794 }
795 
798 static const int8_t noise_table[256] = {
799  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
800  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
801  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
802  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
803  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
804  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
805  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
806  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
807  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
808  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
809  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
810  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
811  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
812  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
813  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
814  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
815 };
816 
827 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
828 {
829  SubStream *s = &m->substream[substr];
830  unsigned int i;
831  uint32_t seed = s->noisegen_seed;
832  unsigned int maxchan = s->max_matrix_channel;
833 
834  for (i = 0; i < s->blockpos; i++) {
835  uint16_t seed_shr7 = seed >> 7;
836  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
837  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
838 
839  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
840  }
841 
842  s->noisegen_seed = seed;
843 }
844 
847 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
848 {
849  SubStream *s = &m->substream[substr];
850  unsigned int i;
851  uint32_t seed = s->noisegen_seed;
852 
853  for (i = 0; i < m->access_unit_size_pow2; i++) {
854  uint8_t seed_shr15 = seed >> 15;
855  m->noise_buffer[i] = noise_table[seed_shr15];
856  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
857  }
858 
859  s->noisegen_seed = seed;
860 }
861 
862 
866 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
867 {
868  SubStream *s = &m->substream[substr];
869  unsigned int mat, src_ch, i;
870  unsigned int maxchan;
871 
872  maxchan = s->max_matrix_channel;
873  if (!s->noise_type) {
874  generate_2_noise_channels(m, substr);
875  maxchan += 2;
876  } else {
877  fill_noise_buffer(m, substr);
878  }
879 
880  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
881  int matrix_noise_shift = s->matrix_noise_shift[mat];
882  unsigned int dest_ch = s->matrix_out_ch[mat];
883  int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
884  int32_t *coeffs = s->matrix_coeff[mat];
885  int index = s->num_primitive_matrices - mat;
886  int index2 = 2 * index + 1;
887 
888  /* TODO: DSPContext? */
889 
890  for (i = 0; i < s->blockpos; i++) {
891  int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
892  int32_t *samples = m->sample_buffer[i];
893  int64_t accum = 0;
894 
895  for (src_ch = 0; src_ch <= maxchan; src_ch++)
896  accum += (int64_t) samples[src_ch] * coeffs[src_ch];
897 
898  if (matrix_noise_shift) {
899  index &= m->access_unit_size_pow2 - 1;
900  accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
901  index += index2;
902  }
903 
904  samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
905  }
906  }
907 }
908 
911 static int output_data(MLPDecodeContext *m, unsigned int substr,
912  void *data, int *got_frame_ptr)
913 {
914  AVCodecContext *avctx = m->avctx;
915  SubStream *s = &m->substream[substr];
916  unsigned int i, out_ch = 0;
917  int32_t *data_32;
918  int16_t *data_16;
919  int ret;
920  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
921 
922  if (m->avctx->channels != s->max_matrix_channel + 1) {
923  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
924  return AVERROR_INVALIDDATA;
925  }
926 
927  /* get output buffer */
928  m->frame.nb_samples = s->blockpos;
929  if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
930  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
931  return ret;
932  }
933  data_32 = (int32_t *)m->frame.data[0];
934  data_16 = (int16_t *)m->frame.data[0];
935 
936  for (i = 0; i < s->blockpos; i++) {
937  for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
938  int mat_ch = s->ch_assign[out_ch];
939  int32_t sample = m->sample_buffer[i][mat_ch]
940  << s->output_shift[mat_ch];
941  s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
942  if (is32) *data_32++ = sample << 8;
943  else *data_16++ = sample >> 8;
944  }
945  }
946 
947  *got_frame_ptr = 1;
948  *(AVFrame *)data = m->frame;
949 
950  return 0;
951 }
952 
957 static int read_access_unit(AVCodecContext *avctx, void* data,
958  int *got_frame_ptr, AVPacket *avpkt)
959 {
960  const uint8_t *buf = avpkt->data;
961  int buf_size = avpkt->size;
962  MLPDecodeContext *m = avctx->priv_data;
963  GetBitContext gb;
964  unsigned int length, substr;
965  unsigned int substream_start;
966  unsigned int header_size = 4;
967  unsigned int substr_header_size = 0;
968  uint8_t substream_parity_present[MAX_SUBSTREAMS];
969  uint16_t substream_data_len[MAX_SUBSTREAMS];
970  uint8_t parity_bits;
971  int ret;
972 
973  if (buf_size < 4)
974  return 0;
975 
976  length = (AV_RB16(buf) & 0xfff) * 2;
977 
978  if (length < 4 || length > buf_size)
979  return AVERROR_INVALIDDATA;
980 
981  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
982 
983  m->is_major_sync_unit = 0;
984  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
985  if (read_major_sync(m, &gb) < 0)
986  goto error;
987  m->is_major_sync_unit = 1;
988  header_size += 28;
989  }
990 
991  if (!m->params_valid) {
993  "Stream parameters not seen; skipping frame.\n");
994  *got_frame_ptr = 0;
995  return length;
996  }
997 
998  substream_start = 0;
999 
1000  for (substr = 0; substr < m->num_substreams; substr++) {
1001  int extraword_present, checkdata_present, end, nonrestart_substr;
1002 
1003  extraword_present = get_bits1(&gb);
1004  nonrestart_substr = get_bits1(&gb);
1005  checkdata_present = get_bits1(&gb);
1006  skip_bits1(&gb);
1007 
1008  end = get_bits(&gb, 12) * 2;
1009 
1010  substr_header_size += 2;
1011 
1012  if (extraword_present) {
1013  if (m->avctx->codec_id == CODEC_ID_MLP) {
1014  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1015  goto error;
1016  }
1017  skip_bits(&gb, 16);
1018  substr_header_size += 2;
1019  }
1020 
1021  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1022  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1023  goto error;
1024  }
1025 
1026  if (end + header_size + substr_header_size > length) {
1028  "Indicated length of substream %d data goes off end of "
1029  "packet.\n", substr);
1030  end = length - header_size - substr_header_size;
1031  }
1032 
1033  if (end < substream_start) {
1034  av_log(avctx, AV_LOG_ERROR,
1035  "Indicated end offset of substream %d data "
1036  "is smaller than calculated start offset.\n",
1037  substr);
1038  goto error;
1039  }
1040 
1041  if (substr > m->max_decoded_substream)
1042  continue;
1043 
1044  substream_parity_present[substr] = checkdata_present;
1045  substream_data_len[substr] = end - substream_start;
1046  substream_start = end;
1047  }
1048 
1049  parity_bits = ff_mlp_calculate_parity(buf, 4);
1050  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1051 
1052  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1053  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1054  goto error;
1055  }
1056 
1057  buf += header_size + substr_header_size;
1058 
1059  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1060  SubStream *s = &m->substream[substr];
1061  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1062 
1063  m->matrix_changed = 0;
1064  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1065 
1066  s->blockpos = 0;
1067  do {
1068  if (get_bits1(&gb)) {
1069  if (get_bits1(&gb)) {
1070  /* A restart header should be present. */
1071  if (read_restart_header(m, &gb, buf, substr) < 0)
1072  goto next_substr;
1073  s->restart_seen = 1;
1074  }
1075 
1076  if (!s->restart_seen)
1077  goto next_substr;
1078  if (read_decoding_params(m, &gb, substr) < 0)
1079  goto next_substr;
1080  }
1081 
1082  if (!s->restart_seen)
1083  goto next_substr;
1084 
1085  if ((ret = read_block_data(m, &gb, substr)) < 0)
1086  return ret;
1087 
1088  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1089  goto substream_length_mismatch;
1090 
1091  } while (!get_bits1(&gb));
1092 
1093  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1094 
1095  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1096  int shorten_by;
1097 
1098  if (get_bits(&gb, 16) != 0xD234)
1099  return AVERROR_INVALIDDATA;
1100 
1101  shorten_by = get_bits(&gb, 16);
1102  if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1103  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1104  else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1105  return AVERROR_INVALIDDATA;
1106 
1107  if (substr == m->max_decoded_substream)
1108  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1109  }
1110 
1111  if (substream_parity_present[substr]) {
1112  uint8_t parity, checksum;
1113 
1114  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1115  goto substream_length_mismatch;
1116 
1117  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1118  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1119 
1120  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1121  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1122  if ( get_bits(&gb, 8) != checksum)
1123  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1124  }
1125 
1126  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1127  goto substream_length_mismatch;
1128 
1129 next_substr:
1130  if (!s->restart_seen)
1132  "No restart header present in substream %d.\n", substr);
1133 
1134  buf += substream_data_len[substr];
1135  }
1136 
1138 
1139  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1140  return ret;
1141 
1142  return length;
1143 
1144 substream_length_mismatch:
1145  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1146  return AVERROR_INVALIDDATA;
1147 
1148 error:
1149  m->params_valid = 0;
1150  return AVERROR_INVALIDDATA;
1151 }
1152 
1154  .name = "mlp",
1155  .type = AVMEDIA_TYPE_AUDIO,
1156  .id = CODEC_ID_MLP,
1157  .priv_data_size = sizeof(MLPDecodeContext),
1158  .init = mlp_decode_init,
1160  .capabilities = CODEC_CAP_DR1,
1161  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1162 };
1163 
1164 #if CONFIG_TRUEHD_DECODER
1165 AVCodec ff_truehd_decoder = {
1166  .name = "truehd",
1167  .type = AVMEDIA_TYPE_AUDIO,
1168  .id = CODEC_ID_TRUEHD,
1169  .priv_data_size = sizeof(MLPDecodeContext),
1170  .init = mlp_decode_init,
1172  .capabilities = CODEC_CAP_DR1,
1173  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1174 };
1175 #endif /* CONFIG_TRUEHD_DECODER */