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 #include "avcodec.h"
  24 #include "internal.h"
  25 #include "ac3.h"
  26 #include "ac3_parser.h"
  27 #include "ac3dec.h"
  28 #include "ac3dec_data.h"
  29
  30 /** gain adaptive quantization mode */
  31 typedef enum {
  32     EAC3_GAQ_NO =0,
  33     EAC3_GAQ_12,
  34     EAC3_GAQ_14,
  35     EAC3_GAQ_124
  36 } EAC3GaqMode;
  37
  38 #define EAC3_SR_CODE_REDUCED  3
  39
  40 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
  41 #define COEFF_0 10273905LL
  42
  43 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
  44 #define COEFF_1 11863283LL
  45
  46 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
  47 #define COEFF_2  3070444LL
  48
  49 /**
  50  * Calculate 6-point IDCT of the pre-mantissas.
  51  * All calculations are 24-bit fixed-point.
  52  */
  53 static void idct6(int pre_mant[6])
  54 {
  55     int tmp;
  56     int even0, even1, even2, odd0, odd1, odd2;
  57
  58     odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
  59
  60     even2 = ( pre_mant[2]                * COEFF_0) >> 23;
  61     tmp   = ( pre_mant[4]                * COEFF_1) >> 23;
  62     odd0  = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
  63
  64     even0 = pre_mant[0] + (tmp >> 1);
  65     even1 = pre_mant[0] - tmp;
  66
  67     tmp = even0;
  68     even0 = tmp + even2;
  69     even2 = tmp - even2;
  70
  71     tmp = odd0;
  72     odd0 = tmp + pre_mant[1] + pre_mant[3];
  73     odd2 = tmp + pre_mant[5] - pre_mant[3];
  74
  75     pre_mant[0] = even0 + odd0;
  76     pre_mant[1] = even1 + odd1;
  77     pre_mant[2] = even2 + odd2;
  78     pre_mant[3] = even2 - odd2;
  79     pre_mant[4] = even1 - odd1;
  80     pre_mant[5] = even0 - odd0;
  81 }
  82
  83 void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
  84 {
  85     int bin, blk, gs;
  86     int end_bap, gaq_mode;
  87     GetBitContext *gbc = &s->gbc;
  88     int gaq_gain[AC3_MAX_COEFS];
  89
  90     gaq_mode = get_bits(gbc, 2);
  91     end_bap = (gaq_mode < 2) ? 12 : 17;
  92
  93     /* if GAQ gain is used, decode gain codes for bins with hebap between
  94        8 and end_bap */
  95     gs = 0;
  96     if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
  97         /* read 1-bit GAQ gain codes */
  98         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
  99             if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
 100                 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
 101         }
 102     } else if (gaq_mode == EAC3_GAQ_124) {
 103         /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
 104         int gc = 2;
 105         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
 106             if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
 107                 if (gc++ == 2) {
 108                     int group_code = get_bits(gbc, 5);
 109                     if (group_code > 26) {
 110                         av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
 111                         group_code = 26;
 112                     }
 113                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
 114                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
 115                     gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
 116                     gc = 0;
 117                 }
 118             }
 119         }
 120     }
 121
 122     gs=0;
 123     for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
 124         int hebap = s->bap[ch][bin];
 125         int bits = ff_eac3_bits_vs_hebap[hebap];
 126         if (!hebap) {
 127             /* zero-mantissa dithering */
 128             for (blk = 0; blk < 6; blk++) {
 129                 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
 130             }
 131         } else if (hebap < 8) {
 132             /* Vector Quantization */
 133             int v = get_bits(gbc, bits);
 134             for (blk = 0; blk < 6; blk++) {
 135                 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
 136             }
 137         } else {
 138             /* Gain Adaptive Quantization */
 139             int gbits, log_gain;
 140             if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
 141                 log_gain = gaq_gain[gs++];
 142             } else {
 143                 log_gain = 0;
 144             }
 145             gbits = bits - log_gain;
 146
 147             for (blk = 0; blk < 6; blk++) {
 148                 int mant = get_sbits(gbc, gbits);
 149                 if (mant == -(1 << (gbits-1))) {
 150                     /* large mantissa */
 151                     int b;
 152                     mant = get_sbits(gbc, bits-2+log_gain) << (26-log_gain-bits);
 153                     /* remap mantissa value to correct for asymmetric quantization */
 154                     if (mant >= 0)
 155                         b = 32768 >> (log_gain+8);
 156                     else
 157                         b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1];
 158                     mant += (ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (mant>>8) + b) >> 7;
 159                 } else {
 160                     /* small mantissa, no GAQ, or Gk=1 */
 161                     mant <<= 24 - bits;
 162                     if (!log_gain) {
 163                         /* remap mantissa value for no GAQ or Gk=1 */
 164                         mant += (ff_eac3_gaq_remap_1[hebap-8] * (mant>>8)) >> 7;
 165                     }
 166                 }
 167                 s->pre_mantissa[ch][bin][blk] = mant;
 168             }
 169         }
 170         idct6(s->pre_mantissa[ch][bin]);
 171     }
 172 }
 173
 174 int ff_eac3_parse_header(AC3DecodeContext *s)
 175 {
 176     int i, blk, ch;
 177     int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
 178     int parse_transient_proc_info;
 179     int num_cpl_blocks;
 180     GetBitContext *gbc = &s->gbc;
 181
 182     /* An E-AC-3 stream can have multiple independent streams which the
 183        application can select from. each independent stream can also contain
 184        dependent streams which are used to add or replace channels. */
 185     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
 186         ff_log_missing_feature(s->avctx, "Dependent substream decoding", 1);
 187         return AC3_PARSE_ERROR_FRAME_TYPE;
 188     } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
 189         av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
 190         return AC3_PARSE_ERROR_FRAME_TYPE;
 191     }
 192
 193     /* The substream id indicates which substream this frame belongs to. each
 194        independent stream has its own substream id, and the dependent streams
 195        associated to an independent stream have matching substream id's. */
 196     if (s->substreamid) {
 197         /* only decode substream with id=0. skip any additional substreams. */
 198         ff_log_missing_feature(s->avctx, "Additional substreams", 1);
 199         return AC3_PARSE_ERROR_FRAME_TYPE;
 200     }
 201
 202     if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
 203         /* The E-AC-3 specification does not tell how to handle reduced sample
 204            rates in bit allocation.  The best assumption would be that it is
 205            handled like AC-3 DolbyNet, but we cannot be sure until we have a
 206            sample which utilizes this feature. */
 207         ff_log_missing_feature(s->avctx, "Reduced sampling rates", 1);
 208         return -1;
 209     }
 210     skip_bits(gbc, 5); // skip bitstream id
 211
 212     /* volume control params */
 213     for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 214         skip_bits(gbc, 5); // skip dialog normalization
 215         if (get_bits1(gbc)) {
 216             skip_bits(gbc, 8); // skip compression gain word
 217         }
 218     }
 219
 220     /* dependent stream channel map */
 221     if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
 222         if (get_bits1(gbc)) {
 223             skip_bits(gbc, 16); // skip custom channel map
 224         }
 225     }
 226
 227     /* mixing metadata */
 228     if (get_bits1(gbc)) {
 229         /* center and surround mix levels */
 230         if (s->channel_mode > AC3_CHMODE_STEREO) {
 231             skip_bits(gbc, 2);  // skip preferred stereo downmix mode
 232             if (s->channel_mode & 1) {
 233                 /* if three front channels exist */
 234                 skip_bits(gbc, 3); //skip Lt/Rt center mix level
 235                 s->center_mix_level = get_bits(gbc, 3);
 236             }
 237             if (s->channel_mode & 4) {
 238                 /* if a surround channel exists */
 239                 skip_bits(gbc, 3); //skip Lt/Rt surround mix level
 240                 s->surround_mix_level = get_bits(gbc, 3);
 241             }
 242         }
 243
 244         /* lfe mix level */
 245         if (s->lfe_on && get_bits1(gbc)) {
 246             // TODO: use LFE mix level
 247             skip_bits(gbc, 5); // skip LFE mix level code
 248         }
 249
 250         /* info for mixing with other streams and substreams */
 251         if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
 252             for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 253                 // TODO: apply program scale factor
 254                 if (get_bits1(gbc)) {
 255                     skip_bits(gbc, 6);  // skip program scale factor
 256                 }
 257             }
 258             if (get_bits1(gbc)) {
 259                 skip_bits(gbc, 6);  // skip external program scale factor
 260             }
 261             /* skip mixing parameter data */
 262             switch(get_bits(gbc, 2)) {
 263                 case 1: skip_bits(gbc, 5);  break;
 264                 case 2: skip_bits(gbc, 12); break;
 265                 case 3: {
 266                     int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
 267                     skip_bits_long(gbc, mix_data_size);
 268                     break;
 269                 }
 270             }
 271             /* skip pan information for mono or dual mono source */
 272             if (s->channel_mode < AC3_CHMODE_STEREO) {
 273                 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 274                     if (get_bits1(gbc)) {
 275                         /* note: this is not in the ATSC A/52B specification
 276                            reference: ETSI TS 102 366 V1.1.1
 277                                       section: E.1.3.1.25 */
 278                         skip_bits(gbc, 8);  // skip pan mean direction index
 279                         skip_bits(gbc, 6);  // skip reserved paninfo bits
 280                     }
 281                 }
 282             }
 283             /* skip mixing configuration information */
 284             if (get_bits1(gbc)) {
 285                 for (blk = 0; blk < s->num_blocks; blk++) {
 286                     if (s->num_blocks == 1 || get_bits1(gbc)) {
 287                         skip_bits(gbc, 5);
 288                     }
 289                 }
 290             }
 291         }
 292     }
 293
 294     /* informational metadata */
 295     if (get_bits1(gbc)) {
 296         skip_bits(gbc, 3); // skip bit stream mode
 297         skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
 298         if (s->channel_mode == AC3_CHMODE_STEREO) {
 299             skip_bits(gbc, 4); // skip Dolby surround and headphone mode
 300         }
 301         if (s->channel_mode >= AC3_CHMODE_2F2R) {
 302             skip_bits(gbc, 2); // skip Dolby surround EX mode
 303         }
 304         for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
 305             if (get_bits1(gbc)) {
 306                 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
 307             }
 308         }
 309         if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
 310             skip_bits1(gbc); // skip source sample rate code
 311         }
 312     }
 313
 314     /* converter synchronization flag
 315        If frames are less than six blocks, this bit should be turned on
 316        once every 6 blocks to indicate the start of a frame set.
 317        reference: RFC 4598, Section 2.1.3  Frame Sets */
 318     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
 319         skip_bits1(gbc); // skip converter synchronization flag
 320     }
 321
 322     /* original frame size code if this stream was converted from AC-3 */
 323     if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
 324             (s->num_blocks == 6 || get_bits1(gbc))) {
 325         skip_bits(gbc, 6); // skip frame size code
 326     }
 327
 328     /* additional bitstream info */
 329     if (get_bits1(gbc)) {
 330         int addbsil = get_bits(gbc, 6);
 331         for (i = 0; i < addbsil + 1; i++) {
 332             skip_bits(gbc, 8); // skip additional bit stream info
 333         }
 334     }
 335
 336     /* audio frame syntax flags, strategy data, and per-frame data */
 337
 338     if (s->num_blocks == 6) {
 339         ac3_exponent_strategy = get_bits1(gbc);
 340         parse_aht_info        = get_bits1(gbc);
 341     } else {
 342         /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
 343            do not use AHT */
 344         ac3_exponent_strategy = 1;
 345         parse_aht_info = 0;
 346     }
 347
 348     s->snr_offset_strategy    = get_bits(gbc, 2);
 349     parse_transient_proc_info = get_bits1(gbc);
 350
 351     s->block_switch_syntax = get_bits1(gbc);
 352     if (!s->block_switch_syntax)
 353         memset(s->block_switch, 0, sizeof(s->block_switch));
 354
 355     s->dither_flag_syntax = get_bits1(gbc);
 356     if (!s->dither_flag_syntax) {
 357         for (ch = 1; ch <= s->fbw_channels; ch++)
 358             s->dither_flag[ch] = 1;
 359     }
 360     s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
 361
 362     s->bit_allocation_syntax = get_bits1(gbc);
 363     if (!s->bit_allocation_syntax) {
 364         /* set default bit allocation parameters */
 365         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
 366         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
 367         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab [1];
 368         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
 369         s->bit_alloc_params.floor      = ff_ac3_floor_tab     [7];
 370     }
 371
 372     s->fast_gain_syntax  = get_bits1(gbc);
 373     s->dba_syntax        = get_bits1(gbc);
 374     s->skip_syntax       = get_bits1(gbc);
 375     parse_spx_atten_data = get_bits1(gbc);
 376
 377     /* coupling strategy occurance and coupling use per block */
 378     num_cpl_blocks = 0;
 379     if (s->channel_mode > 1) {
 380         for (blk = 0; blk < s->num_blocks; blk++) {
 381             s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
 382             if (s->cpl_strategy_exists[blk]) {
 383                 s->cpl_in_use[blk] = get_bits1(gbc);
 384             } else {
 385                 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 386             }
 387             num_cpl_blocks += s->cpl_in_use[blk];
 388         }
 389     } else {
 390         memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
 391     }
 392
 393     /* exponent strategy data */
 394     if (ac3_exponent_strategy) {
 395         /* AC-3-style exponent strategy syntax */
 396         for (blk = 0; blk < s->num_blocks; blk++) {
 397             for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
 398                 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
 399             }
 400         }
 401     } else {
 402         /* LUT-based exponent strategy syntax */
 403         for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
 404             int frmchexpstr = get_bits(gbc, 5);
 405             for (blk = 0; blk < 6; blk++) {
 406                 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
 407             }
 408         }
 409     }
 410     /* LFE exponent strategy */
 411     if (s->lfe_on) {
 412         for (blk = 0; blk < s->num_blocks; blk++) {
 413             s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
 414         }
 415     }
 416     /* original exponent strategies if this stream was converted from AC-3 */
 417     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
 418             (s->num_blocks == 6 || get_bits1(gbc))) {
 419         skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
 420     }
 421
 422     /* determine which channels use AHT */
 423     if (parse_aht_info) {
 424         /* For AHT to be used, all non-zero blocks must reuse exponents from
 425            the first block.  Furthermore, for AHT to be used in the coupling
 426            channel, all blocks must use coupling and use the same coupling
 427            strategy. */
 428         s->channel_uses_aht[CPL_CH]=0;
 429         for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
 430             int use_aht = 1;
 431             for (blk = 1; blk < 6; blk++) {
 432                 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
 433                         (!ch && s->cpl_strategy_exists[blk])) {
 434                     use_aht = 0;
 435                     break;
 436                 }
 437             }
 438             s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
 439         }
 440     } else {
 441         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
 442     }
 443
 444     /* per-frame SNR offset */
 445     if (!s->snr_offset_strategy) {
 446         int csnroffst = (get_bits(gbc, 6) - 15) << 4;
 447         int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
 448         for (ch = 0; ch <= s->channels; ch++)
 449             s->snr_offset[ch] = snroffst;
 450     }
 451
 452     /* transient pre-noise processing data */
 453     if (parse_transient_proc_info) {
 454         for (ch = 1; ch <= s->fbw_channels; ch++) {
 455             if (get_bits1(gbc)) { // channel in transient processing
 456                 skip_bits(gbc, 10); // skip transient processing location
 457                 skip_bits(gbc, 8);  // skip transient processing length
 458             }
 459         }
 460     }
 461
 462     /* spectral extension attenuation data */
 463     if (parse_spx_atten_data) {
 464         ff_log_missing_feature(s->avctx, "Spectral extension attenuation", 1);
 465         for (ch = 1; ch <= s->fbw_channels; ch++) {
 466             if (get_bits1(gbc)) { // channel has spx attenuation
 467                 skip_bits(gbc, 5); // skip spx attenuation code
 468             }
 469         }
 470     }
 471
 472     /* block start information */
 473     if (s->num_blocks > 1 && get_bits1(gbc)) {
 474         /* reference: Section E2.3.2.27
 475            nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
 476            The spec does not say what this data is or what it's used for.
 477            It is likely the offset of each block within the frame. */
 478         int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
 479         skip_bits_long(gbc, block_start_bits);
 480         ff_log_missing_feature(s->avctx, "Block start info", 1);
 481     }
 482
 483     /* syntax state initialization */
 484     for (ch = 1; ch <= s->fbw_channels; ch++) {
 485         s->first_cpl_coords[ch] = 1;
 486     }
 487     s->first_cpl_leak = 1;
 488
 489     return 0;
 490 }