Mercurial > libavcodec.hg
annotate wma.c @ 5303:b8821ff5c30d libavcodec
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
initial commit
NOTE: This and all subsequent ac3dec.c revisions from the soc repository
violate the GPL. This will be fixed after all soc revisions are imported.
This file is not compiled yet, so the license compliance of any builds in
the meantime will not be affected.
author | jbr |
---|---|
date | Sat, 14 Jul 2007 15:38:39 +0000 |
parents | a10ebd496bd9 |
children | 04a241c308e8 |
rev | line source |
---|---|
4490 | 1 /* |
2 * WMA compatible codec | |
3 * Copyright (c) 2002-2007 The FFmpeg Project. | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 #include "avcodec.h" | |
23 #include "wma.h" | |
24 #include "wmadata.h" | |
25 | |
26 #undef NDEBUG | |
27 #include <assert.h> | |
28 | |
29 /* XXX: use same run/length optimization as mpeg decoders */ | |
30 //FIXME maybe split decode / encode or pass flag | |
31 static void init_coef_vlc(VLC *vlc, | |
32 uint16_t **prun_table, uint16_t **plevel_table, uint16_t **pint_table, | |
33 const CoefVLCTable *vlc_table) | |
34 { | |
35 int n = vlc_table->n; | |
36 const uint8_t *table_bits = vlc_table->huffbits; | |
37 const uint32_t *table_codes = vlc_table->huffcodes; | |
38 const uint16_t *levels_table = vlc_table->levels; | |
39 uint16_t *run_table, *level_table, *int_table; | |
40 int i, l, j, k, level; | |
41 | |
42 init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); | |
43 | |
44 run_table = av_malloc(n * sizeof(uint16_t)); | |
45 level_table = av_malloc(n * sizeof(uint16_t)); | |
46 int_table = av_malloc(n * sizeof(uint16_t)); | |
47 i = 2; | |
48 level = 1; | |
49 k = 0; | |
50 while (i < n) { | |
51 int_table[k]= i; | |
52 l = levels_table[k++]; | |
53 for(j=0;j<l;j++) { | |
54 run_table[i] = j; | |
55 level_table[i] = level; | |
56 i++; | |
57 } | |
58 level++; | |
59 } | |
60 *prun_table = run_table; | |
61 *plevel_table = level_table; | |
62 *pint_table= int_table; | |
63 } | |
64 | |
65 int ff_wma_init(AVCodecContext * avctx, int flags2) | |
66 { | |
4601 | 67 WMACodecContext *s = avctx->priv_data; |
4490 | 68 int i; |
69 float *window; | |
70 float bps1, high_freq; | |
71 volatile float bps; | |
72 int sample_rate1; | |
73 int coef_vlc_table; | |
74 | |
5086
a10ebd496bd9
sanity checks (should prevent hypothetical div by zero issue)
michael
parents:
4737
diff
changeset
|
75 if( avctx->sample_rate<=0 || avctx->sample_rate>50000 |
a10ebd496bd9
sanity checks (should prevent hypothetical div by zero issue)
michael
parents:
4737
diff
changeset
|
76 || avctx->channels<=0 || avctx->channels>8 |
a10ebd496bd9
sanity checks (should prevent hypothetical div by zero issue)
michael
parents:
4737
diff
changeset
|
77 || avctx->bit_rate<=0) |
a10ebd496bd9
sanity checks (should prevent hypothetical div by zero issue)
michael
parents:
4737
diff
changeset
|
78 return -1; |
a10ebd496bd9
sanity checks (should prevent hypothetical div by zero issue)
michael
parents:
4737
diff
changeset
|
79 |
4490 | 80 s->sample_rate = avctx->sample_rate; |
81 s->nb_channels = avctx->channels; | |
82 s->bit_rate = avctx->bit_rate; | |
83 s->block_align = avctx->block_align; | |
84 | |
85 dsputil_init(&s->dsp, avctx); | |
86 | |
87 if (avctx->codec->id == CODEC_ID_WMAV1) { | |
88 s->version = 1; | |
89 } else { | |
90 s->version = 2; | |
91 } | |
92 | |
93 /* compute MDCT block size */ | |
94 if (s->sample_rate <= 16000) { | |
95 s->frame_len_bits = 9; | |
96 } else if (s->sample_rate <= 22050 || | |
97 (s->sample_rate <= 32000 && s->version == 1)) { | |
98 s->frame_len_bits = 10; | |
99 } else { | |
100 s->frame_len_bits = 11; | |
101 } | |
102 s->frame_len = 1 << s->frame_len_bits; | |
103 if (s->use_variable_block_len) { | |
104 int nb_max, nb; | |
105 nb = ((flags2 >> 3) & 3) + 1; | |
106 if ((s->bit_rate / s->nb_channels) >= 32000) | |
107 nb += 2; | |
108 nb_max = s->frame_len_bits - BLOCK_MIN_BITS; | |
109 if (nb > nb_max) | |
110 nb = nb_max; | |
111 s->nb_block_sizes = nb + 1; | |
112 } else { | |
113 s->nb_block_sizes = 1; | |
114 } | |
115 | |
4588
fc155ff94878
cosmetics: Fix another common typo, dependAnt --> dependEnt.
diego
parents:
4490
diff
changeset
|
116 /* init rate dependent parameters */ |
4490 | 117 s->use_noise_coding = 1; |
118 high_freq = s->sample_rate * 0.5; | |
119 | |
120 /* if version 2, then the rates are normalized */ | |
121 sample_rate1 = s->sample_rate; | |
122 if (s->version == 2) { | |
123 if (sample_rate1 >= 44100) | |
124 sample_rate1 = 44100; | |
125 else if (sample_rate1 >= 22050) | |
126 sample_rate1 = 22050; | |
127 else if (sample_rate1 >= 16000) | |
128 sample_rate1 = 16000; | |
129 else if (sample_rate1 >= 11025) | |
130 sample_rate1 = 11025; | |
131 else if (sample_rate1 >= 8000) | |
132 sample_rate1 = 8000; | |
133 } | |
134 | |
135 bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); | |
136 s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; | |
137 | |
138 /* compute high frequency value and choose if noise coding should | |
139 be activated */ | |
140 bps1 = bps; | |
141 if (s->nb_channels == 2) | |
142 bps1 = bps * 1.6; | |
143 if (sample_rate1 == 44100) { | |
144 if (bps1 >= 0.61) | |
145 s->use_noise_coding = 0; | |
146 else | |
147 high_freq = high_freq * 0.4; | |
148 } else if (sample_rate1 == 22050) { | |
149 if (bps1 >= 1.16) | |
150 s->use_noise_coding = 0; | |
151 else if (bps1 >= 0.72) | |
152 high_freq = high_freq * 0.7; | |
153 else | |
154 high_freq = high_freq * 0.6; | |
155 } else if (sample_rate1 == 16000) { | |
156 if (bps > 0.5) | |
157 high_freq = high_freq * 0.5; | |
158 else | |
159 high_freq = high_freq * 0.3; | |
160 } else if (sample_rate1 == 11025) { | |
161 high_freq = high_freq * 0.7; | |
162 } else if (sample_rate1 == 8000) { | |
163 if (bps <= 0.625) { | |
164 high_freq = high_freq * 0.5; | |
165 } else if (bps > 0.75) { | |
166 s->use_noise_coding = 0; | |
167 } else { | |
168 high_freq = high_freq * 0.65; | |
169 } | |
170 } else { | |
171 if (bps >= 0.8) { | |
172 high_freq = high_freq * 0.75; | |
173 } else if (bps >= 0.6) { | |
174 high_freq = high_freq * 0.6; | |
175 } else { | |
176 high_freq = high_freq * 0.5; | |
177 } | |
178 } | |
4652 | 179 dprintf(s->avctx, "flags2=0x%x\n", flags2); |
180 dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", | |
4490 | 181 s->version, s->nb_channels, s->sample_rate, s->bit_rate, |
182 s->block_align); | |
4652 | 183 dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n", |
4490 | 184 bps, bps1, high_freq, s->byte_offset_bits); |
4652 | 185 dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", |
4490 | 186 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); |
187 | |
188 /* compute the scale factor band sizes for each MDCT block size */ | |
189 { | |
190 int a, b, pos, lpos, k, block_len, i, j, n; | |
191 const uint8_t *table; | |
192 | |
193 if (s->version == 1) { | |
194 s->coefs_start = 3; | |
195 } else { | |
196 s->coefs_start = 0; | |
197 } | |
198 for(k = 0; k < s->nb_block_sizes; k++) { | |
199 block_len = s->frame_len >> k; | |
200 | |
201 if (s->version == 1) { | |
202 lpos = 0; | |
203 for(i=0;i<25;i++) { | |
204 a = wma_critical_freqs[i]; | |
205 b = s->sample_rate; | |
206 pos = ((block_len * 2 * a) + (b >> 1)) / b; | |
207 if (pos > block_len) | |
208 pos = block_len; | |
209 s->exponent_bands[0][i] = pos - lpos; | |
210 if (pos >= block_len) { | |
211 i++; | |
212 break; | |
213 } | |
214 lpos = pos; | |
215 } | |
216 s->exponent_sizes[0] = i; | |
217 } else { | |
218 /* hardcoded tables */ | |
219 table = NULL; | |
220 a = s->frame_len_bits - BLOCK_MIN_BITS - k; | |
221 if (a < 3) { | |
222 if (s->sample_rate >= 44100) | |
223 table = exponent_band_44100[a]; | |
224 else if (s->sample_rate >= 32000) | |
225 table = exponent_band_32000[a]; | |
226 else if (s->sample_rate >= 22050) | |
227 table = exponent_band_22050[a]; | |
228 } | |
229 if (table) { | |
230 n = *table++; | |
231 for(i=0;i<n;i++) | |
232 s->exponent_bands[k][i] = table[i]; | |
233 s->exponent_sizes[k] = n; | |
234 } else { | |
235 j = 0; | |
236 lpos = 0; | |
237 for(i=0;i<25;i++) { | |
238 a = wma_critical_freqs[i]; | |
239 b = s->sample_rate; | |
240 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); | |
241 pos <<= 2; | |
242 if (pos > block_len) | |
243 pos = block_len; | |
244 if (pos > lpos) | |
245 s->exponent_bands[k][j++] = pos - lpos; | |
246 if (pos >= block_len) | |
247 break; | |
248 lpos = pos; | |
249 } | |
250 s->exponent_sizes[k] = j; | |
251 } | |
252 } | |
253 | |
254 /* max number of coefs */ | |
255 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; | |
256 /* high freq computation */ | |
257 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / | |
258 s->sample_rate + 0.5); | |
259 n = s->exponent_sizes[k]; | |
260 j = 0; | |
261 pos = 0; | |
262 for(i=0;i<n;i++) { | |
263 int start, end; | |
264 start = pos; | |
265 pos += s->exponent_bands[k][i]; | |
266 end = pos; | |
267 if (start < s->high_band_start[k]) | |
268 start = s->high_band_start[k]; | |
269 if (end > s->coefs_end[k]) | |
270 end = s->coefs_end[k]; | |
271 if (end > start) | |
272 s->exponent_high_bands[k][j++] = end - start; | |
273 } | |
274 s->exponent_high_sizes[k] = j; | |
275 #if 0 | |
4600 | 276 tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", |
4490 | 277 s->frame_len >> k, |
278 s->coefs_end[k], | |
279 s->high_band_start[k], | |
280 s->exponent_high_sizes[k]); | |
281 for(j=0;j<s->exponent_high_sizes[k];j++) | |
4600 | 282 tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); |
283 tprintf(s->avctx, "\n"); | |
4490 | 284 #endif |
285 } | |
286 } | |
287 | |
288 #ifdef TRACE | |
289 { | |
290 int i, j; | |
291 for(i = 0; i < s->nb_block_sizes; i++) { | |
4600 | 292 tprintf(s->avctx, "%5d: n=%2d:", |
4490 | 293 s->frame_len >> i, |
294 s->exponent_sizes[i]); | |
295 for(j=0;j<s->exponent_sizes[i];j++) | |
4600 | 296 tprintf(s->avctx, " %d", s->exponent_bands[i][j]); |
297 tprintf(s->avctx, "\n"); | |
4490 | 298 } |
299 } | |
300 #endif | |
301 | |
302 /* init MDCT windows : simple sinus window */ | |
303 for(i = 0; i < s->nb_block_sizes; i++) { | |
304 int n, j; | |
305 float alpha; | |
306 n = 1 << (s->frame_len_bits - i); | |
307 window = av_malloc(sizeof(float) * n); | |
308 alpha = M_PI / (2.0 * n); | |
309 for(j=0;j<n;j++) { | |
4737
99d9dd34903b
Optimize by building the mdct window and multipying/adding at the same time.
banan
parents:
4652
diff
changeset
|
310 window[j] = sin((j + 0.5) * alpha); |
4490 | 311 } |
312 s->windows[i] = window; | |
313 } | |
314 | |
315 s->reset_block_lengths = 1; | |
316 | |
317 if (s->use_noise_coding) { | |
318 | |
319 /* init the noise generator */ | |
320 if (s->use_exp_vlc) | |
321 s->noise_mult = 0.02; | |
322 else | |
323 s->noise_mult = 0.04; | |
324 | |
325 #ifdef TRACE | |
326 for(i=0;i<NOISE_TAB_SIZE;i++) | |
327 s->noise_table[i] = 1.0 * s->noise_mult; | |
328 #else | |
329 { | |
330 unsigned int seed; | |
331 float norm; | |
332 seed = 1; | |
333 norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; | |
334 for(i=0;i<NOISE_TAB_SIZE;i++) { | |
335 seed = seed * 314159 + 1; | |
336 s->noise_table[i] = (float)((int)seed) * norm; | |
337 } | |
338 } | |
339 #endif | |
340 } | |
341 | |
342 /* choose the VLC tables for the coefficients */ | |
343 coef_vlc_table = 2; | |
344 if (s->sample_rate >= 32000) { | |
345 if (bps1 < 0.72) | |
346 coef_vlc_table = 0; | |
347 else if (bps1 < 1.16) | |
348 coef_vlc_table = 1; | |
349 } | |
350 s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; | |
351 s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; | |
352 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], | |
353 s->coef_vlcs[0]); | |
354 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], | |
355 s->coef_vlcs[1]); | |
356 | |
357 return 0; | |
358 } | |
359 | |
360 int ff_wma_total_gain_to_bits(int total_gain){ | |
361 if (total_gain < 15) return 13; | |
362 else if (total_gain < 32) return 12; | |
363 else if (total_gain < 40) return 11; | |
364 else if (total_gain < 45) return 10; | |
365 else return 9; | |
366 } | |
367 | |
368 int ff_wma_end(AVCodecContext *avctx) | |
369 { | |
4601 | 370 WMACodecContext *s = avctx->priv_data; |
4490 | 371 int i; |
372 | |
373 for(i = 0; i < s->nb_block_sizes; i++) | |
374 ff_mdct_end(&s->mdct_ctx[i]); | |
375 for(i = 0; i < s->nb_block_sizes; i++) | |
376 av_free(s->windows[i]); | |
377 | |
378 if (s->use_exp_vlc) { | |
379 free_vlc(&s->exp_vlc); | |
380 } | |
381 if (s->use_noise_coding) { | |
382 free_vlc(&s->hgain_vlc); | |
383 } | |
384 for(i = 0;i < 2; i++) { | |
385 free_vlc(&s->coef_vlc[i]); | |
386 av_free(s->run_table[i]); | |
387 av_free(s->level_table[i]); | |
388 } | |
389 | |
390 return 0; | |
391 } |