LCOV - code coverage report
Current view: top level - libavcodec - eac3dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 249 296 84.1 %
Date: 2018-05-20 11:54:08 Functions: 4 4 100.0 %

          Line data    Source code
       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        3228 : static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
      66             : {
      67             :     int bin, bnd, ch, i;
      68        3228 :     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        3228 :     bin = s->spx_dst_start_freq;
      74        3228 :     num_copy_sections = 0;
      75       10548 :     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
      76             :         int copysize;
      77        7320 :         int bandsize = s->spx_band_sizes[bnd];
      78        7320 :         if (bin + bandsize > s->spx_src_start_freq) {
      79           0 :             copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
      80           0 :             bin = s->spx_dst_start_freq;
      81           0 :             wrapflag[bnd] = 1;
      82             :         }
      83       14640 :         for (i = 0; i < bandsize; i += copysize) {
      84        7320 :             if (bin == s->spx_src_start_freq) {
      85           0 :                 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
      86           0 :                 bin = s->spx_dst_start_freq;
      87             :             }
      88        7320 :             copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
      89        7320 :             bin += copysize;
      90             :         }
      91             :     }
      92        3228 :     copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
      93             : 
      94       10548 :     for (ch = 1; ch <= s->fbw_channels; ch++) {
      95        7320 :         if (!s->channel_uses_spx[ch])
      96           0 :             continue;
      97             : 
      98             :         /* Copy coeffs from normal bands to extension bands */
      99        7320 :         bin = s->spx_src_start_freq;
     100       14640 :         for (i = 0; i < num_copy_sections; i++) {
     101       14640 :             memcpy(&s->transform_coeffs[ch][bin],
     102        7320 :                    &s->transform_coeffs[ch][s->spx_dst_start_freq],
     103        7320 :                    copy_sizes[i]*sizeof(INTFLOAT));
     104        7320 :             bin += copy_sizes[i];
     105             :         }
     106             : 
     107             :         /* Calculate RMS energy for each SPX band. */
     108        7320 :         bin = s->spx_src_start_freq;
     109       26280 :         for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
     110       18960 :             int bandsize = s->spx_band_sizes[bnd];
     111       18960 :             float accum = 0.0f;
     112      263760 :             for (i = 0; i < bandsize; i++) {
     113      244800 :                 float coeff = s->transform_coeffs[ch][bin++];
     114      244800 :                 accum += coeff * coeff;
     115             :             }
     116       18960 :             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        7320 :         if (s->spx_atten_code[ch] >= 0) {
     122        6282 :             const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
     123        6282 :             bin = s->spx_src_start_freq - 2;
     124       20052 :             for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
     125       13770 :                 if (wrapflag[bnd]) {
     126        6282 :                     INTFLOAT *coeffs = &s->transform_coeffs[ch][bin];
     127        6282 :                     coeffs[0] *= atten_tab[0];
     128        6282 :                     coeffs[1] *= atten_tab[1];
     129        6282 :                     coeffs[2] *= atten_tab[2];
     130        6282 :                     coeffs[3] *= atten_tab[1];
     131        6282 :                     coeffs[4] *= atten_tab[0];
     132             :                 }
     133       13770 :                 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        7320 :         bin = s->spx_src_start_freq;
     141       26280 :         for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
     142       18960 :             float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
     143       18960 :             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           0 :             nscale *= 1.0 / (1<<23);
     147           0 :             sscale *= 1.0 / (1<<23);
     148             : #endif
     149      263760 :             for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
     150      244800 :                 float noise  = nscale * (int32_t)av_lfg_get(&s->dith_state);
     151      244800 :                 s->transform_coeffs[ch][bin]   *= sscale;
     152      244800 :                 s->transform_coeffs[ch][bin++] += noise;
     153             :             }
     154             :         }
     155             :     }
     156        3228 : }
     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       98806 : static void idct6(int pre_mant[6])
     173             : {
     174             :     int tmp;
     175             :     int even0, even1, even2, odd0, odd1, odd2;
     176             : 
     177       98806 :     odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
     178             : 
     179       98806 :     even2 = ( pre_mant[2]                * COEFF_0) >> 23;
     180       98806 :     tmp   = ( pre_mant[4]                * COEFF_1) >> 23;
     181       98806 :     odd0  = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
     182             : 
     183       98806 :     even0 = pre_mant[0] + (tmp >> 1);
     184       98806 :     even1 = pre_mant[0] - tmp;
     185             : 
     186       98806 :     tmp = even0;
     187       98806 :     even0 = tmp + even2;
     188       98806 :     even2 = tmp - even2;
     189             : 
     190       98806 :     tmp = odd0;
     191       98806 :     odd0 = tmp + pre_mant[1] + pre_mant[3];
     192       98806 :     odd2 = tmp + pre_mant[5] - pre_mant[3];
     193             : 
     194       98806 :     pre_mant[0] = even0 + odd0;
     195       98806 :     pre_mant[1] = even1 + odd1;
     196       98806 :     pre_mant[2] = even2 + odd2;
     197       98806 :     pre_mant[3] = even2 - odd2;
     198       98806 :     pre_mant[4] = even1 - odd1;
     199       98806 :     pre_mant[5] = even0 - odd0;
     200       98806 : }
     201             : 
     202         808 : 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         808 :     GetBitContext *gbc = &s->gbc;
     207             :     int gaq_gain[AC3_MAX_COEFS];
     208             : 
     209         808 :     gaq_mode = get_bits(gbc, 2);
     210         808 :     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         808 :     gs = 0;
     215        1503 :     if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
     216             :         /* read 1-bit GAQ gain codes */
     217       87190 :         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
     218       86495 :             if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
     219       31184 :                 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
     220             :         }
     221         113 :     } else if (gaq_mode == EAC3_GAQ_124) {
     222             :         /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
     223          52 :         int gc = 2;
     224        6560 :         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
     225        6508 :             if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
     226        1905 :                 if (gc++ == 2) {
     227         655 :                     int group_code = get_bits(gbc, 5);
     228         655 :                     if (group_code > 26) {
     229           0 :                         av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
     230           0 :                         group_code = 26;
     231             :                     }
     232         655 :                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
     233         655 :                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
     234         655 :                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
     235         655 :                     gc = 0;
     236             :                 }
     237             :             }
     238             :         }
     239             :     }
     240             : 
     241         808 :     gs=0;
     242       99614 :     for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
     243       98806 :         int hebap = s->bap[ch][bin];
     244       98806 :         int bits = ff_eac3_bits_vs_hebap[hebap];
     245       98806 :         if (!hebap) {
     246             :             /* zero-mantissa dithering */
     247      223020 :             for (blk = 0; blk < 6; blk++) {
     248      191160 :                 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
     249             :             }
     250       66946 :         } else if (hebap < 8) {
     251             :             /* Vector Quantization */
     252       30923 :             int v = get_bits(gbc, bits);
     253      216461 :             for (blk = 0; blk < 6; blk++) {
     254      185538 :                 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       36023 :             if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
     260       33089 :                 log_gain = gaq_gain[gs++];
     261             :             } else {
     262        2934 :                 log_gain = 0;
     263             :             }
     264       36023 :             gbits = bits - log_gain;
     265             : 
     266      252161 :             for (blk = 0; blk < 6; blk++) {
     267      216138 :                 int mant = get_sbits(gbc, gbits);
     268      240495 :                 if (log_gain && mant == -(1 << (gbits-1))) {
     269             :                     /* large mantissa */
     270             :                     int b;
     271       24357 :                     int mbits = bits - (2 - log_gain);
     272       24357 :                     mant = get_sbits(gbc, mbits);
     273       24357 :                     mant = ((unsigned)mant) << (23 - (mbits - 1));
     274             :                     /* remap mantissa value to correct for asymmetric quantization */
     275       24357 :                     if (mant >= 0)
     276       12102 :                         b = 1 << (23 - log_gain);
     277             :                     else
     278       12255 :                         b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);
     279       24357 :                     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      191781 :                     mant *= (1 << 24 - bits);
     283      191781 :                     if (!log_gain) {
     284             :                         /* remap mantissa value for no GAQ or Gk=1 */
     285      114612 :                         mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
     286             :                     }
     287             :                 }
     288      216138 :                 s->pre_mantissa[ch][bin][blk] = mant;
     289             :             }
     290             :         }
     291       98806 :         idct6(s->pre_mantissa[ch][bin]);
     292             :     }
     293         808 : }
     294             : 
     295        1200 : 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        1200 :     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        1200 :     if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
     307           0 :         av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
     308           0 :         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        1200 :     if (s->substreamid) {
     315             :         /* only decode substream with id=0. skip any additional substreams. */
     316           0 :         if (!s->eac3_subsbtreamid_found) {
     317           0 :             s->eac3_subsbtreamid_found = 1;
     318           0 :             avpriv_request_sample(s->avctx, "Additional substreams");
     319             :         }
     320           0 :         return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
     321             :     }
     322             : 
     323        1200 :     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           0 :         avpriv_request_sample(s->avctx, "Reduced sampling rate");
     329           0 :         return AVERROR_PATCHWELCOME;
     330             :     }
     331        1200 :     skip_bits(gbc, 5); // skip bitstream id
     332             : 
     333             :     /* volume control params */
     334        2400 :     for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
     335        1200 :         s->dialog_normalization[i] = -get_bits(gbc, 5);
     336        1200 :         if (s->dialog_normalization[i] == 0) {
     337           0 :             s->dialog_normalization[i] = -31;
     338             :         }
     339        1200 :         if (s->target_level != 0) {
     340           0 :             s->level_gain[i] = powf(2.0f,
     341           0 :                 (float)(s->target_level - s->dialog_normalization[i])/6.0f);
     342             :         }
     343        1200 :         s->compression_exists[i] = get_bits1(gbc);
     344        1200 :         if (s->compression_exists[i]) {
     345         926 :             s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(get_bits(gbc, 8));
     346             :         }
     347             :     }
     348             : 
     349             :     /* dependent stream channel map */
     350        1200 :     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
     351         159 :         if (get_bits1(gbc)) {
     352         159 :             s->channel_map = get_bits(gbc, 16);
     353         159 :             av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", s->channel_map);
     354             :         }
     355             :     }
     356             : 
     357             :     /* mixing metadata */
     358        1200 :     if (get_bits1(gbc)) {
     359             :         /* center and surround mix levels */
     360         636 :         if (s->channel_mode > AC3_CHMODE_STEREO) {
     361         146 :             s->preferred_downmix = get_bits(gbc, 2);
     362         146 :             if (s->channel_mode & 1) {
     363             :                 /* if three front channels exist */
     364         146 :                 s->center_mix_level_ltrt = get_bits(gbc, 3);
     365         146 :                 s->center_mix_level      = get_bits(gbc, 3);
     366             :             }
     367         146 :             if (s->channel_mode & 4) {
     368             :                 /* if a surround channel exists */
     369         146 :                 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
     370         146 :                 s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
     371             :             }
     372             :         }
     373             : 
     374             :         /* lfe mix level */
     375         636 :         if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
     376         146 :             s->lfe_mix_level = get_bits(gbc, 5);
     377             :         }
     378             : 
     379             :         /* info for mixing with other streams and substreams */
     380         636 :         if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
     381        1272 :             for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
     382             :                 // TODO: apply program scale factor
     383         636 :                 if (get_bits1(gbc)) {
     384           0 :                     skip_bits(gbc, 6);  // skip program scale factor
     385             :                 }
     386             :             }
     387         636 :             if (get_bits1(gbc)) {
     388           0 :                 skip_bits(gbc, 6);  // skip external program scale factor
     389             :             }
     390             :             /* skip mixing parameter data */
     391         636 :             switch(get_bits(gbc, 2)) {
     392           0 :                 case 1: skip_bits(gbc, 5);  break;
     393           0 :                 case 2: skip_bits(gbc, 12); break;
     394           0 :                 case 3: {
     395           0 :                     int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
     396           0 :                     skip_bits_long(gbc, mix_data_size);
     397           0 :                     break;
     398             :                 }
     399             :             }
     400             :             /* skip pan information for mono or dual mono source */
     401         636 :             if (s->channel_mode < AC3_CHMODE_STEREO) {
     402           0 :                 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
     403           0 :                     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           0 :                         skip_bits(gbc, 8);  // skip pan mean direction index
     408           0 :                         skip_bits(gbc, 6);  // skip reserved paninfo bits
     409             :                     }
     410             :                 }
     411             :             }
     412             :             /* skip mixing configuration information */
     413         636 :             if (get_bits1(gbc)) {
     414           0 :                 for (blk = 0; blk < s->num_blocks; blk++) {
     415           0 :                     if (s->num_blocks == 1 || get_bits1(gbc)) {
     416           0 :                         skip_bits(gbc, 5);
     417             :                     }
     418             :                 }
     419             :             }
     420             :         }
     421             :     }
     422             : 
     423             :     /* informational metadata */
     424        1200 :     if (get_bits1(gbc)) {
     425         767 :         s->bitstream_mode = get_bits(gbc, 3);
     426         767 :         skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
     427         767 :         if (s->channel_mode == AC3_CHMODE_STEREO) {
     428         621 :             s->dolby_surround_mode  = get_bits(gbc, 2);
     429         621 :             s->dolby_headphone_mode = get_bits(gbc, 2);
     430             :         }
     431         767 :         if (s->channel_mode >= AC3_CHMODE_2F2R) {
     432         146 :             s->dolby_surround_ex_mode = get_bits(gbc, 2);
     433             :         }
     434        1534 :         for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
     435         767 :             if (get_bits1(gbc)) {
     436         767 :                 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
     437             :             }
     438             :         }
     439         767 :         if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
     440         767 :             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        1200 :     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
     449          98 :         skip_bits1(gbc); // skip converter synchronization flag
     450             :     }
     451             : 
     452             :     /* original frame size code if this stream was converted from AC-3 */
     453        1200 :     if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
     454           0 :             (s->num_blocks == 6 || get_bits1(gbc))) {
     455           0 :         skip_bits(gbc, 6); // skip frame size code
     456             :     }
     457             : 
     458             :     /* additional bitstream info */
     459        1200 :     if (get_bits1(gbc)) {
     460         159 :         int addbsil = get_bits(gbc, 6);
     461         477 :         for (i = 0; i < addbsil + 1; i++) {
     462         318 :             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        1200 :     if (s->num_blocks == 6) {
     469        1102 :         ac3_exponent_strategy = get_bits1(gbc);
     470        1102 :         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          98 :         ac3_exponent_strategy = 1;
     475          98 :         parse_aht_info = 0;
     476             :     }
     477             : 
     478        1200 :     s->snr_offset_strategy    = get_bits(gbc, 2);
     479        1200 :     parse_transient_proc_info = get_bits1(gbc);
     480             : 
     481        1200 :     s->block_switch_syntax = get_bits1(gbc);
     482        1200 :     if (!s->block_switch_syntax)
     483        1200 :         memset(s->block_switch, 0, sizeof(s->block_switch));
     484             : 
     485        1200 :     s->dither_flag_syntax = get_bits1(gbc);
     486        1200 :     if (!s->dither_flag_syntax) {
     487        4356 :         for (ch = 1; ch <= s->fbw_channels; ch++)
     488        3156 :             s->dither_flag[ch] = 1;
     489             :     }
     490        1200 :     s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
     491             : 
     492        1200 :     s->bit_allocation_syntax = get_bits1(gbc);
     493        1200 :     if (!s->bit_allocation_syntax) {
     494             :         /* set default bit allocation parameters */
     495         914 :         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
     496         914 :         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
     497         914 :         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab [1];
     498         914 :         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
     499         914 :         s->bit_alloc_params.floor      = ff_ac3_floor_tab     [7];
     500             :     }
     501             : 
     502        1200 :     s->fast_gain_syntax  = get_bits1(gbc);
     503        1200 :     s->dba_syntax        = get_bits1(gbc);
     504        1200 :     s->skip_syntax       = get_bits1(gbc);
     505        1200 :     parse_spx_atten_data = get_bits1(gbc);
     506             : 
     507             :     /* coupling strategy occurrence and coupling use per block */
     508        1200 :     num_cpl_blocks = 0;
     509        1200 :     if (s->channel_mode > 1) {
     510        7910 :         for (blk = 0; blk < s->num_blocks; blk++) {
     511        6710 :             s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
     512        6710 :             if (s->cpl_strategy_exists[blk]) {
     513        1200 :                 s->cpl_in_use[blk] = get_bits1(gbc);
     514             :             } else {
     515        5510 :                 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
     516             :             }
     517        6710 :             num_cpl_blocks += s->cpl_in_use[blk];
     518             :         }
     519             :     } else {
     520           0 :         memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
     521             :     }
     522             : 
     523             :     /* exponent strategy data */
     524        1200 :     if (ac3_exponent_strategy) {
     525             :         /* AC-3-style exponent strategy syntax */
     526         196 :         for (blk = 0; blk < s->num_blocks; blk++) {
     527         588 :             for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
     528         490 :                 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
     529             :             }
     530             :         }
     531             :     } else {
     532             :         /* LUT-based exponent strategy syntax */
     533        4173 :         for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
     534        3071 :             int frmchexpstr = get_bits(gbc, 5);
     535       21497 :             for (blk = 0; blk < 6; blk++) {
     536       18426 :                 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
     537             :             }
     538             :         }
     539             :     }
     540             :     /* LFE exponent strategy */
     541        1200 :     if (s->lfe_on) {
     542         532 :         for (blk = 0; blk < s->num_blocks; blk++) {
     543         386 :             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        2241 :     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
     548        1139 :             (s->num_blocks == 6 || get_bits1(gbc))) {
     549         959 :         skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
     550             :     }
     551             : 
     552             :     /* determine which channels use AHT */
     553        1200 :     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         444 :         s->channel_uses_aht[CPL_CH]=0;
     559        1524 :         for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
     560        1080 :             int use_aht = 1;
     561        5502 :             for (blk = 1; blk < 6; blk++) {
     562        4694 :                 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
     563           0 :                         (!ch && s->cpl_strategy_exists[blk])) {
     564         272 :                     use_aht = 0;
     565         272 :                     break;
     566             :                 }
     567             :             }
     568        1080 :             s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
     569             :         }
     570             :     } else {
     571         756 :         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
     572             :     }
     573             : 
     574             :     /* per-frame SNR offset */
     575        1200 :     if (!s->snr_offset_strategy) {
     576        1200 :         int csnroffst = (get_bits(gbc, 6) - 15) << 4;
     577        1200 :         int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
     578        5702 :         for (ch = 0; ch <= s->channels; ch++)
     579        4502 :             s->snr_offset[ch] = snroffst;
     580             :     }
     581             : 
     582             :     /* transient pre-noise processing data */
     583        1200 :     if (parse_transient_proc_info) {
     584           0 :         for (ch = 1; ch <= s->fbw_channels; ch++) {
     585           0 :             if (get_bits1(gbc)) { // channel in transient processing
     586           0 :                 skip_bits(gbc, 10); // skip transient processing location
     587           0 :                 skip_bits(gbc, 8);  // skip transient processing length
     588             :             }
     589             :         }
     590             :     }
     591             : 
     592             :     /* spectral extension attenuation data */
     593        4356 :     for (ch = 1; ch <= s->fbw_channels; ch++) {
     594        3156 :         if (parse_spx_atten_data && get_bits1(gbc)) {
     595        1047 :             s->spx_atten_code[ch] = get_bits(gbc, 5);
     596             :         } else {
     597        2109 :             s->spx_atten_code[ch] = -1;
     598             :         }
     599             :     }
     600             : 
     601             :     /* block start information */
     602        1200 :     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           0 :         int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
     608           0 :         skip_bits_long(gbc, block_start_bits);
     609           0 :         avpriv_request_sample(s->avctx, "Block start info");
     610             :     }
     611             : 
     612             :     /* syntax state initialization */
     613        4356 :     for (ch = 1; ch <= s->fbw_channels; ch++) {
     614        3156 :         s->first_spx_coords[ch] = 1;
     615        3156 :         s->first_cpl_coords[ch] = 1;
     616             :     }
     617        1200 :     s->first_cpl_leak = 1;
     618             : 
     619        1200 :     return 0;
     620             : }

Generated by: LCOV version 1.13