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