1/* 2 * WMA compatible codec 3 * Copyright (c) 2002-2007 The FFmpeg Project 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include "avcodec.h" 23#include "wma.h" 24#include "wmadata.h" 25 26#undef NDEBUG 27#include <assert.h> 28 29/* XXX: use same run/length optimization as mpeg decoders */ 30//FIXME maybe split decode / encode or pass flag 31static void init_coef_vlc(VLC *vlc, uint16_t **prun_table, 32 float **plevel_table, uint16_t **pint_table, 33 const CoefVLCTable *vlc_table) 34{ 35 int n = vlc_table->n; 36 const uint8_t *table_bits = vlc_table->huffbits; 37 const uint32_t *table_codes = vlc_table->huffcodes; 38 const uint16_t *levels_table = vlc_table->levels; 39 uint16_t *run_table, *level_table, *int_table; 40 float *flevel_table; 41 int i, l, j, k, level; 42 43 init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); 44 45 run_table = av_malloc(n * sizeof(uint16_t)); 46 level_table = av_malloc(n * sizeof(uint16_t)); 47 flevel_table= av_malloc(n * sizeof(*flevel_table)); 48 int_table = av_malloc(n * sizeof(uint16_t)); 49 i = 2; 50 level = 1; 51 k = 0; 52 while (i < n) { 53 int_table[k] = i; 54 l = levels_table[k++]; 55 for (j = 0; j < l; j++) { 56 run_table[i] = j; 57 level_table[i] = level; 58 flevel_table[i]= level; 59 i++; 60 } 61 level++; 62 } 63 *prun_table = run_table; 64 *plevel_table = flevel_table; 65 *pint_table = int_table; 66 av_free(level_table); 67} 68 69/** 70 *@brief Get the samples per frame for this stream. 71 *@param sample_rate output sample_rate 72 *@param version wma version 73 *@param decode_flags codec compression features 74 *@return log2 of the number of output samples per frame 75 */ 76int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, 77 unsigned int decode_flags) 78{ 79 80 int frame_len_bits; 81 82 if (sample_rate <= 16000) { 83 frame_len_bits = 9; 84 } else if (sample_rate <= 22050 || 85 (sample_rate <= 32000 && version == 1)) { 86 frame_len_bits = 10; 87 } else if (sample_rate <= 48000) { 88 frame_len_bits = 11; 89 } else if (sample_rate <= 96000) { 90 frame_len_bits = 12; 91 } else { 92 frame_len_bits = 13; 93 } 94 95 if (version == 3) { 96 int tmp = decode_flags & 0x6; 97 if (tmp == 0x2) { 98 ++frame_len_bits; 99 } else if (tmp == 0x4) { 100 --frame_len_bits; 101 } else if (tmp == 0x6) { 102 frame_len_bits -= 2; 103 } 104 } 105 106 return frame_len_bits; 107} 108 109int ff_wma_init(AVCodecContext *avctx, int flags2) 110{ 111 WMACodecContext *s = avctx->priv_data; 112 int i; 113 float bps1, high_freq; 114 volatile float bps; 115 int sample_rate1; 116 int coef_vlc_table; 117 118 if ( avctx->sample_rate <= 0 || avctx->sample_rate > 50000 119 || avctx->channels <= 0 || avctx->channels > 8 120 || avctx->bit_rate <= 0) 121 return -1; 122 123 s->sample_rate = avctx->sample_rate; 124 s->nb_channels = avctx->channels; 125 s->bit_rate = avctx->bit_rate; 126 s->block_align = avctx->block_align; 127 128 dsputil_init(&s->dsp, avctx); 129 130 if (avctx->codec->id == CODEC_ID_WMAV1) { 131 s->version = 1; 132 } else { 133 s->version = 2; 134 } 135 136 /* compute MDCT block size */ 137 s->frame_len_bits = ff_wma_get_frame_len_bits(s->sample_rate, s->version, 0); 138 139 s->frame_len = 1 << s->frame_len_bits; 140 if (s->use_variable_block_len) { 141 int nb_max, nb; 142 nb = ((flags2 >> 3) & 3) + 1; 143 if ((s->bit_rate / s->nb_channels) >= 32000) 144 nb += 2; 145 nb_max = s->frame_len_bits - BLOCK_MIN_BITS; 146 if (nb > nb_max) 147 nb = nb_max; 148 s->nb_block_sizes = nb + 1; 149 } else { 150 s->nb_block_sizes = 1; 151 } 152 153 /* init rate dependent parameters */ 154 s->use_noise_coding = 1; 155 high_freq = s->sample_rate * 0.5; 156 157 /* if version 2, then the rates are normalized */ 158 sample_rate1 = s->sample_rate; 159 if (s->version == 2) { 160 if (sample_rate1 >= 44100) { 161 sample_rate1 = 44100; 162 } else if (sample_rate1 >= 22050) { 163 sample_rate1 = 22050; 164 } else if (sample_rate1 >= 16000) { 165 sample_rate1 = 16000; 166 } else if (sample_rate1 >= 11025) { 167 sample_rate1 = 11025; 168 } else if (sample_rate1 >= 8000) { 169 sample_rate1 = 8000; 170 } 171 } 172 173 bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); 174 s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; 175 176 /* compute high frequency value and choose if noise coding should 177 be activated */ 178 bps1 = bps; 179 if (s->nb_channels == 2) 180 bps1 = bps * 1.6; 181 if (sample_rate1 == 44100) { 182 if (bps1 >= 0.61) { 183 s->use_noise_coding = 0; 184 } else { 185 high_freq = high_freq * 0.4; 186 } 187 } else if (sample_rate1 == 22050) { 188 if (bps1 >= 1.16) { 189 s->use_noise_coding = 0; 190 } else if (bps1 >= 0.72) { 191 high_freq = high_freq * 0.7; 192 } else { 193 high_freq = high_freq * 0.6; 194 } 195 } else if (sample_rate1 == 16000) { 196 if (bps > 0.5) { 197 high_freq = high_freq * 0.5; 198 } else { 199 high_freq = high_freq * 0.3; 200 } 201 } else if (sample_rate1 == 11025) { 202 high_freq = high_freq * 0.7; 203 } else if (sample_rate1 == 8000) { 204 if (bps <= 0.625) { 205 high_freq = high_freq * 0.5; 206 } else if (bps > 0.75) { 207 s->use_noise_coding = 0; 208 } else { 209 high_freq = high_freq * 0.65; 210 } 211 } else { 212 if (bps >= 0.8) { 213 high_freq = high_freq * 0.75; 214 } else if (bps >= 0.6) { 215 high_freq = high_freq * 0.6; 216 } else { 217 high_freq = high_freq * 0.5; 218 } 219 } 220 dprintf(s->avctx, "flags2=0x%x\n", flags2); 221 dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", 222 s->version, s->nb_channels, s->sample_rate, s->bit_rate, 223 s->block_align); 224 dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n", 225 bps, bps1, high_freq, s->byte_offset_bits); 226 dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", 227 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); 228 229 /* compute the scale factor band sizes for each MDCT block size */ 230 { 231 int a, b, pos, lpos, k, block_len, i, j, n; 232 const uint8_t *table; 233 234 if (s->version == 1) { 235 s->coefs_start = 3; 236 } else { 237 s->coefs_start = 0; 238 } 239 for (k = 0; k < s->nb_block_sizes; k++) { 240 block_len = s->frame_len >> k; 241 242 if (s->version == 1) { 243 lpos = 0; 244 for (i = 0; i < 25; i++) { 245 a = ff_wma_critical_freqs[i]; 246 b = s->sample_rate; 247 pos = ((block_len * 2 * a) + (b >> 1)) / b; 248 if (pos > block_len) 249 pos = block_len; 250 s->exponent_bands[0][i] = pos - lpos; 251 if (pos >= block_len) { 252 i++; 253 break; 254 } 255 lpos = pos; 256 } 257 s->exponent_sizes[0] = i; 258 } else { 259 /* hardcoded tables */ 260 table = NULL; 261 a = s->frame_len_bits - BLOCK_MIN_BITS - k; 262 if (a < 3) { 263 if (s->sample_rate >= 44100) { 264 table = exponent_band_44100[a]; 265 } else if (s->sample_rate >= 32000) { 266 table = exponent_band_32000[a]; 267 } else if (s->sample_rate >= 22050) { 268 table = exponent_band_22050[a]; 269 } 270 } 271 if (table) { 272 n = *table++; 273 for (i = 0; i < n; i++) 274 s->exponent_bands[k][i] = table[i]; 275 s->exponent_sizes[k] = n; 276 } else { 277 j = 0; 278 lpos = 0; 279 for (i = 0; i < 25; i++) { 280 a = ff_wma_critical_freqs[i]; 281 b = s->sample_rate; 282 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 283 pos <<= 2; 284 if (pos > block_len) 285 pos = block_len; 286 if (pos > lpos) 287 s->exponent_bands[k][j++] = pos - lpos; 288 if (pos >= block_len) 289 break; 290 lpos = pos; 291 } 292 s->exponent_sizes[k] = j; 293 } 294 } 295 296 /* max number of coefs */ 297 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; 298 /* high freq computation */ 299 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / 300 s->sample_rate + 0.5); 301 n = s->exponent_sizes[k]; 302 j = 0; 303 pos = 0; 304 for (i = 0; i < n; i++) { 305 int start, end; 306 start = pos; 307 pos += s->exponent_bands[k][i]; 308 end = pos; 309 if (start < s->high_band_start[k]) 310 start = s->high_band_start[k]; 311 if (end > s->coefs_end[k]) 312 end = s->coefs_end[k]; 313 if (end > start) 314 s->exponent_high_bands[k][j++] = end - start; 315 } 316 s->exponent_high_sizes[k] = j; 317#if 0 318 tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", 319 s->frame_len >> k, 320 s->coefs_end[k], 321 s->high_band_start[k], 322 s->exponent_high_sizes[k]); 323 for (j = 0; j < s->exponent_high_sizes[k]; j++) 324 tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); 325 tprintf(s->avctx, "\n"); 326#endif 327 } 328 } 329 330#ifdef TRACE 331 { 332 int i, j; 333 for (i = 0; i < s->nb_block_sizes; i++) { 334 tprintf(s->avctx, "%5d: n=%2d:", 335 s->frame_len >> i, 336 s->exponent_sizes[i]); 337 for (j = 0; j < s->exponent_sizes[i]; j++) 338 tprintf(s->avctx, " %d", s->exponent_bands[i][j]); 339 tprintf(s->avctx, "\n"); 340 } 341 } 342#endif 343 344 /* init MDCT windows : simple sinus window */ 345 for (i = 0; i < s->nb_block_sizes; i++) { 346 ff_init_ff_sine_windows(s->frame_len_bits - i); 347 s->windows[i] = ff_sine_windows[s->frame_len_bits - i]; 348 } 349 350 s->reset_block_lengths = 1; 351 352 if (s->use_noise_coding) { 353 354 /* init the noise generator */ 355 if (s->use_exp_vlc) { 356 s->noise_mult = 0.02; 357 } else { 358 s->noise_mult = 0.04; 359 } 360 361#ifdef TRACE 362 for (i = 0; i < NOISE_TAB_SIZE; i++) 363 s->noise_table[i] = 1.0 * s->noise_mult; 364#else 365 { 366 unsigned int seed; 367 float norm; 368 seed = 1; 369 norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; 370 for (i = 0; i < NOISE_TAB_SIZE; i++) { 371 seed = seed * 314159 + 1; 372 s->noise_table[i] = (float)((int)seed) * norm; 373 } 374 } 375#endif 376 } 377 378 /* choose the VLC tables for the coefficients */ 379 coef_vlc_table = 2; 380 if (s->sample_rate >= 32000) { 381 if (bps1 < 0.72) { 382 coef_vlc_table = 0; 383 } else if (bps1 < 1.16) { 384 coef_vlc_table = 1; 385 } 386 } 387 s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; 388 s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; 389 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], 390 s->coef_vlcs[0]); 391 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], 392 s->coef_vlcs[1]); 393 394 return 0; 395} 396 397int ff_wma_total_gain_to_bits(int total_gain) 398{ 399 if (total_gain < 15) return 13; 400 else if (total_gain < 32) return 12; 401 else if (total_gain < 40) return 11; 402 else if (total_gain < 45) return 10; 403 else return 9; 404} 405 406int ff_wma_end(AVCodecContext *avctx) 407{ 408 WMACodecContext *s = avctx->priv_data; 409 int i; 410 411 for (i = 0; i < s->nb_block_sizes; i++) 412 ff_mdct_end(&s->mdct_ctx[i]); 413 414 if (s->use_exp_vlc) { 415 free_vlc(&s->exp_vlc); 416 } 417 if (s->use_noise_coding) { 418 free_vlc(&s->hgain_vlc); 419 } 420 for (i = 0; i < 2; i++) { 421 free_vlc(&s->coef_vlc[i]); 422 av_free(s->run_table[i]); 423 av_free(s->level_table[i]); 424 av_free(s->int_table[i]); 425 } 426 427 return 0; 428} 429 430/** 431 * Decode an uncompressed coefficient. 432 * @param s codec context 433 * @return the decoded coefficient 434 */ 435unsigned int ff_wma_get_large_val(GetBitContext* gb) 436{ 437 /** consumes up to 34 bits */ 438 int n_bits = 8; 439 /** decode length */ 440 if (get_bits1(gb)) { 441 n_bits += 8; 442 if (get_bits1(gb)) { 443 n_bits += 8; 444 if (get_bits1(gb)) { 445 n_bits += 7; 446 } 447 } 448 } 449 return get_bits_long(gb, n_bits); 450} 451 452/** 453 * Decode run level compressed coefficients. 454 * @param avctx codec context 455 * @param gb bitstream reader context 456 * @param vlc vlc table for get_vlc2 457 * @param level_table level codes 458 * @param run_table run codes 459 * @param version 0 for wma1,2 1 for wmapro 460 * @param ptr output buffer 461 * @param offset offset in the output buffer 462 * @param num_coefs number of input coefficents 463 * @param block_len input buffer length (2^n) 464 * @param frame_len_bits number of bits for escaped run codes 465 * @param coef_nb_bits number of bits for escaped level codes 466 * @return 0 on success, -1 otherwise 467 */ 468int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, 469 VLC *vlc, 470 const float *level_table, const uint16_t *run_table, 471 int version, WMACoef *ptr, int offset, 472 int num_coefs, int block_len, int frame_len_bits, 473 int coef_nb_bits) 474{ 475 int code, level, sign; 476 const uint32_t *ilvl = (const uint32_t*)level_table; 477 uint32_t *iptr = (uint32_t*)ptr; 478 const unsigned int coef_mask = block_len - 1; 479 for (; offset < num_coefs; offset++) { 480 code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX); 481 if (code > 1) { 482 /** normal code */ 483 offset += run_table[code]; 484 sign = get_bits1(gb) - 1; 485 iptr[offset & coef_mask] = ilvl[code] ^ sign<<31; 486 } else if (code == 1) { 487 /** EOB */ 488 break; 489 } else { 490 /** escape */ 491 if (!version) { 492 level = get_bits(gb, coef_nb_bits); 493 /** NOTE: this is rather suboptimal. reading 494 block_len_bits would be better */ 495 offset += get_bits(gb, frame_len_bits); 496 } else { 497 level = ff_wma_get_large_val(gb); 498 /** escape decode */ 499 if (get_bits1(gb)) { 500 if (get_bits1(gb)) { 501 if (get_bits1(gb)) { 502 av_log(avctx,AV_LOG_ERROR, 503 "broken escape sequence\n"); 504 return -1; 505 } else 506 offset += get_bits(gb, frame_len_bits) + 4; 507 } else 508 offset += get_bits(gb, 2) + 1; 509 } 510 } 511 sign = get_bits1(gb) - 1; 512 ptr[offset & coef_mask] = (level^sign) - sign; 513 } 514 } 515 /** NOTE: EOB can be omitted */ 516 if (offset > num_coefs) { 517 av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n"); 518 return -1; 519 } 520 521 return 0; 522} 523 524