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 
148 
150 
153 
157 
160 
161 static const uint64_t thd_channel_order[] = {
163  AV_CH_FRONT_CENTER, // C
164  AV_CH_LOW_FREQUENCY, // LFE
169  AV_CH_BACK_CENTER, // Cs
170  AV_CH_TOP_CENTER, // Ts
173  AV_CH_TOP_FRONT_CENTER, // Cvh
174  AV_CH_LOW_FREQUENCY_2, // LFE2
175 };
176 
177 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
178  int index)
179 {
180  int i;
181 
182  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
183  return 0;
184 
185  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
186  if (channel_layout & thd_channel_order[i] && !index--)
187  return thd_channel_order[i];
188  return 0;
189 }
190 
191 static VLC huff_vlc[3];
192 
195 static av_cold void init_static(void)
196 {
197  if (!huff_vlc[0].bits) {
198  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
199  &ff_mlp_huffman_tables[0][0][1], 2, 1,
200  &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
201  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
202  &ff_mlp_huffman_tables[1][0][1], 2, 1,
203  &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
204  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
205  &ff_mlp_huffman_tables[2][0][1], 2, 1,
206  &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
207  }
208 
209  ff_mlp_init_crc();
210 }
211 
213  unsigned int substr, unsigned int ch)
214 {
215  SubStream *s = &m->substream[substr];
216  ChannelParams *cp = &s->channel_params[ch];
217  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
218  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
219  int32_t sign_huff_offset = cp->huff_offset;
220 
221  if (cp->codebook > 0)
222  sign_huff_offset -= 7 << lsb_bits;
223 
224  if (sign_shift >= 0)
225  sign_huff_offset -= 1 << sign_shift;
226 
227  return sign_huff_offset;
228 }
229 
234  unsigned int substr, unsigned int pos)
235 {
236  SubStream *s = &m->substream[substr];
237  unsigned int mat, channel;
238 
239  for (mat = 0; mat < s->num_primitive_matrices; mat++)
240  if (s->lsb_bypass[mat])
241  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
242 
243  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
244  ChannelParams *cp = &s->channel_params[channel];
245  int codebook = cp->codebook;
246  int quant_step_size = s->quant_step_size[channel];
247  int lsb_bits = cp->huff_lsbs - quant_step_size;
248  int result = 0;
249 
250  if (codebook > 0)
251  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
252  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
253 
254  if (result < 0)
255  return AVERROR_INVALIDDATA;
256 
257  if (lsb_bits > 0)
258  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
259 
260  result += cp->sign_huff_offset;
261  result <<= quant_step_size;
262 
263  m->sample_buffer[pos + s->blockpos][channel] = result;
264  }
265 
266  return 0;
267 }
268 
270 {
271  MLPDecodeContext *m = avctx->priv_data;
272  int substr;
273 
274  init_static();
275  m->avctx = avctx;
276  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
277  m->substream[substr].lossless_check_data = 0xffffffff;
278  ff_mlpdsp_init(&m->dsp);
279 
280  return 0;
281 }
282 
289 {
290  MLPHeaderInfo mh;
291  int substr, ret;
292 
293  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
294  return ret;
295 
296  if (mh.group1_bits == 0) {
297  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
298  return AVERROR_INVALIDDATA;
299  }
300  if (mh.group2_bits > mh.group1_bits) {
302  "Channel group 2 cannot have more bits per sample than group 1.\n");
303  return AVERROR_INVALIDDATA;
304  }
305 
308  "Channel groups with differing sample rates are not currently supported.\n");
309  return AVERROR_INVALIDDATA;
310  }
311 
312  if (mh.group1_samplerate == 0) {
313  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
314  return AVERROR_INVALIDDATA;
315  }
318  "Sampling rate %d is greater than the supported maximum (%d).\n",
320  return AVERROR_INVALIDDATA;
321  }
322  if (mh.access_unit_size > MAX_BLOCKSIZE) {
324  "Block size %d is greater than the supported maximum (%d).\n",
326  return AVERROR_INVALIDDATA;
327  }
330  "Block size pow2 %d is greater than the supported maximum (%d).\n",
332  return AVERROR_INVALIDDATA;
333  }
334 
335  if (mh.num_substreams == 0)
336  return AVERROR_INVALIDDATA;
337  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
338  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
339  return AVERROR_INVALIDDATA;
340  }
341  if (mh.num_substreams > MAX_SUBSTREAMS) {
343  "%d substreams (more than the "
344  "maximum supported by the decoder)",
345  mh.num_substreams);
346  return AVERROR_PATCHWELCOME;
347  }
348 
351 
354 
357 
359  if (mh.group1_bits > 16)
361  else
367 
368  m->params_valid = 1;
369  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
370  m->substream[substr].restart_seen = 0;
371 
372  /* Set the layout for each substream. When there's more than one, the first
373  * substream is Stereo. Subsequent substreams' layouts are indicated in the
374  * major sync. */
375  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
376  if ((substr = (mh.num_substreams > 1)))
378  m->substream[substr].ch_layout = mh.channel_layout_mlp;
379  } else {
380  if ((substr = (mh.num_substreams > 1)))
382  if (mh.num_substreams > 2)
385  else
388  }
389 
390  /* Parse the TrueHD decoder channel modifiers and set each substream's
391  * AVMatrixEncoding accordingly.
392  *
393  * The meaning of the modifiers depends on the channel layout:
394  *
395  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
396  *
397  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
398  *
399  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
400  * layouts with an Ls/Rs channel pair
401  */
402  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
405  if (mh.num_substreams > 2 &&
410 
411  if (mh.num_substreams > 1 &&
416 
417  if (mh.num_substreams > 0)
418  switch (mh.channel_modifier_thd_stream0) {
421  break;
424  break;
425  default:
426  break;
427  }
428  }
429 
430  return 0;
431 }
432 
438  const uint8_t *buf, unsigned int substr)
439 {
440  SubStream *s = &m->substream[substr];
441  unsigned int ch;
442  int sync_word, tmp;
443  uint8_t checksum;
444  uint8_t lossless_check;
445  int start_count = get_bits_count(gbp);
446  int min_channel, max_channel, max_matrix_channel;
447  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
450 
451  sync_word = get_bits(gbp, 13);
452 
453  if (sync_word != 0x31ea >> 1) {
455  "restart header sync incorrect (got 0x%04x)\n", sync_word);
456  return AVERROR_INVALIDDATA;
457  }
458 
459  s->noise_type = get_bits1(gbp);
460 
461  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
462  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
463  return AVERROR_INVALIDDATA;
464  }
465 
466  skip_bits(gbp, 16); /* Output timestamp */
467 
468  min_channel = get_bits(gbp, 4);
469  max_channel = get_bits(gbp, 4);
470  max_matrix_channel = get_bits(gbp, 4);
471 
472  if (max_matrix_channel > std_max_matrix_channel) {
474  "Max matrix channel cannot be greater than %d.\n",
475  max_matrix_channel);
476  return AVERROR_INVALIDDATA;
477  }
478 
479  if (max_channel != max_matrix_channel) {
481  "Max channel must be equal max matrix channel.\n");
482  return AVERROR_INVALIDDATA;
483  }
484 
485  /* This should happen for TrueHD streams with >6 channels and MLP's noise
486  * type. It is not yet known if this is allowed. */
489  "%d channels (more than the "
490  "maximum supported by the decoder)",
491  s->max_channel + 2);
492  return AVERROR_PATCHWELCOME;
493  }
494 
495  if (min_channel > max_channel) {
497  "Substream min channel cannot be greater than max channel.\n");
498  return AVERROR_INVALIDDATA;
499  }
500 
501  s->min_channel = min_channel;
502  s->max_channel = max_channel;
503  s->max_matrix_channel = max_matrix_channel;
504 
505 #if FF_API_REQUEST_CHANNELS
507  if (m->avctx->request_channels > 0 &&
508  m->avctx->request_channels <= s->max_channel + 1 &&
509  m->max_decoded_substream > substr) {
511  "Extracting %d-channel downmix from substream %d. "
512  "Further substreams will be skipped.\n",
513  s->max_channel + 1, substr);
514  m->max_decoded_substream = substr;
515  } else
517 #endif
521  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
522  "Further substreams will be skipped.\n",
523  s->max_channel + 1, s->ch_layout, substr);
524  m->max_decoded_substream = substr;
525  }
526 
527  s->noise_shift = get_bits(gbp, 4);
528  s->noisegen_seed = get_bits(gbp, 23);
529 
530  skip_bits(gbp, 19);
531 
532  s->data_check_present = get_bits1(gbp);
533  lossless_check = get_bits(gbp, 8);
534  if (substr == m->max_decoded_substream
535  && s->lossless_check_data != 0xffffffff) {
537  if (tmp != lossless_check)
539  "Lossless check failed - expected %02x, calculated %02x.\n",
540  lossless_check, tmp);
541  }
542 
543  skip_bits(gbp, 16);
544 
545  memset(s->ch_assign, 0, sizeof(s->ch_assign));
546 
547  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
548  int ch_assign = get_bits(gbp, 6);
549  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
550  uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
551  ch_assign);
553  channel);
554  }
555  if (ch_assign > s->max_matrix_channel) {
557  "Assignment of matrix channel %d to invalid output channel %d",
558  ch, ch_assign);
559  return AVERROR_PATCHWELCOME;
560  }
561  s->ch_assign[ch_assign] = ch;
562  }
563 
564  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
565 
566  if (checksum != get_bits(gbp, 8))
567  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
568 
569  /* Set default decoding parameters. */
570  s->param_presence_flags = 0xff;
571  s->num_primitive_matrices = 0;
572  s->blocksize = 8;
573  s->lossless_check_data = 0;
574 
575  memset(s->output_shift , 0, sizeof(s->output_shift ));
576  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
577 
578  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
579  ChannelParams *cp = &s->channel_params[ch];
580  cp->filter_params[FIR].order = 0;
581  cp->filter_params[IIR].order = 0;
582  cp->filter_params[FIR].shift = 0;
583  cp->filter_params[IIR].shift = 0;
584 
585  /* Default audio coding is 24-bit raw PCM. */
586  cp->huff_offset = 0;
587  cp->sign_huff_offset = (-1) << 23;
588  cp->codebook = 0;
589  cp->huff_lsbs = 24;
590  }
591 
592  if (substr == m->max_decoded_substream) {
593  m->avctx->channels = s->max_matrix_channel + 1;
594  m->avctx->channel_layout = s->ch_layout;
596  s->output_shift,
599  }
600 
601  return 0;
602 }
603 
607  unsigned int substr, unsigned int channel,
608  unsigned int filter)
609 {
610  SubStream *s = &m->substream[substr];
611  FilterParams *fp = &s->channel_params[channel].filter_params[filter];
612  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
613  const char fchar = filter ? 'I' : 'F';
614  int i, order;
615 
616  // Filter is 0 for FIR, 1 for IIR.
617  assert(filter < 2);
618 
619  if (m->filter_changed[channel][filter]++ > 1) {
620  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
621  return AVERROR_INVALIDDATA;
622  }
623 
624  order = get_bits(gbp, 4);
625  if (order > max_order) {
627  "%cIR filter order %d is greater than maximum %d.\n",
628  fchar, order, max_order);
629  return AVERROR_INVALIDDATA;
630  }
631  fp->order = order;
632 
633  if (order > 0) {
634  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
635  int coeff_bits, coeff_shift;
636 
637  fp->shift = get_bits(gbp, 4);
638 
639  coeff_bits = get_bits(gbp, 5);
640  coeff_shift = get_bits(gbp, 3);
641  if (coeff_bits < 1 || coeff_bits > 16) {
643  "%cIR filter coeff_bits must be between 1 and 16.\n",
644  fchar);
645  return AVERROR_INVALIDDATA;
646  }
647  if (coeff_bits + coeff_shift > 16) {
649  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
650  fchar);
651  return AVERROR_INVALIDDATA;
652  }
653 
654  for (i = 0; i < order; i++)
655  fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
656 
657  if (get_bits1(gbp)) {
658  int state_bits, state_shift;
659 
660  if (filter == FIR) {
662  "FIR filter has state data specified.\n");
663  return AVERROR_INVALIDDATA;
664  }
665 
666  state_bits = get_bits(gbp, 4);
667  state_shift = get_bits(gbp, 4);
668 
669  /* TODO: Check validity of state data. */
670 
671  for (i = 0; i < order; i++)
672  fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
673  }
674  }
675 
676  return 0;
677 }
678 
681 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
682 {
683  SubStream *s = &m->substream[substr];
684  unsigned int mat, ch;
685  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
688 
689  if (m->matrix_changed++ > 1) {
690  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
691  return AVERROR_INVALIDDATA;
692  }
693 
694  s->num_primitive_matrices = get_bits(gbp, 4);
695 
696  if (s->num_primitive_matrices > max_primitive_matrices) {
698  "Number of primitive matrices cannot be greater than %d.\n",
699  max_primitive_matrices);
700  return AVERROR_INVALIDDATA;
701  }
702 
703  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
704  int frac_bits, max_chan;
705  s->matrix_out_ch[mat] = get_bits(gbp, 4);
706  frac_bits = get_bits(gbp, 4);
707  s->lsb_bypass [mat] = get_bits1(gbp);
708 
709  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
711  "Invalid channel %d specified as output from matrix.\n",
712  s->matrix_out_ch[mat]);
713  return AVERROR_INVALIDDATA;
714  }
715  if (frac_bits > 14) {
717  "Too many fractional bits specified.\n");
718  return AVERROR_INVALIDDATA;
719  }
720 
721  max_chan = s->max_matrix_channel;
722  if (!s->noise_type)
723  max_chan+=2;
724 
725  for (ch = 0; ch <= max_chan; ch++) {
726  int coeff_val = 0;
727  if (get_bits1(gbp))
728  coeff_val = get_sbits(gbp, frac_bits + 2);
729 
730  s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
731  }
732 
733  if (s->noise_type)
734  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
735  else
736  s->matrix_noise_shift[mat] = 0;
737  }
738 
739  return 0;
740 }
741 
744 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
745  GetBitContext *gbp, unsigned int ch)
746 {
747  SubStream *s = &m->substream[substr];
748  ChannelParams *cp = &s->channel_params[ch];
749  FilterParams *fir = &cp->filter_params[FIR];
750  FilterParams *iir = &cp->filter_params[IIR];
751  int ret;
752 
754  if (get_bits1(gbp))
755  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
756  return ret;
757 
759  if (get_bits1(gbp))
760  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
761  return ret;
762 
763  if (fir->order + iir->order > 8) {
764  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
765  return AVERROR_INVALIDDATA;
766  }
767 
768  if (fir->order && iir->order &&
769  fir->shift != iir->shift) {
771  "FIR and IIR filters must use the same precision.\n");
772  return AVERROR_INVALIDDATA;
773  }
774  /* The FIR and IIR filters must have the same precision.
775  * To simplify the filtering code, only the precision of the
776  * FIR filter is considered. If only the IIR filter is employed,
777  * the FIR filter precision is set to that of the IIR filter, so
778  * that the filtering code can use it. */
779  if (!fir->order && iir->order)
780  fir->shift = iir->shift;
781 
783  if (get_bits1(gbp))
784  cp->huff_offset = get_sbits(gbp, 15);
785 
786  cp->codebook = get_bits(gbp, 2);
787  cp->huff_lsbs = get_bits(gbp, 5);
788 
789  if (cp->huff_lsbs > 24) {
790  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
791  return AVERROR_INVALIDDATA;
792  }
793 
794  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
795 
796  return 0;
797 }
798 
803  unsigned int substr)
804 {
805  SubStream *s = &m->substream[substr];
806  unsigned int ch;
807  int ret;
808 
810  if (get_bits1(gbp))
811  s->param_presence_flags = get_bits(gbp, 8);
812 
814  if (get_bits1(gbp)) {
815  s->blocksize = get_bits(gbp, 9);
816  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
817  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
818  s->blocksize = 0;
819  return AVERROR_INVALIDDATA;
820  }
821  }
822 
824  if (get_bits1(gbp))
825  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
826  return ret;
827 
829  if (get_bits1(gbp)) {
830  for (ch = 0; ch <= s->max_matrix_channel; ch++)
831  s->output_shift[ch] = get_sbits(gbp, 4);
832  if (substr == m->max_decoded_substream)
834  s->output_shift,
837  }
838 
840  if (get_bits1(gbp))
841  for (ch = 0; ch <= s->max_channel; ch++) {
842  ChannelParams *cp = &s->channel_params[ch];
843 
844  s->quant_step_size[ch] = get_bits(gbp, 4);
845 
846  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
847  }
848 
849  for (ch = s->min_channel; ch <= s->max_channel; ch++)
850  if (get_bits1(gbp))
851  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
852  return ret;
853 
854  return 0;
855 }
856 
857 #define MSB_MASK(bits) (-1u << bits)
858 
862 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
863  unsigned int channel)
864 {
865  SubStream *s = &m->substream[substr];
866  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
868  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
869  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
870  FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
871  FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
872  unsigned int filter_shift = fir->shift;
873  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
874 
875  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
876  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
877 
878  m->dsp.mlp_filter_channel(firbuf, fircoeff,
879  fir->order, iir->order,
880  filter_shift, mask, s->blocksize,
881  &m->sample_buffer[s->blockpos][channel]);
882 
883  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
884  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
885 }
886 
890  unsigned int substr)
891 {
892  SubStream *s = &m->substream[substr];
893  unsigned int i, ch, expected_stream_pos = 0;
894  int ret;
895 
896  if (s->data_check_present) {
897  expected_stream_pos = get_bits_count(gbp);
898  expected_stream_pos += get_bits(gbp, 16);
900  "Substreams with VLC block size check info");
901  }
902 
903  if (s->blockpos + s->blocksize > m->access_unit_size) {
904  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
905  return AVERROR_INVALIDDATA;
906  }
907 
908  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
909  s->blocksize * sizeof(m->bypassed_lsbs[0]));
910 
911  for (i = 0; i < s->blocksize; i++)
912  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
913  return ret;
914 
915  for (ch = s->min_channel; ch <= s->max_channel; ch++)
916  filter_channel(m, substr, ch);
917 
918  s->blockpos += s->blocksize;
919 
920  if (s->data_check_present) {
921  if (get_bits_count(gbp) != expected_stream_pos)
922  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
923  skip_bits(gbp, 8);
924  }
925 
926  return 0;
927 }
928 
931 static const int8_t noise_table[256] = {
932  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
933  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
934  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
935  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
936  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
937  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
938  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
939  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
940  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
941  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
942  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
943  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
944  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
945  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
946  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
947  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
948 };
949 
960 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
961 {
962  SubStream *s = &m->substream[substr];
963  unsigned int i;
964  uint32_t seed = s->noisegen_seed;
965  unsigned int maxchan = s->max_matrix_channel;
966 
967  for (i = 0; i < s->blockpos; i++) {
968  uint16_t seed_shr7 = seed >> 7;
969  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
970  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
971 
972  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
973  }
974 
975  s->noisegen_seed = seed;
976 }
977 
980 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
981 {
982  SubStream *s = &m->substream[substr];
983  unsigned int i;
984  uint32_t seed = s->noisegen_seed;
985 
986  for (i = 0; i < m->access_unit_size_pow2; i++) {
987  uint8_t seed_shr15 = seed >> 15;
988  m->noise_buffer[i] = noise_table[seed_shr15];
989  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
990  }
991 
992  s->noisegen_seed = seed;
993 }
994 
995 
999 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1000 {
1001  SubStream *s = &m->substream[substr];
1002  unsigned int mat;
1003  unsigned int maxchan;
1004 
1005  maxchan = s->max_matrix_channel;
1006  if (!s->noise_type) {
1007  generate_2_noise_channels(m, substr);
1008  maxchan += 2;
1009  } else {
1010  fill_noise_buffer(m, substr);
1011  }
1012 
1013  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1014  unsigned int dest_ch = s->matrix_out_ch[mat];
1015  m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1016  s->matrix_coeff[mat],
1017  &m->bypassed_lsbs[0][mat],
1018  m->noise_buffer,
1019  s->num_primitive_matrices - mat,
1020  dest_ch,
1021  s->blockpos,
1022  maxchan,
1023  s->matrix_noise_shift[mat],
1025  MSB_MASK(s->quant_step_size[dest_ch]));
1026  }
1027 }
1028 
1031 static int output_data(MLPDecodeContext *m, unsigned int substr,
1032  AVFrame *frame, int *got_frame_ptr)
1033 {
1034  AVCodecContext *avctx = m->avctx;
1035  SubStream *s = &m->substream[substr];
1036  int ret;
1037  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1038 
1039  if (m->avctx->channels != s->max_matrix_channel + 1) {
1040  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1041  return AVERROR_INVALIDDATA;
1042  }
1043 
1044  if (!s->blockpos) {
1045  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1046  return AVERROR_INVALIDDATA;
1047  }
1048 
1049  /* get output buffer */
1050  frame->nb_samples = s->blockpos;
1051  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1052  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1053  return ret;
1054  }
1056  s->blockpos,
1057  m->sample_buffer,
1058  frame->data[0],
1059  s->ch_assign,
1060  s->output_shift,
1061  s->max_matrix_channel,
1062  is32);
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:161
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:348
#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:135
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:802
#define AV_CH_TOP_FRONT_RIGHT
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
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
Definition: mlpdec.c:154
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:960
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible. ...
Definition: mlpdec.c:136
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:1838
#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:968
#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: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: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:2508
AVCodec.
Definition: avcodec.h:2790
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:108
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:92
#define PARAM_OUTSHIFT
Definition: mlpdec.c:88
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
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:151
#define AV_CH_WIDE_LEFT
uint8_t bits
Definition: crc.c:251
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1793
uint8_t
#define av_cold
Definition: attributes.h:66
MLPDSPContext dsp
Definition: mlpdec.c:158
#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:67
#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:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:967
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:980
#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:606
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:437
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:681
signed 32 bits
Definition: samplefmt.h:65
#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: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: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:123
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 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:177
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:155
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:150
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
static VLC huff_vlc[3]
Definition: mlpdec.c:191
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
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:168
const char * name
Name of the codec implementation.
Definition: avcodec.h:2797
#define PARAM_QUANTSTEP
Definition: mlpdec.c:89
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:139
Definition: get_bits.h:64
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:1846
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:269
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:58
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:744
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
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:522
#define AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_FRONT_CENTER
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:152
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 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:233
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:145
#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:160
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:212
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1805
#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: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:1061
int sample_rate
samples per second
Definition: avcodec.h:1785
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:149
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:1044
#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:603
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:156
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: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:999
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:889
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:100
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
Definition: mlpdec.c:142
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:931
#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:288
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:37
#define AV_CH_BACK_CENTER
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
#define AV_CH_SIDE_RIGHT
#define MSB_MASK(bits)
Definition: mlpdec.c:857
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:195
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:79
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:76
common internal api header.
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:103
signed 16 bits
Definition: samplefmt.h:64
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:147
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:499
void * priv_data
Definition: avcodec.h:1086
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:1031
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:77
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:862
sample data coding information
Definition: mlp.h:82
int channels
number of audio channels
Definition: avcodec.h:1786
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:50
#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:39
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1853
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
#define PARAM_PRESENCE
Definition: mlpdec.c:93
This structure stores compressed data.
Definition: avcodec.h:944
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:179
#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