FFmpeg
eac3dec.c
Go to the documentation of this file.
1 /*
2  * E-AC-3 decoder
3  * Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
4  * Copyright (c) 2008 Justin Ruggles
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /*
24  * There are several features of E-AC-3 that this decoder does not yet support.
25  *
26  * Enhanced Coupling
27  * No known samples exist. If any ever surface, this feature should not be
28  * too difficult to implement.
29  *
30  * Reduced Sample Rates
31  * No known samples exist. The spec also does not give clear information
32  * on how this is to be implemented.
33  *
34  * Transient Pre-noise Processing
35  * This is side information which a decoder should use to reduce artifacts
36  * caused by transients. There are samples which are known to have this
37  * information, but this decoder currently ignores it.
38  */
39 
40 
41 #include "avcodec.h"
42 #include "internal.h"
43 #include "aac_ac3_parser.h"
44 #include "ac3.h"
45 #include "ac3dec.h"
46 #include "ac3dec_data.h"
47 #include "eac3_data.h"
48 
49 /** gain adaptive quantization mode */
50 typedef enum {
55 } EAC3GaqMode;
56 
57 #define EAC3_SR_CODE_REDUCED 3
58 
59 static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
60 {
61  int bin, bnd, ch, i;
62  uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
63  float rms_energy[SPX_MAX_BANDS];
64 
65  /* Set copy index mapping table. Set wrap flags to apply a notch filter at
66  wrap points later on. */
67  bin = s->spx_dst_start_freq;
68  num_copy_sections = 0;
69  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
70  int copysize;
71  int bandsize = s->spx_band_sizes[bnd];
72  if (bin + bandsize > s->spx_src_start_freq) {
73  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
74  bin = s->spx_dst_start_freq;
75  wrapflag[bnd] = 1;
76  }
77  for (i = 0; i < bandsize; i += copysize) {
78  if (bin == s->spx_src_start_freq) {
79  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
80  bin = s->spx_dst_start_freq;
81  }
82  copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
83  bin += copysize;
84  }
85  }
86  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
87 
88  for (ch = 1; ch <= s->fbw_channels; ch++) {
89  if (!s->channel_uses_spx[ch])
90  continue;
91 
92  /* Copy coeffs from normal bands to extension bands */
93  bin = s->spx_src_start_freq;
94  for (i = 0; i < num_copy_sections; i++) {
95  memcpy(&s->transform_coeffs[ch][bin],
96  &s->transform_coeffs[ch][s->spx_dst_start_freq],
97  copy_sizes[i]*sizeof(INTFLOAT));
98  bin += copy_sizes[i];
99  }
100 
101  /* Calculate RMS energy for each SPX band. */
102  bin = s->spx_src_start_freq;
103  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
104  int bandsize = s->spx_band_sizes[bnd];
105  float accum = 0.0f;
106  for (i = 0; i < bandsize; i++) {
107  float coeff = s->transform_coeffs[ch][bin++];
108  accum += coeff * coeff;
109  }
110  rms_energy[bnd] = sqrtf(accum / bandsize);
111  }
112 
113  /* Apply a notch filter at transitions between normal and extension
114  bands and at all wrap points. */
115  if (s->spx_atten_code[ch] >= 0) {
116  const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
117  bin = s->spx_src_start_freq - 2;
118  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
119  if (wrapflag[bnd]) {
120  INTFLOAT *coeffs = &s->transform_coeffs[ch][bin];
121  coeffs[0] *= atten_tab[0];
122  coeffs[1] *= atten_tab[1];
123  coeffs[2] *= atten_tab[2];
124  coeffs[3] *= atten_tab[1];
125  coeffs[4] *= atten_tab[0];
126  }
127  bin += s->spx_band_sizes[bnd];
128  }
129  }
130 
131  /* Apply noise-blended coefficient scaling based on previously
132  calculated RMS energy, blending factors, and SPX coordinates for
133  each band. */
134  bin = s->spx_src_start_freq;
135  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
136  float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
137  float sscale = s->spx_signal_blend[ch][bnd];
138 #if USE_FIXED
139  // spx_noise_blend and spx_signal_blend are both FP.23
140  nscale *= 1.0 / (1<<23);
141  sscale *= 1.0 / (1<<23);
142 #endif
143  for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
144  float noise = nscale * (int32_t)av_lfg_get(&s->dith_state);
145  s->transform_coeffs[ch][bin] *= sscale;
146  s->transform_coeffs[ch][bin++] += noise;
147  }
148  }
149  }
150 }
151 
152 
153 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
154 #define COEFF_0 10273905LL
155 
156 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
157 #define COEFF_1 11863283LL
158 
159 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
160 #define COEFF_2 3070444LL
161 
162 /**
163  * Calculate 6-point IDCT of the pre-mantissas.
164  * All calculations are 24-bit fixed-point.
165  */
166 static void idct6(int pre_mant[6])
167 {
168  int tmp;
169  int even0, even1, even2, odd0, odd1, odd2;
170 
171  odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
172 
173  even2 = ( pre_mant[2] * COEFF_0) >> 23;
174  tmp = ( pre_mant[4] * COEFF_1) >> 23;
175  odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
176 
177  even0 = pre_mant[0] + (tmp >> 1);
178  even1 = pre_mant[0] - tmp;
179 
180  tmp = even0;
181  even0 = tmp + even2;
182  even2 = tmp - even2;
183 
184  tmp = odd0;
185  odd0 = tmp + pre_mant[1] + pre_mant[3];
186  odd2 = tmp + pre_mant[5] - pre_mant[3];
187 
188  pre_mant[0] = even0 + odd0;
189  pre_mant[1] = even1 + odd1;
190  pre_mant[2] = even2 + odd2;
191  pre_mant[3] = even2 - odd2;
192  pre_mant[4] = even1 - odd1;
193  pre_mant[5] = even0 - odd0;
194 }
195 
196 static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
197 {
198  int bin, blk, gs;
199  int end_bap, gaq_mode;
200  GetBitContext *gbc = &s->gbc;
201  int gaq_gain[AC3_MAX_COEFS];
202 
203  gaq_mode = get_bits(gbc, 2);
204  end_bap = (gaq_mode < 2) ? 12 : 17;
205 
206  /* if GAQ gain is used, decode gain codes for bins with hebap between
207  8 and end_bap */
208  gs = 0;
209  if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
210  /* read 1-bit GAQ gain codes */
211  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
212  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
213  gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
214  }
215  } else if (gaq_mode == EAC3_GAQ_124) {
216  /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
217  int gc = 2;
218  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
219  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
220  if (gc++ == 2) {
221  int group_code = get_bits(gbc, 5);
222  if (group_code > 26) {
223  av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
224  group_code = 26;
225  }
226  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
227  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
228  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
229  gc = 0;
230  }
231  }
232  }
233  }
234 
235  gs=0;
236  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
237  int hebap = s->bap[ch][bin];
238  int bits = ff_eac3_bits_vs_hebap[hebap];
239  if (!hebap) {
240  /* zero-mantissa dithering */
241  for (blk = 0; blk < 6; blk++) {
242  s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
243  }
244  } else if (hebap < 8) {
245  /* Vector Quantization */
246  int v = get_bits(gbc, bits);
247  for (blk = 0; blk < 6; blk++) {
248  s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8);
249  }
250  } else {
251  /* Gain Adaptive Quantization */
252  int gbits, log_gain;
253  if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
254  log_gain = gaq_gain[gs++];
255  } else {
256  log_gain = 0;
257  }
258  gbits = bits - log_gain;
259 
260  for (blk = 0; blk < 6; blk++) {
261  int mant = get_sbits(gbc, gbits);
262  if (log_gain && mant == -(1 << (gbits-1))) {
263  /* large mantissa */
264  int b;
265  int mbits = bits - (2 - log_gain);
266  mant = get_sbits(gbc, mbits);
267  mant = ((unsigned)mant) << (23 - (mbits - 1));
268  /* remap mantissa value to correct for asymmetric quantization */
269  if (mant >= 0)
270  b = 1 << (23 - log_gain);
271  else
272  b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);
273  mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
274  } else {
275  /* small mantissa, no GAQ, or Gk=1 */
276  mant *= (1 << 24 - bits);
277  if (!log_gain) {
278  /* remap mantissa value for no GAQ or Gk=1 */
279  mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
280  }
281  }
282  s->pre_mantissa[ch][bin][blk] = mant;
283  }
284  }
285  idct6(s->pre_mantissa[ch][bin]);
286  }
287 }
288 
289 static int ff_eac3_parse_header(AC3DecodeContext *s)
290 {
291  int i, blk, ch;
292  int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
293  int parse_transient_proc_info;
294  int num_cpl_blocks;
295  GetBitContext *gbc = &s->gbc;
296 
297  /* An E-AC-3 stream can have multiple independent streams which the
298  application can select from. each independent stream can also contain
299  dependent streams which are used to add or replace channels. */
300  if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
301  av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
303  }
304 
305  /* The substream id indicates which substream this frame belongs to. each
306  independent stream has its own substream id, and the dependent streams
307  associated to an independent stream have matching substream id's. */
308  if (s->substreamid) {
309  /* only decode substream with id=0. skip any additional substreams. */
310  if (!s->eac3_subsbtreamid_found) {
311  s->eac3_subsbtreamid_found = 1;
312  avpriv_request_sample(s->avctx, "Additional substreams");
313  }
315  }
316 
317  if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
318  /* The E-AC-3 specification does not tell how to handle reduced sample
319  rates in bit allocation. The best assumption would be that it is
320  handled like AC-3 DolbyNet, but we cannot be sure until we have a
321  sample which utilizes this feature. */
322  avpriv_request_sample(s->avctx, "Reduced sampling rate");
323  return AVERROR_PATCHWELCOME;
324  }
325  skip_bits(gbc, 5); // skip bitstream id
326 
327  /* volume control params */
328  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
329  s->dialog_normalization[i] = -get_bits(gbc, 5);
330  if (s->dialog_normalization[i] == 0) {
331  s->dialog_normalization[i] = -31;
332  }
333  if (s->target_level != 0) {
334  s->level_gain[i] = powf(2.0f,
335  (float)(s->target_level - s->dialog_normalization[i])/6.0f);
336  }
337  s->compression_exists[i] = get_bits1(gbc);
338  if (s->compression_exists[i]) {
339  s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(get_bits(gbc, 8));
340  }
341  }
342 
343  /* dependent stream channel map */
344  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
345  if (get_bits1(gbc)) {
346  int64_t channel_layout = 0;
347  int channel_map = get_bits(gbc, 16);
348  av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", channel_map);
349 
350  for (i = 0; i < 16; i++)
351  if (channel_map & (1 << (EAC3_MAX_CHANNELS - i - 1)))
352  channel_layout |= ff_eac3_custom_channel_map_locations[i][1];
353 
354  if (av_popcount64(channel_layout) > EAC3_MAX_CHANNELS) {
355  return AVERROR_INVALIDDATA;
356  }
357  s->channel_map = channel_map;
358  }
359  }
360 
361  /* mixing metadata */
362  if (get_bits1(gbc)) {
363  /* center and surround mix levels */
364  if (s->channel_mode > AC3_CHMODE_STEREO) {
365  s->preferred_downmix = get_bits(gbc, 2);
366  if (s->channel_mode & 1) {
367  /* if three front channels exist */
368  s->center_mix_level_ltrt = get_bits(gbc, 3);
369  s->center_mix_level = get_bits(gbc, 3);
370  }
371  if (s->channel_mode & 4) {
372  /* if a surround channel exists */
373  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
374  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
375  }
376  }
377 
378  /* lfe mix level */
379  if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
380  s->lfe_mix_level = get_bits(gbc, 5);
381  }
382 
383  /* info for mixing with other streams and substreams */
384  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
385  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
386  // TODO: apply program scale factor
387  if (get_bits1(gbc)) {
388  skip_bits(gbc, 6); // skip program scale factor
389  }
390  }
391  if (get_bits1(gbc)) {
392  skip_bits(gbc, 6); // skip external program scale factor
393  }
394  /* skip mixing parameter data */
395  switch(get_bits(gbc, 2)) {
396  case 1: skip_bits(gbc, 5); break;
397  case 2: skip_bits(gbc, 12); break;
398  case 3: {
399  int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
400  skip_bits_long(gbc, mix_data_size);
401  break;
402  }
403  }
404  /* skip pan information for mono or dual mono source */
405  if (s->channel_mode < AC3_CHMODE_STEREO) {
406  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
407  if (get_bits1(gbc)) {
408  /* note: this is not in the ATSC A/52B specification
409  reference: ETSI TS 102 366 V1.1.1
410  section: E.1.3.1.25 */
411  skip_bits(gbc, 8); // skip pan mean direction index
412  skip_bits(gbc, 6); // skip reserved paninfo bits
413  }
414  }
415  }
416  /* skip mixing configuration information */
417  if (get_bits1(gbc)) {
418  for (blk = 0; blk < s->num_blocks; blk++) {
419  if (s->num_blocks == 1 || get_bits1(gbc)) {
420  skip_bits(gbc, 5);
421  }
422  }
423  }
424  }
425  }
426 
427  /* informational metadata */
428  if (get_bits1(gbc)) {
429  s->bitstream_mode = get_bits(gbc, 3);
430  skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
431  if (s->channel_mode == AC3_CHMODE_STEREO) {
432  s->dolby_surround_mode = get_bits(gbc, 2);
433  s->dolby_headphone_mode = get_bits(gbc, 2);
434  }
435  if (s->channel_mode >= AC3_CHMODE_2F2R) {
436  s->dolby_surround_ex_mode = get_bits(gbc, 2);
437  }
438  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
439  if (get_bits1(gbc)) {
440  skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
441  }
442  }
443  if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
444  skip_bits1(gbc); // skip source sample rate code
445  }
446  }
447 
448  /* converter synchronization flag
449  If frames are less than six blocks, this bit should be turned on
450  once every 6 blocks to indicate the start of a frame set.
451  reference: RFC 4598, Section 2.1.3 Frame Sets */
452  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
453  skip_bits1(gbc); // skip converter synchronization flag
454  }
455 
456  /* original frame size code if this stream was converted from AC-3 */
457  if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
458  (s->num_blocks == 6 || get_bits1(gbc))) {
459  skip_bits(gbc, 6); // skip frame size code
460  }
461 
462  /* additional bitstream info */
463  if (get_bits1(gbc)) {
464  int addbsil = get_bits(gbc, 6);
465  for (i = 0; i < addbsil + 1; i++) {
466  skip_bits(gbc, 8); // skip additional bit stream info
467  }
468  }
469 
470  /* audio frame syntax flags, strategy data, and per-frame data */
471 
472  if (s->num_blocks == 6) {
473  ac3_exponent_strategy = get_bits1(gbc);
474  parse_aht_info = get_bits1(gbc);
475  } else {
476  /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
477  do not use AHT */
478  ac3_exponent_strategy = 1;
479  parse_aht_info = 0;
480  }
481 
482  s->snr_offset_strategy = get_bits(gbc, 2);
483  parse_transient_proc_info = get_bits1(gbc);
484 
485  s->block_switch_syntax = get_bits1(gbc);
486  if (!s->block_switch_syntax)
487  memset(s->block_switch, 0, sizeof(s->block_switch));
488 
489  s->dither_flag_syntax = get_bits1(gbc);
490  if (!s->dither_flag_syntax) {
491  for (ch = 1; ch <= s->fbw_channels; ch++)
492  s->dither_flag[ch] = 1;
493  }
494  s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
495 
496  s->bit_allocation_syntax = get_bits1(gbc);
497  if (!s->bit_allocation_syntax) {
498  /* set default bit allocation parameters */
499  s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
500  s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
501  s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
502  s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
503  s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
504  }
505 
506  s->fast_gain_syntax = get_bits1(gbc);
507  s->dba_syntax = get_bits1(gbc);
508  s->skip_syntax = get_bits1(gbc);
509  parse_spx_atten_data = get_bits1(gbc);
510 
511  /* coupling strategy occurrence and coupling use per block */
512  num_cpl_blocks = 0;
513  if (s->channel_mode > 1) {
514  for (blk = 0; blk < s->num_blocks; blk++) {
515  s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
516  if (s->cpl_strategy_exists[blk]) {
517  s->cpl_in_use[blk] = get_bits1(gbc);
518  } else {
519  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
520  }
521  num_cpl_blocks += s->cpl_in_use[blk];
522  }
523  } else {
524  memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
525  }
526 
527  /* exponent strategy data */
528  if (ac3_exponent_strategy) {
529  /* AC-3-style exponent strategy syntax */
530  for (blk = 0; blk < s->num_blocks; blk++) {
531  for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
532  s->exp_strategy[blk][ch] = get_bits(gbc, 2);
533  }
534  }
535  } else {
536  /* LUT-based exponent strategy syntax */
537  for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
538  int frmchexpstr = get_bits(gbc, 5);
539  for (blk = 0; blk < 6; blk++) {
540  s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
541  }
542  }
543  }
544  /* LFE exponent strategy */
545  if (s->lfe_on) {
546  for (blk = 0; blk < s->num_blocks; blk++) {
547  s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
548  }
549  }
550  /* original exponent strategies if this stream was converted from AC-3 */
551  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
552  (s->num_blocks == 6 || get_bits1(gbc))) {
553  skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
554  }
555 
556  /* determine which channels use AHT */
557  if (parse_aht_info) {
558  /* For AHT to be used, all non-zero blocks must reuse exponents from
559  the first block. Furthermore, for AHT to be used in the coupling
560  channel, all blocks must use coupling and use the same coupling
561  strategy. */
562  s->channel_uses_aht[CPL_CH]=0;
563  for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
564  int use_aht = 1;
565  for (blk = 1; blk < 6; blk++) {
566  if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
567  (!ch && s->cpl_strategy_exists[blk])) {
568  use_aht = 0;
569  break;
570  }
571  }
572  s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
573  }
574  } else {
575  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
576  }
577 
578  /* per-frame SNR offset */
579  if (!s->snr_offset_strategy) {
580  int csnroffst = (get_bits(gbc, 6) - 15) << 4;
581  int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
582  for (ch = 0; ch <= s->channels; ch++)
583  s->snr_offset[ch] = snroffst;
584  }
585 
586  /* transient pre-noise processing data */
587  if (parse_transient_proc_info) {
588  for (ch = 1; ch <= s->fbw_channels; ch++) {
589  if (get_bits1(gbc)) { // channel in transient processing
590  skip_bits(gbc, 10); // skip transient processing location
591  skip_bits(gbc, 8); // skip transient processing length
592  }
593  }
594  }
595 
596  /* spectral extension attenuation data */
597  for (ch = 1; ch <= s->fbw_channels; ch++) {
598  if (parse_spx_atten_data && get_bits1(gbc)) {
599  s->spx_atten_code[ch] = get_bits(gbc, 5);
600  } else {
601  s->spx_atten_code[ch] = -1;
602  }
603  }
604 
605  /* block start information */
606  if (s->num_blocks > 1 && get_bits1(gbc)) {
607  /* reference: Section E2.3.2.27
608  nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
609  The spec does not say what this data is or what it's used for.
610  It is likely the offset of each block within the frame. */
611  int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
612  skip_bits_long(gbc, block_start_bits);
613  avpriv_request_sample(s->avctx, "Block start info");
614  }
615 
616  /* syntax state initialization */
617  for (ch = 1; ch <= s->fbw_channels; ch++) {
618  s->first_spx_coords[ch] = 1;
619  s->first_cpl_coords[ch] = 1;
620  }
621  s->first_cpl_leak = 1;
622 
623  return 0;
624 }
EAC3GaqMode
gain adaptive quantization mode
Definition: eac3dec.c:50
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:280
const float ff_eac3_spx_atten_tab[32][3]
Table E.25: Spectral Extension Attenuation Table ff_eac3_spx_atten_tab[code][bin]=pow(2.0,(bin+1)*(code+1)/-15.0);.
Definition: eac3_data.c:1101
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
const uint8_t ff_ac3_ungroup_3_in_5_bits_tab[32][3]
Table used to ungroup 3 values stored in 5 bits.
Definition: ac3dec_data.c:35
static int ff_eac3_parse_header(AC3DecodeContext *s)
Definition: eac3dec.c:289
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
#define AC3_MAX_COEFS
Definition: ac3.h:35
#define avpriv_request_sample(...)
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_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),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){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) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;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)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8: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);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=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){int planes=out->planar?out->ch_count:1;unsigned m=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){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int av_log2(unsigned v)
Definition: intmath.c:26
#define EXP_REUSE
Definition: ac3.h:48
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:288
#define blk(i)
Definition: sha.c:185
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
float INTFLOAT
Definition: aac_defines.h:86
#define COEFF_0
lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23))
Definition: eac3dec.c:154
uint8_t
#define f(width, name)
Definition: cbs_vp9.c:255
#define av_log(a,...)
static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
Definition: eac3dec.c:196
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:284
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define COEFF_2
lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23))
Definition: eac3dec.c:160
uint8_t bits
Definition: vp3data.h:202
#define EAC3_SR_CODE_REDUCED
Definition: eac3dec.c:57
#define powf(x, y)
Definition: libm.h:50
static void idct6(int pre_mant[6])
Calculate 6-point IDCT of the pre-mantissas.
Definition: eac3dec.c:166
#define AC3_HEAVY_RANGE(x)
Definition: ac3.h:91
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
int32_t
const int16_t ff_eac3_gaq_remap_1[12]
Table E3.6, Gk=1 No gain (Gk=1) inverse quantization, remapping scale factors ff_eac3_gaq_remap[hebap...
Definition: eac3_data.c:40
#define s(width, name)
Definition: cbs_vp9.c:257
const int16_t ff_eac3_gaq_remap_2_4_a[9][2]
Table E3.6, Gk=2 & Gk=4, A Large mantissa inverse quantization, remapping scale factors ff_eac3_gaq_r...
Definition: eac3_data.c:49
#define COEFF_1
lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23))
Definition: eac3dec.c:157
const uint8_t ff_eac3_bits_vs_hebap[20]
Definition: eac3_data.c:30
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define CPL_CH
coupling channel index
Definition: ac3.h:33
Libavcodec external API header.
const int16_t ff_eac3_gaq_remap_2_4_b[9][2]
Table E3.6, Gk=2 & Gk=4, B Large mantissa inverse quantization, negative mantissa remapping offsets f...
Definition: eac3_data.c:66
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
Definition: eac3dec.c:59
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:47
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:296
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
const uint64_t ff_eac3_custom_channel_map_locations[16][2]
Definition: ac3tab.c:317
common internal api header.
const uint8_t ff_eac3_frm_expstr[32][6]
Table E2.14 Frame Exponent Strategy Combinations.
Definition: eac3_data.c:1062
#define EAC3_MAX_CHANNELS
maximum number of channels in EAC3
Definition: ac3.h:31
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
const int16_t(*const [8] ff_eac3_mantissa_vq)[6]
Definition: eac3_data.c:1048
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:292
Common code between the AC-3 encoder and decoder.
static uint8_t tmp[11]
Definition: aes_ctr.c:26