Libav
|
00001 /* 00002 * WMA compatible codec 00003 * Copyright (c) 2002-2007 The FFmpeg Project 00004 * 00005 * This file is part of FFmpeg. 00006 * 00007 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00022 #include "avcodec.h" 00023 #include "wma.h" 00024 #include "wmadata.h" 00025 00026 #undef NDEBUG 00027 #include <assert.h> 00028 00029 /* XXX: use same run/length optimization as mpeg decoders */ 00030 //FIXME maybe split decode / encode or pass flag 00031 static void init_coef_vlc(VLC *vlc, uint16_t **prun_table, 00032 float **plevel_table, uint16_t **pint_table, 00033 const CoefVLCTable *vlc_table) 00034 { 00035 int n = vlc_table->n; 00036 const uint8_t *table_bits = vlc_table->huffbits; 00037 const uint32_t *table_codes = vlc_table->huffcodes; 00038 const uint16_t *levels_table = vlc_table->levels; 00039 uint16_t *run_table, *level_table, *int_table; 00040 float *flevel_table; 00041 int i, l, j, k, level; 00042 00043 init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); 00044 00045 run_table = av_malloc(n * sizeof(uint16_t)); 00046 level_table = av_malloc(n * sizeof(uint16_t)); 00047 flevel_table= av_malloc(n * sizeof(*flevel_table)); 00048 int_table = av_malloc(n * sizeof(uint16_t)); 00049 i = 2; 00050 level = 1; 00051 k = 0; 00052 while (i < n) { 00053 int_table[k] = i; 00054 l = levels_table[k++]; 00055 for (j = 0; j < l; j++) { 00056 run_table[i] = j; 00057 level_table[i] = level; 00058 flevel_table[i]= level; 00059 i++; 00060 } 00061 level++; 00062 } 00063 *prun_table = run_table; 00064 *plevel_table = flevel_table; 00065 *pint_table = int_table; 00066 av_free(level_table); 00067 } 00068 00076 int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, 00077 unsigned int decode_flags) 00078 { 00079 00080 int frame_len_bits; 00081 00082 if (sample_rate <= 16000) { 00083 frame_len_bits = 9; 00084 } else if (sample_rate <= 22050 || 00085 (sample_rate <= 32000 && version == 1)) { 00086 frame_len_bits = 10; 00087 } else if (sample_rate <= 48000) { 00088 frame_len_bits = 11; 00089 } else if (sample_rate <= 96000) { 00090 frame_len_bits = 12; 00091 } else { 00092 frame_len_bits = 13; 00093 } 00094 00095 if (version == 3) { 00096 int tmp = decode_flags & 0x6; 00097 if (tmp == 0x2) { 00098 ++frame_len_bits; 00099 } else if (tmp == 0x4) { 00100 --frame_len_bits; 00101 } else if (tmp == 0x6) { 00102 frame_len_bits -= 2; 00103 } 00104 } 00105 00106 return frame_len_bits; 00107 } 00108 00109 int ff_wma_init(AVCodecContext *avctx, int flags2) 00110 { 00111 WMACodecContext *s = avctx->priv_data; 00112 int i; 00113 float bps1, high_freq; 00114 volatile float bps; 00115 int sample_rate1; 00116 int coef_vlc_table; 00117 00118 if ( avctx->sample_rate <= 0 || avctx->sample_rate > 50000 00119 || avctx->channels <= 0 || avctx->channels > 8 00120 || avctx->bit_rate <= 0) 00121 return -1; 00122 00123 s->sample_rate = avctx->sample_rate; 00124 s->nb_channels = avctx->channels; 00125 s->bit_rate = avctx->bit_rate; 00126 s->block_align = avctx->block_align; 00127 00128 dsputil_init(&s->dsp, avctx); 00129 00130 if (avctx->codec->id == CODEC_ID_WMAV1) { 00131 s->version = 1; 00132 } else { 00133 s->version = 2; 00134 } 00135 00136 /* compute MDCT block size */ 00137 s->frame_len_bits = ff_wma_get_frame_len_bits(s->sample_rate, s->version, 0); 00138 s->next_block_len_bits = s->frame_len_bits; 00139 s->prev_block_len_bits = s->frame_len_bits; 00140 s->block_len_bits = s->frame_len_bits; 00141 00142 s->frame_len = 1 << s->frame_len_bits; 00143 if (s->use_variable_block_len) { 00144 int nb_max, nb; 00145 nb = ((flags2 >> 3) & 3) + 1; 00146 if ((s->bit_rate / s->nb_channels) >= 32000) 00147 nb += 2; 00148 nb_max = s->frame_len_bits - BLOCK_MIN_BITS; 00149 if (nb > nb_max) 00150 nb = nb_max; 00151 s->nb_block_sizes = nb + 1; 00152 } else { 00153 s->nb_block_sizes = 1; 00154 } 00155 00156 /* init rate dependent parameters */ 00157 s->use_noise_coding = 1; 00158 high_freq = s->sample_rate * 0.5; 00159 00160 /* if version 2, then the rates are normalized */ 00161 sample_rate1 = s->sample_rate; 00162 if (s->version == 2) { 00163 if (sample_rate1 >= 44100) { 00164 sample_rate1 = 44100; 00165 } else if (sample_rate1 >= 22050) { 00166 sample_rate1 = 22050; 00167 } else if (sample_rate1 >= 16000) { 00168 sample_rate1 = 16000; 00169 } else if (sample_rate1 >= 11025) { 00170 sample_rate1 = 11025; 00171 } else if (sample_rate1 >= 8000) { 00172 sample_rate1 = 8000; 00173 } 00174 } 00175 00176 bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); 00177 s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; 00178 00179 /* compute high frequency value and choose if noise coding should 00180 be activated */ 00181 bps1 = bps; 00182 if (s->nb_channels == 2) 00183 bps1 = bps * 1.6; 00184 if (sample_rate1 == 44100) { 00185 if (bps1 >= 0.61) { 00186 s->use_noise_coding = 0; 00187 } else { 00188 high_freq = high_freq * 0.4; 00189 } 00190 } else if (sample_rate1 == 22050) { 00191 if (bps1 >= 1.16) { 00192 s->use_noise_coding = 0; 00193 } else if (bps1 >= 0.72) { 00194 high_freq = high_freq * 0.7; 00195 } else { 00196 high_freq = high_freq * 0.6; 00197 } 00198 } else if (sample_rate1 == 16000) { 00199 if (bps > 0.5) { 00200 high_freq = high_freq * 0.5; 00201 } else { 00202 high_freq = high_freq * 0.3; 00203 } 00204 } else if (sample_rate1 == 11025) { 00205 high_freq = high_freq * 0.7; 00206 } else if (sample_rate1 == 8000) { 00207 if (bps <= 0.625) { 00208 high_freq = high_freq * 0.5; 00209 } else if (bps > 0.75) { 00210 s->use_noise_coding = 0; 00211 } else { 00212 high_freq = high_freq * 0.65; 00213 } 00214 } else { 00215 if (bps >= 0.8) { 00216 high_freq = high_freq * 0.75; 00217 } else if (bps >= 0.6) { 00218 high_freq = high_freq * 0.6; 00219 } else { 00220 high_freq = high_freq * 0.5; 00221 } 00222 } 00223 dprintf(s->avctx, "flags2=0x%x\n", flags2); 00224 dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", 00225 s->version, s->nb_channels, s->sample_rate, s->bit_rate, 00226 s->block_align); 00227 dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n", 00228 bps, bps1, high_freq, s->byte_offset_bits); 00229 dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", 00230 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); 00231 00232 /* compute the scale factor band sizes for each MDCT block size */ 00233 { 00234 int a, b, pos, lpos, k, block_len, i, j, n; 00235 const uint8_t *table; 00236 00237 if (s->version == 1) { 00238 s->coefs_start = 3; 00239 } else { 00240 s->coefs_start = 0; 00241 } 00242 for (k = 0; k < s->nb_block_sizes; k++) { 00243 block_len = s->frame_len >> k; 00244 00245 if (s->version == 1) { 00246 lpos = 0; 00247 for (i = 0; i < 25; i++) { 00248 a = ff_wma_critical_freqs[i]; 00249 b = s->sample_rate; 00250 pos = ((block_len * 2 * a) + (b >> 1)) / b; 00251 if (pos > block_len) 00252 pos = block_len; 00253 s->exponent_bands[0][i] = pos - lpos; 00254 if (pos >= block_len) { 00255 i++; 00256 break; 00257 } 00258 lpos = pos; 00259 } 00260 s->exponent_sizes[0] = i; 00261 } else { 00262 /* hardcoded tables */ 00263 table = NULL; 00264 a = s->frame_len_bits - BLOCK_MIN_BITS - k; 00265 if (a < 3) { 00266 if (s->sample_rate >= 44100) { 00267 table = exponent_band_44100[a]; 00268 } else if (s->sample_rate >= 32000) { 00269 table = exponent_band_32000[a]; 00270 } else if (s->sample_rate >= 22050) { 00271 table = exponent_band_22050[a]; 00272 } 00273 } 00274 if (table) { 00275 n = *table++; 00276 for (i = 0; i < n; i++) 00277 s->exponent_bands[k][i] = table[i]; 00278 s->exponent_sizes[k] = n; 00279 } else { 00280 j = 0; 00281 lpos = 0; 00282 for (i = 0; i < 25; i++) { 00283 a = ff_wma_critical_freqs[i]; 00284 b = s->sample_rate; 00285 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 00286 pos <<= 2; 00287 if (pos > block_len) 00288 pos = block_len; 00289 if (pos > lpos) 00290 s->exponent_bands[k][j++] = pos - lpos; 00291 if (pos >= block_len) 00292 break; 00293 lpos = pos; 00294 } 00295 s->exponent_sizes[k] = j; 00296 } 00297 } 00298 00299 /* max number of coefs */ 00300 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; 00301 /* high freq computation */ 00302 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / 00303 s->sample_rate + 0.5); 00304 n = s->exponent_sizes[k]; 00305 j = 0; 00306 pos = 0; 00307 for (i = 0; i < n; i++) { 00308 int start, end; 00309 start = pos; 00310 pos += s->exponent_bands[k][i]; 00311 end = pos; 00312 if (start < s->high_band_start[k]) 00313 start = s->high_band_start[k]; 00314 if (end > s->coefs_end[k]) 00315 end = s->coefs_end[k]; 00316 if (end > start) 00317 s->exponent_high_bands[k][j++] = end - start; 00318 } 00319 s->exponent_high_sizes[k] = j; 00320 #if 0 00321 tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", 00322 s->frame_len >> k, 00323 s->coefs_end[k], 00324 s->high_band_start[k], 00325 s->exponent_high_sizes[k]); 00326 for (j = 0; j < s->exponent_high_sizes[k]; j++) 00327 tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); 00328 tprintf(s->avctx, "\n"); 00329 #endif 00330 } 00331 } 00332 00333 #ifdef TRACE 00334 { 00335 int i, j; 00336 for (i = 0; i < s->nb_block_sizes; i++) { 00337 tprintf(s->avctx, "%5d: n=%2d:", 00338 s->frame_len >> i, 00339 s->exponent_sizes[i]); 00340 for (j = 0; j < s->exponent_sizes[i]; j++) 00341 tprintf(s->avctx, " %d", s->exponent_bands[i][j]); 00342 tprintf(s->avctx, "\n"); 00343 } 00344 } 00345 #endif 00346 00347 /* init MDCT windows : simple sinus window */ 00348 for (i = 0; i < s->nb_block_sizes; i++) { 00349 ff_init_ff_sine_windows(s->frame_len_bits - i); 00350 s->windows[i] = ff_sine_windows[s->frame_len_bits - i]; 00351 } 00352 00353 s->reset_block_lengths = 1; 00354 00355 if (s->use_noise_coding) { 00356 00357 /* init the noise generator */ 00358 if (s->use_exp_vlc) { 00359 s->noise_mult = 0.02; 00360 } else { 00361 s->noise_mult = 0.04; 00362 } 00363 00364 #ifdef TRACE 00365 for (i = 0; i < NOISE_TAB_SIZE; i++) 00366 s->noise_table[i] = 1.0 * s->noise_mult; 00367 #else 00368 { 00369 unsigned int seed; 00370 float norm; 00371 seed = 1; 00372 norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; 00373 for (i = 0; i < NOISE_TAB_SIZE; i++) { 00374 seed = seed * 314159 + 1; 00375 s->noise_table[i] = (float)((int)seed) * norm; 00376 } 00377 } 00378 #endif 00379 } 00380 00381 /* choose the VLC tables for the coefficients */ 00382 coef_vlc_table = 2; 00383 if (s->sample_rate >= 32000) { 00384 if (bps1 < 0.72) { 00385 coef_vlc_table = 0; 00386 } else if (bps1 < 1.16) { 00387 coef_vlc_table = 1; 00388 } 00389 } 00390 s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; 00391 s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; 00392 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], 00393 s->coef_vlcs[0]); 00394 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], 00395 s->coef_vlcs[1]); 00396 00397 return 0; 00398 } 00399 00400 int ff_wma_total_gain_to_bits(int total_gain) 00401 { 00402 if (total_gain < 15) return 13; 00403 else if (total_gain < 32) return 12; 00404 else if (total_gain < 40) return 11; 00405 else if (total_gain < 45) return 10; 00406 else return 9; 00407 } 00408 00409 int ff_wma_end(AVCodecContext *avctx) 00410 { 00411 WMACodecContext *s = avctx->priv_data; 00412 int i; 00413 00414 for (i = 0; i < s->nb_block_sizes; i++) 00415 ff_mdct_end(&s->mdct_ctx[i]); 00416 00417 if (s->use_exp_vlc) { 00418 free_vlc(&s->exp_vlc); 00419 } 00420 if (s->use_noise_coding) { 00421 free_vlc(&s->hgain_vlc); 00422 } 00423 for (i = 0; i < 2; i++) { 00424 free_vlc(&s->coef_vlc[i]); 00425 av_free(s->run_table[i]); 00426 av_free(s->level_table[i]); 00427 av_free(s->int_table[i]); 00428 } 00429 00430 return 0; 00431 } 00432 00438 unsigned int ff_wma_get_large_val(GetBitContext* gb) 00439 { 00441 int n_bits = 8; 00443 if (get_bits1(gb)) { 00444 n_bits += 8; 00445 if (get_bits1(gb)) { 00446 n_bits += 8; 00447 if (get_bits1(gb)) { 00448 n_bits += 7; 00449 } 00450 } 00451 } 00452 return get_bits_long(gb, n_bits); 00453 } 00454 00471 int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, 00472 VLC *vlc, 00473 const float *level_table, const uint16_t *run_table, 00474 int version, WMACoef *ptr, int offset, 00475 int num_coefs, int block_len, int frame_len_bits, 00476 int coef_nb_bits) 00477 { 00478 int code, level, sign; 00479 const uint32_t *ilvl = (const uint32_t*)level_table; 00480 uint32_t *iptr = (uint32_t*)ptr; 00481 const unsigned int coef_mask = block_len - 1; 00482 for (; offset < num_coefs; offset++) { 00483 code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX); 00484 if (code > 1) { 00486 offset += run_table[code]; 00487 sign = get_bits1(gb) - 1; 00488 iptr[offset & coef_mask] = ilvl[code] ^ sign<<31; 00489 } else if (code == 1) { 00491 break; 00492 } else { 00494 if (!version) { 00495 level = get_bits(gb, coef_nb_bits); 00498 offset += get_bits(gb, frame_len_bits); 00499 } else { 00500 level = ff_wma_get_large_val(gb); 00502 if (get_bits1(gb)) { 00503 if (get_bits1(gb)) { 00504 if (get_bits1(gb)) { 00505 av_log(avctx,AV_LOG_ERROR, 00506 "broken escape sequence\n"); 00507 return -1; 00508 } else 00509 offset += get_bits(gb, frame_len_bits) + 4; 00510 } else 00511 offset += get_bits(gb, 2) + 1; 00512 } 00513 } 00514 sign = get_bits1(gb) - 1; 00515 ptr[offset & coef_mask] = (level^sign) - sign; 00516 } 00517 } 00519 if (offset > num_coefs) { 00520 av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n"); 00521 return -1; 00522 } 00523 00524 return 0; 00525 } 00526