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 02110-1301 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=v-v1; |
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[end-1] + 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) << (ln-j-1); |
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 .. ln-1 */
|
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[N-1-2*i]) >> 1; |
427 |
im = -((int)rot[N/2+2*i] - (int)rot[N/2-1-2*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/2-1-2*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[i-1][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[i-1] + 2); |
557 |
for (i=nb_groups-1;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 |
(((csnroffst-15) << 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 << (qbits-1)); |
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[N-j-1] = MUL16(input_samples[N-j-1], |
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 |
}; |