Mercurial > libavcodec.hg
annotate ac3enc.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 582e635cfa08 |
children | 6ff5dc0dbaf0 |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest AC3 encoder | |
429 | 3 * Copyright (c) 2000 Fabrice Bellard. |
0 | 4 * |
429 | 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. | |
0 | 9 * |
429 | 10 * This library is distributed in the hope that it will be useful, |
0 | 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 * Lesser General Public License for more details. | |
0 | 14 * |
429 | 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 18 */ |
1106 | 19 |
20 /** | |
21 * @file ac3enc.c | |
22 * The simplest AC3 encoder. | |
23 */ | |
64 | 24 //#define DEBUG |
25 //#define DEBUG_BITALLOC | |
26 #include "avcodec.h" | |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2367
diff
changeset
|
27 #include "bitstream.h" |
782 | 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; | |
1057 | 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 */ | |
782 | 40 int halfratecod; |
1057 | 41 unsigned int frmsizecod; |
42 unsigned int fscod; /* frequency */ | |
43 unsigned int acmod; | |
782 | 44 int lfe; |
1057 | 45 unsigned int bsmod; |
782 | 46 short last_samples[AC3_MAX_CHANNELS][256]; |
1057 | 47 unsigned int chbwcod[AC3_MAX_CHANNELS]; |
782 | 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 | |
0 | 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 | |
1064 | 71 static inline int16_t fix15(float a) |
0 | 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 | |
782 | 117 spec. */ |
1064 | 118 void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap, |
119 int8_t *exp, int start, int end, | |
782 | 120 int snroffset, int fgain, int is_lfe, |
121 int deltbae,int deltnseg, | |
1064 | 122 uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba) |
0 | 123 { |
124 int bin,i,j,k,end1,v,v1,bndstrt,bndend,lowcomp,begin; | |
125 int fastleak,slowleak,address,tmp; | |
1064 | 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 */ | |
0 | 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 | |
782 | 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; | |
0 | 191 |
782 | 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; | |
0 | 203 |
782 | 204 v=fastleak - lowcomp; |
205 if (slowleak > v) v=slowleak; | |
0 | 206 |
782 | 207 excite[bin] = v; |
208 } | |
209 begin = 22; | |
210 } else { | |
211 /* coupling channel */ | |
212 begin = bndstrt; | |
0 | 213 |
782 | 214 fastleak = (s->cplfleak << 8) + 768; |
215 slowleak = (s->cplsleak << 8) + 768; | |
0 | 216 } |
217 | |
782 | 218 for (bin = begin; bin < bndend; bin++) { |
0 | 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 | |
782 | 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 | |
0 | 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 */ | |
1064 | 412 static void mdct512(int32_t *out, int16_t *in) |
0 | 413 { |
414 int i, re, im, re1, im1; | |
1064 | 415 int16_t rot[N]; |
0 | 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 ? */ | |
1064 | 444 static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n) |
0 | 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 | |
1064 | 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], | |
314 | 456 int ch, int is_lfe) |
0 | 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 | |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
467 av_log(NULL, AV_LOG_DEBUG, "exp_diff=%d\n", exp_diff); |
0 | 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 } | |
314 | 474 if (is_lfe) |
475 return; | |
476 | |
0 | 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 } | |
314 | 496 i = j; |
0 | 497 } |
498 } | |
499 | |
500 /* set exp[i] to min(exp[i], exp1[i]) */ | |
1064 | 501 static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n) |
0 | 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 */ | |
1064 | 513 static int encode_exp(uint8_t encoded_exp[N/2], |
514 uint8_t exp[N/2], | |
0 | 515 int nb_exps, |
516 int exp_strategy) | |
517 { | |
2157
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
518 int group_size, nb_groups, i, j, k, exp_min; |
1064 | 519 uint8_t exp1[N/2]; |
0 | 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 | |
2157
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
553 /* Decrease the delta between each groups to within 2 |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
554 * so that they can be differentially encoded */ |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
555 for (i=1;i<=nb_groups;i++) |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
556 exp1[i] = FFMIN(exp1[i], exp1[i-1] + 2); |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
557 for (i=nb_groups-1;i>=0;i--) |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
558 exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2); |
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
559 |
0 | 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) | |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
571 av_log(NULL, AV_LOG_DEBUG, "exponents: strategy=%d\n", exp_strategy); |
0 | 572 for(i=0;i<=nb_groups * group_size;i++) { |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
573 av_log(NULL, AV_LOG_DEBUG, "%d ", encoded_exp[i]); |
0 | 574 } |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
575 av_log(NULL, AV_LOG_DEBUG, "\n"); |
0 | 576 #endif |
577 | |
578 return 4 + (nb_groups / 3) * 7; | |
579 } | |
580 | |
581 /* return the size in bits taken by the mantissa */ | |
1064 | 582 static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs) |
0 | 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, | |
1064 | 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], | |
0 | 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; | |
314 | 645 for(ch=0;ch<s->nb_all_channels;ch++) { |
782 | 646 ac3_parametric_bit_allocation(&s->bit_alloc, |
1064 | 647 bap[i][ch], (int8_t *)encoded_exp[i][ch], |
782 | 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); | |
0 | 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, | |
1064 | 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], | |
0 | 672 int frame_bits) |
673 { | |
674 int i, ch; | |
675 int csnroffst, fsnroffst; | |
1064 | 676 uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; |
314 | 677 static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; |
0 | 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; | |
314 | 685 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 686 s->fgaincod[ch] = 4; |
687 | |
688 /* compute real values */ | |
782 | 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 | |
0 | 697 /* header size */ |
698 frame_bits += 65; | |
314 | 699 // if (s->acmod == 2) |
700 // frame_bits += 2; | |
701 frame_bits += frame_bits_inc[s->acmod]; | |
0 | 702 |
703 /* audio blocks */ | |
704 for(i=0;i<NB_BLOCKS;i++) { | |
314 | 705 frame_bits += s->nb_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ |
0 | 706 if (s->acmod == 2) |
314 | 707 frame_bits++; /* rematstr */ |
708 frame_bits += 2 * s->nb_channels; /* chexpstr[2] * c */ | |
709 if (s->lfe) | |
710 frame_bits++; /* lfeexpstr */ | |
0 | 711 for(ch=0;ch<s->nb_channels;ch++) { |
712 if (exp_strategy[i][ch] != EXP_REUSE) | |
314 | 713 frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ |
0 | 714 } |
715 frame_bits++; /* baie */ | |
716 frame_bits++; /* snr */ | |
717 frame_bits += 2; /* delta / skip */ | |
718 } | |
719 frame_bits++; /* cplinu for block 0 */ | |
720 /* bit alloc info */ | |
314 | 721 /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */ |
722 /* csnroffset[6] */ | |
723 /* (fsnoffset[4] + fgaincod[4]) * c */ | |
724 frame_bits += 2*4 + 3 + 6 + s->nb_all_channels * (4 + 3); | |
0 | 725 |
1819
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
726 /* auxdatae, crcrsv */ |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
727 frame_bits += 2; |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
728 |
0 | 729 /* CRC */ |
730 frame_bits += 16; | |
731 | |
732 /* now the big work begins : do the bit allocation. Modify the snr | |
733 offset until we can pack everything in the requested frame size */ | |
734 | |
735 csnroffst = s->csnroffst; | |
736 while (csnroffst >= 0 && | |
314 | 737 bit_alloc(s, bap, encoded_exp, exp_strategy, frame_bits, csnroffst, 0) < 0) |
738 csnroffst -= SNR_INC1; | |
0 | 739 if (csnroffst < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1522
diff
changeset
|
740 av_log(NULL, AV_LOG_ERROR, "Yack, Error !!!\n"); |
314 | 741 return -1; |
0 | 742 } |
743 while ((csnroffst + SNR_INC1) <= 63 && | |
744 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
745 csnroffst + SNR_INC1, 0) >= 0) { | |
746 csnroffst += SNR_INC1; | |
747 memcpy(bap, bap1, sizeof(bap1)); | |
748 } | |
749 while ((csnroffst + 1) <= 63 && | |
750 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, csnroffst + 1, 0) >= 0) { | |
751 csnroffst++; | |
752 memcpy(bap, bap1, sizeof(bap1)); | |
753 } | |
754 | |
755 fsnroffst = 0; | |
756 while ((fsnroffst + SNR_INC1) <= 15 && | |
757 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
758 csnroffst, fsnroffst + SNR_INC1) >= 0) { | |
759 fsnroffst += SNR_INC1; | |
760 memcpy(bap, bap1, sizeof(bap1)); | |
761 } | |
762 while ((fsnroffst + 1) <= 15 && | |
763 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
764 csnroffst, fsnroffst + 1) >= 0) { | |
765 fsnroffst++; | |
766 memcpy(bap, bap1, sizeof(bap1)); | |
767 } | |
768 | |
769 s->csnroffst = csnroffst; | |
314 | 770 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 771 s->fsnroffst[ch] = fsnroffst; |
772 #if defined(DEBUG_BITALLOC) | |
773 { | |
774 int j; | |
775 | |
776 for(i=0;i<6;i++) { | |
314 | 777 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 778 printf("Block #%d Ch%d:\n", i, ch); |
779 printf("bap="); | |
780 for(j=0;j<s->nb_coefs[ch];j++) { | |
781 printf("%d ",bap[i][ch][j]); | |
782 } | |
783 printf("\n"); | |
784 } | |
785 } | |
786 } | |
787 #endif | |
788 return 0; | |
789 } | |
790 | |
782 | 791 void ac3_common_init(void) |
792 { | |
793 int i, j, k, l, v; | |
794 /* compute bndtab and masktab from bandsz */ | |
795 k = 0; | |
796 l = 0; | |
797 for(i=0;i<50;i++) { | |
798 bndtab[i] = l; | |
799 v = bndsz[i]; | |
800 for(j=0;j<v;j++) masktab[k++]=i; | |
801 l += v; | |
802 } | |
803 bndtab[50] = 0; | |
804 } | |
805 | |
806 | |
0 | 807 static int AC3_encode_init(AVCodecContext *avctx) |
808 { | |
809 int freq = avctx->sample_rate; | |
810 int bitrate = avctx->bit_rate; | |
811 int channels = avctx->channels; | |
812 AC3EncodeContext *s = avctx->priv_data; | |
782 | 813 int i, j, ch; |
0 | 814 float alpha; |
1064 | 815 static const uint8_t acmod_defs[6] = { |
314 | 816 0x01, /* C */ |
817 0x02, /* L R */ | |
818 0x03, /* L C R */ | |
819 0x06, /* L R SL SR */ | |
820 0x07, /* L C R SL SR */ | |
821 0x07, /* L C R SL SR (+LFE) */ | |
822 }; | |
0 | 823 |
824 avctx->frame_size = AC3_FRAME_SIZE; | |
825 | |
826 /* number of channels */ | |
314 | 827 if (channels < 1 || channels > 6) |
828 return -1; | |
829 s->acmod = acmod_defs[channels - 1]; | |
830 s->lfe = (channels == 6) ? 1 : 0; | |
831 s->nb_all_channels = channels; | |
832 s->nb_channels = channels > 5 ? 5 : channels; | |
833 s->lfe_channel = s->lfe ? 5 : -1; | |
0 | 834 |
835 /* frequency */ | |
836 for(i=0;i<3;i++) { | |
837 for(j=0;j<3;j++) | |
782 | 838 if ((ac3_freqs[j] >> i) == freq) |
0 | 839 goto found; |
840 } | |
841 return -1; | |
842 found: | |
843 s->sample_rate = freq; | |
844 s->halfratecod = i; | |
845 s->fscod = j; | |
846 s->bsid = 8 + s->halfratecod; | |
847 s->bsmod = 0; /* complete main audio service */ | |
848 | |
849 /* bitrate & frame size */ | |
850 bitrate /= 1000; | |
851 for(i=0;i<19;i++) { | |
782 | 852 if ((ac3_bitratetab[i] >> s->halfratecod) == bitrate) |
0 | 853 break; |
854 } | |
855 if (i == 19) | |
856 return -1; | |
857 s->bit_rate = bitrate; | |
858 s->frmsizecod = i << 1; | |
859 s->frame_size_min = (bitrate * 1000 * AC3_FRAME_SIZE) / (freq * 16); | |
860 /* for now we do not handle fractional sizes */ | |
861 s->frame_size = s->frame_size_min; | |
862 | |
863 /* bit allocation init */ | |
864 for(ch=0;ch<s->nb_channels;ch++) { | |
865 /* bandwidth for each channel */ | |
866 /* XXX: should compute the bandwidth according to the frame | |
867 size, so that we avoid anoying high freq artefacts */ | |
868 s->chbwcod[ch] = 50; /* sample bandwidth as mpeg audio layer 2 table 0 */ | |
869 s->nb_coefs[ch] = ((s->chbwcod[ch] + 12) * 3) + 37; | |
870 } | |
314 | 871 if (s->lfe) { |
872 s->nb_coefs[s->lfe_channel] = 7; /* fixed */ | |
873 } | |
0 | 874 /* initial snr offset */ |
875 s->csnroffst = 40; | |
876 | |
782 | 877 ac3_common_init(); |
0 | 878 |
879 /* mdct init */ | |
880 fft_init(MDCT_NBITS - 2); | |
881 for(i=0;i<N/4;i++) { | |
882 alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N; | |
883 xcos1[i] = fix15(-cos(alpha)); | |
884 xsin1[i] = fix15(-sin(alpha)); | |
885 } | |
886 | |
887 ac3_crc_init(); | |
925 | 888 |
889 avctx->coded_frame= avcodec_alloc_frame(); | |
890 avctx->coded_frame->key_frame= 1; | |
0 | 891 |
892 return 0; | |
893 } | |
894 | |
895 /* output the AC3 frame header */ | |
896 static void output_frame_header(AC3EncodeContext *s, unsigned char *frame) | |
897 { | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1408
diff
changeset
|
898 init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE); |
0 | 899 |
900 put_bits(&s->pb, 16, 0x0b77); /* frame header */ | |
901 put_bits(&s->pb, 16, 0); /* crc1: will be filled later */ | |
902 put_bits(&s->pb, 2, s->fscod); | |
903 put_bits(&s->pb, 6, s->frmsizecod + (s->frame_size - s->frame_size_min)); | |
904 put_bits(&s->pb, 5, s->bsid); | |
905 put_bits(&s->pb, 3, s->bsmod); | |
906 put_bits(&s->pb, 3, s->acmod); | |
314 | 907 if ((s->acmod & 0x01) && s->acmod != 0x01) |
908 put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ | |
909 if (s->acmod & 0x04) | |
910 put_bits(&s->pb, 2, 1); /* XXX -6 dB */ | |
911 if (s->acmod == 0x02) | |
0 | 912 put_bits(&s->pb, 2, 0); /* surround not indicated */ |
314 | 913 put_bits(&s->pb, 1, s->lfe); /* LFE */ |
0 | 914 put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */ |
915 put_bits(&s->pb, 1, 0); /* no compression control word */ | |
916 put_bits(&s->pb, 1, 0); /* no lang code */ | |
917 put_bits(&s->pb, 1, 0); /* no audio production info */ | |
918 put_bits(&s->pb, 1, 0); /* no copyright */ | |
919 put_bits(&s->pb, 1, 1); /* original bitstream */ | |
920 put_bits(&s->pb, 1, 0); /* no time code 1 */ | |
921 put_bits(&s->pb, 1, 0); /* no time code 2 */ | |
922 put_bits(&s->pb, 1, 0); /* no addtional bit stream info */ | |
923 } | |
924 | |
925 /* symetric quantization on 'levels' levels */ | |
926 static inline int sym_quant(int c, int e, int levels) | |
927 { | |
928 int v; | |
929 | |
930 if (c >= 0) { | |
87 | 931 v = (levels * (c << e)) >> 24; |
932 v = (v + 1) >> 1; | |
0 | 933 v = (levels >> 1) + v; |
934 } else { | |
87 | 935 v = (levels * ((-c) << e)) >> 24; |
936 v = (v + 1) >> 1; | |
0 | 937 v = (levels >> 1) - v; |
938 } | |
939 assert (v >= 0 && v < levels); | |
940 return v; | |
941 } | |
942 | |
943 /* asymetric quantization on 2^qbits levels */ | |
944 static inline int asym_quant(int c, int e, int qbits) | |
945 { | |
946 int lshift, m, v; | |
947 | |
948 lshift = e + qbits - 24; | |
949 if (lshift >= 0) | |
950 v = c << lshift; | |
951 else | |
952 v = c >> (-lshift); | |
953 /* rounding */ | |
954 v = (v + 1) >> 1; | |
955 m = (1 << (qbits-1)); | |
956 if (v >= m) | |
957 v = m - 1; | |
958 assert(v >= -m); | |
959 return v & ((1 << qbits)-1); | |
960 } | |
961 | |
962 /* Output one audio block. There are NB_BLOCKS audio blocks in one AC3 | |
963 frame */ | |
964 static void output_audio_block(AC3EncodeContext *s, | |
1064 | 965 uint8_t exp_strategy[AC3_MAX_CHANNELS], |
966 uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2], | |
967 uint8_t bap[AC3_MAX_CHANNELS][N/2], | |
968 int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2], | |
969 int8_t global_exp[AC3_MAX_CHANNELS], | |
0 | 970 int block_num) |
971 { | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
972 int ch, nb_groups, group_size, i, baie, rbnd; |
1064 | 973 uint8_t *p; |
974 uint16_t qmant[AC3_MAX_CHANNELS][N/2]; | |
0 | 975 int exp0, exp1; |
976 int mant1_cnt, mant2_cnt, mant4_cnt; | |
1064 | 977 uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; |
0 | 978 int delta0, delta1, delta2; |
979 | |
980 for(ch=0;ch<s->nb_channels;ch++) | |
981 put_bits(&s->pb, 1, 0); /* 512 point MDCT */ | |
982 for(ch=0;ch<s->nb_channels;ch++) | |
983 put_bits(&s->pb, 1, 1); /* no dither */ | |
984 put_bits(&s->pb, 1, 0); /* no dynamic range */ | |
985 if (block_num == 0) { | |
986 /* for block 0, even if no coupling, we must say it. This is a | |
987 waste of bit :-) */ | |
988 put_bits(&s->pb, 1, 1); /* coupling strategy present */ | |
989 put_bits(&s->pb, 1, 0); /* no coupling strategy */ | |
990 } else { | |
991 put_bits(&s->pb, 1, 0); /* no new coupling strategy */ | |
992 } | |
993 | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
994 if (s->acmod == 2) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
995 { |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
996 if(block_num==0) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
997 { |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
998 /* first block must define rematrixing (rematstr) */ |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
999 put_bits(&s->pb, 1, 1); |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1000 |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1001 /* dummy rematrixing rematflg(1:4)=0 */ |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1002 for (rbnd=0;rbnd<4;rbnd++) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1003 put_bits(&s->pb, 1, 0); |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1004 } |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1005 else |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1006 { |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1007 /* no matrixing (but should be used in the future) */ |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1008 put_bits(&s->pb, 1, 0); |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1009 } |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1010 } |
0 | 1011 |
1012 #if defined(DEBUG) | |
1013 { | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1014 static int count = 0; |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
1015 av_log(NULL, AV_LOG_DEBUG, "Block #%d (%d)\n", block_num, count++); |
0 | 1016 } |
1017 #endif | |
1018 /* exponent strategy */ | |
1019 for(ch=0;ch<s->nb_channels;ch++) { | |
1020 put_bits(&s->pb, 2, exp_strategy[ch]); | |
1021 } | |
1022 | |
314 | 1023 if (s->lfe) { |
1024 put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]); | |
1025 } | |
1026 | |
0 | 1027 for(ch=0;ch<s->nb_channels;ch++) { |
1028 if (exp_strategy[ch] != EXP_REUSE) | |
1029 put_bits(&s->pb, 6, s->chbwcod[ch]); | |
1030 } | |
1031 | |
1032 /* exponents */ | |
314 | 1033 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1034 switch(exp_strategy[ch]) { |
1035 case EXP_REUSE: | |
1036 continue; | |
1037 case EXP_D15: | |
1038 group_size = 1; | |
1039 break; | |
1040 case EXP_D25: | |
1041 group_size = 2; | |
1042 break; | |
1043 default: | |
1044 case EXP_D45: | |
1045 group_size = 4; | |
1046 break; | |
1047 } | |
314 | 1048 nb_groups = (s->nb_coefs[ch] + (group_size * 3) - 4) / (3 * group_size); |
0 | 1049 p = encoded_exp[ch]; |
1050 | |
1051 /* first exponent */ | |
1052 exp1 = *p++; | |
1053 put_bits(&s->pb, 4, exp1); | |
1054 | |
1055 /* next ones are delta encoded */ | |
1056 for(i=0;i<nb_groups;i++) { | |
1057 /* merge three delta in one code */ | |
1058 exp0 = exp1; | |
1059 exp1 = p[0]; | |
1060 p += group_size; | |
1061 delta0 = exp1 - exp0 + 2; | |
1062 | |
1063 exp0 = exp1; | |
1064 exp1 = p[0]; | |
1065 p += group_size; | |
1066 delta1 = exp1 - exp0 + 2; | |
1067 | |
1068 exp0 = exp1; | |
1069 exp1 = p[0]; | |
1070 p += group_size; | |
1071 delta2 = exp1 - exp0 + 2; | |
1072 | |
1073 put_bits(&s->pb, 7, ((delta0 * 5 + delta1) * 5) + delta2); | |
1074 } | |
1075 | |
314 | 1076 if (ch != s->lfe_channel) |
1077 put_bits(&s->pb, 2, 0); /* no gain range info */ | |
0 | 1078 } |
1079 | |
1080 /* bit allocation info */ | |
1081 baie = (block_num == 0); | |
1082 put_bits(&s->pb, 1, baie); | |
1083 if (baie) { | |
1084 put_bits(&s->pb, 2, s->sdecaycod); | |
1085 put_bits(&s->pb, 2, s->fdecaycod); | |
1086 put_bits(&s->pb, 2, s->sgaincod); | |
1087 put_bits(&s->pb, 2, s->dbkneecod); | |
1088 put_bits(&s->pb, 3, s->floorcod); | |
1089 } | |
1090 | |
1091 /* snr offset */ | |
1092 put_bits(&s->pb, 1, baie); /* always present with bai */ | |
1093 if (baie) { | |
1094 put_bits(&s->pb, 6, s->csnroffst); | |
314 | 1095 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 1096 put_bits(&s->pb, 4, s->fsnroffst[ch]); |
1097 put_bits(&s->pb, 3, s->fgaincod[ch]); | |
1098 } | |
1099 } | |
1100 | |
1101 put_bits(&s->pb, 1, 0); /* no delta bit allocation */ | |
1102 put_bits(&s->pb, 1, 0); /* no data to skip */ | |
1103 | |
1104 /* mantissa encoding : we use two passes to handle the grouping. A | |
1105 one pass method may be faster, but it would necessitate to | |
1106 modify the output stream. */ | |
1107 | |
1108 /* first pass: quantize */ | |
1109 mant1_cnt = mant2_cnt = mant4_cnt = 0; | |
1110 qmant1_ptr = qmant2_ptr = qmant4_ptr = NULL; | |
1111 | |
314 | 1112 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1113 int b, c, e, v; |
1114 | |
1115 for(i=0;i<s->nb_coefs[ch];i++) { | |
1116 c = mdct_coefs[ch][i]; | |
1117 e = encoded_exp[ch][i] - global_exp[ch]; | |
1118 b = bap[ch][i]; | |
1119 switch(b) { | |
1120 case 0: | |
1121 v = 0; | |
1122 break; | |
1123 case 1: | |
1124 v = sym_quant(c, e, 3); | |
1125 switch(mant1_cnt) { | |
1126 case 0: | |
1127 qmant1_ptr = &qmant[ch][i]; | |
1128 v = 9 * v; | |
1129 mant1_cnt = 1; | |
1130 break; | |
1131 case 1: | |
1132 *qmant1_ptr += 3 * v; | |
1133 mant1_cnt = 2; | |
1134 v = 128; | |
1135 break; | |
1136 default: | |
1137 *qmant1_ptr += v; | |
1138 mant1_cnt = 0; | |
1139 v = 128; | |
1140 break; | |
1141 } | |
1142 break; | |
1143 case 2: | |
1144 v = sym_quant(c, e, 5); | |
1145 switch(mant2_cnt) { | |
1146 case 0: | |
1147 qmant2_ptr = &qmant[ch][i]; | |
1148 v = 25 * v; | |
1149 mant2_cnt = 1; | |
1150 break; | |
1151 case 1: | |
1152 *qmant2_ptr += 5 * v; | |
1153 mant2_cnt = 2; | |
1154 v = 128; | |
1155 break; | |
1156 default: | |
1157 *qmant2_ptr += v; | |
1158 mant2_cnt = 0; | |
1159 v = 128; | |
1160 break; | |
1161 } | |
1162 break; | |
1163 case 3: | |
1164 v = sym_quant(c, e, 7); | |
1165 break; | |
1166 case 4: | |
1167 v = sym_quant(c, e, 11); | |
1168 switch(mant4_cnt) { | |
1169 case 0: | |
1170 qmant4_ptr = &qmant[ch][i]; | |
1171 v = 11 * v; | |
1172 mant4_cnt = 1; | |
1173 break; | |
1174 default: | |
1175 *qmant4_ptr += v; | |
1176 mant4_cnt = 0; | |
1177 v = 128; | |
1178 break; | |
1179 } | |
1180 break; | |
1181 case 5: | |
1182 v = sym_quant(c, e, 15); | |
1183 break; | |
1184 case 14: | |
1185 v = asym_quant(c, e, 14); | |
1186 break; | |
1187 case 15: | |
1188 v = asym_quant(c, e, 16); | |
1189 break; | |
1190 default: | |
1191 v = asym_quant(c, e, b - 1); | |
1192 break; | |
1193 } | |
1194 qmant[ch][i] = v; | |
1195 } | |
1196 } | |
1197 | |
1198 /* second pass : output the values */ | |
314 | 1199 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1200 int b, q; |
1201 | |
1202 for(i=0;i<s->nb_coefs[ch];i++) { | |
1203 q = qmant[ch][i]; | |
1204 b = bap[ch][i]; | |
1205 switch(b) { | |
1206 case 0: | |
1207 break; | |
1208 case 1: | |
1209 if (q != 128) | |
1210 put_bits(&s->pb, 5, q); | |
1211 break; | |
1212 case 2: | |
1213 if (q != 128) | |
1214 put_bits(&s->pb, 7, q); | |
1215 break; | |
1216 case 3: | |
1217 put_bits(&s->pb, 3, q); | |
1218 break; | |
1219 case 4: | |
1220 if (q != 128) | |
1221 put_bits(&s->pb, 7, q); | |
1222 break; | |
1223 case 14: | |
1224 put_bits(&s->pb, 14, q); | |
1225 break; | |
1226 case 15: | |
1227 put_bits(&s->pb, 16, q); | |
1228 break; | |
1229 default: | |
1230 put_bits(&s->pb, b - 1, q); | |
1231 break; | |
1232 } | |
1233 } | |
1234 } | |
1235 } | |
1236 | |
1237 /* compute the ac3 crc */ | |
1238 | |
1239 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) | |
1240 | |
1241 static void ac3_crc_init(void) | |
1242 { | |
1243 unsigned int c, n, k; | |
1244 | |
1245 for(n=0;n<256;n++) { | |
1246 c = n << 8; | |
1247 for (k = 0; k < 8; k++) { | |
1248 if (c & (1 << 15)) | |
1249 c = ((c << 1) & 0xffff) ^ (CRC16_POLY & 0xffff); | |
1250 else | |
1251 c = c << 1; | |
1252 } | |
1253 crc_table[n] = c; | |
1254 } | |
1255 } | |
1256 | |
1064 | 1257 static unsigned int ac3_crc(uint8_t *data, int n, unsigned int crc) |
0 | 1258 { |
1259 int i; | |
1260 for(i=0;i<n;i++) { | |
1261 crc = (crc_table[data[i] ^ (crc >> 8)] ^ (crc << 8)) & 0xffff; | |
1262 } | |
1263 return crc; | |
1264 } | |
1265 | |
1266 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) | |
1267 { | |
1268 unsigned int c; | |
1269 | |
1270 c = 0; | |
1271 while (a) { | |
1272 if (a & 1) | |
1273 c ^= b; | |
1274 a = a >> 1; | |
1275 b = b << 1; | |
1276 if (b & (1 << 16)) | |
1277 b ^= poly; | |
1278 } | |
1279 return c; | |
1280 } | |
1281 | |
1282 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) | |
1283 { | |
1284 unsigned int r; | |
1285 r = 1; | |
1286 while (n) { | |
1287 if (n & 1) | |
1288 r = mul_poly(r, a, poly); | |
1289 a = mul_poly(a, a, poly); | |
1290 n >>= 1; | |
1291 } | |
1292 return r; | |
1293 } | |
1294 | |
1295 | |
1296 /* compute log2(max(abs(tab[]))) */ | |
1064 | 1297 static int log2_tab(int16_t *tab, int n) |
0 | 1298 { |
1299 int i, v; | |
1300 | |
1301 v = 0; | |
1302 for(i=0;i<n;i++) { | |
1303 v |= abs(tab[i]); | |
1304 } | |
65 | 1305 return av_log2(v); |
0 | 1306 } |
1307 | |
1064 | 1308 static void lshift_tab(int16_t *tab, int n, int lshift) |
0 | 1309 { |
1310 int i; | |
1311 | |
1312 if (lshift > 0) { | |
1313 for(i=0;i<n;i++) { | |
1314 tab[i] <<= lshift; | |
1315 } | |
1316 } else if (lshift < 0) { | |
1317 lshift = -lshift; | |
1318 for(i=0;i<n;i++) { | |
1319 tab[i] >>= lshift; | |
1320 } | |
1321 } | |
1322 } | |
1323 | |
1324 /* fill the end of the frame and compute the two crcs */ | |
1325 static int output_frame_end(AC3EncodeContext *s) | |
1326 { | |
1327 int frame_size, frame_size_58, n, crc1, crc2, crc_inv; | |
1064 | 1328 uint8_t *frame; |
0 | 1329 |
1330 frame_size = s->frame_size; /* frame size in words */ | |
1331 /* align to 8 bits */ | |
1332 flush_put_bits(&s->pb); | |
1333 /* add zero bytes to reach the frame size */ | |
1334 frame = s->pb.buf; | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
87
diff
changeset
|
1335 n = 2 * s->frame_size - (pbBufPtr(&s->pb) - frame) - 2; |
0 | 1336 assert(n >= 0); |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1337 if(n>0) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1338 memset(pbBufPtr(&s->pb), 0, n); |
0 | 1339 |
1340 /* Now we must compute both crcs : this is not so easy for crc1 | |
1341 because it is at the beginning of the data... */ | |
1342 frame_size_58 = (frame_size >> 1) + (frame_size >> 3); | |
1343 crc1 = ac3_crc(frame + 4, (2 * frame_size_58) - 4, 0); | |
1344 /* XXX: could precompute crc_inv */ | |
1345 crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY); | |
1346 crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); | |
1347 frame[2] = crc1 >> 8; | |
1348 frame[3] = crc1; | |
1349 | |
1350 crc2 = ac3_crc(frame + 2 * frame_size_58, (frame_size - frame_size_58) * 2 - 2, 0); | |
1351 frame[2*frame_size - 2] = crc2 >> 8; | |
1352 frame[2*frame_size - 1] = crc2; | |
1353 | |
1354 // printf("n=%d frame_size=%d\n", n, frame_size); | |
1355 return frame_size * 2; | |
1356 } | |
1357 | |
782 | 1358 static int AC3_encode_frame(AVCodecContext *avctx, |
1359 unsigned char *frame, int buf_size, void *data) | |
0 | 1360 { |
1361 AC3EncodeContext *s = avctx->priv_data; | |
2367
c353719836af
fix some type mismatches patch by (Jeff Muizelaar <muizelaar rogers com>)
michael
parents:
2157
diff
changeset
|
1362 int16_t *samples = data; |
0 | 1363 int i, j, k, v, ch; |
1064 | 1364 int16_t input_samples[N]; |
1365 int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1366 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1367 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
1368 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1369 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1370 int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
0 | 1371 int frame_bits; |
1372 | |
1373 frame_bits = 0; | |
314 | 1374 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 1375 /* fixed mdct to the six sub blocks & exponent computation */ |
1376 for(i=0;i<NB_BLOCKS;i++) { | |
1064 | 1377 int16_t *sptr; |
0 | 1378 int sinc; |
1379 | |
1380 /* compute input samples */ | |
1064 | 1381 memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t)); |
314 | 1382 sinc = s->nb_all_channels; |
0 | 1383 sptr = samples + (sinc * (N/2) * i) + ch; |
1384 for(j=0;j<N/2;j++) { | |
1385 v = *sptr; | |
1386 input_samples[j + N/2] = v; | |
1387 s->last_samples[ch][j] = v; | |
1388 sptr += sinc; | |
1389 } | |
1390 | |
1391 /* apply the MDCT window */ | |
1392 for(j=0;j<N/2;j++) { | |
1393 input_samples[j] = MUL16(input_samples[j], | |
1394 ac3_window[j]) >> 15; | |
1395 input_samples[N-j-1] = MUL16(input_samples[N-j-1], | |
1396 ac3_window[j]) >> 15; | |
1397 } | |
1398 | |
1399 /* Normalize the samples to use the maximum available | |
1400 precision */ | |
1401 v = 14 - log2_tab(input_samples, N); | |
1402 if (v < 0) | |
1403 v = 0; | |
1404 exp_samples[i][ch] = v - 8; | |
1405 lshift_tab(input_samples, N, v); | |
1406 | |
1407 /* do the MDCT */ | |
1408 mdct512(mdct_coef[i][ch], input_samples); | |
1409 | |
1410 /* compute "exponents". We take into account the | |
1411 normalization there */ | |
1412 for(j=0;j<N/2;j++) { | |
1413 int e; | |
1414 v = abs(mdct_coef[i][ch][j]); | |
1415 if (v == 0) | |
1416 e = 24; | |
1417 else { | |
65 | 1418 e = 23 - av_log2(v) + exp_samples[i][ch]; |
0 | 1419 if (e >= 24) { |
1420 e = 24; | |
1421 mdct_coef[i][ch][j] = 0; | |
1422 } | |
1423 } | |
1424 exp[i][ch][j] = e; | |
1425 } | |
1426 } | |
1427 | |
314 | 1428 compute_exp_strategy(exp_strategy, exp, ch, ch == s->lfe_channel); |
0 | 1429 |
1430 /* compute the exponents as the decoder will see them. The | |
1431 EXP_REUSE case must be handled carefully : we select the | |
1432 min of the exponents */ | |
1433 i = 0; | |
1434 while (i < NB_BLOCKS) { | |
1435 j = i + 1; | |
1436 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) { | |
1437 exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]); | |
1438 j++; | |
1439 } | |
1440 frame_bits += encode_exp(encoded_exp[i][ch], | |
1441 exp[i][ch], s->nb_coefs[ch], | |
1442 exp_strategy[i][ch]); | |
1443 /* copy encoded exponents for reuse case */ | |
1444 for(k=i+1;k<j;k++) { | |
1445 memcpy(encoded_exp[k][ch], encoded_exp[i][ch], | |
1064 | 1446 s->nb_coefs[ch] * sizeof(uint8_t)); |
0 | 1447 } |
1448 i = j; | |
1449 } | |
1450 } | |
1451 | |
1452 compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits); | |
1453 /* everything is known... let's output the frame */ | |
1454 output_frame_header(s, frame); | |
1455 | |
1456 for(i=0;i<NB_BLOCKS;i++) { | |
1457 output_audio_block(s, exp_strategy[i], encoded_exp[i], | |
1458 bap[i], mdct_coef[i], exp_samples[i], i); | |
1459 } | |
1460 return output_frame_end(s); | |
1461 } | |
1462 | |
925 | 1463 static int AC3_encode_close(AVCodecContext *avctx) |
1464 { | |
1465 av_freep(&avctx->coded_frame); | |
1014
48349e11c9b2
C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (Mns Rullgrd))
michaelni
parents:
925
diff
changeset
|
1466 return 0; |
925 | 1467 } |
1468 | |
0 | 1469 #if 0 |
1470 /*************************************************************************/ | |
1471 /* TEST */ | |
1472 | |
1473 #define FN (N/4) | |
1474 | |
1475 void fft_test(void) | |
1476 { | |
1477 IComplex in[FN], in1[FN]; | |
1478 int k, n, i; | |
1479 float sum_re, sum_im, a; | |
1480 | |
1481 /* FFT test */ | |
1482 | |
1483 for(i=0;i<FN;i++) { | |
1484 in[i].re = random() % 65535 - 32767; | |
1485 in[i].im = random() % 65535 - 32767; | |
1486 in1[i] = in[i]; | |
1487 } | |
1488 fft(in, 7); | |
1489 | |
1490 /* do it by hand */ | |
1491 for(k=0;k<FN;k++) { | |
1492 sum_re = 0; | |
1493 sum_im = 0; | |
1494 for(n=0;n<FN;n++) { | |
1495 a = -2 * M_PI * (n * k) / FN; | |
1496 sum_re += in1[n].re * cos(a) - in1[n].im * sin(a); | |
1497 sum_im += in1[n].re * sin(a) + in1[n].im * cos(a); | |
1498 } | |
1499 printf("%3d: %6d,%6d %6.0f,%6.0f\n", | |
1500 k, in[k].re, in[k].im, sum_re / FN, sum_im / FN); | |
1501 } | |
1502 } | |
1503 | |
1504 void mdct_test(void) | |
1505 { | |
1064 | 1506 int16_t input[N]; |
1507 int32_t output[N/2]; | |
0 | 1508 float input1[N]; |
1509 float output1[N/2]; | |
1510 float s, a, err, e, emax; | |
1511 int i, k, n; | |
1512 | |
1513 for(i=0;i<N;i++) { | |
1514 input[i] = (random() % 65535 - 32767) * 9 / 10; | |
1515 input1[i] = input[i]; | |
1516 } | |
1517 | |
1518 mdct512(output, input); | |
1519 | |
1520 /* do it by hand */ | |
1521 for(k=0;k<N/2;k++) { | |
1522 s = 0; | |
1523 for(n=0;n<N;n++) { | |
1524 a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N)); | |
1525 s += input1[n] * cos(a); | |
1526 } | |
1527 output1[k] = -2 * s / N; | |
1528 } | |
1529 | |
1530 err = 0; | |
1531 emax = 0; | |
1532 for(i=0;i<N/2;i++) { | |
1533 printf("%3d: %7d %7.0f\n", i, output[i], output1[i]); | |
1534 e = output[i] - output1[i]; | |
1535 if (e > emax) | |
1536 emax = e; | |
1537 err += e * e; | |
1538 } | |
1539 printf("err2=%f emax=%f\n", err / (N/2), emax); | |
1540 } | |
1541 | |
1542 void test_ac3(void) | |
1543 { | |
1544 AC3EncodeContext ctx; | |
1545 unsigned char frame[AC3_MAX_CODED_FRAME_SIZE]; | |
1546 short samples[AC3_FRAME_SIZE]; | |
1547 int ret, i; | |
1548 | |
1549 AC3_encode_init(&ctx, 44100, 64000, 1); | |
1550 | |
1551 fft_test(); | |
1552 mdct_test(); | |
1553 | |
1554 for(i=0;i<AC3_FRAME_SIZE;i++) | |
1555 samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000); | |
1556 ret = AC3_encode_frame(&ctx, frame, samples); | |
1557 printf("ret=%d\n", ret); | |
1558 } | |
1559 #endif | |
1560 | |
1561 AVCodec ac3_encoder = { | |
1562 "ac3", | |
1563 CODEC_TYPE_AUDIO, | |
1564 CODEC_ID_AC3, | |
1565 sizeof(AC3EncodeContext), | |
1566 AC3_encode_init, | |
1567 AC3_encode_frame, | |
925 | 1568 AC3_encode_close, |
0 | 1569 NULL, |
1570 }; |