ffmpeg / libavcodec / wma.c @ cee4bb89
History  View  Annotate  Download (12.7 KB)
1 
/*


2 
* WMA compatible codec

3 
* Copyright (c) 20022007 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 021101301 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, uint16_t **prun_table, 
32 
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 
/**

66 
*@brief Get the samples per frame for this stream.

67 
*@param sample_rate output sample_rate

68 
*@param version wma version

69 
*@param decode_flags codec compression features

70 
*@return log2 of the number of output samples per frame

71 
*/

72 
int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, 
73 
unsigned int decode_flags) 
74 
{ 
75  
76 
int frame_len_bits;

77  
78 
if (sample_rate <= 16000) 
79 
frame_len_bits = 9;

80 
else if (sample_rate <= 22050  
81 
(sample_rate <= 32000 && version == 1)) 
82 
frame_len_bits = 10;

83 
else

84 
frame_len_bits = 11;

85  
86 
return frame_len_bits;

87 
} 
88  
89 
int ff_wma_init(AVCodecContext *avctx, int flags2) 
90 
{ 
91 
WMACodecContext *s = avctx>priv_data; 
92 
int i;

93 
float bps1, high_freq;

94 
volatile float bps; 
95 
int sample_rate1;

96 
int coef_vlc_table;

97  
98 
if ( avctx>sample_rate <= 0  avctx>sample_rate > 50000 
99 
 avctx>channels <= 0  avctx>channels > 8 
100 
 avctx>bit_rate <= 0)

101 
return 1; 
102  
103 
s>sample_rate = avctx>sample_rate; 
104 
s>nb_channels = avctx>channels; 
105 
s>bit_rate = avctx>bit_rate; 
106 
s>block_align = avctx>block_align; 
107  
108 
dsputil_init(&s>dsp, avctx); 
109  
110 
if (avctx>codec>id == CODEC_ID_WMAV1) {

111 
s>version = 1;

112 
} else {

113 
s>version = 2;

114 
} 
115  
116 
/* compute MDCT block size */

117 
s>frame_len_bits = ff_wma_get_frame_len_bits(s>sample_rate, s>version, 0);

118  
119 
s>frame_len = 1 << s>frame_len_bits;

120 
if (s>use_variable_block_len) {

121 
int nb_max, nb;

122 
nb = ((flags2 >> 3) & 3) + 1; 
123 
if ((s>bit_rate / s>nb_channels) >= 32000) 
124 
nb += 2;

125 
nb_max = s>frame_len_bits  BLOCK_MIN_BITS; 
126 
if (nb > nb_max)

127 
nb = nb_max; 
128 
s>nb_block_sizes = nb + 1;

129 
} else {

130 
s>nb_block_sizes = 1;

131 
} 
132  
133 
/* init rate dependent parameters */

134 
s>use_noise_coding = 1;

135 
high_freq = s>sample_rate * 0.5; 
136  
137 
/* if version 2, then the rates are normalized */

138 
sample_rate1 = s>sample_rate; 
139 
if (s>version == 2) { 
140 
if (sample_rate1 >= 44100) 
141 
sample_rate1 = 44100;

142 
else if (sample_rate1 >= 22050) 
143 
sample_rate1 = 22050;

144 
else if (sample_rate1 >= 16000) 
145 
sample_rate1 = 16000;

146 
else if (sample_rate1 >= 11025) 
147 
sample_rate1 = 11025;

148 
else if (sample_rate1 >= 8000) 
149 
sample_rate1 = 8000;

150 
} 
151  
152 
bps = (float)s>bit_rate / (float)(s>nb_channels * s>sample_rate); 
153 
s>byte_offset_bits = av_log2((int)(bps * s>frame_len / 8.0 + 0.5)) + 2; 
154  
155 
/* compute high frequency value and choose if noise coding should

156 
be activated */

157 
bps1 = bps; 
158 
if (s>nb_channels == 2) 
159 
bps1 = bps * 1.6; 
160 
if (sample_rate1 == 44100) { 
161 
if (bps1 >= 0.61) 
162 
s>use_noise_coding = 0;

163 
else

164 
high_freq = high_freq * 0.4; 
165 
} else if (sample_rate1 == 22050) { 
166 
if (bps1 >= 1.16) 
167 
s>use_noise_coding = 0;

168 
else if (bps1 >= 0.72) 
169 
high_freq = high_freq * 0.7; 
170 
else

171 
high_freq = high_freq * 0.6; 
172 
} else if (sample_rate1 == 16000) { 
173 
if (bps > 0.5) 
174 
high_freq = high_freq * 0.5; 
175 
else

176 
high_freq = high_freq * 0.3; 
177 
} else if (sample_rate1 == 11025) { 
178 
high_freq = high_freq * 0.7; 
179 
} else if (sample_rate1 == 8000) { 
180 
if (bps <= 0.625) { 
181 
high_freq = high_freq * 0.5; 
182 
} else if (bps > 0.75) { 
183 
s>use_noise_coding = 0;

184 
} else {

185 
high_freq = high_freq * 0.65; 
186 
} 
187 
} else {

188 
if (bps >= 0.8) { 
189 
high_freq = high_freq * 0.75; 
190 
} else if (bps >= 0.6) { 
191 
high_freq = high_freq * 0.6; 
192 
} else {

193 
high_freq = high_freq * 0.5; 
194 
} 
195 
} 
196 
dprintf(s>avctx, "flags2=0x%x\n", flags2);

197 
dprintf(s>avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",

198 
s>version, s>nb_channels, s>sample_rate, s>bit_rate, 
199 
s>block_align); 
200 
dprintf(s>avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",

201 
bps, bps1, high_freq, s>byte_offset_bits); 
202 
dprintf(s>avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",

203 
s>use_noise_coding, s>use_exp_vlc, s>nb_block_sizes); 
204  
205 
/* compute the scale factor band sizes for each MDCT block size */

206 
{ 
207 
int a, b, pos, lpos, k, block_len, i, j, n;

208 
const uint8_t *table;

209  
210 
if (s>version == 1) { 
211 
s>coefs_start = 3;

212 
} else {

213 
s>coefs_start = 0;

214 
} 
215 
for (k = 0; k < s>nb_block_sizes; k++) { 
216 
block_len = s>frame_len >> k; 
217  
218 
if (s>version == 1) { 
219 
lpos = 0;

220 
for (i = 0; i < 25; i++) { 
221 
a = wma_critical_freqs[i]; 
222 
b = s>sample_rate; 
223 
pos = ((block_len * 2 * a) + (b >> 1)) / b; 
224 
if (pos > block_len)

225 
pos = block_len; 
226 
s>exponent_bands[0][i] = pos  lpos;

227 
if (pos >= block_len) {

228 
i++; 
229 
break;

230 
} 
231 
lpos = pos; 
232 
} 
233 
s>exponent_sizes[0] = i;

234 
} else {

235 
/* hardcoded tables */

236 
table = NULL;

237 
a = s>frame_len_bits  BLOCK_MIN_BITS  k; 
238 
if (a < 3) { 
239 
if (s>sample_rate >= 44100) 
240 
table = exponent_band_44100[a]; 
241 
else if (s>sample_rate >= 32000) 
242 
table = exponent_band_32000[a]; 
243 
else if (s>sample_rate >= 22050) 
244 
table = exponent_band_22050[a]; 
245 
} 
246 
if (table) {

247 
n = *table++; 
248 
for (i = 0; i < n; i++) 
249 
s>exponent_bands[k][i] = table[i]; 
250 
s>exponent_sizes[k] = n; 
251 
} else {

252 
j = 0;

253 
lpos = 0;

254 
for (i = 0; i < 25; i++) { 
255 
a = wma_critical_freqs[i]; 
256 
b = s>sample_rate; 
257 
pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 
258 
pos <<= 2;

259 
if (pos > block_len)

260 
pos = block_len; 
261 
if (pos > lpos)

262 
s>exponent_bands[k][j++] = pos  lpos; 
263 
if (pos >= block_len)

264 
break;

265 
lpos = pos; 
266 
} 
267 
s>exponent_sizes[k] = j; 
268 
} 
269 
} 
270  
271 
/* max number of coefs */

272 
s>coefs_end[k] = (s>frame_len  ((s>frame_len * 9) / 100)) >> k; 
273 
/* high freq computation */

274 
s>high_band_start[k] = (int)((block_len * 2 * high_freq) / 
275 
s>sample_rate + 0.5); 
276 
n = s>exponent_sizes[k]; 
277 
j = 0;

278 
pos = 0;

279 
for (i = 0; i < n; i++) { 
280 
int start, end;

281 
start = pos; 
282 
pos += s>exponent_bands[k][i]; 
283 
end = pos; 
284 
if (start < s>high_band_start[k])

285 
start = s>high_band_start[k]; 
286 
if (end > s>coefs_end[k])

287 
end = s>coefs_end[k]; 
288 
if (end > start)

289 
s>exponent_high_bands[k][j++] = end  start; 
290 
} 
291 
s>exponent_high_sizes[k] = j; 
292 
#if 0

293 
tprintf(s>avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",

294 
s>frame_len >> k,

295 
s>coefs_end[k],

296 
s>high_band_start[k],

297 
s>exponent_high_sizes[k]);

298 
for (j = 0; j < s>exponent_high_sizes[k]; j++)

299 
tprintf(s>avctx, " %d", s>exponent_high_bands[k][j]);

300 
tprintf(s>avctx, "\n");

301 
#endif

302 
} 
303 
} 
304  
305 
#ifdef TRACE

306 
{ 
307 
int i, j;

308 
for (i = 0; i < s>nb_block_sizes; i++) { 
309 
tprintf(s>avctx, "%5d: n=%2d:",

310 
s>frame_len >> i, 
311 
s>exponent_sizes[i]); 
312 
for (j = 0; j < s>exponent_sizes[i]; j++) 
313 
tprintf(s>avctx, " %d", s>exponent_bands[i][j]);

314 
tprintf(s>avctx, "\n");

315 
} 
316 
} 
317 
#endif

318  
319 
/* init MDCT windows : simple sinus window */

320 
for (i = 0; i < s>nb_block_sizes; i++) { 
321 
int n;

322 
n = 1 << (s>frame_len_bits  i);

323 
ff_sine_window_init(ff_sine_windows[s>frame_len_bits  i  7], n);

324 
s>windows[i] = ff_sine_windows[s>frame_len_bits  i  7];

325 
} 
326  
327 
s>reset_block_lengths = 1;

328  
329 
if (s>use_noise_coding) {

330  
331 
/* init the noise generator */

332 
if (s>use_exp_vlc)

333 
s>noise_mult = 0.02; 
334 
else

335 
s>noise_mult = 0.04; 
336  
337 
#ifdef TRACE

338 
for (i = 0; i < NOISE_TAB_SIZE; i++) 
339 
s>noise_table[i] = 1.0 * s>noise_mult; 
340 
#else

341 
{ 
342 
unsigned int seed; 
343 
float norm;

344 
seed = 1;

345 
norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s>noise_mult; 
346 
for (i = 0; i < NOISE_TAB_SIZE; i++) { 
347 
seed = seed * 314159 + 1; 
348 
s>noise_table[i] = (float)((int)seed) * norm; 
349 
} 
350 
} 
351 
#endif

352 
} 
353  
354 
/* choose the VLC tables for the coefficients */

355 
coef_vlc_table = 2;

356 
if (s>sample_rate >= 32000) { 
357 
if (bps1 < 0.72) 
358 
coef_vlc_table = 0;

359 
else if (bps1 < 1.16) 
360 
coef_vlc_table = 1;

361 
} 
362 
s>coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; 
363 
s>coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; 
364 
init_coef_vlc(&s>coef_vlc[0], &s>run_table[0], &s>level_table[0], &s>int_table[0], 
365 
s>coef_vlcs[0]);

366 
init_coef_vlc(&s>coef_vlc[1], &s>run_table[1], &s>level_table[1], &s>int_table[1], 
367 
s>coef_vlcs[1]);

368  
369 
return 0; 
370 
} 
371  
372 
int ff_wma_total_gain_to_bits(int total_gain) 
373 
{ 
374 
if (total_gain < 15) return 13; 
375 
else if (total_gain < 32) return 12; 
376 
else if (total_gain < 40) return 11; 
377 
else if (total_gain < 45) return 10; 
378 
else return 9; 
379 
} 
380  
381 
int ff_wma_end(AVCodecContext *avctx)

382 
{ 
383 
WMACodecContext *s = avctx>priv_data; 
384 
int i;

385  
386 
for (i = 0; i < s>nb_block_sizes; i++) 
387 
ff_mdct_end(&s>mdct_ctx[i]); 
388  
389 
if (s>use_exp_vlc) {

390 
free_vlc(&s>exp_vlc); 
391 
} 
392 
if (s>use_noise_coding) {

393 
free_vlc(&s>hgain_vlc); 
394 
} 
395 
for (i = 0; i < 2; i++) { 
396 
free_vlc(&s>coef_vlc[i]); 
397 
av_free(s>run_table[i]); 
398 
av_free(s>level_table[i]); 
399 
av_free(s>int_table[i]); 
400 
} 
401  
402 
return 0; 
403 
} 