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