ffmpeg / libavcodec / wmadec.c @ 5509bffa
History  View  Annotate  Download (42 KB)
1 
/*


2 
* WMA compatible decoder

3 
* Copyright (c) 2002 The FFmpeg Project.

4 
*

5 
* This library is free software; you can redistribute it and/or

6 
* modify it under the terms of the GNU Lesser General Public

7 
* License as published by the Free Software Foundation; either

8 
* version 2 of the License, or (at your option) any later version.

9 
*

10 
* This library is distributed in the hope that it will be useful,

11 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

12 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 
* Lesser General Public License for more details.

14 
*

15 
* You should have received a copy of the GNU Lesser General Public

16 
* License along with this library; if not, write to the Free Software

17 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

18 
*/

19  
20 
/**

21 
* @file wmadec.c

22 
* WMA compatible decoder.

23 
* This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.

24 
* WMA v1 is identified by audio format 0x160 in Microsoft media files

25 
* (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.

26 
*

27 
* To use this decoder, a calling application must supply the extra data

28 
* bytes provided with the WMA data. These are the extra, codecspecific

29 
* bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes

30 
* to the decoder using the extradata[_size] fields in AVCodecContext. There

31 
* should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.

32 
*/

33  
34 
#include "avcodec.h" 
35 
#include "bitstream.h" 
36 
#include "dsputil.h" 
37  
38 
/* size of blocks */

39 
#define BLOCK_MIN_BITS 7 
40 
#define BLOCK_MAX_BITS 11 
41 
#define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS) 
42  
43 
#define BLOCK_NB_SIZES (BLOCK_MAX_BITS  BLOCK_MIN_BITS + 1) 
44  
45 
/* XXX: find exact max size */

46 
#define HIGH_BAND_MAX_SIZE 16 
47  
48 
#define NB_LSP_COEFS 10 
49  
50 
/* XXX: is it a suitable value ? */

51 
#define MAX_CODED_SUPERFRAME_SIZE 16384 
52  
53 
#define MAX_CHANNELS 2 
54  
55 
#define NOISE_TAB_SIZE 8192 
56  
57 
#define LSP_POW_BITS 7 
58  
59 
#define VLCBITS 9 
60  
61 
typedef struct WMADecodeContext { 
62 
GetBitContext gb; 
63 
int sample_rate;

64 
int nb_channels;

65 
int bit_rate;

66 
int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */ 
67 
int block_align;

68 
int use_bit_reservoir;

69 
int use_variable_block_len;

70 
int use_exp_vlc; /* exponent coding: 0 = lsp, 1 = vlc + delta */ 
71 
int use_noise_coding; /* true if perceptual noise is added */ 
72 
int byte_offset_bits;

73 
VLC exp_vlc; 
74 
int exponent_sizes[BLOCK_NB_SIZES];

75 
uint16_t exponent_bands[BLOCK_NB_SIZES][25];

76 
int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */ 
77 
int coefs_start; /* first coded coef */ 
78 
int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */ 
79 
int exponent_high_sizes[BLOCK_NB_SIZES];

80 
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];

81 
VLC hgain_vlc; 
82  
83 
/* coded values in high bands */

84 
int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];

85 
int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];

86  
87 
/* there are two possible tables for spectral coefficients */

88 
VLC coef_vlc[2];

89 
uint16_t *run_table[2];

90 
uint16_t *level_table[2];

91 
/* frame info */

92 
int frame_len; /* frame length in samples */ 
93 
int frame_len_bits; /* frame_len = 1 << frame_len_bits */ 
94 
int nb_block_sizes; /* number of block sizes */ 
95 
/* block info */

96 
int reset_block_lengths;

97 
int block_len_bits; /* log2 of current block length */ 
98 
int next_block_len_bits; /* log2 of next block length */ 
99 
int prev_block_len_bits; /* log2 of prev block length */ 
100 
int block_len; /* block length in samples */ 
101 
int block_num; /* block number in current frame */ 
102 
int block_pos; /* current position in frame */ 
103 
uint8_t ms_stereo; /* true if mid/side stereo mode */

104 
uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */

105 
float exponents[MAX_CHANNELS][BLOCK_MAX_SIZE] __attribute__((aligned(16))); 
106 
float max_exponent[MAX_CHANNELS];

107 
int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE]; 
108 
float coefs[MAX_CHANNELS][BLOCK_MAX_SIZE] __attribute__((aligned(16))); 
109 
MDCTContext mdct_ctx[BLOCK_NB_SIZES]; 
110 
float *windows[BLOCK_NB_SIZES];

111 
FFTSample mdct_tmp[BLOCK_MAX_SIZE] __attribute__((aligned(16))); /* temporary storage for imdct */ 
112 
/* output buffer for one frame and the last for IMDCT windowing */

113 
float frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2] __attribute__((aligned(16))); 
114 
/* last frame info */

115 
uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */ 
116 
int last_bitoffset;

117 
int last_superframe_len;

118 
float noise_table[NOISE_TAB_SIZE];

119 
int noise_index;

120 
float noise_mult; /* XXX: suppress that and integrate it in the noise array */ 
121 
/* lsp_to_curve tables */

122 
float lsp_cos_table[BLOCK_MAX_SIZE];

123 
float lsp_pow_e_table[256]; 
124 
float lsp_pow_m_table1[(1 << LSP_POW_BITS)]; 
125 
float lsp_pow_m_table2[(1 << LSP_POW_BITS)]; 
126  
127 
#ifdef TRACE

128 
int frame_count;

129 
#endif

130 
} WMADecodeContext; 
131  
132 
typedef struct CoefVLCTable { 
133 
int n; /* total number of codes */ 
134 
const uint32_t *huffcodes; /* VLC bit values */ 
135 
const uint8_t *huffbits; /* VLC bit size */ 
136 
const uint16_t *levels; /* table to build run/level tables */ 
137 
} CoefVLCTable; 
138  
139 
static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len); 
140  
141 
#include "wmadata.h" 
142  
143 
#ifdef TRACE

144 
static void dump_shorts(const char *name, const short *tab, int n) 
145 
{ 
146 
int i;

147  
148 
tprintf("%s[%d]:\n", name, n);

149 
for(i=0;i<n;i++) { 
150 
if ((i & 7) == 0) 
151 
tprintf("%4d: ", i);

152 
tprintf(" %5d.0", tab[i]);

153 
if ((i & 7) == 7) 
154 
tprintf("\n");

155 
} 
156 
} 
157  
158 
static void dump_floats(const char *name, int prec, const float *tab, int n) 
159 
{ 
160 
int i;

161  
162 
tprintf("%s[%d]:\n", name, n);

163 
for(i=0;i<n;i++) { 
164 
if ((i & 7) == 0) 
165 
tprintf("%4d: ", i);

166 
tprintf(" %8.*f", prec, tab[i]);

167 
if ((i & 7) == 7) 
168 
tprintf("\n");

169 
} 
170 
if ((i & 7) != 0) 
171 
tprintf("\n");

172 
} 
173 
#endif

174  
175 
/* XXX: use same run/length optimization as mpeg decoders */

176 
static void init_coef_vlc(VLC *vlc, 
177 
uint16_t **prun_table, uint16_t **plevel_table, 
178 
const CoefVLCTable *vlc_table)

179 
{ 
180 
int n = vlc_table>n;

181 
const uint8_t *table_bits = vlc_table>huffbits;

182 
const uint32_t *table_codes = vlc_table>huffcodes;

183 
const uint16_t *levels_table = vlc_table>levels;

184 
uint16_t *run_table, *level_table; 
185 
const uint16_t *p;

186 
int i, l, j, level;

187  
188 
init_vlc(vlc, 9, n, table_bits, 1, 1, table_codes, 4, 4, 0); 
189  
190 
run_table = av_malloc(n * sizeof(uint16_t));

191 
level_table = av_malloc(n * sizeof(uint16_t));

192 
p = levels_table; 
193 
i = 2;

194 
level = 1;

195 
while (i < n) {

196 
l = *p++; 
197 
for(j=0;j<l;j++) { 
198 
run_table[i] = j; 
199 
level_table[i] = level; 
200 
i++; 
201 
} 
202 
level++; 
203 
} 
204 
*prun_table = run_table; 
205 
*plevel_table = level_table; 
206 
} 
207  
208 
static int wma_decode_init(AVCodecContext * avctx) 
209 
{ 
210 
WMADecodeContext *s = avctx>priv_data; 
211 
int i, flags1, flags2;

212 
float *window;

213 
uint8_t *extradata; 
214 
float bps1, high_freq;

215 
volatile float bps; 
216 
int sample_rate1;

217 
int coef_vlc_table;

218  
219 
s>sample_rate = avctx>sample_rate; 
220 
s>nb_channels = avctx>channels; 
221 
s>bit_rate = avctx>bit_rate; 
222 
s>block_align = avctx>block_align; 
223  
224 
if (avctx>codec>id == CODEC_ID_WMAV1) {

225 
s>version = 1;

226 
} else {

227 
s>version = 2;

228 
} 
229  
230 
/* extract flag infos */

231 
flags1 = 0;

232 
flags2 = 0;

233 
extradata = avctx>extradata; 
234 
if (s>version == 1 && avctx>extradata_size >= 4) { 
235 
flags1 = extradata[0]  (extradata[1] << 8); 
236 
flags2 = extradata[2]  (extradata[3] << 8); 
237 
} else if (s>version == 2 && avctx>extradata_size >= 6) { 
238 
flags1 = extradata[0]  (extradata[1] << 8)  
239 
(extradata[2] << 16)  (extradata[3] << 24); 
240 
flags2 = extradata[4]  (extradata[5] << 8); 
241 
} 
242 
s>use_exp_vlc = flags2 & 0x0001;

243 
s>use_bit_reservoir = flags2 & 0x0002;

244 
s>use_variable_block_len = flags2 & 0x0004;

245  
246 
/* compute MDCT block size */

247 
if (s>sample_rate <= 16000) { 
248 
s>frame_len_bits = 9;

249 
} else if (s>sample_rate <= 22050  
250 
(s>sample_rate <= 32000 && s>version == 1)) { 
251 
s>frame_len_bits = 10;

252 
} else {

253 
s>frame_len_bits = 11;

254 
} 
255 
s>frame_len = 1 << s>frame_len_bits;

256 
if (s>use_variable_block_len) {

257 
int nb_max, nb;

258 
nb = ((flags2 >> 3) & 3) + 1; 
259 
if ((s>bit_rate / s>nb_channels) >= 32000) 
260 
nb += 2;

261 
nb_max = s>frame_len_bits  BLOCK_MIN_BITS; 
262 
if (nb > nb_max)

263 
nb = nb_max; 
264 
s>nb_block_sizes = nb + 1;

265 
} else {

266 
s>nb_block_sizes = 1;

267 
} 
268  
269 
/* init rate dependant parameters */

270 
s>use_noise_coding = 1;

271 
high_freq = s>sample_rate * 0.5; 
272  
273 
/* if version 2, then the rates are normalized */

274 
sample_rate1 = s>sample_rate; 
275 
if (s>version == 2) { 
276 
if (sample_rate1 >= 44100) 
277 
sample_rate1 = 44100;

278 
else if (sample_rate1 >= 22050) 
279 
sample_rate1 = 22050;

280 
else if (sample_rate1 >= 16000) 
281 
sample_rate1 = 16000;

282 
else if (sample_rate1 >= 11025) 
283 
sample_rate1 = 11025;

284 
else if (sample_rate1 >= 8000) 
285 
sample_rate1 = 8000;

286 
} 
287  
288 
bps = (float)s>bit_rate / (float)(s>nb_channels * s>sample_rate); 
289 
s>byte_offset_bits = av_log2((int)(bps * s>frame_len / 8.0 + 0.5)) + 2; 
290  
291 
/* compute high frequency value and choose if noise coding should

292 
be activated */

293 
bps1 = bps; 
294 
if (s>nb_channels == 2) 
295 
bps1 = bps * 1.6; 
296 
if (sample_rate1 == 44100) { 
297 
if (bps1 >= 0.61) 
298 
s>use_noise_coding = 0;

299 
else

300 
high_freq = high_freq * 0.4; 
301 
} else if (sample_rate1 == 22050) { 
302 
if (bps1 >= 1.16) 
303 
s>use_noise_coding = 0;

304 
else if (bps1 >= 0.72) 
305 
high_freq = high_freq * 0.7; 
306 
else

307 
high_freq = high_freq * 0.6; 
308 
} else if (sample_rate1 == 16000) { 
309 
if (bps > 0.5) 
310 
high_freq = high_freq * 0.5; 
311 
else

312 
high_freq = high_freq * 0.3; 
313 
} else if (sample_rate1 == 11025) { 
314 
high_freq = high_freq * 0.7; 
315 
} else if (sample_rate1 == 8000) { 
316 
if (bps <= 0.625) { 
317 
high_freq = high_freq * 0.5; 
318 
} else if (bps > 0.75) { 
319 
s>use_noise_coding = 0;

320 
} else {

321 
high_freq = high_freq * 0.65; 
322 
} 
323 
} else {

324 
if (bps >= 0.8) { 
325 
high_freq = high_freq * 0.75; 
326 
} else if (bps >= 0.6) { 
327 
high_freq = high_freq * 0.6; 
328 
} else {

329 
high_freq = high_freq * 0.5; 
330 
} 
331 
} 
332 
dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);

333 
dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",

334 
s>version, s>nb_channels, s>sample_rate, s>bit_rate, 
335 
s>block_align); 
336 
dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",

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

339 
s>use_noise_coding, s>use_exp_vlc, s>nb_block_sizes); 
340  
341 
/* compute the scale factor band sizes for each MDCT block size */

342 
{ 
343 
int a, b, pos, lpos, k, block_len, i, j, n;

344 
const uint8_t *table;

345  
346 
if (s>version == 1) { 
347 
s>coefs_start = 3;

348 
} else {

349 
s>coefs_start = 0;

350 
} 
351 
for(k = 0; k < s>nb_block_sizes; k++) { 
352 
block_len = s>frame_len >> k; 
353  
354 
if (s>version == 1) { 
355 
lpos = 0;

356 
for(i=0;i<25;i++) { 
357 
a = wma_critical_freqs[i]; 
358 
b = s>sample_rate; 
359 
pos = ((block_len * 2 * a) + (b >> 1)) / b; 
360 
if (pos > block_len)

361 
pos = block_len; 
362 
s>exponent_bands[0][i] = pos  lpos;

363 
if (pos >= block_len) {

364 
i++; 
365 
break;

366 
} 
367 
lpos = pos; 
368 
} 
369 
s>exponent_sizes[0] = i;

370 
} else {

371 
/* hardcoded tables */

372 
table = NULL;

373 
a = s>frame_len_bits  BLOCK_MIN_BITS  k; 
374 
if (a < 3) { 
375 
if (s>sample_rate >= 44100) 
376 
table = exponent_band_44100[a]; 
377 
else if (s>sample_rate >= 32000) 
378 
table = exponent_band_32000[a]; 
379 
else if (s>sample_rate >= 22050) 
380 
table = exponent_band_22050[a]; 
381 
} 
382 
if (table) {

383 
n = *table++; 
384 
for(i=0;i<n;i++) 
385 
s>exponent_bands[k][i] = table[i]; 
386 
s>exponent_sizes[k] = n; 
387 
} else {

388 
j = 0;

389 
lpos = 0;

390 
for(i=0;i<25;i++) { 
391 
a = wma_critical_freqs[i]; 
392 
b = s>sample_rate; 
393 
pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 
394 
pos <<= 2;

395 
if (pos > block_len)

396 
pos = block_len; 
397 
if (pos > lpos)

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

400 
break;

401 
lpos = pos; 
402 
} 
403 
s>exponent_sizes[k] = j; 
404 
} 
405 
} 
406  
407 
/* max number of coefs */

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

410 
s>high_band_start[k] = (int)((block_len * 2 * high_freq) / 
411 
s>sample_rate + 0.5); 
412 
n = s>exponent_sizes[k]; 
413 
j = 0;

414 
pos = 0;

415 
for(i=0;i<n;i++) { 
416 
int start, end;

417 
start = pos; 
418 
pos += s>exponent_bands[k][i]; 
419 
end = pos; 
420 
if (start < s>high_band_start[k])

421 
start = s>high_band_start[k]; 
422 
if (end > s>coefs_end[k])

423 
end = s>coefs_end[k]; 
424 
if (end > start)

425 
s>exponent_high_bands[k][j++] = end  start; 
426 
} 
427 
s>exponent_high_sizes[k] = j; 
428 
#if 0

429 
tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",

430 
s>frame_len >> k,

431 
s>coefs_end[k],

432 
s>high_band_start[k],

433 
s>exponent_high_sizes[k]);

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

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

436 
tprintf("\n");

437 
#endif

438 
} 
439 
} 
440  
441 
#ifdef TRACE

442 
{ 
443 
int i, j;

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

446 
s>frame_len >> i, 
447 
s>exponent_sizes[i]); 
448 
for(j=0;j<s>exponent_sizes[i];j++) 
449 
tprintf(" %d", s>exponent_bands[i][j]);

450 
tprintf("\n");

451 
} 
452 
} 
453 
#endif

454  
455 
/* init MDCT */

456 
for(i = 0; i < s>nb_block_sizes; i++) 
457 
ff_mdct_init(&s>mdct_ctx[i], s>frame_len_bits  i + 1, 1); 
458  
459 
/* init MDCT windows : simple sinus window */

460 
for(i = 0; i < s>nb_block_sizes; i++) { 
461 
int n, j;

462 
float alpha;

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

464 
window = av_malloc(sizeof(float) * n); 
465 
alpha = M_PI / (2.0 * n); 
466 
for(j=0;j<n;j++) { 
467 
window[n  j  1] = sin((j + 0.5) * alpha); 
468 
} 
469 
s>windows[i] = window; 
470 
} 
471  
472 
s>reset_block_lengths = 1;

473  
474 
if (s>use_noise_coding) {

475  
476 
/* init the noise generator */

477 
if (s>use_exp_vlc)

478 
s>noise_mult = 0.02; 
479 
else

480 
s>noise_mult = 0.04; 
481  
482 
#ifdef TRACE

483 
for(i=0;i<NOISE_TAB_SIZE;i++) 
484 
s>noise_table[i] = 1.0 * s>noise_mult; 
485 
#else

486 
{ 
487 
unsigned int seed; 
488 
float norm;

489 
seed = 1;

490 
norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s>noise_mult; 
491 
for(i=0;i<NOISE_TAB_SIZE;i++) { 
492 
seed = seed * 314159 + 1; 
493 
s>noise_table[i] = (float)((int)seed) * norm; 
494 
} 
495 
} 
496 
#endif

497 
init_vlc(&s>hgain_vlc, 9, sizeof(hgain_huffbits), 
498 
hgain_huffbits, 1, 1, 
499 
hgain_huffcodes, 2, 2, 0); 
500 
} 
501  
502 
if (s>use_exp_vlc) {

503 
init_vlc(&s>exp_vlc, 9, sizeof(scale_huffbits), 
504 
scale_huffbits, 1, 1, 
505 
scale_huffcodes, 4, 4, 0); 
506 
} else {

507 
wma_lsp_to_curve_init(s, s>frame_len); 
508 
} 
509  
510 
/* choose the VLC tables for the coefficients */

511 
coef_vlc_table = 2;

512 
if (s>sample_rate >= 32000) { 
513 
if (bps1 < 0.72) 
514 
coef_vlc_table = 0;

515 
else if (bps1 < 1.16) 
516 
coef_vlc_table = 1;

517 
} 
518  
519 
init_coef_vlc(&s>coef_vlc[0], &s>run_table[0], &s>level_table[0], 
520 
&coef_vlcs[coef_vlc_table * 2]);

521 
init_coef_vlc(&s>coef_vlc[1], &s>run_table[1], &s>level_table[1], 
522 
&coef_vlcs[coef_vlc_table * 2 + 1]); 
523 
return 0; 
524 
} 
525  
526 
/* interpolate values for a bigger or smaller block. The block must

527 
have multiple sizes */

528 
static void interpolate_array(float *scale, int old_size, int new_size) 
529 
{ 
530 
int i, j, jincr, k;

531 
float v;

532  
533 
if (new_size > old_size) {

534 
jincr = new_size / old_size; 
535 
j = new_size; 
536 
for(i = old_size  1; i >=0; i) { 
537 
v = scale[i]; 
538 
k = jincr; 
539 
do {

540 
scale[j] = v; 
541 
} while (k);

542 
} 
543 
} else if (new_size < old_size) { 
544 
j = 0;

545 
jincr = old_size / new_size; 
546 
for(i = 0; i < new_size; i++) { 
547 
scale[i] = scale[j]; 
548 
j += jincr; 
549 
} 
550 
} 
551 
} 
552  
553 
/* compute x^0.25 with an exponent and mantissa table. We use linear

554 
interpolation to reduce the mantissa table size at a small speed

555 
expense (linear interpolation approximately doubles the number of

556 
bits of precision). */

557 
static inline float pow_m1_4(WMADecodeContext *s, float x) 
558 
{ 
559 
union {

560 
float f;

561 
unsigned int v; 
562 
} u, t; 
563 
unsigned int e, m; 
564 
float a, b;

565  
566 
u.f = x; 
567 
e = u.v >> 23;

568 
m = (u.v >> (23  LSP_POW_BITS)) & ((1 << LSP_POW_BITS)  1); 
569 
/* build interpolation scale: 1 <= t < 2. */

570 
t.v = ((u.v << LSP_POW_BITS) & ((1 << 23)  1))  (127 << 23); 
571 
a = s>lsp_pow_m_table1[m]; 
572 
b = s>lsp_pow_m_table2[m]; 
573 
return s>lsp_pow_e_table[e] * (a + b * t.f);

574 
} 
575  
576 
static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len) 
577 
{ 
578 
float wdel, a, b;

579 
int i, e, m;

580  
581 
wdel = M_PI / frame_len; 
582 
for(i=0;i<frame_len;i++) 
583 
s>lsp_cos_table[i] = 2.0f * cos(wdel * i); 
584  
585 
/* tables for x^0.25 computation */

586 
for(i=0;i<256;i++) { 
587 
e = i  126;

588 
s>lsp_pow_e_table[i] = pow(2.0, e * 0.25); 
589 
} 
590  
591 
/* NOTE: these two tables are needed to avoid two operations in

592 
pow_m1_4 */

593 
b = 1.0; 
594 
for(i=(1 << LSP_POW_BITS)  1;i>=0;i) { 
595 
m = (1 << LSP_POW_BITS) + i;

596 
a = (float)m * (0.5 / (1 << LSP_POW_BITS)); 
597 
a = pow(a, 0.25); 
598 
s>lsp_pow_m_table1[i] = 2 * a  b;

599 
s>lsp_pow_m_table2[i] = b  a; 
600 
b = a; 
601 
} 
602 
#if 0

603 
for(i=1;i<20;i++) {

604 
float v, r1, r2;

605 
v = 5.0 / i;

606 
r1 = pow_m1_4(s, v);

607 
r2 = pow(v,0.25);

608 
printf("%f^0.25=%f e=%f\n", v, r1, r2  r1);

609 
}

610 
#endif

611 
} 
612  
613 
/* NOTE: We use the same code as Vorbis here */

614 
/* XXX: optimize it further with SSE/3Dnow */

615 
static void wma_lsp_to_curve(WMADecodeContext *s, 
616 
float *out, float *val_max_ptr, 
617 
int n, float *lsp) 
618 
{ 
619 
int i, j;

620 
float p, q, w, v, val_max;

621  
622 
val_max = 0;

623 
for(i=0;i<n;i++) { 
624 
p = 0.5f; 
625 
q = 0.5f; 
626 
w = s>lsp_cos_table[i]; 
627 
for(j=1;j<NB_LSP_COEFS;j+=2){ 
628 
q *= w  lsp[j  1];

629 
p *= w  lsp[j]; 
630 
} 
631 
p *= p * (2.0f  w); 
632 
q *= q * (2.0f + w); 
633 
v = p + q; 
634 
v = pow_m1_4(s, v); 
635 
if (v > val_max)

636 
val_max = v; 
637 
out[i] = v; 
638 
} 
639 
*val_max_ptr = val_max; 
640 
} 
641  
642 
/* decode exponents coded with LSP coefficients (same idea as Vorbis) */

643 
static void decode_exp_lsp(WMADecodeContext *s, int ch) 
644 
{ 
645 
float lsp_coefs[NB_LSP_COEFS];

646 
int val, i;

647  
648 
for(i = 0; i < NB_LSP_COEFS; i++) { 
649 
if (i == 0  i >= 8) 
650 
val = get_bits(&s>gb, 3);

651 
else

652 
val = get_bits(&s>gb, 4);

653 
lsp_coefs[i] = lsp_codebook[i][val]; 
654 
} 
655  
656 
wma_lsp_to_curve(s, s>exponents[ch], &s>max_exponent[ch], 
657 
s>block_len, lsp_coefs); 
658 
} 
659  
660 
/* decode exponents coded with VLC codes */

661 
static int decode_exp_vlc(WMADecodeContext *s, int ch) 
662 
{ 
663 
int last_exp, n, code;

664 
const uint16_t *ptr, *band_ptr;

665 
float v, *q, max_scale, *q_end;

666  
667 
band_ptr = s>exponent_bands[s>frame_len_bits  s>block_len_bits]; 
668 
ptr = band_ptr; 
669 
q = s>exponents[ch]; 
670 
q_end = q + s>block_len; 
671 
max_scale = 0;

672 
if (s>version == 1) { 
673 
last_exp = get_bits(&s>gb, 5) + 10; 
674 
/* XXX: use a table */

675 
v = pow(10, last_exp * (1.0 / 16.0)); 
676 
max_scale = v; 
677 
n = *ptr++; 
678 
do {

679 
*q++ = v; 
680 
} while (n);

681 
} 
682 
last_exp = 36;

683 
while (q < q_end) {

684 
code = get_vlc2(&s>gb, s>exp_vlc.table, VLCBITS, 2);

685 
if (code < 0) 
686 
return 1; 
687 
/* NOTE: this offset is the same as MPEG4 AAC ! */

688 
last_exp += code  60;

689 
/* XXX: use a table */

690 
v = pow(10, last_exp * (1.0 / 16.0)); 
691 
if (v > max_scale)

692 
max_scale = v; 
693 
n = *ptr++; 
694 
do {

695 
*q++ = v; 
696 
} while (n);

697 
} 
698 
s>max_exponent[ch] = max_scale; 
699 
return 0; 
700 
} 
701  
702 
/* return 0 if OK. return 1 if last block of frame. return 1 if

703 
unrecorrable error. */

704 
static int wma_decode_block(WMADecodeContext *s) 
705 
{ 
706 
int n, v, a, ch, code, bsize;

707 
int coef_nb_bits, total_gain, parse_exponents;

708 
float window[BLOCK_MAX_SIZE * 2]; 
709 
// XXX: FIXME!! there's a bug somewhere which makes this mandatory under altivec

710 
#ifdef HAVE_ALTIVEC

711 
volatile int nb_coefs[MAX_CHANNELS] __attribute__((aligned(16))); 
712 
#else

713 
int nb_coefs[MAX_CHANNELS];

714 
#endif

715 
float mdct_norm;

716  
717 
#ifdef TRACE

718 
tprintf("***decode_block: %d:%d\n", s>frame_count  1, s>block_num); 
719 
#endif

720  
721 
/* compute current block length */

722 
if (s>use_variable_block_len) {

723 
n = av_log2(s>nb_block_sizes  1) + 1; 
724  
725 
if (s>reset_block_lengths) {

726 
s>reset_block_lengths = 0;

727 
v = get_bits(&s>gb, n); 
728 
if (v >= s>nb_block_sizes)

729 
return 1; 
730 
s>prev_block_len_bits = s>frame_len_bits  v; 
731 
v = get_bits(&s>gb, n); 
732 
if (v >= s>nb_block_sizes)

733 
return 1; 
734 
s>block_len_bits = s>frame_len_bits  v; 
735 
} else {

736 
/* update block lengths */

737 
s>prev_block_len_bits = s>block_len_bits; 
738 
s>block_len_bits = s>next_block_len_bits; 
739 
} 
740 
v = get_bits(&s>gb, n); 
741 
if (v >= s>nb_block_sizes)

742 
return 1; 
743 
s>next_block_len_bits = s>frame_len_bits  v; 
744 
} else {

745 
/* fixed block len */

746 
s>next_block_len_bits = s>frame_len_bits; 
747 
s>prev_block_len_bits = s>frame_len_bits; 
748 
s>block_len_bits = s>frame_len_bits; 
749 
} 
750  
751 
/* now check if the block length is coherent with the frame length */

752 
s>block_len = 1 << s>block_len_bits;

753 
if ((s>block_pos + s>block_len) > s>frame_len)

754 
return 1; 
755  
756 
if (s>nb_channels == 2) { 
757 
s>ms_stereo = get_bits(&s>gb, 1);

758 
} 
759 
v = 0;

760 
for(ch = 0; ch < s>nb_channels; ch++) { 
761 
a = get_bits(&s>gb, 1);

762 
s>channel_coded[ch] = a; 
763 
v = a; 
764 
} 
765 
/* if no channel coded, no need to go further */

766 
/* XXX: fix potential framing problems */

767 
if (!v)

768 
goto next;

769  
770 
bsize = s>frame_len_bits  s>block_len_bits; 
771  
772 
/* read total gain and extract corresponding number of bits for

773 
coef escape coding */

774 
total_gain = 1;

775 
for(;;) {

776 
a = get_bits(&s>gb, 7);

777 
total_gain += a; 
778 
if (a != 127) 
779 
break;

780 
} 
781  
782 
if (total_gain < 15) 
783 
coef_nb_bits = 13;

784 
else if (total_gain < 32) 
785 
coef_nb_bits = 12;

786 
else if (total_gain < 40) 
787 
coef_nb_bits = 11;

788 
else if (total_gain < 45) 
789 
coef_nb_bits = 10;

790 
else

791 
coef_nb_bits = 9;

792  
793 
/* compute number of coefficients */

794 
n = s>coefs_end[bsize]  s>coefs_start; 
795 
for(ch = 0; ch < s>nb_channels; ch++) 
796 
nb_coefs[ch] = n; 
797  
798 
/* complex coding */

799 
if (s>use_noise_coding) {

800  
801 
for(ch = 0; ch < s>nb_channels; ch++) { 
802 
if (s>channel_coded[ch]) {

803 
int i, n, a;

804 
n = s>exponent_high_sizes[bsize]; 
805 
for(i=0;i<n;i++) { 
806 
a = get_bits(&s>gb, 1);

807 
s>high_band_coded[ch][i] = a; 
808 
/* if noise coding, the coefficients are not transmitted */

809 
if (a)

810 
nb_coefs[ch] = s>exponent_high_bands[bsize][i]; 
811 
} 
812 
} 
813 
} 
814 
for(ch = 0; ch < s>nb_channels; ch++) { 
815 
if (s>channel_coded[ch]) {

816 
int i, n, val, code;

817  
818 
n = s>exponent_high_sizes[bsize]; 
819 
val = (int)0x80000000; 
820 
for(i=0;i<n;i++) { 
821 
if (s>high_band_coded[ch][i]) {

822 
if (val == (int)0x80000000) { 
823 
val = get_bits(&s>gb, 7)  19; 
824 
} else {

825 
code = get_vlc2(&s>gb, s>hgain_vlc.table, VLCBITS, 2);

826 
if (code < 0) 
827 
return 1; 
828 
val += code  18;

829 
} 
830 
s>high_band_values[ch][i] = val; 
831 
} 
832 
} 
833 
} 
834 
} 
835 
} 
836  
837 
/* exposant can be interpolated in short blocks. */

838 
parse_exponents = 1;

839 
if (s>block_len_bits != s>frame_len_bits) {

840 
parse_exponents = get_bits(&s>gb, 1);

841 
} 
842  
843 
if (parse_exponents) {

844 
for(ch = 0; ch < s>nb_channels; ch++) { 
845 
if (s>channel_coded[ch]) {

846 
if (s>use_exp_vlc) {

847 
if (decode_exp_vlc(s, ch) < 0) 
848 
return 1; 
849 
} else {

850 
decode_exp_lsp(s, ch); 
851 
} 
852 
} 
853 
} 
854 
} else {

855 
for(ch = 0; ch < s>nb_channels; ch++) { 
856 
if (s>channel_coded[ch]) {

857 
interpolate_array(s>exponents[ch], 1 << s>prev_block_len_bits,

858 
s>block_len); 
859 
} 
860 
} 
861 
} 
862  
863 
/* parse spectral coefficients : just RLE encoding */

864 
for(ch = 0; ch < s>nb_channels; ch++) { 
865 
if (s>channel_coded[ch]) {

866 
VLC *coef_vlc; 
867 
int level, run, sign, tindex;

868 
int16_t *ptr, *eptr; 
869 
const int16_t *level_table, *run_table;

870  
871 
/* special VLC tables are used for ms stereo because

872 
there is potentially less energy there */

873 
tindex = (ch == 1 && s>ms_stereo);

874 
coef_vlc = &s>coef_vlc[tindex]; 
875 
run_table = s>run_table[tindex]; 
876 
level_table = s>level_table[tindex]; 
877 
/* XXX: optimize */

878 
ptr = &s>coefs1[ch][0];

879 
eptr = ptr + nb_coefs[ch]; 
880 
memset(ptr, 0, s>block_len * sizeof(int16_t)); 
881 
for(;;) {

882 
code = get_vlc2(&s>gb, coef_vlc>table, VLCBITS, 3);

883 
if (code < 0) 
884 
return 1; 
885 
if (code == 1) { 
886 
/* EOB */

887 
break;

888 
} else if (code == 0) { 
889 
/* escape */

890 
level = get_bits(&s>gb, coef_nb_bits); 
891 
/* NOTE: this is rather suboptimal. reading

892 
block_len_bits would be better */

893 
run = get_bits(&s>gb, s>frame_len_bits); 
894 
} else {

895 
/* normal code */

896 
run = run_table[code]; 
897 
level = level_table[code]; 
898 
} 
899 
sign = get_bits(&s>gb, 1);

900 
if (!sign)

901 
level = level; 
902 
ptr += run; 
903 
if (ptr >= eptr)

904 
return 1; 
905 
*ptr++ = level; 
906 
/* NOTE: EOB can be omitted */

907 
if (ptr >= eptr)

908 
break;

909 
} 
910 
} 
911 
if (s>version == 1 && s>nb_channels >= 2) { 
912 
align_get_bits(&s>gb); 
913 
} 
914 
} 
915  
916 
/* normalize */

917 
{ 
918 
int n4 = s>block_len / 2; 
919 
mdct_norm = 1.0 / (float)n4; 
920 
if (s>version == 1) { 
921 
mdct_norm *= sqrt(n4); 
922 
} 
923 
} 
924  
925 
/* finally compute the MDCT coefficients */

926 
for(ch = 0; ch < s>nb_channels; ch++) { 
927 
if (s>channel_coded[ch]) {

928 
int16_t *coefs1; 
929 
float *coefs, *exponents, mult, mult1, noise, *exp_ptr;

930 
int i, j, n, n1, last_high_band;

931 
float exp_power[HIGH_BAND_MAX_SIZE];

932  
933 
coefs1 = s>coefs1[ch]; 
934 
exponents = s>exponents[ch]; 
935 
mult = pow(10, total_gain * 0.05) / s>max_exponent[ch]; 
936 
mult *= mdct_norm; 
937 
coefs = s>coefs[ch]; 
938 
if (s>use_noise_coding) {

939 
mult1 = mult; 
940 
/* very low freqs : noise */

941 
for(i = 0;i < s>coefs_start; i++) { 
942 
*coefs++ = s>noise_table[s>noise_index] * (*exponents++) * mult1; 
943 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
944 
} 
945  
946 
n1 = s>exponent_high_sizes[bsize]; 
947  
948 
/* compute power of high bands */

949 
exp_ptr = exponents + 
950 
s>high_band_start[bsize]  
951 
s>coefs_start; 
952 
last_high_band = 0; /* avoid warning */ 
953 
for(j=0;j<n1;j++) { 
954 
n = s>exponent_high_bands[s>frame_len_bits  
955 
s>block_len_bits][j]; 
956 
if (s>high_band_coded[ch][j]) {

957 
float e2, v;

958 
e2 = 0;

959 
for(i = 0;i < n; i++) { 
960 
v = exp_ptr[i]; 
961 
e2 += v * v; 
962 
} 
963 
exp_power[j] = e2 / n; 
964 
last_high_band = j; 
965 
tprintf("%d: power=%f (%d)\n", j, exp_power[j], n);

966 
} 
967 
exp_ptr += n; 
968 
} 
969  
970 
/* main freqs and high freqs */

971 
for(j=1;j<n1;j++) { 
972 
if (j < 0) { 
973 
n = s>high_band_start[bsize]  
974 
s>coefs_start; 
975 
} else {

976 
n = s>exponent_high_bands[s>frame_len_bits  
977 
s>block_len_bits][j]; 
978 
} 
979 
if (j >= 0 && s>high_band_coded[ch][j]) { 
980 
/* use noise with specified power */

981 
mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); 
982 
/* XXX: use a table */

983 
mult1 = mult1 * pow(10, s>high_band_values[ch][j] * 0.05); 
984 
mult1 = mult1 / (s>max_exponent[ch] * s>noise_mult); 
985 
mult1 *= mdct_norm; 
986 
for(i = 0;i < n; i++) { 
987 
noise = s>noise_table[s>noise_index]; 
988 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
989 
*coefs++ = (*exponents++) * noise * mult1; 
990 
} 
991 
} else {

992 
/* coded values + small noise */

993 
for(i = 0;i < n; i++) { 
994 
noise = s>noise_table[s>noise_index]; 
995 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
996 
*coefs++ = ((*coefs1++) + noise) * (*exponents++) * mult; 
997 
} 
998 
} 
999 
} 
1000  
1001 
/* very high freqs : noise */

1002 
n = s>block_len  s>coefs_end[bsize]; 
1003 
mult1 = mult * exponents[1];

1004 
for(i = 0; i < n; i++) { 
1005 
*coefs++ = s>noise_table[s>noise_index] * mult1; 
1006 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
1007 
} 
1008 
} else {

1009 
/* XXX: optimize more */

1010 
for(i = 0;i < s>coefs_start; i++) 
1011 
*coefs++ = 0.0; 
1012 
n = nb_coefs[ch]; 
1013 
for(i = 0;i < n; i++) { 
1014 
*coefs++ = coefs1[i] * exponents[i] * mult; 
1015 
} 
1016 
n = s>block_len  s>coefs_end[bsize]; 
1017 
for(i = 0;i < n; i++) 
1018 
*coefs++ = 0.0; 
1019 
} 
1020 
} 
1021 
} 
1022  
1023 
#ifdef TRACE

1024 
for(ch = 0; ch < s>nb_channels; ch++) { 
1025 
if (s>channel_coded[ch]) {

1026 
dump_floats("exponents", 3, s>exponents[ch], s>block_len); 
1027 
dump_floats("coefs", 1, s>coefs[ch], s>block_len); 
1028 
} 
1029 
} 
1030 
#endif

1031  
1032 
if (s>ms_stereo && s>channel_coded[1]) { 
1033 
float a, b;

1034 
int i;

1035  
1036 
/* nominal case for ms stereo: we do it before mdct */

1037 
/* no need to optimize this case because it should almost

1038 
never happen */

1039 
if (!s>channel_coded[0]) { 
1040 
tprintf("rare msstereo case happened\n");

1041 
memset(s>coefs[0], 0, sizeof(float) * s>block_len); 
1042 
s>channel_coded[0] = 1; 
1043 
} 
1044  
1045 
for(i = 0; i < s>block_len; i++) { 
1046 
a = s>coefs[0][i];

1047 
b = s>coefs[1][i];

1048 
s>coefs[0][i] = a + b;

1049 
s>coefs[1][i] = a  b;

1050 
} 
1051 
} 
1052  
1053 
/* build the window : we ensure that when the windows overlap

1054 
their squared sum is always 1 (MDCT reconstruction rule) */

1055 
/* XXX: merge with output */

1056 
{ 
1057 
int i, next_block_len, block_len, prev_block_len, n;

1058 
float *wptr;

1059  
1060 
block_len = s>block_len; 
1061 
prev_block_len = 1 << s>prev_block_len_bits;

1062 
next_block_len = 1 << s>next_block_len_bits;

1063  
1064 
/* right part */

1065 
wptr = window + block_len; 
1066 
if (block_len <= next_block_len) {

1067 
for(i=0;i<block_len;i++) 
1068 
*wptr++ = s>windows[bsize][i]; 
1069 
} else {

1070 
/* overlap */

1071 
n = (block_len / 2)  (next_block_len / 2); 
1072 
for(i=0;i<n;i++) 
1073 
*wptr++ = 1.0; 
1074 
for(i=0;i<next_block_len;i++) 
1075 
*wptr++ = s>windows[s>frame_len_bits  s>next_block_len_bits][i]; 
1076 
for(i=0;i<n;i++) 
1077 
*wptr++ = 0.0; 
1078 
} 
1079  
1080 
/* left part */

1081 
wptr = window + block_len; 
1082 
if (block_len <= prev_block_len) {

1083 
for(i=0;i<block_len;i++) 
1084 
*wptr = s>windows[bsize][i]; 
1085 
} else {

1086 
/* overlap */

1087 
n = (block_len / 2)  (prev_block_len / 2); 
1088 
for(i=0;i<n;i++) 
1089 
*wptr = 1.0; 
1090 
for(i=0;i<prev_block_len;i++) 
1091 
*wptr = s>windows[s>frame_len_bits  s>prev_block_len_bits][i]; 
1092 
for(i=0;i<n;i++) 
1093 
*wptr = 0.0; 
1094 
} 
1095 
} 
1096  
1097  
1098 
for(ch = 0; ch < s>nb_channels; ch++) { 
1099 
if (s>channel_coded[ch]) {

1100 
FFTSample output[BLOCK_MAX_SIZE * 2] __attribute__((aligned(16))); 
1101 
float *ptr;

1102 
int i, n4, index, n;

1103  
1104 
n = s>block_len; 
1105 
n4 = s>block_len / 2;

1106 
ff_imdct_calc(&s>mdct_ctx[bsize], 
1107 
output, s>coefs[ch], s>mdct_tmp); 
1108  
1109 
/* XXX: optimize all that by build the window and

1110 
multipying/adding at the same time */

1111 
/* multiply by the window */

1112 
for(i=0;i<n * 2;i++) { 
1113 
output[i] *= window[i]; 
1114 
} 
1115  
1116 
/* add in the frame */

1117 
index = (s>frame_len / 2) + s>block_pos  n4;

1118 
ptr = &s>frame_out[ch][index]; 
1119 
for(i=0;i<n * 2;i++) { 
1120 
*ptr += output[i]; 
1121 
ptr++; 
1122 
} 
1123  
1124 
/* specific fast case for msstereo : add to second

1125 
channel if it is not coded */

1126 
if (s>ms_stereo && !s>channel_coded[1]) { 
1127 
ptr = &s>frame_out[1][index];

1128 
for(i=0;i<n * 2;i++) { 
1129 
*ptr += output[i]; 
1130 
ptr++; 
1131 
} 
1132 
} 
1133 
} 
1134 
} 
1135 
next:

1136 
/* update block number */

1137 
s>block_num++; 
1138 
s>block_pos += s>block_len; 
1139 
if (s>block_pos >= s>frame_len)

1140 
return 1; 
1141 
else

1142 
return 0; 
1143 
} 
1144  
1145 
/* decode a frame of frame_len samples */

1146 
static int wma_decode_frame(WMADecodeContext *s, int16_t *samples) 
1147 
{ 
1148 
int ret, i, n, a, ch, incr;

1149 
int16_t *ptr; 
1150 
float *iptr;

1151  
1152 
#ifdef TRACE

1153 
tprintf("***decode_frame: %d size=%d\n", s>frame_count++, s>frame_len);

1154 
#endif

1155  
1156 
/* read each block */

1157 
s>block_num = 0;

1158 
s>block_pos = 0;

1159 
for(;;) {

1160 
ret = wma_decode_block(s); 
1161 
if (ret < 0) 
1162 
return 1; 
1163 
if (ret)

1164 
break;

1165 
} 
1166  
1167 
/* convert frame to integer */

1168 
n = s>frame_len; 
1169 
incr = s>nb_channels; 
1170 
for(ch = 0; ch < s>nb_channels; ch++) { 
1171 
ptr = samples + ch; 
1172 
iptr = s>frame_out[ch]; 
1173  
1174 
for(i=0;i<n;i++) { 
1175 
a = lrintf(*iptr++); 
1176 
if (a > 32767) 
1177 
a = 32767;

1178 
else if (a < 32768) 
1179 
a = 32768;

1180 
*ptr = a; 
1181 
ptr += incr; 
1182 
} 
1183 
/* prepare for next block */

1184 
memmove(&s>frame_out[ch][0], &s>frame_out[ch][s>frame_len],

1185 
s>frame_len * sizeof(float)); 
1186 
/* XXX: suppress this */

1187 
memset(&s>frame_out[ch][s>frame_len], 0,

1188 
s>frame_len * sizeof(float)); 
1189 
} 
1190  
1191 
#ifdef TRACE

1192 
dump_shorts("samples", samples, n * s>nb_channels);

1193 
#endif

1194 
return 0; 
1195 
} 
1196  
1197 
static int wma_decode_superframe(AVCodecContext *avctx, 
1198 
void *data, int *data_size, 
1199 
uint8_t *buf, int buf_size)

1200 
{ 
1201 
WMADecodeContext *s = avctx>priv_data; 
1202 
int nb_frames, bit_offset, i, pos, len;

1203 
uint8_t *q; 
1204 
int16_t *samples; 
1205  
1206 
tprintf("***decode_superframe:\n");

1207  
1208 
if(buf_size==0){ 
1209 
s>last_superframe_len = 0;

1210 
return 0; 
1211 
} 
1212  
1213 
samples = data; 
1214  
1215 
init_get_bits(&s>gb, buf, buf_size*8);

1216  
1217 
if (s>use_bit_reservoir) {

1218 
/* read super frame header */

1219 
get_bits(&s>gb, 4); /* super frame index */ 
1220 
nb_frames = get_bits(&s>gb, 4)  1; 
1221  
1222 
bit_offset = get_bits(&s>gb, s>byte_offset_bits + 3);

1223  
1224 
if (s>last_superframe_len > 0) { 
1225 
// printf("skip=%d\n", s>last_bitoffset);

1226 
/* add bit_offset bits to last frame */

1227 
if ((s>last_superframe_len + ((bit_offset + 7) >> 3)) > 
1228 
MAX_CODED_SUPERFRAME_SIZE) 
1229 
goto fail;

1230 
q = s>last_superframe + s>last_superframe_len; 
1231 
len = bit_offset; 
1232 
while (len > 0) { 
1233 
*q++ = (get_bits)(&s>gb, 8);

1234 
len = 8;

1235 
} 
1236 
if (len > 0) { 
1237 
*q++ = (get_bits)(&s>gb, len) << (8  len);

1238 
} 
1239  
1240 
/* XXX: bit_offset bits into last frame */

1241 
init_get_bits(&s>gb, s>last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);

1242 
/* skip unused bits */

1243 
if (s>last_bitoffset > 0) 
1244 
skip_bits(&s>gb, s>last_bitoffset); 
1245 
/* this frame is stored in the last superframe and in the

1246 
current one */

1247 
if (wma_decode_frame(s, samples) < 0) 
1248 
goto fail;

1249 
samples += s>nb_channels * s>frame_len; 
1250 
} 
1251  
1252 
/* read each frame starting from bit_offset */

1253 
pos = bit_offset + 4 + 4 + s>byte_offset_bits + 3; 
1254 
init_get_bits(&s>gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE  (pos >> 3))*8); 
1255 
len = pos & 7;

1256 
if (len > 0) 
1257 
skip_bits(&s>gb, len); 
1258  
1259 
s>reset_block_lengths = 1;

1260 
for(i=0;i<nb_frames;i++) { 
1261 
if (wma_decode_frame(s, samples) < 0) 
1262 
goto fail;

1263 
samples += s>nb_channels * s>frame_len; 
1264 
} 
1265  
1266 
/* we copy the end of the frame in the last frame buffer */

1267 
pos = get_bits_count(&s>gb) + ((bit_offset + 4 + 4 + s>byte_offset_bits + 3) & ~7); 
1268 
s>last_bitoffset = pos & 7;

1269 
pos >>= 3;

1270 
len = buf_size  pos; 
1271 
if (len > MAX_CODED_SUPERFRAME_SIZE  len < 0) { 
1272 
goto fail;

1273 
} 
1274 
s>last_superframe_len = len; 
1275 
memcpy(s>last_superframe, buf + pos, len); 
1276 
} else {

1277 
/* single frame decode */

1278 
if (wma_decode_frame(s, samples) < 0) 
1279 
goto fail;

1280 
samples += s>nb_channels * s>frame_len; 
1281 
} 
1282 
*data_size = (int8_t *)samples  (int8_t *)data; 
1283 
return s>block_align;

1284 
fail:

1285 
/* when error, we reset the bit reservoir */

1286 
s>last_superframe_len = 0;

1287 
return 1; 
1288 
} 
1289  
1290 
static int wma_decode_end(AVCodecContext *avctx) 
1291 
{ 
1292 
WMADecodeContext *s = avctx>priv_data; 
1293 
int i;

1294  
1295 
for(i = 0; i < s>nb_block_sizes; i++) 
1296 
ff_mdct_end(&s>mdct_ctx[i]); 
1297 
for(i = 0; i < s>nb_block_sizes; i++) 
1298 
av_free(s>windows[i]); 
1299  
1300 
if (s>use_exp_vlc) {

1301 
free_vlc(&s>exp_vlc); 
1302 
} 
1303 
if (s>use_noise_coding) {

1304 
free_vlc(&s>hgain_vlc); 
1305 
} 
1306 
for(i = 0;i < 2; i++) { 
1307 
free_vlc(&s>coef_vlc[i]); 
1308 
av_free(s>run_table[i]); 
1309 
av_free(s>level_table[i]); 
1310 
} 
1311  
1312 
return 0; 
1313 
} 
1314  
1315 
AVCodec wmav1_decoder = 
1316 
{ 
1317 
"wmav1",

1318 
CODEC_TYPE_AUDIO, 
1319 
CODEC_ID_WMAV1, 
1320 
sizeof(WMADecodeContext),

1321 
wma_decode_init, 
1322 
NULL,

1323 
wma_decode_end, 
1324 
wma_decode_superframe, 
1325 
}; 
1326  
1327 
AVCodec wmav2_decoder = 
1328 
{ 
1329 
"wmav2",

1330 
CODEC_TYPE_AUDIO, 
1331 
CODEC_ID_WMAV2, 
1332 
sizeof(WMADecodeContext),

1333 
wma_decode_init, 
1334 
NULL,

1335 
wma_decode_end, 
1336 
wma_decode_superframe, 
1337 
}; 