FFmpeg  4.3.6
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  if (nscale < -1.0)
143  nscale = -1.0;
144 #endif
145  for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
146  UINTFLOAT noise = (INTFLOAT)(nscale * (int32_t)av_lfg_get(&s->dith_state));
147  s->transform_coeffs[ch][bin] *= sscale;
148  s->transform_coeffs[ch][bin++] += noise;
149  }
150  }
151  }
152 }
153 
154 
155 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
156 #define COEFF_0 10273905LL
157 
158 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
159 #define COEFF_1 11863283LL
160 
161 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
162 #define COEFF_2 3070444LL
163 
164 /**
165  * Calculate 6-point IDCT of the pre-mantissas.
166  * All calculations are 24-bit fixed-point.
167  */
168 static void idct6(int pre_mant[6])
169 {
170  int tmp;
171  int even0, even1, even2, odd0, odd1, odd2;
172 
173  odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
174 
175  even2 = ( pre_mant[2] * COEFF_0) >> 23;
176  tmp = ( pre_mant[4] * COEFF_1) >> 23;
177  odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
178 
179  even0 = pre_mant[0] + (tmp >> 1);
180  even1 = pre_mant[0] - tmp;
181 
182  tmp = even0;
183  even0 = tmp + even2;
184  even2 = tmp - even2;
185 
186  tmp = odd0;
187  odd0 = tmp + pre_mant[1] + pre_mant[3];
188  odd2 = tmp + pre_mant[5] - pre_mant[3];
189 
190  pre_mant[0] = even0 + odd0;
191  pre_mant[1] = even1 + odd1;
192  pre_mant[2] = even2 + odd2;
193  pre_mant[3] = even2 - odd2;
194  pre_mant[4] = even1 - odd1;
195  pre_mant[5] = even0 - odd0;
196 }
197 
198 static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
199 {
200  int bin, blk, gs;
201  int end_bap, gaq_mode;
202  GetBitContext *gbc = &s->gbc;
203  int gaq_gain[AC3_MAX_COEFS];
204 
205  gaq_mode = get_bits(gbc, 2);
206  end_bap = (gaq_mode < 2) ? 12 : 17;
207 
208  /* if GAQ gain is used, decode gain codes for bins with hebap between
209  8 and end_bap */
210  gs = 0;
211  if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
212  /* read 1-bit GAQ gain codes */
213  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
214  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
215  gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
216  }
217  } else if (gaq_mode == EAC3_GAQ_124) {
218  /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
219  int gc = 2;
220  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
221  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
222  if (gc++ == 2) {
223  int group_code = get_bits(gbc, 5);
224  if (group_code > 26) {
225  av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
226  group_code = 26;
227  }
228  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
229  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
230  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
231  gc = 0;
232  }
233  }
234  }
235  }
236 
237  gs=0;
238  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
239  int hebap = s->bap[ch][bin];
240  int bits = ff_eac3_bits_vs_hebap[hebap];
241  if (!hebap) {
242  /* zero-mantissa dithering */
243  for (blk = 0; blk < 6; blk++) {
244  s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
245  }
246  } else if (hebap < 8) {
247  /* Vector Quantization */
248  int v = get_bits(gbc, bits);
249  for (blk = 0; blk < 6; blk++) {
250  s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8);
251  }
252  } else {
253  /* Gain Adaptive Quantization */
254  int gbits, log_gain;
255  if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
256  log_gain = gaq_gain[gs++];
257  } else {
258  log_gain = 0;
259  }
260  gbits = bits - log_gain;
261 
262  for (blk = 0; blk < 6; blk++) {
263  int mant = get_sbits(gbc, gbits);
264  if (log_gain && mant == -(1 << (gbits-1))) {
265  /* large mantissa */
266  int b;
267  int mbits = bits - (2 - log_gain);
268  mant = get_sbits(gbc, mbits);
269  mant = ((unsigned)mant) << (23 - (mbits - 1));
270  /* remap mantissa value to correct for asymmetric quantization */
271  if (mant >= 0)
272  b = 1 << (23 - log_gain);
273  else
274  b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);
275  mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
276  } else {
277  /* small mantissa, no GAQ, or Gk=1 */
278  mant *= (1 << 24 - bits);
279  if (!log_gain) {
280  /* remap mantissa value for no GAQ or Gk=1 */
281  mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
282  }
283  }
284  s->pre_mantissa[ch][bin][blk] = mant;
285  }
286  }
287  idct6(s->pre_mantissa[ch][bin]);
288  }
289 }
290 
291 static int ff_eac3_parse_header(AC3DecodeContext *s)
292 {
293  int i, blk, ch;
294  int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
295  int parse_transient_proc_info;
296  int num_cpl_blocks;
297  GetBitContext *gbc = &s->gbc;
298 
299  /* An E-AC-3 stream can have multiple independent streams which the
300  application can select from. each independent stream can also contain
301  dependent streams which are used to add or replace channels. */
302  if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
303  av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
305  }
306 
307  /* The substream id indicates which substream this frame belongs to. each
308  independent stream has its own substream id, and the dependent streams
309  associated to an independent stream have matching substream id's. */
310  if (s->substreamid) {
311  /* only decode substream with id=0. skip any additional substreams. */
312  if (!s->eac3_subsbtreamid_found) {
313  s->eac3_subsbtreamid_found = 1;
314  avpriv_request_sample(s->avctx, "Additional substreams");
315  }
317  }
318 
319  if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
320  /* The E-AC-3 specification does not tell how to handle reduced sample
321  rates in bit allocation. The best assumption would be that it is
322  handled like AC-3 DolbyNet, but we cannot be sure until we have a
323  sample which utilizes this feature. */
324  avpriv_request_sample(s->avctx, "Reduced sampling rate");
325  return AVERROR_PATCHWELCOME;
326  }
327  skip_bits(gbc, 5); // skip bitstream id
328 
329  /* volume control params */
330  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
331  s->dialog_normalization[i] = -get_bits(gbc, 5);
332  if (s->dialog_normalization[i] == 0) {
333  s->dialog_normalization[i] = -31;
334  }
335  if (s->target_level != 0) {
336  s->level_gain[i] = powf(2.0f,
337  (float)(s->target_level - s->dialog_normalization[i])/6.0f);
338  }
339  s->compression_exists[i] = get_bits1(gbc);
340  if (s->compression_exists[i]) {
341  s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(get_bits(gbc, 8));
342  }
343  }
344 
345  /* dependent stream channel map */
346  if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
347  if (get_bits1(gbc)) {
348  int64_t channel_layout = 0;
349  int channel_map = get_bits(gbc, 16);
350  av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", channel_map);
351 
352  for (i = 0; i < 16; i++)
353  if (channel_map & (1 << (EAC3_MAX_CHANNELS - i - 1)))
354  channel_layout |= ff_eac3_custom_channel_map_locations[i][1];
355 
356  if (av_popcount64(channel_layout) > EAC3_MAX_CHANNELS) {
357  return AVERROR_INVALIDDATA;
358  }
359  s->channel_map = channel_map;
360  }
361  }
362 
363  /* mixing metadata */
364  if (get_bits1(gbc)) {
365  /* center and surround mix levels */
366  if (s->channel_mode > AC3_CHMODE_STEREO) {
367  s->preferred_downmix = get_bits(gbc, 2);
368  if (s->channel_mode & 1) {
369  /* if three front channels exist */
370  s->center_mix_level_ltrt = get_bits(gbc, 3);
371  s->center_mix_level = get_bits(gbc, 3);
372  }
373  if (s->channel_mode & 4) {
374  /* if a surround channel exists */
375  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
376  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
377  }
378  }
379 
380  /* lfe mix level */
381  if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
382  s->lfe_mix_level = get_bits(gbc, 5);
383  }
384 
385  /* info for mixing with other streams and substreams */
386  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
387  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
388  // TODO: apply program scale factor
389  if (get_bits1(gbc)) {
390  skip_bits(gbc, 6); // skip program scale factor
391  }
392  }
393  if (get_bits1(gbc)) {
394  skip_bits(gbc, 6); // skip external program scale factor
395  }
396  /* skip mixing parameter data */
397  switch(get_bits(gbc, 2)) {
398  case 1: skip_bits(gbc, 5); break;
399  case 2: skip_bits(gbc, 12); break;
400  case 3: {
401  int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
402  skip_bits_long(gbc, mix_data_size);
403  break;
404  }
405  }
406  /* skip pan information for mono or dual mono source */
407  if (s->channel_mode < AC3_CHMODE_STEREO) {
408  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
409  if (get_bits1(gbc)) {
410  /* note: this is not in the ATSC A/52B specification
411  reference: ETSI TS 102 366 V1.1.1
412  section: E.1.3.1.25 */
413  skip_bits(gbc, 8); // skip pan mean direction index
414  skip_bits(gbc, 6); // skip reserved paninfo bits
415  }
416  }
417  }
418  /* skip mixing configuration information */
419  if (get_bits1(gbc)) {
420  for (blk = 0; blk < s->num_blocks; blk++) {
421  if (s->num_blocks == 1 || get_bits1(gbc)) {
422  skip_bits(gbc, 5);
423  }
424  }
425  }
426  }
427  }
428 
429  /* informational metadata */
430  if (get_bits1(gbc)) {
431  s->bitstream_mode = get_bits(gbc, 3);
432  skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
433  if (s->channel_mode == AC3_CHMODE_STEREO) {
434  s->dolby_surround_mode = get_bits(gbc, 2);
435  s->dolby_headphone_mode = get_bits(gbc, 2);
436  }
437  if (s->channel_mode >= AC3_CHMODE_2F2R) {
438  s->dolby_surround_ex_mode = get_bits(gbc, 2);
439  }
440  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
441  if (get_bits1(gbc)) {
442  skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
443  }
444  }
445  if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
446  skip_bits1(gbc); // skip source sample rate code
447  }
448  }
449 
450  /* converter synchronization flag
451  If frames are less than six blocks, this bit should be turned on
452  once every 6 blocks to indicate the start of a frame set.
453  reference: RFC 4598, Section 2.1.3 Frame Sets */
454  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
455  skip_bits1(gbc); // skip converter synchronization flag
456  }
457 
458  /* original frame size code if this stream was converted from AC-3 */
459  if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
460  (s->num_blocks == 6 || get_bits1(gbc))) {
461  skip_bits(gbc, 6); // skip frame size code
462  }
463 
464  /* additional bitstream info */
465  if (get_bits1(gbc)) {
466  int addbsil = get_bits(gbc, 6);
467  for (i = 0; i < addbsil + 1; i++) {
468  skip_bits(gbc, 8); // skip additional bit stream info
469  }
470  }
471 
472  /* audio frame syntax flags, strategy data, and per-frame data */
473 
474  if (s->num_blocks == 6) {
475  ac3_exponent_strategy = get_bits1(gbc);
476  parse_aht_info = get_bits1(gbc);
477  } else {
478  /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
479  do not use AHT */
480  ac3_exponent_strategy = 1;
481  parse_aht_info = 0;
482  }
483 
484  s->snr_offset_strategy = get_bits(gbc, 2);
485  parse_transient_proc_info = get_bits1(gbc);
486 
487  s->block_switch_syntax = get_bits1(gbc);
488  if (!s->block_switch_syntax)
489  memset(s->block_switch, 0, sizeof(s->block_switch));
490 
491  s->dither_flag_syntax = get_bits1(gbc);
492  if (!s->dither_flag_syntax) {
493  for (ch = 1; ch <= s->fbw_channels; ch++)
494  s->dither_flag[ch] = 1;
495  }
496  s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
497 
498  s->bit_allocation_syntax = get_bits1(gbc);
499  if (!s->bit_allocation_syntax) {
500  /* set default bit allocation parameters */
501  s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
502  s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
503  s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
504  s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
505  s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
506  }
507 
508  s->fast_gain_syntax = get_bits1(gbc);
509  s->dba_syntax = get_bits1(gbc);
510  s->skip_syntax = get_bits1(gbc);
511  parse_spx_atten_data = get_bits1(gbc);
512 
513  /* coupling strategy occurrence and coupling use per block */
514  num_cpl_blocks = 0;
515  if (s->channel_mode > 1) {
516  for (blk = 0; blk < s->num_blocks; blk++) {
517  s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
518  if (s->cpl_strategy_exists[blk]) {
519  s->cpl_in_use[blk] = get_bits1(gbc);
520  } else {
521  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
522  }
523  num_cpl_blocks += s->cpl_in_use[blk];
524  }
525  } else {
526  memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
527  }
528 
529  /* exponent strategy data */
530  if (ac3_exponent_strategy) {
531  /* AC-3-style exponent strategy syntax */
532  for (blk = 0; blk < s->num_blocks; blk++) {
533  for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
534  s->exp_strategy[blk][ch] = get_bits(gbc, 2);
535  }
536  }
537  } else {
538  /* LUT-based exponent strategy syntax */
539  for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
540  int frmchexpstr = get_bits(gbc, 5);
541  for (blk = 0; blk < 6; blk++) {
542  s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
543  }
544  }
545  }
546  /* LFE exponent strategy */
547  if (s->lfe_on) {
548  for (blk = 0; blk < s->num_blocks; blk++) {
549  s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
550  }
551  }
552  /* original exponent strategies if this stream was converted from AC-3 */
553  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
554  (s->num_blocks == 6 || get_bits1(gbc))) {
555  skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
556  }
557 
558  /* determine which channels use AHT */
559  if (parse_aht_info) {
560  /* For AHT to be used, all non-zero blocks must reuse exponents from
561  the first block. Furthermore, for AHT to be used in the coupling
562  channel, all blocks must use coupling and use the same coupling
563  strategy. */
564  s->channel_uses_aht[CPL_CH]=0;
565  for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
566  int use_aht = 1;
567  for (blk = 1; blk < 6; blk++) {
568  if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
569  (!ch && s->cpl_strategy_exists[blk])) {
570  use_aht = 0;
571  break;
572  }
573  }
574  s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
575  }
576  } else {
577  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
578  }
579 
580  /* per-frame SNR offset */
581  if (!s->snr_offset_strategy) {
582  int csnroffst = (get_bits(gbc, 6) - 15) << 4;
583  int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
584  for (ch = 0; ch <= s->channels; ch++)
585  s->snr_offset[ch] = snroffst;
586  }
587 
588  /* transient pre-noise processing data */
589  if (parse_transient_proc_info) {
590  for (ch = 1; ch <= s->fbw_channels; ch++) {
591  if (get_bits1(gbc)) { // channel in transient processing
592  skip_bits(gbc, 10); // skip transient processing location
593  skip_bits(gbc, 8); // skip transient processing length
594  }
595  }
596  }
597 
598  /* spectral extension attenuation data */
599  for (ch = 1; ch <= s->fbw_channels; ch++) {
600  if (parse_spx_atten_data && get_bits1(gbc)) {
601  s->spx_atten_code[ch] = get_bits(gbc, 5);
602  } else {
603  s->spx_atten_code[ch] = -1;
604  }
605  }
606 
607  /* block start information */
608  if (s->num_blocks > 1 && get_bits1(gbc)) {
609  /* reference: Section E2.3.2.27
610  nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
611  The spec does not say what this data is or what it's used for.
612  It is likely the offset of each block within the frame. */
613  int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
614  skip_bits_long(gbc, block_start_bits);
615  avpriv_request_sample(s->avctx, "Block start info");
616  }
617 
618  /* syntax state initialization */
619  for (ch = 1; ch <= s->fbw_channels; ch++) {
620  s->first_spx_coords[ch] = 1;
621  s->first_cpl_coords[ch] = 1;
622  }
623  s->first_cpl_leak = 1;
624 
625  return 0;
626 }
float UINTFLOAT
Definition: aac_defines.h:87
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:291
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(...)
const char * b
Definition: vf_curves.c:116
#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:156
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:198
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#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:162
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:168
#define AC3_HEAVY_RANGE(x)
Definition: ac3.h:92
#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:159
#define INTFLOAT
const uint8_t ff_eac3_bits_vs_hebap[20]
Definition: eac3_data.c:30
#define av_log2
Definition: intmath.h:83
#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:53
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:36
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