FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * MLP decoder
25  */
26 
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 
42 /** number of bits used for VLC lookup - longest Huffman code is 9 */
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 {
52  /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
54 
55  //@{
56  /** restart header data */
57  /// The type of noise to be used in the rematrix stage.
58  uint16_t noise_type;
59 
60  /// The index of the first channel coded in this substream.
62  /// The index of the last channel coded in this substream.
64  /// The number of channels input into the rematrix stage.
66  /// For each channel output by the matrix, the output channel to map it to
68  /// The channel layout for this substream
69  uint64_t mask;
70  /// The matrix encoding mode for this substream
72 
73  /// Channel coding parameters for channels in the substream
75 
76  /// The left shift applied to random noise in 0x31ea substreams.
78  /// The current seed value for the pseudorandom noise generator(s).
79  uint32_t noisegen_seed;
80 
81  /// Set if the substream contains extra info to check the size of VLC blocks.
83 
84  /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
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 
96  //@{
97  /** matrix data */
98 
99  /// Number of matrices to be applied.
101 
102  /// matrix output channel
104 
105  /// Whether the LSBs of the matrix output are encoded in the bitstream.
107  /// Matrix coefficients, stored as 2.14 fixed point.
109  /// Left shift to apply to noise values in 0x31eb substreams.
111  //@}
112 
113  /// Left shift to apply to Huffman-decoded residuals.
115 
116  /// number of PCM samples in current audio block
117  uint16_t blocksize;
118  /// Number of PCM samples decoded so far in this frame.
119  uint16_t blockpos;
120 
121  /// Left shift to apply to decoded PCM values to get final 24-bit output.
123 
124  /// Running XOR of all output samples.
126 
127 } SubStream;
128 
129 typedef struct MLPDecodeContext {
131 
132  /// Current access unit being read has a major sync.
134 
135  /// Size of the major sync unit, in bytes
137 
138  /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
140 
141  /// Number of substreams contained within this stream.
143 
144  /// Index of the last substream to decode - further substreams are skipped.
146 
147  /// Stream needs channel reordering to comply with FFmpeg's channel order
149 
150  /// number of PCM samples contained in each frame
152  /// next power of two above the number of samples in each frame
154 
156 
159 
163 
166 
167 static const uint64_t thd_channel_order[] = {
169  AV_CH_FRONT_CENTER, // C
170  AV_CH_LOW_FREQUENCY, // LFE
175  AV_CH_BACK_CENTER, // Cs
176  AV_CH_TOP_CENTER, // Ts
179  AV_CH_TOP_FRONT_CENTER, // Cvh
180  AV_CH_LOW_FREQUENCY_2, // LFE2
181 };
182 
183 static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
184 {
185  return channel_layout && ((channel_layout & mask) == channel_layout);
186 }
187 
188 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
189  int index)
190 {
191  int i;
192 
193  if (av_get_channel_layout_nb_channels(channel_layout) <= index)
194  return 0;
195 
196  for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
197  if (channel_layout & thd_channel_order[i] && !index--)
198  return thd_channel_order[i];
199  return 0;
200 }
201 
202 static VLC huff_vlc[3];
203 
204 /** Initialize static data, constant between all invocations of the codec. */
205 
206 static av_cold void init_static(void)
207 {
208  if (!huff_vlc[0].bits) {
209  INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
210  &ff_mlp_huffman_tables[0][0][1], 2, 1,
211  &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
212  INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
213  &ff_mlp_huffman_tables[1][0][1], 2, 1,
214  &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
215  INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
216  &ff_mlp_huffman_tables[2][0][1], 2, 1,
217  &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
218  }
219 
220  ff_mlp_init_crc();
221 }
222 
224  unsigned int substr, unsigned int ch)
225 {
226  SubStream *s = &m->substream[substr];
227  ChannelParams *cp = &s->channel_params[ch];
228  int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
229  int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
230  int32_t sign_huff_offset = cp->huff_offset;
231 
232  if (cp->codebook > 0)
233  sign_huff_offset -= 7 << lsb_bits;
234 
235  if (sign_shift >= 0)
236  sign_huff_offset -= 1 << sign_shift;
237 
238  return sign_huff_offset;
239 }
240 
241 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
242  * and plain LSBs. */
243 
245  unsigned int substr, unsigned int pos)
246 {
247  SubStream *s = &m->substream[substr];
248  unsigned int mat, channel;
249 
250  for (mat = 0; mat < s->num_primitive_matrices; mat++)
251  if (s->lsb_bypass[mat])
252  m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
253 
254  for (channel = s->min_channel; channel <= s->max_channel; channel++) {
256  int codebook = cp->codebook;
257  int quant_step_size = s->quant_step_size[channel];
258  int lsb_bits = cp->huff_lsbs - quant_step_size;
259  int result = 0;
260 
261  if (codebook > 0)
262  result = get_vlc2(gbp, huff_vlc[codebook-1].table,
263  VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
264 
265  if (result < 0)
266  return AVERROR_INVALIDDATA;
267 
268  if (lsb_bits > 0)
269  result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
270 
271  result += cp->sign_huff_offset;
272  result *= 1 << quant_step_size;
273 
274  m->sample_buffer[pos + s->blockpos][channel] = result;
275  }
276 
277  return 0;
278 }
279 
281 {
282  MLPDecodeContext *m = avctx->priv_data;
283  int substr;
284 
285  init_static();
286  m->avctx = avctx;
287  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
288  m->substream[substr].lossless_check_data = 0xffffffff;
289  ff_mlpdsp_init(&m->dsp);
290 
291  return 0;
292 }
293 
294 /** Read a major sync info header - contains high level information about
295  * the stream - sample rate, channel arrangement etc. Most of this
296  * information is not actually necessary for decoding, only for playback.
297  */
298 
300 {
302  int substr, ret;
303 
304  if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
305  return ret;
306 
307  if (mh.group1_bits == 0) {
308  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
309  return AVERROR_INVALIDDATA;
310  }
311  if (mh.group2_bits > mh.group1_bits) {
313  "Channel group 2 cannot have more bits per sample than group 1.\n");
314  return AVERROR_INVALIDDATA;
315  }
316 
319  "Channel groups with differing sample rates are not currently supported.\n");
320  return AVERROR_INVALIDDATA;
321  }
322 
323  if (mh.group1_samplerate == 0) {
324  av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
325  return AVERROR_INVALIDDATA;
326  }
329  "Sampling rate %d is greater than the supported maximum (%d).\n",
331  return AVERROR_INVALIDDATA;
332  }
333  if (mh.access_unit_size > MAX_BLOCKSIZE) {
335  "Block size %d is greater than the supported maximum (%d).\n",
337  return AVERROR_INVALIDDATA;
338  }
341  "Block size pow2 %d is greater than the supported maximum (%d).\n",
343  return AVERROR_INVALIDDATA;
344  }
345 
346  if (mh.num_substreams == 0)
347  return AVERROR_INVALIDDATA;
348  if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
349  av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
350  return AVERROR_INVALIDDATA;
351  }
352  if (mh.num_substreams > MAX_SUBSTREAMS) {
354  "%d substreams (more than the "
355  "maximum supported by the decoder)",
356  mh.num_substreams);
357  return AVERROR_PATCHWELCOME;
358  }
359 
361 
364 
366 
367  /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
369 
372 
374  if (mh.group1_bits > 16)
376  else
382 
383  m->params_valid = 1;
384  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
385  m->substream[substr].restart_seen = 0;
386 
387  /* Set the layout for each substream. When there's more than one, the first
388  * substream is Stereo. Subsequent substreams' layouts are indicated in the
389  * major sync. */
390  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
391  if (mh.stream_type != 0xbb) {
393  "unexpected stream_type %X in MLP",
394  mh.stream_type);
395  return AVERROR_PATCHWELCOME;
396  }
397  if ((substr = (mh.num_substreams > 1)))
399  m->substream[substr].mask = mh.channel_layout_mlp;
400  } else {
401  if (mh.stream_type != 0xba) {
403  "unexpected stream_type %X in !MLP",
404  mh.stream_type);
405  return AVERROR_PATCHWELCOME;
406  }
407  if ((substr = (mh.num_substreams > 1)))
409  if (mh.num_substreams > 2)
412  else
414  m->substream[substr].mask = mh.channel_layout_thd_stream1;
415 
416  if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
417  av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
418  m->max_decoded_substream = 0;
419  if (m->avctx->channels==2)
421  }
422  }
423 
424  m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
425 
426  /* Parse the TrueHD decoder channel modifiers and set each substream's
427  * AVMatrixEncoding accordingly.
428  *
429  * The meaning of the modifiers depends on the channel layout:
430  *
431  * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
432  *
433  * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
434  *
435  * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
436  * layouts with an Ls/Rs channel pair
437  */
438  for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
441  if (mh.num_substreams > 2 &&
446 
447  if (mh.num_substreams > 1 &&
452 
453  if (mh.num_substreams > 0)
454  switch (mh.channel_modifier_thd_stream0) {
457  break;
460  break;
461  default:
462  break;
463  }
464  }
465 
466  return 0;
467 }
468 
469 /** Read a restart header from a block in a substream. This contains parameters
470  * required to decode the audio that do not change very often. Generally
471  * (always) present only in blocks following a major sync. */
472 
474  const uint8_t *buf, unsigned int substr)
475 {
476  SubStream *s = &m->substream[substr];
477  unsigned int ch;
478  int sync_word, tmp;
480  uint8_t lossless_check;
481  int start_count = get_bits_count(gbp);
482  int min_channel, max_channel, max_matrix_channel;
483  const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
486 
487  sync_word = get_bits(gbp, 13);
488 
489  if (sync_word != 0x31ea >> 1) {
491  "restart header sync incorrect (got 0x%04x)\n", sync_word);
492  return AVERROR_INVALIDDATA;
493  }
494 
495  s->noise_type = get_bits1(gbp);
496 
497  if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
498  av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
499  return AVERROR_INVALIDDATA;
500  }
501 
502  skip_bits(gbp, 16); /* Output timestamp */
503 
504  min_channel = get_bits(gbp, 4);
505  max_channel = get_bits(gbp, 4);
506  max_matrix_channel = get_bits(gbp, 4);
507 
508  if (max_matrix_channel > std_max_matrix_channel) {
510  "Max matrix channel cannot be greater than %d.\n",
511  std_max_matrix_channel);
512  return AVERROR_INVALIDDATA;
513  }
514 
515  if (max_channel != max_matrix_channel) {
517  "Max channel must be equal max matrix channel.\n");
518  return AVERROR_INVALIDDATA;
519  }
520 
521  /* This should happen for TrueHD streams with >6 channels and MLP's noise
522  * type. It is not yet known if this is allowed. */
523  if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
525  "%d channels (more than the "
526  "maximum supported by the decoder)",
527  max_channel + 2);
528  return AVERROR_PATCHWELCOME;
529  }
530 
531  if (min_channel > max_channel) {
533  "Substream min channel cannot be greater than max channel.\n");
534  return AVERROR_INVALIDDATA;
535  }
536 
537  s->min_channel = min_channel;
538  s->max_channel = max_channel;
539  s->max_matrix_channel = max_matrix_channel;
540 
542  m->max_decoded_substream > substr) {
544  "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
545  "Further substreams will be skipped.\n",
546  s->max_channel + 1, s->mask, substr);
547  m->max_decoded_substream = substr;
548  }
549 
550  s->noise_shift = get_bits(gbp, 4);
551  s->noisegen_seed = get_bits(gbp, 23);
552 
553  skip_bits(gbp, 19);
554 
555  s->data_check_present = get_bits1(gbp);
556  lossless_check = get_bits(gbp, 8);
557  if (substr == m->max_decoded_substream
558  && s->lossless_check_data != 0xffffffff) {
560  if (tmp != lossless_check)
562  "Lossless check failed - expected %02x, calculated %02x.\n",
563  lossless_check, tmp);
564  }
565 
566  skip_bits(gbp, 16);
567 
568  memset(s->ch_assign, 0, sizeof(s->ch_assign));
569 
570  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
571  int ch_assign = get_bits(gbp, 6);
572  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
574  ch_assign);
576  channel);
577  }
578  if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
580  "Assignment of matrix channel %d to invalid output channel %d",
581  ch, ch_assign);
582  return AVERROR_PATCHWELCOME;
583  }
584  s->ch_assign[ch_assign] = ch;
585  }
586 
587  checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
588 
589  if (checksum != get_bits(gbp, 8))
590  av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
591 
592  /* Set default decoding parameters. */
593  s->param_presence_flags = 0xff;
594  s->num_primitive_matrices = 0;
595  s->blocksize = 8;
596  s->lossless_check_data = 0;
597 
598  memset(s->output_shift , 0, sizeof(s->output_shift ));
599  memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
600 
601  for (ch = s->min_channel; ch <= s->max_channel; ch++) {
602  ChannelParams *cp = &s->channel_params[ch];
603  cp->filter_params[FIR].order = 0;
604  cp->filter_params[IIR].order = 0;
605  cp->filter_params[FIR].shift = 0;
606  cp->filter_params[IIR].shift = 0;
607 
608  /* Default audio coding is 24-bit raw PCM. */
609  cp->huff_offset = 0;
610  cp->sign_huff_offset = -(1 << 23);
611  cp->codebook = 0;
612  cp->huff_lsbs = 24;
613  }
614 
615  if (substr == m->max_decoded_substream) {
616  m->avctx->channels = s->max_matrix_channel + 1;
617  m->avctx->channel_layout = s->mask;
619  s->output_shift,
622 
623  if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
626  int i = s->ch_assign[4];
627  s->ch_assign[4] = s->ch_assign[3];
628  s->ch_assign[3] = s->ch_assign[2];
629  s->ch_assign[2] = i;
630  } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
631  FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
632  FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
633  }
634  }
635 
636  }
637 
638  return 0;
639 }
640 
641 /** Read parameters for one of the prediction filters. */
642 
644  unsigned int substr, unsigned int channel,
645  unsigned int filter)
646 {
647  SubStream *s = &m->substream[substr];
649  const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
650  const char fchar = filter ? 'I' : 'F';
651  int i, order;
652 
653  // Filter is 0 for FIR, 1 for IIR.
654  av_assert0(filter < 2);
655 
656  if (m->filter_changed[channel][filter]++ > 1) {
657  av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
658  return AVERROR_INVALIDDATA;
659  }
660 
661  order = get_bits(gbp, 4);
662  if (order > max_order) {
664  "%cIR filter order %d is greater than maximum %d.\n",
665  fchar, order, max_order);
666  return AVERROR_INVALIDDATA;
667  }
668  fp->order = order;
669 
670  if (order > 0) {
671  int32_t *fcoeff = s->channel_params[channel].coeff[filter];
672  int coeff_bits, coeff_shift;
673 
674  fp->shift = get_bits(gbp, 4);
675 
676  coeff_bits = get_bits(gbp, 5);
677  coeff_shift = get_bits(gbp, 3);
678  if (coeff_bits < 1 || coeff_bits > 16) {
680  "%cIR filter coeff_bits must be between 1 and 16.\n",
681  fchar);
682  return AVERROR_INVALIDDATA;
683  }
684  if (coeff_bits + coeff_shift > 16) {
686  "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
687  fchar);
688  return AVERROR_INVALIDDATA;
689  }
690 
691  for (i = 0; i < order; i++)
692  fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
693 
694  if (get_bits1(gbp)) {
695  int state_bits, state_shift;
696 
697  if (filter == FIR) {
699  "FIR filter has state data specified.\n");
700  return AVERROR_INVALIDDATA;
701  }
702 
703  state_bits = get_bits(gbp, 4);
704  state_shift = get_bits(gbp, 4);
705 
706  /* TODO: Check validity of state data. */
707 
708  for (i = 0; i < order; i++)
709  fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
710  }
711  }
712 
713  return 0;
714 }
715 
716 /** Read parameters for primitive matrices. */
717 
718 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
719 {
720  SubStream *s = &m->substream[substr];
721  unsigned int mat, ch;
722  const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
725 
726  if (m->matrix_changed++ > 1) {
727  av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
728  return AVERROR_INVALIDDATA;
729  }
730 
731  s->num_primitive_matrices = get_bits(gbp, 4);
732 
733  if (s->num_primitive_matrices > max_primitive_matrices) {
735  "Number of primitive matrices cannot be greater than %d.\n",
736  max_primitive_matrices);
737  goto error;
738  }
739 
740  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
741  int frac_bits, max_chan;
742  s->matrix_out_ch[mat] = get_bits(gbp, 4);
743  frac_bits = get_bits(gbp, 4);
744  s->lsb_bypass [mat] = get_bits1(gbp);
745 
746  if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
748  "Invalid channel %d specified as output from matrix.\n",
749  s->matrix_out_ch[mat]);
750  goto error;
751  }
752  if (frac_bits > 14) {
754  "Too many fractional bits specified.\n");
755  goto error;
756  }
757 
758  max_chan = s->max_matrix_channel;
759  if (!s->noise_type)
760  max_chan+=2;
761 
762  for (ch = 0; ch <= max_chan; ch++) {
763  int coeff_val = 0;
764  if (get_bits1(gbp))
765  coeff_val = get_sbits(gbp, frac_bits + 2);
766 
767  s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
768  }
769 
770  if (s->noise_type)
771  s->matrix_noise_shift[mat] = get_bits(gbp, 4);
772  else
773  s->matrix_noise_shift[mat] = 0;
774  }
775 
776  return 0;
777 error:
778  s->num_primitive_matrices = 0;
779  memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
780 
781  return AVERROR_INVALIDDATA;
782 }
783 
784 /** Read channel parameters. */
785 
786 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
787  GetBitContext *gbp, unsigned int ch)
788 {
789  SubStream *s = &m->substream[substr];
790  ChannelParams *cp = &s->channel_params[ch];
791  FilterParams *fir = &cp->filter_params[FIR];
792  FilterParams *iir = &cp->filter_params[IIR];
793  int ret;
794 
796  if (get_bits1(gbp))
797  if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
798  return ret;
799 
801  if (get_bits1(gbp))
802  if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
803  return ret;
804 
805  if (fir->order + iir->order > 8) {
806  av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
807  return AVERROR_INVALIDDATA;
808  }
809 
810  if (fir->order && iir->order &&
811  fir->shift != iir->shift) {
813  "FIR and IIR filters must use the same precision.\n");
814  return AVERROR_INVALIDDATA;
815  }
816  /* The FIR and IIR filters must have the same precision.
817  * To simplify the filtering code, only the precision of the
818  * FIR filter is considered. If only the IIR filter is employed,
819  * the FIR filter precision is set to that of the IIR filter, so
820  * that the filtering code can use it. */
821  if (!fir->order && iir->order)
822  fir->shift = iir->shift;
823 
825  if (get_bits1(gbp))
826  cp->huff_offset = get_sbits(gbp, 15);
827 
828  cp->codebook = get_bits(gbp, 2);
829  cp->huff_lsbs = get_bits(gbp, 5);
830 
831  if (cp->huff_lsbs > 24) {
832  av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
833  cp->huff_lsbs = 0;
834  return AVERROR_INVALIDDATA;
835  }
836 
837  return 0;
838 }
839 
840 /** Read decoding parameters that change more often than those in the restart
841  * header. */
842 
844  unsigned int substr)
845 {
846  SubStream *s = &m->substream[substr];
847  unsigned int ch;
848  int ret = 0;
849  unsigned recompute_sho = 0;
850 
852  if (get_bits1(gbp))
853  s->param_presence_flags = get_bits(gbp, 8);
854 
856  if (get_bits1(gbp)) {
857  s->blocksize = get_bits(gbp, 9);
858  if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
859  av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
860  s->blocksize = 0;
861  return AVERROR_INVALIDDATA;
862  }
863  }
864 
866  if (get_bits1(gbp))
867  if ((ret = read_matrix_params(m, substr, gbp)) < 0)
868  return ret;
869 
871  if (get_bits1(gbp)) {
872  for (ch = 0; ch <= s->max_matrix_channel; ch++) {
873  s->output_shift[ch] = get_sbits(gbp, 4);
874  if (s->output_shift[ch] < 0) {
875  avpriv_request_sample(m->avctx, "Negative output_shift");
876  s->output_shift[ch] = 0;
877  }
878  }
879  if (substr == m->max_decoded_substream)
881  s->output_shift,
884  }
885 
887  if (get_bits1(gbp))
888  for (ch = 0; ch <= s->max_channel; ch++) {
889  s->quant_step_size[ch] = get_bits(gbp, 4);
890 
891  recompute_sho |= 1<<ch;
892  }
893 
894  for (ch = s->min_channel; ch <= s->max_channel; ch++)
895  if (get_bits1(gbp)) {
896  recompute_sho |= 1<<ch;
897  if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
898  goto fail;
899  }
900 
901 
902 fail:
903  for (ch = 0; ch <= s->max_channel; ch++) {
904  if (recompute_sho & (1<<ch)) {
905  ChannelParams *cp = &s->channel_params[ch];
906 
907  if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
908  if (ret >= 0) {
909  av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
910  ret = AVERROR_INVALIDDATA;
911  }
912  s->quant_step_size[ch] = 0;
913  }
914 
915  cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
916  }
917  }
918  return ret;
919 }
920 
921 #define MSB_MASK(bits) (-1u << (bits))
922 
923 /** Generate PCM samples using the prediction filters and residual values
924  * read from the data stream, and update the filter state. */
925 
926 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
927  unsigned int channel)
928 {
929  SubStream *s = &m->substream[substr];
930  const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
932  int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
933  int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
936  unsigned int filter_shift = fir->shift;
937  int32_t mask = MSB_MASK(s->quant_step_size[channel]);
938 
939  memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
940  memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
941 
942  m->dsp.mlp_filter_channel(firbuf, fircoeff,
943  fir->order, iir->order,
944  filter_shift, mask, s->blocksize,
945  &m->sample_buffer[s->blockpos][channel]);
946 
947  memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
948  memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
949 }
950 
951 /** Read a block of PCM residual data (or actual if no filtering active). */
952 
954  unsigned int substr)
955 {
956  SubStream *s = &m->substream[substr];
957  unsigned int i, ch, expected_stream_pos = 0;
958  int ret;
959 
960  if (s->data_check_present) {
961  expected_stream_pos = get_bits_count(gbp);
962  expected_stream_pos += get_bits(gbp, 16);
964  "Substreams with VLC block size check info");
965  }
966 
967  if (s->blockpos + s->blocksize > m->access_unit_size) {
968  av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
969  return AVERROR_INVALIDDATA;
970  }
971 
972  memset(&m->bypassed_lsbs[s->blockpos][0], 0,
973  s->blocksize * sizeof(m->bypassed_lsbs[0]));
974 
975  for (i = 0; i < s->blocksize; i++)
976  if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
977  return ret;
978 
979  for (ch = s->min_channel; ch <= s->max_channel; ch++)
980  filter_channel(m, substr, ch);
981 
982  s->blockpos += s->blocksize;
983 
984  if (s->data_check_present) {
985  if (get_bits_count(gbp) != expected_stream_pos)
986  av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
987  skip_bits(gbp, 8);
988  }
989 
990  return 0;
991 }
992 
993 /** Data table used for TrueHD noise generation function. */
994 
995 static const int8_t noise_table[256] = {
996  30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
997  52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
998  10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
999  51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
1000  38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
1001  61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
1002  67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
1003  48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
1004  0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1005  16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1006  13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1007  89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1008  36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1009  39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1010  45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1011  -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1012 };
1013 
1014 /** Noise generation functions.
1015  * I'm not sure what these are for - they seem to be some kind of pseudorandom
1016  * sequence generators, used to generate noise data which is used when the
1017  * channels are rematrixed. I'm not sure if they provide a practical benefit
1018  * to compression, or just obfuscate the decoder. Are they for some kind of
1019  * dithering? */
1020 
1021 /** Generate two channels of noise, used in the matrix when
1022  * restart sync word == 0x31ea. */
1023 
1024 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1025 {
1026  SubStream *s = &m->substream[substr];
1027  unsigned int i;
1028  uint32_t seed = s->noisegen_seed;
1029  unsigned int maxchan = s->max_matrix_channel;
1030 
1031  for (i = 0; i < s->blockpos; i++) {
1032  uint16_t seed_shr7 = seed >> 7;
1033  m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1034  m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1035 
1036  seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1037  }
1038 
1039  s->noisegen_seed = seed;
1040 }
1041 
1042 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1043 
1044 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1045 {
1046  SubStream *s = &m->substream[substr];
1047  unsigned int i;
1048  uint32_t seed = s->noisegen_seed;
1049 
1050  for (i = 0; i < m->access_unit_size_pow2; i++) {
1051  uint8_t seed_shr15 = seed >> 15;
1052  m->noise_buffer[i] = noise_table[seed_shr15];
1053  seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1054  }
1055 
1056  s->noisegen_seed = seed;
1057 }
1058 
1059 /** Write the audio data into the output buffer. */
1060 
1061 static int output_data(MLPDecodeContext *m, unsigned int substr,
1062  AVFrame *frame, int *got_frame_ptr)
1063 {
1064  AVCodecContext *avctx = m->avctx;
1065  SubStream *s = &m->substream[substr];
1066  unsigned int mat;
1067  unsigned int maxchan;
1068  int ret;
1069  int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1070 
1071  if (m->avctx->channels != s->max_matrix_channel + 1) {
1072  av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1073  return AVERROR_INVALIDDATA;
1074  }
1075 
1076  if (!s->blockpos) {
1077  av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1078  return AVERROR_INVALIDDATA;
1079  }
1080 
1081  maxchan = s->max_matrix_channel;
1082  if (!s->noise_type) {
1083  generate_2_noise_channels(m, substr);
1084  maxchan += 2;
1085  } else {
1086  fill_noise_buffer(m, substr);
1087  }
1088 
1089  /* Apply the channel matrices in turn to reconstruct the original audio
1090  * samples. */
1091  for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1092  unsigned int dest_ch = s->matrix_out_ch[mat];
1093  m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1094  s->matrix_coeff[mat],
1095  &m->bypassed_lsbs[0][mat],
1096  m->noise_buffer,
1097  s->num_primitive_matrices - mat,
1098  dest_ch,
1099  s->blockpos,
1100  maxchan,
1101  s->matrix_noise_shift[mat],
1103  MSB_MASK(s->quant_step_size[dest_ch]));
1104  }
1105 
1106  /* get output buffer */
1107  frame->nb_samples = s->blockpos;
1108  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1109  return ret;
1111  s->blockpos,
1112  m->sample_buffer,
1113  frame->data[0],
1114  s->ch_assign,
1115  s->output_shift,
1116  s->max_matrix_channel,
1117  is32);
1118 
1119  /* Update matrix encoding side data */
1120  if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1121  return ret;
1122 
1123  *got_frame_ptr = 1;
1124 
1125  return 0;
1126 }
1127 
1128 /** Read an access unit from the stream.
1129  * @return negative on error, 0 if not enough data is present in the input stream,
1130  * otherwise the number of bytes consumed. */
1131 
1132 static int read_access_unit(AVCodecContext *avctx, void* data,
1133  int *got_frame_ptr, AVPacket *avpkt)
1134 {
1135  const uint8_t *buf = avpkt->data;
1136  int buf_size = avpkt->size;
1137  MLPDecodeContext *m = avctx->priv_data;
1138  GetBitContext gb;
1139  unsigned int length, substr;
1140  unsigned int substream_start;
1141  unsigned int header_size = 4;
1142  unsigned int substr_header_size = 0;
1143  uint8_t substream_parity_present[MAX_SUBSTREAMS];
1144  uint16_t substream_data_len[MAX_SUBSTREAMS];
1145  uint8_t parity_bits;
1146  int ret;
1147 
1148  if (buf_size < 4)
1149  return AVERROR_INVALIDDATA;
1150 
1151  length = (AV_RB16(buf) & 0xfff) * 2;
1152 
1153  if (length < 4 || length > buf_size)
1154  return AVERROR_INVALIDDATA;
1155 
1156  init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1157 
1158  m->is_major_sync_unit = 0;
1159  if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1160  if (read_major_sync(m, &gb) < 0)
1161  goto error;
1162  m->is_major_sync_unit = 1;
1163  header_size += m->major_sync_header_size;
1164  }
1165 
1166  if (!m->params_valid) {
1168  "Stream parameters not seen; skipping frame.\n");
1169  *got_frame_ptr = 0;
1170  return length;
1171  }
1172 
1173  substream_start = 0;
1174 
1175  for (substr = 0; substr < m->num_substreams; substr++) {
1176  int extraword_present, checkdata_present, end, nonrestart_substr;
1177 
1178  extraword_present = get_bits1(&gb);
1179  nonrestart_substr = get_bits1(&gb);
1180  checkdata_present = get_bits1(&gb);
1181  skip_bits1(&gb);
1182 
1183  end = get_bits(&gb, 12) * 2;
1184 
1185  substr_header_size += 2;
1186 
1187  if (extraword_present) {
1188  if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1189  av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1190  goto error;
1191  }
1192  skip_bits(&gb, 16);
1193  substr_header_size += 2;
1194  }
1195 
1196  if (length < header_size + substr_header_size) {
1197  av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
1198  goto error;
1199  }
1200 
1201  if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1202  av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1203  goto error;
1204  }
1205 
1206  if (end + header_size + substr_header_size > length) {
1208  "Indicated length of substream %d data goes off end of "
1209  "packet.\n", substr);
1210  end = length - header_size - substr_header_size;
1211  }
1212 
1213  if (end < substream_start) {
1214  av_log(avctx, AV_LOG_ERROR,
1215  "Indicated end offset of substream %d data "
1216  "is smaller than calculated start offset.\n",
1217  substr);
1218  goto error;
1219  }
1220 
1221  if (substr > m->max_decoded_substream)
1222  continue;
1223 
1224  substream_parity_present[substr] = checkdata_present;
1225  substream_data_len[substr] = end - substream_start;
1226  substream_start = end;
1227  }
1228 
1229  parity_bits = ff_mlp_calculate_parity(buf, 4);
1230  parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1231 
1232  if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1233  av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1234  goto error;
1235  }
1236 
1237  buf += header_size + substr_header_size;
1238 
1239  for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1240  SubStream *s = &m->substream[substr];
1241  init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1242 
1243  m->matrix_changed = 0;
1244  memset(m->filter_changed, 0, sizeof(m->filter_changed));
1245 
1246  s->blockpos = 0;
1247  do {
1248  if (get_bits1(&gb)) {
1249  if (get_bits1(&gb)) {
1250  /* A restart header should be present. */
1251  if (read_restart_header(m, &gb, buf, substr) < 0)
1252  goto next_substr;
1253  s->restart_seen = 1;
1254  }
1255 
1256  if (!s->restart_seen)
1257  goto next_substr;
1258  if (read_decoding_params(m, &gb, substr) < 0)
1259  goto next_substr;
1260  }
1261 
1262  if (!s->restart_seen)
1263  goto next_substr;
1264 
1265  if ((ret = read_block_data(m, &gb, substr)) < 0)
1266  return ret;
1267 
1268  if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1269  goto substream_length_mismatch;
1270 
1271  } while (!get_bits1(&gb));
1272 
1273  skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1274 
1275  if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1276  int shorten_by;
1277 
1278  if (get_bits(&gb, 16) != 0xD234)
1279  return AVERROR_INVALIDDATA;
1280 
1281  shorten_by = get_bits(&gb, 16);
1282  if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1283  s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1284  else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1285  return AVERROR_INVALIDDATA;
1286 
1287  if (substr == m->max_decoded_substream)
1288  av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1289  }
1290 
1291  if (substream_parity_present[substr]) {
1293 
1294  if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1295  goto substream_length_mismatch;
1296 
1297  parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1298  checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1299 
1300  if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1301  av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1302  if ( get_bits(&gb, 8) != checksum)
1303  av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1304  }
1305 
1306  if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1307  goto substream_length_mismatch;
1308 
1309 next_substr:
1310  if (!s->restart_seen)
1312  "No restart header present in substream %d.\n", substr);
1313 
1314  buf += substream_data_len[substr];
1315  }
1316 
1317  if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1318  return ret;
1319 
1320  return length;
1321 
1322 substream_length_mismatch:
1323  av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1324  return AVERROR_INVALIDDATA;
1325 
1326 error:
1327  m->params_valid = 0;
1328  return AVERROR_INVALIDDATA;
1329 }
1330 
1331 #if CONFIG_MLP_DECODER
1332 AVCodec ff_mlp_decoder = {
1333  .name = "mlp",
1334  .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1335  .type = AVMEDIA_TYPE_AUDIO,
1336  .id = AV_CODEC_ID_MLP,
1337  .priv_data_size = sizeof(MLPDecodeContext),
1338  .init = mlp_decode_init,
1340  .capabilities = AV_CODEC_CAP_DR1,
1341 };
1342 #endif
1343 #if CONFIG_TRUEHD_DECODER
1344 AVCodec ff_truehd_decoder = {
1345  .name = "truehd",
1346  .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1347  .type = AVMEDIA_TYPE_AUDIO,
1348  .id = AV_CODEC_ID_TRUEHD,
1349  .priv_data_size = sizeof(MLPDecodeContext),
1350  .init = mlp_decode_init,
1352  .capabilities = AV_CODEC_CAP_DR1,
1353 };
1354 #endif /* CONFIG_TRUEHD_DECODER */
uint8_t shift
Right shift to apply to output of filter.
Definition: mlp.h:76
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:397
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout, int index)
Definition: mlpdec.c:188
const char * s
Definition: avisynth_c.h:768
int major_sync_header_size
Size of the major sync unit, in bytes.
Definition: mlpdec.c:136
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MAX_IIR_ORDER
Definition: mlp.h:65
FilterParams filter_params[NUM_FILTERS]
Definition: mlp.h:86
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
static av_cold int mlp_decode_init(AVCodecContext *avctx)
Definition: mlpdec.c:280
#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:160
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
Definition: mlpdec.c:85
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:261
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
uint64_t mask
The channel layout for this substream.
Definition: mlpdec.c:69
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:75
#define AV_CH_TOP_FRONT_LEFT
static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
Definition: mlpdec.c:183
int num_substreams
Number of substreams within stream.
Definition: mlp_parser.h:62
#define AV_CH_TOP_FRONT_CENTER
int size
Definition: avcodec.h:1401
#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
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:473
#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:52
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:2711
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
AVCodec.
Definition: avcodec.h:3351
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int access_unit_size
Number of samples per coded frame.
Definition: mlp_parser.h:56
static VLC huff_vlc[3]
Definition: mlpdec.c:202
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
Definition: mlpdec.c:108
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:97
int matrix_changed
Definition: mlpdec.c:157
#define AV_CH_WIDE_LEFT
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2151
uint8_t
#define av_cold
Definition: attributes.h:82
#define PARAM_BLOCKSIZE
Definition: mlpdec.c:86
MLPDSPContext dsp
Definition: mlpdec.c:164
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
Definition: mlp.h:160
int channel_modifier_thd_stream0
Channel modifier for substream 0 of TrueHD streams ("2-channel presentation")
Definition: mlp_parser.h:45
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
#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
static AVFrame * frame
Public header for CRC hash function implementation.
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
Definition: mlpdec.c:1044
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1400
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
uint8_t restart_seen
Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
Definition: mlpdec.c:53
#define PARAM_HUFFOFFSET
Definition: mlpdec.c:92
bitstream reader API header.
#define AV_CH_BACK_LEFT
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
Definition: mlpdec.c:1024
int channel_arrangement
Definition: mlp_parser.h:43
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:643
#define PARAM_PRESENCE
Definition: mlpdec.c:93
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
int16_t huff_offset
Offset to apply to residual values.
Definition: mlp.h:89
#define PARAM_OUTSHIFT
Definition: mlpdec.c:88
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
Definition: mlpdec.c:786
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
Definition: mlpdec.c:47
#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:120
#define MAX_MATRICES
Definition: mlp.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:47
static const uint16_t mask[17]
Definition: lzw.c:38
uint8_t needs_reordering
Stream needs channel reordering to comply with FFmpeg's channel order.
Definition: mlpdec.c:148
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:161
static const struct endianess table[]
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:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static const uint64_t thd_channel_order[]
Definition: mlpdec.c:167
#define AV_CH_LAYOUT_QUAD
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:244
GLsizei GLsizei * length
Definition: opengl_enc.c:115
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
uint8_t num_substreams
Number of substreams contained within this stream.
Definition: mlpdec.c:142
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:1132
#define fail()
Definition: checkasm.h:112
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:2194
#define MAX_BLOCKSIZE
Definition: diracdec.c:54
#define VLC_STATIC_SIZE
Definition: mlpdec.c:48
common internal API header
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
Definition: mlpdec.c:718
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:926
#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:101
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:1061
#define FFMIN(a, b)
Definition: common.h:96
uint16_t noise_type
restart header data
Definition: mlpdec.c:58
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:299
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 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:953
mcdeint parity
Definition: vf_mcdeint.c:274
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:554
#define AV_CH_FRONT_LEFT_OF_CENTER
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
Definition: mlpdec.c:995
#define AV_CH_FRONT_CENTER
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
Definition: mlpdec.c:158
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:87
static volatile int checksum
Definition: adler32.c:30
#define AV_CH_LAYOUT_5POINT1_BACK
static void error(const char *err)
int access_unit_size
number of PCM samples contained in each frame
Definition: mlpdec.c:151
#define FF_ARRAY_ELEMS(a)
#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:226
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int stream_type
0xBB for MLP, 0xBA for TrueHD
Definition: mlp_parser.h:34
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2163
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int access_unit_size_pow2
Next power of two above number of samples per frame.
Definition: mlp_parser.h:57
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:91
#define MAX_MATRICES_TRUEHD
Definition: mlp.h:42
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:1498
int sample_rate
samples per second
Definition: avcodec.h:2143
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
Definition: mlpdsp.c:128
SubStream substream[MAX_SUBSTREAMS]
Definition: mlpdec.c:155
uint8_t order
number of taps in filter
Definition: mlp.h:75
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:843
int channel_modifier_thd_stream1
Channel modifier for substream 1 of TrueHD streams ("6-channel presentation")
Definition: mlp_parser.h:46
main external API structure.
Definition: avcodec.h:1488
#define PARAM_QUANTSTEP
Definition: mlpdec.c:89
#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
#define fp
Definition: regdef.h:44
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
Definition: mlpdec.c:162
void * buf
Definition: avisynth_c.h:690
filter data
Definition: mlp.h:74
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:313
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:338
#define IIR
Definition: mlp.h:71
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:306
AVCodecContext * avctx
Definition: mlpdec.c:130
#define PARAM_IIR
Definition: mlpdec.c:91
int index
Definition: gxfenc.c:89
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:425
uint8_t num_primitive_matrices
matrix data
Definition: mlpdec.c:100
#define AV_CH_LAYOUT_5POINT0_BACK
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
Definition: mlpdec.c:145
#define MAX_CHANNELS
Definition: aac.h:47
#define FIR
Definition: mlp.h:70
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 huff_lsbs
Size of residual suffix not encoded using VLC.
Definition: mlp.h:92
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
Definition: mlpdec.c:206
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:215
#define AV_CH_SIDE_RIGHT
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
Definition: mlpdec.c:79
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:279
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
Definition: mlpdec.c:103
signed 16 bits
Definition: samplefmt.h:61
int access_unit_size_pow2
next power of two above the number of samples in each frame
Definition: mlpdec.c:153
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
uint64_t channel_layout_thd_stream1
Channel layout for substream 1 of TrueHD streams ("6-channel presentation")
Definition: mlp_parser.h:53
#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:54
static int32_t calculate_sign_huff(MLPDecodeContext *m, unsigned int substr, unsigned int ch)
Definition: mlpdec.c:223
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
void * priv_data
Definition: avcodec.h:1515
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
#define PARAM_MATRIX
Definition: mlpdec.c:87
sample data coding information
Definition: mlp.h:85
int channels
number of audio channels
Definition: avcodec.h:2144
int group1_bits
The bit depth of the first substream.
Definition: mlp_parser.h:37
av_cold void ff_mlp_init_crc(void)
Definition: mlp.c:75
#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 MAX_MATRICES_MLP
Maximum number of matrices used in decoding; most streams have one matrix per output channel...
Definition: mlp.h:41
#define MSB_MASK(bits)
Definition: mlpdec.c:921
AVMatrixEncoding
#define AV_CH_SIDE_LEFT
#define FFSWAP(type, a, b)
Definition: common.h:99
int group1_samplerate
Sample rate of first substream.
Definition: mlp_parser.h:40
#define AV_CH_LAYOUT_MONO
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:2201
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
This structure stores compressed data.
Definition: avcodec.h:1377
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:267
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
#define mh
#define AV_CH_BACK_RIGHT
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define PARAM_FIR
Definition: mlpdec.c:90
int32_t sign_huff_offset
sign/rounding-corrected version of huff_offset
Definition: mlp.h:90
static uint8_t tmp[11]
Definition: aes_ctr.c:26
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:94