Revision 7e0a284b
| libavcodec/ac3enc.c | ||
|---|---|---|
| 78 | 78 |
int16_t **band_psd; ///< psd per critical band |
| 79 | 79 |
int16_t **mask; ///< masking curve |
| 80 | 80 |
uint16_t **qmant; ///< quantized mantissas |
| 81 |
int8_t exp_shift[AC3_MAX_CHANNELS]; ///< exponent shift values
|
|
| 81 |
int8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixed-point coefficient shift values
|
|
| 82 | 82 |
uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block |
| 83 | 83 |
uint8_t rematrixing_flags[4]; ///< rematrixing flags |
| 84 | 84 |
} AC3Block; |
| ... | ... | |
| 269 | 269 |
|
| 270 | 270 |
apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE); |
| 271 | 271 |
|
| 272 |
block->exp_shift[ch] = normalize_samples(s);
|
|
| 272 |
block->coeff_shift[ch] = normalize_samples(s);
|
|
| 273 | 273 |
|
| 274 | 274 |
mdct512(&s->mdct, block->mdct_coef[ch], s->windowed_samples); |
| 275 | 275 |
} |
| ... | ... | |
| 416 | 416 |
AC3Block *block = &s->blocks[blk]; |
| 417 | 417 |
uint8_t *exp = block->exp[ch]; |
| 418 | 418 |
int32_t *coef = block->fixed_coef[ch]; |
| 419 |
int exp_shift = block->exp_shift[ch]; |
|
| 420 | 419 |
for (i = 0; i < AC3_MAX_COEFS; i++) {
|
| 421 | 420 |
int e; |
| 422 | 421 |
int v = abs(coef[i]); |
| 423 | 422 |
if (v == 0) |
| 424 | 423 |
e = 24; |
| 425 | 424 |
else {
|
| 426 |
e = 23 - av_log2(v) + exp_shift;
|
|
| 425 |
e = 23 - av_log2(v); |
|
| 427 | 426 |
if (e >= 24) {
|
| 428 | 427 |
e = 24; |
| 429 | 428 |
coef[i] = 0; |
| ... | ... | |
| 1139 | 1138 |
* Quantize a set of mantissas for a single channel in a single block. |
| 1140 | 1139 |
*/ |
| 1141 | 1140 |
static void quantize_mantissas_blk_ch(AC3EncodeContext *s, int32_t *fixed_coef, |
| 1142 |
int8_t exp_shift, uint8_t *exp,
|
|
| 1141 |
uint8_t *exp, |
|
| 1143 | 1142 |
uint8_t *bap, uint16_t *qmant, int n) |
| 1144 | 1143 |
{
|
| 1145 | 1144 |
int i; |
| ... | ... | |
| 1147 | 1146 |
for (i = 0; i < n; i++) {
|
| 1148 | 1147 |
int v; |
| 1149 | 1148 |
int c = fixed_coef[i]; |
| 1150 |
int e = exp[i] - exp_shift;
|
|
| 1149 |
int e = exp[i]; |
|
| 1151 | 1150 |
int b = bap[i]; |
| 1152 | 1151 |
switch (b) {
|
| 1153 | 1152 |
case 0: |
| ... | ... | |
| 1243 | 1242 |
s->qmant1_ptr = s->qmant2_ptr = s->qmant4_ptr = NULL; |
| 1244 | 1243 |
|
| 1245 | 1244 |
for (ch = 0; ch < s->channels; ch++) {
|
| 1246 |
quantize_mantissas_blk_ch(s, block->fixed_coef[ch], block->exp_shift[ch],
|
|
| 1245 |
quantize_mantissas_blk_ch(s, block->fixed_coef[ch], |
|
| 1247 | 1246 |
block->exp[ch], block->bap[ch], |
| 1248 | 1247 |
block->qmant[ch], s->nb_coefs[ch]); |
| 1249 | 1248 |
} |
| libavcodec/ac3enc_fixed.c | ||
|---|---|---|
| 295 | 295 |
|
| 296 | 296 |
|
| 297 | 297 |
/** |
| 298 |
* Shift each value in an array by a specified amount. |
|
| 299 |
* @param src input array |
|
| 300 |
* @param n number of values in the array |
|
| 301 |
* @param shift shift amount (negative=right, positive=left) |
|
| 302 |
*/ |
|
| 303 |
static void shift_int32(int32_t *src, int n, int shift) |
|
| 304 |
{
|
|
| 305 |
int i; |
|
| 306 |
|
|
| 307 |
if (shift > 0) {
|
|
| 308 |
for (i = 0; i < n; i++) |
|
| 309 |
src[i] <<= shift; |
|
| 310 |
} else if (shift < 0) {
|
|
| 311 |
shift = -shift; |
|
| 312 |
for (i = 0; i < n; i++) |
|
| 313 |
src[i] >>= shift; |
|
| 314 |
} |
|
| 315 |
} |
|
| 316 |
|
|
| 317 |
|
|
| 318 |
/** |
|
| 298 | 319 |
* Normalize the input samples to use the maximum available precision. |
| 299 |
* This assumes signed 16-bit input samples. Exponents are reduced by 9 to |
|
| 300 |
* match the 24-bit internal precision for MDCT coefficients. |
|
| 320 |
* This assumes signed 16-bit input samples. |
|
| 301 | 321 |
* |
| 302 |
* @return exponent shift
|
|
| 322 |
* @return coefficient shift
|
|
| 303 | 323 |
*/ |
| 304 | 324 |
static int normalize_samples(AC3EncodeContext *s) |
| 305 | 325 |
{
|
| 306 | 326 |
int v = 14 - log2_tab(s, s->windowed_samples, AC3_WINDOW_SIZE); |
| 307 | 327 |
lshift_tab(s->windowed_samples, AC3_WINDOW_SIZE, v); |
| 308 |
return v - 9;
|
|
| 328 |
return 9 - v;
|
|
| 309 | 329 |
} |
| 310 | 330 |
|
| 311 | 331 |
|
| 312 | 332 |
/** |
| 313 |
* Scale MDCT coefficients from float to fixed-point.
|
|
| 333 |
* Scale MDCT coefficients to 24-bit fixed-point.
|
|
| 314 | 334 |
*/ |
| 315 | 335 |
static void scale_coefficients(AC3EncodeContext *s) |
| 316 | 336 |
{
|
| 317 |
/* scaling/conversion is obviously not needed for the fixed-point encoder |
|
| 318 |
since the coefficients are already fixed-point. */ |
|
| 319 |
return; |
|
| 337 |
int blk, ch; |
|
| 338 |
|
|
| 339 |
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
|
|
| 340 |
AC3Block *block = &s->blocks[blk]; |
|
| 341 |
for (ch = 0; ch < s->channels; ch++) {
|
|
| 342 |
shift_int32(block->mdct_coef[ch], AC3_MAX_COEFS, |
|
| 343 |
block->coeff_shift[ch]); |
|
| 344 |
} |
|
| 345 |
} |
|
| 320 | 346 |
} |
| 321 | 347 |
|
| 322 | 348 |
|
| tests/ref/acodec/ac3_fixed | ||
|---|---|---|
| 1 |
07bd593823ebd721b3a32ef298bdfc20 *./tests/data/acodec/ac3.rm
|
|
| 1 |
5f1255da35a4ed00a2e932887c9aef77 *./tests/data/acodec/ac3.rm
|
|
| 2 | 2 |
98751 ./tests/data/acodec/ac3.rm |
Also available in: Unified diff