* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+/*
+ * There are several features of E-AC-3 that this decoder does not yet support.
+ *
+ * Enhanced Coupling
+ * No known samples exist. If any ever surface, this feature should not be
+ * too difficult to implement.
+ *
+ * Reduced Sample Rates
+ * No known samples exist. The spec also does not give clear information
+ * on how this is to be implemented.
+ *
+ * Dependent Streams
+ * Only the independent stream is currently decoded. Any dependent
+ * streams are skipped. We have only come across two examples of this, and
+ * they are both just test streams, one for HD-DVD and the other for
+ * Blu-ray.
+ *
+ * Transient Pre-noise Processing
+ * This is side information which a decoder should use to reduce artifacts
+ * caused by transients. There are samples which are known to have this
+ * information, but this decoder currently ignores it.
+ */
+
+
#include "avcodec.h"
+#include "internal.h"
+#include "aac_ac3_parser.h"
#include "ac3.h"
#include "ac3_parser.h"
#include "ac3dec.h"
#include "ac3dec_data.h"
+#include "eac3dec_data.h"
/** gain adaptive quantization mode */
typedef enum {
#define EAC3_SR_CODE_REDUCED 3
+void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
+{
+ int bin, bnd, ch, i;
+ uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
+ float rms_energy[SPX_MAX_BANDS];
+
+ /* Set copy index mapping table. Set wrap flags to apply a notch filter at
+ wrap points later on. */
+ bin = s->spx_dst_start_freq;
+ num_copy_sections = 0;
+ for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
+ int copysize;
+ int bandsize = s->spx_band_sizes[bnd];
+ if (bin + bandsize > s->spx_src_start_freq) {
+ copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
+ bin = s->spx_dst_start_freq;
+ wrapflag[bnd] = 1;
+ }
+ for (i = 0; i < bandsize; i += copysize) {
+ if (bin == s->spx_src_start_freq) {
+ copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
+ bin = s->spx_dst_start_freq;
+ }
+ copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
+ bin += copysize;
+ }
+ }
+ copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
+
+ for (ch = 1; ch <= s->fbw_channels; ch++) {
+ if (!s->channel_uses_spx[ch])
+ continue;
+
+ /* Copy coeffs from normal bands to extension bands */
+ bin = s->spx_src_start_freq;
+ for (i = 0; i < num_copy_sections; i++) {
+ memcpy(&s->transform_coeffs[ch][bin],
+ &s->transform_coeffs[ch][s->spx_dst_start_freq],
+ copy_sizes[i]*sizeof(float));
+ bin += copy_sizes[i];
+ }
+
+ /* Calculate RMS energy for each SPX band. */
+ bin = s->spx_src_start_freq;
+ for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
+ int bandsize = s->spx_band_sizes[bnd];
+ float accum = 0.0f;
+ for (i = 0; i < bandsize; i++) {
+ float coeff = s->transform_coeffs[ch][bin++];
+ accum += coeff * coeff;
+ }
+ rms_energy[bnd] = sqrtf(accum / bandsize);
+ }
+
+ /* Apply a notch filter at transitions between normal and extension
+ bands and at all wrap points. */
+ if (s->spx_atten_code[ch] >= 0) {
+ const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
+ bin = s->spx_src_start_freq - 2;
+ for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
+ if (wrapflag[bnd]) {
+ float *coeffs = &s->transform_coeffs[ch][bin];
+ coeffs[0] *= atten_tab[0];
+ coeffs[1] *= atten_tab[1];
+ coeffs[2] *= atten_tab[2];
+ coeffs[3] *= atten_tab[1];
+ coeffs[4] *= atten_tab[0];
+ }
+ bin += s->spx_band_sizes[bnd];
+ }
+ }
+
+ /* Apply noise-blended coefficient scaling based on previously
+ calculated RMS energy, blending factors, and SPX coordinates for
+ each band. */
+ bin = s->spx_src_start_freq;
+ for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
+ float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f/(1<<31));
+ float sscale = s->spx_signal_blend[ch][bnd];
+ for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
+ float noise = nscale * (int32_t)av_lfg_get(&s->dith_state);
+ s->transform_coeffs[ch][bin] *= sscale;
+ s->transform_coeffs[ch][bin++] += noise;
+ }
+ }
+ }
+}
+
+
/** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
#define COEFF_0 10273905LL
pre_mant[4] = even1 - odd1;
pre_mant[5] = even0 - odd0;
}
+
+void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
+{
+ int bin, blk, gs;
+ int end_bap, gaq_mode;
+ GetBitContext *gbc = &s->gbc;
+ int gaq_gain[AC3_MAX_COEFS];
+
+ gaq_mode = get_bits(gbc, 2);
+ end_bap = (gaq_mode < 2) ? 12 : 17;
+
+ /* if GAQ gain is used, decode gain codes for bins with hebap between
+ 8 and end_bap */
+ gs = 0;
+ if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
+ /* read 1-bit GAQ gain codes */
+ for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
+ if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
+ gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
+ }
+ } else if (gaq_mode == EAC3_GAQ_124) {
+ /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
+ int gc = 2;
+ for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
+ if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
+ if (gc++ == 2) {
+ int group_code = get_bits(gbc, 5);
+ if (group_code > 26) {
+ av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
+ group_code = 26;
+ }
+ gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
+ gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
+ gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
+ gc = 0;
+ }
+ }
+ }
+ }
+
+ gs=0;
+ for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
+ int hebap = s->bap[ch][bin];
+ int bits = ff_eac3_bits_vs_hebap[hebap];
+ if (!hebap) {
+ /* zero-mantissa dithering */
+ for (blk = 0; blk < 6; blk++) {
+ s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
+ }
+ } else if (hebap < 8) {
+ /* Vector Quantization */
+ int v = get_bits(gbc, bits);
+ for (blk = 0; blk < 6; blk++) {
+ s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
+ }
+ } else {
+ /* Gain Adaptive Quantization */
+ int gbits, log_gain;
+ if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
+ log_gain = gaq_gain[gs++];
+ } else {
+ log_gain = 0;
+ }
+ gbits = bits - log_gain;
+
+ for (blk = 0; blk < 6; blk++) {
+ int mant = get_sbits(gbc, gbits);
+ if (log_gain && mant == -(1 << (gbits-1))) {
+ /* large mantissa */
+ int b;
+ int mbits = bits - (2 - log_gain);
+ mant = get_sbits(gbc, mbits);
+ mant <<= (23 - (mbits - 1));
+ /* remap mantissa value to correct for asymmetric quantization */
+ if (mant >= 0)
+ b = 1 << (23 - log_gain);
+ else
+ b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
+ mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
+ } else {
+ /* small mantissa, no GAQ, or Gk=1 */
+ mant <<= 24 - bits;
+ if (!log_gain) {
+ /* remap mantissa value for no GAQ or Gk=1 */
+ mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
+ }
+ }
+ s->pre_mantissa[ch][bin][blk] = mant;
+ }
+ }
+ idct6(s->pre_mantissa[ch][bin]);
+ }
+}
+
+int ff_eac3_parse_header(AC3DecodeContext *s)
+{
+ int i, blk, ch;
+ int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
+ int parse_transient_proc_info;
+ int num_cpl_blocks;
+ GetBitContext *gbc = &s->gbc;
+
+ /* An E-AC-3 stream can have multiple independent streams which the
+ application can select from. each independent stream can also contain
+ dependent streams which are used to add or replace channels. */
+ if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
+ av_log_missing_feature(s->avctx, "Dependent substream decoding", 1);
+ return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
+ } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
+ av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
+ return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
+ }
+
+ /* The substream id indicates which substream this frame belongs to. each
+ independent stream has its own substream id, and the dependent streams
+ associated to an independent stream have matching substream id's. */
+ if (s->substreamid) {
+ /* only decode substream with id=0. skip any additional substreams. */
+ av_log_missing_feature(s->avctx, "Additional substreams", 1);
+ return AAC_AC3_PARSE_ERROR_FRAME_TYPE;
+ }
+
+ if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
+ /* The E-AC-3 specification does not tell how to handle reduced sample
+ rates in bit allocation. The best assumption would be that it is
+ handled like AC-3 DolbyNet, but we cannot be sure until we have a
+ sample which utilizes this feature. */
+ av_log_missing_feature(s->avctx, "Reduced sampling rates", 1);
+ return -1;
+ }
+ skip_bits(gbc, 5); // skip bitstream id
+
+ /* volume control params */
+ for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
+ skip_bits(gbc, 5); // skip dialog normalization
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 8); // skip compression gain word
+ }
+ }
+
+ /* dependent stream channel map */
+ if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 16); // skip custom channel map
+ }
+ }
+
+ /* mixing metadata */
+ if (get_bits1(gbc)) {
+ /* center and surround mix levels */
+ if (s->channel_mode > AC3_CHMODE_STEREO) {
+ skip_bits(gbc, 2); // skip preferred stereo downmix mode
+ if (s->channel_mode & 1) {
+ /* if three front channels exist */
+ skip_bits(gbc, 3); //skip Lt/Rt center mix level
+ s->center_mix_level = get_bits(gbc, 3);
+ }
+ if (s->channel_mode & 4) {
+ /* if a surround channel exists */
+ skip_bits(gbc, 3); //skip Lt/Rt surround mix level
+ s->surround_mix_level = get_bits(gbc, 3);
+ }
+ }
+
+ /* lfe mix level */
+ if (s->lfe_on && get_bits1(gbc)) {
+ // TODO: use LFE mix level
+ skip_bits(gbc, 5); // skip LFE mix level code
+ }
+
+ /* info for mixing with other streams and substreams */
+ if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
+ for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
+ // TODO: apply program scale factor
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 6); // skip program scale factor
+ }
+ }
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 6); // skip external program scale factor
+ }
+ /* skip mixing parameter data */
+ switch(get_bits(gbc, 2)) {
+ case 1: skip_bits(gbc, 5); break;
+ case 2: skip_bits(gbc, 12); break;
+ case 3: {
+ int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
+ skip_bits_long(gbc, mix_data_size);
+ break;
+ }
+ }
+ /* skip pan information for mono or dual mono source */
+ if (s->channel_mode < AC3_CHMODE_STEREO) {
+ for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
+ if (get_bits1(gbc)) {
+ /* note: this is not in the ATSC A/52B specification
+ reference: ETSI TS 102 366 V1.1.1
+ section: E.1.3.1.25 */
+ skip_bits(gbc, 8); // skip pan mean direction index
+ skip_bits(gbc, 6); // skip reserved paninfo bits
+ }
+ }
+ }
+ /* skip mixing configuration information */
+ if (get_bits1(gbc)) {
+ for (blk = 0; blk < s->num_blocks; blk++) {
+ if (s->num_blocks == 1 || get_bits1(gbc)) {
+ skip_bits(gbc, 5);
+ }
+ }
+ }
+ }
+ }
+
+ /* informational metadata */
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 3); // skip bit stream mode
+ skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
+ if (s->channel_mode == AC3_CHMODE_STEREO) {
+ skip_bits(gbc, 4); // skip Dolby surround and headphone mode
+ }
+ if (s->channel_mode >= AC3_CHMODE_2F2R) {
+ skip_bits(gbc, 2); // skip Dolby surround EX mode
+ }
+ for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
+ if (get_bits1(gbc)) {
+ skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
+ }
+ }
+ if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
+ skip_bits1(gbc); // skip source sample rate code
+ }
+ }
+
+ /* converter synchronization flag
+ If frames are less than six blocks, this bit should be turned on
+ once every 6 blocks to indicate the start of a frame set.
+ reference: RFC 4598, Section 2.1.3 Frame Sets */
+ if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
+ skip_bits1(gbc); // skip converter synchronization flag
+ }
+
+ /* original frame size code if this stream was converted from AC-3 */
+ if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
+ (s->num_blocks == 6 || get_bits1(gbc))) {
+ skip_bits(gbc, 6); // skip frame size code
+ }
+
+ /* additional bitstream info */
+ if (get_bits1(gbc)) {
+ int addbsil = get_bits(gbc, 6);
+ for (i = 0; i < addbsil + 1; i++) {
+ skip_bits(gbc, 8); // skip additional bit stream info
+ }
+ }
+
+ /* audio frame syntax flags, strategy data, and per-frame data */
+
+ if (s->num_blocks == 6) {
+ ac3_exponent_strategy = get_bits1(gbc);
+ parse_aht_info = get_bits1(gbc);
+ } else {
+ /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
+ do not use AHT */
+ ac3_exponent_strategy = 1;
+ parse_aht_info = 0;
+ }
+
+ s->snr_offset_strategy = get_bits(gbc, 2);
+ parse_transient_proc_info = get_bits1(gbc);
+
+ s->block_switch_syntax = get_bits1(gbc);
+ if (!s->block_switch_syntax)
+ memset(s->block_switch, 0, sizeof(s->block_switch));
+
+ s->dither_flag_syntax = get_bits1(gbc);
+ if (!s->dither_flag_syntax) {
+ for (ch = 1; ch <= s->fbw_channels; ch++)
+ s->dither_flag[ch] = 1;
+ }
+ s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
+
+ s->bit_allocation_syntax = get_bits1(gbc);
+ if (!s->bit_allocation_syntax) {
+ /* set default bit allocation parameters */
+ s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
+ s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
+ s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
+ s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
+ s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
+ }
+
+ s->fast_gain_syntax = get_bits1(gbc);
+ s->dba_syntax = get_bits1(gbc);
+ s->skip_syntax = get_bits1(gbc);
+ parse_spx_atten_data = get_bits1(gbc);
+
+ /* coupling strategy occurance and coupling use per block */
+ num_cpl_blocks = 0;
+ if (s->channel_mode > 1) {
+ for (blk = 0; blk < s->num_blocks; blk++) {
+ s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
+ if (s->cpl_strategy_exists[blk]) {
+ s->cpl_in_use[blk] = get_bits1(gbc);
+ } else {
+ s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
+ }
+ num_cpl_blocks += s->cpl_in_use[blk];
+ }
+ } else {
+ memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
+ }
+
+ /* exponent strategy data */
+ if (ac3_exponent_strategy) {
+ /* AC-3-style exponent strategy syntax */
+ for (blk = 0; blk < s->num_blocks; blk++) {
+ for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
+ s->exp_strategy[blk][ch] = get_bits(gbc, 2);
+ }
+ }
+ } else {
+ /* LUT-based exponent strategy syntax */
+ for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
+ int frmchexpstr = get_bits(gbc, 5);
+ for (blk = 0; blk < 6; blk++) {
+ s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
+ }
+ }
+ }
+ /* LFE exponent strategy */
+ if (s->lfe_on) {
+ for (blk = 0; blk < s->num_blocks; blk++) {
+ s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
+ }
+ }
+ /* original exponent strategies if this stream was converted from AC-3 */
+ if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
+ (s->num_blocks == 6 || get_bits1(gbc))) {
+ skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
+ }
+
+ /* determine which channels use AHT */
+ if (parse_aht_info) {
+ /* For AHT to be used, all non-zero blocks must reuse exponents from
+ the first block. Furthermore, for AHT to be used in the coupling
+ channel, all blocks must use coupling and use the same coupling
+ strategy. */
+ s->channel_uses_aht[CPL_CH]=0;
+ for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
+ int use_aht = 1;
+ for (blk = 1; blk < 6; blk++) {
+ if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
+ (!ch && s->cpl_strategy_exists[blk])) {
+ use_aht = 0;
+ break;
+ }
+ }
+ s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
+ }
+ } else {
+ memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
+ }
+
+ /* per-frame SNR offset */
+ if (!s->snr_offset_strategy) {
+ int csnroffst = (get_bits(gbc, 6) - 15) << 4;
+ int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
+ for (ch = 0; ch <= s->channels; ch++)
+ s->snr_offset[ch] = snroffst;
+ }
+
+ /* transient pre-noise processing data */
+ if (parse_transient_proc_info) {
+ for (ch = 1; ch <= s->fbw_channels; ch++) {
+ if (get_bits1(gbc)) { // channel in transient processing
+ skip_bits(gbc, 10); // skip transient processing location
+ skip_bits(gbc, 8); // skip transient processing length
+ }
+ }
+ }
+
+ /* spectral extension attenuation data */
+ for (ch = 1; ch <= s->fbw_channels; ch++) {
+ if (parse_spx_atten_data && get_bits1(gbc)) {
+ s->spx_atten_code[ch] = get_bits(gbc, 5);
+ } else {
+ s->spx_atten_code[ch] = -1;
+ }
+ }
+
+ /* block start information */
+ if (s->num_blocks > 1 && get_bits1(gbc)) {
+ /* reference: Section E2.3.2.27
+ nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
+ The spec does not say what this data is or what it's used for.
+ It is likely the offset of each block within the frame. */
+ int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
+ skip_bits_long(gbc, block_start_bits);
+ av_log_missing_feature(s->avctx, "Block start info", 1);
+ }
+
+ /* syntax state initialization */
+ for (ch = 1; ch <= s->fbw_channels; ch++) {
+ s->first_spx_coords[ch] = 1;
+ s->first_cpl_coords[ch] = 1;
+ }
+ s->first_cpl_leak = 1;
+
+ return 0;
+}