Mercurial > libavcodec.hg
annotate mpegaudioenc.c @ 12494:94eaea836bf4 libavcodec
Check avctx width/height more thoroughly (e.g. all values 0 except width would
have been accepted before).
Also do not fail if they are invalid but instead override them to 0.
This allows decoding e.g. MPEG video when only the container values are corrupted.
For encoding a value of 0,0 of course makes no sense, but was allowed
through before and will be caught by an extra check in the encode function.
author | reimar |
---|---|
date | Wed, 15 Sep 2010 04:46:55 +0000 |
parents | dde20597f15e |
children |
rev | line source |
---|---|
0 | 1 /* |
2 * The simplest mpeg audio layer 2 encoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8595
diff
changeset
|
3 * Copyright (c) 2000, 2001 Fabrice Bellard |
0 | 4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
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:
3036
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:
3036
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:
3036
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 */ |
2967 | 21 |
1106 | 22 /** |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
23 * @file |
1106 | 24 * The simplest mpeg audio layer 2 encoder. |
25 */ | |
2967 | 26 |
64 | 27 #include "avcodec.h" |
9411
4cb7c65fc775
Split bitstream.h, put the bitstream writer stuff in the new file
stefano
parents:
8718
diff
changeset
|
28 #include "put_bits.h" |
8595 | 29 |
30 #undef CONFIG_MPEGAUDIO_HP | |
31 #define CONFIG_MPEGAUDIO_HP 0 | |
0 | 32 #include "mpegaudio.h" |
33 | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
34 /* currently, cannot change these constants (need to modify |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
35 quantization stage) */ |
1064 | 36 #define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS) |
84 | 37 |
38 #define SAMPLES_BUF_SIZE 4096 | |
39 | |
40 typedef struct MpegAudioContext { | |
41 PutBitContext pb; | |
42 int nb_channels; | |
43 int lsf; /* 1 if mpeg2 low bitrate selected */ | |
44 int bitrate_index; /* bit rate */ | |
45 int freq_index; | |
46 int frame_size; /* frame size, in bits, without padding */ | |
47 /* padding computation */ | |
48 int frame_frac, frame_frac_incr, do_padding; | |
49 short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */ | |
50 int samples_offset[MPA_MAX_CHANNELS]; /* offset in samples_buf */ | |
51 int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT]; | |
52 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */ | |
53 /* code to group 3 scale factors */ | |
2967 | 54 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT]; |
84 | 55 int sblimit; /* number of used subbands */ |
56 const unsigned char *alloc_table; | |
57 } MpegAudioContext; | |
58 | |
0 | 59 /* define it to use floats in quantization (I don't like floats !) */ |
10328
d4c97368f3e4
Use floating point mathematics when encoding mpeg audio.
cehoyos
parents:
10145
diff
changeset
|
60 #define USE_FLOATS |
0 | 61 |
5031
70f194a2ee53
move some common mpeg audio tables from mpegaudiodectab.h to mpegaudiodata.c
aurel
parents:
4885
diff
changeset
|
62 #include "mpegaudiodata.h" |
0 | 63 #include "mpegaudiotab.h" |
64 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
5161
diff
changeset
|
65 static av_cold int MPA_encode_init(AVCodecContext *avctx) |
0 | 66 { |
67 MpegAudioContext *s = avctx->priv_data; | |
68 int freq = avctx->sample_rate; | |
69 int bitrate = avctx->bit_rate; | |
70 int channels = avctx->channels; | |
84 | 71 int i, v, table; |
0 | 72 float a; |
73 | |
4885
4f351b1e02bc
check for channels<=0 and print a reasonable error message
alex
parents:
4472
diff
changeset
|
74 if (channels <= 0 || channels > 2){ |
4f351b1e02bc
check for channels<=0 and print a reasonable error message
alex
parents:
4472
diff
changeset
|
75 av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels); |
0 | 76 return -1; |
4885
4f351b1e02bc
check for channels<=0 and print a reasonable error message
alex
parents:
4472
diff
changeset
|
77 } |
0 | 78 bitrate = bitrate / 1000; |
79 s->nb_channels = channels; | |
80 avctx->frame_size = MPA_FRAME_SIZE; | |
81 | |
82 /* encoding freq */ | |
83 s->lsf = 0; | |
84 for(i=0;i<3;i++) { | |
5032 | 85 if (ff_mpa_freq_tab[i] == freq) |
0 | 86 break; |
5032 | 87 if ((ff_mpa_freq_tab[i] / 2) == freq) { |
0 | 88 s->lsf = 1; |
89 break; | |
90 } | |
91 } | |
2124 | 92 if (i == 3){ |
93 av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq); | |
0 | 94 return -1; |
2124 | 95 } |
0 | 96 s->freq_index = i; |
97 | |
98 /* encoding bitrate & frequency */ | |
99 for(i=0;i<15;i++) { | |
5032 | 100 if (ff_mpa_bitrate_tab[s->lsf][1][i] == bitrate) |
0 | 101 break; |
102 } | |
2124 | 103 if (i == 15){ |
104 av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate); | |
0 | 105 return -1; |
2124 | 106 } |
0 | 107 s->bitrate_index = i; |
108 | |
109 /* compute total header size & pad bit */ | |
2967 | 110 |
0 | 111 a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0); |
112 s->frame_size = ((int)a) * 8; | |
113 | |
114 /* frame fractional size to compute padding */ | |
115 s->frame_frac = 0; | |
116 s->frame_frac_incr = (int)((a - floor(a)) * 65536.0); | |
2967 | 117 |
0 | 118 /* select the right allocation table */ |
5052
d981eb275c8f
remove dependency of mpeg audio encoder over mpeg audio decoder
aurel
parents:
5032
diff
changeset
|
119 table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf); |
84 | 120 |
0 | 121 /* number of used subbands */ |
5032 | 122 s->sblimit = ff_mpa_sblimit_table[table]; |
123 s->alloc_table = ff_mpa_alloc_tables[table]; | |
0 | 124 |
9999
c78fd9154378
Change av_log() calls surrounded by '#ifdef DEBUG' into dprintf macros.
diego
parents:
9431
diff
changeset
|
125 dprintf(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n", |
c78fd9154378
Change av_log() calls surrounded by '#ifdef DEBUG' into dprintf macros.
diego
parents:
9431
diff
changeset
|
126 bitrate, freq, s->frame_size, table, s->frame_frac_incr); |
0 | 127 |
128 for(i=0;i<s->nb_channels;i++) | |
129 s->samples_offset[i] = 0; | |
130 | |
84 | 131 for(i=0;i<257;i++) { |
132 int v; | |
5032 | 133 v = ff_mpa_enwindow[i]; |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
134 #if WFRAC_BITS != 16 |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
135 v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS); |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
136 #endif |
84 | 137 filter_bank[i] = v; |
138 if ((i & 63) != 0) | |
139 v = -v; | |
140 if (i != 0) | |
141 filter_bank[512 - i] = v; | |
0 | 142 } |
84 | 143 |
0 | 144 for(i=0;i<64;i++) { |
145 v = (int)(pow(2.0, (3 - i) / 3.0) * (1 << 20)); | |
146 if (v <= 0) | |
147 v = 1; | |
148 scale_factor_table[i] = v; | |
149 #ifdef USE_FLOATS | |
150 scale_factor_inv_table[i] = pow(2.0, -(3 - i) / 3.0) / (float)(1 << 20); | |
151 #else | |
152 #define P 15 | |
153 scale_factor_shift[i] = 21 - P - (i / 3); | |
154 scale_factor_mult[i] = (1 << P) * pow(2.0, (i % 3) / 3.0); | |
155 #endif | |
156 } | |
157 for(i=0;i<128;i++) { | |
158 v = i - 64; | |
159 if (v <= -3) | |
160 v = 0; | |
161 else if (v < 0) | |
162 v = 1; | |
163 else if (v == 0) | |
164 v = 2; | |
165 else if (v < 3) | |
166 v = 3; | |
2967 | 167 else |
0 | 168 v = 4; |
169 scale_diff_table[i] = v; | |
170 } | |
171 | |
172 for(i=0;i<17;i++) { | |
5032 | 173 v = ff_mpa_quant_bits[i]; |
2967 | 174 if (v < 0) |
0 | 175 v = -v; |
176 else | |
177 v = v * 3; | |
178 total_quant_bits[i] = 12 * v; | |
179 } | |
180 | |
925 | 181 avctx->coded_frame= avcodec_alloc_frame(); |
182 avctx->coded_frame->key_frame= 1; | |
183 | |
0 | 184 return 0; |
185 } | |
186 | |
84 | 187 /* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */ |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
188 static void idct32(int *out, int *tab) |
0 | 189 { |
190 int i, j; | |
191 int *t, *t1, xr; | |
192 const int *xp = costab32; | |
193 | |
194 for(j=31;j>=3;j-=2) tab[j] += tab[j - 2]; | |
2967 | 195 |
0 | 196 t = tab + 30; |
197 t1 = tab + 2; | |
198 do { | |
199 t[0] += t[-4]; | |
200 t[1] += t[1 - 4]; | |
201 t -= 4; | |
202 } while (t != t1); | |
203 | |
204 t = tab + 28; | |
205 t1 = tab + 4; | |
206 do { | |
207 t[0] += t[-8]; | |
208 t[1] += t[1-8]; | |
209 t[2] += t[2-8]; | |
210 t[3] += t[3-8]; | |
211 t -= 8; | |
212 } while (t != t1); | |
2967 | 213 |
0 | 214 t = tab; |
215 t1 = tab + 32; | |
216 do { | |
2967 | 217 t[ 3] = -t[ 3]; |
218 t[ 6] = -t[ 6]; | |
219 | |
220 t[11] = -t[11]; | |
221 t[12] = -t[12]; | |
222 t[13] = -t[13]; | |
223 t[15] = -t[15]; | |
0 | 224 t += 16; |
225 } while (t != t1); | |
226 | |
2967 | 227 |
0 | 228 t = tab; |
229 t1 = tab + 8; | |
230 do { | |
231 int x1, x2, x3, x4; | |
2967 | 232 |
0 | 233 x3 = MUL(t[16], FIX(SQRT2*0.5)); |
234 x4 = t[0] - x3; | |
235 x3 = t[0] + x3; | |
2967 | 236 |
0 | 237 x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5)); |
238 x1 = MUL((t[8] - x2), xp[0]); | |
239 x2 = MUL((t[8] + x2), xp[1]); | |
240 | |
241 t[ 0] = x3 + x1; | |
242 t[ 8] = x4 - x2; | |
243 t[16] = x4 + x2; | |
244 t[24] = x3 - x1; | |
245 t++; | |
246 } while (t != t1); | |
247 | |
248 xp += 2; | |
249 t = tab; | |
250 t1 = tab + 4; | |
251 do { | |
252 xr = MUL(t[28],xp[0]); | |
253 t[28] = (t[0] - xr); | |
254 t[0] = (t[0] + xr); | |
255 | |
256 xr = MUL(t[4],xp[1]); | |
257 t[ 4] = (t[24] - xr); | |
258 t[24] = (t[24] + xr); | |
2967 | 259 |
0 | 260 xr = MUL(t[20],xp[2]); |
261 t[20] = (t[8] - xr); | |
262 t[ 8] = (t[8] + xr); | |
2967 | 263 |
0 | 264 xr = MUL(t[12],xp[3]); |
265 t[12] = (t[16] - xr); | |
266 t[16] = (t[16] + xr); | |
267 t++; | |
268 } while (t != t1); | |
269 xp += 4; | |
270 | |
271 for (i = 0; i < 4; i++) { | |
272 xr = MUL(tab[30-i*4],xp[0]); | |
273 tab[30-i*4] = (tab[i*4] - xr); | |
274 tab[ i*4] = (tab[i*4] + xr); | |
2967 | 275 |
0 | 276 xr = MUL(tab[ 2+i*4],xp[1]); |
277 tab[ 2+i*4] = (tab[28-i*4] - xr); | |
278 tab[28-i*4] = (tab[28-i*4] + xr); | |
2967 | 279 |
0 | 280 xr = MUL(tab[31-i*4],xp[0]); |
281 tab[31-i*4] = (tab[1+i*4] - xr); | |
282 tab[ 1+i*4] = (tab[1+i*4] + xr); | |
2967 | 283 |
0 | 284 xr = MUL(tab[ 3+i*4],xp[1]); |
285 tab[ 3+i*4] = (tab[29-i*4] - xr); | |
286 tab[29-i*4] = (tab[29-i*4] + xr); | |
2967 | 287 |
0 | 288 xp += 2; |
289 } | |
290 | |
291 t = tab + 30; | |
292 t1 = tab + 1; | |
293 do { | |
294 xr = MUL(t1[0], *xp); | |
295 t1[0] = (t[0] - xr); | |
296 t[0] = (t[0] + xr); | |
297 t -= 2; | |
298 t1 += 2; | |
299 xp++; | |
300 } while (t >= tab); | |
301 | |
302 for(i=0;i<32;i++) { | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
303 out[i] = tab[bitinv32[i]]; |
0 | 304 } |
305 } | |
306 | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
307 #define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS) |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
308 |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12034
diff
changeset
|
309 static void filter(MpegAudioContext *s, int ch, const short *samples, int incr) |
0 | 310 { |
311 short *p, *q; | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
312 int sum, offset, i, j; |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
313 int tmp[64]; |
0 | 314 int tmp1[32]; |
315 int *out; | |
316 | |
317 // print_pow1(samples, 1152); | |
318 | |
319 offset = s->samples_offset[ch]; | |
320 out = &s->sb_samples[ch][0][0][0]; | |
321 for(j=0;j<36;j++) { | |
322 /* 32 samples at once */ | |
323 for(i=0;i<32;i++) { | |
324 s->samples_buf[ch][offset + (31 - i)] = samples[0]; | |
325 samples += incr; | |
326 } | |
327 | |
328 /* filter */ | |
329 p = s->samples_buf[ch] + offset; | |
330 q = filter_bank; | |
331 /* maxsum = 23169 */ | |
332 for(i=0;i<64;i++) { | |
333 sum = p[0*64] * q[0*64]; | |
334 sum += p[1*64] * q[1*64]; | |
335 sum += p[2*64] * q[2*64]; | |
336 sum += p[3*64] * q[3*64]; | |
337 sum += p[4*64] * q[4*64]; | |
338 sum += p[5*64] * q[5*64]; | |
339 sum += p[6*64] * q[6*64]; | |
340 sum += p[7*64] * q[7*64]; | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
341 tmp[i] = sum; |
0 | 342 p++; |
343 q++; | |
344 } | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
345 tmp1[0] = tmp[16] >> WSHIFT; |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
346 for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT; |
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
347 for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT; |
0 | 348 |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
349 idct32(out, tmp1); |
0 | 350 |
351 /* advance of 32 samples */ | |
352 offset -= 32; | |
353 out += 32; | |
354 /* handle the wrap around */ | |
355 if (offset < 0) { | |
2967 | 356 memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32), |
0 | 357 s->samples_buf[ch], (512 - 32) * 2); |
358 offset = SAMPLES_BUF_SIZE - 512; | |
359 } | |
360 } | |
361 s->samples_offset[ch] = offset; | |
362 | |
363 // print_pow(s->sb_samples, 1152); | |
364 } | |
365 | |
366 static void compute_scale_factors(unsigned char scale_code[SBLIMIT], | |
2967 | 367 unsigned char scale_factors[SBLIMIT][3], |
0 | 368 int sb_samples[3][12][SBLIMIT], |
369 int sblimit) | |
370 { | |
371 int *p, vmax, v, n, i, j, k, code; | |
372 int index, d1, d2; | |
373 unsigned char *sf = &scale_factors[0][0]; | |
2967 | 374 |
0 | 375 for(j=0;j<sblimit;j++) { |
376 for(i=0;i<3;i++) { | |
377 /* find the max absolute value */ | |
378 p = &sb_samples[i][0][j]; | |
379 vmax = abs(*p); | |
380 for(k=1;k<12;k++) { | |
381 p += SBLIMIT; | |
382 v = abs(*p); | |
383 if (v > vmax) | |
384 vmax = v; | |
385 } | |
386 /* compute the scale factor index using log 2 computations */ | |
6961 | 387 if (vmax > 1) { |
70 | 388 n = av_log2(vmax); |
2967 | 389 /* n is the position of the MSB of vmax. now |
0 | 390 use at most 2 compares to find the index */ |
391 index = (21 - n) * 3 - 3; | |
392 if (index >= 0) { | |
393 while (vmax <= scale_factor_table[index+1]) | |
394 index++; | |
395 } else { | |
396 index = 0; /* very unlikely case of overflow */ | |
397 } | |
398 } else { | |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
399 index = 62; /* value 63 is not allowed */ |
0 | 400 } |
89
2e88e3afecd0
corrected mpeg audio encoding overflows - now it should give correct quality even for very high volumes
glantau
parents:
84
diff
changeset
|
401 |
0 | 402 #if 0 |
2967 | 403 printf("%2d:%d in=%x %x %d\n", |
0 | 404 j, i, vmax, scale_factor_table[index], index); |
405 #endif | |
406 /* store the scale factor */ | |
407 assert(index >=0 && index <= 63); | |
408 sf[i] = index; | |
409 } | |
410 | |
411 /* compute the transmission factor : look if the scale factors | |
412 are close enough to each other */ | |
413 d1 = scale_diff_table[sf[0] - sf[1] + 64]; | |
414 d2 = scale_diff_table[sf[1] - sf[2] + 64]; | |
2967 | 415 |
0 | 416 /* handle the 25 cases */ |
417 switch(d1 * 5 + d2) { | |
418 case 0*5+0: | |
419 case 0*5+4: | |
420 case 3*5+4: | |
421 case 4*5+0: | |
422 case 4*5+4: | |
423 code = 0; | |
424 break; | |
425 case 0*5+1: | |
426 case 0*5+2: | |
427 case 4*5+1: | |
428 case 4*5+2: | |
429 code = 3; | |
430 sf[2] = sf[1]; | |
431 break; | |
432 case 0*5+3: | |
433 case 4*5+3: | |
434 code = 3; | |
435 sf[1] = sf[2]; | |
436 break; | |
437 case 1*5+0: | |
438 case 1*5+4: | |
439 case 2*5+4: | |
440 code = 1; | |
441 sf[1] = sf[0]; | |
442 break; | |
443 case 1*5+1: | |
444 case 1*5+2: | |
445 case 2*5+0: | |
446 case 2*5+1: | |
447 case 2*5+2: | |
448 code = 2; | |
449 sf[1] = sf[2] = sf[0]; | |
450 break; | |
451 case 2*5+3: | |
452 case 3*5+3: | |
453 code = 2; | |
454 sf[0] = sf[1] = sf[2]; | |
455 break; | |
456 case 3*5+0: | |
457 case 3*5+1: | |
458 case 3*5+2: | |
459 code = 2; | |
460 sf[0] = sf[2] = sf[1]; | |
461 break; | |
462 case 1*5+3: | |
463 code = 2; | |
464 if (sf[0] > sf[2]) | |
465 sf[0] = sf[2]; | |
466 sf[1] = sf[2] = sf[0]; | |
467 break; | |
468 default: | |
5127 | 469 assert(0); //cannot happen |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2398
diff
changeset
|
470 code = 0; /* kill warning */ |
0 | 471 } |
2967 | 472 |
0 | 473 #if 0 |
2967 | 474 printf("%d: %2d %2d %2d %d %d -> %d\n", j, |
0 | 475 sf[0], sf[1], sf[2], d1, d2, code); |
476 #endif | |
477 scale_code[j] = code; | |
478 sf += 3; | |
479 } | |
480 } | |
481 | |
482 /* The most important function : psycho acoustic module. In this | |
483 encoder there is basically none, so this is the worst you can do, | |
484 but also this is the simpler. */ | |
485 static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT]) | |
486 { | |
487 int i; | |
488 | |
489 for(i=0;i<s->sblimit;i++) { | |
490 smr[i] = (int)(fixed_smr[i] * 10); | |
491 } | |
492 } | |
493 | |
494 | |
495 #define SB_NOTALLOCATED 0 | |
496 #define SB_ALLOCATED 1 | |
497 #define SB_NOMORE 2 | |
498 | |
499 /* Try to maximize the smr while using a number of bits inferior to | |
500 the frame size. I tried to make the code simpler, faster and | |
501 smaller than other encoders :-) */ | |
2967 | 502 static void compute_bit_allocation(MpegAudioContext *s, |
0 | 503 short smr1[MPA_MAX_CHANNELS][SBLIMIT], |
504 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT], | |
505 int *padding) | |
506 { | |
507 int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size; | |
508 int incr; | |
509 short smr[MPA_MAX_CHANNELS][SBLIMIT]; | |
510 unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT]; | |
511 const unsigned char *alloc; | |
512 | |
513 memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT); | |
514 memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT); | |
515 memset(bit_alloc, 0, s->nb_channels * SBLIMIT); | |
2967 | 516 |
0 | 517 /* compute frame size and padding */ |
518 max_frame_size = s->frame_size; | |
519 s->frame_frac += s->frame_frac_incr; | |
520 if (s->frame_frac >= 65536) { | |
521 s->frame_frac -= 65536; | |
522 s->do_padding = 1; | |
523 max_frame_size += 8; | |
524 } else { | |
525 s->do_padding = 0; | |
526 } | |
527 | |
528 /* compute the header + bit alloc size */ | |
529 current_frame_size = 32; | |
530 alloc = s->alloc_table; | |
531 for(i=0;i<s->sblimit;i++) { | |
532 incr = alloc[0]; | |
533 current_frame_size += incr * s->nb_channels; | |
534 alloc += 1 << incr; | |
535 } | |
536 for(;;) { | |
537 /* look for the subband with the largest signal to mask ratio */ | |
538 max_sb = -1; | |
539 max_ch = -1; | |
6929 | 540 max_smr = INT_MIN; |
0 | 541 for(ch=0;ch<s->nb_channels;ch++) { |
542 for(i=0;i<s->sblimit;i++) { | |
543 if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) { | |
544 max_smr = smr[ch][i]; | |
545 max_sb = i; | |
546 max_ch = ch; | |
547 } | |
548 } | |
549 } | |
550 #if 0 | |
2967 | 551 printf("current=%d max=%d max_sb=%d alloc=%d\n", |
0 | 552 current_frame_size, max_frame_size, max_sb, |
553 bit_alloc[max_sb]); | |
2967 | 554 #endif |
0 | 555 if (max_sb < 0) |
556 break; | |
2967 | 557 |
0 | 558 /* find alloc table entry (XXX: not optimal, should use |
559 pointer table) */ | |
560 alloc = s->alloc_table; | |
561 for(i=0;i<max_sb;i++) { | |
562 alloc += 1 << alloc[0]; | |
563 } | |
564 | |
565 if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) { | |
566 /* nothing was coded for this band: add the necessary bits */ | |
567 incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6; | |
568 incr += total_quant_bits[alloc[1]]; | |
569 } else { | |
570 /* increments bit allocation */ | |
571 b = bit_alloc[max_ch][max_sb]; | |
2967 | 572 incr = total_quant_bits[alloc[b + 1]] - |
0 | 573 total_quant_bits[alloc[b]]; |
574 } | |
575 | |
576 if (current_frame_size + incr <= max_frame_size) { | |
577 /* can increase size */ | |
578 b = ++bit_alloc[max_ch][max_sb]; | |
579 current_frame_size += incr; | |
580 /* decrease smr by the resolution we added */ | |
581 smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]]; | |
582 /* max allocation size reached ? */ | |
583 if (b == ((1 << alloc[0]) - 1)) | |
584 subband_status[max_ch][max_sb] = SB_NOMORE; | |
585 else | |
586 subband_status[max_ch][max_sb] = SB_ALLOCATED; | |
587 } else { | |
588 /* cannot increase the size of this subband */ | |
589 subband_status[max_ch][max_sb] = SB_NOMORE; | |
590 } | |
591 } | |
592 *padding = max_frame_size - current_frame_size; | |
593 assert(*padding >= 0); | |
594 | |
595 #if 0 | |
596 for(i=0;i<s->sblimit;i++) { | |
597 printf("%d ", bit_alloc[i]); | |
598 } | |
599 printf("\n"); | |
600 #endif | |
601 } | |
602 | |
603 /* | |
604 * Output the mpeg audio layer 2 frame. Note how the code is small | |
605 * compared to other encoders :-) | |
606 */ | |
607 static void encode_frame(MpegAudioContext *s, | |
608 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT], | |
609 int padding) | |
610 { | |
611 int i, j, k, l, bit_alloc_bits, b, ch; | |
612 unsigned char *sf; | |
613 int q[3]; | |
614 PutBitContext *p = &s->pb; | |
615 | |
616 /* header */ | |
617 | |
618 put_bits(p, 12, 0xfff); | |
619 put_bits(p, 1, 1 - s->lsf); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */ | |
620 put_bits(p, 2, 4-2); /* layer 2 */ | |
621 put_bits(p, 1, 1); /* no error protection */ | |
622 put_bits(p, 4, s->bitrate_index); | |
623 put_bits(p, 2, s->freq_index); | |
624 put_bits(p, 1, s->do_padding); /* use padding */ | |
625 put_bits(p, 1, 0); /* private_bit */ | |
626 put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO); | |
627 put_bits(p, 2, 0); /* mode_ext */ | |
628 put_bits(p, 1, 0); /* no copyright */ | |
629 put_bits(p, 1, 1); /* original */ | |
630 put_bits(p, 2, 0); /* no emphasis */ | |
631 | |
632 /* bit allocation */ | |
633 j = 0; | |
634 for(i=0;i<s->sblimit;i++) { | |
635 bit_alloc_bits = s->alloc_table[j]; | |
636 for(ch=0;ch<s->nb_channels;ch++) { | |
637 put_bits(p, bit_alloc_bits, bit_alloc[ch][i]); | |
638 } | |
639 j += 1 << bit_alloc_bits; | |
640 } | |
2967 | 641 |
0 | 642 /* scale codes */ |
643 for(i=0;i<s->sblimit;i++) { | |
644 for(ch=0;ch<s->nb_channels;ch++) { | |
2967 | 645 if (bit_alloc[ch][i]) |
0 | 646 put_bits(p, 2, s->scale_code[ch][i]); |
647 } | |
648 } | |
649 | |
650 /* scale factors */ | |
651 for(i=0;i<s->sblimit;i++) { | |
652 for(ch=0;ch<s->nb_channels;ch++) { | |
653 if (bit_alloc[ch][i]) { | |
654 sf = &s->scale_factors[ch][i][0]; | |
655 switch(s->scale_code[ch][i]) { | |
656 case 0: | |
657 put_bits(p, 6, sf[0]); | |
658 put_bits(p, 6, sf[1]); | |
659 put_bits(p, 6, sf[2]); | |
660 break; | |
661 case 3: | |
662 case 1: | |
663 put_bits(p, 6, sf[0]); | |
664 put_bits(p, 6, sf[2]); | |
665 break; | |
666 case 2: | |
667 put_bits(p, 6, sf[0]); | |
668 break; | |
669 } | |
670 } | |
671 } | |
672 } | |
2967 | 673 |
0 | 674 /* quantization & write sub band samples */ |
675 | |
676 for(k=0;k<3;k++) { | |
677 for(l=0;l<12;l+=3) { | |
678 j = 0; | |
679 for(i=0;i<s->sblimit;i++) { | |
680 bit_alloc_bits = s->alloc_table[j]; | |
681 for(ch=0;ch<s->nb_channels;ch++) { | |
682 b = bit_alloc[ch][i]; | |
683 if (b) { | |
684 int qindex, steps, m, sample, bits; | |
685 /* we encode 3 sub band samples of the same sub band at a time */ | |
686 qindex = s->alloc_table[j+b]; | |
5032 | 687 steps = ff_mpa_quant_steps[qindex]; |
0 | 688 for(m=0;m<3;m++) { |
689 sample = s->sb_samples[ch][k][l + m][i]; | |
690 /* divide by scale factor */ | |
691 #ifdef USE_FLOATS | |
692 { | |
693 float a; | |
694 a = (float)sample * scale_factor_inv_table[s->scale_factors[ch][i][k]]; | |
695 q[m] = (int)((a + 1.0) * steps * 0.5); | |
696 } | |
697 #else | |
698 { | |
699 int q1, e, shift, mult; | |
700 e = s->scale_factors[ch][i][k]; | |
701 shift = scale_factor_shift[e]; | |
702 mult = scale_factor_mult[e]; | |
2967 | 703 |
0 | 704 /* normalize to P bits */ |
705 if (shift < 0) | |
706 q1 = sample << (-shift); | |
707 else | |
708 q1 = sample >> shift; | |
709 q1 = (q1 * mult) >> P; | |
710 q[m] = ((q1 + (1 << P)) * steps) >> (P + 1); | |
711 } | |
712 #endif | |
713 if (q[m] >= steps) | |
714 q[m] = steps - 1; | |
715 assert(q[m] >= 0 && q[m] < steps); | |
716 } | |
5032 | 717 bits = ff_mpa_quant_bits[qindex]; |
0 | 718 if (bits < 0) { |
719 /* group the 3 values to save bits */ | |
2967 | 720 put_bits(p, -bits, |
0 | 721 q[0] + steps * (q[1] + steps * q[2])); |
722 #if 0 | |
2967 | 723 printf("%d: gr1 %d\n", |
0 | 724 i, q[0] + steps * (q[1] + steps * q[2])); |
725 #endif | |
726 } else { | |
727 #if 0 | |
2967 | 728 printf("%d: gr3 %d %d %d\n", |
0 | 729 i, q[0], q[1], q[2]); |
2967 | 730 #endif |
0 | 731 put_bits(p, bits, q[0]); |
732 put_bits(p, bits, q[1]); | |
733 put_bits(p, bits, q[2]); | |
734 } | |
735 } | |
736 } | |
737 /* next subband in alloc table */ | |
2967 | 738 j += 1 << bit_alloc_bits; |
0 | 739 } |
740 } | |
741 } | |
742 | |
743 /* padding */ | |
744 for(i=0;i<padding;i++) | |
745 put_bits(p, 1, 0); | |
746 | |
747 /* flush */ | |
748 flush_put_bits(p); | |
749 } | |
750 | |
1057 | 751 static int MPA_encode_frame(AVCodecContext *avctx, |
2979 | 752 unsigned char *frame, int buf_size, void *data) |
0 | 753 { |
754 MpegAudioContext *s = avctx->priv_data; | |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12034
diff
changeset
|
755 const short *samples = data; |
0 | 756 short smr[MPA_MAX_CHANNELS][SBLIMIT]; |
757 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT]; | |
758 int padding, i; | |
759 | |
760 for(i=0;i<s->nb_channels;i++) { | |
761 filter(s, i, samples + i, s->nb_channels); | |
762 } | |
763 | |
764 for(i=0;i<s->nb_channels;i++) { | |
2967 | 765 compute_scale_factors(s->scale_code[i], s->scale_factors[i], |
0 | 766 s->sb_samples[i], s->sblimit); |
767 } | |
768 for(i=0;i<s->nb_channels;i++) { | |
769 psycho_acoustic_model(s, smr[i]); | |
770 } | |
771 compute_bit_allocation(s, smr, bit_alloc, &padding); | |
772 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1106
diff
changeset
|
773 init_put_bits(&s->pb, frame, MPA_MAX_CODED_FRAME_SIZE); |
0 | 774 |
775 encode_frame(s, bit_alloc, padding); | |
2967 | 776 |
9431 | 777 return put_bits_ptr(&s->pb) - s->pb.buf; |
0 | 778 } |
779 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
5161
diff
changeset
|
780 static av_cold int MPA_encode_close(AVCodecContext *avctx) |
925 | 781 { |
782 av_freep(&avctx->coded_frame); | |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
925
diff
changeset
|
783 return 0; |
925 | 784 } |
0 | 785 |
786 AVCodec mp2_encoder = { | |
787 "mp2", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10328
diff
changeset
|
788 AVMEDIA_TYPE_AUDIO, |
0 | 789 CODEC_ID_MP2, |
790 sizeof(MpegAudioContext), | |
791 MPA_encode_init, | |
792 MPA_encode_frame, | |
925 | 793 MPA_encode_close, |
0 | 794 NULL, |
10145
7955db355703
Make sample_fmts and channel_layouts compound literals const to reduce size of
reimar
parents:
9999
diff
changeset
|
795 .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, |
11654
fe105c6d28c7
Set .supported_samplerates for mpeg audio encoders.
michael
parents:
11644
diff
changeset
|
796 .supported_samplerates= (const int[]){44100, 48000, 32000, 22050, 24000, 16000, 0}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6961
diff
changeset
|
797 .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"), |
0 | 798 }; |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
799 |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
800 #undef FIX |