00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00036 #include "avcodec.h"
00037 #include "wma.h"
00038
00039 #undef NDEBUG
00040 #include <assert.h>
00041
00042 #define EXPVLCBITS 8
00043 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
00044
00045 #define HGAINVLCBITS 9
00046 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
00047
00048 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
00049
00050 #ifdef TRACE
00051 static void dump_shorts(WMACodecContext *s, const char *name, const short *tab, int n)
00052 {
00053 int i;
00054
00055 tprintf(s->avctx, "%s[%d]:\n", name, n);
00056 for(i=0;i<n;i++) {
00057 if ((i & 7) == 0)
00058 tprintf(s->avctx, "%4d: ", i);
00059 tprintf(s->avctx, " %5d.0", tab[i]);
00060 if ((i & 7) == 7)
00061 tprintf(s->avctx, "\n");
00062 }
00063 }
00064
00065 static void dump_floats(WMACodecContext *s, const char *name, int prec, const float *tab, int n)
00066 {
00067 int i;
00068
00069 tprintf(s->avctx, "%s[%d]:\n", name, n);
00070 for(i=0;i<n;i++) {
00071 if ((i & 7) == 0)
00072 tprintf(s->avctx, "%4d: ", i);
00073 tprintf(s->avctx, " %8.*f", prec, tab[i]);
00074 if ((i & 7) == 7)
00075 tprintf(s->avctx, "\n");
00076 }
00077 if ((i & 7) != 0)
00078 tprintf(s->avctx, "\n");
00079 }
00080 #endif
00081
00082 static int wma_decode_init(AVCodecContext * avctx)
00083 {
00084 WMACodecContext *s = avctx->priv_data;
00085 int i, flags1, flags2;
00086 uint8_t *extradata;
00087
00088 s->avctx = avctx;
00089
00090
00091 flags1 = 0;
00092 flags2 = 0;
00093 extradata = avctx->extradata;
00094 if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
00095 flags1 = AV_RL16(extradata);
00096 flags2 = AV_RL16(extradata+2);
00097 } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
00098 flags1 = AV_RL32(extradata);
00099 flags2 = AV_RL16(extradata+4);
00100 }
00101
00102
00103
00104 s->use_exp_vlc = flags2 & 0x0001;
00105 s->use_bit_reservoir = flags2 & 0x0002;
00106 s->use_variable_block_len = flags2 & 0x0004;
00107
00108 if(ff_wma_init(avctx, flags2)<0)
00109 return -1;
00110
00111
00112 for(i = 0; i < s->nb_block_sizes; i++)
00113 ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1);
00114
00115 if (s->use_noise_coding) {
00116 init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),
00117 ff_wma_hgain_huffbits, 1, 1,
00118 ff_wma_hgain_huffcodes, 2, 2, 0);
00119 }
00120
00121 if (s->use_exp_vlc) {
00122 init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits),
00123 ff_wma_scale_huffbits, 1, 1,
00124 ff_wma_scale_huffcodes, 4, 4, 0);
00125 } else {
00126 wma_lsp_to_curve_init(s, s->frame_len);
00127 }
00128
00129 return 0;
00130 }
00131
00138 static inline float pow_m1_4(WMACodecContext *s, float x)
00139 {
00140 union {
00141 float f;
00142 unsigned int v;
00143 } u, t;
00144 unsigned int e, m;
00145 float a, b;
00146
00147 u.f = x;
00148 e = u.v >> 23;
00149 m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
00150
00151 t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
00152 a = s->lsp_pow_m_table1[m];
00153 b = s->lsp_pow_m_table2[m];
00154 return s->lsp_pow_e_table[e] * (a + b * t.f);
00155 }
00156
00157 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
00158 {
00159 float wdel, a, b;
00160 int i, e, m;
00161
00162 wdel = M_PI / frame_len;
00163 for(i=0;i<frame_len;i++)
00164 s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
00165
00166
00167 for(i=0;i<256;i++) {
00168 e = i - 126;
00169 s->lsp_pow_e_table[i] = pow(2.0, e * -0.25);
00170 }
00171
00172
00173
00174 b = 1.0;
00175 for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) {
00176 m = (1 << LSP_POW_BITS) + i;
00177 a = (float)m * (0.5 / (1 << LSP_POW_BITS));
00178 a = pow(a, -0.25);
00179 s->lsp_pow_m_table1[i] = 2 * a - b;
00180 s->lsp_pow_m_table2[i] = b - a;
00181 b = a;
00182 }
00183 #if 0
00184 for(i=1;i<20;i++) {
00185 float v, r1, r2;
00186 v = 5.0 / i;
00187 r1 = pow_m1_4(s, v);
00188 r2 = pow(v,-0.25);
00189 printf("%f^-0.25=%f e=%f\n", v, r1, r2 - r1);
00190 }
00191 #endif
00192 }
00193
00198 static void wma_lsp_to_curve(WMACodecContext *s,
00199 float *out, float *val_max_ptr,
00200 int n, float *lsp)
00201 {
00202 int i, j;
00203 float p, q, w, v, val_max;
00204
00205 val_max = 0;
00206 for(i=0;i<n;i++) {
00207 p = 0.5f;
00208 q = 0.5f;
00209 w = s->lsp_cos_table[i];
00210 for(j=1;j<NB_LSP_COEFS;j+=2){
00211 q *= w - lsp[j - 1];
00212 p *= w - lsp[j];
00213 }
00214 p *= p * (2.0f - w);
00215 q *= q * (2.0f + w);
00216 v = p + q;
00217 v = pow_m1_4(s, v);
00218 if (v > val_max)
00219 val_max = v;
00220 out[i] = v;
00221 }
00222 *val_max_ptr = val_max;
00223 }
00224
00228 static void decode_exp_lsp(WMACodecContext *s, int ch)
00229 {
00230 float lsp_coefs[NB_LSP_COEFS];
00231 int val, i;
00232
00233 for(i = 0; i < NB_LSP_COEFS; i++) {
00234 if (i == 0 || i >= 8)
00235 val = get_bits(&s->gb, 3);
00236 else
00237 val = get_bits(&s->gb, 4);
00238 lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
00239 }
00240
00241 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
00242 s->block_len, lsp_coefs);
00243 }
00244
00248 static int decode_exp_vlc(WMACodecContext *s, int ch)
00249 {
00250 int last_exp, n, code;
00251 const uint16_t *ptr, *band_ptr;
00252 float v, *q, max_scale, *q_end;
00253
00254 band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
00255 ptr = band_ptr;
00256 q = s->exponents[ch];
00257 q_end = q + s->block_len;
00258 max_scale = 0;
00259 if (s->version == 1) {
00260 last_exp = get_bits(&s->gb, 5) + 10;
00261
00262 v = pow(10, last_exp * (1.0 / 16.0));
00263 max_scale = v;
00264 n = *ptr++;
00265 do {
00266 *q++ = v;
00267 } while (--n);
00268 }else
00269 last_exp = 36;
00270
00271 while (q < q_end) {
00272 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
00273 if (code < 0)
00274 return -1;
00275
00276 last_exp += code - 60;
00277
00278 v = pow(10, last_exp * (1.0 / 16.0));
00279 if (v > max_scale)
00280 max_scale = v;
00281 n = *ptr++;
00282 do {
00283 *q++ = v;
00284 } while (--n);
00285 }
00286 s->max_exponent[ch] = max_scale;
00287 return 0;
00288 }
00289
00290
00297 static void wma_window(WMACodecContext *s, float *out)
00298 {
00299 float *in = s->output;
00300 int block_len, bsize, n;
00301
00302
00303 if (s->block_len_bits <= s->prev_block_len_bits) {
00304 block_len = s->block_len;
00305 bsize = s->frame_len_bits - s->block_len_bits;
00306
00307 s->dsp.vector_fmul_add_add(out, in, s->windows[bsize],
00308 out, 0, block_len, 1);
00309
00310 } else {
00311 block_len = 1 << s->prev_block_len_bits;
00312 n = (s->block_len - block_len) / 2;
00313 bsize = s->frame_len_bits - s->prev_block_len_bits;
00314
00315 s->dsp.vector_fmul_add_add(out+n, in+n, s->windows[bsize],
00316 out+n, 0, block_len, 1);
00317
00318 memcpy(out+n+block_len, in+n+block_len, n*sizeof(float));
00319 }
00320
00321 out += s->block_len;
00322 in += s->block_len;
00323
00324
00325 if (s->block_len_bits <= s->next_block_len_bits) {
00326 block_len = s->block_len;
00327 bsize = s->frame_len_bits - s->block_len_bits;
00328
00329 s->dsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len);
00330
00331 } else {
00332 block_len = 1 << s->next_block_len_bits;
00333 n = (s->block_len - block_len) / 2;
00334 bsize = s->frame_len_bits - s->next_block_len_bits;
00335
00336 memcpy(out, in, n*sizeof(float));
00337
00338 s->dsp.vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len);
00339
00340 memset(out+n+block_len, 0, n*sizeof(float));
00341 }
00342 }
00343
00344
00349 static int wma_decode_block(WMACodecContext *s)
00350 {
00351 int n, v, a, ch, code, bsize;
00352 int coef_nb_bits, total_gain;
00353 int nb_coefs[MAX_CHANNELS];
00354 float mdct_norm;
00355
00356 #ifdef TRACE
00357 tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num);
00358 #endif
00359
00360
00361 if (s->use_variable_block_len) {
00362 n = av_log2(s->nb_block_sizes - 1) + 1;
00363
00364 if (s->reset_block_lengths) {
00365 s->reset_block_lengths = 0;
00366 v = get_bits(&s->gb, n);
00367 if (v >= s->nb_block_sizes)
00368 return -1;
00369 s->prev_block_len_bits = s->frame_len_bits - v;
00370 v = get_bits(&s->gb, n);
00371 if (v >= s->nb_block_sizes)
00372 return -1;
00373 s->block_len_bits = s->frame_len_bits - v;
00374 } else {
00375
00376 s->prev_block_len_bits = s->block_len_bits;
00377 s->block_len_bits = s->next_block_len_bits;
00378 }
00379 v = get_bits(&s->gb, n);
00380 if (v >= s->nb_block_sizes)
00381 return -1;
00382 s->next_block_len_bits = s->frame_len_bits - v;
00383 } else {
00384
00385 s->next_block_len_bits = s->frame_len_bits;
00386 s->prev_block_len_bits = s->frame_len_bits;
00387 s->block_len_bits = s->frame_len_bits;
00388 }
00389
00390
00391 s->block_len = 1 << s->block_len_bits;
00392 if ((s->block_pos + s->block_len) > s->frame_len)
00393 return -1;
00394
00395 if (s->nb_channels == 2) {
00396 s->ms_stereo = get_bits1(&s->gb);
00397 }
00398 v = 0;
00399 for(ch = 0; ch < s->nb_channels; ch++) {
00400 a = get_bits1(&s->gb);
00401 s->channel_coded[ch] = a;
00402 v |= a;
00403 }
00404
00405
00406 if (!v)
00407 goto next;
00408
00409 bsize = s->frame_len_bits - s->block_len_bits;
00410
00411
00412
00413 total_gain = 1;
00414 for(;;) {
00415 a = get_bits(&s->gb, 7);
00416 total_gain += a;
00417 if (a != 127)
00418 break;
00419 }
00420
00421 coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
00422
00423
00424 n = s->coefs_end[bsize] - s->coefs_start;
00425 for(ch = 0; ch < s->nb_channels; ch++)
00426 nb_coefs[ch] = n;
00427
00428
00429 if (s->use_noise_coding) {
00430
00431 for(ch = 0; ch < s->nb_channels; ch++) {
00432 if (s->channel_coded[ch]) {
00433 int i, n, a;
00434 n = s->exponent_high_sizes[bsize];
00435 for(i=0;i<n;i++) {
00436 a = get_bits1(&s->gb);
00437 s->high_band_coded[ch][i] = a;
00438
00439 if (a)
00440 nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
00441 }
00442 }
00443 }
00444 for(ch = 0; ch < s->nb_channels; ch++) {
00445 if (s->channel_coded[ch]) {
00446 int i, n, val, code;
00447
00448 n = s->exponent_high_sizes[bsize];
00449 val = (int)0x80000000;
00450 for(i=0;i<n;i++) {
00451 if (s->high_band_coded[ch][i]) {
00452 if (val == (int)0x80000000) {
00453 val = get_bits(&s->gb, 7) - 19;
00454 } else {
00455 code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX);
00456 if (code < 0)
00457 return -1;
00458 val += code - 18;
00459 }
00460 s->high_band_values[ch][i] = val;
00461 }
00462 }
00463 }
00464 }
00465 }
00466
00467
00468 if ((s->block_len_bits == s->frame_len_bits) ||
00469 get_bits1(&s->gb)) {
00470 for(ch = 0; ch < s->nb_channels; ch++) {
00471 if (s->channel_coded[ch]) {
00472 if (s->use_exp_vlc) {
00473 if (decode_exp_vlc(s, ch) < 0)
00474 return -1;
00475 } else {
00476 decode_exp_lsp(s, ch);
00477 }
00478 s->exponents_bsize[ch] = bsize;
00479 }
00480 }
00481 }
00482
00483
00484 for(ch = 0; ch < s->nb_channels; ch++) {
00485 if (s->channel_coded[ch]) {
00486 VLC *coef_vlc;
00487 int level, run, sign, tindex;
00488 int16_t *ptr, *eptr;
00489 const uint16_t *level_table, *run_table;
00490
00491
00492
00493 tindex = (ch == 1 && s->ms_stereo);
00494 coef_vlc = &s->coef_vlc[tindex];
00495 run_table = s->run_table[tindex];
00496 level_table = s->level_table[tindex];
00497
00498 ptr = &s->coefs1[ch][0];
00499 eptr = ptr + nb_coefs[ch];
00500 memset(ptr, 0, s->block_len * sizeof(int16_t));
00501 for(;;) {
00502 code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX);
00503 if (code < 0)
00504 return -1;
00505 if (code == 1) {
00506
00507 break;
00508 } else if (code == 0) {
00509
00510 level = get_bits(&s->gb, coef_nb_bits);
00511
00512
00513 run = get_bits(&s->gb, s->frame_len_bits);
00514 } else {
00515
00516 run = run_table[code];
00517 level = level_table[code];
00518 }
00519 sign = get_bits1(&s->gb);
00520 if (!sign)
00521 level = -level;
00522 ptr += run;
00523 if (ptr >= eptr)
00524 {
00525 av_log(NULL, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n");
00526 break;
00527 }
00528 *ptr++ = level;
00529
00530 if (ptr >= eptr)
00531 break;
00532 }
00533 }
00534 if (s->version == 1 && s->nb_channels >= 2) {
00535 align_get_bits(&s->gb);
00536 }
00537 }
00538
00539
00540 {
00541 int n4 = s->block_len / 2;
00542 mdct_norm = 1.0 / (float)n4;
00543 if (s->version == 1) {
00544 mdct_norm *= sqrt(n4);
00545 }
00546 }
00547
00548
00549 for(ch = 0; ch < s->nb_channels; ch++) {
00550 if (s->channel_coded[ch]) {
00551 int16_t *coefs1;
00552 float *coefs, *exponents, mult, mult1, noise;
00553 int i, j, n, n1, last_high_band, esize;
00554 float exp_power[HIGH_BAND_MAX_SIZE];
00555
00556 coefs1 = s->coefs1[ch];
00557 exponents = s->exponents[ch];
00558 esize = s->exponents_bsize[ch];
00559 mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
00560 mult *= mdct_norm;
00561 coefs = s->coefs[ch];
00562 if (s->use_noise_coding) {
00563 mult1 = mult;
00564
00565 for(i = 0;i < s->coefs_start; i++) {
00566 *coefs++ = s->noise_table[s->noise_index] *
00567 exponents[i<<bsize>>esize] * mult1;
00568 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
00569 }
00570
00571 n1 = s->exponent_high_sizes[bsize];
00572
00573
00574 exponents = s->exponents[ch] +
00575 (s->high_band_start[bsize]<<bsize);
00576 last_high_band = 0;
00577 for(j=0;j<n1;j++) {
00578 n = s->exponent_high_bands[s->frame_len_bits -
00579 s->block_len_bits][j];
00580 if (s->high_band_coded[ch][j]) {
00581 float e2, v;
00582 e2 = 0;
00583 for(i = 0;i < n; i++) {
00584 v = exponents[i<<bsize>>esize];
00585 e2 += v * v;
00586 }
00587 exp_power[j] = e2 / n;
00588 last_high_band = j;
00589 tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
00590 }
00591 exponents += n<<bsize;
00592 }
00593
00594
00595 exponents = s->exponents[ch] + (s->coefs_start<<bsize);
00596 for(j=-1;j<n1;j++) {
00597 if (j < 0) {
00598 n = s->high_band_start[bsize] -
00599 s->coefs_start;
00600 } else {
00601 n = s->exponent_high_bands[s->frame_len_bits -
00602 s->block_len_bits][j];
00603 }
00604 if (j >= 0 && s->high_band_coded[ch][j]) {
00605
00606 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
00607
00608 mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
00609 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
00610 mult1 *= mdct_norm;
00611 for(i = 0;i < n; i++) {
00612 noise = s->noise_table[s->noise_index];
00613 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
00614 *coefs++ = noise *
00615 exponents[i<<bsize>>esize] * mult1;
00616 }
00617 exponents += n<<bsize;
00618 } else {
00619
00620 for(i = 0;i < n; i++) {
00621 noise = s->noise_table[s->noise_index];
00622 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
00623 *coefs++ = ((*coefs1++) + noise) *
00624 exponents[i<<bsize>>esize] * mult;
00625 }
00626 exponents += n<<bsize;
00627 }
00628 }
00629
00630
00631 n = s->block_len - s->coefs_end[bsize];
00632 mult1 = mult * exponents[((-1<<bsize))>>esize];
00633 for(i = 0; i < n; i++) {
00634 *coefs++ = s->noise_table[s->noise_index] * mult1;
00635 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
00636 }
00637 } else {
00638
00639 for(i = 0;i < s->coefs_start; i++)
00640 *coefs++ = 0.0;
00641 n = nb_coefs[ch];
00642 for(i = 0;i < n; i++) {
00643 *coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult;
00644 }
00645 n = s->block_len - s->coefs_end[bsize];
00646 for(i = 0;i < n; i++)
00647 *coefs++ = 0.0;
00648 }
00649 }
00650 }
00651
00652 #ifdef TRACE
00653 for(ch = 0; ch < s->nb_channels; ch++) {
00654 if (s->channel_coded[ch]) {
00655 dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
00656 dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
00657 }
00658 }
00659 #endif
00660
00661 if (s->ms_stereo && s->channel_coded[1]) {
00662 float a, b;
00663 int i;
00664
00665
00666
00667
00668 if (!s->channel_coded[0]) {
00669 tprintf(s->avctx, "rare ms-stereo case happened\n");
00670 memset(s->coefs[0], 0, sizeof(float) * s->block_len);
00671 s->channel_coded[0] = 1;
00672 }
00673
00674 for(i = 0; i < s->block_len; i++) {
00675 a = s->coefs[0][i];
00676 b = s->coefs[1][i];
00677 s->coefs[0][i] = a + b;
00678 s->coefs[1][i] = a - b;
00679 }
00680 }
00681
00682 for(ch = 0; ch < s->nb_channels; ch++) {
00683 if (s->channel_coded[ch]) {
00684 int n4, index, n;
00685
00686 n = s->block_len;
00687 n4 = s->block_len / 2;
00688 s->mdct_ctx[bsize].fft.imdct_calc(&s->mdct_ctx[bsize],
00689 s->output, s->coefs[ch], s->mdct_tmp);
00690
00691
00692 index = (s->frame_len / 2) + s->block_pos - n4;
00693 wma_window(s, &s->frame_out[ch][index]);
00694
00695
00696
00697 if (s->ms_stereo && !s->channel_coded[1]) {
00698 wma_window(s, &s->frame_out[1][index]);
00699 }
00700 }
00701 }
00702 next:
00703
00704 s->block_num++;
00705 s->block_pos += s->block_len;
00706 if (s->block_pos >= s->frame_len)
00707 return 1;
00708 else
00709 return 0;
00710 }
00711
00712
00713 static int wma_decode_frame(WMACodecContext *s, int16_t *samples)
00714 {
00715 int ret, i, n, ch, incr;
00716 int16_t *ptr;
00717 float *iptr;
00718
00719 #ifdef TRACE
00720 tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len);
00721 #endif
00722
00723
00724 s->block_num = 0;
00725 s->block_pos = 0;
00726 for(;;) {
00727 ret = wma_decode_block(s);
00728 if (ret < 0)
00729 return -1;
00730 if (ret)
00731 break;
00732 }
00733
00734
00735 n = s->frame_len;
00736 incr = s->nb_channels;
00737 for(ch = 0; ch < s->nb_channels; ch++) {
00738 ptr = samples + ch;
00739 iptr = s->frame_out[ch];
00740
00741 for(i=0;i<n;i++) {
00742 *ptr = av_clip_int16(lrintf(*iptr++));
00743 ptr += incr;
00744 }
00745
00746 memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
00747 s->frame_len * sizeof(float));
00748 }
00749
00750 #ifdef TRACE
00751 dump_shorts(s, "samples", samples, n * s->nb_channels);
00752 #endif
00753 return 0;
00754 }
00755
00756 static int wma_decode_superframe(AVCodecContext *avctx,
00757 void *data, int *data_size,
00758 const uint8_t *buf, int buf_size)
00759 {
00760 WMACodecContext *s = avctx->priv_data;
00761 int nb_frames, bit_offset, i, pos, len;
00762 uint8_t *q;
00763 int16_t *samples;
00764
00765 tprintf(avctx, "***decode_superframe:\n");
00766
00767 if(buf_size==0){
00768 s->last_superframe_len = 0;
00769 return 0;
00770 }
00771 if (buf_size < s->block_align)
00772 return 0;
00773 buf_size = s->block_align;
00774
00775 samples = data;
00776
00777 init_get_bits(&s->gb, buf, buf_size*8);
00778
00779 if (s->use_bit_reservoir) {
00780
00781 skip_bits(&s->gb, 4);
00782 nb_frames = get_bits(&s->gb, 4) - 1;
00783
00784 bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
00785
00786 if (s->last_superframe_len > 0) {
00787
00788
00789 if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
00790 MAX_CODED_SUPERFRAME_SIZE)
00791 goto fail;
00792 q = s->last_superframe + s->last_superframe_len;
00793 len = bit_offset;
00794 while (len > 7) {
00795 *q++ = (get_bits)(&s->gb, 8);
00796 len -= 8;
00797 }
00798 if (len > 0) {
00799 *q++ = (get_bits)(&s->gb, len) << (8 - len);
00800 }
00801
00802
00803 init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);
00804
00805 if (s->last_bitoffset > 0)
00806 skip_bits(&s->gb, s->last_bitoffset);
00807
00808
00809 if (wma_decode_frame(s, samples) < 0)
00810 goto fail;
00811 samples += s->nb_channels * s->frame_len;
00812 }
00813
00814
00815 pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
00816 init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8);
00817 len = pos & 7;
00818 if (len > 0)
00819 skip_bits(&s->gb, len);
00820
00821 s->reset_block_lengths = 1;
00822 for(i=0;i<nb_frames;i++) {
00823 if (wma_decode_frame(s, samples) < 0)
00824 goto fail;
00825 samples += s->nb_channels * s->frame_len;
00826 }
00827
00828
00829 pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
00830 s->last_bitoffset = pos & 7;
00831 pos >>= 3;
00832 len = buf_size - pos;
00833 if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
00834 goto fail;
00835 }
00836 s->last_superframe_len = len;
00837 memcpy(s->last_superframe, buf + pos, len);
00838 } else {
00839
00840 if (wma_decode_frame(s, samples) < 0)
00841 goto fail;
00842 samples += s->nb_channels * s->frame_len;
00843 }
00844
00845
00846
00847 *data_size = (int8_t *)samples - (int8_t *)data;
00848 return s->block_align;
00849 fail:
00850
00851 s->last_superframe_len = 0;
00852 return -1;
00853 }
00854
00855 AVCodec wmav1_decoder =
00856 {
00857 "wmav1",
00858 CODEC_TYPE_AUDIO,
00859 CODEC_ID_WMAV1,
00860 sizeof(WMACodecContext),
00861 wma_decode_init,
00862 NULL,
00863 ff_wma_end,
00864 wma_decode_superframe,
00865 };
00866
00867 AVCodec wmav2_decoder =
00868 {
00869 "wmav2",
00870 CODEC_TYPE_AUDIO,
00871 CODEC_ID_WMAV2,
00872 sizeof(WMACodecContext),
00873 wma_decode_init,
00874 NULL,
00875 ff_wma_end,
00876 wma_decode_superframe,
00877 };