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