Mercurial > libavcodec.hg
annotate ac3enc.c @ 3198:6b9f0c4fbdbe libavcodec
First part of a series of speed-enchancing patches.
This one sets up a snow.h and makes snow use the dsputil function pointer
framework to access the three functions that will be implemented in asm
in the other parts of the patchset.
Patch by Robert Edele < yartrebo AH earthlink POIS net>
Original thread:
Subject: [Ffmpeg-devel] [PATCH] Snow mmx+sse2 asm optimizations
Date: Sun, 05 Feb 2006 12:47:14 -0500
author | gpoirier |
---|---|
date | Thu, 16 Mar 2006 19:18:18 +0000 |
parents | 1475eb5f8649 |
children | ed485fd3f984 |
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 | |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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" |
3170 | 28 #include "crc.h" |
782 | 29 #include "ac3.h" |
30 | |
31 typedef struct AC3EncodeContext { | |
32 PutBitContext pb; | |
33 int nb_channels; | |
34 int nb_all_channels; | |
35 int lfe_channel; | |
36 int bit_rate; | |
1057 | 37 unsigned int sample_rate; |
38 unsigned int bsid; | |
39 unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */ | |
40 unsigned int frame_size; /* current frame size in words */ | |
782 | 41 int halfratecod; |
1057 | 42 unsigned int frmsizecod; |
43 unsigned int fscod; /* frequency */ | |
44 unsigned int acmod; | |
782 | 45 int lfe; |
1057 | 46 unsigned int bsmod; |
782 | 47 short last_samples[AC3_MAX_CHANNELS][256]; |
1057 | 48 unsigned int chbwcod[AC3_MAX_CHANNELS]; |
782 | 49 int nb_coefs[AC3_MAX_CHANNELS]; |
2967 | 50 |
782 | 51 /* bitrate allocation control */ |
2967 | 52 int sgaincod, sdecaycod, fdecaycod, dbkneecod, floorcod; |
782 | 53 AC3BitAllocParameters bit_alloc; |
54 int csnroffst; | |
55 int fgaincod[AC3_MAX_CHANNELS]; | |
56 int fsnroffst[AC3_MAX_CHANNELS]; | |
57 /* mantissa encoding */ | |
58 int mant1_cnt, mant2_cnt, mant4_cnt; | |
59 } AC3EncodeContext; | |
60 | |
0 | 61 #include "ac3tab.h" |
62 | |
63 #define MDCT_NBITS 9 | |
64 #define N (1 << MDCT_NBITS) | |
65 | |
66 /* new exponents are sent if their Norm 1 exceed this number */ | |
67 #define EXP_DIFF_THRESHOLD 1000 | |
68 | |
69 static void fft_init(int ln); | |
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; | |
2967 | 77 else if (v > 32767) |
0 | 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 ; | |
2967 | 86 } else if (b0 > b1) { |
0 | 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 ; | |
2967 | 98 } else if (b0 > b1) { |
0 | 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, |
2967 | 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; | |
2967 | 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 } | |
2967 | 188 |
782 | 189 end1=bndend; |
190 if (end1 > 22) end1=22; | |
2967 | 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) ; | |
2967 | 195 |
782 | 196 fastleak -= s->fdecay ; |
197 v = bndpsd[bin] - fgain; | |
198 if (fastleak < v) fastleak = v; | |
2967 | 199 |
782 | 200 slowleak -= s->sdecay ; |
201 v = bndpsd[bin] - s->sgain; | |
202 if (slowleak < v) slowleak = v; | |
2967 | 203 |
782 | 204 v=fastleak - lowcomp; |
205 if (slowleak > v) v=slowleak; | |
2967 | 206 |
782 | 207 excite[bin] = v; |
208 } | |
209 begin = 22; | |
210 } else { | |
211 /* coupling channel */ | |
212 begin = bndstrt; | |
2967 | 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 */ |
2967 | 264 |
0 | 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 { | |
2979 | 340 int j, l, np, np2; |
341 int nblocks, nloops; | |
0 | 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 { | |
2967 | 364 BF(p[0].re, p[0].im, p[1].re, p[1].im, |
0 | 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 { | |
2967 | 374 BF(p[0].re, p[0].im, p[2].re, p[2].im, |
0 | 375 p[0].re, p[0].im, p[2].re, p[2].im); |
2967 | 376 BF(p[1].re, p[1].im, p[3].re, p[3].im, |
0 | 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); | |
2967 | 393 |
0 | 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; | |
2967 | 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]; | |
2967 | 423 |
0 | 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); | |
2967 | 432 |
0 | 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; | |
2967 | 460 |
0 | 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); | |
2967 | 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) |
2979 | 475 return; |
314 | 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 } | |
2979 | 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 } | |
2967 | 510 |
0 | 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 */ | |
2967 | 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++) |
2979 | 556 exp1[i] = FFMIN(exp1[i], exp1[i-1] + 2); |
2157
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--) |
2979 | 558 exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2); |
2157
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 } | |
2967 | 569 |
0 | 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 */ | |
2967 | 595 if (s->mant1_cnt == 0) |
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 */ | |
2967 | 602 if (s->mant2_cnt == 0) |
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; | |
2967 | 614 if (++s->mant4_cnt == 2) |
0 | 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++) { |
2967 | 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, | |
782 | 651 fgaintab[s->fgaincod[ch]], |
652 ch == s->lfe_channel, | |
653 2, 0, NULL, NULL, NULL); | |
2967 | 654 frame_bits += compute_mantissa_size(s, bap[i][ch], |
0 | 655 s->nb_coefs[ch]); |
656 } | |
657 } | |
658 #if 0 | |
2967 | 659 printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n", |
660 csnroffst, fsnroffst, frame_bits, | |
0 | 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; | |
2967 | 685 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 686 s->fgaincod[ch] = 4; |
2967 | 687 |
0 | 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]; | |
2967 | 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 */ |
2644
6ff5dc0dbaf0
While adding stereo rematrixing, I came across something that needs to
michael
parents:
2398
diff
changeset
|
706 if (s->acmod == 2) { |
314 | 707 frame_bits++; /* rematstr */ |
2644
6ff5dc0dbaf0
While adding stereo rematrixing, I came across something that needs to
michael
parents:
2398
diff
changeset
|
708 if(i==0) frame_bits += 4; |
6ff5dc0dbaf0
While adding stereo rematrixing, I came across something that needs to
michael
parents:
2398
diff
changeset
|
709 } |
314 | 710 frame_bits += 2 * s->nb_channels; /* chexpstr[2] * c */ |
2979 | 711 if (s->lfe) |
712 frame_bits++; /* lfeexpstr */ | |
0 | 713 for(ch=0;ch<s->nb_channels;ch++) { |
714 if (exp_strategy[i][ch] != EXP_REUSE) | |
314 | 715 frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ |
0 | 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 */ | |
314 | 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); | |
0 | 727 |
1819
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
728 /* auxdatae, crcrsv */ |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
729 frame_bits += 2; |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
730 |
0 | 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; | |
2967 | 738 while (csnroffst >= 0 && |
2979 | 739 bit_alloc(s, bap, encoded_exp, exp_strategy, frame_bits, csnroffst, 0) < 0) |
740 csnroffst -= SNR_INC1; | |
0 | 741 if (csnroffst < 0) { |
2979 | 742 av_log(NULL, AV_LOG_ERROR, "Yack, Error !!!\n"); |
743 return -1; | |
0 | 744 } |
2967 | 745 while ((csnroffst + SNR_INC1) <= 63 && |
746 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 747 csnroffst + SNR_INC1, 0) >= 0) { |
748 csnroffst += SNR_INC1; | |
749 memcpy(bap, bap1, sizeof(bap1)); | |
750 } | |
2967 | 751 while ((csnroffst + 1) <= 63 && |
0 | 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; | |
2967 | 758 while ((fsnroffst + SNR_INC1) <= 15 && |
759 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 760 csnroffst, fsnroffst + SNR_INC1) >= 0) { |
761 fsnroffst += SNR_INC1; | |
762 memcpy(bap, bap1, sizeof(bap1)); | |
763 } | |
2967 | 764 while ((fsnroffst + 1) <= 15 && |
765 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 766 csnroffst, fsnroffst + 1) >= 0) { |
767 fsnroffst++; | |
768 memcpy(bap, bap1, sizeof(bap1)); | |
769 } | |
2967 | 770 |
0 | 771 s->csnroffst = csnroffst; |
314 | 772 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 773 s->fsnroffst[ch] = fsnroffst; |
774 #if defined(DEBUG_BITALLOC) | |
775 { | |
776 int j; | |
777 | |
778 for(i=0;i<6;i++) { | |
314 | 779 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 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 | |
782 | 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 | |
0 | 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; | |
782 | 815 int i, j, ch; |
0 | 816 float alpha; |
1064 | 817 static const uint8_t acmod_defs[6] = { |
2979 | 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) */ | |
314 | 824 }; |
0 | 825 |
826 avctx->frame_size = AC3_FRAME_SIZE; | |
2967 | 827 |
0 | 828 /* number of channels */ |
314 | 829 if (channels < 1 || channels > 6) |
2979 | 830 return -1; |
314 | 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; | |
0 | 836 |
837 /* frequency */ | |
838 for(i=0;i<3;i++) { | |
2967 | 839 for(j=0;j<3;j++) |
782 | 840 if ((ac3_freqs[j] >> i) == freq) |
0 | 841 goto found; |
842 } | |
843 return -1; | |
2967 | 844 found: |
0 | 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++) { | |
782 | 854 if ((ac3_bitratetab[i] >> s->halfratecod) == bitrate) |
0 | 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; | |
2967 | 864 |
0 | 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 } | |
314 | 873 if (s->lfe) { |
2979 | 874 s->nb_coefs[s->lfe_channel] = 7; /* fixed */ |
314 | 875 } |
0 | 876 /* initial snr offset */ |
877 s->csnroffst = 40; | |
878 | |
782 | 879 ac3_common_init(); |
0 | 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 | |
925 | 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) |
2979 | 908 put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ |
314 | 909 if (s->acmod & 0x04) |
2979 | 910 put_bits(&s->pb, 2, 1); /* XXX -6 dB */ |
314 | 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 | |
2967 | 980 for(ch=0;ch<s->nb_channels;ch++) |
0 | 981 put_bits(&s->pb, 1, 0); /* 512 point MDCT */ |
2967 | 982 for(ch=0;ch<s->nb_channels;ch++) |
0 | 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 { |
2979 | 996 if(block_num==0) |
997 { | |
998 /* first block must define rematrixing (rematstr) */ | |
999 put_bits(&s->pb, 1, 1); | |
2967 | 1000 |
2979 | 1001 /* dummy rematrixing rematflg(1:4)=0 */ |
1002 for (rbnd=0;rbnd<4;rbnd++) | |
1003 put_bits(&s->pb, 1, 0); | |
1004 } | |
1005 else | |
1006 { | |
1007 /* no matrixing (but should be used in the future) */ | |
1008 put_bits(&s->pb, 1, 0); | |
1009 } | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1010 } |
0 | 1011 |
2967 | 1012 #if defined(DEBUG) |
0 | 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 } | |
2967 | 1022 |
314 | 1023 if (s->lfe) { |
2979 | 1024 put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]); |
314 | 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 } | |
2967 | 1031 |
0 | 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 } | |
2979 | 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 | |
2979 | 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 } | |
2967 | 1100 |
0 | 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; |
2967 | 1201 |
0 | 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: | |
2967 | 1209 if (q != 128) |
0 | 1210 put_bits(&s->pb, 5, q); |
1211 break; | |
1212 case 2: | |
2967 | 1213 if (q != 128) |
0 | 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 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) | |
1238 | |
1239 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) | |
1240 { | |
1241 unsigned int c; | |
1242 | |
1243 c = 0; | |
1244 while (a) { | |
1245 if (a & 1) | |
1246 c ^= b; | |
1247 a = a >> 1; | |
1248 b = b << 1; | |
1249 if (b & (1 << 16)) | |
1250 b ^= poly; | |
1251 } | |
1252 return c; | |
1253 } | |
1254 | |
1255 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) | |
1256 { | |
1257 unsigned int r; | |
1258 r = 1; | |
1259 while (n) { | |
1260 if (n & 1) | |
1261 r = mul_poly(r, a, poly); | |
1262 a = mul_poly(a, a, poly); | |
1263 n >>= 1; | |
1264 } | |
1265 return r; | |
1266 } | |
1267 | |
1268 | |
1269 /* compute log2(max(abs(tab[]))) */ | |
1064 | 1270 static int log2_tab(int16_t *tab, int n) |
0 | 1271 { |
1272 int i, v; | |
1273 | |
1274 v = 0; | |
1275 for(i=0;i<n;i++) { | |
1276 v |= abs(tab[i]); | |
1277 } | |
65 | 1278 return av_log2(v); |
0 | 1279 } |
1280 | |
1064 | 1281 static void lshift_tab(int16_t *tab, int n, int lshift) |
0 | 1282 { |
1283 int i; | |
1284 | |
1285 if (lshift > 0) { | |
1286 for(i=0;i<n;i++) { | |
1287 tab[i] <<= lshift; | |
1288 } | |
1289 } else if (lshift < 0) { | |
1290 lshift = -lshift; | |
1291 for(i=0;i<n;i++) { | |
1292 tab[i] >>= lshift; | |
1293 } | |
1294 } | |
1295 } | |
1296 | |
1297 /* fill the end of the frame and compute the two crcs */ | |
1298 static int output_frame_end(AC3EncodeContext *s) | |
1299 { | |
1300 int frame_size, frame_size_58, n, crc1, crc2, crc_inv; | |
1064 | 1301 uint8_t *frame; |
0 | 1302 |
1303 frame_size = s->frame_size; /* frame size in words */ | |
1304 /* align to 8 bits */ | |
1305 flush_put_bits(&s->pb); | |
1306 /* add zero bytes to reach the frame size */ | |
1307 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
|
1308 n = 2 * s->frame_size - (pbBufPtr(&s->pb) - frame) - 2; |
0 | 1309 assert(n >= 0); |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1310 if(n>0) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1311 memset(pbBufPtr(&s->pb), 0, n); |
2967 | 1312 |
0 | 1313 /* Now we must compute both crcs : this is not so easy for crc1 |
1314 because it is at the beginning of the data... */ | |
1315 frame_size_58 = (frame_size >> 1) + (frame_size >> 3); | |
3170 | 1316 crc1 = bswap_16(av_crc(av_crc8005, 0, frame + 4, 2 * frame_size_58 - 4)); |
0 | 1317 /* XXX: could precompute crc_inv */ |
1318 crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY); | |
1319 crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); | |
1320 frame[2] = crc1 >> 8; | |
1321 frame[3] = crc1; | |
2967 | 1322 |
3170 | 1323 crc2 = bswap_16(av_crc(av_crc8005, 0, frame + 2 * frame_size_58, (frame_size - frame_size_58) * 2 - 2)); |
0 | 1324 frame[2*frame_size - 2] = crc2 >> 8; |
1325 frame[2*frame_size - 1] = crc2; | |
1326 | |
1327 // printf("n=%d frame_size=%d\n", n, frame_size); | |
1328 return frame_size * 2; | |
1329 } | |
1330 | |
782 | 1331 static int AC3_encode_frame(AVCodecContext *avctx, |
1332 unsigned char *frame, int buf_size, void *data) | |
0 | 1333 { |
1334 AC3EncodeContext *s = avctx->priv_data; | |
2367
c353719836af
fix some type mismatches patch by (Jeff Muizelaar <muizelaar rogers com>)
michael
parents:
2157
diff
changeset
|
1335 int16_t *samples = data; |
0 | 1336 int i, j, k, v, ch; |
1064 | 1337 int16_t input_samples[N]; |
1338 int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1339 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1340 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
1341 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1342 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1343 int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
0 | 1344 int frame_bits; |
1345 | |
1346 frame_bits = 0; | |
314 | 1347 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 1348 /* fixed mdct to the six sub blocks & exponent computation */ |
1349 for(i=0;i<NB_BLOCKS;i++) { | |
1064 | 1350 int16_t *sptr; |
0 | 1351 int sinc; |
1352 | |
1353 /* compute input samples */ | |
1064 | 1354 memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t)); |
314 | 1355 sinc = s->nb_all_channels; |
0 | 1356 sptr = samples + (sinc * (N/2) * i) + ch; |
1357 for(j=0;j<N/2;j++) { | |
1358 v = *sptr; | |
1359 input_samples[j + N/2] = v; | |
2967 | 1360 s->last_samples[ch][j] = v; |
0 | 1361 sptr += sinc; |
1362 } | |
1363 | |
1364 /* apply the MDCT window */ | |
1365 for(j=0;j<N/2;j++) { | |
2967 | 1366 input_samples[j] = MUL16(input_samples[j], |
0 | 1367 ac3_window[j]) >> 15; |
2967 | 1368 input_samples[N-j-1] = MUL16(input_samples[N-j-1], |
0 | 1369 ac3_window[j]) >> 15; |
1370 } | |
2967 | 1371 |
0 | 1372 /* Normalize the samples to use the maximum available |
1373 precision */ | |
1374 v = 14 - log2_tab(input_samples, N); | |
1375 if (v < 0) | |
1376 v = 0; | |
1377 exp_samples[i][ch] = v - 8; | |
1378 lshift_tab(input_samples, N, v); | |
1379 | |
1380 /* do the MDCT */ | |
1381 mdct512(mdct_coef[i][ch], input_samples); | |
2967 | 1382 |
0 | 1383 /* compute "exponents". We take into account the |
1384 normalization there */ | |
1385 for(j=0;j<N/2;j++) { | |
1386 int e; | |
1387 v = abs(mdct_coef[i][ch][j]); | |
1388 if (v == 0) | |
1389 e = 24; | |
1390 else { | |
65 | 1391 e = 23 - av_log2(v) + exp_samples[i][ch]; |
0 | 1392 if (e >= 24) { |
1393 e = 24; | |
1394 mdct_coef[i][ch][j] = 0; | |
1395 } | |
1396 } | |
1397 exp[i][ch][j] = e; | |
1398 } | |
1399 } | |
2967 | 1400 |
314 | 1401 compute_exp_strategy(exp_strategy, exp, ch, ch == s->lfe_channel); |
0 | 1402 |
1403 /* compute the exponents as the decoder will see them. The | |
1404 EXP_REUSE case must be handled carefully : we select the | |
1405 min of the exponents */ | |
1406 i = 0; | |
1407 while (i < NB_BLOCKS) { | |
1408 j = i + 1; | |
1409 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) { | |
1410 exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]); | |
1411 j++; | |
1412 } | |
1413 frame_bits += encode_exp(encoded_exp[i][ch], | |
2967 | 1414 exp[i][ch], s->nb_coefs[ch], |
0 | 1415 exp_strategy[i][ch]); |
1416 /* copy encoded exponents for reuse case */ | |
1417 for(k=i+1;k<j;k++) { | |
2967 | 1418 memcpy(encoded_exp[k][ch], encoded_exp[i][ch], |
1064 | 1419 s->nb_coefs[ch] * sizeof(uint8_t)); |
0 | 1420 } |
1421 i = j; | |
1422 } | |
1423 } | |
1424 | |
1425 compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits); | |
1426 /* everything is known... let's output the frame */ | |
1427 output_frame_header(s, frame); | |
2967 | 1428 |
0 | 1429 for(i=0;i<NB_BLOCKS;i++) { |
2967 | 1430 output_audio_block(s, exp_strategy[i], encoded_exp[i], |
0 | 1431 bap[i], mdct_coef[i], exp_samples[i], i); |
1432 } | |
1433 return output_frame_end(s); | |
1434 } | |
1435 | |
925 | 1436 static int AC3_encode_close(AVCodecContext *avctx) |
1437 { | |
1438 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
|
1439 return 0; |
925 | 1440 } |
1441 | |
0 | 1442 #if 0 |
1443 /*************************************************************************/ | |
1444 /* TEST */ | |
1445 | |
1446 #define FN (N/4) | |
1447 | |
1448 void fft_test(void) | |
1449 { | |
1450 IComplex in[FN], in1[FN]; | |
1451 int k, n, i; | |
1452 float sum_re, sum_im, a; | |
1453 | |
1454 /* FFT test */ | |
1455 | |
1456 for(i=0;i<FN;i++) { | |
1457 in[i].re = random() % 65535 - 32767; | |
1458 in[i].im = random() % 65535 - 32767; | |
1459 in1[i] = in[i]; | |
1460 } | |
1461 fft(in, 7); | |
1462 | |
1463 /* do it by hand */ | |
1464 for(k=0;k<FN;k++) { | |
1465 sum_re = 0; | |
1466 sum_im = 0; | |
1467 for(n=0;n<FN;n++) { | |
1468 a = -2 * M_PI * (n * k) / FN; | |
1469 sum_re += in1[n].re * cos(a) - in1[n].im * sin(a); | |
1470 sum_im += in1[n].re * sin(a) + in1[n].im * cos(a); | |
1471 } | |
2967 | 1472 printf("%3d: %6d,%6d %6.0f,%6.0f\n", |
1473 k, in[k].re, in[k].im, sum_re / FN, sum_im / FN); | |
0 | 1474 } |
1475 } | |
1476 | |
1477 void mdct_test(void) | |
1478 { | |
1064 | 1479 int16_t input[N]; |
1480 int32_t output[N/2]; | |
0 | 1481 float input1[N]; |
1482 float output1[N/2]; | |
1483 float s, a, err, e, emax; | |
1484 int i, k, n; | |
1485 | |
1486 for(i=0;i<N;i++) { | |
1487 input[i] = (random() % 65535 - 32767) * 9 / 10; | |
1488 input1[i] = input[i]; | |
1489 } | |
1490 | |
1491 mdct512(output, input); | |
2967 | 1492 |
0 | 1493 /* do it by hand */ |
1494 for(k=0;k<N/2;k++) { | |
1495 s = 0; | |
1496 for(n=0;n<N;n++) { | |
1497 a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N)); | |
1498 s += input1[n] * cos(a); | |
1499 } | |
1500 output1[k] = -2 * s / N; | |
1501 } | |
2967 | 1502 |
0 | 1503 err = 0; |
1504 emax = 0; | |
1505 for(i=0;i<N/2;i++) { | |
1506 printf("%3d: %7d %7.0f\n", i, output[i], output1[i]); | |
1507 e = output[i] - output1[i]; | |
1508 if (e > emax) | |
1509 emax = e; | |
1510 err += e * e; | |
1511 } | |
1512 printf("err2=%f emax=%f\n", err / (N/2), emax); | |
1513 } | |
1514 | |
1515 void test_ac3(void) | |
1516 { | |
1517 AC3EncodeContext ctx; | |
1518 unsigned char frame[AC3_MAX_CODED_FRAME_SIZE]; | |
1519 short samples[AC3_FRAME_SIZE]; | |
1520 int ret, i; | |
2967 | 1521 |
0 | 1522 AC3_encode_init(&ctx, 44100, 64000, 1); |
1523 | |
1524 fft_test(); | |
1525 mdct_test(); | |
1526 | |
1527 for(i=0;i<AC3_FRAME_SIZE;i++) | |
1528 samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000); | |
1529 ret = AC3_encode_frame(&ctx, frame, samples); | |
1530 printf("ret=%d\n", ret); | |
1531 } | |
1532 #endif | |
1533 | |
1534 AVCodec ac3_encoder = { | |
1535 "ac3", | |
1536 CODEC_TYPE_AUDIO, | |
1537 CODEC_ID_AC3, | |
1538 sizeof(AC3EncodeContext), | |
1539 AC3_encode_init, | |
1540 AC3_encode_frame, | |
925 | 1541 AC3_encode_close, |
0 | 1542 NULL, |
1543 }; |