Mercurial > libavcodec.hg
annotate ac3enc.c @ 4167:a3134db4857e libavcodec
store a identifer and the first header in extradata
with this mp3 should be binary identical to what you had before header compression
support mp3 with crc (by droping the crc and putting it back during header decompress, currently its just random tough, does any deocoder even check it?)
author | michael |
---|---|
date | Fri, 10 Nov 2006 11:31:02 +0000 |
parents | c8c591fe26f8 |
children | fbac0859753d |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest AC3 encoder | |
429 | 3 * Copyright (c) 2000 Fabrice Bellard. |
0 | 4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
429 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3668
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
1106 | 21 |
22 /** | |
23 * @file ac3enc.c | |
24 * The simplest AC3 encoder. | |
25 */ | |
64 | 26 //#define DEBUG |
27 //#define DEBUG_BITALLOC | |
28 #include "avcodec.h" | |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2367
diff
changeset
|
29 #include "bitstream.h" |
3170 | 30 #include "crc.h" |
782 | 31 #include "ac3.h" |
32 | |
33 typedef struct AC3EncodeContext { | |
34 PutBitContext pb; | |
35 int nb_channels; | |
36 int nb_all_channels; | |
37 int lfe_channel; | |
38 int bit_rate; | |
1057 | 39 unsigned int sample_rate; |
40 unsigned int bsid; | |
41 unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */ | |
42 unsigned int frame_size; /* current frame size in words */ | |
3246 | 43 unsigned int bits_written; |
44 unsigned int samples_written; | |
782 | 45 int halfratecod; |
1057 | 46 unsigned int frmsizecod; |
47 unsigned int fscod; /* frequency */ | |
48 unsigned int acmod; | |
782 | 49 int lfe; |
1057 | 50 unsigned int bsmod; |
782 | 51 short last_samples[AC3_MAX_CHANNELS][256]; |
1057 | 52 unsigned int chbwcod[AC3_MAX_CHANNELS]; |
782 | 53 int nb_coefs[AC3_MAX_CHANNELS]; |
2967 | 54 |
782 | 55 /* bitrate allocation control */ |
2967 | 56 int sgaincod, sdecaycod, fdecaycod, dbkneecod, floorcod; |
782 | 57 AC3BitAllocParameters bit_alloc; |
58 int csnroffst; | |
59 int fgaincod[AC3_MAX_CHANNELS]; | |
60 int fsnroffst[AC3_MAX_CHANNELS]; | |
61 /* mantissa encoding */ | |
62 int mant1_cnt, mant2_cnt, mant4_cnt; | |
63 } AC3EncodeContext; | |
64 | |
0 | 65 #include "ac3tab.h" |
66 | |
67 #define MDCT_NBITS 9 | |
68 #define N (1 << MDCT_NBITS) | |
69 | |
70 /* new exponents are sent if their Norm 1 exceed this number */ | |
71 #define EXP_DIFF_THRESHOLD 1000 | |
72 | |
73 static void fft_init(int ln); | |
74 | |
1064 | 75 static inline int16_t fix15(float a) |
0 | 76 { |
77 int v; | |
78 v = (int)(a * (float)(1 << 15)); | |
79 if (v < -32767) | |
80 v = -32767; | |
2967 | 81 else if (v > 32767) |
0 | 82 v = 32767; |
83 return v; | |
84 } | |
85 | |
86 static inline int calc_lowcomp1(int a, int b0, int b1) | |
87 { | |
88 if ((b0 + 256) == b1) { | |
89 a = 384 ; | |
2967 | 90 } else if (b0 > b1) { |
0 | 91 a = a - 64; |
92 if (a < 0) a=0; | |
93 } | |
94 return a; | |
95 } | |
96 | |
97 static inline int calc_lowcomp(int a, int b0, int b1, int bin) | |
98 { | |
99 if (bin < 7) { | |
100 if ((b0 + 256) == b1) { | |
101 a = 384 ; | |
2967 | 102 } else if (b0 > b1) { |
0 | 103 a = a - 64; |
104 if (a < 0) a=0; | |
105 } | |
106 } else if (bin < 20) { | |
107 if ((b0 + 256) == b1) { | |
108 a = 320 ; | |
109 } else if (b0 > b1) { | |
110 a= a - 64; | |
111 if (a < 0) a=0; | |
112 } | |
113 } else { | |
114 a = a - 128; | |
115 if (a < 0) a=0; | |
116 } | |
117 return a; | |
118 } | |
119 | |
120 /* AC3 bit allocation. The algorithm is the one described in the AC3 | |
782 | 121 spec. */ |
1064 | 122 void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap, |
123 int8_t *exp, int start, int end, | |
782 | 124 int snroffset, int fgain, int is_lfe, |
2967 | 125 int deltbae,int deltnseg, |
1064 | 126 uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba) |
0 | 127 { |
128 int bin,i,j,k,end1,v,v1,bndstrt,bndend,lowcomp,begin; | |
129 int fastleak,slowleak,address,tmp; | |
1064 | 130 int16_t psd[256]; /* scaled exponents */ |
131 int16_t bndpsd[50]; /* interpolated exponents */ | |
132 int16_t excite[50]; /* excitation */ | |
133 int16_t mask[50]; /* masking value */ | |
0 | 134 |
135 /* exponent mapping to PSD */ | |
136 for(bin=start;bin<end;bin++) { | |
137 psd[bin]=(3072 - (exp[bin] << 7)); | |
138 } | |
139 | |
140 /* PSD integration */ | |
141 j=start; | |
142 k=masktab[start]; | |
143 do { | |
144 v=psd[j]; | |
145 j++; | |
146 end1=bndtab[k+1]; | |
147 if (end1 > end) end1=end; | |
148 for(i=j;i<end1;i++) { | |
149 int c,adr; | |
150 /* logadd */ | |
151 v1=psd[j]; | |
152 c=v-v1; | |
153 if (c >= 0) { | |
154 adr=c >> 1; | |
155 if (adr > 255) adr=255; | |
156 v=v + latab[adr]; | |
157 } else { | |
158 adr=(-c) >> 1; | |
159 if (adr > 255) adr=255; | |
160 v=v1 + latab[adr]; | |
161 } | |
162 j++; | |
163 } | |
164 bndpsd[k]=v; | |
165 k++; | |
166 } while (end > bndtab[k]); | |
167 | |
168 /* excitation function */ | |
169 bndstrt = masktab[start]; | |
170 bndend = masktab[end-1] + 1; | |
2967 | 171 |
782 | 172 if (bndstrt == 0) { |
173 lowcomp = 0; | |
174 lowcomp = calc_lowcomp1(lowcomp, bndpsd[0], bndpsd[1]) ; | |
175 excite[0] = bndpsd[0] - fgain - lowcomp ; | |
176 lowcomp = calc_lowcomp1(lowcomp, bndpsd[1], bndpsd[2]) ; | |
177 excite[1] = bndpsd[1] - fgain - lowcomp ; | |
178 begin = 7 ; | |
179 for (bin = 2; bin < 7; bin++) { | |
180 if (!(is_lfe && bin == 6)) | |
181 lowcomp = calc_lowcomp1(lowcomp, bndpsd[bin], bndpsd[bin+1]) ; | |
182 fastleak = bndpsd[bin] - fgain ; | |
183 slowleak = bndpsd[bin] - s->sgain ; | |
184 excite[bin] = fastleak - lowcomp ; | |
185 if (!(is_lfe && bin == 6)) { | |
186 if (bndpsd[bin] <= bndpsd[bin+1]) { | |
187 begin = bin + 1 ; | |
188 break ; | |
189 } | |
190 } | |
191 } | |
2967 | 192 |
782 | 193 end1=bndend; |
194 if (end1 > 22) end1=22; | |
2967 | 195 |
782 | 196 for (bin = begin; bin < end1; bin++) { |
197 if (!(is_lfe && bin == 6)) | |
198 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin) ; | |
2967 | 199 |
782 | 200 fastleak -= s->fdecay ; |
201 v = bndpsd[bin] - fgain; | |
202 if (fastleak < v) fastleak = v; | |
2967 | 203 |
782 | 204 slowleak -= s->sdecay ; |
205 v = bndpsd[bin] - s->sgain; | |
206 if (slowleak < v) slowleak = v; | |
2967 | 207 |
782 | 208 v=fastleak - lowcomp; |
209 if (slowleak > v) v=slowleak; | |
2967 | 210 |
782 | 211 excite[bin] = v; |
212 } | |
213 begin = 22; | |
214 } else { | |
215 /* coupling channel */ | |
216 begin = bndstrt; | |
2967 | 217 |
782 | 218 fastleak = (s->cplfleak << 8) + 768; |
219 slowleak = (s->cplsleak << 8) + 768; | |
0 | 220 } |
221 | |
782 | 222 for (bin = begin; bin < bndend; bin++) { |
0 | 223 fastleak -= s->fdecay ; |
224 v = bndpsd[bin] - fgain; | |
225 if (fastleak < v) fastleak = v; | |
226 slowleak -= s->sdecay ; | |
227 v = bndpsd[bin] - s->sgain; | |
228 if (slowleak < v) slowleak = v; | |
229 | |
230 v=fastleak; | |
231 if (slowleak > v) v = slowleak; | |
232 excite[bin] = v; | |
233 } | |
234 | |
235 /* compute masking curve */ | |
236 | |
237 for (bin = bndstrt; bin < bndend; bin++) { | |
238 v1 = excite[bin]; | |
239 tmp = s->dbknee - bndpsd[bin]; | |
240 if (tmp > 0) { | |
241 v1 += tmp >> 2; | |
242 } | |
243 v=hth[bin >> s->halfratecod][s->fscod]; | |
244 if (v1 > v) v=v1; | |
245 mask[bin] = v; | |
246 } | |
247 | |
782 | 248 /* delta bit allocation */ |
249 | |
250 if (deltbae == 0 || deltbae == 1) { | |
251 int band, seg, delta; | |
252 band = 0 ; | |
253 for (seg = 0; seg < deltnseg; seg++) { | |
254 band += deltoffst[seg] ; | |
255 if (deltba[seg] >= 4) { | |
256 delta = (deltba[seg] - 3) << 7; | |
257 } else { | |
258 delta = (deltba[seg] - 4) << 7; | |
259 } | |
260 for (k = 0; k < deltlen[seg]; k++) { | |
261 mask[band] += delta ; | |
262 band++ ; | |
263 } | |
264 } | |
265 } | |
266 | |
0 | 267 /* compute bit allocation */ |
2967 | 268 |
0 | 269 i = start ; |
270 j = masktab[start] ; | |
271 do { | |
272 v=mask[j]; | |
273 v -= snroffset ; | |
274 v -= s->floor ; | |
275 if (v < 0) v = 0; | |
276 v &= 0x1fe0 ; | |
277 v += s->floor ; | |
278 | |
279 end1=bndtab[j] + bndsz[j]; | |
280 if (end1 > end) end1=end; | |
281 | |
282 for (k = i; k < end1; k++) { | |
283 address = (psd[i] - v) >> 5 ; | |
284 if (address < 0) address=0; | |
285 else if (address > 63) address=63; | |
286 bap[i] = baptab[address]; | |
287 i++; | |
288 } | |
289 } while (end > bndtab[j++]) ; | |
290 } | |
291 | |
292 typedef struct IComplex { | |
293 short re,im; | |
294 } IComplex; | |
295 | |
296 static void fft_init(int ln) | |
297 { | |
298 int i, j, m, n; | |
299 float alpha; | |
300 | |
301 n = 1 << ln; | |
302 | |
303 for(i=0;i<(n/2);i++) { | |
304 alpha = 2 * M_PI * (float)i / (float)n; | |
305 costab[i] = fix15(cos(alpha)); | |
306 sintab[i] = fix15(sin(alpha)); | |
307 } | |
308 | |
309 for(i=0;i<n;i++) { | |
310 m=0; | |
311 for(j=0;j<ln;j++) { | |
312 m |= ((i >> j) & 1) << (ln-j-1); | |
313 } | |
314 fft_rev[i]=m; | |
315 } | |
316 } | |
317 | |
318 /* butter fly op */ | |
319 #define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \ | |
320 {\ | |
321 int ax, ay, bx, by;\ | |
322 bx=pre1;\ | |
323 by=pim1;\ | |
324 ax=qre1;\ | |
325 ay=qim1;\ | |
326 pre = (bx + ax) >> 1;\ | |
327 pim = (by + ay) >> 1;\ | |
328 qre = (bx - ax) >> 1;\ | |
329 qim = (by - ay) >> 1;\ | |
330 } | |
331 | |
332 #define MUL16(a,b) ((a) * (b)) | |
333 | |
334 #define CMUL(pre, pim, are, aim, bre, bim) \ | |
335 {\ | |
336 pre = (MUL16(are, bre) - MUL16(aim, bim)) >> 15;\ | |
337 pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15;\ | |
338 } | |
339 | |
340 | |
341 /* do a 2^n point complex fft on 2^ln points. */ | |
342 static void fft(IComplex *z, int ln) | |
343 { | |
2979 | 344 int j, l, np, np2; |
345 int nblocks, nloops; | |
0 | 346 register IComplex *p,*q; |
347 int tmp_re, tmp_im; | |
348 | |
349 np = 1 << ln; | |
350 | |
351 /* reverse */ | |
352 for(j=0;j<np;j++) { | |
353 int k; | |
354 IComplex tmp; | |
355 k = fft_rev[j]; | |
356 if (k < j) { | |
357 tmp = z[k]; | |
358 z[k] = z[j]; | |
359 z[j] = tmp; | |
360 } | |
361 } | |
362 | |
363 /* pass 0 */ | |
364 | |
365 p=&z[0]; | |
366 j=(np >> 1); | |
367 do { | |
2967 | 368 BF(p[0].re, p[0].im, p[1].re, p[1].im, |
0 | 369 p[0].re, p[0].im, p[1].re, p[1].im); |
370 p+=2; | |
371 } while (--j != 0); | |
372 | |
373 /* pass 1 */ | |
374 | |
375 p=&z[0]; | |
376 j=np >> 2; | |
377 do { | |
2967 | 378 BF(p[0].re, p[0].im, p[2].re, p[2].im, |
0 | 379 p[0].re, p[0].im, p[2].re, p[2].im); |
2967 | 380 BF(p[1].re, p[1].im, p[3].re, p[3].im, |
0 | 381 p[1].re, p[1].im, p[3].im, -p[3].re); |
382 p+=4; | |
383 } while (--j != 0); | |
384 | |
385 /* pass 2 .. ln-1 */ | |
386 | |
387 nblocks = np >> 3; | |
388 nloops = 1 << 2; | |
389 np2 = np >> 1; | |
390 do { | |
391 p = z; | |
392 q = z + nloops; | |
393 for (j = 0; j < nblocks; ++j) { | |
394 | |
395 BF(p->re, p->im, q->re, q->im, | |
396 p->re, p->im, q->re, q->im); | |
2967 | 397 |
0 | 398 p++; |
399 q++; | |
400 for(l = nblocks; l < np2; l += nblocks) { | |
401 CMUL(tmp_re, tmp_im, costab[l], -sintab[l], q->re, q->im); | |
402 BF(p->re, p->im, q->re, q->im, | |
403 p->re, p->im, tmp_re, tmp_im); | |
404 p++; | |
405 q++; | |
406 } | |
407 p += nloops; | |
408 q += nloops; | |
409 } | |
410 nblocks = nblocks >> 1; | |
411 nloops = nloops << 1; | |
412 } while (nblocks != 0); | |
413 } | |
414 | |
415 /* do a 512 point mdct */ | |
1064 | 416 static void mdct512(int32_t *out, int16_t *in) |
0 | 417 { |
418 int i, re, im, re1, im1; | |
2967 | 419 int16_t rot[N]; |
0 | 420 IComplex x[N/4]; |
421 | |
422 /* shift to simplify computations */ | |
423 for(i=0;i<N/4;i++) | |
424 rot[i] = -in[i + 3*N/4]; | |
425 for(i=N/4;i<N;i++) | |
426 rot[i] = in[i - N/4]; | |
2967 | 427 |
0 | 428 /* pre rotation */ |
429 for(i=0;i<N/4;i++) { | |
430 re = ((int)rot[2*i] - (int)rot[N-1-2*i]) >> 1; | |
431 im = -((int)rot[N/2+2*i] - (int)rot[N/2-1-2*i]) >> 1; | |
432 CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]); | |
433 } | |
434 | |
435 fft(x, MDCT_NBITS - 2); | |
2967 | 436 |
0 | 437 /* post rotation */ |
438 for(i=0;i<N/4;i++) { | |
439 re = x[i].re; | |
440 im = x[i].im; | |
441 CMUL(re1, im1, re, im, xsin1[i], xcos1[i]); | |
442 out[2*i] = im1; | |
443 out[N/2-1-2*i] = re1; | |
444 } | |
445 } | |
446 | |
447 /* XXX: use another norm ? */ | |
1064 | 448 static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n) |
0 | 449 { |
450 int sum, i; | |
451 sum = 0; | |
452 for(i=0;i<n;i++) { | |
453 sum += abs(exp1[i] - exp2[i]); | |
454 } | |
455 return sum; | |
456 } | |
457 | |
1064 | 458 static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], |
459 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], | |
314 | 460 int ch, int is_lfe) |
0 | 461 { |
462 int i, j; | |
463 int exp_diff; | |
2967 | 464 |
0 | 465 /* estimate if the exponent variation & decide if they should be |
466 reused in the next frame */ | |
467 exp_strategy[0][ch] = EXP_NEW; | |
468 for(i=1;i<NB_BLOCKS;i++) { | |
469 exp_diff = calc_exp_diff(exp[i][ch], exp[i-1][ch], N/2); | |
2967 | 470 #ifdef DEBUG |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
471 av_log(NULL, AV_LOG_DEBUG, "exp_diff=%d\n", exp_diff); |
0 | 472 #endif |
473 if (exp_diff > EXP_DIFF_THRESHOLD) | |
474 exp_strategy[i][ch] = EXP_NEW; | |
475 else | |
476 exp_strategy[i][ch] = EXP_REUSE; | |
477 } | |
314 | 478 if (is_lfe) |
2979 | 479 return; |
314 | 480 |
0 | 481 /* now select the encoding strategy type : if exponents are often |
482 recoded, we use a coarse encoding */ | |
483 i = 0; | |
484 while (i < NB_BLOCKS) { | |
485 j = i + 1; | |
486 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) | |
487 j++; | |
488 switch(j - i) { | |
489 case 1: | |
490 exp_strategy[i][ch] = EXP_D45; | |
491 break; | |
492 case 2: | |
493 case 3: | |
494 exp_strategy[i][ch] = EXP_D25; | |
495 break; | |
496 default: | |
497 exp_strategy[i][ch] = EXP_D15; | |
498 break; | |
499 } | |
2979 | 500 i = j; |
0 | 501 } |
502 } | |
503 | |
504 /* set exp[i] to min(exp[i], exp1[i]) */ | |
1064 | 505 static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n) |
0 | 506 { |
507 int i; | |
508 | |
509 for(i=0;i<n;i++) { | |
510 if (exp1[i] < exp[i]) | |
511 exp[i] = exp1[i]; | |
512 } | |
513 } | |
2967 | 514 |
0 | 515 /* update the exponents so that they are the ones the decoder will |
516 decode. Return the number of bits used to code the exponents */ | |
2967 | 517 static int encode_exp(uint8_t encoded_exp[N/2], |
518 uint8_t exp[N/2], | |
0 | 519 int nb_exps, |
520 int exp_strategy) | |
521 { | |
2157
4478e603a8e3
simpler delta decreasing algorithm patch by (Jeff Muizelaar <jrmuizel at student dot cs dot uwaterloo dot ca>)
michael
parents:
1819
diff
changeset
|
522 int group_size, nb_groups, i, j, k, exp_min; |
1064 | 523 uint8_t exp1[N/2]; |
0 | 524 |
525 switch(exp_strategy) { | |
526 case EXP_D15: | |
527 group_size = 1; | |
528 break; | |
529 case EXP_D25: | |
530 group_size = 2; | |
531 break; | |
532 default: | |
533 case EXP_D45: | |
534 group_size = 4; | |
535 break; | |
536 } | |
537 nb_groups = ((nb_exps + (group_size * 3) - 4) / (3 * group_size)) * 3; | |
538 | |
539 /* for each group, compute the minimum exponent */ | |
540 exp1[0] = exp[0]; /* DC exponent is handled separately */ | |
541 k = 1; | |
542 for(i=1;i<=nb_groups;i++) { | |
543 exp_min = exp[k]; | |
544 assert(exp_min >= 0 && exp_min <= 24); | |
545 for(j=1;j<group_size;j++) { | |
546 if (exp[k+j] < exp_min) | |
547 exp_min = exp[k+j]; | |
548 } | |
549 exp1[i] = exp_min; | |
550 k += group_size; | |
551 } | |
552 | |
553 /* constraint for DC exponent */ | |
554 if (exp1[0] > 15) | |
555 exp1[0] = 15; | |
556 | |
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 /* 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
|
558 * 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
|
559 for (i=1;i<=nb_groups;i++) |
2979 | 560 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
|
561 for (i=nb_groups-1;i>=0;i--) |
2979 | 562 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
|
563 |
0 | 564 /* now we have the exponent values the decoder will see */ |
565 encoded_exp[0] = exp1[0]; | |
566 k = 1; | |
567 for(i=1;i<=nb_groups;i++) { | |
568 for(j=0;j<group_size;j++) { | |
569 encoded_exp[k+j] = exp1[i]; | |
570 } | |
571 k += group_size; | |
572 } | |
2967 | 573 |
0 | 574 #if defined(DEBUG) |
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, "exponents: strategy=%d\n", exp_strategy); |
0 | 576 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
|
577 av_log(NULL, AV_LOG_DEBUG, "%d ", encoded_exp[i]); |
0 | 578 } |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
579 av_log(NULL, AV_LOG_DEBUG, "\n"); |
0 | 580 #endif |
581 | |
582 return 4 + (nb_groups / 3) * 7; | |
583 } | |
584 | |
585 /* return the size in bits taken by the mantissa */ | |
1064 | 586 static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs) |
0 | 587 { |
588 int bits, mant, i; | |
589 | |
590 bits = 0; | |
591 for(i=0;i<nb_coefs;i++) { | |
592 mant = m[i]; | |
593 switch(mant) { | |
594 case 0: | |
595 /* nothing */ | |
596 break; | |
597 case 1: | |
598 /* 3 mantissa in 5 bits */ | |
2967 | 599 if (s->mant1_cnt == 0) |
0 | 600 bits += 5; |
601 if (++s->mant1_cnt == 3) | |
602 s->mant1_cnt = 0; | |
603 break; | |
604 case 2: | |
605 /* 3 mantissa in 7 bits */ | |
2967 | 606 if (s->mant2_cnt == 0) |
0 | 607 bits += 7; |
608 if (++s->mant2_cnt == 3) | |
609 s->mant2_cnt = 0; | |
610 break; | |
611 case 3: | |
612 bits += 3; | |
613 break; | |
614 case 4: | |
615 /* 2 mantissa in 7 bits */ | |
616 if (s->mant4_cnt == 0) | |
617 bits += 7; | |
2967 | 618 if (++s->mant4_cnt == 2) |
0 | 619 s->mant4_cnt = 0; |
620 break; | |
621 case 14: | |
622 bits += 14; | |
623 break; | |
624 case 15: | |
625 bits += 16; | |
626 break; | |
627 default: | |
628 bits += mant - 1; | |
629 break; | |
630 } | |
631 } | |
632 return bits; | |
633 } | |
634 | |
635 | |
636 static int bit_alloc(AC3EncodeContext *s, | |
1064 | 637 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], |
638 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], | |
639 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], | |
0 | 640 int frame_bits, int csnroffst, int fsnroffst) |
641 { | |
642 int i, ch; | |
643 | |
644 /* compute size */ | |
645 for(i=0;i<NB_BLOCKS;i++) { | |
646 s->mant1_cnt = 0; | |
647 s->mant2_cnt = 0; | |
648 s->mant4_cnt = 0; | |
314 | 649 for(ch=0;ch<s->nb_all_channels;ch++) { |
2967 | 650 ac3_parametric_bit_allocation(&s->bit_alloc, |
651 bap[i][ch], (int8_t *)encoded_exp[i][ch], | |
652 0, s->nb_coefs[ch], | |
653 (((csnroffst-15) << 4) + | |
654 fsnroffst) << 2, | |
782 | 655 fgaintab[s->fgaincod[ch]], |
656 ch == s->lfe_channel, | |
657 2, 0, NULL, NULL, NULL); | |
2967 | 658 frame_bits += compute_mantissa_size(s, bap[i][ch], |
0 | 659 s->nb_coefs[ch]); |
660 } | |
661 } | |
662 #if 0 | |
2967 | 663 printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n", |
664 csnroffst, fsnroffst, frame_bits, | |
0 | 665 16 * s->frame_size - ((frame_bits + 7) & ~7)); |
666 #endif | |
667 return 16 * s->frame_size - frame_bits; | |
668 } | |
669 | |
670 #define SNR_INC1 4 | |
671 | |
672 static int compute_bit_allocation(AC3EncodeContext *s, | |
1064 | 673 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], |
674 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], | |
675 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], | |
0 | 676 int frame_bits) |
677 { | |
678 int i, ch; | |
679 int csnroffst, fsnroffst; | |
1064 | 680 uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; |
314 | 681 static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; |
0 | 682 |
683 /* init default parameters */ | |
684 s->sdecaycod = 2; | |
685 s->fdecaycod = 1; | |
686 s->sgaincod = 1; | |
687 s->dbkneecod = 2; | |
688 s->floorcod = 4; | |
2967 | 689 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 690 s->fgaincod[ch] = 4; |
2967 | 691 |
0 | 692 /* compute real values */ |
782 | 693 s->bit_alloc.fscod = s->fscod; |
694 s->bit_alloc.halfratecod = s->halfratecod; | |
695 s->bit_alloc.sdecay = sdecaytab[s->sdecaycod] >> s->halfratecod; | |
696 s->bit_alloc.fdecay = fdecaytab[s->fdecaycod] >> s->halfratecod; | |
697 s->bit_alloc.sgain = sgaintab[s->sgaincod]; | |
698 s->bit_alloc.dbknee = dbkneetab[s->dbkneecod]; | |
699 s->bit_alloc.floor = floortab[s->floorcod]; | |
2967 | 700 |
0 | 701 /* header size */ |
702 frame_bits += 65; | |
314 | 703 // if (s->acmod == 2) |
704 // frame_bits += 2; | |
705 frame_bits += frame_bits_inc[s->acmod]; | |
0 | 706 |
707 /* audio blocks */ | |
708 for(i=0;i<NB_BLOCKS;i++) { | |
314 | 709 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
|
710 if (s->acmod == 2) { |
314 | 711 frame_bits++; /* rematstr */ |
2644
6ff5dc0dbaf0
While adding stereo rematrixing, I came across something that needs to
michael
parents:
2398
diff
changeset
|
712 if(i==0) frame_bits += 4; |
6ff5dc0dbaf0
While adding stereo rematrixing, I came across something that needs to
michael
parents:
2398
diff
changeset
|
713 } |
314 | 714 frame_bits += 2 * s->nb_channels; /* chexpstr[2] * c */ |
2979 | 715 if (s->lfe) |
716 frame_bits++; /* lfeexpstr */ | |
0 | 717 for(ch=0;ch<s->nb_channels;ch++) { |
718 if (exp_strategy[i][ch] != EXP_REUSE) | |
314 | 719 frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ |
0 | 720 } |
721 frame_bits++; /* baie */ | |
722 frame_bits++; /* snr */ | |
723 frame_bits += 2; /* delta / skip */ | |
724 } | |
725 frame_bits++; /* cplinu for block 0 */ | |
726 /* bit alloc info */ | |
314 | 727 /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */ |
728 /* csnroffset[6] */ | |
729 /* (fsnoffset[4] + fgaincod[4]) * c */ | |
730 frame_bits += 2*4 + 3 + 6 + s->nb_all_channels * (4 + 3); | |
0 | 731 |
1819
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
732 /* auxdatae, crcrsv */ |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
733 frame_bits += 2; |
34cdcb221665
auxdatae, crcrs fix by (Jean-Francois Panisset <panisset at comcast dot net>)
michael
parents:
1602
diff
changeset
|
734 |
0 | 735 /* CRC */ |
736 frame_bits += 16; | |
737 | |
738 /* now the big work begins : do the bit allocation. Modify the snr | |
739 offset until we can pack everything in the requested frame size */ | |
740 | |
741 csnroffst = s->csnroffst; | |
2967 | 742 while (csnroffst >= 0 && |
2979 | 743 bit_alloc(s, bap, encoded_exp, exp_strategy, frame_bits, csnroffst, 0) < 0) |
744 csnroffst -= SNR_INC1; | |
0 | 745 if (csnroffst < 0) { |
3221 | 746 av_log(NULL, AV_LOG_ERROR, "Bit allocation failed, try increasing the bitrate, -ab 384 for example!\n"); |
2979 | 747 return -1; |
0 | 748 } |
2967 | 749 while ((csnroffst + SNR_INC1) <= 63 && |
750 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 751 csnroffst + SNR_INC1, 0) >= 0) { |
752 csnroffst += SNR_INC1; | |
753 memcpy(bap, bap1, sizeof(bap1)); | |
754 } | |
2967 | 755 while ((csnroffst + 1) <= 63 && |
0 | 756 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, csnroffst + 1, 0) >= 0) { |
757 csnroffst++; | |
758 memcpy(bap, bap1, sizeof(bap1)); | |
759 } | |
760 | |
761 fsnroffst = 0; | |
2967 | 762 while ((fsnroffst + SNR_INC1) <= 15 && |
763 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 764 csnroffst, fsnroffst + SNR_INC1) >= 0) { |
765 fsnroffst += SNR_INC1; | |
766 memcpy(bap, bap1, sizeof(bap1)); | |
767 } | |
2967 | 768 while ((fsnroffst + 1) <= 15 && |
769 bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, | |
0 | 770 csnroffst, fsnroffst + 1) >= 0) { |
771 fsnroffst++; | |
772 memcpy(bap, bap1, sizeof(bap1)); | |
773 } | |
2967 | 774 |
0 | 775 s->csnroffst = csnroffst; |
314 | 776 for(ch=0;ch<s->nb_all_channels;ch++) |
0 | 777 s->fsnroffst[ch] = fsnroffst; |
778 #if defined(DEBUG_BITALLOC) | |
779 { | |
780 int j; | |
781 | |
782 for(i=0;i<6;i++) { | |
314 | 783 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 784 printf("Block #%d Ch%d:\n", i, ch); |
785 printf("bap="); | |
786 for(j=0;j<s->nb_coefs[ch];j++) { | |
787 printf("%d ",bap[i][ch][j]); | |
788 } | |
789 printf("\n"); | |
790 } | |
791 } | |
792 } | |
793 #endif | |
794 return 0; | |
795 } | |
796 | |
782 | 797 void ac3_common_init(void) |
798 { | |
799 int i, j, k, l, v; | |
800 /* compute bndtab and masktab from bandsz */ | |
801 k = 0; | |
802 l = 0; | |
803 for(i=0;i<50;i++) { | |
804 bndtab[i] = l; | |
805 v = bndsz[i]; | |
806 for(j=0;j<v;j++) masktab[k++]=i; | |
807 l += v; | |
808 } | |
3668
34d76180e5d0
Fix 2 bit allocation bugs. One fix enables using a higher bandwidth code. The other fixes an issue with floorcod=7.
jbr
parents:
3280
diff
changeset
|
809 bndtab[50] = l; |
782 | 810 } |
811 | |
812 | |
0 | 813 static int AC3_encode_init(AVCodecContext *avctx) |
814 { | |
815 int freq = avctx->sample_rate; | |
816 int bitrate = avctx->bit_rate; | |
817 int channels = avctx->channels; | |
818 AC3EncodeContext *s = avctx->priv_data; | |
782 | 819 int i, j, ch; |
0 | 820 float alpha; |
1064 | 821 static const uint8_t acmod_defs[6] = { |
2979 | 822 0x01, /* C */ |
823 0x02, /* L R */ | |
824 0x03, /* L C R */ | |
825 0x06, /* L R SL SR */ | |
826 0x07, /* L C R SL SR */ | |
827 0x07, /* L C R SL SR (+LFE) */ | |
314 | 828 }; |
0 | 829 |
830 avctx->frame_size = AC3_FRAME_SIZE; | |
2967 | 831 |
0 | 832 /* number of channels */ |
314 | 833 if (channels < 1 || channels > 6) |
2979 | 834 return -1; |
314 | 835 s->acmod = acmod_defs[channels - 1]; |
836 s->lfe = (channels == 6) ? 1 : 0; | |
837 s->nb_all_channels = channels; | |
838 s->nb_channels = channels > 5 ? 5 : channels; | |
839 s->lfe_channel = s->lfe ? 5 : -1; | |
0 | 840 |
841 /* frequency */ | |
842 for(i=0;i<3;i++) { | |
2967 | 843 for(j=0;j<3;j++) |
782 | 844 if ((ac3_freqs[j] >> i) == freq) |
0 | 845 goto found; |
846 } | |
847 return -1; | |
2967 | 848 found: |
0 | 849 s->sample_rate = freq; |
850 s->halfratecod = i; | |
851 s->fscod = j; | |
852 s->bsid = 8 + s->halfratecod; | |
853 s->bsmod = 0; /* complete main audio service */ | |
854 | |
855 /* bitrate & frame size */ | |
856 bitrate /= 1000; | |
857 for(i=0;i<19;i++) { | |
782 | 858 if ((ac3_bitratetab[i] >> s->halfratecod) == bitrate) |
0 | 859 break; |
860 } | |
861 if (i == 19) | |
862 return -1; | |
863 s->bit_rate = bitrate; | |
864 s->frmsizecod = i << 1; | |
865 s->frame_size_min = (bitrate * 1000 * AC3_FRAME_SIZE) / (freq * 16); | |
3246 | 866 s->bits_written = 0; |
867 s->samples_written = 0; | |
0 | 868 s->frame_size = s->frame_size_min; |
2967 | 869 |
0 | 870 /* bit allocation init */ |
871 for(ch=0;ch<s->nb_channels;ch++) { | |
872 /* bandwidth for each channel */ | |
873 /* XXX: should compute the bandwidth according to the frame | |
874 size, so that we avoid anoying high freq artefacts */ | |
875 s->chbwcod[ch] = 50; /* sample bandwidth as mpeg audio layer 2 table 0 */ | |
876 s->nb_coefs[ch] = ((s->chbwcod[ch] + 12) * 3) + 37; | |
877 } | |
314 | 878 if (s->lfe) { |
2979 | 879 s->nb_coefs[s->lfe_channel] = 7; /* fixed */ |
314 | 880 } |
0 | 881 /* initial snr offset */ |
882 s->csnroffst = 40; | |
883 | |
782 | 884 ac3_common_init(); |
0 | 885 |
886 /* mdct init */ | |
887 fft_init(MDCT_NBITS - 2); | |
888 for(i=0;i<N/4;i++) { | |
889 alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N; | |
890 xcos1[i] = fix15(-cos(alpha)); | |
891 xsin1[i] = fix15(-sin(alpha)); | |
892 } | |
893 | |
925 | 894 avctx->coded_frame= avcodec_alloc_frame(); |
895 avctx->coded_frame->key_frame= 1; | |
0 | 896 |
897 return 0; | |
898 } | |
899 | |
900 /* output the AC3 frame header */ | |
901 static void output_frame_header(AC3EncodeContext *s, unsigned char *frame) | |
902 { | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1408
diff
changeset
|
903 init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE); |
0 | 904 |
905 put_bits(&s->pb, 16, 0x0b77); /* frame header */ | |
906 put_bits(&s->pb, 16, 0); /* crc1: will be filled later */ | |
907 put_bits(&s->pb, 2, s->fscod); | |
908 put_bits(&s->pb, 6, s->frmsizecod + (s->frame_size - s->frame_size_min)); | |
909 put_bits(&s->pb, 5, s->bsid); | |
910 put_bits(&s->pb, 3, s->bsmod); | |
911 put_bits(&s->pb, 3, s->acmod); | |
314 | 912 if ((s->acmod & 0x01) && s->acmod != 0x01) |
2979 | 913 put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ |
314 | 914 if (s->acmod & 0x04) |
2979 | 915 put_bits(&s->pb, 2, 1); /* XXX -6 dB */ |
314 | 916 if (s->acmod == 0x02) |
0 | 917 put_bits(&s->pb, 2, 0); /* surround not indicated */ |
314 | 918 put_bits(&s->pb, 1, s->lfe); /* LFE */ |
0 | 919 put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */ |
920 put_bits(&s->pb, 1, 0); /* no compression control word */ | |
921 put_bits(&s->pb, 1, 0); /* no lang code */ | |
922 put_bits(&s->pb, 1, 0); /* no audio production info */ | |
923 put_bits(&s->pb, 1, 0); /* no copyright */ | |
924 put_bits(&s->pb, 1, 1); /* original bitstream */ | |
925 put_bits(&s->pb, 1, 0); /* no time code 1 */ | |
926 put_bits(&s->pb, 1, 0); /* no time code 2 */ | |
927 put_bits(&s->pb, 1, 0); /* no addtional bit stream info */ | |
928 } | |
929 | |
930 /* symetric quantization on 'levels' levels */ | |
931 static inline int sym_quant(int c, int e, int levels) | |
932 { | |
933 int v; | |
934 | |
935 if (c >= 0) { | |
87 | 936 v = (levels * (c << e)) >> 24; |
937 v = (v + 1) >> 1; | |
0 | 938 v = (levels >> 1) + v; |
939 } else { | |
87 | 940 v = (levels * ((-c) << e)) >> 24; |
941 v = (v + 1) >> 1; | |
0 | 942 v = (levels >> 1) - v; |
943 } | |
944 assert (v >= 0 && v < levels); | |
945 return v; | |
946 } | |
947 | |
948 /* asymetric quantization on 2^qbits levels */ | |
949 static inline int asym_quant(int c, int e, int qbits) | |
950 { | |
951 int lshift, m, v; | |
952 | |
953 lshift = e + qbits - 24; | |
954 if (lshift >= 0) | |
955 v = c << lshift; | |
956 else | |
957 v = c >> (-lshift); | |
958 /* rounding */ | |
959 v = (v + 1) >> 1; | |
960 m = (1 << (qbits-1)); | |
961 if (v >= m) | |
962 v = m - 1; | |
963 assert(v >= -m); | |
964 return v & ((1 << qbits)-1); | |
965 } | |
966 | |
967 /* Output one audio block. There are NB_BLOCKS audio blocks in one AC3 | |
968 frame */ | |
969 static void output_audio_block(AC3EncodeContext *s, | |
1064 | 970 uint8_t exp_strategy[AC3_MAX_CHANNELS], |
971 uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2], | |
972 uint8_t bap[AC3_MAX_CHANNELS][N/2], | |
973 int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2], | |
974 int8_t global_exp[AC3_MAX_CHANNELS], | |
0 | 975 int block_num) |
976 { | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
977 int ch, nb_groups, group_size, i, baie, rbnd; |
1064 | 978 uint8_t *p; |
979 uint16_t qmant[AC3_MAX_CHANNELS][N/2]; | |
0 | 980 int exp0, exp1; |
981 int mant1_cnt, mant2_cnt, mant4_cnt; | |
1064 | 982 uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; |
0 | 983 int delta0, delta1, delta2; |
984 | |
2967 | 985 for(ch=0;ch<s->nb_channels;ch++) |
0 | 986 put_bits(&s->pb, 1, 0); /* 512 point MDCT */ |
2967 | 987 for(ch=0;ch<s->nb_channels;ch++) |
0 | 988 put_bits(&s->pb, 1, 1); /* no dither */ |
989 put_bits(&s->pb, 1, 0); /* no dynamic range */ | |
990 if (block_num == 0) { | |
991 /* for block 0, even if no coupling, we must say it. This is a | |
992 waste of bit :-) */ | |
993 put_bits(&s->pb, 1, 1); /* coupling strategy present */ | |
994 put_bits(&s->pb, 1, 0); /* no coupling strategy */ | |
995 } else { | |
996 put_bits(&s->pb, 1, 0); /* no new coupling strategy */ | |
997 } | |
998 | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
999 if (s->acmod == 2) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1000 { |
2979 | 1001 if(block_num==0) |
1002 { | |
1003 /* first block must define rematrixing (rematstr) */ | |
1004 put_bits(&s->pb, 1, 1); | |
2967 | 1005 |
2979 | 1006 /* dummy rematrixing rematflg(1:4)=0 */ |
1007 for (rbnd=0;rbnd<4;rbnd++) | |
1008 put_bits(&s->pb, 1, 0); | |
1009 } | |
1010 else | |
1011 { | |
1012 /* no matrixing (but should be used in the future) */ | |
1013 put_bits(&s->pb, 1, 0); | |
1014 } | |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1015 } |
0 | 1016 |
2967 | 1017 #if defined(DEBUG) |
0 | 1018 { |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1019 static int count = 0; |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
1020 av_log(NULL, AV_LOG_DEBUG, "Block #%d (%d)\n", block_num, count++); |
0 | 1021 } |
1022 #endif | |
1023 /* exponent strategy */ | |
1024 for(ch=0;ch<s->nb_channels;ch++) { | |
1025 put_bits(&s->pb, 2, exp_strategy[ch]); | |
1026 } | |
2967 | 1027 |
314 | 1028 if (s->lfe) { |
2979 | 1029 put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]); |
314 | 1030 } |
1031 | |
0 | 1032 for(ch=0;ch<s->nb_channels;ch++) { |
1033 if (exp_strategy[ch] != EXP_REUSE) | |
1034 put_bits(&s->pb, 6, s->chbwcod[ch]); | |
1035 } | |
2967 | 1036 |
0 | 1037 /* exponents */ |
314 | 1038 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1039 switch(exp_strategy[ch]) { |
1040 case EXP_REUSE: | |
1041 continue; | |
1042 case EXP_D15: | |
1043 group_size = 1; | |
1044 break; | |
1045 case EXP_D25: | |
1046 group_size = 2; | |
1047 break; | |
1048 default: | |
1049 case EXP_D45: | |
1050 group_size = 4; | |
1051 break; | |
1052 } | |
2979 | 1053 nb_groups = (s->nb_coefs[ch] + (group_size * 3) - 4) / (3 * group_size); |
0 | 1054 p = encoded_exp[ch]; |
1055 | |
1056 /* first exponent */ | |
1057 exp1 = *p++; | |
1058 put_bits(&s->pb, 4, exp1); | |
1059 | |
1060 /* next ones are delta encoded */ | |
1061 for(i=0;i<nb_groups;i++) { | |
1062 /* merge three delta in one code */ | |
1063 exp0 = exp1; | |
1064 exp1 = p[0]; | |
1065 p += group_size; | |
1066 delta0 = exp1 - exp0 + 2; | |
1067 | |
1068 exp0 = exp1; | |
1069 exp1 = p[0]; | |
1070 p += group_size; | |
1071 delta1 = exp1 - exp0 + 2; | |
1072 | |
1073 exp0 = exp1; | |
1074 exp1 = p[0]; | |
1075 p += group_size; | |
1076 delta2 = exp1 - exp0 + 2; | |
1077 | |
1078 put_bits(&s->pb, 7, ((delta0 * 5 + delta1) * 5) + delta2); | |
1079 } | |
1080 | |
2979 | 1081 if (ch != s->lfe_channel) |
1082 put_bits(&s->pb, 2, 0); /* no gain range info */ | |
0 | 1083 } |
1084 | |
1085 /* bit allocation info */ | |
1086 baie = (block_num == 0); | |
1087 put_bits(&s->pb, 1, baie); | |
1088 if (baie) { | |
1089 put_bits(&s->pb, 2, s->sdecaycod); | |
1090 put_bits(&s->pb, 2, s->fdecaycod); | |
1091 put_bits(&s->pb, 2, s->sgaincod); | |
1092 put_bits(&s->pb, 2, s->dbkneecod); | |
1093 put_bits(&s->pb, 3, s->floorcod); | |
1094 } | |
1095 | |
1096 /* snr offset */ | |
1097 put_bits(&s->pb, 1, baie); /* always present with bai */ | |
1098 if (baie) { | |
1099 put_bits(&s->pb, 6, s->csnroffst); | |
314 | 1100 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 1101 put_bits(&s->pb, 4, s->fsnroffst[ch]); |
1102 put_bits(&s->pb, 3, s->fgaincod[ch]); | |
1103 } | |
1104 } | |
2967 | 1105 |
0 | 1106 put_bits(&s->pb, 1, 0); /* no delta bit allocation */ |
1107 put_bits(&s->pb, 1, 0); /* no data to skip */ | |
1108 | |
1109 /* mantissa encoding : we use two passes to handle the grouping. A | |
1110 one pass method may be faster, but it would necessitate to | |
1111 modify the output stream. */ | |
1112 | |
1113 /* first pass: quantize */ | |
1114 mant1_cnt = mant2_cnt = mant4_cnt = 0; | |
1115 qmant1_ptr = qmant2_ptr = qmant4_ptr = NULL; | |
1116 | |
314 | 1117 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1118 int b, c, e, v; |
1119 | |
1120 for(i=0;i<s->nb_coefs[ch];i++) { | |
1121 c = mdct_coefs[ch][i]; | |
1122 e = encoded_exp[ch][i] - global_exp[ch]; | |
1123 b = bap[ch][i]; | |
1124 switch(b) { | |
1125 case 0: | |
1126 v = 0; | |
1127 break; | |
1128 case 1: | |
1129 v = sym_quant(c, e, 3); | |
1130 switch(mant1_cnt) { | |
1131 case 0: | |
1132 qmant1_ptr = &qmant[ch][i]; | |
1133 v = 9 * v; | |
1134 mant1_cnt = 1; | |
1135 break; | |
1136 case 1: | |
1137 *qmant1_ptr += 3 * v; | |
1138 mant1_cnt = 2; | |
1139 v = 128; | |
1140 break; | |
1141 default: | |
1142 *qmant1_ptr += v; | |
1143 mant1_cnt = 0; | |
1144 v = 128; | |
1145 break; | |
1146 } | |
1147 break; | |
1148 case 2: | |
1149 v = sym_quant(c, e, 5); | |
1150 switch(mant2_cnt) { | |
1151 case 0: | |
1152 qmant2_ptr = &qmant[ch][i]; | |
1153 v = 25 * v; | |
1154 mant2_cnt = 1; | |
1155 break; | |
1156 case 1: | |
1157 *qmant2_ptr += 5 * v; | |
1158 mant2_cnt = 2; | |
1159 v = 128; | |
1160 break; | |
1161 default: | |
1162 *qmant2_ptr += v; | |
1163 mant2_cnt = 0; | |
1164 v = 128; | |
1165 break; | |
1166 } | |
1167 break; | |
1168 case 3: | |
1169 v = sym_quant(c, e, 7); | |
1170 break; | |
1171 case 4: | |
1172 v = sym_quant(c, e, 11); | |
1173 switch(mant4_cnt) { | |
1174 case 0: | |
1175 qmant4_ptr = &qmant[ch][i]; | |
1176 v = 11 * v; | |
1177 mant4_cnt = 1; | |
1178 break; | |
1179 default: | |
1180 *qmant4_ptr += v; | |
1181 mant4_cnt = 0; | |
1182 v = 128; | |
1183 break; | |
1184 } | |
1185 break; | |
1186 case 5: | |
1187 v = sym_quant(c, e, 15); | |
1188 break; | |
1189 case 14: | |
1190 v = asym_quant(c, e, 14); | |
1191 break; | |
1192 case 15: | |
1193 v = asym_quant(c, e, 16); | |
1194 break; | |
1195 default: | |
1196 v = asym_quant(c, e, b - 1); | |
1197 break; | |
1198 } | |
1199 qmant[ch][i] = v; | |
1200 } | |
1201 } | |
1202 | |
1203 /* second pass : output the values */ | |
314 | 1204 for (ch = 0; ch < s->nb_all_channels; ch++) { |
0 | 1205 int b, q; |
2967 | 1206 |
0 | 1207 for(i=0;i<s->nb_coefs[ch];i++) { |
1208 q = qmant[ch][i]; | |
1209 b = bap[ch][i]; | |
1210 switch(b) { | |
1211 case 0: | |
1212 break; | |
1213 case 1: | |
2967 | 1214 if (q != 128) |
0 | 1215 put_bits(&s->pb, 5, q); |
1216 break; | |
1217 case 2: | |
2967 | 1218 if (q != 128) |
0 | 1219 put_bits(&s->pb, 7, q); |
1220 break; | |
1221 case 3: | |
1222 put_bits(&s->pb, 3, q); | |
1223 break; | |
1224 case 4: | |
1225 if (q != 128) | |
1226 put_bits(&s->pb, 7, q); | |
1227 break; | |
1228 case 14: | |
1229 put_bits(&s->pb, 14, q); | |
1230 break; | |
1231 case 15: | |
1232 put_bits(&s->pb, 16, q); | |
1233 break; | |
1234 default: | |
1235 put_bits(&s->pb, b - 1, q); | |
1236 break; | |
1237 } | |
1238 } | |
1239 } | |
1240 } | |
1241 | |
1242 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16)) | |
1243 | |
1244 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly) | |
1245 { | |
1246 unsigned int c; | |
1247 | |
1248 c = 0; | |
1249 while (a) { | |
1250 if (a & 1) | |
1251 c ^= b; | |
1252 a = a >> 1; | |
1253 b = b << 1; | |
1254 if (b & (1 << 16)) | |
1255 b ^= poly; | |
1256 } | |
1257 return c; | |
1258 } | |
1259 | |
1260 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) | |
1261 { | |
1262 unsigned int r; | |
1263 r = 1; | |
1264 while (n) { | |
1265 if (n & 1) | |
1266 r = mul_poly(r, a, poly); | |
1267 a = mul_poly(a, a, poly); | |
1268 n >>= 1; | |
1269 } | |
1270 return r; | |
1271 } | |
1272 | |
1273 | |
1274 /* compute log2(max(abs(tab[]))) */ | |
1064 | 1275 static int log2_tab(int16_t *tab, int n) |
0 | 1276 { |
1277 int i, v; | |
1278 | |
1279 v = 0; | |
1280 for(i=0;i<n;i++) { | |
1281 v |= abs(tab[i]); | |
1282 } | |
65 | 1283 return av_log2(v); |
0 | 1284 } |
1285 | |
1064 | 1286 static void lshift_tab(int16_t *tab, int n, int lshift) |
0 | 1287 { |
1288 int i; | |
1289 | |
1290 if (lshift > 0) { | |
1291 for(i=0;i<n;i++) { | |
1292 tab[i] <<= lshift; | |
1293 } | |
1294 } else if (lshift < 0) { | |
1295 lshift = -lshift; | |
1296 for(i=0;i<n;i++) { | |
1297 tab[i] >>= lshift; | |
1298 } | |
1299 } | |
1300 } | |
1301 | |
1302 /* fill the end of the frame and compute the two crcs */ | |
1303 static int output_frame_end(AC3EncodeContext *s) | |
1304 { | |
1305 int frame_size, frame_size_58, n, crc1, crc2, crc_inv; | |
1064 | 1306 uint8_t *frame; |
0 | 1307 |
1308 frame_size = s->frame_size; /* frame size in words */ | |
1309 /* align to 8 bits */ | |
1310 flush_put_bits(&s->pb); | |
1311 /* add zero bytes to reach the frame size */ | |
1312 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
|
1313 n = 2 * s->frame_size - (pbBufPtr(&s->pb) - frame) - 2; |
0 | 1314 assert(n >= 0); |
1408
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1315 if(n>0) |
4d67eb341a0c
AC3 encoding patch ba (Ross Martin <ffmpeg at ross dot interwrx dot com>)
michaelni
parents:
1106
diff
changeset
|
1316 memset(pbBufPtr(&s->pb), 0, n); |
2967 | 1317 |
0 | 1318 /* Now we must compute both crcs : this is not so easy for crc1 |
1319 because it is at the beginning of the data... */ | |
1320 frame_size_58 = (frame_size >> 1) + (frame_size >> 3); | |
3170 | 1321 crc1 = bswap_16(av_crc(av_crc8005, 0, frame + 4, 2 * frame_size_58 - 4)); |
0 | 1322 /* XXX: could precompute crc_inv */ |
1323 crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY); | |
1324 crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); | |
1325 frame[2] = crc1 >> 8; | |
1326 frame[3] = crc1; | |
2967 | 1327 |
3170 | 1328 crc2 = bswap_16(av_crc(av_crc8005, 0, frame + 2 * frame_size_58, (frame_size - frame_size_58) * 2 - 2)); |
0 | 1329 frame[2*frame_size - 2] = crc2 >> 8; |
1330 frame[2*frame_size - 1] = crc2; | |
1331 | |
1332 // printf("n=%d frame_size=%d\n", n, frame_size); | |
1333 return frame_size * 2; | |
1334 } | |
1335 | |
782 | 1336 static int AC3_encode_frame(AVCodecContext *avctx, |
1337 unsigned char *frame, int buf_size, void *data) | |
0 | 1338 { |
1339 AC3EncodeContext *s = avctx->priv_data; | |
2367
c353719836af
fix some type mismatches patch by (Jeff Muizelaar <muizelaar rogers com>)
michael
parents:
2157
diff
changeset
|
1340 int16_t *samples = data; |
0 | 1341 int i, j, k, v, ch; |
1064 | 1342 int16_t input_samples[N]; |
1343 int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1344 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1345 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
1346 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1347 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; | |
1348 int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS]; | |
0 | 1349 int frame_bits; |
1350 | |
1351 frame_bits = 0; | |
314 | 1352 for(ch=0;ch<s->nb_all_channels;ch++) { |
0 | 1353 /* fixed mdct to the six sub blocks & exponent computation */ |
1354 for(i=0;i<NB_BLOCKS;i++) { | |
1064 | 1355 int16_t *sptr; |
0 | 1356 int sinc; |
1357 | |
1358 /* compute input samples */ | |
1064 | 1359 memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t)); |
314 | 1360 sinc = s->nb_all_channels; |
0 | 1361 sptr = samples + (sinc * (N/2) * i) + ch; |
1362 for(j=0;j<N/2;j++) { | |
1363 v = *sptr; | |
1364 input_samples[j + N/2] = v; | |
2967 | 1365 s->last_samples[ch][j] = v; |
0 | 1366 sptr += sinc; |
1367 } | |
1368 | |
1369 /* apply the MDCT window */ | |
1370 for(j=0;j<N/2;j++) { | |
2967 | 1371 input_samples[j] = MUL16(input_samples[j], |
0 | 1372 ac3_window[j]) >> 15; |
2967 | 1373 input_samples[N-j-1] = MUL16(input_samples[N-j-1], |
0 | 1374 ac3_window[j]) >> 15; |
1375 } | |
2967 | 1376 |
0 | 1377 /* Normalize the samples to use the maximum available |
1378 precision */ | |
1379 v = 14 - log2_tab(input_samples, N); | |
1380 if (v < 0) | |
1381 v = 0; | |
3258
8d42d21e570c
AC3 encoding volume fix, by Justin Ruggles jruggle earthlink net.
banan
parents:
3246
diff
changeset
|
1382 exp_samples[i][ch] = v - 9; |
0 | 1383 lshift_tab(input_samples, N, v); |
1384 | |
1385 /* do the MDCT */ | |
1386 mdct512(mdct_coef[i][ch], input_samples); | |
2967 | 1387 |
0 | 1388 /* compute "exponents". We take into account the |
1389 normalization there */ | |
1390 for(j=0;j<N/2;j++) { | |
1391 int e; | |
1392 v = abs(mdct_coef[i][ch][j]); | |
1393 if (v == 0) | |
1394 e = 24; | |
1395 else { | |
65 | 1396 e = 23 - av_log2(v) + exp_samples[i][ch]; |
0 | 1397 if (e >= 24) { |
1398 e = 24; | |
1399 mdct_coef[i][ch][j] = 0; | |
1400 } | |
1401 } | |
1402 exp[i][ch][j] = e; | |
1403 } | |
1404 } | |
2967 | 1405 |
314 | 1406 compute_exp_strategy(exp_strategy, exp, ch, ch == s->lfe_channel); |
0 | 1407 |
1408 /* compute the exponents as the decoder will see them. The | |
1409 EXP_REUSE case must be handled carefully : we select the | |
1410 min of the exponents */ | |
1411 i = 0; | |
1412 while (i < NB_BLOCKS) { | |
1413 j = i + 1; | |
1414 while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) { | |
1415 exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]); | |
1416 j++; | |
1417 } | |
1418 frame_bits += encode_exp(encoded_exp[i][ch], | |
2967 | 1419 exp[i][ch], s->nb_coefs[ch], |
0 | 1420 exp_strategy[i][ch]); |
1421 /* copy encoded exponents for reuse case */ | |
1422 for(k=i+1;k<j;k++) { | |
2967 | 1423 memcpy(encoded_exp[k][ch], encoded_exp[i][ch], |
1064 | 1424 s->nb_coefs[ch] * sizeof(uint8_t)); |
0 | 1425 } |
1426 i = j; | |
1427 } | |
1428 } | |
1429 | |
3246 | 1430 /* adjust for fractional frame sizes */ |
1431 while(s->bits_written >= s->bit_rate*1000 && s->samples_written >= s->sample_rate) { | |
1432 s->bits_written -= s->bit_rate*1000; | |
1433 s->samples_written -= s->sample_rate; | |
1434 } | |
1435 s->frame_size = s->frame_size_min + (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate*1000); | |
1436 s->bits_written += s->frame_size * 16; | |
1437 s->samples_written += AC3_FRAME_SIZE; | |
1438 | |
0 | 1439 compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits); |
1440 /* everything is known... let's output the frame */ | |
1441 output_frame_header(s, frame); | |
2967 | 1442 |
0 | 1443 for(i=0;i<NB_BLOCKS;i++) { |
2967 | 1444 output_audio_block(s, exp_strategy[i], encoded_exp[i], |
0 | 1445 bap[i], mdct_coef[i], exp_samples[i], i); |
1446 } | |
1447 return output_frame_end(s); | |
1448 } | |
1449 | |
925 | 1450 static int AC3_encode_close(AVCodecContext *avctx) |
1451 { | |
1452 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
|
1453 return 0; |
925 | 1454 } |
1455 | |
0 | 1456 #if 0 |
1457 /*************************************************************************/ | |
1458 /* TEST */ | |
1459 | |
1460 #define FN (N/4) | |
1461 | |
1462 void fft_test(void) | |
1463 { | |
1464 IComplex in[FN], in1[FN]; | |
1465 int k, n, i; | |
1466 float sum_re, sum_im, a; | |
1467 | |
1468 /* FFT test */ | |
1469 | |
1470 for(i=0;i<FN;i++) { | |
1471 in[i].re = random() % 65535 - 32767; | |
1472 in[i].im = random() % 65535 - 32767; | |
1473 in1[i] = in[i]; | |
1474 } | |
1475 fft(in, 7); | |
1476 | |
1477 /* do it by hand */ | |
1478 for(k=0;k<FN;k++) { | |
1479 sum_re = 0; | |
1480 sum_im = 0; | |
1481 for(n=0;n<FN;n++) { | |
1482 a = -2 * M_PI * (n * k) / FN; | |
1483 sum_re += in1[n].re * cos(a) - in1[n].im * sin(a); | |
1484 sum_im += in1[n].re * sin(a) + in1[n].im * cos(a); | |
1485 } | |
2967 | 1486 printf("%3d: %6d,%6d %6.0f,%6.0f\n", |
1487 k, in[k].re, in[k].im, sum_re / FN, sum_im / FN); | |
0 | 1488 } |
1489 } | |
1490 | |
1491 void mdct_test(void) | |
1492 { | |
1064 | 1493 int16_t input[N]; |
1494 int32_t output[N/2]; | |
0 | 1495 float input1[N]; |
1496 float output1[N/2]; | |
1497 float s, a, err, e, emax; | |
1498 int i, k, n; | |
1499 | |
1500 for(i=0;i<N;i++) { | |
1501 input[i] = (random() % 65535 - 32767) * 9 / 10; | |
1502 input1[i] = input[i]; | |
1503 } | |
1504 | |
1505 mdct512(output, input); | |
2967 | 1506 |
0 | 1507 /* do it by hand */ |
1508 for(k=0;k<N/2;k++) { | |
1509 s = 0; | |
1510 for(n=0;n<N;n++) { | |
1511 a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N)); | |
1512 s += input1[n] * cos(a); | |
1513 } | |
1514 output1[k] = -2 * s / N; | |
1515 } | |
2967 | 1516 |
0 | 1517 err = 0; |
1518 emax = 0; | |
1519 for(i=0;i<N/2;i++) { | |
1520 printf("%3d: %7d %7.0f\n", i, output[i], output1[i]); | |
1521 e = output[i] - output1[i]; | |
1522 if (e > emax) | |
1523 emax = e; | |
1524 err += e * e; | |
1525 } | |
1526 printf("err2=%f emax=%f\n", err / (N/2), emax); | |
1527 } | |
1528 | |
1529 void test_ac3(void) | |
1530 { | |
1531 AC3EncodeContext ctx; | |
1532 unsigned char frame[AC3_MAX_CODED_FRAME_SIZE]; | |
1533 short samples[AC3_FRAME_SIZE]; | |
1534 int ret, i; | |
2967 | 1535 |
0 | 1536 AC3_encode_init(&ctx, 44100, 64000, 1); |
1537 | |
1538 fft_test(); | |
1539 mdct_test(); | |
1540 | |
1541 for(i=0;i<AC3_FRAME_SIZE;i++) | |
1542 samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000); | |
1543 ret = AC3_encode_frame(&ctx, frame, samples); | |
1544 printf("ret=%d\n", ret); | |
1545 } | |
1546 #endif | |
1547 | |
1548 AVCodec ac3_encoder = { | |
1549 "ac3", | |
1550 CODEC_TYPE_AUDIO, | |
1551 CODEC_ID_AC3, | |
1552 sizeof(AC3EncodeContext), | |
1553 AC3_encode_init, | |
1554 AC3_encode_frame, | |
925 | 1555 AC3_encode_close, |
0 | 1556 NULL, |
1557 }; |