From: Justin Ruggles Date: Fri, 10 Jun 2011 18:57:19 +0000 (-0400) Subject: ac3enc: split templated float vs. fixed functions into a separate file. X-Git-Tag: v0.7rc1~9 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e0cc66df61664bb6f9271d9aae3c778e1f906b4c;p=platform%2Fupstream%2Flibav.git ac3enc: split templated float vs. fixed functions into a separate file. Function pointers are used for templated functions instead of needlessly duplicating many functions. --- diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 581d6bf..0cfa08c 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -60,8 +60,9 @@ OBJS-$(CONFIG_AAC_ENCODER) += aacenc.o aaccoder.o \ mpeg4audio.o kbdwin.o OBJS-$(CONFIG_AASC_DECODER) += aasc.o msrledec.o OBJS-$(CONFIG_AC3_DECODER) += ac3dec.o ac3dec_data.o ac3.o kbdwin.o -OBJS-$(CONFIG_AC3_ENCODER) += ac3enc_float.o ac3tab.o ac3.o kbdwin.o -OBJS-$(CONFIG_AC3_FIXED_ENCODER) += ac3enc_fixed.o ac3tab.o ac3.o +OBJS-$(CONFIG_AC3_ENCODER) += ac3enc_float.o ac3enc.o ac3tab.o \ + ac3.o kbdwin.o +OBJS-$(CONFIG_AC3_FIXED_ENCODER) += ac3enc_fixed.o ac3enc.o ac3tab.o ac3.o OBJS-$(CONFIG_ALAC_DECODER) += alac.o OBJS-$(CONFIG_ALAC_ENCODER) += alacenc.o OBJS-$(CONFIG_ALS_DECODER) += alsdec.o bgmc.o mpeg4audio.o @@ -124,8 +125,8 @@ OBJS-$(CONFIG_DVVIDEO_DECODER) += dv.o dvdata.o OBJS-$(CONFIG_DVVIDEO_ENCODER) += dv.o dvdata.o OBJS-$(CONFIG_DXA_DECODER) += dxa.o OBJS-$(CONFIG_EAC3_DECODER) += eac3dec.o eac3dec_data.o -OBJS-$(CONFIG_EAC3_ENCODER) += eac3enc.o ac3enc_float.o ac3tab.o \ - ac3.o kbdwin.o +OBJS-$(CONFIG_EAC3_ENCODER) += eac3enc.o ac3enc.o ac3enc_float.o \ + ac3tab.o ac3.o kbdwin.o OBJS-$(CONFIG_EACMV_DECODER) += eacmv.o OBJS-$(CONFIG_EAMAD_DECODER) += eamad.o eaidct.o mpeg12.o \ mpeg12data.o mpegvideo.o \ diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c index e71afe6..1147ed1 100644 --- a/libavcodec/ac3enc.c +++ b/libavcodec/ac3enc.c @@ -67,46 +67,6 @@ static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = { }; -#define OFFSET(param) offsetof(AC3EncodeContext, options.param) -#define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) - -#define AC3ENC_TYPE_AC3_FIXED 0 -#define AC3ENC_TYPE_AC3 1 -#define AC3ENC_TYPE_EAC3 2 - -#if CONFIG_AC3ENC_FLOAT -#define AC3ENC_TYPE AC3ENC_TYPE_AC3 -#include "ac3enc_opts_template.c" -static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name, - ac3_options, LIBAVUTIL_VERSION_INT }; -#undef AC3ENC_TYPE -#define AC3ENC_TYPE AC3ENC_TYPE_EAC3 -#include "ac3enc_opts_template.c" -static AVClass eac3enc_class = { "E-AC-3 Encoder", av_default_item_name, - eac3_options, LIBAVUTIL_VERSION_INT }; -#else -#define AC3ENC_TYPE AC3ENC_TYPE_AC3_FIXED -#include "ac3enc_opts_template.c" -static AVClass ac3enc_class = { "Fixed-Point AC-3 Encoder", av_default_item_name, - ac3fixed_options, LIBAVUTIL_VERSION_INT }; -#endif - - -/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */ - -static av_cold void mdct_end(AC3MDCTContext *mdct); - -static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, - int nbits); - -static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input, - const SampleType *window, unsigned int len); - -static int normalize_samples(AC3EncodeContext *s); - -static void scale_coefficients(AC3EncodeContext *s); - - /** * LUT for number of exponent groups. * exponent_group_tab[coupling][exponent strategy-1][number of coefficients] @@ -117,7 +77,7 @@ static uint8_t exponent_group_tab[2][3][256]; /** * List of supported channel layouts. */ -static const int64_t ac3_channel_layouts[] = { +const int64_t ff_ac3_channel_layouts[19] = { AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_2_1, @@ -230,60 +190,6 @@ static void adjust_frame_size(AC3EncodeContext *s) } -/** - * Deinterleave input samples. - * Channels are reordered from Libav's default order to AC-3 order. - */ -static void deinterleave_input_samples(AC3EncodeContext *s, - const SampleType *samples) -{ - int ch, i; - - /* deinterleave and remap input samples */ - for (ch = 0; ch < s->channels; ch++) { - const SampleType *sptr; - int sinc; - - /* copy last 256 samples of previous frame to the start of the current frame */ - memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE], - AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0])); - - /* deinterleave */ - sinc = s->channels; - sptr = samples + s->channel_map[ch]; - for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) { - s->planar_samples[ch][i] = *sptr; - sptr += sinc; - } - } -} - - -/** - * Apply the MDCT to input samples to generate frequency coefficients. - * This applies the KBD window and normalizes the input to reduce precision - * loss due to fixed-point calculations. - */ -static void apply_mdct(AC3EncodeContext *s) -{ - int blk, ch; - - for (ch = 0; ch < s->channels; ch++) { - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE]; - - apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct->window, AC3_WINDOW_SIZE); - - block->coeff_shift[ch+1] = normalize_samples(s); - - s->mdct->fft.mdct_calcw(&s->mdct->fft, block->mdct_coef[ch+1], - s->windowed_samples); - } - } -} - - static void compute_coupling_strategy(AC3EncodeContext *s) { int blk, ch; @@ -346,296 +252,6 @@ static void compute_coupling_strategy(AC3EncodeContext *s) /** - * Calculate a single coupling coordinate. - */ -static inline float calc_cpl_coord(float energy_ch, float energy_cpl) -{ - float coord = 0.125; - if (energy_cpl > 0) - coord *= sqrtf(energy_ch / energy_cpl); - return coord; -} - - -/** - * Calculate coupling channel and coupling coordinates. - * TODO: Currently this is only used for the floating-point encoder. I was - * able to make it work for the fixed-point encoder, but quality was - * generally lower in most cases than not using coupling. If a more - * adaptive coupling strategy were to be implemented it might be useful - * at that time to use coupling for the fixed-point encoder as well. - */ -static void apply_channel_coupling(AC3EncodeContext *s) -{ -#if CONFIG_AC3ENC_FLOAT - LOCAL_ALIGNED_16(float, cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]); - LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]); - int blk, ch, bnd, i, j; - CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}}; - int num_cpl_coefs = s->num_cpl_subbands * 12; - - memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords)); - memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*fixed_cpl_coords)); - - /* calculate coupling channel from fbw channels */ - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - CoefType *cpl_coef = &block->mdct_coef[CPL_CH][s->start_freq[CPL_CH]]; - if (!block->cpl_in_use) - continue; - memset(cpl_coef-1, 0, (num_cpl_coefs+4) * sizeof(*cpl_coef)); - for (ch = 1; ch <= s->fbw_channels; ch++) { - CoefType *ch_coef = &block->mdct_coef[ch][s->start_freq[CPL_CH]]; - if (!block->channel_in_cpl[ch]) - continue; - for (i = 0; i < num_cpl_coefs; i++) - cpl_coef[i] += ch_coef[i]; - } - /* note: coupling start bin % 4 will always be 1 and num_cpl_coefs - will always be a multiple of 12, so we need to subtract 1 from - the start and add 4 to the length when using optimized - functions which require 16-byte alignment. */ - - /* coefficients must be clipped to +/- 1.0 in order to be encoded */ - s->dsp.vector_clipf(cpl_coef-1, cpl_coef-1, -1.0f, 1.0f, num_cpl_coefs+4); - - /* scale coupling coefficients from float to 24-bit fixed-point */ - s->ac3dsp.float_to_fixed24(&block->fixed_coef[CPL_CH][s->start_freq[CPL_CH]-1], - cpl_coef-1, num_cpl_coefs+4); - } - - /* calculate energy in each band in coupling channel and each fbw channel */ - /* TODO: possibly use SIMD to speed up energy calculation */ - bnd = 0; - i = s->start_freq[CPL_CH]; - while (i < s->cpl_end_freq) { - int band_size = s->cpl_band_sizes[bnd]; - for (ch = CPL_CH; ch <= s->fbw_channels; ch++) { - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch])) - continue; - for (j = 0; j < band_size; j++) { - CoefType v = block->mdct_coef[ch][i+j]; - MAC_COEF(energy[blk][ch][bnd], v, v); - } - } - } - i += band_size; - bnd++; - } - - /* determine which blocks to send new coupling coordinates for */ - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL; - int new_coords = 0; - CoefSumType coord_diff[AC3_MAX_CHANNELS] = {0,}; - - if (block->cpl_in_use) { - /* calculate coupling coordinates for all blocks and calculate the - average difference between coordinates in successive blocks */ - for (ch = 1; ch <= s->fbw_channels; ch++) { - if (!block->channel_in_cpl[ch]) - continue; - - for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { - cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd], - energy[blk][CPL_CH][bnd]); - if (blk > 0 && block0->cpl_in_use && - block0->channel_in_cpl[ch]) { - coord_diff[ch] += fabs(cpl_coords[blk-1][ch][bnd] - - cpl_coords[blk ][ch][bnd]); - } - } - coord_diff[ch] /= s->num_cpl_bands; - } - - /* send new coordinates if this is the first block, if previous - * block did not use coupling but this block does, the channels - * using coupling has changed from the previous block, or the - * coordinate difference from the last block for any channel is - * greater than a threshold value. */ - if (blk == 0) { - new_coords = 1; - } else if (!block0->cpl_in_use) { - new_coords = 1; - } else { - for (ch = 1; ch <= s->fbw_channels; ch++) { - if (block->channel_in_cpl[ch] && !block0->channel_in_cpl[ch]) { - new_coords = 1; - break; - } - } - if (!new_coords) { - for (ch = 1; ch <= s->fbw_channels; ch++) { - if (block->channel_in_cpl[ch] && coord_diff[ch] > 0.04) { - new_coords = 1; - break; - } - } - } - } - } - block->new_cpl_coords = new_coords; - } - - /* calculate final coupling coordinates, taking into account reusing of - coordinates in successive blocks */ - for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { - blk = 0; - while (blk < AC3_MAX_BLOCKS) { - int blk1; - CoefSumType energy_cpl; - AC3Block *block = &s->blocks[blk]; - - if (!block->cpl_in_use) { - blk++; - continue; - } - - energy_cpl = energy[blk][CPL_CH][bnd]; - blk1 = blk+1; - while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) { - if (s->blocks[blk1].cpl_in_use) - energy_cpl += energy[blk1][CPL_CH][bnd]; - blk1++; - } - - for (ch = 1; ch <= s->fbw_channels; ch++) { - CoefType energy_ch; - if (!block->channel_in_cpl[ch]) - continue; - energy_ch = energy[blk][ch][bnd]; - blk1 = blk+1; - while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) { - if (s->blocks[blk1].cpl_in_use) - energy_ch += energy[blk1][ch][bnd]; - blk1++; - } - cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl); - } - blk = blk1; - } - } - - /* calculate exponents/mantissas for coupling coordinates */ - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - if (!block->cpl_in_use || !block->new_cpl_coords) - continue; - - s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1], - cpl_coords[blk][1], - s->fbw_channels * 16); - s->ac3dsp.extract_exponents(block->cpl_coord_exp[1], - fixed_cpl_coords[blk][1], - s->fbw_channels * 16); - - for (ch = 1; ch <= s->fbw_channels; ch++) { - int bnd, min_exp, max_exp, master_exp; - - /* determine master exponent */ - min_exp = max_exp = block->cpl_coord_exp[ch][0]; - for (bnd = 1; bnd < s->num_cpl_bands; bnd++) { - int exp = block->cpl_coord_exp[ch][bnd]; - min_exp = FFMIN(exp, min_exp); - max_exp = FFMAX(exp, max_exp); - } - master_exp = ((max_exp - 15) + 2) / 3; - master_exp = FFMAX(master_exp, 0); - while (min_exp < master_exp * 3) - master_exp--; - for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { - block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] - - master_exp * 3, 0, 15); - } - block->cpl_master_exp[ch] = master_exp; - - /* quantize mantissas */ - for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { - int cpl_exp = block->cpl_coord_exp[ch][bnd]; - int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24; - if (cpl_exp == 15) - cpl_mant >>= 1; - else - cpl_mant -= 16; - - block->cpl_coord_mant[ch][bnd] = cpl_mant; - } - } - } - - if (CONFIG_EAC3_ENCODER && s->eac3) - ff_eac3_set_cpl_states(s); -#endif /* CONFIG_AC3ENC_FLOAT */ -} - - -/** - * Determine rematrixing flags for each block and band. - */ -static void compute_rematrixing_strategy(AC3EncodeContext *s) -{ - int nb_coefs; - int blk, bnd, i; - AC3Block *block, *block0; - - if (s->channel_mode != AC3_CHMODE_STEREO) - return; - - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - block = &s->blocks[blk]; - block->new_rematrixing_strategy = !blk; - - if (!s->rematrixing_enabled) { - block0 = block; - continue; - } - - block->num_rematrixing_bands = 4; - if (block->cpl_in_use) { - block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61); - block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37); - if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands) - block->new_rematrixing_strategy = 1; - } - nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]); - - for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) { - /* calculate calculate sum of squared coeffs for one band in one block */ - int start = ff_ac3_rematrix_band_tab[bnd]; - int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); - CoefSumType sum[4] = {0,}; - for (i = start; i < end; i++) { - CoefType lt = block->mdct_coef[1][i]; - CoefType rt = block->mdct_coef[2][i]; - CoefType md = lt + rt; - CoefType sd = lt - rt; - MAC_COEF(sum[0], lt, lt); - MAC_COEF(sum[1], rt, rt); - MAC_COEF(sum[2], md, md); - MAC_COEF(sum[3], sd, sd); - } - - /* compare sums to determine if rematrixing will be used for this band */ - if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1])) - block->rematrixing_flags[bnd] = 1; - else - block->rematrixing_flags[bnd] = 0; - - /* determine if new rematrixing flags will be sent */ - if (blk && - block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) { - block->new_rematrixing_strategy = 1; - } - } - block0 = block; - } -} - - -/** * Apply stereo rematrixing to coefficients based on rematrixing flags. */ static void apply_rematrixing(AC3EncodeContext *s) @@ -1467,7 +1083,7 @@ static int compute_bit_allocation(AC3EncodeContext *s) if (s->cpl_on) { s->cpl_on = 0; compute_coupling_strategy(s); - compute_rematrixing_strategy(s); + s->compute_rematrixing_strategy(s); apply_rematrixing(s); process_exponents(s); ret = compute_bit_allocation(s); @@ -2262,8 +1878,8 @@ static int validate_metadata(AVCodecContext *avctx) /** * Encode a single AC-3 frame. */ -static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, - int buf_size, void *data) +int ff_ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, + int buf_size, void *data) { AC3EncodeContext *s = avctx->priv_data; const SampleType *samples = data; @@ -2278,19 +1894,19 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, if (s->bit_alloc.sr_code == 1 || s->eac3) adjust_frame_size(s); - deinterleave_input_samples(s, samples); + s->deinterleave_input_samples(s, samples); - apply_mdct(s); + s->apply_mdct(s); - scale_coefficients(s); + s->scale_coefficients(s); s->cpl_on = s->cpl_enabled; compute_coupling_strategy(s); if (s->cpl_on) - apply_channel_coupling(s); + s->apply_channel_coupling(s); - compute_rematrixing_strategy(s); + s->compute_rematrixing_strategy(s); apply_rematrixing(s); @@ -2313,7 +1929,7 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, /** * Finalize encoding and free any memory allocated by the encoder. */ -static av_cold int ac3_encode_close(AVCodecContext *avctx) +av_cold int ff_ac3_encode_close(AVCodecContext *avctx) { int blk, ch; AC3EncodeContext *s = avctx->priv_data; @@ -2344,7 +1960,7 @@ static av_cold int ac3_encode_close(AVCodecContext *avctx) av_freep(&block->qmant); } - mdct_end(s->mdct); + s->mdct_end(s->mdct); av_freep(&s->mdct); av_freep(&avctx->coded_frame); @@ -2515,8 +2131,7 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) (s->channel_mode == AC3_CHMODE_STEREO); s->cpl_enabled = s->options.channel_coupling && - s->channel_mode >= AC3_CHMODE_STEREO && - CONFIG_AC3ENC_FLOAT; + s->channel_mode >= AC3_CHMODE_STEREO && !s->fixed_point; return 0; } @@ -2674,7 +2289,7 @@ static av_cold int allocate_buffers(AVCodecContext *avctx) } } - if (CONFIG_AC3ENC_FLOAT) { + if (!s->fixed_point) { FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * channels * AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail); for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { @@ -2703,7 +2318,7 @@ alloc_fail: /** * Initialize the encoder. */ -static av_cold int ac3_encode_init(AVCodecContext *avctx) +av_cold int ff_ac3_encode_init(AVCodecContext *avctx) { AC3EncodeContext *s = avctx->priv_data; int ret, frame_size_58; @@ -2734,6 +2349,27 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx) } /* set function pointers */ + if (CONFIG_AC3_FIXED_ENCODER && s->fixed_point) { + s->mdct_end = ff_ac3_fixed_mdct_end; + s->mdct_init = ff_ac3_fixed_mdct_init; + s->apply_window = ff_ac3_fixed_apply_window; + s->normalize_samples = ff_ac3_fixed_normalize_samples; + s->scale_coefficients = ff_ac3_fixed_scale_coefficients; + s->deinterleave_input_samples = ff_ac3_fixed_deinterleave_input_samples; + s->apply_mdct = ff_ac3_fixed_apply_mdct; + s->apply_channel_coupling = ff_ac3_fixed_apply_channel_coupling; + s->compute_rematrixing_strategy = ff_ac3_fixed_compute_rematrixing_strategy; + } else if (CONFIG_AC3_ENCODER || CONFIG_EAC3_ENCODER) { + s->mdct_end = ff_ac3_float_mdct_end; + s->mdct_init = ff_ac3_float_mdct_init; + s->apply_window = ff_ac3_float_apply_window; + s->normalize_samples = ff_ac3_float_normalize_samples; + s->scale_coefficients = ff_ac3_float_scale_coefficients; + s->deinterleave_input_samples = ff_ac3_float_deinterleave_input_samples; + s->apply_mdct = ff_ac3_float_apply_mdct; + s->apply_channel_coupling = ff_ac3_float_apply_channel_coupling; + s->compute_rematrixing_strategy = ff_ac3_float_compute_rematrixing_strategy; + } if (CONFIG_EAC3_ENCODER && s->eac3) s->output_frame_header = ff_eac3_output_frame_header; else @@ -2746,7 +2382,7 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx) bit_alloc_init(s); FF_ALLOCZ_OR_GOTO(avctx, s->mdct, sizeof(AC3MDCTContext), init_fail); - ret = mdct_init(avctx, s->mdct, 9); + ret = s->mdct_init(avctx, s->mdct, 9); if (ret) goto init_fail; @@ -2763,6 +2399,6 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx) return 0; init_fail: - ac3_encode_close(avctx); + ff_ac3_encode_close(avctx); return ret; } diff --git a/libavcodec/ac3enc.h b/libavcodec/ac3enc.h index ccdb963..e9d7e0a 100644 --- a/libavcodec/ac3enc.h +++ b/libavcodec/ac3enc.h @@ -40,18 +40,28 @@ #define CONFIG_AC3ENC_FLOAT 0 #endif +#define OFFSET(param) offsetof(AC3EncodeContext, options.param) +#define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) + +#define AC3ENC_TYPE_AC3_FIXED 0 +#define AC3ENC_TYPE_AC3 1 +#define AC3ENC_TYPE_EAC3 2 + #if CONFIG_AC3ENC_FLOAT +#define AC3_NAME(x) ff_ac3_float_ ## x #define MAC_COEF(d,a,b) ((d)+=(a)*(b)) typedef float SampleType; typedef float CoefType; typedef float CoefSumType; #else +#define AC3_NAME(x) ff_ac3_fixed_ ## x #define MAC_COEF(d,a,b) MAC64(d,a,b) typedef int16_t SampleType; typedef int32_t CoefType; typedef int64_t CoefSumType; #endif + typedef struct AC3MDCTContext { const SampleType *window; ///< MDCT window function FFTContext fft; ///< FFT context for MDCT calculation @@ -132,6 +142,7 @@ typedef struct AC3EncodeContext { AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info + int fixed_point; ///< indicates if fixed-point encoder is being used int eac3; ///< indicates if this is E-AC-3 vs. AC-3 int bitstream_id; ///< bitstream id (bsid) int bitstream_mode; ///< bitstream mode (bsmod) @@ -209,7 +220,75 @@ typedef struct AC3EncodeContext { uint8_t *ref_bap [AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< bit allocation pointers (bap) int ref_bap_set; ///< indicates if ref_bap pointers have been set + /* fixed vs. float function pointers */ + void (*mdct_end)(AC3MDCTContext *mdct); + int (*mdct_init)(AVCodecContext *avctx, AC3MDCTContext *mdct, int nbits); + void (*apply_window)(DSPContext *dsp, SampleType *output, + const SampleType *input, const SampleType *window, + unsigned int len); + int (*normalize_samples)(struct AC3EncodeContext *s); + void (*scale_coefficients)(struct AC3EncodeContext *s); + + /* fixed vs. float templated function pointers */ + void (*deinterleave_input_samples)(struct AC3EncodeContext *s, + const SampleType *samples); + void (*apply_mdct)(struct AC3EncodeContext *s); + void (*apply_channel_coupling)(struct AC3EncodeContext *s); + void (*compute_rematrixing_strategy)(struct AC3EncodeContext *s); + + /* AC-3 vs. E-AC-3 function pointers */ void (*output_frame_header)(struct AC3EncodeContext *s); } AC3EncodeContext; + +extern const int64_t ff_ac3_channel_layouts[19]; + +int ff_ac3_encode_init(AVCodecContext *avctx); + +int ff_ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, + int buf_size, void *data); + +int ff_ac3_encode_close(AVCodecContext *avctx); + + +/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */ + +void ff_ac3_fixed_mdct_end(AC3MDCTContext *mdct); +void ff_ac3_float_mdct_end(AC3MDCTContext *mdct); + +int ff_ac3_fixed_mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, + int nbits); +int ff_ac3_float_mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, + int nbits); + +void ff_ac3_fixed_apply_window(DSPContext *dsp, SampleType *output, + const SampleType *input, + const SampleType *window, unsigned int len); +void ff_ac3_float_apply_window(DSPContext *dsp, SampleType *output, + const SampleType *input, + const SampleType *window, unsigned int len); + +int ff_ac3_fixed_normalize_samples(AC3EncodeContext *s); +int ff_ac3_float_normalize_samples(AC3EncodeContext *s); + +void ff_ac3_fixed_scale_coefficients(AC3EncodeContext *s); +void ff_ac3_float_scale_coefficients(AC3EncodeContext *s); + + +/* prototypes for functions in ac3enc_template.c */ + +void ff_ac3_fixed_deinterleave_input_samples(AC3EncodeContext *s, + const SampleType *samples); +void ff_ac3_float_deinterleave_input_samples(AC3EncodeContext *s, + const SampleType *samples); + +void ff_ac3_fixed_apply_mdct(AC3EncodeContext *s); +void ff_ac3_float_apply_mdct(AC3EncodeContext *s); + +void ff_ac3_fixed_apply_channel_coupling(AC3EncodeContext *s); +void ff_ac3_float_apply_channel_coupling(AC3EncodeContext *s); + +void ff_ac3_fixed_compute_rematrixing_strategy(AC3EncodeContext *s); +void ff_ac3_float_compute_rematrixing_strategy(AC3EncodeContext *s); + #endif /* AVCODEC_AC3ENC_H */ diff --git a/libavcodec/ac3enc_fixed.c b/libavcodec/ac3enc_fixed.c index 035ebb3..0620a6a 100644 --- a/libavcodec/ac3enc_fixed.c +++ b/libavcodec/ac3enc_fixed.c @@ -28,13 +28,20 @@ #define CONFIG_FFT_FLOAT 0 #undef CONFIG_AC3ENC_FLOAT -#include "ac3enc.c" +#include "ac3enc.h" + +#define AC3ENC_TYPE AC3ENC_TYPE_AC3_FIXED +#include "ac3enc_opts_template.c" +static AVClass ac3enc_class = { "Fixed-Point AC-3 Encoder", av_default_item_name, + ac3fixed_options, LIBAVUTIL_VERSION_INT }; + +#include "ac3enc_template.c" /** * Finalize MDCT and free allocated memory. */ -static av_cold void mdct_end(AC3MDCTContext *mdct) +av_cold void AC3_NAME(mdct_end)(AC3MDCTContext *mdct) { ff_mdct_end(&mdct->fft); } @@ -44,8 +51,8 @@ static av_cold void mdct_end(AC3MDCTContext *mdct) * Initialize MDCT tables. * @param nbits log2(MDCT size) */ -static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, - int nbits) +av_cold int AC3_NAME(mdct_init)(AVCodecContext *avctx, AC3MDCTContext *mdct, + int nbits) { int ret = ff_mdct_init(&mdct->fft, nbits, 0, -1.0); mdct->window = ff_ac3_window; @@ -56,8 +63,9 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, /** * Apply KBD window to input samples prior to MDCT. */ -static void apply_window(DSPContext *dsp, int16_t *output, const int16_t *input, - const int16_t *window, unsigned int len) +void AC3_NAME(apply_window)(DSPContext *dsp, int16_t *output, + const int16_t *input, const int16_t *window, + unsigned int len) { dsp->apply_window_int16(output, input, window, len); } @@ -82,7 +90,7 @@ static int log2_tab(AC3EncodeContext *s, int16_t *src, int len) * * @return exponent shift */ -static int normalize_samples(AC3EncodeContext *s) +int AC3_NAME(normalize_samples)(AC3EncodeContext *s) { int v = 14 - log2_tab(s, s->windowed_samples, AC3_WINDOW_SIZE); if (v > 0) @@ -95,7 +103,7 @@ static int normalize_samples(AC3EncodeContext *s) /** * Scale MDCT coefficients to 25-bit signed fixed-point. */ -static void scale_coefficients(AC3EncodeContext *s) +void AC3_NAME(scale_coefficients)(AC3EncodeContext *s) { int blk, ch; @@ -109,17 +117,25 @@ static void scale_coefficients(AC3EncodeContext *s) } +static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx) +{ + AC3EncodeContext *s = avctx->priv_data; + s->fixed_point = 1; + return ff_ac3_encode_init(avctx); +} + + AVCodec ff_ac3_fixed_encoder = { "ac3_fixed", AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3, sizeof(AC3EncodeContext), - ac3_encode_init, - ac3_encode_frame, - ac3_encode_close, + ac3_fixed_encode_init, + ff_ac3_encode_frame, + ff_ac3_encode_close, NULL, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .priv_class = &ac3enc_class, - .channel_layouts = ac3_channel_layouts, + .channel_layouts = ff_ac3_channel_layouts, }; diff --git a/libavcodec/ac3enc_float.c b/libavcodec/ac3enc_float.c index 012c31d..9c7e88e 100644 --- a/libavcodec/ac3enc_float.c +++ b/libavcodec/ac3enc_float.c @@ -27,14 +27,25 @@ */ #define CONFIG_AC3ENC_FLOAT 1 -#include "ac3enc.c" +#include "ac3enc.h" +#include "eac3enc.h" #include "kbdwin.h" +#if CONFIG_AC3_ENCODER +#define AC3ENC_TYPE AC3ENC_TYPE_AC3 +#include "ac3enc_opts_template.c" +static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name, + ac3_options, LIBAVUTIL_VERSION_INT }; +#endif + +#include "ac3enc_template.c" + + /** * Finalize MDCT and free allocated memory. */ -static av_cold void mdct_end(AC3MDCTContext *mdct) +av_cold void ff_ac3_float_mdct_end(AC3MDCTContext *mdct) { ff_mdct_end(&mdct->fft); av_freep(&mdct->window); @@ -45,8 +56,8 @@ static av_cold void mdct_end(AC3MDCTContext *mdct) * Initialize MDCT tables. * @param nbits log2(MDCT size) */ -static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, - int nbits) +av_cold int ff_ac3_float_mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, + int nbits) { float *window; int i, n, n2; @@ -71,8 +82,9 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, /** * Apply KBD window to input samples prior to MDCT. */ -static void apply_window(DSPContext *dsp, float *output, const float *input, - const float *window, unsigned int len) +void ff_ac3_float_apply_window(DSPContext *dsp, float *output, + const float *input, const float *window, + unsigned int len) { dsp->vector_fmul(output, input, window, len); } @@ -81,7 +93,7 @@ static void apply_window(DSPContext *dsp, float *output, const float *input, /** * Normalize the input samples to use the maximum available precision. */ -static int normalize_samples(AC3EncodeContext *s) +int ff_ac3_float_normalize_samples(AC3EncodeContext *s) { /* Normalization is not needed for floating-point samples, so just return 0 */ return 0; @@ -91,7 +103,7 @@ static int normalize_samples(AC3EncodeContext *s) /** * Scale MDCT coefficients from float to 24-bit fixed-point. */ -static void scale_coefficients(AC3EncodeContext *s) +void ff_ac3_float_scale_coefficients(AC3EncodeContext *s) { int chan_size = AC3_MAX_COEFS * AC3_MAX_BLOCKS; s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer + chan_size, @@ -106,29 +118,13 @@ AVCodec ff_ac3_encoder = { AVMEDIA_TYPE_AUDIO, CODEC_ID_AC3, sizeof(AC3EncodeContext), - ac3_encode_init, - ac3_encode_frame, - ac3_encode_close, + ff_ac3_encode_init, + ff_ac3_encode_frame, + ff_ac3_encode_close, NULL, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .priv_class = &ac3enc_class, - .channel_layouts = ac3_channel_layouts, -}; -#endif - -#if CONFIG_EAC3_ENCODER -AVCodec ff_eac3_encoder = { - .name = "eac3", - .type = AVMEDIA_TYPE_AUDIO, - .id = CODEC_ID_EAC3, - .priv_data_size = sizeof(AC3EncodeContext), - .init = ac3_encode_init, - .encode = ac3_encode_frame, - .close = ac3_encode_close, - .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, - .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"), - .priv_class = &eac3enc_class, - .channel_layouts = ac3_channel_layouts, + .channel_layouts = ff_ac3_channel_layouts, }; #endif diff --git a/libavcodec/ac3enc_opts_template.c b/libavcodec/ac3enc_opts_template.c index e16e0d0..39138a1 100644 --- a/libavcodec/ac3enc_opts_template.c +++ b/libavcodec/ac3enc_opts_template.c @@ -19,6 +19,9 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "libavutil/opt.h" +#include "ac3.h" + #if AC3ENC_TYPE == AC3ENC_TYPE_AC3_FIXED static const AVOption ac3fixed_options[] = { #elif AC3ENC_TYPE == AC3ENC_TYPE_AC3 diff --git a/libavcodec/ac3enc_template.c b/libavcodec/ac3enc_template.c new file mode 100644 index 0000000..d88fa22 --- /dev/null +++ b/libavcodec/ac3enc_template.c @@ -0,0 +1,377 @@ +/* + * AC-3 encoder float/fixed template + * Copyright (c) 2000 Fabrice Bellard + * Copyright (c) 2006-2011 Justin Ruggles + * Copyright (c) 2006-2010 Prakash Punnoor + * + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * AC-3 encoder float/fixed template + */ + +#include + +#include "ac3enc.h" + + +/** + * Deinterleave input samples. + * Channels are reordered from Libav's default order to AC-3 order. + */ +void AC3_NAME(deinterleave_input_samples)(AC3EncodeContext *s, + const SampleType *samples) +{ + int ch, i; + + /* deinterleave and remap input samples */ + for (ch = 0; ch < s->channels; ch++) { + const SampleType *sptr; + int sinc; + + /* copy last 256 samples of previous frame to the start of the current frame */ + memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE], + AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0])); + + /* deinterleave */ + sinc = s->channels; + sptr = samples + s->channel_map[ch]; + for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) { + s->planar_samples[ch][i] = *sptr; + sptr += sinc; + } + } +} + + +/** + * Apply the MDCT to input samples to generate frequency coefficients. + * This applies the KBD window and normalizes the input to reduce precision + * loss due to fixed-point calculations. + */ +void AC3_NAME(apply_mdct)(AC3EncodeContext *s) +{ + int blk, ch; + + for (ch = 0; ch < s->channels; ch++) { + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE]; + + s->apply_window(&s->dsp, s->windowed_samples, input_samples, + s->mdct->window, AC3_WINDOW_SIZE); + + if (s->fixed_point) + block->coeff_shift[ch+1] = s->normalize_samples(s); + + s->mdct->fft.mdct_calcw(&s->mdct->fft, block->mdct_coef[ch+1], + s->windowed_samples); + } + } +} + + +/** + * Calculate a single coupling coordinate. + */ +static inline float calc_cpl_coord(float energy_ch, float energy_cpl) +{ + float coord = 0.125; + if (energy_cpl > 0) + coord *= sqrtf(energy_ch / energy_cpl); + return coord; +} + + +/** + * Calculate coupling channel and coupling coordinates. + * TODO: Currently this is only used for the floating-point encoder. I was + * able to make it work for the fixed-point encoder, but quality was + * generally lower in most cases than not using coupling. If a more + * adaptive coupling strategy were to be implemented it might be useful + * at that time to use coupling for the fixed-point encoder as well. + */ +void AC3_NAME(apply_channel_coupling)(AC3EncodeContext *s) +{ +#if CONFIG_AC3ENC_FLOAT + LOCAL_ALIGNED_16(float, cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]); + LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]); + int blk, ch, bnd, i, j; + CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}}; + int num_cpl_coefs = s->num_cpl_subbands * 12; + + memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords)); + memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*fixed_cpl_coords)); + + /* calculate coupling channel from fbw channels */ + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + CoefType *cpl_coef = &block->mdct_coef[CPL_CH][s->start_freq[CPL_CH]]; + if (!block->cpl_in_use) + continue; + memset(cpl_coef-1, 0, (num_cpl_coefs+4) * sizeof(*cpl_coef)); + for (ch = 1; ch <= s->fbw_channels; ch++) { + CoefType *ch_coef = &block->mdct_coef[ch][s->start_freq[CPL_CH]]; + if (!block->channel_in_cpl[ch]) + continue; + for (i = 0; i < num_cpl_coefs; i++) + cpl_coef[i] += ch_coef[i]; + } + /* note: coupling start bin % 4 will always be 1 and num_cpl_coefs + will always be a multiple of 12, so we need to subtract 1 from + the start and add 4 to the length when using optimized + functions which require 16-byte alignment. */ + + /* coefficients must be clipped to +/- 1.0 in order to be encoded */ + s->dsp.vector_clipf(cpl_coef-1, cpl_coef-1, -1.0f, 1.0f, num_cpl_coefs+4); + + /* scale coupling coefficients from float to 24-bit fixed-point */ + s->ac3dsp.float_to_fixed24(&block->fixed_coef[CPL_CH][s->start_freq[CPL_CH]-1], + cpl_coef-1, num_cpl_coefs+4); + } + + /* calculate energy in each band in coupling channel and each fbw channel */ + /* TODO: possibly use SIMD to speed up energy calculation */ + bnd = 0; + i = s->start_freq[CPL_CH]; + while (i < s->cpl_end_freq) { + int band_size = s->cpl_band_sizes[bnd]; + for (ch = CPL_CH; ch <= s->fbw_channels; ch++) { + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch])) + continue; + for (j = 0; j < band_size; j++) { + CoefType v = block->mdct_coef[ch][i+j]; + MAC_COEF(energy[blk][ch][bnd], v, v); + } + } + } + i += band_size; + bnd++; + } + + /* determine which blocks to send new coupling coordinates for */ + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL; + int new_coords = 0; + CoefSumType coord_diff[AC3_MAX_CHANNELS] = {0,}; + + if (block->cpl_in_use) { + /* calculate coupling coordinates for all blocks and calculate the + average difference between coordinates in successive blocks */ + for (ch = 1; ch <= s->fbw_channels; ch++) { + if (!block->channel_in_cpl[ch]) + continue; + + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd], + energy[blk][CPL_CH][bnd]); + if (blk > 0 && block0->cpl_in_use && + block0->channel_in_cpl[ch]) { + coord_diff[ch] += fabs(cpl_coords[blk-1][ch][bnd] - + cpl_coords[blk ][ch][bnd]); + } + } + coord_diff[ch] /= s->num_cpl_bands; + } + + /* send new coordinates if this is the first block, if previous + * block did not use coupling but this block does, the channels + * using coupling has changed from the previous block, or the + * coordinate difference from the last block for any channel is + * greater than a threshold value. */ + if (blk == 0) { + new_coords = 1; + } else if (!block0->cpl_in_use) { + new_coords = 1; + } else { + for (ch = 1; ch <= s->fbw_channels; ch++) { + if (block->channel_in_cpl[ch] && !block0->channel_in_cpl[ch]) { + new_coords = 1; + break; + } + } + if (!new_coords) { + for (ch = 1; ch <= s->fbw_channels; ch++) { + if (block->channel_in_cpl[ch] && coord_diff[ch] > 0.04) { + new_coords = 1; + break; + } + } + } + } + } + block->new_cpl_coords = new_coords; + } + + /* calculate final coupling coordinates, taking into account reusing of + coordinates in successive blocks */ + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + blk = 0; + while (blk < AC3_MAX_BLOCKS) { + int blk1; + CoefSumType energy_cpl; + AC3Block *block = &s->blocks[blk]; + + if (!block->cpl_in_use) { + blk++; + continue; + } + + energy_cpl = energy[blk][CPL_CH][bnd]; + blk1 = blk+1; + while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) { + if (s->blocks[blk1].cpl_in_use) + energy_cpl += energy[blk1][CPL_CH][bnd]; + blk1++; + } + + for (ch = 1; ch <= s->fbw_channels; ch++) { + CoefType energy_ch; + if (!block->channel_in_cpl[ch]) + continue; + energy_ch = energy[blk][ch][bnd]; + blk1 = blk+1; + while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) { + if (s->blocks[blk1].cpl_in_use) + energy_ch += energy[blk1][ch][bnd]; + blk1++; + } + cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl); + } + blk = blk1; + } + } + + /* calculate exponents/mantissas for coupling coordinates */ + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + if (!block->cpl_in_use || !block->new_cpl_coords) + continue; + + s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1], + cpl_coords[blk][1], + s->fbw_channels * 16); + s->ac3dsp.extract_exponents(block->cpl_coord_exp[1], + fixed_cpl_coords[blk][1], + s->fbw_channels * 16); + + for (ch = 1; ch <= s->fbw_channels; ch++) { + int bnd, min_exp, max_exp, master_exp; + + /* determine master exponent */ + min_exp = max_exp = block->cpl_coord_exp[ch][0]; + for (bnd = 1; bnd < s->num_cpl_bands; bnd++) { + int exp = block->cpl_coord_exp[ch][bnd]; + min_exp = FFMIN(exp, min_exp); + max_exp = FFMAX(exp, max_exp); + } + master_exp = ((max_exp - 15) + 2) / 3; + master_exp = FFMAX(master_exp, 0); + while (min_exp < master_exp * 3) + master_exp--; + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] - + master_exp * 3, 0, 15); + } + block->cpl_master_exp[ch] = master_exp; + + /* quantize mantissas */ + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + int cpl_exp = block->cpl_coord_exp[ch][bnd]; + int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24; + if (cpl_exp == 15) + cpl_mant >>= 1; + else + cpl_mant -= 16; + + block->cpl_coord_mant[ch][bnd] = cpl_mant; + } + } + } + + if (CONFIG_EAC3_ENCODER && s->eac3) + ff_eac3_set_cpl_states(s); +#endif /* CONFIG_AC3ENC_FLOAT */ +} + + +/** + * Determine rematrixing flags for each block and band. + */ +void AC3_NAME(compute_rematrixing_strategy)(AC3EncodeContext *s) +{ + int nb_coefs; + int blk, bnd, i; + AC3Block *block, *av_uninit(block0); + + if (s->channel_mode != AC3_CHMODE_STEREO) + return; + + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + block = &s->blocks[blk]; + block->new_rematrixing_strategy = !blk; + + if (!s->rematrixing_enabled) { + block0 = block; + continue; + } + + block->num_rematrixing_bands = 4; + if (block->cpl_in_use) { + block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61); + block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37); + if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands) + block->new_rematrixing_strategy = 1; + } + nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]); + + for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) { + /* calculate calculate sum of squared coeffs for one band in one block */ + int start = ff_ac3_rematrix_band_tab[bnd]; + int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); + CoefSumType sum[4] = {0,}; + for (i = start; i < end; i++) { + CoefType lt = block->mdct_coef[1][i]; + CoefType rt = block->mdct_coef[2][i]; + CoefType md = lt + rt; + CoefType sd = lt - rt; + MAC_COEF(sum[0], lt, lt); + MAC_COEF(sum[1], rt, rt); + MAC_COEF(sum[2], md, md); + MAC_COEF(sum[3], sd, sd); + } + + /* compare sums to determine if rematrixing will be used for this band */ + if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1])) + block->rematrixing_flags[bnd] = 1; + else + block->rematrixing_flags[bnd] = 0; + + /* determine if new rematrixing flags will be sent */ + if (blk && + block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) { + block->new_rematrixing_strategy = 1; + } + } + block0 = block; + } +} diff --git a/libavcodec/eac3enc.c b/libavcodec/eac3enc.c index 20f4b87..d37acaf 100644 --- a/libavcodec/eac3enc.c +++ b/libavcodec/eac3enc.c @@ -28,6 +28,13 @@ #include "ac3enc.h" #include "eac3enc.h" + +#define AC3ENC_TYPE AC3ENC_TYPE_EAC3 +#include "ac3enc_opts_template.c" +static AVClass eac3enc_class = { "E-AC-3 Encoder", av_default_item_name, + eac3_options, LIBAVUTIL_VERSION_INT }; + + void ff_eac3_set_cpl_states(AC3EncodeContext *s) { int ch, blk; @@ -129,3 +136,20 @@ void ff_eac3_output_frame_header(AC3EncodeContext *s) /* block start info */ put_bits(&s->pb, 1, 0); } + + +#if CONFIG_EAC3_ENCODER +AVCodec ff_eac3_encoder = { + .name = "eac3", + .type = AVMEDIA_TYPE_AUDIO, + .id = CODEC_ID_EAC3, + .priv_data_size = sizeof(AC3EncodeContext), + .init = ff_ac3_encode_init, + .encode = ff_ac3_encode_frame, + .close = ff_ac3_encode_close, + .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, + .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"), + .priv_class = &eac3enc_class, + .channel_layouts = ff_ac3_channel_layouts, +}; +#endif