Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move large arrays to AC3EncodeContext rather than passing them around.

Browse Source 
Originally committed as revision 26012 to svn://svn.ffmpeg.org/ffmpeg/trunk
oldabi
Justin Ruggles 14 years ago
parent 7da4dc17d9
commit 266d24be4a
1 changed files with 106 additions and 158 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 264
      libavcodec/ac3enc.c

264
libavcodec/ac3enc.c
Unescape View File

@ -101,6 +101,21 @@ typedef struct AC3EncodeContext {
uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
int16_t last_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]; ///< last 256 samples from previous frame
int16_t planar_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE+AC3_FRAME_SIZE];
int16_t windowed_samples[AC3_WINDOW_SIZE];
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 num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
uint8_t grouped_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS];
int16_t psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int16_t band_psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS];
int16_t mask[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS];
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
uint8_t bap1[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int8_t exp_shift[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
uint16_t qmant[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
} AC3EncodeContext;
@ -132,8 +147,7 @@ static void adjust_frame_size(AC3EncodeContext *s)
* Channels are reordered from FFmpeg's default order to AC-3 order.
*/
static void deinterleave_input_samples(AC3EncodeContext *s,
const int16_t *samples,
int16_t planar_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE+AC3_FRAME_SIZE])
const int16_t *samples)
{
int ch, i;
@ -143,20 +157,20 @@ static void deinterleave_input_samples(AC3EncodeContext *s,
int sinc;
/* copy last 256 samples of previous frame to the start of the current frame */
memcpy(&planar_samples[ch][0], s->last_samples[ch],
AC3_BLOCK_SIZE * sizeof(planar_samples[0][0]));
memcpy(&s->planar_samples[ch][0], s->last_samples[ch],
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++) {
planar_samples[ch][i] = *sptr;
s->planar_samples[ch][i] = *sptr;
sptr += sinc;
}
/* save last 256 samples for next frame */
memcpy(s->last_samples[ch], &planar_samples[ch][6* AC3_BLOCK_SIZE],
AC3_BLOCK_SIZE * sizeof(planar_samples[0][0]));
memcpy(s->last_samples[ch], &s->planar_samples[ch][6* AC3_BLOCK_SIZE],
AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
}
}
@ -396,12 +410,11 @@ static void lshift_tab(int16_t *tab, int n, int lshift)
*
* @return exponent shift
*/
static int normalize_samples(AC3EncodeContext *s,
int16_t windowed_samples[AC3_WINDOW_SIZE])
static int normalize_samples(AC3EncodeContext *s)
{
int v = 14 - log2_tab(windowed_samples, AC3_WINDOW_SIZE);
int v = 14 - log2_tab(s->windowed_samples, AC3_WINDOW_SIZE);
v = FFMAX(0, v);
lshift_tab(windowed_samples, AC3_WINDOW_SIZE, v);
lshift_tab(s->windowed_samples, AC3_WINDOW_SIZE, v);
return v - 9;
}
@ -411,23 +424,19 @@ static int normalize_samples(AC3EncodeContext *s,
* This applies the KBD window and normalizes the input to reduce precision
* loss due to fixed-point calculations.
*/
static void apply_mdct(AC3EncodeContext *s,
int16_t planar_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE+AC3_FRAME_SIZE],
int8_t exp_shift[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
int32_t mdct_coef[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
static void apply_mdct(AC3EncodeContext *s)
{
int blk, ch;
int16_t windowed_samples[AC3_WINDOW_SIZE];
for (ch = 0; ch < s->channels; ch++) {
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
const int16_t *input_samples = &planar_samples[ch][blk * AC3_BLOCK_SIZE];
const int16_t *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
apply_window(windowed_samples, input_samples, ff_ac3_window, AC3_WINDOW_SIZE);
apply_window(s->windowed_samples, input_samples, ff_ac3_window, AC3_WINDOW_SIZE);
exp_shift[blk][ch] = normalize_samples(s, windowed_samples);
s->exp_shift[blk][ch] = normalize_samples(s);
mdct512(mdct_coef[blk][ch], windowed_samples);
mdct512(s->mdct_coef[blk][ch], s->windowed_samples);
}
}
}
@ -438,10 +447,7 @@ static void apply_mdct(AC3EncodeContext *s,
* This takes into account the normalization that was done to the input samples
* by adjusting the exponents by the exponent shift values.
*/
static void extract_exponents(AC3EncodeContext *s,
int32_t mdct_coef[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int8_t exp_shift[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
static void extract_exponents(AC3EncodeContext *s)
{
int blk, ch, i;
@ -451,17 +457,17 @@ static void extract_exponents(AC3EncodeContext *s,
/* compute "exponents". We take into account the normalization there */
for (i = 0; i < AC3_MAX_COEFS; i++) {
int e;
int v = abs(mdct_coef[blk][ch][i]);
int v = abs(s->mdct_coef[blk][ch][i]);
if (v == 0)
e = 24;
else {
e = 23 - av_log2(v) + exp_shift[blk][ch];
e = 23 - av_log2(v) + s->exp_shift[blk][ch];
if (e >= 24) {
e = 24;
mdct_coef[blk][ch][i] = 0;
s->mdct_coef[blk][ch][i] = 0;
}
}
exp[blk][ch][i] = e;
s->exp[blk][ch][i] = e;
}
}
}
@ -529,9 +535,7 @@ static void compute_exp_strategy_ch(uint8_t *exp_strategy, uint8_t **exp)
* Calculate exponent strategies for all channels.
* Array arrangement is reversed to simplify the per-channel calculation.
*/
static void compute_exp_strategy(AC3EncodeContext *s,
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
static void compute_exp_strategy(AC3EncodeContext *s)
{
uint8_t *exp1[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS];
uint8_t exp_str1[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS];
@ -539,20 +543,20 @@ static void compute_exp_strategy(AC3EncodeContext *s,
for (ch = 0; ch < s->fbw_channels; ch++) {
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
exp1[ch][blk] = exp[blk][ch];
exp_str1[ch][blk] = exp_strategy[blk][ch];
exp1[ch][blk] = s->exp[blk][ch];
exp_str1[ch][blk] = s->exp_strategy[blk][ch];
}
compute_exp_strategy_ch(exp_str1[ch], exp1[ch]);
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
exp_strategy[blk][ch] = exp_str1[ch][blk];
s->exp_strategy[blk][ch] = exp_str1[ch][blk];
}
if (s->lfe_on) {
ch = s->lfe_channel;
exp_strategy[0][ch] = EXP_D15;
s->exp_strategy[0][ch] = EXP_D15;
for (blk = 1; blk < 5; blk++)
exp_strategy[blk][ch] = EXP_REUSE;
s->exp_strategy[blk][ch] = EXP_REUSE;
}
}
@ -629,11 +633,7 @@ static void encode_exponents_blk_ch(uint8_t encoded_exp[AC3_MAX_COEFS],
* deltas between adjacent exponent groups so that they can be differentially
* encoded.
*/
static void encode_exponents(AC3EncodeContext *s,
uint8_t exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t encoded_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
static void encode_exponents(AC3EncodeContext *s)
{
int blk, blk1, blk2, ch;
@ -642,17 +642,17 @@ static void encode_exponents(AC3EncodeContext *s,
blk = 0;
while (blk < AC3_MAX_BLOCKS) {
blk1 = blk + 1;
while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1][ch] == EXP_REUSE) {
exponent_min(exp[blk][ch], exp[blk1][ch], s->nb_coefs[ch]);
while (blk1 < AC3_MAX_BLOCKS && s->exp_strategy[blk1][ch] == EXP_REUSE) {
exponent_min(s->exp[blk][ch], s->exp[blk1][ch], s->nb_coefs[ch]);
blk1++;
}
encode_exponents_blk_ch(encoded_exp[blk][ch],
exp[blk][ch], s->nb_coefs[ch],
exp_strategy[blk][ch],
&num_exp_groups[blk][ch]);
encode_exponents_blk_ch(s->encoded_exp[blk][ch],
s->exp[blk][ch], s->nb_coefs[ch],
s->exp_strategy[blk][ch],
&s->num_exp_groups[blk][ch]);
/* copy encoded exponents for reuse case */
for (blk2 = blk+1; blk2 < blk1; blk2++) {
memcpy(encoded_exp[blk2][ch], encoded_exp[blk][ch],
memcpy(s->encoded_exp[blk2][ch], s->encoded_exp[blk][ch],
s->nb_coefs[ch] * sizeof(uint8_t));
}
blk = blk1;
@ -666,11 +666,7 @@ static void encode_exponents(AC3EncodeContext *s,
* 3 delta-encoded exponents are in each 7-bit group. The number of groups
* varies depending on exponent strategy and bandwidth.
*/
static void group_exponents(AC3EncodeContext *s,
uint8_t encoded_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t grouped_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS])
static void group_exponents(AC3EncodeContext *s)
{
int blk, ch, i;
int group_size, bit_count;
@ -681,20 +677,20 @@ static void group_exponents(AC3EncodeContext *s,
bit_count = 0;
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
for (ch = 0; ch < s->channels; ch++) {
if (exp_strategy[blk][ch] == EXP_REUSE) {
num_exp_groups[blk][ch] = 0;
if (s->exp_strategy[blk][ch] == EXP_REUSE) {
s->num_exp_groups[blk][ch] = 0;
continue;
}
group_size = exp_strategy[blk][ch] + (exp_strategy[blk][ch] == EXP_D45);
bit_count += 4 + (num_exp_groups[blk][ch] * 7);
p = encoded_exp[blk][ch];
group_size = s->exp_strategy[blk][ch] + (s->exp_strategy[blk][ch] == EXP_D45);
bit_count += 4 + (s->num_exp_groups[blk][ch] * 7);
p = s->encoded_exp[blk][ch];
/* DC exponent */
exp1 = *p++;
grouped_exp[blk][ch][0] = exp1;
s->grouped_exp[blk][ch][0] = exp1;
/* remaining exponents are delta encoded */
for (i = 1; i <= num_exp_groups[blk][ch]; i++) {
for (i = 1; i <= s->num_exp_groups[blk][ch]; i++) {
/* merge three delta in one code */
exp0 = exp1;
exp1 = p[0];
@ -711,7 +707,7 @@ static void group_exponents(AC3EncodeContext *s,
p += group_size;
delta2 = exp1 - exp0 + 2;
grouped_exp[blk][ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
s->grouped_exp[blk][ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
}
}
}
@ -725,22 +721,15 @@ static void group_exponents(AC3EncodeContext *s,
* Extract exponents from MDCT coefficients, calculate exponent strategies,
* and encode final exponents.
*/
static void process_exponents(AC3EncodeContext *s,
int32_t mdct_coef[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int8_t exp_shift[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
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 num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t grouped_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS])
static void process_exponents(AC3EncodeContext *s)
{
extract_exponents(s, mdct_coef, exp_shift, exp);
extract_exponents(s);
compute_exp_strategy(s, exp_strategy, exp);
compute_exp_strategy(s);
encode_exponents(s, exp, exp_strategy, num_exp_groups, encoded_exp);
encode_exponents(s);
group_exponents(s, encoded_exp, exp_strategy, num_exp_groups, grouped_exp);
group_exponents(s);
}
@ -778,8 +767,7 @@ static void bit_alloc_init(AC3EncodeContext *s)
/**
* Count the bits used to encode the frame, minus exponents and mantissas.
*/
static void count_frame_bits(AC3EncodeContext *s,
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS])
static void count_frame_bits(AC3EncodeContext *s)
{
static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
int blk, ch;
@ -801,7 +789,7 @@ static void count_frame_bits(AC3EncodeContext *s,
if (s->lfe_on)
frame_bits++; /* lfeexpstr */
for (ch = 0; ch < s->fbw_channels; ch++) {
if (exp_strategy[blk][ch] != EXP_REUSE)
if (s->exp_strategy[blk][ch] != EXP_REUSE)
frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */
}
frame_bits++; /* baie */
@ -882,30 +870,25 @@ static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs)
* Calculate masking curve based on the final exponents.
* Also calculate the power spectral densities to use in future calculations.
*/
static void bit_alloc_masking(AC3EncodeContext *s,
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][AC3_CRITICAL_BANDS])
static void bit_alloc_masking(AC3EncodeContext *s)
{
int blk, ch;
int16_t band_psd[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS];
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], AC3_MAX_COEFS*sizeof(psd[0][0][0]));
memcpy(mask[blk][ch], mask[blk-1][ch], AC3_CRITICAL_BANDS*sizeof(mask[0][0][0]));
if (s->exp_strategy[blk][ch] == EXP_REUSE) {
memcpy(s->psd[blk][ch], s->psd[blk-1][ch], AC3_MAX_COEFS*sizeof(s->psd[0][0][0]));
memcpy(s->mask[blk][ch], s->mask[blk-1][ch], AC3_CRITICAL_BANDS*sizeof(s->mask[0][0][0]));
} else {
ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0,
ff_ac3_bit_alloc_calc_psd(s->encoded_exp[blk][ch], 0,
s->nb_coefs[ch],
psd[blk][ch], band_psd[blk][ch]);
ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, band_psd[blk][ch],
s->psd[blk][ch], s->band_psd[blk][ch]);
ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, s->band_psd[blk][ch],
0, s->nb_coefs[ch],
ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
ch == s->lfe_channel,
DBA_NONE, 0, NULL, NULL, NULL,
mask[blk][ch]);
s->mask[blk][ch]);
}
}
}
@ -920,8 +903,6 @@ static void bit_alloc_masking(AC3EncodeContext *s,
* is used.
*/
static int bit_alloc(AC3EncodeContext *s,
int16_t mask[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS],
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 snr_offset)
{
@ -936,7 +917,7 @@ static int bit_alloc(AC3EncodeContext *s,
s->mant2_cnt = 0;
s->mant4_cnt = 0;
for (ch = 0; ch < s->channels; ch++) {
ff_ac3_bit_alloc_calc_bap(mask[blk][ch], psd[blk][ch], 0,
ff_ac3_bit_alloc_calc_bap(s->mask[blk][ch], s->psd[blk][ch], 0,
s->nb_coefs[ch], snr_offset,
s->bit_alloc.floor, ff_ac3_bap_tab,
bap[blk][ch]);
@ -953,23 +934,17 @@ static int bit_alloc(AC3EncodeContext *s,
* frame size. Output is the SNR offset and a set of bit allocation pointers
* used to quantize the mantissas.
*/
static int compute_bit_allocation(AC3EncodeContext *s,
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])
static int compute_bit_allocation(AC3EncodeContext *s)
{
int ch;
int bits_left;
int snr_offset;
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][AC3_CRITICAL_BANDS];
/* count frame bits other than exponents and mantissas */
count_frame_bits(s, exp_strategy);
count_frame_bits(s);
/* calculate psd and masking curve before doing bit allocation */
bit_alloc_masking(s, encoded_exp, exp_strategy, psd, mask);
bit_alloc_masking(s);
/* now the big work begins : do the bit allocation. Modify the snr
offset until we can pack everything in the requested frame size */
@ -979,7 +954,7 @@ static int compute_bit_allocation(AC3EncodeContext *s,
snr_offset = s->coarse_snr_offset << 4;
while (snr_offset >= 0 &&
bit_alloc(s, mask, psd, bap, snr_offset) > bits_left) {
bit_alloc(s, s->bap, snr_offset) > bits_left) {
snr_offset -= 64;
}
if (snr_offset < 0) {
@ -987,24 +962,24 @@ static int compute_bit_allocation(AC3EncodeContext *s,
}
while (snr_offset + 64 <= 1023 &&
bit_alloc(s, mask, psd, bap1, snr_offset + 64) <= bits_left) {
bit_alloc(s, s->bap1, snr_offset + 64) <= bits_left) {
snr_offset += 64;
memcpy(bap, bap1, sizeof(bap1));
memcpy(s->bap, s->bap1, sizeof(s->bap1));
}
while (snr_offset + 16 <= 1023 &&
bit_alloc(s, mask, psd, bap1, snr_offset + 16) <= bits_left) {
bit_alloc(s, s->bap1, snr_offset + 16) <= bits_left) {
snr_offset += 16;
memcpy(bap, bap1, sizeof(bap1));
memcpy(s->bap, s->bap1, sizeof(s->bap1));
}
while (snr_offset + 4 <= 1023 &&
bit_alloc(s, mask, psd, bap1, snr_offset + 4) <= bits_left) {
bit_alloc(s, s->bap1, snr_offset + 4) <= bits_left) {
snr_offset += 4;
memcpy(bap, bap1, sizeof(bap1));
memcpy(s->bap, s->bap1, sizeof(s->bap1));
}
while (snr_offset + 1 <= 1023 &&
bit_alloc(s, mask, psd, bap1, snr_offset + 1) <= bits_left) {
bit_alloc(s, s->bap1, snr_offset + 1) <= bits_left) {
snr_offset++;
memcpy(bap, bap1, sizeof(bap1));
memcpy(s->bap, s->bap1, sizeof(s->bap1));
}
s->coarse_snr_offset = snr_offset >> 4;
@ -1156,12 +1131,7 @@ static void quantize_mantissas_blk_ch(AC3EncodeContext *s,
/**
* Quantize mantissas using coefficients, exponents, and bit allocation pointers.
*/
static void quantize_mantissas(AC3EncodeContext *s,
int32_t mdct_coef[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int8_t exp_shift[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],
uint16_t qmant[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
static void quantize_mantissas(AC3EncodeContext *s)
{
int blk, ch;
@ -1171,9 +1141,9 @@ static void quantize_mantissas(AC3EncodeContext *s,
s->qmant1_ptr = s->qmant2_ptr = s->qmant4_ptr = NULL;
for (ch = 0; ch < s->channels; ch++) {
quantize_mantissas_blk_ch(s, mdct_coef[blk][ch], exp_shift[blk][ch],
encoded_exp[blk][ch], bap[blk][ch],
qmant[blk][ch], s->nb_coefs[ch]);
quantize_mantissas_blk_ch(s, s->mdct_coef[blk][ch], s->exp_shift[blk][ch],
s->encoded_exp[blk][ch], s->bap[blk][ch],
s->qmant[blk][ch], s->nb_coefs[ch]);
}
}
}
@ -1214,11 +1184,6 @@ static void output_frame_header(AC3EncodeContext *s)
* Write one audio block to the output bitstream.
*/
static void output_audio_block(AC3EncodeContext *s,
uint8_t exp_strategy[AC3_MAX_CHANNELS],
uint8_t num_exp_groups[AC3_MAX_CHANNELS],
uint8_t grouped_exp[AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS],
uint8_t bap[AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint16_t qmant[AC3_MAX_CHANNELS][AC3_MAX_COEFS],
int block_num)
{
int ch, i, baie, rbnd;
@ -1251,28 +1216,28 @@ static void output_audio_block(AC3EncodeContext *s,
/* exponent strategy */
for (ch = 0; ch < s->fbw_channels; ch++)
put_bits(&s->pb, 2, exp_strategy[ch]);
put_bits(&s->pb, 2, s->exp_strategy[block_num][ch]);
if (s->lfe_on)
put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]);
put_bits(&s->pb, 1, s->exp_strategy[block_num][s->lfe_channel]);
/* bandwidth */
for (ch = 0; ch < s->fbw_channels; ch++) {
if (exp_strategy[ch] != EXP_REUSE)
if (s->exp_strategy[block_num][ch] != EXP_REUSE)
put_bits(&s->pb, 6, s->bandwidth_code[ch]);
}
/* exponents */
for (ch = 0; ch < s->channels; ch++) {
if (exp_strategy[ch] == EXP_REUSE)
if (s->exp_strategy[block_num][ch] == EXP_REUSE)
continue;
/* first exponent */
put_bits(&s->pb, 4, grouped_exp[ch][0]);
put_bits(&s->pb, 4, s->grouped_exp[block_num][ch][0]);
/* next ones are delta-encoded and grouped */
for (i = 1; i <= num_exp_groups[ch]; i++)
put_bits(&s->pb, 7, grouped_exp[ch][i]);
for (i = 1; i <= s->num_exp_groups[block_num][ch]; i++)
put_bits(&s->pb, 7, s->grouped_exp[block_num][ch][i]);
if (ch != s->lfe_channel)
put_bits(&s->pb, 2, 0); /* no gain range info */
@ -1307,8 +1272,8 @@ static void output_audio_block(AC3EncodeContext *s,
int b, q;
for (i = 0; i < s->nb_coefs[ch]; i++) {
q = qmant[ch][i];
b = bap[ch][i];
q = s->qmant[block_num][ch][i];
b = s->bap[block_num][ch][i];
switch (b) {
case 0: break;
case 1: if (q != 128) put_bits(&s->pb, 5, q); break;
@ -1400,12 +1365,7 @@ static void output_frame_end(AC3EncodeContext *s)
* Write the frame to the output bitstream.
*/
static void output_frame(AC3EncodeContext *s,
unsigned char *frame,
uint8_t exp_strategy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS],
uint8_t grouped_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS],
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS],
uint16_t qmant[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS])
unsigned char *frame)
{
int blk;
@ -1414,8 +1374,7 @@ static void output_frame(AC3EncodeContext *s,
output_frame_header(s);
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
output_audio_block(s, exp_strategy[blk], num_exp_groups[blk],
grouped_exp[blk], bap[blk], qmant[blk], blk);
output_audio_block(s, blk);
}
output_frame_end(s);
@ -1430,37 +1389,26 @@ static int ac3_encode_frame(AVCodecContext *avctx,
{
AC3EncodeContext *s = avctx->priv_data;
const int16_t *samples = data;
int16_t planar_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE+AC3_FRAME_SIZE];
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 num_exp_groups[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
uint8_t grouped_exp[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS];
uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int8_t exp_shift[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS];
uint16_t qmant[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS];
int ret;
if (s->bit_alloc.sr_code == 1)
adjust_frame_size(s);
deinterleave_input_samples(s, samples, planar_samples);
deinterleave_input_samples(s, samples);
apply_mdct(s, planar_samples, exp_shift, mdct_coef);
apply_mdct(s);
process_exponents(s, mdct_coef, exp_shift, exp, exp_strategy, encoded_exp,
num_exp_groups, grouped_exp);
process_exponents(s);
ret = compute_bit_allocation(s, bap, encoded_exp, exp_strategy);
ret = compute_bit_allocation(s);
if (ret) {
av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
return ret;
}
quantize_mantissas(s, mdct_coef, exp_shift, encoded_exp, bap, qmant);
quantize_mantissas(s);
output_frame(s, frame, exp_strategy, num_exp_groups, grouped_exp, bap, qmant);
output_frame(s, frame);
return s->frame_size;
}

Write Preview
Loading…
Cancel
Save