Libav 0.7.1
|
00001 /* 00002 * WMA compatible decoder 00003 * Copyright (c) 2002 The Libav Project 00004 * 00005 * This file is part of Libav. 00006 * 00007 * Libav is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * Libav is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with Libav; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 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, flags2; 00086 uint8_t *extradata; 00087 00088 s->avctx = avctx; 00089 00090 /* extract flag infos */ 00091 flags2 = 0; 00092 extradata = avctx->extradata; 00093 if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) { 00094 flags2 = AV_RL16(extradata+2); 00095 } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) { 00096 flags2 = AV_RL16(extradata+4); 00097 } 00098 // for(i=0; i<avctx->extradata_size; i++) 00099 // av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]); 00100 00101 s->use_exp_vlc = flags2 & 0x0001; 00102 s->use_bit_reservoir = flags2 & 0x0002; 00103 s->use_variable_block_len = flags2 & 0x0004; 00104 00105 if(ff_wma_init(avctx, flags2)<0) 00106 return -1; 00107 00108 /* init MDCT */ 00109 for(i = 0; i < s->nb_block_sizes; i++) 00110 ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0); 00111 00112 if (s->use_noise_coding) { 00113 init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits), 00114 ff_wma_hgain_huffbits, 1, 1, 00115 ff_wma_hgain_huffcodes, 2, 2, 0); 00116 } 00117 00118 if (s->use_exp_vlc) { 00119 init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits), //FIXME move out of context 00120 ff_aac_scalefactor_bits, 1, 1, 00121 ff_aac_scalefactor_code, 4, 4, 0); 00122 } else { 00123 wma_lsp_to_curve_init(s, s->frame_len); 00124 } 00125 00126 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 00127 return 0; 00128 } 00129 00136 static inline float pow_m1_4(WMACodecContext *s, float x) 00137 { 00138 union { 00139 float f; 00140 unsigned int v; 00141 } u, t; 00142 unsigned int e, m; 00143 float a, b; 00144 00145 u.f = x; 00146 e = u.v >> 23; 00147 m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1); 00148 /* build interpolation scale: 1 <= t < 2. */ 00149 t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23); 00150 a = s->lsp_pow_m_table1[m]; 00151 b = s->lsp_pow_m_table2[m]; 00152 return s->lsp_pow_e_table[e] * (a + b * t.f); 00153 } 00154 00155 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len) 00156 { 00157 float wdel, a, b; 00158 int i, e, m; 00159 00160 wdel = M_PI / frame_len; 00161 for(i=0;i<frame_len;i++) 00162 s->lsp_cos_table[i] = 2.0f * cos(wdel * i); 00163 00164 /* tables for x^-0.25 computation */ 00165 for(i=0;i<256;i++) { 00166 e = i - 126; 00167 s->lsp_pow_e_table[i] = pow(2.0, e * -0.25); 00168 } 00169 00170 /* NOTE: these two tables are needed to avoid two operations in 00171 pow_m1_4 */ 00172 b = 1.0; 00173 for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) { 00174 m = (1 << LSP_POW_BITS) + i; 00175 a = (float)m * (0.5 / (1 << LSP_POW_BITS)); 00176 a = pow(a, -0.25); 00177 s->lsp_pow_m_table1[i] = 2 * a - b; 00178 s->lsp_pow_m_table2[i] = b - a; 00179 b = a; 00180 } 00181 } 00182 00187 static void wma_lsp_to_curve(WMACodecContext *s, 00188 float *out, float *val_max_ptr, 00189 int n, float *lsp) 00190 { 00191 int i, j; 00192 float p, q, w, v, val_max; 00193 00194 val_max = 0; 00195 for(i=0;i<n;i++) { 00196 p = 0.5f; 00197 q = 0.5f; 00198 w = s->lsp_cos_table[i]; 00199 for(j=1;j<NB_LSP_COEFS;j+=2){ 00200 q *= w - lsp[j - 1]; 00201 p *= w - lsp[j]; 00202 } 00203 p *= p * (2.0f - w); 00204 q *= q * (2.0f + w); 00205 v = p + q; 00206 v = pow_m1_4(s, v); 00207 if (v > val_max) 00208 val_max = v; 00209 out[i] = v; 00210 } 00211 *val_max_ptr = val_max; 00212 } 00213 00217 static void decode_exp_lsp(WMACodecContext *s, int ch) 00218 { 00219 float lsp_coefs[NB_LSP_COEFS]; 00220 int val, i; 00221 00222 for(i = 0; i < NB_LSP_COEFS; i++) { 00223 if (i == 0 || i >= 8) 00224 val = get_bits(&s->gb, 3); 00225 else 00226 val = get_bits(&s->gb, 4); 00227 lsp_coefs[i] = ff_wma_lsp_codebook[i][val]; 00228 } 00229 00230 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch], 00231 s->block_len, lsp_coefs); 00232 } 00233 00235 static const float pow_tab[] = { 00236 1.7782794100389e-04, 2.0535250264571e-04, 00237 2.3713737056617e-04, 2.7384196342644e-04, 00238 3.1622776601684e-04, 3.6517412725484e-04, 00239 4.2169650342858e-04, 4.8696752516586e-04, 00240 5.6234132519035e-04, 6.4938163157621e-04, 00241 7.4989420933246e-04, 8.6596432336006e-04, 00242 1.0000000000000e-03, 1.1547819846895e-03, 00243 1.3335214321633e-03, 1.5399265260595e-03, 00244 1.7782794100389e-03, 2.0535250264571e-03, 00245 2.3713737056617e-03, 2.7384196342644e-03, 00246 3.1622776601684e-03, 3.6517412725484e-03, 00247 4.2169650342858e-03, 4.8696752516586e-03, 00248 5.6234132519035e-03, 6.4938163157621e-03, 00249 7.4989420933246e-03, 8.6596432336006e-03, 00250 1.0000000000000e-02, 1.1547819846895e-02, 00251 1.3335214321633e-02, 1.5399265260595e-02, 00252 1.7782794100389e-02, 2.0535250264571e-02, 00253 2.3713737056617e-02, 2.7384196342644e-02, 00254 3.1622776601684e-02, 3.6517412725484e-02, 00255 4.2169650342858e-02, 4.8696752516586e-02, 00256 5.6234132519035e-02, 6.4938163157621e-02, 00257 7.4989420933246e-02, 8.6596432336007e-02, 00258 1.0000000000000e-01, 1.1547819846895e-01, 00259 1.3335214321633e-01, 1.5399265260595e-01, 00260 1.7782794100389e-01, 2.0535250264571e-01, 00261 2.3713737056617e-01, 2.7384196342644e-01, 00262 3.1622776601684e-01, 3.6517412725484e-01, 00263 4.2169650342858e-01, 4.8696752516586e-01, 00264 5.6234132519035e-01, 6.4938163157621e-01, 00265 7.4989420933246e-01, 8.6596432336007e-01, 00266 1.0000000000000e+00, 1.1547819846895e+00, 00267 1.3335214321633e+00, 1.5399265260595e+00, 00268 1.7782794100389e+00, 2.0535250264571e+00, 00269 2.3713737056617e+00, 2.7384196342644e+00, 00270 3.1622776601684e+00, 3.6517412725484e+00, 00271 4.2169650342858e+00, 4.8696752516586e+00, 00272 5.6234132519035e+00, 6.4938163157621e+00, 00273 7.4989420933246e+00, 8.6596432336007e+00, 00274 1.0000000000000e+01, 1.1547819846895e+01, 00275 1.3335214321633e+01, 1.5399265260595e+01, 00276 1.7782794100389e+01, 2.0535250264571e+01, 00277 2.3713737056617e+01, 2.7384196342644e+01, 00278 3.1622776601684e+01, 3.6517412725484e+01, 00279 4.2169650342858e+01, 4.8696752516586e+01, 00280 5.6234132519035e+01, 6.4938163157621e+01, 00281 7.4989420933246e+01, 8.6596432336007e+01, 00282 1.0000000000000e+02, 1.1547819846895e+02, 00283 1.3335214321633e+02, 1.5399265260595e+02, 00284 1.7782794100389e+02, 2.0535250264571e+02, 00285 2.3713737056617e+02, 2.7384196342644e+02, 00286 3.1622776601684e+02, 3.6517412725484e+02, 00287 4.2169650342858e+02, 4.8696752516586e+02, 00288 5.6234132519035e+02, 6.4938163157621e+02, 00289 7.4989420933246e+02, 8.6596432336007e+02, 00290 1.0000000000000e+03, 1.1547819846895e+03, 00291 1.3335214321633e+03, 1.5399265260595e+03, 00292 1.7782794100389e+03, 2.0535250264571e+03, 00293 2.3713737056617e+03, 2.7384196342644e+03, 00294 3.1622776601684e+03, 3.6517412725484e+03, 00295 4.2169650342858e+03, 4.8696752516586e+03, 00296 5.6234132519035e+03, 6.4938163157621e+03, 00297 7.4989420933246e+03, 8.6596432336007e+03, 00298 1.0000000000000e+04, 1.1547819846895e+04, 00299 1.3335214321633e+04, 1.5399265260595e+04, 00300 1.7782794100389e+04, 2.0535250264571e+04, 00301 2.3713737056617e+04, 2.7384196342644e+04, 00302 3.1622776601684e+04, 3.6517412725484e+04, 00303 4.2169650342858e+04, 4.8696752516586e+04, 00304 5.6234132519035e+04, 6.4938163157621e+04, 00305 7.4989420933246e+04, 8.6596432336007e+04, 00306 1.0000000000000e+05, 1.1547819846895e+05, 00307 1.3335214321633e+05, 1.5399265260595e+05, 00308 1.7782794100389e+05, 2.0535250264571e+05, 00309 2.3713737056617e+05, 2.7384196342644e+05, 00310 3.1622776601684e+05, 3.6517412725484e+05, 00311 4.2169650342858e+05, 4.8696752516586e+05, 00312 5.6234132519035e+05, 6.4938163157621e+05, 00313 7.4989420933246e+05, 8.6596432336007e+05, 00314 }; 00315 00319 static int decode_exp_vlc(WMACodecContext *s, int ch) 00320 { 00321 int last_exp, n, code; 00322 const uint16_t *ptr; 00323 float v, max_scale; 00324 uint32_t *q, *q_end, iv; 00325 const float *ptab = pow_tab + 60; 00326 const uint32_t *iptab = (const uint32_t*)ptab; 00327 00328 ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; 00329 q = (uint32_t *)s->exponents[ch]; 00330 q_end = q + s->block_len; 00331 max_scale = 0; 00332 if (s->version == 1) { 00333 last_exp = get_bits(&s->gb, 5) + 10; 00334 v = ptab[last_exp]; 00335 iv = iptab[last_exp]; 00336 max_scale = v; 00337 n = *ptr++; 00338 switch (n & 3) do { 00339 case 0: *q++ = iv; 00340 case 3: *q++ = iv; 00341 case 2: *q++ = iv; 00342 case 1: *q++ = iv; 00343 } while ((n -= 4) > 0); 00344 }else 00345 last_exp = 36; 00346 00347 while (q < q_end) { 00348 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); 00349 if (code < 0){ 00350 av_log(s->avctx, AV_LOG_ERROR, "Exponent vlc invalid\n"); 00351 return -1; 00352 } 00353 /* NOTE: this offset is the same as MPEG4 AAC ! */ 00354 last_exp += code - 60; 00355 if ((unsigned)last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) { 00356 av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n", 00357 last_exp); 00358 return -1; 00359 } 00360 v = ptab[last_exp]; 00361 iv = iptab[last_exp]; 00362 if (v > max_scale) 00363 max_scale = v; 00364 n = *ptr++; 00365 switch (n & 3) do { 00366 case 0: *q++ = iv; 00367 case 3: *q++ = iv; 00368 case 2: *q++ = iv; 00369 case 1: *q++ = iv; 00370 } while ((n -= 4) > 0); 00371 } 00372 s->max_exponent[ch] = max_scale; 00373 return 0; 00374 } 00375 00376 00383 static void wma_window(WMACodecContext *s, float *out) 00384 { 00385 float *in = s->output; 00386 int block_len, bsize, n; 00387 00388 /* left part */ 00389 if (s->block_len_bits <= s->prev_block_len_bits) { 00390 block_len = s->block_len; 00391 bsize = s->frame_len_bits - s->block_len_bits; 00392 00393 s->dsp.vector_fmul_add(out, in, s->windows[bsize], 00394 out, block_len); 00395 00396 } else { 00397 block_len = 1 << s->prev_block_len_bits; 00398 n = (s->block_len - block_len) / 2; 00399 bsize = s->frame_len_bits - s->prev_block_len_bits; 00400 00401 s->dsp.vector_fmul_add(out+n, in+n, s->windows[bsize], 00402 out+n, block_len); 00403 00404 memcpy(out+n+block_len, in+n+block_len, n*sizeof(float)); 00405 } 00406 00407 out += s->block_len; 00408 in += s->block_len; 00409 00410 /* right part */ 00411 if (s->block_len_bits <= s->next_block_len_bits) { 00412 block_len = s->block_len; 00413 bsize = s->frame_len_bits - s->block_len_bits; 00414 00415 s->dsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len); 00416 00417 } else { 00418 block_len = 1 << s->next_block_len_bits; 00419 n = (s->block_len - block_len) / 2; 00420 bsize = s->frame_len_bits - s->next_block_len_bits; 00421 00422 memcpy(out, in, n*sizeof(float)); 00423 00424 s->dsp.vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len); 00425 00426 memset(out+n+block_len, 0, n*sizeof(float)); 00427 } 00428 } 00429 00430 00435 static int wma_decode_block(WMACodecContext *s) 00436 { 00437 int n, v, a, ch, bsize; 00438 int coef_nb_bits, total_gain; 00439 int nb_coefs[MAX_CHANNELS]; 00440 float mdct_norm; 00441 FFTContext *mdct; 00442 00443 #ifdef TRACE 00444 tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num); 00445 #endif 00446 00447 /* compute current block length */ 00448 if (s->use_variable_block_len) { 00449 n = av_log2(s->nb_block_sizes - 1) + 1; 00450 00451 if (s->reset_block_lengths) { 00452 s->reset_block_lengths = 0; 00453 v = get_bits(&s->gb, n); 00454 if (v >= s->nb_block_sizes){ 00455 av_log(s->avctx, AV_LOG_ERROR, "prev_block_len_bits %d out of range\n", s->frame_len_bits - v); 00456 return -1; 00457 } 00458 s->prev_block_len_bits = s->frame_len_bits - v; 00459 v = get_bits(&s->gb, n); 00460 if (v >= s->nb_block_sizes){ 00461 av_log(s->avctx, AV_LOG_ERROR, "block_len_bits %d out of range\n", s->frame_len_bits - v); 00462 return -1; 00463 } 00464 s->block_len_bits = s->frame_len_bits - v; 00465 } else { 00466 /* update block lengths */ 00467 s->prev_block_len_bits = s->block_len_bits; 00468 s->block_len_bits = s->next_block_len_bits; 00469 } 00470 v = get_bits(&s->gb, n); 00471 if (v >= s->nb_block_sizes){ 00472 av_log(s->avctx, AV_LOG_ERROR, "next_block_len_bits %d out of range\n", s->frame_len_bits - v); 00473 return -1; 00474 } 00475 s->next_block_len_bits = s->frame_len_bits - v; 00476 } else { 00477 /* fixed block len */ 00478 s->next_block_len_bits = s->frame_len_bits; 00479 s->prev_block_len_bits = s->frame_len_bits; 00480 s->block_len_bits = s->frame_len_bits; 00481 } 00482 00483 /* now check if the block length is coherent with the frame length */ 00484 s->block_len = 1 << s->block_len_bits; 00485 if ((s->block_pos + s->block_len) > s->frame_len){ 00486 av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n"); 00487 return -1; 00488 } 00489 00490 if (s->nb_channels == 2) { 00491 s->ms_stereo = get_bits1(&s->gb); 00492 } 00493 v = 0; 00494 for(ch = 0; ch < s->nb_channels; ch++) { 00495 a = get_bits1(&s->gb); 00496 s->channel_coded[ch] = a; 00497 v |= a; 00498 } 00499 00500 bsize = s->frame_len_bits - s->block_len_bits; 00501 00502 /* if no channel coded, no need to go further */ 00503 /* XXX: fix potential framing problems */ 00504 if (!v) 00505 goto next; 00506 00507 /* read total gain and extract corresponding number of bits for 00508 coef escape coding */ 00509 total_gain = 1; 00510 for(;;) { 00511 a = get_bits(&s->gb, 7); 00512 total_gain += a; 00513 if (a != 127) 00514 break; 00515 } 00516 00517 coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); 00518 00519 /* compute number of coefficients */ 00520 n = s->coefs_end[bsize] - s->coefs_start; 00521 for(ch = 0; ch < s->nb_channels; ch++) 00522 nb_coefs[ch] = n; 00523 00524 /* complex coding */ 00525 if (s->use_noise_coding) { 00526 00527 for(ch = 0; ch < s->nb_channels; ch++) { 00528 if (s->channel_coded[ch]) { 00529 int i, n, a; 00530 n = s->exponent_high_sizes[bsize]; 00531 for(i=0;i<n;i++) { 00532 a = get_bits1(&s->gb); 00533 s->high_band_coded[ch][i] = a; 00534 /* if noise coding, the coefficients are not transmitted */ 00535 if (a) 00536 nb_coefs[ch] -= s->exponent_high_bands[bsize][i]; 00537 } 00538 } 00539 } 00540 for(ch = 0; ch < s->nb_channels; ch++) { 00541 if (s->channel_coded[ch]) { 00542 int i, n, val, code; 00543 00544 n = s->exponent_high_sizes[bsize]; 00545 val = (int)0x80000000; 00546 for(i=0;i<n;i++) { 00547 if (s->high_band_coded[ch][i]) { 00548 if (val == (int)0x80000000) { 00549 val = get_bits(&s->gb, 7) - 19; 00550 } else { 00551 code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX); 00552 if (code < 0){ 00553 av_log(s->avctx, AV_LOG_ERROR, "hgain vlc invalid\n"); 00554 return -1; 00555 } 00556 val += code - 18; 00557 } 00558 s->high_band_values[ch][i] = val; 00559 } 00560 } 00561 } 00562 } 00563 } 00564 00565 /* exponents can be reused in short blocks. */ 00566 if ((s->block_len_bits == s->frame_len_bits) || 00567 get_bits1(&s->gb)) { 00568 for(ch = 0; ch < s->nb_channels; ch++) { 00569 if (s->channel_coded[ch]) { 00570 if (s->use_exp_vlc) { 00571 if (decode_exp_vlc(s, ch) < 0) 00572 return -1; 00573 } else { 00574 decode_exp_lsp(s, ch); 00575 } 00576 s->exponents_bsize[ch] = bsize; 00577 } 00578 } 00579 } 00580 00581 /* parse spectral coefficients : just RLE encoding */ 00582 for(ch = 0; ch < s->nb_channels; ch++) { 00583 if (s->channel_coded[ch]) { 00584 int tindex; 00585 WMACoef* ptr = &s->coefs1[ch][0]; 00586 00587 /* special VLC tables are used for ms stereo because 00588 there is potentially less energy there */ 00589 tindex = (ch == 1 && s->ms_stereo); 00590 memset(ptr, 0, s->block_len * sizeof(WMACoef)); 00591 ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex], 00592 s->level_table[tindex], s->run_table[tindex], 00593 0, ptr, 0, nb_coefs[ch], 00594 s->block_len, s->frame_len_bits, coef_nb_bits); 00595 } 00596 if (s->version == 1 && s->nb_channels >= 2) { 00597 align_get_bits(&s->gb); 00598 } 00599 } 00600 00601 /* normalize */ 00602 { 00603 int n4 = s->block_len / 2; 00604 mdct_norm = 1.0 / (float)n4; 00605 if (s->version == 1) { 00606 mdct_norm *= sqrt(n4); 00607 } 00608 } 00609 00610 /* finally compute the MDCT coefficients */ 00611 for(ch = 0; ch < s->nb_channels; ch++) { 00612 if (s->channel_coded[ch]) { 00613 WMACoef *coefs1; 00614 float *coefs, *exponents, mult, mult1, noise; 00615 int i, j, n, n1, last_high_band, esize; 00616 float exp_power[HIGH_BAND_MAX_SIZE]; 00617 00618 coefs1 = s->coefs1[ch]; 00619 exponents = s->exponents[ch]; 00620 esize = s->exponents_bsize[ch]; 00621 mult = pow(10, total_gain * 0.05) / s->max_exponent[ch]; 00622 mult *= mdct_norm; 00623 coefs = s->coefs[ch]; 00624 if (s->use_noise_coding) { 00625 mult1 = mult; 00626 /* very low freqs : noise */ 00627 for(i = 0;i < s->coefs_start; i++) { 00628 *coefs++ = s->noise_table[s->noise_index] * 00629 exponents[i<<bsize>>esize] * mult1; 00630 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 00631 } 00632 00633 n1 = s->exponent_high_sizes[bsize]; 00634 00635 /* compute power of high bands */ 00636 exponents = s->exponents[ch] + 00637 (s->high_band_start[bsize]<<bsize>>esize); 00638 last_high_band = 0; /* avoid warning */ 00639 for(j=0;j<n1;j++) { 00640 n = s->exponent_high_bands[s->frame_len_bits - 00641 s->block_len_bits][j]; 00642 if (s->high_band_coded[ch][j]) { 00643 float e2, v; 00644 e2 = 0; 00645 for(i = 0;i < n; i++) { 00646 v = exponents[i<<bsize>>esize]; 00647 e2 += v * v; 00648 } 00649 exp_power[j] = e2 / n; 00650 last_high_band = j; 00651 tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n); 00652 } 00653 exponents += n<<bsize>>esize; 00654 } 00655 00656 /* main freqs and high freqs */ 00657 exponents = s->exponents[ch] + (s->coefs_start<<bsize>>esize); 00658 for(j=-1;j<n1;j++) { 00659 if (j < 0) { 00660 n = s->high_band_start[bsize] - 00661 s->coefs_start; 00662 } else { 00663 n = s->exponent_high_bands[s->frame_len_bits - 00664 s->block_len_bits][j]; 00665 } 00666 if (j >= 0 && s->high_band_coded[ch][j]) { 00667 /* use noise with specified power */ 00668 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); 00669 /* XXX: use a table */ 00670 mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05); 00671 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult); 00672 mult1 *= mdct_norm; 00673 for(i = 0;i < n; i++) { 00674 noise = s->noise_table[s->noise_index]; 00675 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 00676 *coefs++ = noise * 00677 exponents[i<<bsize>>esize] * mult1; 00678 } 00679 exponents += n<<bsize>>esize; 00680 } else { 00681 /* coded values + small noise */ 00682 for(i = 0;i < n; i++) { 00683 noise = s->noise_table[s->noise_index]; 00684 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 00685 *coefs++ = ((*coefs1++) + noise) * 00686 exponents[i<<bsize>>esize] * mult; 00687 } 00688 exponents += n<<bsize>>esize; 00689 } 00690 } 00691 00692 /* very high freqs : noise */ 00693 n = s->block_len - s->coefs_end[bsize]; 00694 mult1 = mult * exponents[((-1<<bsize))>>esize]; 00695 for(i = 0; i < n; i++) { 00696 *coefs++ = s->noise_table[s->noise_index] * mult1; 00697 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 00698 } 00699 } else { 00700 /* XXX: optimize more */ 00701 for(i = 0;i < s->coefs_start; i++) 00702 *coefs++ = 0.0; 00703 n = nb_coefs[ch]; 00704 for(i = 0;i < n; i++) { 00705 *coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult; 00706 } 00707 n = s->block_len - s->coefs_end[bsize]; 00708 for(i = 0;i < n; i++) 00709 *coefs++ = 0.0; 00710 } 00711 } 00712 } 00713 00714 #ifdef TRACE 00715 for(ch = 0; ch < s->nb_channels; ch++) { 00716 if (s->channel_coded[ch]) { 00717 dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len); 00718 dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len); 00719 } 00720 } 00721 #endif 00722 00723 if (s->ms_stereo && s->channel_coded[1]) { 00724 /* nominal case for ms stereo: we do it before mdct */ 00725 /* no need to optimize this case because it should almost 00726 never happen */ 00727 if (!s->channel_coded[0]) { 00728 tprintf(s->avctx, "rare ms-stereo case happened\n"); 00729 memset(s->coefs[0], 0, sizeof(float) * s->block_len); 00730 s->channel_coded[0] = 1; 00731 } 00732 00733 s->dsp.butterflies_float(s->coefs[0], s->coefs[1], s->block_len); 00734 } 00735 00736 next: 00737 mdct = &s->mdct_ctx[bsize]; 00738 00739 for(ch = 0; ch < s->nb_channels; ch++) { 00740 int n4, index; 00741 00742 n4 = s->block_len / 2; 00743 if(s->channel_coded[ch]){ 00744 mdct->imdct_calc(mdct, s->output, s->coefs[ch]); 00745 }else if(!(s->ms_stereo && ch==1)) 00746 memset(s->output, 0, sizeof(s->output)); 00747 00748 /* multiply by the window and add in the frame */ 00749 index = (s->frame_len / 2) + s->block_pos - n4; 00750 wma_window(s, &s->frame_out[ch][index]); 00751 } 00752 00753 /* update block number */ 00754 s->block_num++; 00755 s->block_pos += s->block_len; 00756 if (s->block_pos >= s->frame_len) 00757 return 1; 00758 else 00759 return 0; 00760 } 00761 00762 /* decode a frame of frame_len samples */ 00763 static int wma_decode_frame(WMACodecContext *s, int16_t *samples) 00764 { 00765 int ret, n, ch, incr; 00766 const float *output[MAX_CHANNELS]; 00767 00768 #ifdef TRACE 00769 tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len); 00770 #endif 00771 00772 /* read each block */ 00773 s->block_num = 0; 00774 s->block_pos = 0; 00775 for(;;) { 00776 ret = wma_decode_block(s); 00777 if (ret < 0) 00778 return -1; 00779 if (ret) 00780 break; 00781 } 00782 00783 /* convert frame to integer */ 00784 n = s->frame_len; 00785 incr = s->nb_channels; 00786 for (ch = 0; ch < MAX_CHANNELS; ch++) 00787 output[ch] = s->frame_out[ch]; 00788 s->fmt_conv.float_to_int16_interleave(samples, output, n, incr); 00789 for (ch = 0; ch < incr; ch++) { 00790 /* prepare for next block */ 00791 memmove(&s->frame_out[ch][0], &s->frame_out[ch][n], n * sizeof(float)); 00792 } 00793 00794 #ifdef TRACE 00795 dump_shorts(s, "samples", samples, n * s->nb_channels); 00796 #endif 00797 return 0; 00798 } 00799 00800 static int wma_decode_superframe(AVCodecContext *avctx, 00801 void *data, int *data_size, 00802 AVPacket *avpkt) 00803 { 00804 const uint8_t *buf = avpkt->data; 00805 int buf_size = avpkt->size; 00806 WMACodecContext *s = avctx->priv_data; 00807 int nb_frames, bit_offset, i, pos, len; 00808 uint8_t *q; 00809 int16_t *samples; 00810 00811 tprintf(avctx, "***decode_superframe:\n"); 00812 00813 if(buf_size==0){ 00814 s->last_superframe_len = 0; 00815 return 0; 00816 } 00817 if (buf_size < s->block_align) 00818 return 0; 00819 buf_size = s->block_align; 00820 00821 samples = data; 00822 00823 init_get_bits(&s->gb, buf, buf_size*8); 00824 00825 if (s->use_bit_reservoir) { 00826 /* read super frame header */ 00827 skip_bits(&s->gb, 4); /* super frame index */ 00828 nb_frames = get_bits(&s->gb, 4) - 1; 00829 00830 if((nb_frames+1) * s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){ 00831 av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n"); 00832 goto fail; 00833 } 00834 00835 bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3); 00836 00837 if (s->last_superframe_len > 0) { 00838 // printf("skip=%d\n", s->last_bitoffset); 00839 /* add bit_offset bits to last frame */ 00840 if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) > 00841 MAX_CODED_SUPERFRAME_SIZE) 00842 goto fail; 00843 q = s->last_superframe + s->last_superframe_len; 00844 len = bit_offset; 00845 while (len > 7) { 00846 *q++ = (get_bits)(&s->gb, 8); 00847 len -= 8; 00848 } 00849 if (len > 0) { 00850 *q++ = (get_bits)(&s->gb, len) << (8 - len); 00851 } 00852 00853 /* XXX: bit_offset bits into last frame */ 00854 init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8); 00855 /* skip unused bits */ 00856 if (s->last_bitoffset > 0) 00857 skip_bits(&s->gb, s->last_bitoffset); 00858 /* this frame is stored in the last superframe and in the 00859 current one */ 00860 if (wma_decode_frame(s, samples) < 0) 00861 goto fail; 00862 samples += s->nb_channels * s->frame_len; 00863 } 00864 00865 /* read each frame starting from bit_offset */ 00866 pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3; 00867 if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8) 00868 return AVERROR_INVALIDDATA; 00869 init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8); 00870 len = pos & 7; 00871 if (len > 0) 00872 skip_bits(&s->gb, len); 00873 00874 s->reset_block_lengths = 1; 00875 for(i=0;i<nb_frames;i++) { 00876 if (wma_decode_frame(s, samples) < 0) 00877 goto fail; 00878 samples += s->nb_channels * s->frame_len; 00879 } 00880 00881 /* we copy the end of the frame in the last frame buffer */ 00882 pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7); 00883 s->last_bitoffset = pos & 7; 00884 pos >>= 3; 00885 len = buf_size - pos; 00886 if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) { 00887 av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len); 00888 goto fail; 00889 } 00890 s->last_superframe_len = len; 00891 memcpy(s->last_superframe, buf + pos, len); 00892 } else { 00893 if(s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){ 00894 av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n"); 00895 goto fail; 00896 } 00897 /* single frame decode */ 00898 if (wma_decode_frame(s, samples) < 0) 00899 goto fail; 00900 samples += s->nb_channels * s->frame_len; 00901 } 00902 00903 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len, (int8_t *)samples - (int8_t *)data, s->block_align); 00904 00905 *data_size = (int8_t *)samples - (int8_t *)data; 00906 return s->block_align; 00907 fail: 00908 /* when error, we reset the bit reservoir */ 00909 s->last_superframe_len = 0; 00910 return -1; 00911 } 00912 00913 static av_cold void flush(AVCodecContext *avctx) 00914 { 00915 WMACodecContext *s = avctx->priv_data; 00916 00917 s->last_bitoffset= 00918 s->last_superframe_len= 0; 00919 } 00920 00921 AVCodec ff_wmav1_decoder = 00922 { 00923 "wmav1", 00924 AVMEDIA_TYPE_AUDIO, 00925 CODEC_ID_WMAV1, 00926 sizeof(WMACodecContext), 00927 wma_decode_init, 00928 NULL, 00929 ff_wma_end, 00930 wma_decode_superframe, 00931 .flush=flush, 00932 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"), 00933 }; 00934 00935 AVCodec ff_wmav2_decoder = 00936 { 00937 "wmav2", 00938 AVMEDIA_TYPE_AUDIO, 00939 CODEC_ID_WMAV2, 00940 sizeof(WMACodecContext), 00941 wma_decode_init, 00942 NULL, 00943 ff_wma_end, 00944 wma_decode_superframe, 00945 .flush=flush, 00946 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"), 00947 };