virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

cosmetics: use better (and shared) macro names for some constant values

Browse Source 
Originally committed as revision 25950 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Justin Ruggles 2010-12-14 14:50:34 +00:00
parent a657899cf7
commit 7066cc8f2b
3 changed files with 77 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libavcodec/ac3.h
View File

@ -32,8 +32,10 @@
#define AC3_MAX_CODED_FRAME_SIZE 3840 /* in bytes */
#define AC3_MAX_CHANNELS 6 /* including LFE channel */
#define NB_BLOCKS 6 /* number of PCM blocks inside an AC-3 frame */
#define AC3_FRAME_SIZE (NB_BLOCKS * 256)
#define AC3_MAX_COEFS 256
#define AC3_BLOCK_SIZE 256
#define AC3_MAX_BLOCKS 6
#define AC3_FRAME_SIZE (AC3_MAX_BLOCKS * 256)
/* exponent encoding strategy */
#define EXP_REUSE 0

11
libavcodec/ac3dec.h
View File

@ -63,9 +63,6 @@
#define AC3_OUTPUT_LFEON 8
#define AC3_MAX_COEFS 256
#define AC3_BLOCK_SIZE 256
#define MAX_BLOCKS 6
#define SPX_MAX_BANDS 17
typedef struct {
@ -101,8 +98,8 @@ typedef struct {
///@}
///@defgroup cpl standard coupling
int cpl_in_use[MAX_BLOCKS]; ///< coupling in use (cplinu)
int cpl_strategy_exists[MAX_BLOCKS]; ///< coupling strategy exists (cplstre)
int cpl_in_use[AC3_MAX_BLOCKS]; ///< coupling in use (cplinu)
int cpl_strategy_exists[AC3_MAX_BLOCKS];///< coupling strategy exists (cplstre)
int channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling (chincpl)
int phase_flags_in_use; ///< phase flags in use (phsflginu)
int phase_flags[18]; ///< phase flags (phsflg)
@ -131,7 +128,7 @@ typedef struct {
///@defgroup aht adaptive hybrid transform
int channel_uses_aht[AC3_MAX_CHANNELS]; ///< channel AHT in use (chahtinu)
int pre_mantissa[AC3_MAX_CHANNELS][AC3_MAX_COEFS][MAX_BLOCKS]; ///< pre-IDCT mantissas
int pre_mantissa[AC3_MAX_CHANNELS][AC3_MAX_COEFS][AC3_MAX_BLOCKS]; ///< pre-IDCT mantissas
///@}
///@defgroup channel channel
@ -161,7 +158,7 @@ typedef struct {
///@defgroup exponents exponents
int num_exp_groups[AC3_MAX_CHANNELS]; ///< Number of exponent groups (nexpgrp)
int8_t dexps[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; ///< decoded exponents
int exp_strategy[MAX_BLOCKS][AC3_MAX_CHANNELS]; ///< exponent strategies (expstr)
int exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS]; ///< exponent strategies (expstr)
///@}
///@defgroup bitalloc bit allocation

138
libavcodec/ac3enc.c
View File

@ -68,7 +68,7 @@ typedef struct AC3EncodeContext {
/* mantissa encoding */
int mant1_cnt, mant2_cnt, mant4_cnt;
int16_t last_samples[AC3_MAX_CHANNELS][256];
int16_t last_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];
} AC3EncodeContext;
static int16_t costab[64];
@ -77,7 +77,7 @@ static int16_t xcos1[128];
static int16_t xsin1[128];
#define MDCT_NBITS 9
#define N (1 << MDCT_NBITS)
#define MDCT_SAMPLES (1 << MDCT_NBITS)
/* new exponents are sent if their Norm 1 exceed this number */
#define EXP_DIFF_THRESHOLD 1000
@ -205,31 +205,31 @@ static void fft(IComplex *z, int ln)
static void mdct512(int32_t *out, int16_t *in)
{
int i, re, im, re1, im1;
int16_t rot[N];
IComplex x[N/4];
int16_t rot[MDCT_SAMPLES];
IComplex x[MDCT_SAMPLES/4];
/* shift to simplify computations */
for(i=0;i<N/4;i++)
rot[i] = -in[i + 3*N/4];
for(i=N/4;i<N;i++)
rot[i] = in[i - N/4];
for(i=0;i<MDCT_SAMPLES/4;i++)
rot[i] = -in[i + 3*MDCT_SAMPLES/4];
for(i=MDCT_SAMPLES/4;i<MDCT_SAMPLES;i++)
rot[i] = in[i - MDCT_SAMPLES/4];
/* pre rotation */
for(i=0;i<N/4;i++) {
re = ((int)rot[2*i] - (int)rot[N-1-2*i]) >> 1;
im = -((int)rot[N/2+2*i] - (int)rot[N/2-1-2*i]) >> 1;
for(i=0;i<MDCT_SAMPLES/4;i++) {
re = ((int)rot[2*i] - (int)rot[MDCT_SAMPLES-1-2*i]) >> 1;
im = -((int)rot[MDCT_SAMPLES/2+2*i] - (int)rot[MDCT_SAMPLES/2-1-2*i]) >> 1;
CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]);
}
fft(x, MDCT_NBITS - 2);
/* post rotation */
for(i=0;i<N/4;i++) {
for(i=0;i<MDCT_SAMPLES/4;i++) {
re = x[i].re;
im = x[i].im;
CMUL(re1, im1, re, im, xsin1[i], xcos1[i]);
out[2*i] = im1;
out[N/2-1-2*i] = re1;
out[MDCT_SAMPLES/2-1-2*i] = re1;
}
}
@ -244,8 +244,8 @@ static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n)
return sum;
}
static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
static void compute_exp_strategy(uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int ch, int is_lfe)
{
int i, j;
@ -254,8 +254,8 @@ static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNEL
/* estimate if the exponent variation & decide if they should be
reused in the next frame */
exp_strategy[0][ch] = EXP_NEW;
for(i=1;i<NB_BLOCKS;i++) {
exp_diff = calc_exp_diff(exp[i][ch], exp[i-1][ch], N/2);
for(i=1;i<AC3_MAX_BLOCKS;i++) {
exp_diff = calc_exp_diff(exp[i][ch], exp[i-1][ch], AC3_MAX_COEFS);
dprintf(NULL, "exp_diff=%d\n", exp_diff);
if (exp_diff > EXP_DIFF_THRESHOLD)
exp_strategy[i][ch] = EXP_NEW;
@ -268,9 +268,9 @@ static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNEL
/* now select the encoding strategy type : if exponents are often
recoded, we use a coarse encoding */
i = 0;
while (i < NB_BLOCKS) {
while (i < AC3_MAX_BLOCKS) {
j = i + 1;
while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE)
while (j < AC3_MAX_BLOCKS && exp_strategy[j][ch] == EXP_REUSE)
j++;
switch(j - i) {
case 1:
@ -289,7 +289,7 @@ static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNEL
}
/* set exp[i] to min(exp[i], exp1[i]) */
static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n)
static void exponent_min(uint8_t exp[AC3_MAX_COEFS], uint8_t exp1[AC3_MAX_COEFS], int n)
{
int i;
@ -301,13 +301,13 @@ static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n)
/* update the exponents so that they are the ones the decoder will
decode. Return the number of bits used to code the exponents */
static int encode_exp(uint8_t encoded_exp[N/2],
uint8_t exp[N/2],
static int encode_exp(uint8_t encoded_exp[AC3_MAX_COEFS],
uint8_t exp[AC3_MAX_COEFS],
int nb_exps,
int exp_strategy)
{
int group_size, nb_groups, i, j, k, exp_min;
uint8_t exp1[N/2];
uint8_t exp1[AC3_MAX_COEFS];
switch(exp_strategy) {
case EXP_D15:
@ -421,18 +421,18 @@ static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs)
static void bit_alloc_masking(AC3EncodeContext *s,
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50])
uint8_t encoded_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
int16_t psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int16_t mask[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][50])
{
int blk, ch;
int16_t band_psd[NB_BLOCKS][AC3_MAX_CHANNELS][50];
int16_t band_psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][50];
for(blk=0; blk<NB_BLOCKS; blk++) {
for(blk=0; blk<AC3_MAX_BLOCKS; blk++) {
for(ch=0;ch<s->channels;ch++) {
if(exp_strategy[blk][ch] == EXP_REUSE) {
memcpy(psd[blk][ch], psd[blk-1][ch], (N/2)*sizeof(int16_t));
memcpy(psd[blk][ch], psd[blk-1][ch], AC3_MAX_COEFS*sizeof(int16_t));
memcpy(mask[blk][ch], mask[blk-1][ch], 50*sizeof(int16_t));
} else {
ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0,
@ -450,9 +450,9 @@ static void bit_alloc_masking(AC3EncodeContext *s,
}
static int bit_alloc(AC3EncodeContext *s,
int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50],
int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
int16_t mask[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][50],
int16_t psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int frame_bits, int coarse_snr_offset, int fine_snr_offset)
{
int i, ch;
@ -461,7 +461,7 @@ static int bit_alloc(AC3EncodeContext *s,
snr_offset = (((coarse_snr_offset - 15) << 4) + fine_snr_offset) << 2;
/* compute size */
for(i=0;i<NB_BLOCKS;i++) {
for(i=0;i<AC3_MAX_BLOCKS;i++) {
s->mant1_cnt = 0;
s->mant2_cnt = 0;
s->mant4_cnt = 0;
@ -485,16 +485,16 @@ static int bit_alloc(AC3EncodeContext *s,
#define SNR_INC1 4
static int compute_bit_allocation(AC3EncodeContext *s,
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t encoded_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
int frame_bits)
{
int i, ch;
int coarse_snr_offset, fine_snr_offset;
uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50];
uint8_t bap1[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int16_t psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int16_t mask[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][50];
static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
/* init default parameters */
@ -520,7 +520,7 @@ static int compute_bit_allocation(AC3EncodeContext *s,
frame_bits += frame_bits_inc[s->channel_mode];
/* audio blocks */
for(i=0;i<NB_BLOCKS;i++) {
for(i=0;i<AC3_MAX_BLOCKS;i++) {
frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
if (s->channel_mode == AC3_CHMODE_STEREO) {
frame_bits++; /* rematstr */
@ -711,7 +711,7 @@ static av_cold int AC3_encode_init(AVCodecContext *avctx)
if(avctx->cutoff) {
/* calculate bandwidth based on user-specified cutoff frequency */
int cutoff = av_clip(avctx->cutoff, 1, s->sample_rate >> 1);
int fbw_coeffs = cutoff * 512 / s->sample_rate;
int fbw_coeffs = cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
} else {
/* use default bandwidth setting */
@ -732,8 +732,8 @@ static av_cold int AC3_encode_init(AVCodecContext *avctx)
/* mdct init */
fft_init(MDCT_NBITS - 2);
for(i=0;i<N/4;i++) {
alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N;
for(i=0;i<MDCT_SAMPLES/4;i++) {
alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)MDCT_SAMPLES;
xcos1[i] = fix15(-cos(alpha));
xsin1[i] = fix15(-sin(alpha));
}
@ -811,19 +811,19 @@ static inline int asym_quant(int c, int e, int qbits)
return v & ((1 << qbits)-1);
}
/* Output one audio block. There are NB_BLOCKS audio blocks in one AC-3
/* Output one audio block. There are AC3_MAX_BLOCKS audio blocks in one AC-3
frame */
static void output_audio_block(AC3EncodeContext *s,
uint8_t exp_strategy[AC3_MAX_CHANNELS],
uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2],
uint8_t bap[AC3_MAX_CHANNELS][N/2],
int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2],
uint8_t encoded_exp[AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int32_t mdct_coefs[AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int8_t global_exp[AC3_MAX_CHANNELS],
int block_num)
{
int ch, nb_groups, group_size, i, baie, rbnd;
uint8_t *p;
uint16_t qmant[AC3_MAX_CHANNELS][N/2];
uint16_t qmant[AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int exp0, exp1;
int mant1_cnt, mant2_cnt, mant4_cnt;
uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr;
@ -1187,56 +1187,56 @@ static int AC3_encode_frame(AVCodecContext *avctx,
AC3EncodeContext *s = avctx->priv_data;
const int16_t *samples = data;
int i, j, k, v, ch;
int16_t input_samples[N];
int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS];
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS];
int16_t input_samples[AC3_BLOCK_SIZE*2];
int32_t mdct_coef[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
uint8_t exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
uint8_t encoded_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int8_t exp_samples[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
int frame_bits;
frame_bits = 0;
for(ch=0;ch<s->channels;ch++) {
int ich = s->channel_map[ch];
/* fixed mdct to the six sub blocks & exponent computation */
for(i=0;i<NB_BLOCKS;i++) {
for(i=0;i<AC3_MAX_BLOCKS;i++) {
const int16_t *sptr;
int sinc;
/* compute input samples */
memcpy(input_samples, s->last_samples[ich], N/2 * sizeof(int16_t));
memcpy(input_samples, s->last_samples[ich], AC3_BLOCK_SIZE * sizeof(int16_t));
sinc = s->channels;
sptr = samples + (sinc * (N/2) * i) + ich;
for(j=0;j<N/2;j++) {
sptr = samples + (sinc * AC3_BLOCK_SIZE * i) + ich;
for(j=0;j<AC3_BLOCK_SIZE;j++) {
v = *sptr;
input_samples[j + N/2] = v;
input_samples[j + AC3_BLOCK_SIZE] = v;
s->last_samples[ich][j] = v;
sptr += sinc;
}
/* apply the MDCT window */
for(j=0;j<N/2;j++) {
for(j=0;j<AC3_BLOCK_SIZE;j++) {
input_samples[j] = MUL16(input_samples[j],
ff_ac3_window[j]) >> 15;
input_samples[N-j-1] = MUL16(input_samples[N-j-1],
input_samples[AC3_BLOCK_SIZE*2-j-1] = MUL16(input_samples[AC3_BLOCK_SIZE*2-j-1],
ff_ac3_window[j]) >> 15;
}
/* Normalize the samples to use the maximum available
precision */
v = 14 - log2_tab(input_samples, N);
v = 14 - log2_tab(input_samples, AC3_BLOCK_SIZE*2);
if (v < 0)
v = 0;
exp_samples[i][ch] = v - 9;
lshift_tab(input_samples, N, v);
lshift_tab(input_samples, AC3_BLOCK_SIZE*2, v);
/* do the MDCT */
mdct512(mdct_coef[i][ch], input_samples);
/* compute "exponents". We take into account the
normalization there */
for(j=0;j<N/2;j++) {
for(j=0;j<AC3_MAX_COEFS;j++) {
int e;
v = abs(mdct_coef[i][ch][j]);
if (v == 0)
@ -1258,9 +1258,9 @@ static int AC3_encode_frame(AVCodecContext *avctx,
EXP_REUSE case must be handled carefully : we select the
min of the exponents */
i = 0;
while (i < NB_BLOCKS) {
while (i < AC3_MAX_BLOCKS) {
j = i + 1;
while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) {
while (j < AC3_MAX_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) {
exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]);
j++;
}
@ -1289,7 +1289,7 @@ static int AC3_encode_frame(AVCodecContext *avctx,
/* everything is known... let's output the frame */
output_frame_header(s, frame);
for(i=0;i<NB_BLOCKS;i++) {
for(i=0;i<AC3_MAX_BLOCKS;i++) {
output_audio_block(s, exp_strategy[i], encoded_exp[i],
bap[i], mdct_coef[i], exp_samples[i], i);
}