Statistics
| Branch: | Revision:

ffmpeg / libavcodec / eac3dec.c @ 2912e87a

History | View | Annotate | Download (22.4 KB)

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 Libav.
7
 *
8
 * Libav 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
 * Libav 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 Libav; 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 "ac3_parser.h"
52
#include "ac3dec.h"
53
#include "ac3dec_data.h"
54
#include "eac3dec_data.h"
55

    
56
/** gain adaptive quantization mode */
57
typedef enum {
58
    EAC3_GAQ_NO =0,
59
    EAC3_GAQ_12,
60
    EAC3_GAQ_14,
61
    EAC3_GAQ_124
62
} EAC3GaqMode;
63

    
64
#define EAC3_SR_CODE_REDUCED  3
65

    
66
void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
67
{
68
    int bin, bnd, ch, i;
69
    uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
70
    float rms_energy[SPX_MAX_BANDS];
71

    
72
    /* Set copy index mapping table. Set wrap flags to apply a notch filter at
73
       wrap points later on. */
74
    bin = s->spx_dst_start_freq;
75
    num_copy_sections = 0;
76
    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
77
        int copysize;
78
        int bandsize = s->spx_band_sizes[bnd];
79
        if (bin + bandsize > s->spx_src_start_freq) {
80
            copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
81
            bin = s->spx_dst_start_freq;
82
            wrapflag[bnd] = 1;
83
        }
84
        for (i = 0; i < bandsize; i += copysize) {
85
            if (bin == s->spx_src_start_freq) {
86
                copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
87
                bin = s->spx_dst_start_freq;
88
            }
89
            copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
90
            bin += copysize;
91
        }
92
    }
93
    copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
94

    
95
    for (ch = 1; ch <= s->fbw_channels; ch++) {
96
        if (!s->channel_uses_spx[ch])
97
            continue;
98

    
99
        /* Copy coeffs from normal bands to extension bands */
100
        bin = s->spx_src_start_freq;
101
        for (i = 0; i < num_copy_sections; i++) {
102
            memcpy(&s->transform_coeffs[ch][bin],
103
                   &s->transform_coeffs[ch][s->spx_dst_start_freq],
104
                   copy_sizes[i]*sizeof(float));
105
            bin += copy_sizes[i];
106
        }
107

    
108
        /* Calculate RMS energy for each SPX band. */
109
        bin = s->spx_src_start_freq;
110
        for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
111
            int bandsize = s->spx_band_sizes[bnd];
112
            float accum = 0.0f;
113
            for (i = 0; i < bandsize; i++) {
114
                float coeff = s->transform_coeffs[ch][bin++];
115
                accum += coeff * coeff;
116
            }
117
            rms_energy[bnd] = sqrtf(accum / bandsize);
118
        }
119

    
120
        /* Apply a notch filter at transitions between normal and extension
121
           bands and at all wrap points. */
122
        if (s->spx_atten_code[ch] >= 0) {
123
            const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
124
            bin = s->spx_src_start_freq - 2;
125
            for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
126
                if (wrapflag[bnd]) {
127
                    float *coeffs = &s->transform_coeffs[ch][bin];
128
                    coeffs[0] *= atten_tab[0];
129
                    coeffs[1] *= atten_tab[1];
130
                    coeffs[2] *= atten_tab[2];
131
                    coeffs[3] *= atten_tab[1];
132
                    coeffs[4] *= atten_tab[0];
133
                }
134
                bin += s->spx_band_sizes[bnd];
135
            }
136
        }
137

    
138
        /* Apply noise-blended coefficient scaling based on previously
139
           calculated RMS energy, blending factors, and SPX coordinates for
140
           each band. */
141
        bin = s->spx_src_start_freq;
142
        for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
143
            float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f/(1<<31));
144
            float sscale = s->spx_signal_blend[ch][bnd];
145
            for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
146
                float noise  = 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
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] << 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 <<= (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] << 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 <<= 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
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_DEPENDENT) {
303
        av_log_missing_feature(s->avctx, "Dependent substream decoding", 1);
304
        return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
305
    } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
306
        av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
307
        return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
308
    }
309

    
310
    /* The substream id indicates which substream this frame belongs to. each
311
       independent stream has its own substream id, and the dependent streams
312
       associated to an independent stream have matching substream id's. */
313
    if (s->substreamid) {
314
        /* only decode substream with id=0. skip any additional substreams. */
315
        av_log_missing_feature(s->avctx, "Additional substreams", 1);
316
        return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
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
        av_log_missing_feature(s->avctx, "Reduced sampling rates", 1);
325
        return -1;
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
        skip_bits(gbc, 5); // skip dialog normalization
332
        if (get_bits1(gbc)) {
333
            skip_bits(gbc, 8); // skip compression gain word
334
        }
335
    }
336

    
337
    /* dependent stream channel map */
338
    if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
339
        if (get_bits1(gbc)) {
340
            skip_bits(gbc, 16); // skip custom channel map
341
        }
342
    }
343

    
344
    /* mixing metadata */
345
    if (get_bits1(gbc)) {
346
        /* center and surround mix levels */
347
        if (s->channel_mode > AC3_CHMODE_STEREO) {
348
            skip_bits(gbc, 2);  // skip preferred stereo downmix mode
349
            if (s->channel_mode & 1) {
350
                /* if three front channels exist */
351
                skip_bits(gbc, 3); //skip Lt/Rt center mix level
352
                s->center_mix_level = get_bits(gbc, 3);
353
            }
354
            if (s->channel_mode & 4) {
355
                /* if a surround channel exists */
356
                skip_bits(gbc, 3); //skip Lt/Rt surround mix level
357
                s->surround_mix_level = get_bits(gbc, 3);
358
            }
359
        }
360

    
361
        /* lfe mix level */
362
        if (s->lfe_on && get_bits1(gbc)) {
363
            // TODO: use LFE mix level
364
            skip_bits(gbc, 5); // skip LFE mix level code
365
        }
366

    
367
        /* info for mixing with other streams and substreams */
368
        if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
369
            for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
370
                // TODO: apply program scale factor
371
                if (get_bits1(gbc)) {
372
                    skip_bits(gbc, 6);  // skip program scale factor
373
                }
374
            }
375
            if (get_bits1(gbc)) {
376
                skip_bits(gbc, 6);  // skip external program scale factor
377
            }
378
            /* skip mixing parameter data */
379
            switch(get_bits(gbc, 2)) {
380
                case 1: skip_bits(gbc, 5);  break;
381
                case 2: skip_bits(gbc, 12); break;
382
                case 3: {
383
                    int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
384
                    skip_bits_long(gbc, mix_data_size);
385
                    break;
386
                }
387
            }
388
            /* skip pan information for mono or dual mono source */
389
            if (s->channel_mode < AC3_CHMODE_STEREO) {
390
                for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
391
                    if (get_bits1(gbc)) {
392
                        /* note: this is not in the ATSC A/52B specification
393
                           reference: ETSI TS 102 366 V1.1.1
394
                                      section: E.1.3.1.25 */
395
                        skip_bits(gbc, 8);  // skip pan mean direction index
396
                        skip_bits(gbc, 6);  // skip reserved paninfo bits
397
                    }
398
                }
399
            }
400
            /* skip mixing configuration information */
401
            if (get_bits1(gbc)) {
402
                for (blk = 0; blk < s->num_blocks; blk++) {
403
                    if (s->num_blocks == 1 || get_bits1(gbc)) {
404
                        skip_bits(gbc, 5);
405
                    }
406
                }
407
            }
408
        }
409
    }
410

    
411
    /* informational metadata */
412
    if (get_bits1(gbc)) {
413
        skip_bits(gbc, 3); // skip bit stream mode
414
        skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
415
        if (s->channel_mode == AC3_CHMODE_STEREO) {
416
            skip_bits(gbc, 4); // skip Dolby surround and headphone mode
417
        }
418
        if (s->channel_mode >= AC3_CHMODE_2F2R) {
419
            skip_bits(gbc, 2); // skip Dolby surround EX mode
420
        }
421
        for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
422
            if (get_bits1(gbc)) {
423
                skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
424
            }
425
        }
426
        if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
427
            skip_bits1(gbc); // skip source sample rate code
428
        }
429
    }
430

    
431
    /* converter synchronization flag
432
       If frames are less than six blocks, this bit should be turned on
433
       once every 6 blocks to indicate the start of a frame set.
434
       reference: RFC 4598, Section 2.1.3  Frame Sets */
435
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
436
        skip_bits1(gbc); // skip converter synchronization flag
437
    }
438

    
439
    /* original frame size code if this stream was converted from AC-3 */
440
    if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
441
            (s->num_blocks == 6 || get_bits1(gbc))) {
442
        skip_bits(gbc, 6); // skip frame size code
443
    }
444

    
445
    /* additional bitstream info */
446
    if (get_bits1(gbc)) {
447
        int addbsil = get_bits(gbc, 6);
448
        for (i = 0; i < addbsil + 1; i++) {
449
            skip_bits(gbc, 8); // skip additional bit stream info
450
        }
451
    }
452

    
453
    /* audio frame syntax flags, strategy data, and per-frame data */
454

    
455
    if (s->num_blocks == 6) {
456
        ac3_exponent_strategy = get_bits1(gbc);
457
        parse_aht_info        = get_bits1(gbc);
458
    } else {
459
        /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
460
           do not use AHT */
461
        ac3_exponent_strategy = 1;
462
        parse_aht_info = 0;
463
    }
464

    
465
    s->snr_offset_strategy    = get_bits(gbc, 2);
466
    parse_transient_proc_info = get_bits1(gbc);
467

    
468
    s->block_switch_syntax = get_bits1(gbc);
469
    if (!s->block_switch_syntax)
470
        memset(s->block_switch, 0, sizeof(s->block_switch));
471

    
472
    s->dither_flag_syntax = get_bits1(gbc);
473
    if (!s->dither_flag_syntax) {
474
        for (ch = 1; ch <= s->fbw_channels; ch++)
475
            s->dither_flag[ch] = 1;
476
    }
477
    s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
478

    
479
    s->bit_allocation_syntax = get_bits1(gbc);
480
    if (!s->bit_allocation_syntax) {
481
        /* set default bit allocation parameters */
482
        s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
483
        s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
484
        s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab [1];
485
        s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
486
        s->bit_alloc_params.floor      = ff_ac3_floor_tab     [7];
487
    }
488

    
489
    s->fast_gain_syntax  = get_bits1(gbc);
490
    s->dba_syntax        = get_bits1(gbc);
491
    s->skip_syntax       = get_bits1(gbc);
492
    parse_spx_atten_data = get_bits1(gbc);
493

    
494
    /* coupling strategy occurance and coupling use per block */
495
    num_cpl_blocks = 0;
496
    if (s->channel_mode > 1) {
497
        for (blk = 0; blk < s->num_blocks; blk++) {
498
            s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
499
            if (s->cpl_strategy_exists[blk]) {
500
                s->cpl_in_use[blk] = get_bits1(gbc);
501
            } else {
502
                s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
503
            }
504
            num_cpl_blocks += s->cpl_in_use[blk];
505
        }
506
    } else {
507
        memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
508
    }
509

    
510
    /* exponent strategy data */
511
    if (ac3_exponent_strategy) {
512
        /* AC-3-style exponent strategy syntax */
513
        for (blk = 0; blk < s->num_blocks; blk++) {
514
            for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
515
                s->exp_strategy[blk][ch] = get_bits(gbc, 2);
516
            }
517
        }
518
    } else {
519
        /* LUT-based exponent strategy syntax */
520
        for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
521
            int frmchexpstr = get_bits(gbc, 5);
522
            for (blk = 0; blk < 6; blk++) {
523
                s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
524
            }
525
        }
526
    }
527
    /* LFE exponent strategy */
528
    if (s->lfe_on) {
529
        for (blk = 0; blk < s->num_blocks; blk++) {
530
            s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
531
        }
532
    }
533
    /* original exponent strategies if this stream was converted from AC-3 */
534
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
535
            (s->num_blocks == 6 || get_bits1(gbc))) {
536
        skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
537
    }
538

    
539
    /* determine which channels use AHT */
540
    if (parse_aht_info) {
541
        /* For AHT to be used, all non-zero blocks must reuse exponents from
542
           the first block.  Furthermore, for AHT to be used in the coupling
543
           channel, all blocks must use coupling and use the same coupling
544
           strategy. */
545
        s->channel_uses_aht[CPL_CH]=0;
546
        for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
547
            int use_aht = 1;
548
            for (blk = 1; blk < 6; blk++) {
549
                if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
550
                        (!ch && s->cpl_strategy_exists[blk])) {
551
                    use_aht = 0;
552
                    break;
553
                }
554
            }
555
            s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
556
        }
557
    } else {
558
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
559
    }
560

    
561
    /* per-frame SNR offset */
562
    if (!s->snr_offset_strategy) {
563
        int csnroffst = (get_bits(gbc, 6) - 15) << 4;
564
        int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
565
        for (ch = 0; ch <= s->channels; ch++)
566
            s->snr_offset[ch] = snroffst;
567
    }
568

    
569
    /* transient pre-noise processing data */
570
    if (parse_transient_proc_info) {
571
        for (ch = 1; ch <= s->fbw_channels; ch++) {
572
            if (get_bits1(gbc)) { // channel in transient processing
573
                skip_bits(gbc, 10); // skip transient processing location
574
                skip_bits(gbc, 8);  // skip transient processing length
575
            }
576
        }
577
    }
578

    
579
    /* spectral extension attenuation data */
580
    for (ch = 1; ch <= s->fbw_channels; ch++) {
581
        if (parse_spx_atten_data && get_bits1(gbc)) {
582
            s->spx_atten_code[ch] = get_bits(gbc, 5);
583
        } else {
584
            s->spx_atten_code[ch] = -1;
585
        }
586
    }
587

    
588
    /* block start information */
589
    if (s->num_blocks > 1 && get_bits1(gbc)) {
590
        /* reference: Section E2.3.2.27
591
           nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
592
           The spec does not say what this data is or what it's used for.
593
           It is likely the offset of each block within the frame. */
594
        int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
595
        skip_bits_long(gbc, block_start_bits);
596
        av_log_missing_feature(s->avctx, "Block start info", 1);
597
    }
598

    
599
    /* syntax state initialization */
600
    for (ch = 1; ch <= s->fbw_channels; ch++) {
601
        s->first_spx_coords[ch] = 1;
602
        s->first_cpl_coords[ch] = 1;
603
    }
604
    s->first_cpl_leak = 1;
605

    
606
    return 0;
607
}