1/* 2 * The simplest AC-3 encoder 3 * Copyright (c) 2000 Fabrice Bellard 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file libavcodec/ac3enc.c 24 * The simplest AC-3 encoder. 25 */ 26//#define DEBUG 27//#define DEBUG_BITALLOC 28#include "libavutil/crc.h" 29#include "avcodec.h" 30#include "bitstream.h" 31#include "ac3.h" 32 33typedef struct AC3EncodeContext { 34 PutBitContext pb; 35 int nb_channels; 36 int nb_all_channels; 37 int lfe_channel; 38 int bit_rate; 39 unsigned int sample_rate; 40 unsigned int bitstream_id; 41 unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */ 42 unsigned int frame_size; /* current frame size in words */ 43 unsigned int bits_written; 44 unsigned int samples_written; 45 int sr_shift; 46 unsigned int frame_size_code; 47 unsigned int sr_code; /* frequency */ 48 unsigned int channel_mode; 49 int lfe; 50 unsigned int bitstream_mode; 51 short last_samples[AC3_MAX_CHANNELS][256]; 52 unsigned int chbwcod[AC3_MAX_CHANNELS]; 53 int nb_coefs[AC3_MAX_CHANNELS]; 54 55 /* bitrate allocation control */ 56 int slow_gain_code, slow_decay_code, fast_decay_code, db_per_bit_code, floor_code; 57 AC3BitAllocParameters bit_alloc; 58 int coarse_snr_offset; 59 int fast_gain_code[AC3_MAX_CHANNELS]; 60 int fine_snr_offset[AC3_MAX_CHANNELS]; 61 /* mantissa encoding */ 62 int mant1_cnt, mant2_cnt, mant4_cnt; 63} AC3EncodeContext; 64 65static int16_t costab[64]; 66static int16_t sintab[64]; 67static int16_t xcos1[128]; 68static int16_t xsin1[128]; 69 70#define MDCT_NBITS 9 71#define N (1 << MDCT_NBITS) 72 73/* new exponents are sent if their Norm 1 exceed this number */ 74#define EXP_DIFF_THRESHOLD 1000 75 76static inline int16_t fix15(float a) 77{ 78 int v; 79 v = (int)(a * (float)(1 << 15)); 80 if (v < -32767) 81 v = -32767; 82 else if (v > 32767) 83 v = 32767; 84 return v; 85} 86 87typedef struct IComplex { 88 short re,im; 89} IComplex; 90 91static av_cold void fft_init(int ln) 92{ 93 int i, n; 94 float alpha; 95 96 n = 1 << ln; 97 98 for(i=0;i<(n/2);i++) { 99 alpha = 2 * M_PI * (float)i / (float)n; 100 costab[i] = fix15(cos(alpha)); 101 sintab[i] = fix15(sin(alpha)); 102 } 103} 104 105/* butter fly op */ 106#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \ 107{\ 108 int ax, ay, bx, by;\ 109 bx=pre1;\ 110 by=pim1;\ 111 ax=qre1;\ 112 ay=qim1;\ 113 pre = (bx + ax) >> 1;\ 114 pim = (by + ay) >> 1;\ 115 qre = (bx - ax) >> 1;\ 116 qim = (by - ay) >> 1;\ 117} 118 119#define MUL16(a,b) ((a) * (b)) 120 121#define CMUL(pre, pim, are, aim, bre, bim) \ 122{\ 123 pre = (MUL16(are, bre) - MUL16(aim, bim)) >> 15;\ 124 pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15;\ 125} 126 127 128/* do a 2^n point complex fft on 2^ln points. */ 129static void fft(IComplex *z, int ln) 130{ 131 int j, l, np, np2; 132 int nblocks, nloops; 133 register IComplex *p,*q; 134 int tmp_re, tmp_im; 135 136 np = 1 << ln; 137 138 /* reverse */ 139 for(j=0;j<np;j++) { 140 int k = ff_reverse[j] >> (8 - ln); 141 if (k < j) 142 FFSWAP(IComplex, z[k], z[j]); 143 } 144 145 /* pass 0 */ 146 147 p=&z[0]; 148 j=(np >> 1); 149 do { 150 BF(p[0].re, p[0].im, p[1].re, p[1].im, 151 p[0].re, p[0].im, p[1].re, p[1].im); 152 p+=2; 153 } while (--j != 0); 154 155 /* pass 1 */ 156 157 p=&z[0]; 158 j=np >> 2; 159 do { 160 BF(p[0].re, p[0].im, p[2].re, p[2].im, 161 p[0].re, p[0].im, p[2].re, p[2].im); 162 BF(p[1].re, p[1].im, p[3].re, p[3].im, 163 p[1].re, p[1].im, p[3].im, -p[3].re); 164 p+=4; 165 } while (--j != 0); 166 167 /* pass 2 .. ln-1 */ 168 169 nblocks = np >> 3; 170 nloops = 1 << 2; 171 np2 = np >> 1; 172 do { 173 p = z; 174 q = z + nloops; 175 for (j = 0; j < nblocks; ++j) { 176 177 BF(p->re, p->im, q->re, q->im, 178 p->re, p->im, q->re, q->im); 179 180 p++; 181 q++; 182 for(l = nblocks; l < np2; l += nblocks) { 183 CMUL(tmp_re, tmp_im, costab[l], -sintab[l], q->re, q->im); 184 BF(p->re, p->im, q->re, q->im, 185 p->re, p->im, tmp_re, tmp_im); 186 p++; 187 q++; 188 } 189 p += nloops; 190 q += nloops; 191 } 192 nblocks = nblocks >> 1; 193 nloops = nloops << 1; 194 } while (nblocks != 0); 195} 196 197/* do a 512 point mdct */ 198static void mdct512(int32_t *out, int16_t *in) 199{ 200 int i, re, im, re1, im1; 201 int16_t rot[N]; 202 IComplex x[N/4]; 203 204 /* shift to simplify computations */ 205 for(i=0;i<N/4;i++) 206 rot[i] = -in[i + 3*N/4]; 207 for(i=N/4;i<N;i++) 208 rot[i] = in[i - N/4]; 209 210 /* pre rotation */ 211 for(i=0;i<N/4;i++) { 212 re = ((int)rot[2*i] - (int)rot[N-1-2*i]) >> 1; 213 im = -((int)rot[N/2+2*i] - (int)rot[N/2-1-2*i]) >> 1; 214 CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]); 215 } 216 217 fft(x, MDCT_NBITS - 2); 218 219 /* post rotation */ 220 for(i=0;i<N/4;i++) { 221 re = x[i].re; 222 im = x[i].im; 223 CMUL(re1, im1, re, im, xsin1[i], xcos1[i]); 224 out[2*i] = im1; 225 out[N/2-1-2*i] = re1; 226 } 227} 228 229/* XXX: use another norm ? */ 230static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n) 231{ 232 int sum, i; 233 sum = 0; 234 for(i=0;i<n;i++) { 235 sum += abs(exp1[i] - exp2[i]); 236 } 237 return sum; 238} 239 240static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 241 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 242 int ch, int is_lfe) 243{ 244 int i, j; 245 int exp_diff; 246 247 /* estimate if the exponent variation & decide if they should be 248 reused in the next frame */ 249 exp_strategy[0][ch] = EXP_NEW; 250 for(i=1;i<NB_BLOCKS;i++) { 251 exp_diff = calc_exp_diff(exp[i][ch], exp[i-1][ch], N/2); 252#ifdef DEBUG 253 av_log(NULL, AV_LOG_DEBUG, "exp_diff=%d\n", exp_diff); 254#endif 255 if (exp_diff > EXP_DIFF_THRESHOLD) 256 exp_strategy[i][ch] = EXP_NEW; 257 else 258 exp_strategy[i][ch] = EXP_REUSE; 259 } 260 if (is_lfe) 261 return; 262 263 /* now select the encoding strategy type : if exponents are often 264 recoded, we use a coarse encoding */ 265 i = 0; 266 while (i < NB_BLOCKS) { 267 j = i + 1; 268 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) 269 j++; 270 switch(j - i) { 271 case 1: 272 exp_strategy[i][ch] = EXP_D45; 273 break; 274 case 2: 275 case 3: 276 exp_strategy[i][ch] = EXP_D25; 277 break; 278 default: 279 exp_strategy[i][ch] = EXP_D15; 280 break; 281 } 282 i = j; 283 } 284} 285 286/* set exp[i] to min(exp[i], exp1[i]) */ 287static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n) 288{ 289 int i; 290 291 for(i=0;i<n;i++) { 292 if (exp1[i] < exp[i]) 293 exp[i] = exp1[i]; 294 } 295} 296 297/* update the exponents so that they are the ones the decoder will 298 decode. Return the number of bits used to code the exponents */ 299static int encode_exp(uint8_t encoded_exp[N/2], 300 uint8_t exp[N/2], 301 int nb_exps, 302 int exp_strategy) 303{ 304 int group_size, nb_groups, i, j, k, exp_min; 305 uint8_t exp1[N/2]; 306 307 switch(exp_strategy) { 308 case EXP_D15: 309 group_size = 1; 310 break; 311 case EXP_D25: 312 group_size = 2; 313 break; 314 default: 315 case EXP_D45: 316 group_size = 4; 317 break; 318 } 319 nb_groups = ((nb_exps + (group_size * 3) - 4) / (3 * group_size)) * 3; 320 321 /* for each group, compute the minimum exponent */ 322 exp1[0] = exp[0]; /* DC exponent is handled separately */ 323 k = 1; 324 for(i=1;i<=nb_groups;i++) { 325 exp_min = exp[k]; 326 assert(exp_min >= 0 && exp_min <= 24); 327 for(j=1;j<group_size;j++) { 328 if (exp[k+j] < exp_min) 329 exp_min = exp[k+j]; 330 } 331 exp1[i] = exp_min; 332 k += group_size; 333 } 334 335 /* constraint for DC exponent */ 336 if (exp1[0] > 15) 337 exp1[0] = 15; 338 339 /* Decrease the delta between each groups to within 2 340 * so that they can be differentially encoded */ 341 for (i=1;i<=nb_groups;i++) 342 exp1[i] = FFMIN(exp1[i], exp1[i-1] + 2); 343 for (i=nb_groups-1;i>=0;i--) 344 exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2); 345 346 /* now we have the exponent values the decoder will see */ 347 encoded_exp[0] = exp1[0]; 348 k = 1; 349 for(i=1;i<=nb_groups;i++) { 350 for(j=0;j<group_size;j++) { 351 encoded_exp[k+j] = exp1[i]; 352 } 353 k += group_size; 354 } 355 356#if defined(DEBUG) 357 av_log(NULL, AV_LOG_DEBUG, "exponents: strategy=%d\n", exp_strategy); 358 for(i=0;i<=nb_groups * group_size;i++) { 359 av_log(NULL, AV_LOG_DEBUG, "%d ", encoded_exp[i]); 360 } 361 av_log(NULL, AV_LOG_DEBUG, "\n"); 362#endif 363 364 return 4 + (nb_groups / 3) * 7; 365} 366 367/* return the size in bits taken by the mantissa */ 368static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs) 369{ 370 int bits, mant, i; 371 372 bits = 0; 373 for(i=0;i<nb_coefs;i++) { 374 mant = m[i]; 375 switch(mant) { 376 case 0: 377 /* nothing */ 378 break; 379 case 1: 380 /* 3 mantissa in 5 bits */ 381 if (s->mant1_cnt == 0) 382 bits += 5; 383 if (++s->mant1_cnt == 3) 384 s->mant1_cnt = 0; 385 break; 386 case 2: 387 /* 3 mantissa in 7 bits */ 388 if (s->mant2_cnt == 0) 389 bits += 7; 390 if (++s->mant2_cnt == 3) 391 s->mant2_cnt = 0; 392 break; 393 case 3: 394 bits += 3; 395 break; 396 case 4: 397 /* 2 mantissa in 7 bits */ 398 if (s->mant4_cnt == 0) 399 bits += 7; 400 if (++s->mant4_cnt == 2) 401 s->mant4_cnt = 0; 402 break; 403 case 14: 404 bits += 14; 405 break; 406 case 15: 407 bits += 16; 408 break; 409 default: 410 bits += mant - 1; 411 break; 412 } 413 } 414 return bits; 415} 416 417 418static void bit_alloc_masking(AC3EncodeContext *s, 419 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 420 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 421 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 422 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50]) 423{ 424 int blk, ch; 425 int16_t band_psd[NB_BLOCKS][AC3_MAX_CHANNELS][50]; 426 427 for(blk=0; blk<NB_BLOCKS; blk++) { 428 for(ch=0;ch<s->nb_all_channels;ch++) { 429 if(exp_strategy[blk][ch] == EXP_REUSE) { 430 memcpy(psd[blk][ch], psd[blk-1][ch], (N/2)*sizeof(int16_t)); 431 memcpy(mask[blk][ch], mask[blk-1][ch], 50*sizeof(int16_t)); 432 } else { 433 ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0, 434 s->nb_coefs[ch], 435 psd[blk][ch], band_psd[blk][ch]); 436 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, band_psd[blk][ch], 437 0, s->nb_coefs[ch], 438 ff_ac3_fast_gain_tab[s->fast_gain_code[ch]], 439 ch == s->lfe_channel, 440 DBA_NONE, 0, NULL, NULL, NULL, 441 mask[blk][ch]); 442 } 443 } 444 } 445} 446 447static int bit_alloc(AC3EncodeContext *s, 448 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50], 449 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 450 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 451 int frame_bits, int coarse_snr_offset, int fine_snr_offset) 452{ 453 int i, ch; 454 int snr_offset; 455 456 snr_offset = (((coarse_snr_offset - 15) << 4) + fine_snr_offset) << 2; 457 458 /* compute size */ 459 for(i=0;i<NB_BLOCKS;i++) { 460 s->mant1_cnt = 0; 461 s->mant2_cnt = 0; 462 s->mant4_cnt = 0; 463 for(ch=0;ch<s->nb_all_channels;ch++) { 464 ff_ac3_bit_alloc_calc_bap(mask[i][ch], psd[i][ch], 0, 465 s->nb_coefs[ch], snr_offset, 466 s->bit_alloc.floor, ff_ac3_bap_tab, 467 bap[i][ch]); 468 frame_bits += compute_mantissa_size(s, bap[i][ch], 469 s->nb_coefs[ch]); 470 } 471 } 472#if 0 473 printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n", 474 coarse_snr_offset, fine_snr_offset, frame_bits, 475 16 * s->frame_size - ((frame_bits + 7) & ~7)); 476#endif 477 return 16 * s->frame_size - frame_bits; 478} 479 480#define SNR_INC1 4 481 482static int compute_bit_allocation(AC3EncodeContext *s, 483 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 484 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], 485 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 486 int frame_bits) 487{ 488 int i, ch; 489 int coarse_snr_offset, fine_snr_offset; 490 uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 491 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 492 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50]; 493 static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; 494 495 /* init default parameters */ 496 s->slow_decay_code = 2; 497 s->fast_decay_code = 1; 498 s->slow_gain_code = 1; 499 s->db_per_bit_code = 2; 500 s->floor_code = 4; 501 for(ch=0;ch<s->nb_all_channels;ch++) 502 s->fast_gain_code[ch] = 4; 503 504 /* compute real values */ 505 s->bit_alloc.sr_code = s->sr_code; 506 s->bit_alloc.sr_shift = s->sr_shift; 507 s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->sr_shift; 508 s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->sr_shift; 509 s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code]; 510 s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code]; 511 s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code]; 512 513 /* header size */ 514 frame_bits += 65; 515 // if (s->channel_mode == 2) 516 // frame_bits += 2; 517 frame_bits += frame_bits_inc[s->channel_mode]; 518 519 /* audio blocks */ 520 for(i=0;i<NB_BLOCKS;i++) { 521 frame_bits += s->nb_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ 522 if (s->channel_mode == AC3_CHMODE_STEREO) { 523 frame_bits++; /* rematstr */ 524 if(i==0) frame_bits += 4; 525 } 526 frame_bits += 2 * s->nb_channels; /* chexpstr[2] * c */ 527 if (s->lfe) 528 frame_bits++; /* lfeexpstr */ 529 for(ch=0;ch<s->nb_channels;ch++) { 530 if (exp_strategy[i][ch] != EXP_REUSE) 531 frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ 532 } 533 frame_bits++; /* baie */ 534 frame_bits++; /* snr */ 535 frame_bits += 2; /* delta / skip */ 536 } 537 frame_bits++; /* cplinu for block 0 */ 538 /* bit alloc info */ 539 /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */ 540 /* csnroffset[6] */ 541 /* (fsnoffset[4] + fgaincod[4]) * c */ 542 frame_bits += 2*4 + 3 + 6 + s->nb_all_channels * (4 + 3); 543 544 /* auxdatae, crcrsv */ 545 frame_bits += 2; 546 547 /* CRC */ 548 frame_bits += 16; 549 550 /* calculate psd and masking curve before doing bit allocation */ 551 bit_alloc_masking(s, encoded_exp, exp_strategy, psd, mask); 552 553 /* now the big work begins : do the bit allocation. Modify the snr 554 offset until we can pack everything in the requested frame size */ 555 556 coarse_snr_offset = s->coarse_snr_offset; 557 while (coarse_snr_offset >= 0 && 558 bit_alloc(s, mask, psd, bap, frame_bits, coarse_snr_offset, 0) < 0) 559 coarse_snr_offset -= SNR_INC1; 560 if (coarse_snr_offset < 0) { 561 av_log(NULL, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n"); 562 return -1; 563 } 564 while ((coarse_snr_offset + SNR_INC1) <= 63 && 565 bit_alloc(s, mask, psd, bap1, frame_bits, 566 coarse_snr_offset + SNR_INC1, 0) >= 0) { 567 coarse_snr_offset += SNR_INC1; 568 memcpy(bap, bap1, sizeof(bap1)); 569 } 570 while ((coarse_snr_offset + 1) <= 63 && 571 bit_alloc(s, mask, psd, bap1, frame_bits, coarse_snr_offset + 1, 0) >= 0) { 572 coarse_snr_offset++; 573 memcpy(bap, bap1, sizeof(bap1)); 574 } 575 576 fine_snr_offset = 0; 577 while ((fine_snr_offset + SNR_INC1) <= 15 && 578 bit_alloc(s, mask, psd, bap1, frame_bits, 579 coarse_snr_offset, fine_snr_offset + SNR_INC1) >= 0) { 580 fine_snr_offset += SNR_INC1; 581 memcpy(bap, bap1, sizeof(bap1)); 582 } 583 while ((fine_snr_offset + 1) <= 15 && 584 bit_alloc(s, mask, psd, bap1, frame_bits, 585 coarse_snr_offset, fine_snr_offset + 1) >= 0) { 586 fine_snr_offset++; 587 memcpy(bap, bap1, sizeof(bap1)); 588 } 589 590 s->coarse_snr_offset = coarse_snr_offset; 591 for(ch=0;ch<s->nb_all_channels;ch++) 592 s->fine_snr_offset[ch] = fine_snr_offset; 593#if defined(DEBUG_BITALLOC) 594 { 595 int j; 596 597 for(i=0;i<6;i++) { 598 for(ch=0;ch<s->nb_all_channels;ch++) { 599 printf("Block #%d Ch%d:\n", i, ch); 600 printf("bap="); 601 for(j=0;j<s->nb_coefs[ch];j++) { 602 printf("%d ",bap[i][ch][j]); 603 } 604 printf("\n"); 605 } 606 } 607 } 608#endif 609 return 0; 610} 611 612static av_cold int AC3_encode_init(AVCodecContext *avctx) 613{ 614 int freq = avctx->sample_rate; 615 int bitrate = avctx->bit_rate; 616 int channels = avctx->channels; 617 AC3EncodeContext *s = avctx->priv_data; 618 int i, j, ch; 619 float alpha; 620 int bw_code; 621 static const uint8_t channel_mode_defs[6] = { 622 0x01, /* C */ 623 0x02, /* L R */ 624 0x03, /* L C R */ 625 0x06, /* L R SL SR */ 626 0x07, /* L C R SL SR */ 627 0x07, /* L C R SL SR (+LFE) */ 628 }; 629 630 avctx->frame_size = AC3_FRAME_SIZE; 631 632 ac3_common_init(); 633 634 /* number of channels */ 635 if (channels < 1 || channels > 6) 636 return -1; 637 s->channel_mode = channel_mode_defs[channels - 1]; 638 s->lfe = (channels == 6) ? 1 : 0; 639 s->nb_all_channels = channels; 640 s->nb_channels = channels > 5 ? 5 : channels; 641 s->lfe_channel = s->lfe ? 5 : -1; 642 643 /* frequency */ 644 for(i=0;i<3;i++) { 645 for(j=0;j<3;j++) 646 if ((ff_ac3_sample_rate_tab[j] >> i) == freq) 647 goto found; 648 } 649 return -1; 650 found: 651 s->sample_rate = freq; 652 s->sr_shift = i; 653 s->sr_code = j; 654 s->bitstream_id = 8 + s->sr_shift; 655 s->bitstream_mode = 0; /* complete main audio service */ 656 657 /* bitrate & frame size */ 658 for(i=0;i<19;i++) { 659 if ((ff_ac3_bitrate_tab[i] >> s->sr_shift)*1000 == bitrate) 660 break; 661 } 662 if (i == 19) 663 return -1; 664 s->bit_rate = bitrate; 665 s->frame_size_code = i << 1; 666 s->frame_size_min = ff_ac3_frame_size_tab[s->frame_size_code][s->sr_code]; 667 s->bits_written = 0; 668 s->samples_written = 0; 669 s->frame_size = s->frame_size_min; 670 671 /* bit allocation init */ 672 if(avctx->cutoff) { 673 /* calculate bandwidth based on user-specified cutoff frequency */ 674 int cutoff = av_clip(avctx->cutoff, 1, s->sample_rate >> 1); 675 int fbw_coeffs = cutoff * 512 / s->sample_rate; 676 bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60); 677 } else { 678 /* use default bandwidth setting */ 679 /* XXX: should compute the bandwidth according to the frame 680 size, so that we avoid annoying high frequency artifacts */ 681 bw_code = 50; 682 } 683 for(ch=0;ch<s->nb_channels;ch++) { 684 /* bandwidth for each channel */ 685 s->chbwcod[ch] = bw_code; 686 s->nb_coefs[ch] = bw_code * 3 + 73; 687 } 688 if (s->lfe) { 689 s->nb_coefs[s->lfe_channel] = 7; /* fixed */ 690 } 691 /* initial snr offset */ 692 s->coarse_snr_offset = 40; 693 694 /* mdct init */ 695 fft_init(MDCT_NBITS - 2); 696 for(i=0;i<N/4;i++) { 697 alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N; 698 xcos1[i] = fix15(-cos(alpha)); 699 xsin1[i] = fix15(-sin(alpha)); 700 } 701 702 avctx->coded_frame= avcodec_alloc_frame(); 703 avctx->coded_frame->key_frame= 1; 704 705 return 0; 706} 707 708/* output the AC-3 frame header */ 709static void output_frame_header(AC3EncodeContext *s, unsigned char *frame) 710{ 711 init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE); 712 713 put_bits(&s->pb, 16, 0x0b77); /* frame header */ 714 put_bits(&s->pb, 16, 0); /* crc1: will be filled later */ 715 put_bits(&s->pb, 2, s->sr_code); 716 put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min)); 717 put_bits(&s->pb, 5, s->bitstream_id); 718 put_bits(&s->pb, 3, s->bitstream_mode); 719 put_bits(&s->pb, 3, s->channel_mode); 720 if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO) 721 put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ 722 if (s->channel_mode & 0x04) 723 put_bits(&s->pb, 2, 1); /* XXX -6 dB */ 724 if (s->channel_mode == AC3_CHMODE_STEREO) 725 put_bits(&s->pb, 2, 0); /* surround not indicated */ 726 put_bits(&s->pb, 1, s->lfe); /* LFE */ 727 put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */ 728 put_bits(&s->pb, 1, 0); /* no compression control word */ 729 put_bits(&s->pb, 1, 0); /* no lang code */ 730 put_bits(&s->pb, 1, 0); /* no audio production info */ 731 put_bits(&s->pb, 1, 0); /* no copyright */ 732 put_bits(&s->pb, 1, 1); /* original bitstream */ 733 put_bits(&s->pb, 1, 0); /* no time code 1 */ 734 put_bits(&s->pb, 1, 0); /* no time code 2 */ 735 put_bits(&s->pb, 1, 0); /* no additional bit stream info */ 736} 737 738/* symetric quantization on 'levels' levels */ 739static inline int sym_quant(int c, int e, int levels) 740{ 741 int v; 742 743 if (c >= 0) { 744 v = (levels * (c << e)) >> 24; 745 v = (v + 1) >> 1; 746 v = (levels >> 1) + v; 747 } else { 748 v = (levels * ((-c) << e)) >> 24; 749 v = (v + 1) >> 1; 750 v = (levels >> 1) - v; 751 } 752 assert (v >= 0 && v < levels); 753 return v; 754} 755 756/* asymetric quantization on 2^qbits levels */ 757static inline int asym_quant(int c, int e, int qbits) 758{ 759 int lshift, m, v; 760 761 lshift = e + qbits - 24; 762 if (lshift >= 0) 763 v = c << lshift; 764 else 765 v = c >> (-lshift); 766 /* rounding */ 767 v = (v + 1) >> 1; 768 m = (1 << (qbits-1)); 769 if (v >= m) 770 v = m - 1; 771 assert(v >= -m); 772 return v & ((1 << qbits)-1); 773} 774 775/* Output one audio block. There are NB_BLOCKS audio blocks in one AC-3 776 frame */ 777static void output_audio_block(AC3EncodeContext *s, 778 uint8_t exp_strategy[AC3_MAX_CHANNELS], 779 uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2], 780 uint8_t bap[AC3_MAX_CHANNELS][N/2], 781 int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2], 782 int8_t global_exp[AC3_MAX_CHANNELS], 783 int block_num) 784{ 785 int ch, nb_groups, group_size, i, baie, rbnd; 786 uint8_t *p; 787 uint16_t qmant[AC3_MAX_CHANNELS][N/2]; 788 int exp0, exp1; 789 int mant1_cnt, mant2_cnt, mant4_cnt; 790 uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; 791 int delta0, delta1, delta2; 792 793 for(ch=0;ch<s->nb_channels;ch++) 794 put_bits(&s->pb, 1, 0); /* 512 point MDCT */ 795 for(ch=0;ch<s->nb_channels;ch++) 796 put_bits(&s->pb, 1, 1); /* no dither */ 797 put_bits(&s->pb, 1, 0); /* no dynamic range */ 798 if (block_num == 0) { 799 /* for block 0, even if no coupling, we must say it. This is a 800 waste of bit :-) */ 801 put_bits(&s->pb, 1, 1); /* coupling strategy present */ 802 put_bits(&s->pb, 1, 0); /* no coupling strategy */ 803 } else { 804 put_bits(&s->pb, 1, 0); /* no new coupling strategy */ 805 } 806 807 if (s->channel_mode == AC3_CHMODE_STEREO) 808 { 809 if(block_num==0) 810 { 811 /* first block must define rematrixing (rematstr) */ 812 put_bits(&s->pb, 1, 1); 813 814 /* dummy rematrixing rematflg(1:4)=0 */ 815 for (rbnd=0;rbnd<4;rbnd++) 816 put_bits(&s->pb, 1, 0); 817 } 818 else 819 { 820 /* no matrixing (but should be used in the future) */ 821 put_bits(&s->pb, 1, 0); 822 } 823 } 824 825#if defined(DEBUG) 826 { 827 static int count = 0; 828 av_log(NULL, AV_LOG_DEBUG, "Block #%d (%d)\n", block_num, count++); 829 } 830#endif 831 /* exponent strategy */ 832 for(ch=0;ch<s->nb_channels;ch++) { 833 put_bits(&s->pb, 2, exp_strategy[ch]); 834 } 835 836 if (s->lfe) { 837 put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]); 838 } 839 840 for(ch=0;ch<s->nb_channels;ch++) { 841 if (exp_strategy[ch] != EXP_REUSE) 842 put_bits(&s->pb, 6, s->chbwcod[ch]); 843 } 844 845 /* exponents */ 846 for (ch = 0; ch < s->nb_all_channels; ch++) { 847 switch(exp_strategy[ch]) { 848 case EXP_REUSE: 849 continue; 850 case EXP_D15: 851 group_size = 1; 852 break; 853 case EXP_D25: 854 group_size = 2; 855 break; 856 default: 857 case EXP_D45: 858 group_size = 4; 859 break; 860 } 861 nb_groups = (s->nb_coefs[ch] + (group_size * 3) - 4) / (3 * group_size); 862 p = encoded_exp[ch]; 863 864 /* first exponent */ 865 exp1 = *p++; 866 put_bits(&s->pb, 4, exp1); 867 868 /* next ones are delta encoded */ 869 for(i=0;i<nb_groups;i++) { 870 /* merge three delta in one code */ 871 exp0 = exp1; 872 exp1 = p[0]; 873 p += group_size; 874 delta0 = exp1 - exp0 + 2; 875 876 exp0 = exp1; 877 exp1 = p[0]; 878 p += group_size; 879 delta1 = exp1 - exp0 + 2; 880 881 exp0 = exp1; 882 exp1 = p[0]; 883 p += group_size; 884 delta2 = exp1 - exp0 + 2; 885 886 put_bits(&s->pb, 7, ((delta0 * 5 + delta1) * 5) + delta2); 887 } 888 889 if (ch != s->lfe_channel) 890 put_bits(&s->pb, 2, 0); /* no gain range info */ 891 } 892 893 /* bit allocation info */ 894 baie = (block_num == 0); 895 put_bits(&s->pb, 1, baie); 896 if (baie) { 897 put_bits(&s->pb, 2, s->slow_decay_code); 898 put_bits(&s->pb, 2, s->fast_decay_code); 899 put_bits(&s->pb, 2, s->slow_gain_code); 900 put_bits(&s->pb, 2, s->db_per_bit_code); 901 put_bits(&s->pb, 3, s->floor_code); 902 } 903 904 /* snr offset */ 905 put_bits(&s->pb, 1, baie); /* always present with bai */ 906 if (baie) { 907 put_bits(&s->pb, 6, s->coarse_snr_offset); 908 for(ch=0;ch<s->nb_all_channels;ch++) { 909 put_bits(&s->pb, 4, s->fine_snr_offset[ch]); 910 put_bits(&s->pb, 3, s->fast_gain_code[ch]); 911 } 912 } 913 914 put_bits(&s->pb, 1, 0); /* no delta bit allocation */ 915 put_bits(&s->pb, 1, 0); /* no data to skip */ 916 917 /* mantissa encoding : we use two passes to handle the grouping. A 918 one pass method may be faster, but it would necessitate to 919 modify the output stream. */ 920 921 /* first pass: quantize */ 922 mant1_cnt = mant2_cnt = mant4_cnt = 0; 923 qmant1_ptr = qmant2_ptr = qmant4_ptr = NULL; 924 925 for (ch = 0; ch < s->nb_all_channels; ch++) { 926 int b, c, e, v; 927 928 for(i=0;i<s->nb_coefs[ch];i++) { 929 c = mdct_coefs[ch][i]; 930 e = encoded_exp[ch][i] - global_exp[ch]; 931 b = bap[ch][i]; 932 switch(b) { 933 case 0: 934 v = 0; 935 break; 936 case 1: 937 v = sym_quant(c, e, 3); 938 switch(mant1_cnt) { 939 case 0: 940 qmant1_ptr = &qmant[ch][i]; 941 v = 9 * v; 942 mant1_cnt = 1; 943 break; 944 case 1: 945 *qmant1_ptr += 3 * v; 946 mant1_cnt = 2; 947 v = 128; 948 break; 949 default: 950 *qmant1_ptr += v; 951 mant1_cnt = 0; 952 v = 128; 953 break; 954 } 955 break; 956 case 2: 957 v = sym_quant(c, e, 5); 958 switch(mant2_cnt) { 959 case 0: 960 qmant2_ptr = &qmant[ch][i]; 961 v = 25 * v; 962 mant2_cnt = 1; 963 break; 964 case 1: 965 *qmant2_ptr += 5 * v; 966 mant2_cnt = 2; 967 v = 128; 968 break; 969 default: 970 *qmant2_ptr += v; 971 mant2_cnt = 0; 972 v = 128; 973 break; 974 } 975 break; 976 case 3: 977 v = sym_quant(c, e, 7); 978 break; 979 case 4: 980 v = sym_quant(c, e, 11); 981 switch(mant4_cnt) { 982 case 0: 983 qmant4_ptr = &qmant[ch][i]; 984 v = 11 * v; 985 mant4_cnt = 1; 986 break; 987 default: 988 *qmant4_ptr += v; 989 mant4_cnt = 0; 990 v = 128; 991 break; 992 } 993 break; 994 case 5: 995 v = sym_quant(c, e, 15); 996 break; 997 case 14: 998 v = asym_quant(c, e, 14); 999 break; 1000 case 15: 1001 v = asym_quant(c, e, 16); 1002 break; 1003 default: 1004 v = asym_quant(c, e, b - 1); 1005 break; 1006 } 1007 qmant[ch][i] = v; 1008 } 1009 } 1010 1011 /* second pass : output the values */ 1012 for (ch = 0; ch < s->nb_all_channels; ch++) { 1013 int b, q; 1014 1015 for(i=0;i<s->nb_coefs[ch];i++) { 1016 q = qmant[ch][i]; 1017 b = bap[ch][i]; 1018 switch(b) { 1019 case 0: 1020 break; 1021 case 1: 1022 if (q != 128) 1023 put_bits(&s->pb, 5, q); 1024 break; 1025 case 2: 1026 if (q != 128) 1027 put_bits(&s->pb, 7, q); 1028 break; 1029 case 3: 1030 put_bits(&s->pb, 3, q); 1031 break; 1032 case 4: 1033 if (q != 128) 1034 put_bits(&s->pb, 7, q); 1035 break; 1036 case 14: 1037 put_bits(&s->pb, 14, q); 1038 break; 1039 case 15: 1040 put_bits(&s->pb, 16, q); 1041 break; 1042 default: 1043 put_bits(&s->pb, b - 1, q); 1044 break; 1045 } 1046 } 1047 } 1048} 1049 1050#define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) 1051 1052static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) 1053{ 1054 unsigned int c; 1055 1056 c = 0; 1057 while (a) { 1058 if (a & 1) 1059 c ^= b; 1060 a = a >> 1; 1061 b = b << 1; 1062 if (b & (1 << 16)) 1063 b ^= poly; 1064 } 1065 return c; 1066} 1067 1068static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) 1069{ 1070 unsigned int r; 1071 r = 1; 1072 while (n) { 1073 if (n & 1) 1074 r = mul_poly(r, a, poly); 1075 a = mul_poly(a, a, poly); 1076 n >>= 1; 1077 } 1078 return r; 1079} 1080 1081 1082/* compute log2(max(abs(tab[]))) */ 1083static int log2_tab(int16_t *tab, int n) 1084{ 1085 int i, v; 1086 1087 v = 0; 1088 for(i=0;i<n;i++) { 1089 v |= abs(tab[i]); 1090 } 1091 return av_log2(v); 1092} 1093 1094static void lshift_tab(int16_t *tab, int n, int lshift) 1095{ 1096 int i; 1097 1098 if (lshift > 0) { 1099 for(i=0;i<n;i++) { 1100 tab[i] <<= lshift; 1101 } 1102 } else if (lshift < 0) { 1103 lshift = -lshift; 1104 for(i=0;i<n;i++) { 1105 tab[i] >>= lshift; 1106 } 1107 } 1108} 1109 1110/* fill the end of the frame and compute the two crcs */ 1111static int output_frame_end(AC3EncodeContext *s) 1112{ 1113 int frame_size, frame_size_58, n, crc1, crc2, crc_inv; 1114 uint8_t *frame; 1115 1116 frame_size = s->frame_size; /* frame size in words */ 1117 /* align to 8 bits */ 1118 flush_put_bits(&s->pb); 1119 /* add zero bytes to reach the frame size */ 1120 frame = s->pb.buf; 1121 n = 2 * s->frame_size - (pbBufPtr(&s->pb) - frame) - 2; 1122 assert(n >= 0); 1123 if(n>0) 1124 memset(pbBufPtr(&s->pb), 0, n); 1125 1126 /* Now we must compute both crcs : this is not so easy for crc1 1127 because it is at the beginning of the data... */ 1128 frame_size_58 = (frame_size >> 1) + (frame_size >> 3); 1129 crc1 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, 1130 frame + 4, 2 * frame_size_58 - 4)); 1131 /* XXX: could precompute crc_inv */ 1132 crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY); 1133 crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); 1134 AV_WB16(frame+2,crc1); 1135 1136 crc2 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, 1137 frame + 2 * frame_size_58, 1138 (frame_size - frame_size_58) * 2 - 2)); 1139 AV_WB16(frame+2*frame_size-2,crc2); 1140 1141 // printf("n=%d frame_size=%d\n", n, frame_size); 1142 return frame_size * 2; 1143} 1144 1145static int AC3_encode_frame(AVCodecContext *avctx, 1146 unsigned char *frame, int buf_size, void *data) 1147{ 1148 AC3EncodeContext *s = avctx->priv_data; 1149 int16_t *samples = data; 1150 int i, j, k, v, ch; 1151 int16_t input_samples[N]; 1152 int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 1153 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 1154 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]; 1155 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 1156 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; 1157 int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS]; 1158 int frame_bits; 1159 1160 frame_bits = 0; 1161 for(ch=0;ch<s->nb_all_channels;ch++) { 1162 /* fixed mdct to the six sub blocks & exponent computation */ 1163 for(i=0;i<NB_BLOCKS;i++) { 1164 int16_t *sptr; 1165 int sinc; 1166 1167 /* compute input samples */ 1168 memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t)); 1169 sinc = s->nb_all_channels; 1170 sptr = samples + (sinc * (N/2) * i) + ch; 1171 for(j=0;j<N/2;j++) { 1172 v = *sptr; 1173 input_samples[j + N/2] = v; 1174 s->last_samples[ch][j] = v; 1175 sptr += sinc; 1176 } 1177 1178 /* apply the MDCT window */ 1179 for(j=0;j<N/2;j++) { 1180 input_samples[j] = MUL16(input_samples[j], 1181 ff_ac3_window[j]) >> 15; 1182 input_samples[N-j-1] = MUL16(input_samples[N-j-1], 1183 ff_ac3_window[j]) >> 15; 1184 } 1185 1186 /* Normalize the samples to use the maximum available 1187 precision */ 1188 v = 14 - log2_tab(input_samples, N); 1189 if (v < 0) 1190 v = 0; 1191 exp_samples[i][ch] = v - 9; 1192 lshift_tab(input_samples, N, v); 1193 1194 /* do the MDCT */ 1195 mdct512(mdct_coef[i][ch], input_samples); 1196 1197 /* compute "exponents". We take into account the 1198 normalization there */ 1199 for(j=0;j<N/2;j++) { 1200 int e; 1201 v = abs(mdct_coef[i][ch][j]); 1202 if (v == 0) 1203 e = 24; 1204 else { 1205 e = 23 - av_log2(v) + exp_samples[i][ch]; 1206 if (e >= 24) { 1207 e = 24; 1208 mdct_coef[i][ch][j] = 0; 1209 } 1210 } 1211 exp[i][ch][j] = e; 1212 } 1213 } 1214 1215 compute_exp_strategy(exp_strategy, exp, ch, ch == s->lfe_channel); 1216 1217 /* compute the exponents as the decoder will see them. The 1218 EXP_REUSE case must be handled carefully : we select the 1219 min of the exponents */ 1220 i = 0; 1221 while (i < NB_BLOCKS) { 1222 j = i + 1; 1223 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) { 1224 exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]); 1225 j++; 1226 } 1227 frame_bits += encode_exp(encoded_exp[i][ch], 1228 exp[i][ch], s->nb_coefs[ch], 1229 exp_strategy[i][ch]); 1230 /* copy encoded exponents for reuse case */ 1231 for(k=i+1;k<j;k++) { 1232 memcpy(encoded_exp[k][ch], encoded_exp[i][ch], 1233 s->nb_coefs[ch] * sizeof(uint8_t)); 1234 } 1235 i = j; 1236 } 1237 } 1238 1239 /* adjust for fractional frame sizes */ 1240 while(s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) { 1241 s->bits_written -= s->bit_rate; 1242 s->samples_written -= s->sample_rate; 1243 } 1244 s->frame_size = s->frame_size_min + (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate); 1245 s->bits_written += s->frame_size * 16; 1246 s->samples_written += AC3_FRAME_SIZE; 1247 1248 compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits); 1249 /* everything is known... let's output the frame */ 1250 output_frame_header(s, frame); 1251 1252 for(i=0;i<NB_BLOCKS;i++) { 1253 output_audio_block(s, exp_strategy[i], encoded_exp[i], 1254 bap[i], mdct_coef[i], exp_samples[i], i); 1255 } 1256 return output_frame_end(s); 1257} 1258 1259static av_cold int AC3_encode_close(AVCodecContext *avctx) 1260{ 1261 av_freep(&avctx->coded_frame); 1262 return 0; 1263} 1264 1265#if 0 1266/*************************************************************************/ 1267/* TEST */ 1268 1269#undef random 1270#define FN (N/4) 1271 1272void fft_test(void) 1273{ 1274 IComplex in[FN], in1[FN]; 1275 int k, n, i; 1276 float sum_re, sum_im, a; 1277 1278 /* FFT test */ 1279 1280 for(i=0;i<FN;i++) { 1281 in[i].re = random() % 65535 - 32767; 1282 in[i].im = random() % 65535 - 32767; 1283 in1[i] = in[i]; 1284 } 1285 fft(in, 7); 1286 1287 /* do it by hand */ 1288 for(k=0;k<FN;k++) { 1289 sum_re = 0; 1290 sum_im = 0; 1291 for(n=0;n<FN;n++) { 1292 a = -2 * M_PI * (n * k) / FN; 1293 sum_re += in1[n].re * cos(a) - in1[n].im * sin(a); 1294 sum_im += in1[n].re * sin(a) + in1[n].im * cos(a); 1295 } 1296 printf("%3d: %6d,%6d %6.0f,%6.0f\n", 1297 k, in[k].re, in[k].im, sum_re / FN, sum_im / FN); 1298 } 1299} 1300 1301void mdct_test(void) 1302{ 1303 int16_t input[N]; 1304 int32_t output[N/2]; 1305 float input1[N]; 1306 float output1[N/2]; 1307 float s, a, err, e, emax; 1308 int i, k, n; 1309 1310 for(i=0;i<N;i++) { 1311 input[i] = (random() % 65535 - 32767) * 9 / 10; 1312 input1[i] = input[i]; 1313 } 1314 1315 mdct512(output, input); 1316 1317 /* do it by hand */ 1318 for(k=0;k<N/2;k++) { 1319 s = 0; 1320 for(n=0;n<N;n++) { 1321 a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N)); 1322 s += input1[n] * cos(a); 1323 } 1324 output1[k] = -2 * s / N; 1325 } 1326 1327 err = 0; 1328 emax = 0; 1329 for(i=0;i<N/2;i++) { 1330 printf("%3d: %7d %7.0f\n", i, output[i], output1[i]); 1331 e = output[i] - output1[i]; 1332 if (e > emax) 1333 emax = e; 1334 err += e * e; 1335 } 1336 printf("err2=%f emax=%f\n", err / (N/2), emax); 1337} 1338 1339void test_ac3(void) 1340{ 1341 AC3EncodeContext ctx; 1342 unsigned char frame[AC3_MAX_CODED_FRAME_SIZE]; 1343 short samples[AC3_FRAME_SIZE]; 1344 int ret, i; 1345 1346 AC3_encode_init(&ctx, 44100, 64000, 1); 1347 1348 fft_test(); 1349 mdct_test(); 1350 1351 for(i=0;i<AC3_FRAME_SIZE;i++) 1352 samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000); 1353 ret = AC3_encode_frame(&ctx, frame, samples); 1354 printf("ret=%d\n", ret); 1355} 1356#endif 1357 1358AVCodec ac3_encoder = { 1359 "ac3", 1360 CODEC_TYPE_AUDIO, 1361 CODEC_ID_AC3, 1362 sizeof(AC3EncodeContext), 1363 AC3_encode_init, 1364 AC3_encode_frame, 1365 AC3_encode_close, 1366 NULL, 1367 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, 1368 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), 1369}; 1370