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  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 
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 */
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:154
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:348
static const int16_t coeffs[28]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define MAX_IIR_ORDER
Definition: mlp.h:65
FilterParams filter_params[NUM_FILTERS]
Definition: mlp.h:83
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
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:787
#define AV_CH_TOP_FRONT_RIGHT
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
Definition: mlpdec.c:147
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
Definition: mlpdec.c:78
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
Definition: mlpdec.c:939
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible. ...
Definition: mlpdec.c:129
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
attribute_deprecated int request_channels
Decoder should decode to this many channels if it can (0 for default)
Definition: avcodec.h:1832
#define AV_CH_TOP_FRONT_LEFT
int num_substreams
Number of substreams within stream.
Definition: mlp_parser.h:59
#define AV_CH_TOP_FRONT_CENTER
int size
Definition: avcodec.h:974
#define AV_CH_LOW_FREQUENCY_2
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
enum AVMatrixEncoding matrix_encoding
The matrix encoding mode for this substream.
Definition: mlpdec.c:64
static int16_t * samples
Definition: output.c:53
#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:49
#define FF_ARRAY_ELEMS(a)
int8_t output_shift[MAX_CHANNELS]
Left shift to apply to decoded PCM values to get final 24-bit output.
Definition: mlpdec.c:115
#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:2488
signed 16 bits
Definition: samplefmt.h:52
#define sample
AVCodec.
Definition: avcodec.h:2755
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:226
int access_unit_size
Number of samples per coded frame.
Definition: mlp_parser.h:53
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
Definition: mlpdec.c:101
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:85
#define PARAM_OUTSHIFT
Definition: mlpdec.c:81
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int matrix_changed
Definition: mlpdec.c:144
#define AV_CH_WIDE_LEFT
uint8_t bits
Definition: crc.c:216
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1787
uint8_t
#define av_cold
Definition: attributes.h:66
MLPDSPContext dsp
Definition: mlpdec.c:151
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:443
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
Definition: mlp.h:120
int channel_modifier_thd_stream0
Channel modifier for substream 0 of TrueHD sreams ("2-channel presentation")
Definition: mlp_parser.h:42
#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:60
#define AV_CH_WIDE_RIGHT
#define AV_CH_LOW_FREQUENCY
AVCodec ff_mlp_decoder
Definition: mlpdec.c:1273
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:711
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:973
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
Definition: mlpdec.c:959
#define PARAM_FIR
Definition: mlpdec.c:83
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:46
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:54
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:591
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:426
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:666
#define PARAM_BLOCKSIZE
Definition: mlpdec.c:79
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:1077
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:56
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
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
ChannelParams channel_params[MAX_CHANNELS]
Channel coding parameters for channels in the substream.
Definition: mlpdec.c:67
#define MAX_MATRIX_CHANNEL_TRUEHD
Definition: mlp.h:31
int channel_modifier_thd_stream2
Channel modifier for substream 2 of TrueHD sreams ("8-channel presentation")
Definition: mlp_parser.h:44
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:170
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:148
uint8_t quant_step_size[MAX_CHANNELS]
Left shift to apply to Huffman-decoded residuals.
Definition: mlpdec.c:107
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
static VLC huff_vlc[3]
Definition: mlpdec.c:184
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:80
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
#define PARAM_QUANTSTEP
Definition: mlpdec.c:82
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:132
Definition: get_bits.h:64
uint8_t max_matrix_channel
The number of channels input into the rematrix stage.
Definition: mlpdec.c:58
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1840
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:262
signed 32 bits
Definition: samplefmt.h:53
common internal API header
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:307
#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
#define FFMIN(a, b)
Definition: common.h:57
uint16_t noise_type
restart header data
Definition: mlpdec.c:51
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:729
int32_t
int32_t lossless_check_data
Running XOR of all output samples.
Definition: mlpdec.c:118
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:522
#define AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_CENTER
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:145
uint8_t lsb_bypass[MAX_MATRICES]
Whether the LSBs of the matrix output are encoded in the bitstream.
Definition: mlpdec.c:99
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:226
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:138
#define AV_CH_FRONT_RIGHT_OF_CENTER
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:156
if(ac->has_optimized_func)
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
static int32_t calculate_sign_huff(MLPDecodeContext *m, unsigned int substr, unsigned int ch)
Definition: mlpdec.c:205
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1799
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
int access_unit_size_pow2
Next power of two above number of samples per frame.
Definition: mlp_parser.h:54
uint16_t blocksize
number of PCM samples in current audio block
Definition: mlpdec.c:110
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
Libavcodec 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:75
int32_t state[MAX_FIR_ORDER]
Definition: mlp.h:78
enum AVCodecID codec_id
Definition: avcodec.h:1065
int sample_rate
samples per second
Definition: avcodec.h:1779
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
Definition: mlpdsp.c:60
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
Definition: mlpdec.c:42
SubStream substream[MAX_SUBSTREAMS]
Definition: mlpdec.c:142
uint8_t order
number of taps in filter
Definition: mlp.h:75
int channel_modifier_thd_stream1
Channel modifier for substream 1 of TrueHD sreams ("6-channel presentation")
Definition: mlp_parser.h:43
main external API structure.
Definition: avcodec.h:1054
#define AV_CH_FRONT_LEFT
int is_major_sync_unit
Current access unit being read has a major sync.
Definition: mlpdec.c:126
static unsigned int seed
Definition: videogen.c:78
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:575
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:149
filter data
Definition: mlp.h:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:296
#define IIR
Definition: mlp.h:71
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
AVCodecContext * avctx
Definition: mlpdec.c:123
int index
Definition: gxfenc.c:72
uint64_t ch_layout
The channel layout for this substream.
Definition: mlpdec.c:62
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
Apply the channel matrices in turn to reconstruct the original audio samples.
Definition: mlpdec.c:978
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:868
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
uint8_t num_primitive_matrices
matrix data
Definition: mlpdec.c:93
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
Definition: mlpdec.c:135
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:910
#define MAX_CHANNELS
Definition: aac.h:42
#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:281
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:112
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: frame.h:113
#define AV_CH_SIDE_RIGHT
#define MSB_MASK(bits)
Definition: mlpdec.c:836
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:188
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:72
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:75
common internal api header.
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:96
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:140
uint64_t channel_layout_thd_stream1
Channel layout for substream 1 of TrueHD streams ("6-channel presentation")
Definition: mlp_parser.h:50
#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:51
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:128
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:498
void * priv_data
Definition: avcodec.h:1090
uint8_t matrix_noise_shift[MAX_MATRICES]
Left shift to apply to noise values in 0x31eb substreams.
Definition: mlpdec.c:103
uint8_t noise_shift
The left shift applied to random noise in 0x31ea substreams.
Definition: mlpdec.c:70
static int output_data(MLPDecodeContext *m, unsigned int substr, AVFrame *frame, int *got_frame_ptr)
Write the audio data into the output buffer.
Definition: mlpdec.c:1023
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:76
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:841
sample data coding information
Definition: mlp.h:82
int channels
number of audio channels
Definition: avcodec.h:1780
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:84
#define MAX_MATRICES_MLP
Maximum number of matrices used in decoding; most streams have one matrix per output channel...
Definition: mlp.h:41
AVMatrixEncoding
#define AV_CH_SIDE_LEFT
int group1_samplerate
Sample rate of first substream.
Definition: mlp_parser.h:39
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1847
#define PARAM_PRESENCE
Definition: mlpdec.c:86
This structure stores compressed data.
Definition: avcodec.h:950
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: frame.h:151
#define AV_CH_BACK_RIGHT
int32_t sign_huff_offset
sign/rounding-corrected version of huff_offset
Definition: mlp.h:87
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