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 branch 'qatar/master' 

* qatar/master:
  ALPHA: Replace sized int_fast integer types with plain int/unsigned.
Duplicate  DPX image encoder
Duplicate  DPX decoder: read sample aspect ratio
Duplciate  DPX decoder: add buffer size checks.
  ac3enc: clip large coefficient values and negative exponents rather than using av_assert2().
  ac3enc: do not store a bandwidth code for each channel.
  ac3enc: remove bandwidth reduction as fallback for bit allocation failure.
  ac3enc: merge compute_exp_strategy_ch() into compute_exp_strategy()
  ac3enc: return error if frame+exponent bits are too large instead of using av_assert2().
  ac3enc: differentiate between current block and reference block in bit_alloc()
  ac3enc: simplify exponent_init() by calculating exponent_group_tab[] based on exponent group sizes.
  ac3enc: simplify stereo rematrixing decision options
Include both URLs:  Update URL to fate samples

Conflicts:
	Changelog
	doc/fate.txt
	libavcodec/ac3enc.c
	libavcodec/dpxenc.c
	libavcodec/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n0.8
Michael Niedermayer 14 years ago
parent
3862ebba23 ad1862d64a
commit
c3f5b81125
7 changed files with 100 additions and 140 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +12
    -0
      doc/encoders.texi
  2. +1
    -0
      doc/fate.txt
  3. +1
    -0
      libavcodec/ac3.h
  4. +3
    -1
      libavcodec/ac3dsp.c
  5. +71
    -127
      libavcodec/ac3enc.c
  6. +3
    -3
      libavcodec/alpha/simple_idct_alpha.c
  7. +9
    -9
      libavcodec/dpxenc.c

+ 12
- 0
doc/encoders.texi View File

@@ -353,4 +353,16 @@ HDCD A/D Converter

@end table

@subheading Other AC-3 Encoding Options

@table @option

@item -stereo_rematrixing @var{boolean}
Stereo Rematrixing. Enables/Disables use of rematrixing for stereo input. This
is an optional AC-3 feature that increases quality by selectively encoding
the left/right channels as mid/side. This option is enabled by default, and it
is highly recommended that it be left as enabled except for testing purposes.

@end table

@c man end ENCODERS

+ 1
- 0
doc/fate.txt View File

@@ -8,6 +8,7 @@ that is provided separately from the actual source distribution.
Use the following command to get the fate test samples

# rsync -aL rsync://rsync.mplayerhq.hu:/samples/fate-suite/ fate/fate-suite
# rsync -aL rsync://fate-suite.libav.org:/fate-suite/ fate-suite

To inform the build system about the testsuite location, pass
`--samples=<path to the samples>` to configure or set the SAMPLES Make


+ 1
- 0
libavcodec/ac3.h View File

@@ -158,6 +158,7 @@ typedef struct AC3EncOptions {

/* other encoding options */
int allow_per_frame_metadata;
int stereo_rematrixing;
} AC3EncOptions;




+ 3
- 1
libavcodec/ac3dsp.c View File

@@ -164,8 +164,10 @@ static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
if (e >= 24) {
e = 24;
coef[i] = 0;
} else if (e < 0) {
e = 0;
coef[i] = av_clip(coef[i], -16777215, 16777215);
}
av_assert2(e >= 0);
}
exp[i] = e;
}


+ 71
- 127
libavcodec/ac3enc.c View File

@@ -52,12 +52,6 @@
/** Maximum number of exponent groups. +1 for separate DC exponent. */
#define AC3_MAX_EXP_GROUPS 85

/* stereo rematrixing algorithms */
#define AC3_REMATRIXING_IS_STATIC 0x1
#define AC3_REMATRIXING_SUMS 0
#define AC3_REMATRIXING_NONE 1
#define AC3_REMATRIXING_ALWAYS 3

#if CONFIG_AC3ENC_FLOAT
#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
typedef float SampleType;
@@ -137,10 +131,10 @@ typedef struct AC3EncodeContext {
int loro_surround_mix_level; ///< Lo/Ro surround mix level code

int cutoff; ///< user-specified cutoff frequency, in Hz
int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod)
int bandwidth_code; ///< bandwidth code (0 to 60) (chbwcod)
int nb_coefs[AC3_MAX_CHANNELS];

int rematrixing; ///< determines how rematrixing strategy is calculated
int rematrixing_enabled; ///< stereo rematrixing enabled
int num_rematrixing_bands; ///< number of rematrixing bands

/* bitrate allocation control */
@@ -240,6 +234,8 @@ const AVOption ff_ac3_options[] = {
{"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), FF_OPT_TYPE_INT, {.dbl = -1 }, -1, 1, AC3ENC_PARAM, "ad_conv_type"},
{"standard", "Standard (default)", 0, FF_OPT_TYPE_CONST, {.dbl = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
{"hdcd", "HDCD", 0, FF_OPT_TYPE_CONST, {.dbl = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
/* Other Encoding Options */
{"stereo_rematrixing", "Stereo Rematrixing", OFFSET(stereo_rematrixing), FF_OPT_TYPE_INT, {.dbl = 1 }, 0, 1, AC3ENC_PARAM},
{NULL}
};
#endif
@@ -404,28 +400,6 @@ static void apply_mdct(AC3EncodeContext *s)
}


/**
* Initialize stereo rematrixing.
* If the strategy does not change for each frame, set the rematrixing flags.
*/
static void rematrixing_init(AC3EncodeContext *s)
{
if (s->channel_mode == AC3_CHMODE_STEREO)
s->rematrixing = AC3_REMATRIXING_SUMS;
else
s->rematrixing = AC3_REMATRIXING_NONE;
/* NOTE: AC3_REMATRIXING_ALWAYS might be used in
the future in conjunction with channel coupling. */

if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) {
int flag = (s->rematrixing == AC3_REMATRIXING_ALWAYS);
s->blocks[0].new_rematrixing_strategy = 1;
memset(s->blocks[0].rematrixing_flags, flag,
sizeof(s->blocks[0].rematrixing_flags));
}
}


/**
* Determine rematrixing flags for each block and band.
*/
@@ -435,16 +409,18 @@ static void compute_rematrixing_strategy(AC3EncodeContext *s)
int blk, bnd, i;
AC3Block *block, *block0;

s->num_rematrixing_bands = 4;

if (s->rematrixing & AC3_REMATRIXING_IS_STATIC)
if (s->channel_mode != AC3_CHMODE_STEREO)
return;

s->num_rematrixing_bands = 4;

nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);

for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
block = &s->blocks[blk];
block->new_rematrixing_strategy = !blk;
if (!s->rematrixing_enabled)
continue;
for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
/* calculate calculate sum of squared coeffs for one band in one block */
int start = ff_ac3_rematrix_band_tab[bnd];
@@ -488,7 +464,7 @@ static void apply_rematrixing(AC3EncodeContext *s)
int start, end;
uint8_t *flags;

if (s->rematrixing == AC3_REMATRIXING_NONE)
if (!s->rematrixing_enabled)
return;

nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
@@ -518,11 +494,13 @@ static void apply_rematrixing(AC3EncodeContext *s)
*/
static av_cold void exponent_init(AC3EncodeContext *s)
{
int i;
for (i = 73; i < 256; i++) {
exponent_group_tab[0][i] = (i - 1) / 3;
exponent_group_tab[1][i] = (i + 2) / 6;
exponent_group_tab[2][i] = (i + 8) / 12;
int expstr, i, grpsize;

for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
grpsize = 3 << expstr;
for (i = 73; i < 256; i++) {
exponent_group_tab[expstr][i] = (i + grpsize - 4) / grpsize;
}
}
/* LFE */
exponent_group_tab[0][7] = 2;
@@ -555,56 +533,47 @@ static void extract_exponents(AC3EncodeContext *s)
#define EXP_DIFF_THRESHOLD 500


/**
* Calculate exponent strategies for all blocks in a single channel.
*/
static void compute_exp_strategy_ch(AC3EncodeContext *s, uint8_t *exp_strategy,
uint8_t *exp)
{
int blk, blk1;
int exp_diff;

/* estimate if the exponent variation & decide if they should be
reused in the next frame */
exp_strategy[0] = EXP_NEW;
exp += AC3_MAX_COEFS;
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
if (exp_diff > EXP_DIFF_THRESHOLD)
exp_strategy[blk] = EXP_NEW;
else
exp_strategy[blk] = EXP_REUSE;
exp += AC3_MAX_COEFS;
}

/* now select the encoding strategy type : if exponents are often
recoded, we use a coarse encoding */
blk = 0;
while (blk < AC3_MAX_BLOCKS) {
blk1 = blk + 1;
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
blk1++;
switch (blk1 - blk) {
case 1: exp_strategy[blk] = EXP_D45; break;
case 2:
case 3: exp_strategy[blk] = EXP_D25; break;
default: exp_strategy[blk] = EXP_D15; break;
}
blk = blk1;
}
}


/**
* Calculate exponent strategies for all channels.
* Array arrangement is reversed to simplify the per-channel calculation.
*/
static void compute_exp_strategy(AC3EncodeContext *s)
{
int ch, blk;
int ch, blk, blk1;

for (ch = 0; ch < s->fbw_channels; ch++) {
compute_exp_strategy_ch(s, s->exp_strategy[ch], s->blocks[0].exp[ch]);
uint8_t *exp_strategy = s->exp_strategy[ch];
uint8_t *exp = s->blocks[0].exp[ch];
int exp_diff;

/* estimate if the exponent variation & decide if they should be
reused in the next frame */
exp_strategy[0] = EXP_NEW;
exp += AC3_MAX_COEFS;
for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
if (exp_diff > EXP_DIFF_THRESHOLD)
exp_strategy[blk] = EXP_NEW;
else
exp_strategy[blk] = EXP_REUSE;
exp += AC3_MAX_COEFS;
}

/* now select the encoding strategy type : if exponents are often
recoded, we use a coarse encoding */
blk = 0;
while (blk < AC3_MAX_BLOCKS) {
blk1 = blk + 1;
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
blk1++;
switch (blk1 - blk) {
case 1: exp_strategy[blk] = EXP_D45; break;
case 2:
case 3: exp_strategy[blk] = EXP_D25; break;
default: exp_strategy[blk] = EXP_D15; break;
}
blk = blk1;
}
}
if (s->lfe_on) {
ch = s->lfe_channel;
@@ -1005,7 +974,8 @@ static int bit_alloc(AC3EncodeContext *s, int snr_offset)
reset_block_bap(s);
mantissa_bits = 0;
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
AC3Block *block;
AC3Block *block = &s->blocks[blk];
AC3Block *ref_block;
// initialize grouped mantissa counts. these are set so that they are
// padded to the next whole group size when bits are counted in
// compute_mantissa_size_final
@@ -1017,14 +987,17 @@ static int bit_alloc(AC3EncodeContext *s, int snr_offset)
blocks within a frame are the exponent values. We can take
advantage of that by reusing the bit allocation pointers
whenever we reuse exponents. */
block = s->blocks[blk].exp_ref_block[ch];
ref_block = block->exp_ref_block[ch];
if (s->exp_strategy[ch][blk] != EXP_REUSE) {
s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 0,
s->nb_coefs[ch], snr_offset,
s->bit_alloc.floor, ff_ac3_bap_tab,
block->bap[ch]);
s->ac3dsp.bit_alloc_calc_bap(ref_block->mask[ch],
ref_block->psd[ch], 0,
s->nb_coefs[ch], snr_offset,
s->bit_alloc.floor, ff_ac3_bap_tab,
ref_block->bap[ch]);
}
mantissa_bits += s->ac3dsp.compute_mantissa_size(mant_cnt, block->bap[ch], s->nb_coefs[ch]);
mantissa_bits += s->ac3dsp.compute_mantissa_size(mant_cnt,
ref_block->bap[ch],
s->nb_coefs[ch]);
}
mantissa_bits += compute_mantissa_size_final(mant_cnt);
}
@@ -1043,7 +1016,8 @@ static int cbr_bit_allocation(AC3EncodeContext *s)
int snr_offset, snr_incr;

bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
av_assert2(bits_left >= 0);
if (bits_left < 0)
return AVERROR(EINVAL);

snr_offset = s->coarse_snr_offset << 4;

@@ -1121,27 +1095,6 @@ static int downgrade_exponents(AC3EncodeContext *s)
}


/**
* Reduce the bandwidth to reduce the number of bits used for a given SNR offset.
* This is a second fallback for when bit allocation still fails after exponents
* have been downgraded.
* @return non-zero if bandwidth reduction was unsuccessful
*/
static int reduce_bandwidth(AC3EncodeContext *s, int min_bw_code)
{
int ch;

if (s->bandwidth_code[0] > min_bw_code) {
for (ch = 0; ch < s->fbw_channels; ch++) {
s->bandwidth_code[ch]--;
s->nb_coefs[ch] = s->bandwidth_code[ch] * 3 + 73;
}
return 0;
}
return -1;
}


/**
* Perform bit allocation search.
* Finds the SNR offset value that maximizes quality and fits in the specified
@@ -1167,15 +1120,6 @@ static int compute_bit_allocation(AC3EncodeContext *s)
continue;
}

/* fallback 2: reduce bandwidth */
/* only do this if the user has not specified a specific cutoff
frequency */
if (!s->cutoff && !reduce_bandwidth(s, 0)) {
process_exponents(s);
ret = compute_bit_allocation(s);
continue;
}

/* fallbacks were not enough... */
break;
}
@@ -1436,7 +1380,7 @@ static void output_audio_block(AC3EncodeContext *s, int blk)
/* bandwidth */
for (ch = 0; ch < s->fbw_channels; ch++) {
if (s->exp_strategy[ch][blk] != EXP_REUSE)
put_bits(&s->pb, 6, s->bandwidth_code[ch]);
put_bits(&s->pb, 6, s->bandwidth_code);
}

/* exponents */
@@ -2062,6 +2006,9 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
if (ret)
return ret;

s->rematrixing_enabled = s->options.stereo_rematrixing &&
(s->channel_mode == AC3_CHMODE_STEREO);

return 0;
}

@@ -2073,22 +2020,21 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
*/
static av_cold void set_bandwidth(AC3EncodeContext *s)
{
int ch, bw_code;
int ch;

if (s->cutoff) {
/* calculate bandwidth based on user-specified cutoff frequency */
int fbw_coeffs;
fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
} else {
/* use default bandwidth setting */
bw_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
}

/* set number of coefficients for each channel */
for (ch = 0; ch < s->fbw_channels; ch++) {
s->bandwidth_code[ch] = bw_code;
s->nb_coefs[ch] = bw_code * 3 + 73;
s->nb_coefs[ch] = s->bandwidth_code * 3 + 73;
}
if (s->lfe_on)
s->nb_coefs[s->lfe_channel] = 7; /* LFE channel always has 7 coefs */
@@ -2220,8 +2166,6 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)

set_bandwidth(s);

rematrixing_init(s);

exponent_init(s);

bit_alloc_init(s);


+ 3
- 3
libavcodec/alpha/simple_idct_alpha.c View File

@@ -46,7 +46,7 @@
/* 0: all entries 0, 1: only first entry nonzero, 2: otherwise */
static inline int idct_row(DCTELEM *row)
{
int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3, t;
int a0, a1, a2, a3, b0, b1, b2, b3, t;
uint64_t l, r, t2;
l = ldq(row);
r = ldq(row + 4);
@@ -154,7 +154,7 @@ static inline int idct_row(DCTELEM *row)

static inline void idct_col(DCTELEM *col)
{
int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
int a0, a1, a2, a3, b0, b1, b2, b3;

col[0] += (1 << (COL_SHIFT - 1)) / W4;

@@ -235,7 +235,7 @@ static inline void idct_col2(DCTELEM *col)
uint64_t l, r;

for (i = 0; i < 8; ++i) {
int_fast32_t a0 = col[i] + (1 << (COL_SHIFT - 1)) / W4;
int a0 = col[i] + (1 << (COL_SHIFT - 1)) / W4;

a0 *= W4;
col[i] = a0 >> COL_SHIFT;


+ 9
- 9
libavcodec/dpxenc.c View File

@@ -136,7 +136,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
switch(s->bits_per_component) {
case 8:
case 16:
size = avpicture_layout((AVPicture*)data, avctx->pix_fmt,
size = avpicture_layout(data, avctx->pix_fmt,
avctx->width, avctx->height,
buf + HEADER_SIZE, buf_size - HEADER_SIZE);
if (size < 0)
@@ -146,7 +146,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
size = avctx->height * avctx->width * 4;
if (buf_size < HEADER_SIZE + size)
return -1;
encode_rgb48_10bit(avctx, (AVPicture*)data, buf + HEADER_SIZE);
encode_rgb48_10bit(avctx, data, buf + HEADER_SIZE);
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n", s->bits_per_component);
@@ -160,13 +160,13 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
}

AVCodec ff_dpx_encoder = {
"dpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DPX,
sizeof(DPXContext),
encode_init,
encode_frame,
.pix_fmts= (const enum PixelFormat[]){
.name = "dpx",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DPX,
.priv_data_size = sizeof(DPXContext),
.init = encode_init,
.encode = encode_frame,
.pix_fmts = (const enum PixelFormat[]){
PIX_FMT_RGB24,
PIX_FMT_RGBA,
PIX_FMT_RGB48LE,


Write Preview
Loading…
Cancel
Save