git.sesse.net Git - ffmpeg/blob - 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_DEPENDENT) {
 307         if (!s->eac3_frame_dependent_found) {
 308             s->eac3_frame_dependent_found = 1;
 309             avpriv_request_sample(s->avctx, "Dependent substream decoding");
 310         }
 311         return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
 312     } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
 313         av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
 314         return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
 315     }
 316
 317     /* The substream id indicates which substream this frame belongs to. each
 318        independent stream has its own substream id, and the dependent streams
 319        associated to an independent stream have matching substream id's. */
 320     if (s->substreamid) {
 321         /* only decode substream with id=0. skip any additional substreams. */
 322         if (!s->eac3_subsbtreamid_found) {
 323             s->eac3_subsbtreamid_found = 1;
 324             avpriv_request_sample(s->avctx, "Additional substreams");
 325         }
 326         return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
 327     }
 328
 329     if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
 330         /* The E-AC-3 specification does not tell how to handle reduced sample
 331            rates in bit allocation.  The best assumption would be that it is
 332            handled like AC-3 DolbyNet, but we cannot be sure until we have a
 333            sample which utilizes this feature. */
 334         avpriv_request_sample(s->avctx, "Reduced sampling rate");
 335         return AVERROR_PATCHWELCOME;
 336     }
 337     skip_bits(gbc, 5); // skip bitstream id
 338
 339     /* volume control params */
 340     for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 341         s->dialog_normalization[i] = -get_bits(gbc, 5);
 342         if (s->dialog_normalization[i] == 0) {
 343             s->dialog_normalization[i] = -31;
 344         }
 345         if (s->target_level != 0) {
 346             s->level_gain[i] = powf(2.0f,
 347                 (float)(s->target_level - s->dialog_normalization[i])/6.0f);
 348         }
 349         s->compression_exists[i] = get_bits1(gbc);
 350         if (s->compression_exists[i]) {
 351             s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(get_bits(gbc, 8));
 352         }
 353     }
 354
 355     /* dependent stream channel map */
 356     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
 357         if (get_bits1(gbc)) {
 358             skip_bits(gbc, 16); // skip custom channel map
 359         }
 360     }
 361
 362     /* mixing metadata */
 363     if (get_bits1(gbc)) {
 364         /* center and surround mix levels */
 365         if (s->channel_mode > AC3_CHMODE_STEREO) {
 366             s->preferred_downmix = get_bits(gbc, 2);
 367             if (s->channel_mode & 1) {
 368                 /* if three front channels exist */
 369                 s->center_mix_level_ltrt = get_bits(gbc, 3);
 370                 s->center_mix_level      = get_bits(gbc, 3);
 371             }
 372             if (s->channel_mode & 4) {
 373                 /* if a surround channel exists */
 374                 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
 375                 s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
 376             }
 377         }
 378
 379         /* lfe mix level */
 380         if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
 381             s->lfe_mix_level = get_bits(gbc, 5);
 382         }
 383
 384         /* info for mixing with other streams and substreams */
 385         if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
 386             for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 387                 // TODO: apply program scale factor
 388                 if (get_bits1(gbc)) {
 389                     skip_bits(gbc, 6);  // skip program scale factor
 390                 }
 391             }
 392             if (get_bits1(gbc)) {
 393                 skip_bits(gbc, 6);  // skip external program scale factor
 394             }
 395             /* skip mixing parameter data */
 396             switch(get_bits(gbc, 2)) {
 397                 case 1: skip_bits(gbc, 5);  break;
 398                 case 2: skip_bits(gbc, 12); break;
 399                 case 3: {
 400                     int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
 401                     skip_bits_long(gbc, mix_data_size);
 402                     break;
 403                 }
 404             }
 405             /* skip pan information for mono or dual mono source */
 406             if (s->channel_mode < AC3_CHMODE_STEREO) {
 407                 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 408                     if (get_bits1(gbc)) {
 409                         /* note: this is not in the ATSC A/52B specification
 410                            reference: ETSI TS 102 366 V1.1.1
 411                                       section: E.1.3.1.25 */
 412                         skip_bits(gbc, 8);  // skip pan mean direction index
 413                         skip_bits(gbc, 6);  // skip reserved paninfo bits
 414                     }
 415                 }
 416             }
 417             /* skip mixing configuration information */
 418             if (get_bits1(gbc)) {
 419                 for (blk = 0; blk < s->num_blocks; blk++) {
 420                     if (s->num_blocks == 1 || get_bits1(gbc)) {
 421                         skip_bits(gbc, 5);
 422                     }
 423                 }
 424             }
 425         }
 426     }
 427
 428     /* informational metadata */
 429     if (get_bits1(gbc)) {
 430         s->bitstream_mode = get_bits(gbc, 3);
 431         skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
 432         if (s->channel_mode == AC3_CHMODE_STEREO) {
 433             s->dolby_surround_mode  = get_bits(gbc, 2);
 434             s->dolby_headphone_mode = get_bits(gbc, 2);
 435         }
 436         if (s->channel_mode >= AC3_CHMODE_2F2R) {
 437             s->dolby_surround_ex_mode = get_bits(gbc, 2);
 438         }
 439         for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 440             if (get_bits1(gbc)) {
 441                 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
 442             }
 443         }
 444         if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
 445             skip_bits1(gbc); // skip source sample rate code
 446         }
 447     }
 448
 449     /* converter synchronization flag
 450        If frames are less than six blocks, this bit should be turned on
 451        once every 6 blocks to indicate the start of a frame set.
 452        reference: RFC 4598, Section 2.1.3  Frame Sets */
 453     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
 454         skip_bits1(gbc); // skip converter synchronization flag
 455     }
 456
 457     /* original frame size code if this stream was converted from AC-3 */
 458     if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
 459             (s->num_blocks == 6 || get_bits1(gbc))) {
 460         skip_bits(gbc, 6); // skip frame size code
 461     }
 462
 463     /* additional bitstream info */
 464     if (get_bits1(gbc)) {
 465         int addbsil = get_bits(gbc, 6);
 466         for (i = 0; i < addbsil + 1; i++) {
 467             skip_bits(gbc, 8); // skip additional bit stream info
 468         }
 469     }
 470
 471     /* audio frame syntax flags, strategy data, and per-frame data */
 472
 473     if (s->num_blocks == 6) {
 474         ac3_exponent_strategy = get_bits1(gbc);
 475         parse_aht_info        = get_bits1(gbc);
 476     } else {
 477         /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
 478            do not use AHT */
 479         ac3_exponent_strategy = 1;
 480         parse_aht_info = 0;
 481     }
 482
 483     s->snr_offset_strategy    = get_bits(gbc, 2);
 484     parse_transient_proc_info = get_bits1(gbc);
 485
 486     s->block_switch_syntax = get_bits1(gbc);
 487     if (!s->block_switch_syntax)
 488         memset(s->block_switch, 0, sizeof(s->block_switch));
 489
 490     s->dither_flag_syntax = get_bits1(gbc);
 491     if (!s->dither_flag_syntax) {
 492         for (ch = 1; ch <= s->fbw_channels; ch++)
 493             s->dither_flag[ch] = 1;
 494     }
 495     s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
 496
 497     s->bit_allocation_syntax = get_bits1(gbc);
 498     if (!s->bit_allocation_syntax) {
 499         /* set default bit allocation parameters */
 500         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
 501         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
 502         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab [1];
 503         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
 504         s->bit_alloc_params.floor      = ff_ac3_floor_tab     [7];
 505     }
 506
 507     s->fast_gain_syntax  = get_bits1(gbc);
 508     s->dba_syntax        = get_bits1(gbc);
 509     s->skip_syntax       = get_bits1(gbc);
 510     parse_spx_atten_data = get_bits1(gbc);
 511
 512     /* coupling strategy occurrence and coupling use per block */
 513     num_cpl_blocks = 0;
 514     if (s->channel_mode > 1) {
 515         for (blk = 0; blk < s->num_blocks; blk++) {
 516             s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
 517             if (s->cpl_strategy_exists[blk]) {
 518                 s->cpl_in_use[blk] = get_bits1(gbc);
 519             } else {
 520                 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 521             }
 522             num_cpl_blocks += s->cpl_in_use[blk];
 523         }
 524     } else {
 525         memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
 526     }
 527
 528     /* exponent strategy data */
 529     if (ac3_exponent_strategy) {
 530         /* AC-3-style exponent strategy syntax */
 531         for (blk = 0; blk < s->num_blocks; blk++) {
 532             for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
 533                 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
 534             }
 535         }
 536     } else {
 537         /* LUT-based exponent strategy syntax */
 538         for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
 539             int frmchexpstr = get_bits(gbc, 5);
 540             for (blk = 0; blk < 6; blk++) {
 541                 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
 542             }
 543         }
 544     }
 545     /* LFE exponent strategy */
 546     if (s->lfe_on) {
 547         for (blk = 0; blk < s->num_blocks; blk++) {
 548             s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
 549         }
 550     }
 551     /* original exponent strategies if this stream was converted from AC-3 */
 552     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
 553             (s->num_blocks == 6 || get_bits1(gbc))) {
 554         skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
 555     }
 556
 557     /* determine which channels use AHT */
 558     if (parse_aht_info) {
 559         /* For AHT to be used, all non-zero blocks must reuse exponents from
 560            the first block.  Furthermore, for AHT to be used in the coupling
 561            channel, all blocks must use coupling and use the same coupling
 562            strategy. */
 563         s->channel_uses_aht[CPL_CH]=0;
 564         for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
 565             int use_aht = 1;
 566             for (blk = 1; blk < 6; blk++) {
 567                 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
 568                         (!ch && s->cpl_strategy_exists[blk])) {
 569                     use_aht = 0;
 570                     break;
 571                 }
 572             }
 573             s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
 574         }
 575     } else {
 576         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
 577     }
 578
 579     /* per-frame SNR offset */
 580     if (!s->snr_offset_strategy) {
 581         int csnroffst = (get_bits(gbc, 6) - 15) << 4;
 582         int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
 583         for (ch = 0; ch <= s->channels; ch++)
 584             s->snr_offset[ch] = snroffst;
 585     }
 586
 587     /* transient pre-noise processing data */
 588     if (parse_transient_proc_info) {
 589         for (ch = 1; ch <= s->fbw_channels; ch++) {
 590             if (get_bits1(gbc)) { // channel in transient processing
 591                 skip_bits(gbc, 10); // skip transient processing location
 592                 skip_bits(gbc, 8);  // skip transient processing length
 593             }
 594         }
 595     }
 596
 597     /* spectral extension attenuation data */
 598     for (ch = 1; ch <= s->fbw_channels; ch++) {
 599         if (parse_spx_atten_data && get_bits1(gbc)) {
 600             s->spx_atten_code[ch] = get_bits(gbc, 5);
 601         } else {
 602             s->spx_atten_code[ch] = -1;
 603         }
 604     }
 605
 606     /* block start information */
 607     if (s->num_blocks > 1 && get_bits1(gbc)) {
 608         /* reference: Section E2.3.2.27
 609            nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
 610            The spec does not say what this data is or what it's used for.
 611            It is likely the offset of each block within the frame. */
 612         int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
 613         skip_bits_long(gbc, block_start_bits);
 614         avpriv_request_sample(s->avctx, "Block start info");
 615     }
 616
 617     /* syntax state initialization */
 618     for (ch = 1; ch <= s->fbw_channels; ch++) {
 619         s->first_spx_coords[ch] = 1;
 620         s->first_cpl_coords[ch] = 1;
 621     }
 622     s->first_cpl_leak = 1;
 623
 624     return 0;
 625 }