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 #include "config.h"
41 
43 #if ARCH_ARM
44 #define VLC_BITS 5
45 #define VLC_STATIC_SIZE 64
46 #else
47 #define VLC_BITS 9
48 #define VLC_STATIC_SIZE 512
49 #endif
50 
51 typedef struct SubStream {
54 
56 
57  uint16_t noise_type;
59 
69  uint64_t ch_layout;
72 
75 
79  uint32_t noisegen_seed;
80 
83 
86 #define PARAM_BLOCKSIZE (1 << 7)
87 #define PARAM_MATRIX (1 << 6)
88 #define PARAM_OUTSHIFT (1 << 5)
89 #define PARAM_QUANTSTEP (1 << 4)
90 #define PARAM_FIR (1 << 3)
91 #define PARAM_IIR (1 << 2)
92 #define PARAM_HUFFOFFSET (1 << 1)
93 #define PARAM_PRESENCE (1 << 0)
94 
95 
97 
101 
104 
112 
115 
117  uint16_t blocksize;
119  uint16_t blockpos;
120 
123 
126 
127 } SubStream;
128 
129 typedef struct MLPDecodeContext {
131 
134 
137 
140 
143 
146 
151 
153 
155  int filter_changed[MAX_CHANNELS][NUM_FILTERS];
156 
157  int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
158  int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
160 
163 
164 static const uint64_t thd_channel_order[] = {
166  AV_CH_FRONT_CENTER, // C
167  AV_CH_LOW_FREQUENCY, // LFE
172  AV_CH_BACK_CENTER, // Cs
173  AV_CH_TOP_CENTER, // Ts
176  AV_CH_TOP_FRONT_CENTER, // Cvh
177  AV_CH_LOW_FREQUENCY_2, // LFE2
178 };
179 
180 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
181  int index)
182 {
183  int i;
184 
185  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
186  return 0;
187 
188  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
189  if (channel_layout & thd_channel_order[i] && !index--)
190  return thd_channel_order[i];
191  return 0;
192 }
193 
194 static VLC huff_vlc[3];
195 
198 static av_cold void init_static(void)
199 {
200  if (!huff_vlc[0].bits) {
201  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
202  &ff_mlp_huffman_tables[0][0][1], 2, 1,
203  &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
204  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
205  &ff_mlp_huffman_tables[1][0][1], 2, 1,
206  &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
207  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
208  &ff_mlp_huffman_tables[2][0][1], 2, 1,
209  &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
210  }
211 
212  ff_mlp_init_crc();
213 }
214 
216  unsigned int substr, unsigned int ch)
217 {
218  SubStream *s = &m->substream[substr];
219  ChannelParams *cp = &s->channel_params[ch];
220  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
221  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
222  int32_t sign_huff_offset = cp->huff_offset;
223 
224  if (cp->codebook > 0)
225  sign_huff_offset -= 7 << lsb_bits;
226 
227  if (sign_shift >= 0)
228  sign_huff_offset -= 1 << sign_shift;
229 
230  return sign_huff_offset;
231 }
232 
237  unsigned int substr, unsigned int pos)
238 {
239  SubStream *s = &m->substream[substr];
240  unsigned int mat, channel;
241 
242  for (mat = 0; mat < s->num_primitive_matrices; mat++)
243  if (s->lsb_bypass[mat])
244  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
245 
246  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
247  ChannelParams *cp = &s->channel_params[channel];
248  int codebook = cp->codebook;
249  int quant_step_size = s->quant_step_size[channel];
250  int lsb_bits = cp->huff_lsbs - quant_step_size;
251  int result = 0;
252 
253  if (codebook > 0)
254  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
255  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
256 
257  if (result < 0)
258  return AVERROR_INVALIDDATA;
259 
260  if (lsb_bits > 0)
261  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
262 
263  result += cp->sign_huff_offset;
264  result <<= quant_step_size;
265 
266  m->sample_buffer[pos + s->blockpos][channel] = result;
267  }
268 
269  return 0;
270 }
271 
273 {
274  MLPDecodeContext *m = avctx->priv_data;
275  int substr;
276 
277  init_static();
278  m->avctx = avctx;
279  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
280  m->substream[substr].lossless_check_data = 0xffffffff;
281  ff_mlpdsp_init(&m->dsp);
282 
283  return 0;
284 }
285 
292 {
293  MLPHeaderInfo mh;
294  int substr, ret;
295 
296  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
297  return ret;
298 
299  if (mh.group1_bits == 0) {
300  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
301  return AVERROR_INVALIDDATA;
302  }
303  if (mh.group2_bits > mh.group1_bits) {
305  "Channel group 2 cannot have more bits per sample than group 1.\n");
306  return AVERROR_INVALIDDATA;
307  }
308 
311  "Channel groups with differing sample rates are not currently supported.\n");
312  return AVERROR_INVALIDDATA;
313  }
314 
315  if (mh.group1_samplerate == 0) {
316  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
317  return AVERROR_INVALIDDATA;
318  }
321  "Sampling rate %d is greater than the supported maximum (%d).\n",
323  return AVERROR_INVALIDDATA;
324  }
325  if (mh.access_unit_size > MAX_BLOCKSIZE) {
327  "Block size %d is greater than the supported maximum (%d).\n",
329  return AVERROR_INVALIDDATA;
330  }
333  "Block size pow2 %d is greater than the supported maximum (%d).\n",
335  return AVERROR_INVALIDDATA;
336  }
337 
338  if (mh.num_substreams == 0)
339  return AVERROR_INVALIDDATA;
340  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
341  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
342  return AVERROR_INVALIDDATA;
343  }
344  if (mh.num_substreams > MAX_SUBSTREAMS) {
346  "%d substreams (more than the "
347  "maximum supported by the decoder)",
348  mh.num_substreams);
349  return AVERROR_PATCHWELCOME;
350  }
351 
353 
356 
358 
359  /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
361 
364 
366  if (mh.group1_bits > 16)
368  else
374 
375  m->params_valid = 1;
376  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
377  m->substream[substr].restart_seen = 0;
378 
379  /* Set the layout for each substream. When there's more than one, the first
380  * substream is Stereo. Subsequent substreams' layouts are indicated in the
381  * major sync. */
382  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
383  if ((substr = (mh.num_substreams > 1)))
385  m->substream[substr].ch_layout = mh.channel_layout_mlp;
386  } else {
387  if ((substr = (mh.num_substreams > 1)))
389  if (mh.num_substreams > 2)
392  else
395  }
396 
397  /* Parse the TrueHD decoder channel modifiers and set each substream's
398  * AVMatrixEncoding accordingly.
399  *
400  * The meaning of the modifiers depends on the channel layout:
401  *
402  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
403  *
404  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
405  *
406  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
407  * layouts with an Ls/Rs channel pair
408  */
409  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
412  if (mh.num_substreams > 2 &&
417 
418  if (mh.num_substreams > 1 &&
423 
424  if (mh.num_substreams > 0)
425  switch (mh.channel_modifier_thd_stream0) {
428  break;
431  break;
432  default:
433  break;
434  }
435  }
436 
437  return 0;
438 }
439 
445  const uint8_t *buf, unsigned int substr)
446 {
447  SubStream *s = &m->substream[substr];
448  unsigned int ch;
449  int sync_word, tmp;
451  uint8_t lossless_check;
452  int start_count = get_bits_count(gbp);
454  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
457 
458  sync_word = get_bits(gbp, 13);
459 
460  if (sync_word != 0x31ea >> 1) {
462  "restart header sync incorrect (got 0x%04x)\n", sync_word);
463  return AVERROR_INVALIDDATA;
464  }
465 
466  s->noise_type = get_bits1(gbp);
467 
468  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
469  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
470  return AVERROR_INVALIDDATA;
471  }
472 
473  skip_bits(gbp, 16); /* Output timestamp */
474 
475  min_channel = get_bits(gbp, 4);
476  max_channel = get_bits(gbp, 4);
477  max_matrix_channel = get_bits(gbp, 4);
478 
479  if (max_matrix_channel > std_max_matrix_channel) {
481  "Max matrix channel cannot be greater than %d.\n",
482  max_matrix_channel);
483  return AVERROR_INVALIDDATA;
484  }
485 
486  if (max_channel != max_matrix_channel) {
488  "Max channel must be equal max matrix channel.\n");
489  return AVERROR_INVALIDDATA;
490  }
491 
492  /* This should happen for TrueHD streams with >6 channels and MLP's noise
493  * type. It is not yet known if this is allowed. */
496  "%d channels (more than the "
497  "maximum supported by the decoder)",
498  s->max_channel + 2);
499  return AVERROR_PATCHWELCOME;
500  }
501 
502  if (min_channel > max_channel) {
504  "Substream min channel cannot be greater than max channel.\n");
505  return AVERROR_INVALIDDATA;
506  }
507 
511 
515  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
516  "Further substreams will be skipped.\n",
517  s->max_channel + 1, s->ch_layout, substr);
518  m->max_decoded_substream = substr;
519  }
520 
521  s->noise_shift = get_bits(gbp, 4);
522  s->noisegen_seed = get_bits(gbp, 23);
523 
524  skip_bits(gbp, 19);
525 
526  s->data_check_present = get_bits1(gbp);
527  lossless_check = get_bits(gbp, 8);
528  if (substr == m->max_decoded_substream
529  && s->lossless_check_data != 0xffffffff) {
531  if (tmp != lossless_check)
533  "Lossless check failed - expected %02x, calculated %02x.\n",
534  lossless_check, tmp);
535  }
536 
537  skip_bits(gbp, 16);
538 
539  memset(s->ch_assign, 0, sizeof(s->ch_assign));
540 
541  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
542  int ch_assign = get_bits(gbp, 6);
543  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
544  uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
545  ch_assign);
547  channel);
548  }
549  if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
551  "Assignment of matrix channel %d to invalid output channel %d",
552  ch, ch_assign);
553  return AVERROR_PATCHWELCOME;
554  }
555  s->ch_assign[ch_assign] = ch;
556  }
557 
558  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
559 
560  if (checksum != get_bits(gbp, 8))
561  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
562 
563  /* Set default decoding parameters. */
564  s->param_presence_flags = 0xff;
565  s->num_primitive_matrices = 0;
566  s->blocksize = 8;
567  s->lossless_check_data = 0;
568 
569  memset(s->output_shift , 0, sizeof(s->output_shift ));
570  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
571 
572  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
573  ChannelParams *cp = &s->channel_params[ch];
574  cp->filter_params[FIR].order = 0;
575  cp->filter_params[IIR].order = 0;
576  cp->filter_params[FIR].shift = 0;
577  cp->filter_params[IIR].shift = 0;
578 
579  /* Default audio coding is 24-bit raw PCM. */
580  cp->huff_offset = 0;
581  cp->sign_huff_offset = -(1 << 23);
582  cp->codebook = 0;
583  cp->huff_lsbs = 24;
584  }
585 
586  if (substr == m->max_decoded_substream) {
587  m->avctx->channels = s->max_matrix_channel + 1;
588  m->avctx->channel_layout = s->ch_layout;
590  s->output_shift,
593  }
594 
595  return 0;
596 }
597 
601  unsigned int substr, unsigned int channel,
602  unsigned int filter)
603 {
604  SubStream *s = &m->substream[substr];
605  FilterParams *fp = &s->channel_params[channel].filter_params[filter];
606  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
607  const char fchar = filter ? 'I' : 'F';
608  int i, order;
609 
610  // Filter is 0 for FIR, 1 for IIR.
611  assert(filter < 2);
612 
613  if (m->filter_changed[channel][filter]++ > 1) {
614  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
615  return AVERROR_INVALIDDATA;
616  }
617 
618  order = get_bits(gbp, 4);
619  if (order > max_order) {
621  "%cIR filter order %d is greater than maximum %d.\n",
622  fchar, order, max_order);
623  return AVERROR_INVALIDDATA;
624  }
625  fp->order = order;
626 
627  if (order > 0) {
628  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
629  int coeff_bits, coeff_shift;
630 
631  fp->shift = get_bits(gbp, 4);
632 
633  coeff_bits = get_bits(gbp, 5);
634  coeff_shift = get_bits(gbp, 3);
635  if (coeff_bits < 1 || coeff_bits > 16) {
637  "%cIR filter coeff_bits must be between 1 and 16.\n",
638  fchar);
639  return AVERROR_INVALIDDATA;
640  }
641  if (coeff_bits + coeff_shift > 16) {
643  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
644  fchar);
645  return AVERROR_INVALIDDATA;
646  }
647 
648  for (i = 0; i < order; i++)
649  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
650 
651  if (get_bits1(gbp)) {
652  int state_bits, state_shift;
653 
654  if (filter == FIR) {
656  "FIR filter has state data specified.\n");
657  return AVERROR_INVALIDDATA;
658  }
659 
660  state_bits = get_bits(gbp, 4);
661  state_shift = get_bits(gbp, 4);
662 
663  /* TODO: Check validity of state data. */
664 
665  for (i = 0; i < order; i++)
666  fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
667  }
668  }
669 
670  return 0;
671 }
672 
675 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
676 {
677  SubStream *s = &m->substream[substr];
678  unsigned int mat, ch;
679  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
682 
683  if (m->matrix_changed++ > 1) {
684  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
685  return AVERROR_INVALIDDATA;
686  }
687 
688  s->num_primitive_matrices = get_bits(gbp, 4);
689 
690  if (s->num_primitive_matrices > max_primitive_matrices) {
692  "Number of primitive matrices cannot be greater than %d.\n",
693  max_primitive_matrices);
694  return AVERROR_INVALIDDATA;
695  }
696 
697  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
698  int frac_bits, max_chan;
699  s->matrix_out_ch[mat] = get_bits(gbp, 4);
700  frac_bits = get_bits(gbp, 4);
701  s->lsb_bypass [mat] = get_bits1(gbp);
702 
703  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
705  "Invalid channel %d specified as output from matrix.\n",
706  s->matrix_out_ch[mat]);
707  return AVERROR_INVALIDDATA;
708  }
709  if (frac_bits > 14) {
711  "Too many fractional bits specified.\n");
712  return AVERROR_INVALIDDATA;
713  }
714 
715  max_chan = s->max_matrix_channel;
716  if (!s->noise_type)
717  max_chan+=2;
718 
719  for (ch = 0; ch <= max_chan; ch++) {
720  int coeff_val = 0;
721  if (get_bits1(gbp))
722  coeff_val = get_sbits(gbp, frac_bits + 2);
723 
724  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
725  }
726 
727  if (s->noise_type)
728  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
729  else
730  s->matrix_noise_shift[mat] = 0;
731  }
732 
733  return 0;
734 }
735 
738 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
739  GetBitContext *gbp, unsigned int ch)
740 {
741  SubStream *s = &m->substream[substr];
742  ChannelParams *cp = &s->channel_params[ch];
743  FilterParams *fir = &cp->filter_params[FIR];
744  FilterParams *iir = &cp->filter_params[IIR];
745  int ret;
746 
748  if (get_bits1(gbp))
749  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
750  return ret;
751 
753  if (get_bits1(gbp))
754  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
755  return ret;
756 
757  if (fir->order + iir->order > 8) {
758  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
759  return AVERROR_INVALIDDATA;
760  }
761 
762  if (fir->order && iir->order &&
763  fir->shift != iir->shift) {
765  "FIR and IIR filters must use the same precision.\n");
766  return AVERROR_INVALIDDATA;
767  }
768  /* The FIR and IIR filters must have the same precision.
769  * To simplify the filtering code, only the precision of the
770  * FIR filter is considered. If only the IIR filter is employed,
771  * the FIR filter precision is set to that of the IIR filter, so
772  * that the filtering code can use it. */
773  if (!fir->order && iir->order)
774  fir->shift = iir->shift;
775 
777  if (get_bits1(gbp))
778  cp->huff_offset = get_sbits(gbp, 15);
779 
780  cp->codebook = get_bits(gbp, 2);
781  cp->huff_lsbs = get_bits(gbp, 5);
782 
783  if (cp->huff_lsbs > 24) {
784  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
785  return AVERROR_INVALIDDATA;
786  }
787 
788  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
789 
790  return 0;
791 }
792 
797  unsigned int substr)
798 {
799  SubStream *s = &m->substream[substr];
800  unsigned int ch;
801  int ret;
802 
804  if (get_bits1(gbp))
805  s->param_presence_flags = get_bits(gbp, 8);
806 
808  if (get_bits1(gbp)) {
809  s->blocksize = get_bits(gbp, 9);
810  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
811  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
812  s->blocksize = 0;
813  return AVERROR_INVALIDDATA;
814  }
815  }
816 
818  if (get_bits1(gbp))
819  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
820  return ret;
821 
823  if (get_bits1(gbp)) {
824  for (ch = 0; ch <= s->max_matrix_channel; ch++)
825  s->output_shift[ch] = get_sbits(gbp, 4);
826  if (substr == m->max_decoded_substream)
828  s->output_shift,
831  }
832 
834  if (get_bits1(gbp))
835  for (ch = 0; ch <= s->max_channel; ch++) {
836  ChannelParams *cp = &s->channel_params[ch];
837 
838  s->quant_step_size[ch] = get_bits(gbp, 4);
839 
840  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
841  }
842 
843  for (ch = s->min_channel; ch <= s->max_channel; ch++)
844  if (get_bits1(gbp))
845  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
846  return ret;
847 
848  return 0;
849 }
850 
851 #define MSB_MASK(bits) (-1u << bits)
852 
856 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
857  unsigned int channel)
858 {
859  SubStream *s = &m->substream[substr];
860  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
862  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
863  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
864  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
865  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
866  unsigned int filter_shift = fir->shift;
867  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
868 
869  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
870  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
871 
872  m->dsp.mlp_filter_channel(firbuf, fircoeff,
873  fir->order, iir->order,
874  filter_shift, mask, s->blocksize,
875  &m->sample_buffer[s->blockpos][channel]);
876 
877  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
878  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
879 }
880 
884  unsigned int substr)
885 {
886  SubStream *s = &m->substream[substr];
887  unsigned int i, ch, expected_stream_pos = 0;
888  int ret;
889 
890  if (s->data_check_present) {
891  expected_stream_pos = get_bits_count(gbp);
892  expected_stream_pos += get_bits(gbp, 16);
894  "Substreams with VLC block size check info");
895  }
896 
897  if (s->blockpos + s->blocksize > m->access_unit_size) {
898  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
899  return AVERROR_INVALIDDATA;
900  }
901 
902  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
903  s->blocksize * sizeof(m->bypassed_lsbs[0]));
904 
905  for (i = 0; i < s->blocksize; i++)
906  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
907  return ret;
908 
909  for (ch = s->min_channel; ch <= s->max_channel; ch++)
910  filter_channel(m, substr, ch);
911 
912  s->blockpos += s->blocksize;
913 
914  if (s->data_check_present) {
915  if (get_bits_count(gbp) != expected_stream_pos)
916  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
917  skip_bits(gbp, 8);
918  }
919 
920  return 0;
921 }
922 
925 static const int8_t noise_table[256] = {
926  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
927  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
928  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
929  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
930  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
931  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
932  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
933  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
934  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
935  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
936  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
937  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
938  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
939  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
940  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
941  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
942 };
943 
954 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
955 {
956  SubStream *s = &m->substream[substr];
957  unsigned int i;
958  uint32_t seed = s->noisegen_seed;
959  unsigned int maxchan = s->max_matrix_channel;
960 
961  for (i = 0; i < s->blockpos; i++) {
962  uint16_t seed_shr7 = seed >> 7;
963  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
964  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
965 
966  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
967  }
968 
969  s->noisegen_seed = seed;
970 }
971 
974 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
975 {
976  SubStream *s = &m->substream[substr];
977  unsigned int i;
978  uint32_t seed = s->noisegen_seed;
979 
980  for (i = 0; i < m->access_unit_size_pow2; i++) {
981  uint8_t seed_shr15 = seed >> 15;
982  m->noise_buffer[i] = noise_table[seed_shr15];
983  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
984  }
985 
986  s->noisegen_seed = seed;
987 }
988 
989 
993 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
994 {
995  SubStream *s = &m->substream[substr];
996  unsigned int mat;
997  unsigned int maxchan;
998 
999  maxchan = s->max_matrix_channel;
1000  if (!s->noise_type) {
1001  generate_2_noise_channels(m, substr);
1002  maxchan += 2;
1003  } else {
1004  fill_noise_buffer(m, substr);
1005  }
1006 
1007  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1008  unsigned int dest_ch = s->matrix_out_ch[mat];
1009  m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1010  s->matrix_coeff[mat],
1011  &m->bypassed_lsbs[0][mat],
1012  m->noise_buffer,
1013  s->num_primitive_matrices - mat,
1014  dest_ch,
1015  s->blockpos,
1016  maxchan,
1017  s->matrix_noise_shift[mat],
1019  MSB_MASK(s->quant_step_size[dest_ch]));
1020  }
1021 }
1022 
1025 static int output_data(MLPDecodeContext *m, unsigned int substr,
1026  AVFrame *frame, int *got_frame_ptr)
1027 {
1028  AVCodecContext *avctx = m->avctx;
1029  SubStream *s = &m->substream[substr];
1030  int ret;
1031  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1032 
1033  if (m->avctx->channels != s->max_matrix_channel + 1) {
1034  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1035  return AVERROR_INVALIDDATA;
1036  }
1037 
1038  if (!s->blockpos) {
1039  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1040  return AVERROR_INVALIDDATA;
1041  }
1042 
1043  /* get output buffer */
1044  frame->nb_samples = s->blockpos;
1045  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1046  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1047  return ret;
1048  }
1050  s->blockpos,
1051  m->sample_buffer,
1052  frame->data[0],
1053  s->ch_assign,
1054  s->output_shift,
1055  s->max_matrix_channel,
1056  is32);
1057 
1058  /* Update matrix encoding side data */
1059  if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1060  return ret;
1061 
1062  *got_frame_ptr = 1;
1063 
1064  return 0;
1065 }
1066 
1071 static int read_access_unit(AVCodecContext *avctx, void* data,
1072  int *got_frame_ptr, AVPacket *avpkt)
1073 {
1074  const uint8_t *buf = avpkt->data;
1075  int buf_size = avpkt->size;
1076  MLPDecodeContext *m = avctx->priv_data;
1077  GetBitContext gb;
1078  unsigned int length, substr;
1079  unsigned int substream_start;
1080  unsigned int header_size = 4;
1081  unsigned int substr_header_size = 0;
1082  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1083  uint16_t substream_data_len[MAX_SUBSTREAMS];
1084  uint8_t parity_bits;
1085  int ret;
1086 
1087  if (buf_size < 4)
1088  return 0;
1089 
1090  length = (AV_RB16(buf) & 0xfff) * 2;
1091 
1092  if (length < 4 || length > buf_size)
1093  return AVERROR_INVALIDDATA;
1094 
1095  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1096 
1097  m->is_major_sync_unit = 0;
1098  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1099  if (read_major_sync(m, &gb) < 0)
1100  goto error;
1101  m->is_major_sync_unit = 1;
1102  header_size += m->major_sync_header_size;
1103  }
1104 
1105  if (!m->params_valid) {
1107  "Stream parameters not seen; skipping frame.\n");
1108  *got_frame_ptr = 0;
1109  return length;
1110  }
1111 
1112  substream_start = 0;
1113 
1114  for (substr = 0; substr < m->num_substreams; substr++) {
1115  int extraword_present, checkdata_present, end, nonrestart_substr;
1116 
1117  extraword_present = get_bits1(&gb);
1118  nonrestart_substr = get_bits1(&gb);
1119  checkdata_present = get_bits1(&gb);
1120  skip_bits1(&gb);
1121 
1122  end = get_bits(&gb, 12) * 2;
1123 
1124  substr_header_size += 2;
1125 
1126  if (extraword_present) {
1127  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1128  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1129  goto error;
1130  }
1131  skip_bits(&gb, 16);
1132  substr_header_size += 2;
1133  }
1134 
1135  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1136  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1137  goto error;
1138  }
1139 
1140  if (end + header_size + substr_header_size > length) {
1142  "Indicated length of substream %d data goes off end of "
1143  "packet.\n", substr);
1144  end = length - header_size - substr_header_size;
1145  }
1146 
1147  if (end < substream_start) {
1148  av_log(avctx, AV_LOG_ERROR,
1149  "Indicated end offset of substream %d data "
1150  "is smaller than calculated start offset.\n",
1151  substr);
1152  goto error;
1153  }
1154 
1155  if (substr > m->max_decoded_substream)
1156  continue;
1157 
1158  substream_parity_present[substr] = checkdata_present;
1159  substream_data_len[substr] = end - substream_start;
1160  substream_start = end;
1161  }
1162 
1163  parity_bits = ff_mlp_calculate_parity(buf, 4);
1164  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1165 
1166  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1167  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1168  goto error;
1169  }
1170 
1171  buf += header_size + substr_header_size;
1172 
1173  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1174  SubStream *s = &m->substream[substr];
1175  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1176 
1177  m->matrix_changed = 0;
1178  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1179 
1180  s->blockpos = 0;
1181  do {
1182  if (get_bits1(&gb)) {
1183  if (get_bits1(&gb)) {
1184  /* A restart header should be present. */
1185  if (read_restart_header(m, &gb, buf, substr) < 0)
1186  goto next_substr;
1187  s->restart_seen = 1;
1188  }
1189 
1190  if (!s->restart_seen)
1191  goto next_substr;
1192  if (read_decoding_params(m, &gb, substr) < 0)
1193  goto next_substr;
1194  }
1195 
1196  if (!s->restart_seen)
1197  goto next_substr;
1198 
1199  if ((ret = read_block_data(m, &gb, substr)) < 0)
1200  return ret;
1201 
1202  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1203  goto substream_length_mismatch;
1204 
1205  } while (!get_bits1(&gb));
1206 
1207  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1208 
1209  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1210  int shorten_by;
1211 
1212  if (get_bits(&gb, 16) != 0xD234)
1213  return AVERROR_INVALIDDATA;
1214 
1215  shorten_by = get_bits(&gb, 16);
1216  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1217  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1218  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1219  return AVERROR_INVALIDDATA;
1220 
1221  if (substr == m->max_decoded_substream)
1222  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1223  }
1224 
1225  if (substream_parity_present[substr]) {
1226  uint8_t parity, checksum;
1227 
1228  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1229  goto substream_length_mismatch;
1230 
1231  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1232  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1233 
1234  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1235  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1236  if ( get_bits(&gb, 8) != checksum)
1237  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1238  }
1239 
1240  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1241  goto substream_length_mismatch;
1242 
1243 next_substr:
1244  if (!s->restart_seen)
1246  "No restart header present in substream %d.\n", substr);
1247 
1248  buf += substream_data_len[substr];
1249  }
1250 
1252 
1253  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1254  return ret;
1255 
1256  return length;
1257 
1258 substream_length_mismatch:
1259  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1260  return AVERROR_INVALIDDATA;
1261 
1262 error:
1263  m->params_valid = 0;
1264  return AVERROR_INVALIDDATA;
1265 }
1266 
1268  .name = "mlp",
1269  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1270  .type = AVMEDIA_TYPE_AUDIO,
1271  .id = AV_CODEC_ID_MLP,
1272  .priv_data_size = sizeof(MLPDecodeContext),
1273  .init = mlp_decode_init,
1275  .capabilities = AV_CODEC_CAP_DR1,
1276 };
1277 
1278 #if CONFIG_TRUEHD_DECODER
1279 AVCodec ff_truehd_decoder = {
1280  .name = "truehd",
1281  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1282  .type = AVMEDIA_TYPE_AUDIO,
1283  .id = AV_CODEC_ID_TRUEHD,
1284  .priv_data_size = sizeof(MLPDecodeContext),
1285  .init = mlp_decode_init,
1287  .capabilities = AV_CODEC_CAP_DR1,
1288 };
1289 #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:164
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:344
int major_sync_header_size
Size of the major sync unit, in bytes.
Definition: mlpdec.c:136
void(* mlp_rematrix_channel)(int32_t *samples, const int32_t *coeffs, const uint8_t *bypassed_lsbs, const int8_t *noise_buffer, int index, unsigned int dest_ch, uint16_t blockpos, unsigned int maxchan, int matrix_noise_shift, int access_unit_size_pow2, int32_t mask)
Definition: mlpdsp.h:54
#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:140
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:796
int32_t(*(* mlp_select_pack_output)(uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32))(int32_t
Definition: mlpdsp.h:65
#define AV_CH_TOP_FRONT_RIGHT
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
Definition: mlpdec.c:157
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
Definition: mlpdec.c:85
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
Definition: mlpdec.c:954
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible. ...
Definition: mlpdec.c:139
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:57
#define AV_CH_TOP_FRONT_LEFT
int num_substreams
Number of substreams within stream.
Definition: mlp_parser.h:60
#define AV_CH_TOP_FRONT_CENTER
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
#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:71
#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:50
#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:122
#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:2776
AVCodec.
Definition: avcodec.h:3120
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:214
int access_unit_size
Number of samples per coded frame.
Definition: mlp_parser.h:54
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
Definition: mlpdec.c:108
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:92
#define PARAM_OUTSHIFT
Definition: mlpdec.c:88
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:154
#define AV_CH_WIDE_LEFT
uint8_t bits
Definition: crc.c:252
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2160
uint8_t
#define av_cold
Definition: attributes.h:66
MLPDSPContext dsp
Definition: mlpdec.c:161
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 streams ("2-channel presentation")
Definition: mlp_parser.h:43
#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:67
#define AV_CH_WIDE_RIGHT
#define AV_CH_LOW_FREQUENCY
AVCodec ff_mlp_decoder
Definition: mlpdec.c:1267
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:182
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
Definition: mlpdec.c:974
#define PARAM_FIR
Definition: mlpdec.c:90
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:53
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:61
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:600
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:444
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:675
signed 32 bits
Definition: samplefmt.h:64
#define PARAM_BLOCKSIZE
Definition: mlpdec.c:86
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:1071
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:63
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:124
ChannelParams channel_params[MAX_CHANNELS]
Channel coding parameters for channels in the substream.
Definition: mlpdec.c:74
#define MAX_MATRIX_CHANNEL_TRUEHD
Definition: mlp.h:31
int channel_modifier_thd_stream2
Channel modifier for substream 2 of TrueHD streams ("8-channel presentation")
Definition: mlp_parser.h:45
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:180
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:158
uint8_t quant_step_size[MAX_CHANNELS]
Left shift to apply to Huffman-decoded residuals.
Definition: mlpdec.c:114
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
static VLC huff_vlc[3]
Definition: mlpdec.c:194
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:87
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
#define PARAM_QUANTSTEP
Definition: mlpdec.c:89
int32_t(* mlp_pack_output)(int32_t lossless_check_data, uint16_t blockpos, int32_t(*sample_buffer)[MAX_CHANNELS], void *data, uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32)
Definition: mlpdsp.h:69
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:142
Definition: vlc.h:26
uint8_t max_matrix_channel
The number of channels input into the rematrix stage.
Definition: mlpdec.c:65
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2203
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:272
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:66
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:50
uint16_t noise_type
restart header data
Definition: mlpdec.c:58
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:738
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
int32_t
int32_t lossless_check_data
Running XOR of all output samples.
Definition: mlpdec.c:125
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:493
#define AV_CH_FRONT_LEFT_OF_CENTER
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:155
#define AV_CH_FRONT_CENTER
uint8_t lsb_bypass[MAX_MATRICES]
Whether the LSBs of the matrix output are encoded in the bitstream.
Definition: mlpdec.c:106
int32_t coeff[NUM_FILTERS][MAX_FIR_ORDER]
Definition: mlp.h:84
static volatile int checksum
Definition: adler32.c:27
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:236
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:148
#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:161
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:215
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2172
#define AV_LOG_INFO
Standard information.
Definition: log.h:135
int access_unit_size_pow2
Next power of two above number of samples per frame.
Definition: mlp_parser.h:55
uint16_t blocksize
number of PCM samples in current audio block
Definition: mlpdec.c:117
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:82
int32_t state[MAX_FIR_ORDER]
Definition: mlp.h:78
enum AVCodecID codec_id
Definition: avcodec.h:1426
int sample_rate
samples per second
Definition: avcodec.h:2152
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
Definition: mlpdsp.c:128
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
Definition: mlpdec.c:47
SubStream substream[MAX_SUBSTREAMS]
Definition: mlpdec.c:152
uint8_t order
number of taps in filter
Definition: mlp.h:75
int channel_modifier_thd_stream1
Channel modifier for substream 1 of TrueHD streams ("6-channel presentation")
Definition: mlp_parser.h:44
main external API structure.
Definition: avcodec.h:1409
#define AV_CH_FRONT_LEFT
int is_major_sync_unit
Current access unit being read has a major sync.
Definition: mlpdec.c:133
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:589
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:159
filter data
Definition: mlp.h:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:292
#define IIR
Definition: mlp.h:71
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:259
AVCodecContext * avctx
Definition: mlpdec.c:130
int index
Definition: gxfenc.c:72
uint64_t ch_layout
The channel layout for this substream.
Definition: mlpdec.c:69
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
Apply the channel matrices in turn to reconstruct the original audio samples.
Definition: mlpdec.c:993
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:883
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:362
uint8_t num_primitive_matrices
matrix data
Definition: mlpdec.c:100
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
Definition: mlpdec.c:145
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:925
#define MAX_CHANNELS
Definition: aac.h:42
#define VLC_STATIC_SIZE
Definition: mlpdec.c:48
#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:291
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:119
int group2_bits
Bit depth of the second substream (MLP only)
Definition: mlp_parser.h:38
#define AV_CH_BACK_CENTER
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
#define AV_CH_SIDE_RIGHT
#define MSB_MASK(bits)
Definition: mlpdec.c:851
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:198
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:79
common internal api header.
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:103
signed 16 bits
Definition: samplefmt.h:63
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:150
uint64_t channel_layout_thd_stream1
Channel layout for substream 1 of TrueHD streams ("6-channel presentation")
Definition: mlp_parser.h:51
#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:52
int header_size
Size of the major sync header, in bytes.
Definition: mlp_parser.h:35
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:145
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
void * priv_data
Definition: avcodec.h:1451
uint8_t matrix_noise_shift[MAX_MATRICES]
Left shift to apply to noise values in 0x31eb substreams.
Definition: mlpdec.c:110
uint8_t noise_shift
The left shift applied to random noise in 0x31ea substreams.
Definition: mlpdec.c:77
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:1025
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:856
sample data coding information
Definition: mlp.h:82
int channels
number of audio channels
Definition: avcodec.h:2153
int group1_bits
The bit depth of the first substream.
Definition: mlp_parser.h:37
static uint8_t tmp[8]
Definition: des.c:38
av_cold void ff_mlp_init_crc(void)
Definition: mlp.c:54
#define AV_CH_SURROUND_DIRECT_LEFT
#define AV_CH_FRONT_RIGHT
#define PARAM_IIR
Definition: mlpdec.c:91
#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:40
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:2210
#define PARAM_PRESENCE
Definition: mlpdec.c:93
This structure stores compressed data.
Definition: avcodec.h:1323
int group2_samplerate
Sample rate of second substream (MLP only)
Definition: mlp_parser.h:41
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
#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