X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fac3enc_template.c;h=79b4946b657fe384ad2a5c832fc03e0cb3159fcc;hb=56c2f37727015212a404cae0f444d8bc8704d691;hp=e7b8967edd6d22cb3b4ccad0dd23c753132d8104;hpb=a0d17b6d45b8550bd8826baa9f8eb4e1a596525a;p=ffmpeg diff --git a/libavcodec/ac3enc_template.c b/libavcodec/ac3enc_template.c index e7b8967edd6..79b4946b657 100644 --- a/libavcodec/ac3enc_template.c +++ b/libavcodec/ac3enc_template.c @@ -28,18 +28,24 @@ #include +#include "libavutil/attributes.h" +#include "libavutil/internal.h" + +#include "audiodsp.h" +#include "internal.h" +#include "ac3enc.h" +#include "eac3enc.h" /* prototypes for static functions in ac3enc_fixed.c and ac3enc_float.c */ static void scale_coefficients(AC3EncodeContext *s); -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 clip_coefficients(DSPContext *dsp, CoefType *coef, unsigned int len); +static void clip_coefficients(AudioDSPContext *adsp, CoefType *coef, + unsigned int len); + +static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl); int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s) @@ -62,36 +68,29 @@ alloc_fail: } -/** - * Deinterleave input samples. +/* + * Copy input samples. * Channels are reordered from Libav's default order to AC-3 order. */ -static void deinterleave_input_samples(AC3EncodeContext *s, - const SampleType *samples) +static void copy_input_samples(AC3EncodeContext *s, SampleType **samples) { - int ch, i; + int ch; - /* deinterleave and remap input samples */ + /* copy 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_BLOCK_SIZE * s->num_blocks], 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_BLOCK_SIZE * (s->num_blocks + 1); i++) { - s->planar_samples[ch][i] = *sptr; - sptr += sinc; - } + /* copy new samples for current frame */ + memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE], + samples[s->channel_map[ch]], + AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0])); } } -/** +/* * 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. @@ -105,8 +104,13 @@ static void apply_mdct(AC3EncodeContext *s) 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); +#if CONFIG_AC3ENC_FLOAT + s->fdsp.vector_fmul(s->windowed_samples, input_samples, + s->mdct_window, AC3_WINDOW_SIZE); +#else + s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples, + s->mdct_window, AC3_WINDOW_SIZE); +#endif if (s->fixed_point) block->coeff_shift[ch+1] = normalize_samples(s); @@ -118,32 +122,25 @@ static void apply_mdct(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 FFMIN(coord, COEF_MAX); -} - - -/** +/* * Calculate coupling channel and coupling coordinates. */ static void apply_channel_coupling(AC3EncodeContext *s) { + LOCAL_ALIGNED_16(CoefType, cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]); #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]); +#else + int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords; +#endif int blk, ch, bnd, i, j; CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}}; int cpl_start, num_cpl_coefs; memset(cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords)); - memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*fixed_cpl_coords)); +#if CONFIG_AC3ENC_FLOAT + memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords)); +#endif /* align start to 16-byte boundary. align length to multiple of 32. note: coupling start bin % 4 will always be 1 */ @@ -167,7 +164,7 @@ static void apply_channel_coupling(AC3EncodeContext *s) } /* coefficients must be clipped in order to be encoded */ - clip_coefficients(&s->dsp, cpl_coef, num_cpl_coefs); + clip_coefficients(&s->adsp, cpl_coef, num_cpl_coefs); } /* calculate energy in each band in coupling channel and each fbw channel */ @@ -231,11 +228,11 @@ static void apply_channel_coupling(AC3EncodeContext *s) } else { CoefSumType coord_diff = 0; for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { - coord_diff += fabs(cpl_coords[blk-1][ch][bnd] - - cpl_coords[blk ][ch][bnd]); + coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] - + cpl_coords[blk ][ch][bnd]); } coord_diff /= s->num_cpl_bands; - if (coord_diff > 0.03) + if (coord_diff > NEW_CPL_COORD_THRESHOLD) block->new_cpl_coords[ch] = 1; } } @@ -282,9 +279,11 @@ static void apply_channel_coupling(AC3EncodeContext *s) if (!block->cpl_in_use) continue; +#if CONFIG_AC3ENC_FLOAT s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1], cpl_coords[blk][1], s->fbw_channels * 16); +#endif s->ac3dsp.extract_exponents(block->cpl_coord_exp[1], fixed_cpl_coords[blk][1], s->fbw_channels * 16); @@ -328,18 +327,17 @@ static void apply_channel_coupling(AC3EncodeContext *s) 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, *av_uninit(block0); + AC3Block *block, *block0; if (s->channel_mode != AC3_CHMODE_STEREO) return; @@ -395,14 +393,10 @@ static void compute_rematrixing_strategy(AC3EncodeContext *s) } -/** - * Encode a single AC-3 frame. - */ -int AC3_NAME(encode_frame)(AVCodecContext *avctx, unsigned char *frame, - int buf_size, void *data) +int AC3_NAME(encode_frame)(AVCodecContext *avctx, AVPacket *avpkt, + const AVFrame *frame, int *got_packet_ptr) { AC3EncodeContext *s = avctx->priv_data; - const SampleType *samples = data; int ret; if (s->options.allow_per_frame_metadata) { @@ -414,14 +408,14 @@ int AC3_NAME(encode_frame)(AVCodecContext *avctx, unsigned char *frame, if (s->bit_alloc.sr_code == 1 || s->eac3) ff_ac3_adjust_frame_size(s); - deinterleave_input_samples(s, samples); + copy_input_samples(s, (SampleType **)frame->extended_data); apply_mdct(s); if (s->fixed_point) scale_coefficients(s); - clip_coefficients(&s->dsp, s->blocks[0].mdct_coef[1], + clip_coefficients(&s->adsp, s->blocks[0].mdct_coef[1], AC3_MAX_COEFS * s->num_blocks * s->channels); s->cpl_on = s->cpl_enabled; @@ -449,7 +443,15 @@ int AC3_NAME(encode_frame)(AVCodecContext *avctx, unsigned char *frame, ff_ac3_quantize_mantissas(s); - ff_ac3_output_frame(s, frame); + if ((ret = ff_alloc_packet(avpkt, s->frame_size))) { + av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n"); + return ret; + } + ff_ac3_output_frame(s, avpkt->data); + + if (frame->pts != AV_NOPTS_VALUE) + avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay); - return s->frame_size; + *got_packet_ptr = 1; + return 0; }