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 00139 s->frame_len = 1 << s->frame_len_bits; 00140 if (s->use_variable_block_len) { 00141 int nb_max, nb; 00142 nb = ((flags2 >> 3) & 3) + 1; 00143 if ((s->bit_rate / s->nb_channels) >= 32000) 00144 nb += 2; 00145 nb_max = s->frame_len_bits - BLOCK_MIN_BITS; 00146 if (nb > nb_max) 00147 nb = nb_max; 00148 s->nb_block_sizes = nb + 1; 00149 } else { 00150 s->nb_block_sizes = 1; 00151 } 00152 00153 /* init rate dependent parameters */ 00154 s->use_noise_coding = 1; 00155 high_freq = s->sample_rate * 0.5; 00156 00157 /* if version 2, then the rates are normalized */ 00158 sample_rate1 = s->sample_rate; 00159 if (s->version == 2) { 00160 if (sample_rate1 >= 44100) { 00161 sample_rate1 = 44100; 00162 } else if (sample_rate1 >= 22050) { 00163 sample_rate1 = 22050; 00164 } else if (sample_rate1 >= 16000) { 00165 sample_rate1 = 16000; 00166 } else if (sample_rate1 >= 11025) { 00167 sample_rate1 = 11025; 00168 } else if (sample_rate1 >= 8000) { 00169 sample_rate1 = 8000; 00170 } 00171 } 00172 00173 bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); 00174 s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; 00175 00176 /* compute high frequency value and choose if noise coding should 00177 be activated */ 00178 bps1 = bps; 00179 if (s->nb_channels == 2) 00180 bps1 = bps * 1.6; 00181 if (sample_rate1 == 44100) { 00182 if (bps1 >= 0.61) { 00183 s->use_noise_coding = 0; 00184 } else { 00185 high_freq = high_freq * 0.4; 00186 } 00187 } else if (sample_rate1 == 22050) { 00188 if (bps1 >= 1.16) { 00189 s->use_noise_coding = 0; 00190 } else if (bps1 >= 0.72) { 00191 high_freq = high_freq * 0.7; 00192 } else { 00193 high_freq = high_freq * 0.6; 00194 } 00195 } else if (sample_rate1 == 16000) { 00196 if (bps > 0.5) { 00197 high_freq = high_freq * 0.5; 00198 } else { 00199 high_freq = high_freq * 0.3; 00200 } 00201 } else if (sample_rate1 == 11025) { 00202 high_freq = high_freq * 0.7; 00203 } else if (sample_rate1 == 8000) { 00204 if (bps <= 0.625) { 00205 high_freq = high_freq * 0.5; 00206 } else if (bps > 0.75) { 00207 s->use_noise_coding = 0; 00208 } else { 00209 high_freq = high_freq * 0.65; 00210 } 00211 } else { 00212 if (bps >= 0.8) { 00213 high_freq = high_freq * 0.75; 00214 } else if (bps >= 0.6) { 00215 high_freq = high_freq * 0.6; 00216 } else { 00217 high_freq = high_freq * 0.5; 00218 } 00219 } 00220 dprintf(s->avctx, "flags2=0x%x\n", flags2); 00221 dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", 00222 s->version, s->nb_channels, s->sample_rate, s->bit_rate, 00223 s->block_align); 00224 dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n", 00225 bps, bps1, high_freq, s->byte_offset_bits); 00226 dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", 00227 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); 00228 00229 /* compute the scale factor band sizes for each MDCT block size */ 00230 { 00231 int a, b, pos, lpos, k, block_len, i, j, n; 00232 const uint8_t *table; 00233 00234 if (s->version == 1) { 00235 s->coefs_start = 3; 00236 } else { 00237 s->coefs_start = 0; 00238 } 00239 for (k = 0; k < s->nb_block_sizes; k++) { 00240 block_len = s->frame_len >> k; 00241 00242 if (s->version == 1) { 00243 lpos = 0; 00244 for (i = 0; i < 25; i++) { 00245 a = ff_wma_critical_freqs[i]; 00246 b = s->sample_rate; 00247 pos = ((block_len * 2 * a) + (b >> 1)) / b; 00248 if (pos > block_len) 00249 pos = block_len; 00250 s->exponent_bands[0][i] = pos - lpos; 00251 if (pos >= block_len) { 00252 i++; 00253 break; 00254 } 00255 lpos = pos; 00256 } 00257 s->exponent_sizes[0] = i; 00258 } else { 00259 /* hardcoded tables */ 00260 table = NULL; 00261 a = s->frame_len_bits - BLOCK_MIN_BITS - k; 00262 if (a < 3) { 00263 if (s->sample_rate >= 44100) { 00264 table = exponent_band_44100[a]; 00265 } else if (s->sample_rate >= 32000) { 00266 table = exponent_band_32000[a]; 00267 } else if (s->sample_rate >= 22050) { 00268 table = exponent_band_22050[a]; 00269 } 00270 } 00271 if (table) { 00272 n = *table++; 00273 for (i = 0; i < n; i++) 00274 s->exponent_bands[k][i] = table[i]; 00275 s->exponent_sizes[k] = n; 00276 } else { 00277 j = 0; 00278 lpos = 0; 00279 for (i = 0; i < 25; i++) { 00280 a = ff_wma_critical_freqs[i]; 00281 b = s->sample_rate; 00282 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 00283 pos <<= 2; 00284 if (pos > block_len) 00285 pos = block_len; 00286 if (pos > lpos) 00287 s->exponent_bands[k][j++] = pos - lpos; 00288 if (pos >= block_len) 00289 break; 00290 lpos = pos; 00291 } 00292 s->exponent_sizes[k] = j; 00293 } 00294 } 00295 00296 /* max number of coefs */ 00297 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; 00298 /* high freq computation */ 00299 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / 00300 s->sample_rate + 0.5); 00301 n = s->exponent_sizes[k]; 00302 j = 0; 00303 pos = 0; 00304 for (i = 0; i < n; i++) { 00305 int start, end; 00306 start = pos; 00307 pos += s->exponent_bands[k][i]; 00308 end = pos; 00309 if (start < s->high_band_start[k]) 00310 start = s->high_band_start[k]; 00311 if (end > s->coefs_end[k]) 00312 end = s->coefs_end[k]; 00313 if (end > start) 00314 s->exponent_high_bands[k][j++] = end - start; 00315 } 00316 s->exponent_high_sizes[k] = j; 00317 #if 0 00318 tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", 00319 s->frame_len >> k, 00320 s->coefs_end[k], 00321 s->high_band_start[k], 00322 s->exponent_high_sizes[k]); 00323 for (j = 0; j < s->exponent_high_sizes[k]; j++) 00324 tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); 00325 tprintf(s->avctx, "\n"); 00326 #endif 00327 } 00328 } 00329 00330 #ifdef TRACE 00331 { 00332 int i, j; 00333 for (i = 0; i < s->nb_block_sizes; i++) { 00334 tprintf(s->avctx, "%5d: n=%2d:", 00335 s->frame_len >> i, 00336 s->exponent_sizes[i]); 00337 for (j = 0; j < s->exponent_sizes[i]; j++) 00338 tprintf(s->avctx, " %d", s->exponent_bands[i][j]); 00339 tprintf(s->avctx, "\n"); 00340 } 00341 } 00342 #endif 00343 00344 /* init MDCT windows : simple sinus window */ 00345 for (i = 0; i < s->nb_block_sizes; i++) { 00346 ff_init_ff_sine_windows(s->frame_len_bits - i); 00347 s->windows[i] = ff_sine_windows[s->frame_len_bits - i]; 00348 } 00349 00350 s->reset_block_lengths = 1; 00351 00352 if (s->use_noise_coding) { 00353 00354 /* init the noise generator */ 00355 if (s->use_exp_vlc) { 00356 s->noise_mult = 0.02; 00357 } else { 00358 s->noise_mult = 0.04; 00359 } 00360 00361 #ifdef TRACE 00362 for (i = 0; i < NOISE_TAB_SIZE; i++) 00363 s->noise_table[i] = 1.0 * s->noise_mult; 00364 #else 00365 { 00366 unsigned int seed; 00367 float norm; 00368 seed = 1; 00369 norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; 00370 for (i = 0; i < NOISE_TAB_SIZE; i++) { 00371 seed = seed * 314159 + 1; 00372 s->noise_table[i] = (float)((int)seed) * norm; 00373 } 00374 } 00375 #endif 00376 } 00377 00378 /* choose the VLC tables for the coefficients */ 00379 coef_vlc_table = 2; 00380 if (s->sample_rate >= 32000) { 00381 if (bps1 < 0.72) { 00382 coef_vlc_table = 0; 00383 } else if (bps1 < 1.16) { 00384 coef_vlc_table = 1; 00385 } 00386 } 00387 s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; 00388 s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; 00389 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], 00390 s->coef_vlcs[0]); 00391 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], 00392 s->coef_vlcs[1]); 00393 00394 return 0; 00395 } 00396 00397 int ff_wma_total_gain_to_bits(int total_gain) 00398 { 00399 if (total_gain < 15) return 13; 00400 else if (total_gain < 32) return 12; 00401 else if (total_gain < 40) return 11; 00402 else if (total_gain < 45) return 10; 00403 else return 9; 00404 } 00405 00406 int ff_wma_end(AVCodecContext *avctx) 00407 { 00408 WMACodecContext *s = avctx->priv_data; 00409 int i; 00410 00411 for (i = 0; i < s->nb_block_sizes; i++) 00412 ff_mdct_end(&s->mdct_ctx[i]); 00413 00414 if (s->use_exp_vlc) { 00415 free_vlc(&s->exp_vlc); 00416 } 00417 if (s->use_noise_coding) { 00418 free_vlc(&s->hgain_vlc); 00419 } 00420 for (i = 0; i < 2; i++) { 00421 free_vlc(&s->coef_vlc[i]); 00422 av_free(s->run_table[i]); 00423 av_free(s->level_table[i]); 00424 av_free(s->int_table[i]); 00425 } 00426 00427 return 0; 00428 } 00429 00435 unsigned int ff_wma_get_large_val(GetBitContext* gb) 00436 { 00438 int n_bits = 8; 00440 if (get_bits1(gb)) { 00441 n_bits += 8; 00442 if (get_bits1(gb)) { 00443 n_bits += 8; 00444 if (get_bits1(gb)) { 00445 n_bits += 7; 00446 } 00447 } 00448 } 00449 return get_bits_long(gb, n_bits); 00450 } 00451 00468 int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, 00469 VLC *vlc, 00470 const float *level_table, const uint16_t *run_table, 00471 int version, WMACoef *ptr, int offset, 00472 int num_coefs, int block_len, int frame_len_bits, 00473 int coef_nb_bits) 00474 { 00475 int code, level, sign; 00476 const uint32_t *ilvl = (const uint32_t*)level_table; 00477 uint32_t *iptr = (uint32_t*)ptr; 00478 const unsigned int coef_mask = block_len - 1; 00479 for (; offset < num_coefs; offset++) { 00480 code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX); 00481 if (code > 1) { 00483 offset += run_table[code]; 00484 sign = get_bits1(gb) - 1; 00485 iptr[offset & coef_mask] = ilvl[code] ^ sign<<31; 00486 } else if (code == 1) { 00488 break; 00489 } else { 00491 if (!version) { 00492 level = get_bits(gb, coef_nb_bits); 00495 offset += get_bits(gb, frame_len_bits); 00496 } else { 00497 level = ff_wma_get_large_val(gb); 00499 if (get_bits1(gb)) { 00500 if (get_bits1(gb)) { 00501 if (get_bits1(gb)) { 00502 av_log(avctx,AV_LOG_ERROR, 00503 "broken escape sequence\n"); 00504 return -1; 00505 } else 00506 offset += get_bits(gb, frame_len_bits) + 4; 00507 } else 00508 offset += get_bits(gb, 2) + 1; 00509 } 00510 } 00511 sign = get_bits1(gb) - 1; 00512 ptr[offset & coef_mask] = (level^sign) - sign; 00513 } 00514 } 00516 if (offset > num_coefs) { 00517 av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n"); 00518 return -1; 00519 } 00520 00521 return 0; 00522 } 00523