falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge remote-tracking branch 'qatar/master' 

* qatar/master: (24 commits)
  utils: Drop pointless '#if 1' preprocessor directive.
  ac3enc: remove empty ac3_float function that is never called
  ac3enc: split templated float vs. fixed functions into a separate file.
  ac3enc: dynamically allocate AC3EncodeContext fields windowed_samples and mdct
  ac3enc: use function pointer to choose between AC-3 and E-AC-3 header output functions.
  Roll back 4:4:4 H.264 for now Needs some ARM/PPC asm modifications.
  Fix SVQ3 after adding 4:4:4 H.264 support
  H.264: fix CODEC_FLAG_GRAY
  4:4:4 H.264 decoding support
  h264_parser: Fix whitespace after previous change.
  h264_parser: Fix behaviour when PARSER_FLAG_COMPLETE_FRAMES is set.
  wav: remove an invalid free().
  lavf: initialise reference_dts in av_estimate_timings_from_pts.
  h264: don't be so picky on decoding pps in extradata.
  avcodec.h: add or elaborate on some documentation comments.
  h264: change a few comments into error messages
  ac3dec: fix doxy-style for comment ("///>" should be "///<" instead).
  img2: add .dpx to the list of supported file extensions.
  ffv1: fix undefined behavior with insane widths.
  ARM: jrevdct_arm: simplify stack usage
  ...

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n0.8
Michael Niedermayer 14 years ago
parent
fdb5e02901 35bdaf3d42
commit
173cd695cb
18 changed files with 800 additions and 493 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +8
    -0
      Changelog
  2. +4
    -4
      libavcodec/Makefile
  3. +1
    -1
      libavcodec/ac3dec.h
  4. +48
    -408
      libavcodec/ac3enc.c
  5. +81
    -2
      libavcodec/ac3enc.h
  6. +27
    -11
      libavcodec/ac3enc_fixed.c
  7. +22
    -36
      libavcodec/ac3enc_float.c
  8. +3
    -0
      libavcodec/ac3enc_opts_template.c
  9. +377
    -0
      libavcodec/ac3enc_template.c
  10. +3
    -0
      libavcodec/arm/Makefile
  11. +13
    -18
      libavcodec/arm/jrevdct_arm.S
  12. +143
    -0
      libavcodec/arm/mpegaudiodsp_fixed_armv6.S
  13. +33
    -0
      libavcodec/arm/mpegaudiodsp_init_arm.c
  14. +24
    -0
      libavcodec/eac3enc.c
  15. +11
    -11
      libavcodec/h264.c
  16. +1
    -0
      libavcodec/mpegaudiodsp.c
  17. +1
    -0
      libavcodec/mpegaudiodsp.h
  18. +0
    -2
      libavformat/utils.c

+ 8
- 0
Changelog View File

@@ -10,6 +10,14 @@ version <next>:
- libxvid aspect pickiness fixed - libxvid aspect pickiness fixed
- Frame multithreaded decoding - Frame multithreaded decoding
- E-AC-3 audio encoder - E-AC-3 audio encoder
- ac3enc: add channel coupling support
- floating-point sample format support to the ac3, eac3, dca, aac, and vorbis decoders.
- H264/MPEG frame-level multi-threading
- All av_metadata_* functions renamed to av_dict_* and moved to libavutil


version 0.7_beta2:

- Lots of deprecated API cruft removed - Lots of deprecated API cruft removed
- fft and imdct optimizations for AVX (Sandy Bridge) processors - fft and imdct optimizations for AVX (Sandy Bridge) processors
- showinfo filter added - showinfo filter added


+ 4
- 4
libavcodec/Makefile View File

@@ -63,8 +63,8 @@ OBJS-$(CONFIG_AAC_ENCODER) += aacenc.o aaccoder.o \
OBJS-$(CONFIG_AASC_DECODER) += aasc.o msrledec.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_DECODER) += ac3dec.o ac3dec_data.o ac3.o kbdwin.o
OBJS-$(CONFIG_AC3_ENCODER) += ac3enc_combined.o ac3enc_fixed.o ac3enc_float.o ac3tab.o ac3.o kbdwin.o OBJS-$(CONFIG_AC3_ENCODER) += ac3enc_combined.o ac3enc_fixed.o ac3enc_float.o ac3tab.o ac3.o kbdwin.o
OBJS-$(CONFIG_AC3_FLOAT_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_FLOAT_ENCODER) += ac3enc_float.o ac3tab.o ac3tab.o ac3.o kbdwin.o
OBJS-$(CONFIG_AC3_FIXED_ENCODER) += ac3enc_fixed.o ac3tab.o ac3tab.o ac3.o
OBJS-$(CONFIG_ALAC_DECODER) += alac.o OBJS-$(CONFIG_ALAC_DECODER) += alac.o
OBJS-$(CONFIG_ALAC_ENCODER) += alacenc.o OBJS-$(CONFIG_ALAC_ENCODER) += alacenc.o
OBJS-$(CONFIG_ALS_DECODER) += alsdec.o bgmc.o mpeg4audio.o OBJS-$(CONFIG_ALS_DECODER) += alsdec.o bgmc.o mpeg4audio.o
@@ -128,8 +128,8 @@ OBJS-$(CONFIG_DVVIDEO_DECODER) += dv.o dvdata.o
OBJS-$(CONFIG_DVVIDEO_ENCODER) += dv.o dvdata.o OBJS-$(CONFIG_DVVIDEO_ENCODER) += dv.o dvdata.o
OBJS-$(CONFIG_DXA_DECODER) += dxa.o OBJS-$(CONFIG_DXA_DECODER) += dxa.o
OBJS-$(CONFIG_EAC3_DECODER) += eac3dec.o eac3dec_data.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_EACMV_DECODER) += eacmv.o
OBJS-$(CONFIG_EAMAD_DECODER) += eamad.o eaidct.o mpeg12.o \ OBJS-$(CONFIG_EAMAD_DECODER) += eamad.o eaidct.o mpeg12.o \
mpeg12data.o mpegvideo.o \ mpeg12data.o mpegvideo.o \


+ 1
- 1
libavcodec/ac3dec.h View File

@@ -196,7 +196,7 @@ typedef struct {
///@} ///@}


///@defgroup arrays aligned arrays ///@defgroup arrays aligned arrays
DECLARE_ALIGNED(16, int, fixed_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; ///> fixed-point transform coefficients
DECLARE_ALIGNED(16, int, fixed_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; ///< fixed-point transform coefficients
DECLARE_ALIGNED(32, float, transform_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; ///< transform coefficients DECLARE_ALIGNED(32, float, transform_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; ///< transform coefficients
DECLARE_ALIGNED(32, float, delay)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]; ///< delay - added to the next block DECLARE_ALIGNED(32, float, delay)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]; ///< delay - added to the next block
DECLARE_ALIGNED(32, float, window)[AC3_BLOCK_SIZE]; ///< window coefficients DECLARE_ALIGNED(32, float, window)[AC3_BLOCK_SIZE]; ///< window coefficients


+ 48
- 408
libavcodec/ac3enc.c View File

@@ -42,7 +42,6 @@
#include "ac3.h" #include "ac3.h"
#include "audioconvert.h" #include "audioconvert.h"
#include "fft.h" #include "fft.h"

#include "ac3enc.h" #include "ac3enc.h"
#include "eac3enc.h" #include "eac3enc.h"


@@ -68,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. * LUT for number of exponent groups.
* exponent_group_tab[coupling][exponent strategy-1][number of coefficients] * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
@@ -118,8 +77,7 @@ static uint8_t exponent_group_tab[2][3][256];
/** /**
* List of supported channel layouts. * List of supported channel layouts.
*/ */
#if CONFIG_AC3ENC_FLOAT || !CONFIG_AC3_FLOAT_ENCODER //we need this exactly once compiled in
const int64_t ff_ac3_channel_layouts[] = {
const int64_t ff_ac3_channel_layouts[19] = {
AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO,
AV_CH_LAYOUT_2_1, AV_CH_LAYOUT_2_1,
@@ -140,7 +98,6 @@ const int64_t ff_ac3_channel_layouts[] = {
AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_5POINT1_BACK,
0 0
}; };
#endif




/** /**
@@ -233,60 +190,6 @@ static void adjust_frame_size(AC3EncodeContext *s)
} }




/**
* Deinterleave input samples.
* Channels are reordered from FFmpeg'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) static void compute_coupling_strategy(AC3EncodeContext *s)
{ {
int blk, ch; int blk, ch;
@@ -348,296 +251,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. * Apply stereo rematrixing to coefficients based on rematrixing flags.
*/ */
@@ -1470,7 +1083,7 @@ static int compute_bit_allocation(AC3EncodeContext *s)
if (s->cpl_on) { if (s->cpl_on) {
s->cpl_on = 0; s->cpl_on = 0;
compute_coupling_strategy(s); compute_coupling_strategy(s);
compute_rematrixing_strategy(s);
s->compute_rematrixing_strategy(s);
apply_rematrixing(s); apply_rematrixing(s);
process_exponents(s); process_exponents(s);
ret = compute_bit_allocation(s); ret = compute_bit_allocation(s);
@@ -1990,10 +1603,7 @@ static void output_frame(AC3EncodeContext *s, unsigned char *frame)


init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE); init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);


if (CONFIG_EAC3_ENCODER && s->eac3)
ff_eac3_output_frame_header(s);
else
ac3_output_frame_header(s);
s->output_frame_header(s);


for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
output_audio_block(s, blk); output_audio_block(s, blk);
@@ -2268,8 +1878,8 @@ static int validate_metadata(AVCodecContext *avctx)
/** /**
* Encode a single AC-3 frame. * 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; AC3EncodeContext *s = avctx->priv_data;
const SampleType *samples = data; const SampleType *samples = data;
@@ -2284,19 +1894,19 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
if (s->bit_alloc.sr_code == 1 || s->eac3) if (s->bit_alloc.sr_code == 1 || s->eac3)
adjust_frame_size(s); 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; s->cpl_on = s->cpl_enabled;
compute_coupling_strategy(s); compute_coupling_strategy(s);


if (s->cpl_on) 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); apply_rematrixing(s);


@@ -2319,11 +1929,12 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
/** /**
* Finalize encoding and free any memory allocated by the encoder. * 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; int blk, ch;
AC3EncodeContext *s = avctx->priv_data; AC3EncodeContext *s = avctx->priv_data;


av_freep(&s->windowed_samples);
for (ch = 0; ch < s->channels; ch++) for (ch = 0; ch < s->channels; ch++)
av_freep(&s->planar_samples[ch]); av_freep(&s->planar_samples[ch]);
av_freep(&s->planar_samples); av_freep(&s->planar_samples);
@@ -2349,7 +1960,8 @@ static av_cold int ac3_encode_close(AVCodecContext *avctx)
av_freep(&block->qmant); av_freep(&block->qmant);
} }


mdct_end(&s->mdct);
s->mdct_end(s->mdct);
av_freep(&s->mdct);


av_freep(&avctx->coded_frame); av_freep(&avctx->coded_frame);
return 0; return 0;
@@ -2519,8 +2131,7 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
(s->channel_mode == AC3_CHMODE_STEREO); (s->channel_mode == AC3_CHMODE_STEREO);


s->cpl_enabled = s->options.channel_coupling && 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; return 0;
} }
@@ -2604,6 +2215,8 @@ static av_cold int allocate_buffers(AVCodecContext *avctx)
AC3EncodeContext *s = avctx->priv_data; AC3EncodeContext *s = avctx->priv_data;
int channels = s->channels + 1; /* includes coupling channel */ int channels = s->channels + 1; /* includes coupling channel */


FF_ALLOC_OR_GOTO(avctx, s->windowed_samples, AC3_WINDOW_SIZE *
sizeof(*s->windowed_samples), alloc_fail);
FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples), FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples),
alloc_fail); alloc_fail);
for (ch = 0; ch < s->channels; ch++) { for (ch = 0; ch < s->channels; ch++) {
@@ -2676,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 * FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * channels *
AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail); AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail);
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
@@ -2705,7 +2318,7 @@ alloc_fail:
/** /**
* Initialize the encoder. * 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; AC3EncodeContext *s = avctx->priv_data;
int ret, frame_size_58; int ret, frame_size_58;
@@ -2735,13 +2348,40 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)
s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY); s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
} }


/* 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->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
s->output_frame_header = ac3_output_frame_header;

set_bandwidth(s); set_bandwidth(s);


exponent_init(s); exponent_init(s);


bit_alloc_init(s); bit_alloc_init(s);


ret = mdct_init(avctx, &s->mdct, 9);
FF_ALLOCZ_OR_GOTO(avctx, s->mdct, sizeof(AC3MDCTContext), init_fail);
ret = s->mdct_init(avctx, s->mdct, 9);
if (ret) if (ret)
goto init_fail; goto init_fail;


@@ -2758,6 +2398,6 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)


return 0; return 0;
init_fail: init_fail:
ac3_encode_close(avctx);
ff_ac3_encode_close(avctx);
return ret; return ret;
} }

+ 81
- 2
libavcodec/ac3enc.h View File

@@ -40,18 +40,28 @@
#define CONFIG_AC3ENC_FLOAT 0 #define CONFIG_AC3ENC_FLOAT 0
#endif #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 #if CONFIG_AC3ENC_FLOAT
#define AC3_NAME(x) ff_ac3_float_ ## x
#define MAC_COEF(d,a,b) ((d)+=(a)*(b)) #define MAC_COEF(d,a,b) ((d)+=(a)*(b))
typedef float SampleType; typedef float SampleType;
typedef float CoefType; typedef float CoefType;
typedef float CoefSumType; typedef float CoefSumType;
#else #else
#define AC3_NAME(x) ff_ac3_fixed_ ## x
#define MAC_COEF(d,a,b) MAC64(d,a,b) #define MAC_COEF(d,a,b) MAC64(d,a,b)
typedef int16_t SampleType; typedef int16_t SampleType;
typedef int32_t CoefType; typedef int32_t CoefType;
typedef int64_t CoefSumType; typedef int64_t CoefSumType;
#endif #endif



typedef struct AC3MDCTContext { typedef struct AC3MDCTContext {
const SampleType *window; ///< MDCT window function const SampleType *window; ///< MDCT window function
FFTContext fft; ///< FFT context for MDCT calculation FFTContext fft; ///< FFT context for MDCT calculation
@@ -128,10 +138,11 @@ typedef struct AC3EncodeContext {
PutBitContext pb; ///< bitstream writer context PutBitContext pb; ///< bitstream writer context
DSPContext dsp; DSPContext dsp;
AC3DSPContext ac3dsp; ///< AC-3 optimized functions AC3DSPContext ac3dsp; ///< AC-3 optimized functions
AC3MDCTContext mdct; ///< MDCT context
AC3MDCTContext *mdct; ///< MDCT context


AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info 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 eac3; ///< indicates if this is E-AC-3 vs. AC-3
int bitstream_id; ///< bitstream id (bsid) int bitstream_id; ///< bitstream id (bsid)
int bitstream_mode; ///< bitstream mode (bsmod) int bitstream_mode; ///< bitstream mode (bsmod)
@@ -189,6 +200,7 @@ typedef struct AC3EncodeContext {
int frame_bits; ///< all frame bits except exponents and mantissas int frame_bits; ///< all frame bits except exponents and mantissas
int exponent_bits; ///< number of bits used for exponents int exponent_bits; ///< number of bits used for exponents


SampleType *windowed_samples;
SampleType **planar_samples; SampleType **planar_samples;
uint8_t *bap_buffer; uint8_t *bap_buffer;
uint8_t *bap1_buffer; uint8_t *bap1_buffer;
@@ -208,7 +220,74 @@ typedef struct AC3EncodeContext {
uint8_t *ref_bap [AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< bit allocation pointers (bap) 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 int ref_bap_set; ///< indicates if ref_bap pointers have been set


DECLARE_ALIGNED(32, SampleType, windowed_samples)[AC3_WINDOW_SIZE];
/* 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; } 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);

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 */ #endif /* AVCODEC_AC3ENC_H */

+ 27
- 11
libavcodec/ac3enc_fixed.c View File

@@ -28,13 +28,20 @@


#define CONFIG_FFT_FLOAT 0 #define CONFIG_FFT_FLOAT 0
#undef CONFIG_AC3ENC_FLOAT #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. * 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); ff_mdct_end(&mdct->fft);
} }
@@ -44,8 +51,8 @@ static av_cold void mdct_end(AC3MDCTContext *mdct)
* Initialize MDCT tables. * Initialize MDCT tables.
* @param nbits log2(MDCT size) * @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); int ret = ff_mdct_init(&mdct->fft, nbits, 0, -1.0);
mdct->window = ff_ac3_window; 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. * 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); 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 * @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); int v = 14 - log2_tab(s, s->windowed_samples, AC3_WINDOW_SIZE);
if (v > 0) if (v > 0)
@@ -95,7 +103,7 @@ static int normalize_samples(AC3EncodeContext *s)
/** /**
* Scale MDCT coefficients to 25-bit signed fixed-point. * 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; int blk, ch;


@@ -109,14 +117,22 @@ 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 = { AVCodec ff_ac3_fixed_encoder = {
"ac3_fixed", "ac3_fixed",
AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3, CODEC_ID_AC3,
sizeof(AC3EncodeContext), sizeof(AC3EncodeContext),
ac3_encode_init,
ac3_encode_frame,
ac3_encode_close,
ac3_fixed_encode_init,
ff_ac3_encode_frame,
ff_ac3_encode_close,
NULL, NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),


+ 22
- 36
libavcodec/ac3enc_float.c View File

@@ -27,14 +27,25 @@
*/ */


#define CONFIG_AC3ENC_FLOAT 1 #define CONFIG_AC3ENC_FLOAT 1
#include "ac3enc.c"
#include "ac3enc.h"
#include "eac3enc.h"
#include "kbdwin.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. * 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); ff_mdct_end(&mdct->fft);
av_freep(&mdct->window); av_freep(&mdct->window);
@@ -45,8 +56,8 @@ static av_cold void mdct_end(AC3MDCTContext *mdct)
* Initialize MDCT tables. * Initialize MDCT tables.
* @param nbits log2(MDCT size) * @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; float *window;
int i, n, n2; int i, n, n2;
@@ -71,27 +82,18 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
/** /**
* Apply KBD window to input samples prior to 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); dsp->vector_fmul(output, input, window, len);
} }




/**
* Normalize the input samples to use the maximum available precision.
*/
static int normalize_samples(AC3EncodeContext *s)
{
/* Normalization is not needed for floating-point samples, so just return 0 */
return 0;
}


/** /**
* Scale MDCT coefficients from float to 24-bit fixed-point. * 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; int chan_size = AC3_MAX_COEFS * AC3_MAX_BLOCKS;
s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer + chan_size, s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer + chan_size,
@@ -106,9 +108,9 @@ AVCodec ff_ac3_float_encoder = {
AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3, CODEC_ID_AC3,
sizeof(AC3EncodeContext), sizeof(AC3EncodeContext),
ac3_encode_init,
ac3_encode_frame,
ac3_encode_close,
ff_ac3_encode_init,
ff_ac3_encode_frame,
ff_ac3_encode_close,
NULL, NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
@@ -116,19 +118,3 @@ AVCodec ff_ac3_float_encoder = {
.channel_layouts = ff_ac3_channel_layouts, .channel_layouts = ff_ac3_channel_layouts,
}; };
#endif #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 = ff_ac3_channel_layouts,
};
#endif

+ 3
- 0
libavcodec/ac3enc_opts_template.c View File

@@ -19,6 +19,9 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * 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 #if AC3ENC_TYPE == AC3ENC_TYPE_AC3_FIXED
static const AVOption ac3fixed_options[] = { static const AVOption ac3fixed_options[] = {
#elif AC3ENC_TYPE == AC3ENC_TYPE_AC3 #elif AC3ENC_TYPE == AC3ENC_TYPE_AC3


+ 377
- 0
libavcodec/ac3enc_template.c View File

@@ -0,0 +1,377 @@
/*
* AC-3 encoder float/fixed template
* Copyright (c) 2000 Fabrice Bellard
* Copyright (c) 2006-2011 Justin Ruggles <justin.ruggles@gmail.com>
* Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
*
* 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 <stdint.h>

#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;
}
}

+ 3
- 0
libavcodec/arm/Makefile View File

@@ -5,6 +5,9 @@ OBJS-$(CONFIG_DCA_DECODER) += arm/dcadsp_init_arm.o \


ARMV6-OBJS-$(CONFIG_AC3DSP) += arm/ac3dsp_armv6.o ARMV6-OBJS-$(CONFIG_AC3DSP) += arm/ac3dsp_armv6.o


OBJS-$(CONFIG_MPEGAUDIODSP) += arm/mpegaudiodsp_init_arm.o
ARMV6-OBJS-$(CONFIG_MPEGAUDIODSP) += arm/mpegaudiodsp_fixed_armv6.o

OBJS-$(CONFIG_VP5_DECODER) += arm/vp56dsp_init_arm.o OBJS-$(CONFIG_VP5_DECODER) += arm/vp56dsp_init_arm.o
OBJS-$(CONFIG_VP6_DECODER) += arm/vp56dsp_init_arm.o OBJS-$(CONFIG_VP6_DECODER) += arm/vp56dsp_init_arm.o
OBJS-$(CONFIG_VP8_DECODER) += arm/vp8dsp_init_arm.o OBJS-$(CONFIG_VP8_DECODER) += arm/vp8dsp_init_arm.o


+ 13
- 18
libavcodec/arm/jrevdct_arm.S View File

@@ -54,18 +54,13 @@
#define FIX_M_1_961570560_ID 40 #define FIX_M_1_961570560_ID 40
#define FIX_M_2_562915447_ID 44 #define FIX_M_2_562915447_ID 44
#define FIX_0xFFFF_ID 48 #define FIX_0xFFFF_ID 48
.text
.align


function ff_j_rev_dct_arm, export=1 function ff_j_rev_dct_arm, export=1
stmdb sp!, { r4 - r12, lr } @ all callee saved regs

sub sp, sp, #4 @ reserve some space on the stack
str r0, [ sp ] @ save the DCT pointer to the stack
push {r0, r4 - r11, lr}


mov lr, r0 @ lr = pointer to the current row mov lr, r0 @ lr = pointer to the current row
mov r12, #8 @ r12 = row-counter mov r12, #8 @ r12 = row-counter
adr r11, const_array @ r11 = base pointer to the constants array
movrel r11, const_array @ r11 = base pointer to the constants array
row_loop: row_loop:
ldrsh r0, [lr, # 0] @ r0 = 'd0' ldrsh r0, [lr, # 0] @ r0 = 'd0'
ldrsh r2, [lr, # 2] @ r2 = 'd2' ldrsh r2, [lr, # 2] @ r2 = 'd2'
@@ -102,7 +97,7 @@ row_loop:
add r4, r6, r3, lsl #13 @ r4 = tmp11 add r4, r6, r3, lsl #13 @ r4 = tmp11
rsb r3, r6, r3, lsl #13 @ r3 = tmp12 rsb r3, r6, r3, lsl #13 @ r3 = tmp12


stmdb sp!, { r0, r2, r3, r4 } @ save on the stack tmp10, tmp13, tmp12, tmp11
push {r0, r2, r3, r4} @ save on the stack tmp10, tmp13, tmp12, tmp11


ldrsh r3, [lr, #10] @ r3 = 'd3' ldrsh r3, [lr, #10] @ r3 = 'd3'
ldrsh r5, [lr, #12] @ r5 = 'd5' ldrsh r5, [lr, #12] @ r5 = 'd5'
@@ -136,8 +131,8 @@ row_loop:
add r3, r3, r4 @ r3 = tmp2 add r3, r3, r4 @ r3 = tmp2
add r1, r1, r6 @ r1 = tmp3 add r1, r1, r6 @ r1 = tmp3


ldmia sp!, { r0, r2, r4, r6 } @ r0 = tmp10 / r2 = tmp13 / r4 = tmp12 / r6 = tmp11
@ r1 = tmp3 / r3 = tmp2 / r5 = tmp1 / r7 = tmp0
pop {r0, r2, r4, r6} @ r0 = tmp10 / r2 = tmp13 / r4 = tmp12 / r6 = tmp11
@ r1 = tmp3 / r3 = tmp2 / r5 = tmp1 / r7 = tmp0


@ Compute DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS) @ Compute DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS)
add r8, r0, r1 add r8, r0, r1
@@ -211,7 +206,7 @@ end_of_row_loop:


start_column_loop: start_column_loop:
@ Start of column loop @ Start of column loop
ldr lr, [ sp ]
pop {lr}
mov r12, #8 mov r12, #8
column_loop: column_loop:
ldrsh r0, [lr, #( 0*8)] @ r0 = 'd0' ldrsh r0, [lr, #( 0*8)] @ r0 = 'd0'
@@ -245,7 +240,7 @@ column_loop:
orrs r10, r9, r10 orrs r10, r9, r10
beq empty_odd_column beq empty_odd_column


stmdb sp!, { r0, r2, r4, r6 } @ save on the stack tmp10, tmp13, tmp12, tmp11
push {r0, r2, r4, r6} @ save on the stack tmp10, tmp13, tmp12, tmp11


add r0, r3, r5 @ r0 = 'z2' add r0, r3, r5 @ r0 = 'z2'
add r2, r1, r7 @ r2 = 'z1' add r2, r1, r7 @ r2 = 'z1'
@@ -275,8 +270,8 @@ column_loop:
add r3, r3, r4 @ r3 = tmp2 add r3, r3, r4 @ r3 = tmp2
add r1, r1, r6 @ r1 = tmp3 add r1, r1, r6 @ r1 = tmp3


ldmia sp!, { r0, r2, r4, r6 } @ r0 = tmp10 / r2 = tmp13 / r4 = tmp11 / r6 = tmp12
@ r1 = tmp3 / r3 = tmp2 / r5 = tmp1 / r7 = tmp0
pop {r0, r2, r4, r6} @ r0 = tmp10 / r2 = tmp13 / r4 = tmp11 / r6 = tmp12
@ r1 = tmp3 / r3 = tmp2 / r5 = tmp1 / r7 = tmp0


@ Compute DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3) @ Compute DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3)
add r8, r0, r1 add r8, r0, r1
@@ -368,11 +363,10 @@ empty_odd_column:


the_end: the_end:
@ The end.... @ The end....
add sp, sp, #4
ldmia sp!, { r4 - r12, pc } @ restore callee saved regs and return
pop {r4 - r11, pc}
endfunc


const_array:
.align
const const_array
.word FIX_0_298631336 .word FIX_0_298631336
.word FIX_0_541196100 .word FIX_0_541196100
.word FIX_0_765366865 .word FIX_0_765366865
@@ -386,3 +380,4 @@ const_array:
.word FIX_M_1_961570560 .word FIX_M_1_961570560
.word FIX_M_2_562915447 .word FIX_M_2_562915447
.word FIX_0xFFFF .word FIX_0xFFFF
endconst

+ 143
- 0
libavcodec/arm/mpegaudiodsp_fixed_armv6.S View File

@@ -0,0 +1,143 @@
/*
* Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
*
* 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
*/

#include "asm.S"

.macro skip args:vararg
.endm

.macro sum8 lo, hi, w, p, t1, t2, t3, t4, rsb=skip, offs=0
ldr \t1, [\w, #4*\offs]
ldr \t2, [\p, #4]!
\rsb \t1, \t1, #0
.irpc i, 135
ldr \t3, [\w, #4*64*\i+4*\offs]
ldr \t4, [\p, #4*64*\i]
smlal \lo, \hi, \t1, \t2
\rsb \t3, \t3, #0
ldr \t1, [\w, #4*64*(\i+1)+4*\offs]
ldr \t2, [\p, #4*64*(\i+1)]
smlal \lo, \hi, \t3, \t4
\rsb \t1, \t1, #0
.endr
ldr \t3, [\w, #4*64*7+4*\offs]
ldr \t4, [\p, #4*64*7]
smlal \lo, \hi, \t1, \t2
\rsb \t3, \t3, #0
smlal \lo, \hi, \t3, \t4
.endm

.macro round rd, lo, hi
lsr \rd, \lo, #24
bic \lo, \lo, #0xff000000
orr \rd, \rd, \hi, lsl #8
mov \hi, #0
ssat \rd, #16, \rd
.endm

function ff_mpadsp_apply_window_fixed_armv6, export=1
push {r2,r4-r11,lr}

add r4, r0, #4*512 @ synth_buf + 512
.rept 4
ldm r0!, {r5-r12}
stm r4!, {r5-r12}
.endr

ldr r4, [sp, #40] @ incr
sub r0, r0, #4*17 @ synth_buf + 16
ldr r8, [r2] @ sum:low
add r2, r0, #4*32 @ synth_buf + 48
rsb r5, r4, r4, lsl #5 @ 31 * incr
lsl r4, r4, #1
asr r9, r8, #31 @ sum:high
add r5, r3, r5, lsl #1 @ samples2
add r6, r1, #4*32 @ w2
str r4, [sp, #40]

sum8 r8, r9, r1, r0, r10, r11, r12, lr
sum8 r8, r9, r1, r2, r10, r11, r12, lr, rsb, 32
round r10, r8, r9
strh r10, [r3], r4

mov lr, #15
1:
ldr r12, [r0, #4]!
ldr r11, [r6, #-4]!
ldr r10, [r1, #4]!
.irpc i, 0246
.if \i
ldr r11, [r6, #4*64*\i]
ldr r10, [r1, #4*64*\i]
.endif
rsb r11, r11, #0
smlal r8, r9, r10, r12
ldr r10, [r0, #4*64*(\i+1)]
.ifeq \i
smull r4, r7, r11, r12
.else
smlal r4, r7, r11, r12
.endif
ldr r11, [r6, #4*64*(\i+1)]
ldr r12, [r1, #4*64*(\i+1)]
rsb r11, r11, #0
smlal r8, r9, r12, r10
.iflt \i-6
ldr r12, [r0, #4*64*(\i+2)]
.else
ldr r12, [r2, #-4]!
.endif
smlal r4, r7, r11, r10
.endr
.irpc i, 0246
ldr r10, [r1, #4*64*\i+4*32]
rsb r12, r12, #0
ldr r11, [r6, #4*64*\i+4*32]
smlal r8, r9, r10, r12
ldr r10, [r2, #4*64*(\i+1)]
smlal r4, r7, r11, r12
ldr r12, [r1, #4*64*(\i+1)+4*32]
rsb r10, r10, #0
ldr r11, [r6, #4*64*(\i+1)+4*32]
smlal r8, r9, r12, r10
.iflt \i-6
ldr r12, [r2, #4*64*(\i+2)]
.else
ldr r12, [sp, #40]
.endif
smlal r4, r7, r11, r10
.endr
round r10, r8, r9
adds r8, r8, r4
adc r9, r9, r7
strh r10, [r3], r12
round r11, r8, r9
subs lr, lr, #1
strh r11, [r5], -r12
bgt 1b

sum8 r8, r9, r1, r0, r10, r11, r12, lr, rsb, 33
pop {r4}
round r10, r8, r9
str r8, [r4]
strh r10, [r3]

pop {r4-r11,pc}
endfunc

+ 33
- 0
libavcodec/arm/mpegaudiodsp_init_arm.c View File

@@ -0,0 +1,33 @@
/*
* Copyright (c) 2011 Mans Rullgard
*
* 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
*/

#include <stdint.h>
#include "libavcodec/mpegaudiodsp.h"
#include "config.h"

void ff_mpadsp_apply_window_fixed_armv6(int32_t *synth_buf, int32_t *window,
int *dither, int16_t *out, int incr);

void ff_mpadsp_init_arm(MPADSPContext *s)
{
if (HAVE_ARMV6) {
s->apply_window_fixed = ff_mpadsp_apply_window_fixed_armv6;
}
}

+ 24
- 0
libavcodec/eac3enc.c View File

@@ -28,6 +28,13 @@
#include "ac3enc.h" #include "ac3enc.h"
#include "eac3enc.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) void ff_eac3_set_cpl_states(AC3EncodeContext *s)
{ {
int ch, blk; int ch, blk;
@@ -129,3 +136,20 @@ void ff_eac3_output_frame_header(AC3EncodeContext *s)
/* block start info */ /* block start info */
put_bits(&s->pb, 1, 0); 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

+ 11
- 11
libavcodec/h264.c View File

@@ -995,7 +995,7 @@ int ff_h264_decode_extradata(H264Context *h)
cnt = *(p++); // Number of pps cnt = *(p++); // Number of pps
for (i = 0; i < cnt; i++) { for (i = 0; i < cnt; i++) {
nalsize = AV_RB16(p) + 2; nalsize = AV_RB16(p) + 2;
if(decode_nal_units(h, p, nalsize) < 0) {
if (decode_nal_units(h, p, nalsize) < 0) {
av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
return -1; return -1;
} }
@@ -2351,8 +2351,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
MPV_common_end(s); MPV_common_end(s);
} }
if (!s->context_initialized) { if (!s->context_initialized) {
if(h != h0){
av_log(h->s.avctx, AV_LOG_ERROR, "we cant (re-)initialize context during parallel decoding\n");
if (h != h0) {
av_log(h->s.avctx, AV_LOG_ERROR, "Cannot (re-)initialize context during parallel decoding.\n");
return -1; return -1;
} }


@@ -2398,8 +2398,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){


s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt); s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);


if (MPV_common_init(s) < 0){
av_log(h->s.avctx, AV_LOG_ERROR, "MPV_common_init() failed\n");
if (MPV_common_init(s) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "MPV_common_init() failed.\n");
return -1; return -1;
} }
s->first_field = 0; s->first_field = 0;
@@ -2409,8 +2409,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
ff_h264_alloc_tables(h); ff_h264_alloc_tables(h);


if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) { if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {
if (context_init(h) < 0){
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed\n");
if (context_init(h) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1; return -1;
} }
} else { } else {
@@ -2428,8 +2428,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
} }


for(i = 0; i < s->avctx->thread_count; i++) for(i = 0; i < s->avctx->thread_count; i++)
if(context_init(h->thread_context[i]) < 0){
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed\n");
if (context_init(h->thread_context[i]) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1; return -1;
} }
} }
@@ -2737,8 +2737,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){
av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n"); av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
h0->single_decode_warning = 1; h0->single_decode_warning = 1;
} }
if(h != h0){
av_log(h->s.avctx, AV_LOG_ERROR, "deblocking switched inside frame\n");
if (h != h0) {
av_log(h->s.avctx, AV_LOG_ERROR, "Deblocking switched inside frame.\n");
return 1; return 1;
} }
} }


+ 1
- 0
libavcodec/mpegaudiodsp.c View File

@@ -35,6 +35,7 @@ void ff_mpadsp_init(MPADSPContext *s)
s->dct32_float = dct.dct32; s->dct32_float = dct.dct32;
s->dct32_fixed = ff_dct32_fixed; s->dct32_fixed = ff_dct32_fixed;


if (ARCH_ARM) ff_mpadsp_init_arm(s);
if (HAVE_MMX) ff_mpadsp_init_mmx(s); if (HAVE_MMX) ff_mpadsp_init_mmx(s);
if (HAVE_ALTIVEC) ff_mpadsp_init_altivec(s); if (HAVE_ALTIVEC) ff_mpadsp_init_altivec(s);
} }

+ 1
- 0
libavcodec/mpegaudiodsp.h View File

@@ -47,6 +47,7 @@ void ff_mpa_synth_filter_float(MPADSPContext *s,
float *samples, int incr, float *samples, int incr,
float *sb_samples); float *sb_samples);


void ff_mpadsp_init_arm(MPADSPContext *s);
void ff_mpadsp_init_mmx(MPADSPContext *s); void ff_mpadsp_init_mmx(MPADSPContext *s);
void ff_mpadsp_init_altivec(MPADSPContext *s); void ff_mpadsp_init_altivec(MPADSPContext *s);




+ 0
- 2
libavformat/utils.c View File

@@ -1605,14 +1605,12 @@ int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, i


pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max; pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max; ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
#if 1
pos_min = pos; pos_min = pos;
ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX); ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
pos_min++; pos_min++;
ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX); ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n", av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
pos, ts_min, target_ts, ts_max); pos, ts_min, target_ts, ts_max);
#endif
*ts_ret= ts; *ts_ret= ts;
return pos; return pos;
} }


Write Preview
Loading…
Cancel
Save