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