ffmpeg / libavcodec / ac3enc.c @ 5509bffa
History  View  Annotate  Download (42.6 KB)
1 
/*


2 
* The simplest AC3 encoder

3 
* Copyright (c) 2000 Fabrice Bellard.

4 
*

5 
* This library is free software; you can redistribute it and/or

6 
* modify it under the terms of the GNU Lesser General Public

7 
* License as published by the Free Software Foundation; either

8 
* version 2 of the License, or (at your option) any later version.

9 
*

10 
* This library is distributed in the hope that it will be useful,

11 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

12 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 
* Lesser General Public License for more details.

14 
*

15 
* You should have received a copy of the GNU Lesser General Public

16 
* License along with this library; if not, write to the Free Software

17 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

18 
*/

19  
20 
/**

21 
* @file ac3enc.c

22 
* The simplest AC3 encoder.

23 
*/

24 
//#define DEBUG

25 
//#define DEBUG_BITALLOC

26 
#include "avcodec.h" 
27 
#include "bitstream.h" 
28 
#include "ac3.h" 
29  
30 
typedef struct AC3EncodeContext { 
31 
PutBitContext pb; 
32 
int nb_channels;

33 
int nb_all_channels;

34 
int lfe_channel;

35 
int bit_rate;

36 
unsigned int sample_rate; 
37 
unsigned int bsid; 
38 
unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */ 
39 
unsigned int frame_size; /* current frame size in words */ 
40 
int halfratecod;

41 
unsigned int frmsizecod; 
42 
unsigned int fscod; /* frequency */ 
43 
unsigned int acmod; 
44 
int lfe;

45 
unsigned int bsmod; 
46 
short last_samples[AC3_MAX_CHANNELS][256]; 
47 
unsigned int chbwcod[AC3_MAX_CHANNELS]; 
48 
int nb_coefs[AC3_MAX_CHANNELS];

49  
50 
/* bitrate allocation control */

51 
int sgaincod, sdecaycod, fdecaycod, dbkneecod, floorcod;

52 
AC3BitAllocParameters bit_alloc; 
53 
int csnroffst;

54 
int fgaincod[AC3_MAX_CHANNELS];

55 
int fsnroffst[AC3_MAX_CHANNELS];

56 
/* mantissa encoding */

57 
int mant1_cnt, mant2_cnt, mant4_cnt;

58 
} AC3EncodeContext; 
59  
60 
#include "ac3tab.h" 
61  
62 
#define MDCT_NBITS 9 
63 
#define N (1 << MDCT_NBITS) 
64  
65 
/* new exponents are sent if their Norm 1 exceed this number */

66 
#define EXP_DIFF_THRESHOLD 1000 
67  
68 
static void fft_init(int ln); 
69 
static void ac3_crc_init(void); 
70  
71 
static inline int16_t fix15(float a) 
72 
{ 
73 
int v;

74 
v = (int)(a * (float)(1 << 15)); 
75 
if (v < 32767) 
76 
v = 32767;

77 
else if (v > 32767) 
78 
v = 32767;

79 
return v;

80 
} 
81  
82 
static inline int calc_lowcomp1(int a, int b0, int b1) 
83 
{ 
84 
if ((b0 + 256) == b1) { 
85 
a = 384 ;

86 
} else if (b0 > b1) { 
87 
a = a  64;

88 
if (a < 0) a=0; 
89 
} 
90 
return a;

91 
} 
92  
93 
static inline int calc_lowcomp(int a, int b0, int b1, int bin) 
94 
{ 
95 
if (bin < 7) { 
96 
if ((b0 + 256) == b1) { 
97 
a = 384 ;

98 
} else if (b0 > b1) { 
99 
a = a  64;

100 
if (a < 0) a=0; 
101 
} 
102 
} else if (bin < 20) { 
103 
if ((b0 + 256) == b1) { 
104 
a = 320 ;

105 
} else if (b0 > b1) { 
106 
a= a  64;

107 
if (a < 0) a=0; 
108 
} 
109 
} else {

110 
a = a  128;

111 
if (a < 0) a=0; 
112 
} 
113 
return a;

114 
} 
115  
116 
/* AC3 bit allocation. The algorithm is the one described in the AC3

117 
spec. */

118 
void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap,

119 
int8_t *exp, int start, int end, 
120 
int snroffset, int fgain, int is_lfe, 
121 
int deltbae,int deltnseg, 
122 
uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba) 
123 
{ 
124 
int bin,i,j,k,end1,v,v1,bndstrt,bndend,lowcomp,begin;

125 
int fastleak,slowleak,address,tmp;

126 
int16_t psd[256]; /* scaled exponents */ 
127 
int16_t bndpsd[50]; /* interpolated exponents */ 
128 
int16_t excite[50]; /* excitation */ 
129 
int16_t mask[50]; /* masking value */ 
130  
131 
/* exponent mapping to PSD */

132 
for(bin=start;bin<end;bin++) {

133 
psd[bin]=(3072  (exp[bin] << 7)); 
134 
} 
135  
136 
/* PSD integration */

137 
j=start; 
138 
k=masktab[start]; 
139 
do {

140 
v=psd[j]; 
141 
j++; 
142 
end1=bndtab[k+1];

143 
if (end1 > end) end1=end;

144 
for(i=j;i<end1;i++) {

145 
int c,adr;

146 
/* logadd */

147 
v1=psd[j]; 
148 
c=vv1; 
149 
if (c >= 0) { 
150 
adr=c >> 1;

151 
if (adr > 255) adr=255; 
152 
v=v + latab[adr]; 
153 
} else {

154 
adr=(c) >> 1;

155 
if (adr > 255) adr=255; 
156 
v=v1 + latab[adr]; 
157 
} 
158 
j++; 
159 
} 
160 
bndpsd[k]=v; 
161 
k++; 
162 
} while (end > bndtab[k]);

163  
164 
/* excitation function */

165 
bndstrt = masktab[start]; 
166 
bndend = masktab[end1] + 1; 
167  
168 
if (bndstrt == 0) { 
169 
lowcomp = 0;

170 
lowcomp = calc_lowcomp1(lowcomp, bndpsd[0], bndpsd[1]) ; 
171 
excite[0] = bndpsd[0]  fgain  lowcomp ; 
172 
lowcomp = calc_lowcomp1(lowcomp, bndpsd[1], bndpsd[2]) ; 
173 
excite[1] = bndpsd[1]  fgain  lowcomp ; 
174 
begin = 7 ;

175 
for (bin = 2; bin < 7; bin++) { 
176 
if (!(is_lfe && bin == 6)) 
177 
lowcomp = calc_lowcomp1(lowcomp, bndpsd[bin], bndpsd[bin+1]) ;

178 
fastleak = bndpsd[bin]  fgain ; 
179 
slowleak = bndpsd[bin]  s>sgain ; 
180 
excite[bin] = fastleak  lowcomp ; 
181 
if (!(is_lfe && bin == 6)) { 
182 
if (bndpsd[bin] <= bndpsd[bin+1]) { 
183 
begin = bin + 1 ;

184 
break ;

185 
} 
186 
} 
187 
} 
188  
189 
end1=bndend; 
190 
if (end1 > 22) end1=22; 
191  
192 
for (bin = begin; bin < end1; bin++) {

193 
if (!(is_lfe && bin == 6)) 
194 
lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin) ;

195  
196 
fastleak = s>fdecay ; 
197 
v = bndpsd[bin]  fgain; 
198 
if (fastleak < v) fastleak = v;

199  
200 
slowleak = s>sdecay ; 
201 
v = bndpsd[bin]  s>sgain; 
202 
if (slowleak < v) slowleak = v;

203  
204 
v=fastleak  lowcomp; 
205 
if (slowleak > v) v=slowleak;

206  
207 
excite[bin] = v; 
208 
} 
209 
begin = 22;

210 
} else {

211 
/* coupling channel */

212 
begin = bndstrt; 
213  
214 
fastleak = (s>cplfleak << 8) + 768; 
215 
slowleak = (s>cplsleak << 8) + 768; 
216 
} 
217  
218 
for (bin = begin; bin < bndend; bin++) {

219 
fastleak = s>fdecay ; 
220 
v = bndpsd[bin]  fgain; 
221 
if (fastleak < v) fastleak = v;

222 
slowleak = s>sdecay ; 
223 
v = bndpsd[bin]  s>sgain; 
224 
if (slowleak < v) slowleak = v;

225  
226 
v=fastleak; 
227 
if (slowleak > v) v = slowleak;

228 
excite[bin] = v; 
229 
} 
230  
231 
/* compute masking curve */

232  
233 
for (bin = bndstrt; bin < bndend; bin++) {

234 
v1 = excite[bin]; 
235 
tmp = s>dbknee  bndpsd[bin]; 
236 
if (tmp > 0) { 
237 
v1 += tmp >> 2;

238 
} 
239 
v=hth[bin >> s>halfratecod][s>fscod]; 
240 
if (v1 > v) v=v1;

241 
mask[bin] = v; 
242 
} 
243  
244 
/* delta bit allocation */

245  
246 
if (deltbae == 0  deltbae == 1) { 
247 
int band, seg, delta;

248 
band = 0 ;

249 
for (seg = 0; seg < deltnseg; seg++) { 
250 
band += deltoffst[seg] ; 
251 
if (deltba[seg] >= 4) { 
252 
delta = (deltba[seg]  3) << 7; 
253 
} else {

254 
delta = (deltba[seg]  4) << 7; 
255 
} 
256 
for (k = 0; k < deltlen[seg]; k++) { 
257 
mask[band] += delta ; 
258 
band++ ; 
259 
} 
260 
} 
261 
} 
262  
263 
/* compute bit allocation */

264  
265 
i = start ; 
266 
j = masktab[start] ; 
267 
do {

268 
v=mask[j]; 
269 
v = snroffset ; 
270 
v = s>floor ; 
271 
if (v < 0) v = 0; 
272 
v &= 0x1fe0 ;

273 
v += s>floor ; 
274  
275 
end1=bndtab[j] + bndsz[j]; 
276 
if (end1 > end) end1=end;

277  
278 
for (k = i; k < end1; k++) {

279 
address = (psd[i]  v) >> 5 ;

280 
if (address < 0) address=0; 
281 
else if (address > 63) address=63; 
282 
bap[i] = baptab[address]; 
283 
i++; 
284 
} 
285 
} while (end > bndtab[j++]) ;

286 
} 
287  
288 
typedef struct IComplex { 
289 
short re,im;

290 
} IComplex; 
291  
292 
static void fft_init(int ln) 
293 
{ 
294 
int i, j, m, n;

295 
float alpha;

296  
297 
n = 1 << ln;

298  
299 
for(i=0;i<(n/2);i++) { 
300 
alpha = 2 * M_PI * (float)i / (float)n; 
301 
costab[i] = fix15(cos(alpha)); 
302 
sintab[i] = fix15(sin(alpha)); 
303 
} 
304  
305 
for(i=0;i<n;i++) { 
306 
m=0;

307 
for(j=0;j<ln;j++) { 
308 
m = ((i >> j) & 1) << (lnj1); 
309 
} 
310 
fft_rev[i]=m; 
311 
} 
312 
} 
313  
314 
/* butter fly op */

315 
#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \

316 
{\ 
317 
int ax, ay, bx, by;\

318 
bx=pre1;\ 
319 
by=pim1;\ 
320 
ax=qre1;\ 
321 
ay=qim1;\ 
322 
pre = (bx + ax) >> 1;\

323 
pim = (by + ay) >> 1;\

324 
qre = (bx  ax) >> 1;\

325 
qim = (by  ay) >> 1;\

326 
} 
327  
328 
#define MUL16(a,b) ((a) * (b))

329  
330 
#define CMUL(pre, pim, are, aim, bre, bim) \

331 
{\ 
332 
pre = (MUL16(are, bre)  MUL16(aim, bim)) >> 15;\

333 
pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15;\

334 
} 
335  
336  
337 
/* do a 2^n point complex fft on 2^ln points. */

338 
static void fft(IComplex *z, int ln) 
339 
{ 
340 
int j, l, np, np2;

341 
int nblocks, nloops;

342 
register IComplex *p,*q;

343 
int tmp_re, tmp_im;

344  
345 
np = 1 << ln;

346  
347 
/* reverse */

348 
for(j=0;j<np;j++) { 
349 
int k;

350 
IComplex tmp; 
351 
k = fft_rev[j]; 
352 
if (k < j) {

353 
tmp = z[k]; 
354 
z[k] = z[j]; 
355 
z[j] = tmp; 
356 
} 
357 
} 
358  
359 
/* pass 0 */

360  
361 
p=&z[0];

362 
j=(np >> 1);

363 
do {

364 
BF(p[0].re, p[0].im, p[1].re, p[1].im, 
365 
p[0].re, p[0].im, p[1].re, p[1].im); 
366 
p+=2;

367 
} while (j != 0); 
368  
369 
/* pass 1 */

370  
371 
p=&z[0];

372 
j=np >> 2;

373 
do {

374 
BF(p[0].re, p[0].im, p[2].re, p[2].im, 
375 
p[0].re, p[0].im, p[2].re, p[2].im); 
376 
BF(p[1].re, p[1].im, p[3].re, p[3].im, 
377 
p[1].re, p[1].im, p[3].im, p[3].re); 
378 
p+=4;

379 
} while (j != 0); 
380  
381 
/* pass 2 .. ln1 */

382  
383 
nblocks = np >> 3;

384 
nloops = 1 << 2; 
385 
np2 = np >> 1;

386 
do {

387 
p = z; 
388 
q = z + nloops; 
389 
for (j = 0; j < nblocks; ++j) { 
390  
391 
BF(p>re, p>im, q>re, q>im, 
392 
p>re, p>im, q>re, q>im); 
393  
394 
p++; 
395 
q++; 
396 
for(l = nblocks; l < np2; l += nblocks) {

397 
CMUL(tmp_re, tmp_im, costab[l], sintab[l], q>re, q>im); 
398 
BF(p>re, p>im, q>re, q>im, 
399 
p>re, p>im, tmp_re, tmp_im); 
400 
p++; 
401 
q++; 
402 
} 
403 
p += nloops; 
404 
q += nloops; 
405 
} 
406 
nblocks = nblocks >> 1;

407 
nloops = nloops << 1;

408 
} while (nblocks != 0); 
409 
} 
410  
411 
/* do a 512 point mdct */

412 
static void mdct512(int32_t *out, int16_t *in) 
413 
{ 
414 
int i, re, im, re1, im1;

415 
int16_t rot[N]; 
416 
IComplex x[N/4];

417  
418 
/* shift to simplify computations */

419 
for(i=0;i<N/4;i++) 
420 
rot[i] = in[i + 3*N/4]; 
421 
for(i=N/4;i<N;i++) 
422 
rot[i] = in[i  N/4];

423  
424 
/* pre rotation */

425 
for(i=0;i<N/4;i++) { 
426 
re = ((int)rot[2*i]  (int)rot[N12*i]) >> 1; 
427 
im = ((int)rot[N/2+2*i]  (int)rot[N/212*i]) >> 1; 
428 
CMUL(x[i].re, x[i].im, re, im, xcos1[i], xsin1[i]); 
429 
} 
430  
431 
fft(x, MDCT_NBITS  2);

432  
433 
/* post rotation */

434 
for(i=0;i<N/4;i++) { 
435 
re = x[i].re; 
436 
im = x[i].im; 
437 
CMUL(re1, im1, re, im, xsin1[i], xcos1[i]); 
438 
out[2*i] = im1;

439 
out[N/212*i] = re1; 
440 
} 
441 
} 
442  
443 
/* XXX: use another norm ? */

444 
static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n) 
445 
{ 
446 
int sum, i;

447 
sum = 0;

448 
for(i=0;i<n;i++) { 
449 
sum += abs(exp1[i]  exp2[i]); 
450 
} 
451 
return sum;

452 
} 
453  
454 
static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 
455 
uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],

456 
int ch, int is_lfe) 
457 
{ 
458 
int i, j;

459 
int exp_diff;

460  
461 
/* estimate if the exponent variation & decide if they should be

462 
reused in the next frame */

463 
exp_strategy[0][ch] = EXP_NEW;

464 
for(i=1;i<NB_BLOCKS;i++) { 
465 
exp_diff = calc_exp_diff(exp[i][ch], exp[i1][ch], N/2); 
466 
#ifdef DEBUG

467 
av_log(NULL, AV_LOG_DEBUG, "exp_diff=%d\n", exp_diff); 
468 
#endif

469 
if (exp_diff > EXP_DIFF_THRESHOLD)

470 
exp_strategy[i][ch] = EXP_NEW; 
471 
else

472 
exp_strategy[i][ch] = EXP_REUSE; 
473 
} 
474 
if (is_lfe)

475 
return;

476  
477 
/* now select the encoding strategy type : if exponents are often

478 
recoded, we use a coarse encoding */

479 
i = 0;

480 
while (i < NB_BLOCKS) {

481 
j = i + 1;

482 
while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE)

483 
j++; 
484 
switch(j  i) {

485 
case 1: 
486 
exp_strategy[i][ch] = EXP_D45; 
487 
break;

488 
case 2: 
489 
case 3: 
490 
exp_strategy[i][ch] = EXP_D25; 
491 
break;

492 
default:

493 
exp_strategy[i][ch] = EXP_D15; 
494 
break;

495 
} 
496 
i = j; 
497 
} 
498 
} 
499  
500 
/* set exp[i] to min(exp[i], exp1[i]) */

501 
static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n) 
502 
{ 
503 
int i;

504  
505 
for(i=0;i<n;i++) { 
506 
if (exp1[i] < exp[i])

507 
exp[i] = exp1[i]; 
508 
} 
509 
} 
510  
511 
/* update the exponents so that they are the ones the decoder will

512 
decode. Return the number of bits used to code the exponents */

513 
static int encode_exp(uint8_t encoded_exp[N/2], 
514 
uint8_t exp[N/2],

515 
int nb_exps,

516 
int exp_strategy)

517 
{ 
518 
int group_size, nb_groups, i, j, k, exp_min;

519 
uint8_t exp1[N/2];

520  
521 
switch(exp_strategy) {

522 
case EXP_D15:

523 
group_size = 1;

524 
break;

525 
case EXP_D25:

526 
group_size = 2;

527 
break;

528 
default:

529 
case EXP_D45:

530 
group_size = 4;

531 
break;

532 
} 
533 
nb_groups = ((nb_exps + (group_size * 3)  4) / (3 * group_size)) * 3; 
534  
535 
/* for each group, compute the minimum exponent */

536 
exp1[0] = exp[0]; /* DC exponent is handled separately */ 
537 
k = 1;

538 
for(i=1;i<=nb_groups;i++) { 
539 
exp_min = exp[k]; 
540 
assert(exp_min >= 0 && exp_min <= 24); 
541 
for(j=1;j<group_size;j++) { 
542 
if (exp[k+j] < exp_min)

543 
exp_min = exp[k+j]; 
544 
} 
545 
exp1[i] = exp_min; 
546 
k += group_size; 
547 
} 
548  
549 
/* constraint for DC exponent */

550 
if (exp1[0] > 15) 
551 
exp1[0] = 15; 
552  
553 
/* Decrease the delta between each groups to within 2

554 
* so that they can be differentially encoded */

555 
for (i=1;i<=nb_groups;i++) 
556 
exp1[i] = FFMIN(exp1[i], exp1[i1] + 2); 
557 
for (i=nb_groups1;i>=0;i) 
558 
exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2); 
559  
560 
/* now we have the exponent values the decoder will see */

561 
encoded_exp[0] = exp1[0]; 
562 
k = 1;

563 
for(i=1;i<=nb_groups;i++) { 
564 
for(j=0;j<group_size;j++) { 
565 
encoded_exp[k+j] = exp1[i]; 
566 
} 
567 
k += group_size; 
568 
} 
569  
570 
#if defined(DEBUG)

571 
av_log(NULL, AV_LOG_DEBUG, "exponents: strategy=%d\n", exp_strategy); 
572 
for(i=0;i<=nb_groups * group_size;i++) { 
573 
av_log(NULL, AV_LOG_DEBUG, "%d ", encoded_exp[i]); 
574 
} 
575 
av_log(NULL, AV_LOG_DEBUG, "\n"); 
576 
#endif

577  
578 
return 4 + (nb_groups / 3) * 7; 
579 
} 
580  
581 
/* return the size in bits taken by the mantissa */

582 
static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs) 
583 
{ 
584 
int bits, mant, i;

585  
586 
bits = 0;

587 
for(i=0;i<nb_coefs;i++) { 
588 
mant = m[i]; 
589 
switch(mant) {

590 
case 0: 
591 
/* nothing */

592 
break;

593 
case 1: 
594 
/* 3 mantissa in 5 bits */

595 
if (s>mant1_cnt == 0) 
596 
bits += 5;

597 
if (++s>mant1_cnt == 3) 
598 
s>mant1_cnt = 0;

599 
break;

600 
case 2: 
601 
/* 3 mantissa in 7 bits */

602 
if (s>mant2_cnt == 0) 
603 
bits += 7;

604 
if (++s>mant2_cnt == 3) 
605 
s>mant2_cnt = 0;

606 
break;

607 
case 3: 
608 
bits += 3;

609 
break;

610 
case 4: 
611 
/* 2 mantissa in 7 bits */

612 
if (s>mant4_cnt == 0) 
613 
bits += 7;

614 
if (++s>mant4_cnt == 2) 
615 
s>mant4_cnt = 0;

616 
break;

617 
case 14: 
618 
bits += 14;

619 
break;

620 
case 15: 
621 
bits += 16;

622 
break;

623 
default:

624 
bits += mant  1;

625 
break;

626 
} 
627 
} 
628 
return bits;

629 
} 
630  
631  
632 
static int bit_alloc(AC3EncodeContext *s, 
633 
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],

634 
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],

635 
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 
636 
int frame_bits, int csnroffst, int fsnroffst) 
637 
{ 
638 
int i, ch;

639  
640 
/* compute size */

641 
for(i=0;i<NB_BLOCKS;i++) { 
642 
s>mant1_cnt = 0;

643 
s>mant2_cnt = 0;

644 
s>mant4_cnt = 0;

645 
for(ch=0;ch<s>nb_all_channels;ch++) { 
646 
ac3_parametric_bit_allocation(&s>bit_alloc, 
647 
bap[i][ch], (int8_t *)encoded_exp[i][ch], 
648 
0, s>nb_coefs[ch],

649 
(((csnroffst15) << 4) + 
650 
fsnroffst) << 2,

651 
fgaintab[s>fgaincod[ch]], 
652 
ch == s>lfe_channel, 
653 
2, 0, NULL, NULL, NULL); 
654 
frame_bits += compute_mantissa_size(s, bap[i][ch], 
655 
s>nb_coefs[ch]); 
656 
} 
657 
} 
658 
#if 0

659 
printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n",

660 
csnroffst, fsnroffst, frame_bits,

661 
16 * s>frame_size  ((frame_bits + 7) & ~7));

662 
#endif

663 
return 16 * s>frame_size  frame_bits; 
664 
} 
665  
666 
#define SNR_INC1 4 
667  
668 
static int compute_bit_allocation(AC3EncodeContext *s, 
669 
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],

670 
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],

671 
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], 
672 
int frame_bits)

673 
{ 
674 
int i, ch;

675 
int csnroffst, fsnroffst;

676 
uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];

677 
static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; 
678  
679 
/* init default parameters */

680 
s>sdecaycod = 2;

681 
s>fdecaycod = 1;

682 
s>sgaincod = 1;

683 
s>dbkneecod = 2;

684 
s>floorcod = 4;

685 
for(ch=0;ch<s>nb_all_channels;ch++) 
686 
s>fgaincod[ch] = 4;

687  
688 
/* compute real values */

689 
s>bit_alloc.fscod = s>fscod; 
690 
s>bit_alloc.halfratecod = s>halfratecod; 
691 
s>bit_alloc.sdecay = sdecaytab[s>sdecaycod] >> s>halfratecod; 
692 
s>bit_alloc.fdecay = fdecaytab[s>fdecaycod] >> s>halfratecod; 
693 
s>bit_alloc.sgain = sgaintab[s>sgaincod]; 
694 
s>bit_alloc.dbknee = dbkneetab[s>dbkneecod]; 
695 
s>bit_alloc.floor = floortab[s>floorcod]; 
696  
697 
/* header size */

698 
frame_bits += 65;

699 
// if (s>acmod == 2)

700 
// frame_bits += 2;

701 
frame_bits += frame_bits_inc[s>acmod]; 
702  
703 
/* audio blocks */

704 
for(i=0;i<NB_BLOCKS;i++) { 
705 
frame_bits += s>nb_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ 
706 
if (s>acmod == 2) { 
707 
frame_bits++; /* rematstr */

708 
if(i==0) frame_bits += 4; 
709 
} 
710 
frame_bits += 2 * s>nb_channels; /* chexpstr[2] * c */ 
711 
if (s>lfe)

712 
frame_bits++; /* lfeexpstr */

713 
for(ch=0;ch<s>nb_channels;ch++) { 
714 
if (exp_strategy[i][ch] != EXP_REUSE)

715 
frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ 
716 
} 
717 
frame_bits++; /* baie */

718 
frame_bits++; /* snr */

719 
frame_bits += 2; /* delta / skip */ 
720 
} 
721 
frame_bits++; /* cplinu for block 0 */

722 
/* bit alloc info */

723 
/* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */

724 
/* csnroffset[6] */

725 
/* (fsnoffset[4] + fgaincod[4]) * c */

726 
frame_bits += 2*4 + 3 + 6 + s>nb_all_channels * (4 + 3); 
727  
728 
/* auxdatae, crcrsv */

729 
frame_bits += 2;

730  
731 
/* CRC */

732 
frame_bits += 16;

733  
734 
/* now the big work begins : do the bit allocation. Modify the snr

735 
offset until we can pack everything in the requested frame size */

736  
737 
csnroffst = s>csnroffst; 
738 
while (csnroffst >= 0 && 
739 
bit_alloc(s, bap, encoded_exp, exp_strategy, frame_bits, csnroffst, 0) < 0) 
740 
csnroffst = SNR_INC1; 
741 
if (csnroffst < 0) { 
742 
av_log(NULL, AV_LOG_ERROR, "Yack, Error !!!\n"); 
743 
return 1; 
744 
} 
745 
while ((csnroffst + SNR_INC1) <= 63 && 
746 
bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, 
747 
csnroffst + SNR_INC1, 0) >= 0) { 
748 
csnroffst += SNR_INC1; 
749 
memcpy(bap, bap1, sizeof(bap1));

750 
} 
751 
while ((csnroffst + 1) <= 63 && 
752 
bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, csnroffst + 1, 0) >= 0) { 
753 
csnroffst++; 
754 
memcpy(bap, bap1, sizeof(bap1));

755 
} 
756  
757 
fsnroffst = 0;

758 
while ((fsnroffst + SNR_INC1) <= 15 && 
759 
bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, 
760 
csnroffst, fsnroffst + SNR_INC1) >= 0) {

761 
fsnroffst += SNR_INC1; 
762 
memcpy(bap, bap1, sizeof(bap1));

763 
} 
764 
while ((fsnroffst + 1) <= 15 && 
765 
bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, 
766 
csnroffst, fsnroffst + 1) >= 0) { 
767 
fsnroffst++; 
768 
memcpy(bap, bap1, sizeof(bap1));

769 
} 
770  
771 
s>csnroffst = csnroffst; 
772 
for(ch=0;ch<s>nb_all_channels;ch++) 
773 
s>fsnroffst[ch] = fsnroffst; 
774 
#if defined(DEBUG_BITALLOC)

775 
{ 
776 
int j;

777  
778 
for(i=0;i<6;i++) { 
779 
for(ch=0;ch<s>nb_all_channels;ch++) { 
780 
printf("Block #%d Ch%d:\n", i, ch);

781 
printf("bap=");

782 
for(j=0;j<s>nb_coefs[ch];j++) { 
783 
printf("%d ",bap[i][ch][j]);

784 
} 
785 
printf("\n");

786 
} 
787 
} 
788 
} 
789 
#endif

790 
return 0; 
791 
} 
792  
793 
void ac3_common_init(void) 
794 
{ 
795 
int i, j, k, l, v;

796 
/* compute bndtab and masktab from bandsz */

797 
k = 0;

798 
l = 0;

799 
for(i=0;i<50;i++) { 
800 
bndtab[i] = l; 
801 
v = bndsz[i]; 
802 
for(j=0;j<v;j++) masktab[k++]=i; 
803 
l += v; 
804 
} 
805 
bndtab[50] = 0; 
806 
} 
807  
808  
809 
static int AC3_encode_init(AVCodecContext *avctx) 
810 
{ 
811 
int freq = avctx>sample_rate;

812 
int bitrate = avctx>bit_rate;

813 
int channels = avctx>channels;

814 
AC3EncodeContext *s = avctx>priv_data; 
815 
int i, j, ch;

816 
float alpha;

817 
static const uint8_t acmod_defs[6] = { 
818 
0x01, /* C */ 
819 
0x02, /* L R */ 
820 
0x03, /* L C R */ 
821 
0x06, /* L R SL SR */ 
822 
0x07, /* L C R SL SR */ 
823 
0x07, /* L C R SL SR (+LFE) */ 
824 
}; 
825  
826 
avctx>frame_size = AC3_FRAME_SIZE; 
827  
828 
/* number of channels */

829 
if (channels < 1  channels > 6) 
830 
return 1; 
831 
s>acmod = acmod_defs[channels  1];

832 
s>lfe = (channels == 6) ? 1 : 0; 
833 
s>nb_all_channels = channels; 
834 
s>nb_channels = channels > 5 ? 5 : channels; 
835 
s>lfe_channel = s>lfe ? 5 : 1; 
836  
837 
/* frequency */

838 
for(i=0;i<3;i++) { 
839 
for(j=0;j<3;j++) 
840 
if ((ac3_freqs[j] >> i) == freq)

841 
goto found;

842 
} 
843 
return 1; 
844 
found:

845 
s>sample_rate = freq; 
846 
s>halfratecod = i; 
847 
s>fscod = j; 
848 
s>bsid = 8 + s>halfratecod;

849 
s>bsmod = 0; /* complete main audio service */ 
850  
851 
/* bitrate & frame size */

852 
bitrate /= 1000;

853 
for(i=0;i<19;i++) { 
854 
if ((ac3_bitratetab[i] >> s>halfratecod) == bitrate)

855 
break;

856 
} 
857 
if (i == 19) 
858 
return 1; 
859 
s>bit_rate = bitrate; 
860 
s>frmsizecod = i << 1;

861 
s>frame_size_min = (bitrate * 1000 * AC3_FRAME_SIZE) / (freq * 16); 
862 
/* for now we do not handle fractional sizes */

863 
s>frame_size = s>frame_size_min; 
864  
865 
/* bit allocation init */

866 
for(ch=0;ch<s>nb_channels;ch++) { 
867 
/* bandwidth for each channel */

868 
/* XXX: should compute the bandwidth according to the frame

869 
size, so that we avoid anoying high freq artefacts */

870 
s>chbwcod[ch] = 50; /* sample bandwidth as mpeg audio layer 2 table 0 */ 
871 
s>nb_coefs[ch] = ((s>chbwcod[ch] + 12) * 3) + 37; 
872 
} 
873 
if (s>lfe) {

874 
s>nb_coefs[s>lfe_channel] = 7; /* fixed */ 
875 
} 
876 
/* initial snr offset */

877 
s>csnroffst = 40;

878  
879 
ac3_common_init(); 
880  
881 
/* mdct init */

882 
fft_init(MDCT_NBITS  2);

883 
for(i=0;i<N/4;i++) { 
884 
alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N; 
885 
xcos1[i] = fix15(cos(alpha)); 
886 
xsin1[i] = fix15(sin(alpha)); 
887 
} 
888  
889 
ac3_crc_init(); 
890  
891 
avctx>coded_frame= avcodec_alloc_frame(); 
892 
avctx>coded_frame>key_frame= 1;

893  
894 
return 0; 
895 
} 
896  
897 
/* output the AC3 frame header */

898 
static void output_frame_header(AC3EncodeContext *s, unsigned char *frame) 
899 
{ 
900 
init_put_bits(&s>pb, frame, AC3_MAX_CODED_FRAME_SIZE); 
901  
902 
put_bits(&s>pb, 16, 0x0b77); /* frame header */ 
903 
put_bits(&s>pb, 16, 0); /* crc1: will be filled later */ 
904 
put_bits(&s>pb, 2, s>fscod);

905 
put_bits(&s>pb, 6, s>frmsizecod + (s>frame_size  s>frame_size_min));

906 
put_bits(&s>pb, 5, s>bsid);

907 
put_bits(&s>pb, 3, s>bsmod);

908 
put_bits(&s>pb, 3, s>acmod);

909 
if ((s>acmod & 0x01) && s>acmod != 0x01) 
910 
put_bits(&s>pb, 2, 1); /* XXX 4.5 dB */ 
911 
if (s>acmod & 0x04) 
912 
put_bits(&s>pb, 2, 1); /* XXX 6 dB */ 
913 
if (s>acmod == 0x02) 
914 
put_bits(&s>pb, 2, 0); /* surround not indicated */ 
915 
put_bits(&s>pb, 1, s>lfe); /* LFE */ 
916 
put_bits(&s>pb, 5, 31); /* dialog norm: 31 db */ 
917 
put_bits(&s>pb, 1, 0); /* no compression control word */ 
918 
put_bits(&s>pb, 1, 0); /* no lang code */ 
919 
put_bits(&s>pb, 1, 0); /* no audio production info */ 
920 
put_bits(&s>pb, 1, 0); /* no copyright */ 
921 
put_bits(&s>pb, 1, 1); /* original bitstream */ 
922 
put_bits(&s>pb, 1, 0); /* no time code 1 */ 
923 
put_bits(&s>pb, 1, 0); /* no time code 2 */ 
924 
put_bits(&s>pb, 1, 0); /* no addtional bit stream info */ 
925 
} 
926  
927 
/* symetric quantization on 'levels' levels */

928 
static inline int sym_quant(int c, int e, int levels) 
929 
{ 
930 
int v;

931  
932 
if (c >= 0) { 
933 
v = (levels * (c << e)) >> 24;

934 
v = (v + 1) >> 1; 
935 
v = (levels >> 1) + v;

936 
} else {

937 
v = (levels * ((c) << e)) >> 24;

938 
v = (v + 1) >> 1; 
939 
v = (levels >> 1)  v;

940 
} 
941 
assert (v >= 0 && v < levels);

942 
return v;

943 
} 
944  
945 
/* asymetric quantization on 2^qbits levels */

946 
static inline int asym_quant(int c, int e, int qbits) 
947 
{ 
948 
int lshift, m, v;

949  
950 
lshift = e + qbits  24;

951 
if (lshift >= 0) 
952 
v = c << lshift; 
953 
else

954 
v = c >> (lshift); 
955 
/* rounding */

956 
v = (v + 1) >> 1; 
957 
m = (1 << (qbits1)); 
958 
if (v >= m)

959 
v = m  1;

960 
assert(v >= m); 
961 
return v & ((1 << qbits)1); 
962 
} 
963  
964 
/* Output one audio block. There are NB_BLOCKS audio blocks in one AC3

965 
frame */

966 
static void output_audio_block(AC3EncodeContext *s, 
967 
uint8_t exp_strategy[AC3_MAX_CHANNELS], 
968 
uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2],

969 
uint8_t bap[AC3_MAX_CHANNELS][N/2],

970 
int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2],

971 
int8_t global_exp[AC3_MAX_CHANNELS], 
972 
int block_num)

973 
{ 
974 
int ch, nb_groups, group_size, i, baie, rbnd;

975 
uint8_t *p; 
976 
uint16_t qmant[AC3_MAX_CHANNELS][N/2];

977 
int exp0, exp1;

978 
int mant1_cnt, mant2_cnt, mant4_cnt;

979 
uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; 
980 
int delta0, delta1, delta2;

981  
982 
for(ch=0;ch<s>nb_channels;ch++) 
983 
put_bits(&s>pb, 1, 0); /* 512 point MDCT */ 
984 
for(ch=0;ch<s>nb_channels;ch++) 
985 
put_bits(&s>pb, 1, 1); /* no dither */ 
986 
put_bits(&s>pb, 1, 0); /* no dynamic range */ 
987 
if (block_num == 0) { 
988 
/* for block 0, even if no coupling, we must say it. This is a

989 
waste of bit :) */

990 
put_bits(&s>pb, 1, 1); /* coupling strategy present */ 
991 
put_bits(&s>pb, 1, 0); /* no coupling strategy */ 
992 
} else {

993 
put_bits(&s>pb, 1, 0); /* no new coupling strategy */ 
994 
} 
995  
996 
if (s>acmod == 2) 
997 
{ 
998 
if(block_num==0) 
999 
{ 
1000 
/* first block must define rematrixing (rematstr) */

1001 
put_bits(&s>pb, 1, 1); 
1002  
1003 
/* dummy rematrixing rematflg(1:4)=0 */

1004 
for (rbnd=0;rbnd<4;rbnd++) 
1005 
put_bits(&s>pb, 1, 0); 
1006 
} 
1007 
else

1008 
{ 
1009 
/* no matrixing (but should be used in the future) */

1010 
put_bits(&s>pb, 1, 0); 
1011 
} 
1012 
} 
1013  
1014 
#if defined(DEBUG)

1015 
{ 
1016 
static int count = 0; 
1017 
av_log(NULL, AV_LOG_DEBUG, "Block #%d (%d)\n", block_num, count++); 
1018 
} 
1019 
#endif

1020 
/* exponent strategy */

1021 
for(ch=0;ch<s>nb_channels;ch++) { 
1022 
put_bits(&s>pb, 2, exp_strategy[ch]);

1023 
} 
1024  
1025 
if (s>lfe) {

1026 
put_bits(&s>pb, 1, exp_strategy[s>lfe_channel]);

1027 
} 
1028  
1029 
for(ch=0;ch<s>nb_channels;ch++) { 
1030 
if (exp_strategy[ch] != EXP_REUSE)

1031 
put_bits(&s>pb, 6, s>chbwcod[ch]);

1032 
} 
1033  
1034 
/* exponents */

1035 
for (ch = 0; ch < s>nb_all_channels; ch++) { 
1036 
switch(exp_strategy[ch]) {

1037 
case EXP_REUSE:

1038 
continue;

1039 
case EXP_D15:

1040 
group_size = 1;

1041 
break;

1042 
case EXP_D25:

1043 
group_size = 2;

1044 
break;

1045 
default:

1046 
case EXP_D45:

1047 
group_size = 4;

1048 
break;

1049 
} 
1050 
nb_groups = (s>nb_coefs[ch] + (group_size * 3)  4) / (3 * group_size); 
1051 
p = encoded_exp[ch]; 
1052  
1053 
/* first exponent */

1054 
exp1 = *p++; 
1055 
put_bits(&s>pb, 4, exp1);

1056  
1057 
/* next ones are delta encoded */

1058 
for(i=0;i<nb_groups;i++) { 
1059 
/* merge three delta in one code */

1060 
exp0 = exp1; 
1061 
exp1 = p[0];

1062 
p += group_size; 
1063 
delta0 = exp1  exp0 + 2;

1064  
1065 
exp0 = exp1; 
1066 
exp1 = p[0];

1067 
p += group_size; 
1068 
delta1 = exp1  exp0 + 2;

1069  
1070 
exp0 = exp1; 
1071 
exp1 = p[0];

1072 
p += group_size; 
1073 
delta2 = exp1  exp0 + 2;

1074  
1075 
put_bits(&s>pb, 7, ((delta0 * 5 + delta1) * 5) + delta2); 
1076 
} 
1077  
1078 
if (ch != s>lfe_channel)

1079 
put_bits(&s>pb, 2, 0); /* no gain range info */ 
1080 
} 
1081  
1082 
/* bit allocation info */

1083 
baie = (block_num == 0);

1084 
put_bits(&s>pb, 1, baie);

1085 
if (baie) {

1086 
put_bits(&s>pb, 2, s>sdecaycod);

1087 
put_bits(&s>pb, 2, s>fdecaycod);

1088 
put_bits(&s>pb, 2, s>sgaincod);

1089 
put_bits(&s>pb, 2, s>dbkneecod);

1090 
put_bits(&s>pb, 3, s>floorcod);

1091 
} 
1092  
1093 
/* snr offset */

1094 
put_bits(&s>pb, 1, baie); /* always present with bai */ 
1095 
if (baie) {

1096 
put_bits(&s>pb, 6, s>csnroffst);

1097 
for(ch=0;ch<s>nb_all_channels;ch++) { 
1098 
put_bits(&s>pb, 4, s>fsnroffst[ch]);

1099 
put_bits(&s>pb, 3, s>fgaincod[ch]);

1100 
} 
1101 
} 
1102  
1103 
put_bits(&s>pb, 1, 0); /* no delta bit allocation */ 
1104 
put_bits(&s>pb, 1, 0); /* no data to skip */ 
1105  
1106 
/* mantissa encoding : we use two passes to handle the grouping. A

1107 
one pass method may be faster, but it would necessitate to

1108 
modify the output stream. */

1109  
1110 
/* first pass: quantize */

1111 
mant1_cnt = mant2_cnt = mant4_cnt = 0;

1112 
qmant1_ptr = qmant2_ptr = qmant4_ptr = NULL;

1113  
1114 
for (ch = 0; ch < s>nb_all_channels; ch++) { 
1115 
int b, c, e, v;

1116  
1117 
for(i=0;i<s>nb_coefs[ch];i++) { 
1118 
c = mdct_coefs[ch][i]; 
1119 
e = encoded_exp[ch][i]  global_exp[ch]; 
1120 
b = bap[ch][i]; 
1121 
switch(b) {

1122 
case 0: 
1123 
v = 0;

1124 
break;

1125 
case 1: 
1126 
v = sym_quant(c, e, 3);

1127 
switch(mant1_cnt) {

1128 
case 0: 
1129 
qmant1_ptr = &qmant[ch][i]; 
1130 
v = 9 * v;

1131 
mant1_cnt = 1;

1132 
break;

1133 
case 1: 
1134 
*qmant1_ptr += 3 * v;

1135 
mant1_cnt = 2;

1136 
v = 128;

1137 
break;

1138 
default:

1139 
*qmant1_ptr += v; 
1140 
mant1_cnt = 0;

1141 
v = 128;

1142 
break;

1143 
} 
1144 
break;

1145 
case 2: 
1146 
v = sym_quant(c, e, 5);

1147 
switch(mant2_cnt) {

1148 
case 0: 
1149 
qmant2_ptr = &qmant[ch][i]; 
1150 
v = 25 * v;

1151 
mant2_cnt = 1;

1152 
break;

1153 
case 1: 
1154 
*qmant2_ptr += 5 * v;

1155 
mant2_cnt = 2;

1156 
v = 128;

1157 
break;

1158 
default:

1159 
*qmant2_ptr += v; 
1160 
mant2_cnt = 0;

1161 
v = 128;

1162 
break;

1163 
} 
1164 
break;

1165 
case 3: 
1166 
v = sym_quant(c, e, 7);

1167 
break;

1168 
case 4: 
1169 
v = sym_quant(c, e, 11);

1170 
switch(mant4_cnt) {

1171 
case 0: 
1172 
qmant4_ptr = &qmant[ch][i]; 
1173 
v = 11 * v;

1174 
mant4_cnt = 1;

1175 
break;

1176 
default:

1177 
*qmant4_ptr += v; 
1178 
mant4_cnt = 0;

1179 
v = 128;

1180 
break;

1181 
} 
1182 
break;

1183 
case 5: 
1184 
v = sym_quant(c, e, 15);

1185 
break;

1186 
case 14: 
1187 
v = asym_quant(c, e, 14);

1188 
break;

1189 
case 15: 
1190 
v = asym_quant(c, e, 16);

1191 
break;

1192 
default:

1193 
v = asym_quant(c, e, b  1);

1194 
break;

1195 
} 
1196 
qmant[ch][i] = v; 
1197 
} 
1198 
} 
1199  
1200 
/* second pass : output the values */

1201 
for (ch = 0; ch < s>nb_all_channels; ch++) { 
1202 
int b, q;

1203  
1204 
for(i=0;i<s>nb_coefs[ch];i++) { 
1205 
q = qmant[ch][i]; 
1206 
b = bap[ch][i]; 
1207 
switch(b) {

1208 
case 0: 
1209 
break;

1210 
case 1: 
1211 
if (q != 128) 
1212 
put_bits(&s>pb, 5, q);

1213 
break;

1214 
case 2: 
1215 
if (q != 128) 
1216 
put_bits(&s>pb, 7, q);

1217 
break;

1218 
case 3: 
1219 
put_bits(&s>pb, 3, q);

1220 
break;

1221 
case 4: 
1222 
if (q != 128) 
1223 
put_bits(&s>pb, 7, q);

1224 
break;

1225 
case 14: 
1226 
put_bits(&s>pb, 14, q);

1227 
break;

1228 
case 15: 
1229 
put_bits(&s>pb, 16, q);

1230 
break;

1231 
default:

1232 
put_bits(&s>pb, b  1, q);

1233 
break;

1234 
} 
1235 
} 
1236 
} 
1237 
} 
1238  
1239 
/* compute the ac3 crc */

1240  
1241 
#define CRC16_POLY ((1 << 0)  (1 << 2)  (1 << 15)  (1 << 16)) 
1242  
1243 
static void ac3_crc_init(void) 
1244 
{ 
1245 
unsigned int c, n, k; 
1246  
1247 
for(n=0;n<256;n++) { 
1248 
c = n << 8;

1249 
for (k = 0; k < 8; k++) { 
1250 
if (c & (1 << 15)) 
1251 
c = ((c << 1) & 0xffff) ^ (CRC16_POLY & 0xffff); 
1252 
else

1253 
c = c << 1;

1254 
} 
1255 
crc_table[n] = c; 
1256 
} 
1257 
} 
1258  
1259 
static unsigned int ac3_crc(uint8_t *data, int n, unsigned int crc) 
1260 
{ 
1261 
int i;

1262 
for(i=0;i<n;i++) { 
1263 
crc = (crc_table[data[i] ^ (crc >> 8)] ^ (crc << 8)) & 0xffff; 
1264 
} 
1265 
return crc;

1266 
} 
1267  
1268 
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) 
1269 
{ 
1270 
unsigned int c; 
1271  
1272 
c = 0;

1273 
while (a) {

1274 
if (a & 1) 
1275 
c ^= b; 
1276 
a = a >> 1;

1277 
b = b << 1;

1278 
if (b & (1 << 16)) 
1279 
b ^= poly; 
1280 
} 
1281 
return c;

1282 
} 
1283  
1284 
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) 
1285 
{ 
1286 
unsigned int r; 
1287 
r = 1;

1288 
while (n) {

1289 
if (n & 1) 
1290 
r = mul_poly(r, a, poly); 
1291 
a = mul_poly(a, a, poly); 
1292 
n >>= 1;

1293 
} 
1294 
return r;

1295 
} 
1296  
1297  
1298 
/* compute log2(max(abs(tab[]))) */

1299 
static int log2_tab(int16_t *tab, int n) 
1300 
{ 
1301 
int i, v;

1302  
1303 
v = 0;

1304 
for(i=0;i<n;i++) { 
1305 
v = abs(tab[i]); 
1306 
} 
1307 
return av_log2(v);

1308 
} 
1309  
1310 
static void lshift_tab(int16_t *tab, int n, int lshift) 
1311 
{ 
1312 
int i;

1313  
1314 
if (lshift > 0) { 
1315 
for(i=0;i<n;i++) { 
1316 
tab[i] <<= lshift; 
1317 
} 
1318 
} else if (lshift < 0) { 
1319 
lshift = lshift; 
1320 
for(i=0;i<n;i++) { 
1321 
tab[i] >>= lshift; 
1322 
} 
1323 
} 
1324 
} 
1325  
1326 
/* fill the end of the frame and compute the two crcs */

1327 
static int output_frame_end(AC3EncodeContext *s) 
1328 
{ 
1329 
int frame_size, frame_size_58, n, crc1, crc2, crc_inv;

1330 
uint8_t *frame; 
1331  
1332 
frame_size = s>frame_size; /* frame size in words */

1333 
/* align to 8 bits */

1334 
flush_put_bits(&s>pb); 
1335 
/* add zero bytes to reach the frame size */

1336 
frame = s>pb.buf; 
1337 
n = 2 * s>frame_size  (pbBufPtr(&s>pb)  frame)  2; 
1338 
assert(n >= 0);

1339 
if(n>0) 
1340 
memset(pbBufPtr(&s>pb), 0, n);

1341  
1342 
/* Now we must compute both crcs : this is not so easy for crc1

1343 
because it is at the beginning of the data... */

1344 
frame_size_58 = (frame_size >> 1) + (frame_size >> 3); 
1345 
crc1 = ac3_crc(frame + 4, (2 * frame_size_58)  4, 0); 
1346 
/* XXX: could precompute crc_inv */

1347 
crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58)  16, CRC16_POLY); 
1348 
crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); 
1349 
frame[2] = crc1 >> 8; 
1350 
frame[3] = crc1;

1351  
1352 
crc2 = ac3_crc(frame + 2 * frame_size_58, (frame_size  frame_size_58) * 2  2, 0); 
1353 
frame[2*frame_size  2] = crc2 >> 8; 
1354 
frame[2*frame_size  1] = crc2; 
1355  
1356 
// printf("n=%d frame_size=%d\n", n, frame_size);

1357 
return frame_size * 2; 
1358 
} 
1359  
1360 
static int AC3_encode_frame(AVCodecContext *avctx, 
1361 
unsigned char *frame, int buf_size, void *data) 
1362 
{ 
1363 
AC3EncodeContext *s = avctx>priv_data; 
1364 
int16_t *samples = data; 
1365 
int i, j, k, v, ch;

1366 
int16_t input_samples[N]; 
1367 
int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];

1368 
uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];

1369 
uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]; 
1370 
uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];

1371 
uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];

1372 
int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS]; 
1373 
int frame_bits;

1374  
1375 
frame_bits = 0;

1376 
for(ch=0;ch<s>nb_all_channels;ch++) { 
1377 
/* fixed mdct to the six sub blocks & exponent computation */

1378 
for(i=0;i<NB_BLOCKS;i++) { 
1379 
int16_t *sptr; 
1380 
int sinc;

1381  
1382 
/* compute input samples */

1383 
memcpy(input_samples, s>last_samples[ch], N/2 * sizeof(int16_t)); 
1384 
sinc = s>nb_all_channels; 
1385 
sptr = samples + (sinc * (N/2) * i) + ch;

1386 
for(j=0;j<N/2;j++) { 
1387 
v = *sptr; 
1388 
input_samples[j + N/2] = v;

1389 
s>last_samples[ch][j] = v; 
1390 
sptr += sinc; 
1391 
} 
1392  
1393 
/* apply the MDCT window */

1394 
for(j=0;j<N/2;j++) { 
1395 
input_samples[j] = MUL16(input_samples[j], 
1396 
ac3_window[j]) >> 15;

1397 
input_samples[Nj1] = MUL16(input_samples[Nj1], 
1398 
ac3_window[j]) >> 15;

1399 
} 
1400  
1401 
/* Normalize the samples to use the maximum available

1402 
precision */

1403 
v = 14  log2_tab(input_samples, N);

1404 
if (v < 0) 
1405 
v = 0;

1406 
exp_samples[i][ch] = v  8;

1407 
lshift_tab(input_samples, N, v); 
1408  
1409 
/* do the MDCT */

1410 
mdct512(mdct_coef[i][ch], input_samples); 
1411  
1412 
/* compute "exponents". We take into account the

1413 
normalization there */

1414 
for(j=0;j<N/2;j++) { 
1415 
int e;

1416 
v = abs(mdct_coef[i][ch][j]); 
1417 
if (v == 0) 
1418 
e = 24;

1419 
else {

1420 
e = 23  av_log2(v) + exp_samples[i][ch];

1421 
if (e >= 24) { 
1422 
e = 24;

1423 
mdct_coef[i][ch][j] = 0;

1424 
} 
1425 
} 
1426 
exp[i][ch][j] = e; 
1427 
} 
1428 
} 
1429  
1430 
compute_exp_strategy(exp_strategy, exp, ch, ch == s>lfe_channel); 
1431  
1432 
/* compute the exponents as the decoder will see them. The

1433 
EXP_REUSE case must be handled carefully : we select the

1434 
min of the exponents */

1435 
i = 0;

1436 
while (i < NB_BLOCKS) {

1437 
j = i + 1;

1438 
while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) {

1439 
exponent_min(exp[i][ch], exp[j][ch], s>nb_coefs[ch]); 
1440 
j++; 
1441 
} 
1442 
frame_bits += encode_exp(encoded_exp[i][ch], 
1443 
exp[i][ch], s>nb_coefs[ch], 
1444 
exp_strategy[i][ch]); 
1445 
/* copy encoded exponents for reuse case */

1446 
for(k=i+1;k<j;k++) { 
1447 
memcpy(encoded_exp[k][ch], encoded_exp[i][ch], 
1448 
s>nb_coefs[ch] * sizeof(uint8_t));

1449 
} 
1450 
i = j; 
1451 
} 
1452 
} 
1453  
1454 
compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits); 
1455 
/* everything is known... let's output the frame */

1456 
output_frame_header(s, frame); 
1457  
1458 
for(i=0;i<NB_BLOCKS;i++) { 
1459 
output_audio_block(s, exp_strategy[i], encoded_exp[i], 
1460 
bap[i], mdct_coef[i], exp_samples[i], i); 
1461 
} 
1462 
return output_frame_end(s);

1463 
} 
1464  
1465 
static int AC3_encode_close(AVCodecContext *avctx) 
1466 
{ 
1467 
av_freep(&avctx>coded_frame); 
1468 
return 0; 
1469 
} 
1470  
1471 
#if 0

1472 
/*************************************************************************/

1473 
/* TEST */

1474 

1475 
#define FN (N/4)

1476 

1477 
void fft_test(void)

1478 
{

1479 
IComplex in[FN], in1[FN];

1480 
int k, n, i;

1481 
float sum_re, sum_im, a;

1482 

1483 
/* FFT test */

1484 

1485 
for(i=0;i<FN;i++) {

1486 
in[i].re = random() % 65535  32767;

1487 
in[i].im = random() % 65535  32767;

1488 
in1[i] = in[i];

1489 
}

1490 
fft(in, 7);

1491 

1492 
/* do it by hand */

1493 
for(k=0;k<FN;k++) {

1494 
sum_re = 0;

1495 
sum_im = 0;

1496 
for(n=0;n<FN;n++) {

1497 
a = 2 * M_PI * (n * k) / FN;

1498 
sum_re += in1[n].re * cos(a)  in1[n].im * sin(a);

1499 
sum_im += in1[n].re * sin(a) + in1[n].im * cos(a);

1500 
}

1501 
printf("%3d: %6d,%6d %6.0f,%6.0f\n",

1502 
k, in[k].re, in[k].im, sum_re / FN, sum_im / FN);

1503 
}

1504 
}

1505 

1506 
void mdct_test(void)

1507 
{

1508 
int16_t input[N];

1509 
int32_t output[N/2];

1510 
float input1[N];

1511 
float output1[N/2];

1512 
float s, a, err, e, emax;

1513 
int i, k, n;

1514 

1515 
for(i=0;i<N;i++) {

1516 
input[i] = (random() % 65535  32767) * 9 / 10;

1517 
input1[i] = input[i];

1518 
}

1519 

1520 
mdct512(output, input);

1521 

1522 
/* do it by hand */

1523 
for(k=0;k<N/2;k++) {

1524 
s = 0;

1525 
for(n=0;n<N;n++) {

1526 
a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N));

1527 
s += input1[n] * cos(a);

1528 
}

1529 
output1[k] = 2 * s / N;

1530 
}

1531 

1532 
err = 0;

1533 
emax = 0;

1534 
for(i=0;i<N/2;i++) {

1535 
printf("%3d: %7d %7.0f\n", i, output[i], output1[i]);

1536 
e = output[i]  output1[i];

1537 
if (e > emax)

1538 
emax = e;

1539 
err += e * e;

1540 
}

1541 
printf("err2=%f emax=%f\n", err / (N/2), emax);

1542 
}

1543 

1544 
void test_ac3(void)

1545 
{

1546 
AC3EncodeContext ctx;

1547 
unsigned char frame[AC3_MAX_CODED_FRAME_SIZE];

1548 
short samples[AC3_FRAME_SIZE];

1549 
int ret, i;

1550 

1551 
AC3_encode_init(&ctx, 44100, 64000, 1);

1552 

1553 
fft_test();

1554 
mdct_test();

1555 

1556 
for(i=0;i<AC3_FRAME_SIZE;i++)

1557 
samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000);

1558 
ret = AC3_encode_frame(&ctx, frame, samples);

1559 
printf("ret=%d\n", ret);

1560 
}

1561 
#endif

1562  
1563 
AVCodec ac3_encoder = { 
1564 
"ac3",

1565 
CODEC_TYPE_AUDIO, 
1566 
CODEC_ID_AC3, 
1567 
sizeof(AC3EncodeContext),

1568 
AC3_encode_init, 
1569 
AC3_encode_frame, 
1570 
AC3_encode_close, 
1571 
NULL,

1572 
}; 