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