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