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 {
51 EAC3_GAQ_NO =0,
52 EAC3_GAQ_12,
53 EAC3_GAQ_14,
54 EAC3_GAQ_124
55 } EAC3GaqMode;
56
57 #define EAC3_SR_CODE_REDUCED 3
58
ff_eac3_apply_spectral_extension(AC3DecodeContext * s)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 */
idct6(int pre_mant[6])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
ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext * s,int ch)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
ff_eac3_parse_header(AC3DecodeContext * s)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");
302 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
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 }
314 return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
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 }
625