1/* 2 * Wmapro compatible decoder 3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion 4 * Copyright (c) 2008 - 2009 Sascha Sommer, Benjamin Larsson 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23/** 24 * @file 25 * @brief wmapro decoder implementation 26 * Wmapro is an MDCT based codec comparable to wma standard or AAC. 27 * The decoding therefore consists of the following steps: 28 * - bitstream decoding 29 * - reconstruction of per-channel data 30 * - rescaling and inverse quantization 31 * - IMDCT 32 * - windowing and overlapp-add 33 * 34 * The compressed wmapro bitstream is split into individual packets. 35 * Every such packet contains one or more wma frames. 36 * The compressed frames may have a variable length and frames may 37 * cross packet boundaries. 38 * Common to all wmapro frames is the number of samples that are stored in 39 * a frame. 40 * The number of samples and a few other decode flags are stored 41 * as extradata that has to be passed to the decoder. 42 * 43 * The wmapro frames themselves are again split into a variable number of 44 * subframes. Every subframe contains the data for 2^N time domain samples 45 * where N varies between 7 and 12. 46 * 47 * Example wmapro bitstream (in samples): 48 * 49 * || packet 0 || packet 1 || packet 2 packets 50 * --------------------------------------------------- 51 * || frame 0 || frame 1 || frame 2 || frames 52 * --------------------------------------------------- 53 * || | | || | | | || || subframes of channel 0 54 * --------------------------------------------------- 55 * || | | || | | | || || subframes of channel 1 56 * --------------------------------------------------- 57 * 58 * The frame layouts for the individual channels of a wma frame does not need 59 * to be the same. 60 * 61 * However, if the offsets and lengths of several subframes of a frame are the 62 * same, the subframes of the channels can be grouped. 63 * Every group may then use special coding techniques like M/S stereo coding 64 * to improve the compression ratio. These channel transformations do not 65 * need to be applied to a whole subframe. Instead, they can also work on 66 * individual scale factor bands (see below). 67 * The coefficients that carry the audio signal in the frequency domain 68 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements. 69 * In addition to that, the encoder can switch to a runlevel coding scheme 70 * by transmitting subframe_length / 128 zero coefficients. 71 * 72 * Before the audio signal can be converted to the time domain, the 73 * coefficients have to be rescaled and inverse quantized. 74 * A subframe is therefore split into several scale factor bands that get 75 * scaled individually. 76 * Scale factors are submitted for every frame but they might be shared 77 * between the subframes of a channel. Scale factors are initially DPCM-coded. 78 * Once scale factors are shared, the differences are transmitted as runlevel 79 * codes. 80 * Every subframe length and offset combination in the frame layout shares a 81 * common quantization factor that can be adjusted for every channel by a 82 * modifier. 83 * After the inverse quantization, the coefficients get processed by an IMDCT. 84 * The resulting values are then windowed with a sine window and the first half 85 * of the values are added to the second half of the output from the previous 86 * subframe in order to reconstruct the output samples. 87 */ 88 89#include "avcodec.h" 90#include "internal.h" 91#include "get_bits.h" 92#include "put_bits.h" 93#include "wmaprodata.h" 94#include "dsputil.h" 95#include "wma.h" 96 97/** current decoder limitations */ 98#define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels 99#define MAX_SUBFRAMES 32 ///< max number of subframes per channel 100#define MAX_BANDS 29 ///< max number of scale factor bands 101#define MAX_FRAMESIZE 32768 ///< maximum compressed frame size 102 103#define WMAPRO_BLOCK_MAX_BITS 12 ///< log2 of max block size 104#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size 105#define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1) ///< possible block sizes 106 107 108#define VLCBITS 9 109#define SCALEVLCBITS 8 110#define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS) 111#define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS) 112#define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS) 113#define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS) 114#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS) 115 116static VLC sf_vlc; ///< scale factor DPCM vlc 117static VLC sf_rl_vlc; ///< scale factor run length vlc 118static VLC vec4_vlc; ///< 4 coefficients per symbol 119static VLC vec2_vlc; ///< 2 coefficients per symbol 120static VLC vec1_vlc; ///< 1 coefficient per symbol 121static VLC coef_vlc[2]; ///< coefficient run length vlc codes 122static float sin64[33]; ///< sinus table for decorrelation 123 124/** 125 * @brief frame specific decoder context for a single channel 126 */ 127typedef struct { 128 int16_t prev_block_len; ///< length of the previous block 129 uint8_t transmit_coefs; 130 uint8_t num_subframes; 131 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples 132 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame 133 uint8_t cur_subframe; ///< current subframe number 134 uint16_t decoded_samples; ///< number of already processed samples 135 uint8_t grouped; ///< channel is part of a group 136 int quant_step; ///< quantization step for the current subframe 137 int8_t reuse_sf; ///< share scale factors between subframes 138 int8_t scale_factor_step; ///< scaling step for the current subframe 139 int max_scale_factor; ///< maximum scale factor for the current subframe 140 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values 141 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling) 142 int* scale_factors; ///< pointer to the scale factor values used for decoding 143 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block 144 float* coeffs; ///< pointer to the subframe decode buffer 145 DECLARE_ALIGNED(16, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer 146} WMAProChannelCtx; 147 148/** 149 * @brief channel group for channel transformations 150 */ 151typedef struct { 152 uint8_t num_channels; ///< number of channels in the group 153 int8_t transform; ///< transform on / off 154 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band 155 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS]; 156 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients 157} WMAProChannelGrp; 158 159/** 160 * @brief main decoder context 161 */ 162typedef struct WMAProDecodeCtx { 163 /* generic decoder variables */ 164 AVCodecContext* avctx; ///< codec context for av_log 165 DSPContext dsp; ///< accelerated DSP functions 166 uint8_t frame_data[MAX_FRAMESIZE + 167 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data 168 PutBitContext pb; ///< context for filling the frame_data buffer 169 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size 170 DECLARE_ALIGNED(16, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer 171 float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes 172 173 /* frame size dependent frame information (set during initialization) */ 174 uint32_t decode_flags; ///< used compression features 175 uint8_t len_prefix; ///< frame is prefixed with its length 176 uint8_t dynamic_range_compression; ///< frame contains DRC data 177 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0]) 178 uint16_t samples_per_frame; ///< number of samples to output 179 uint16_t log2_frame_size; 180 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels) 181 int8_t lfe_channel; ///< lfe channel index 182 uint8_t max_num_subframes; 183 uint8_t subframe_len_bits; ///< number of bits used for the subframe length 184 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1 185 uint16_t min_samples_per_subframe; 186 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size 187 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4) 188 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix 189 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values 190 191 /* packet decode state */ 192 GetBitContext pgb; ///< bitstream reader context for the packet 193 uint8_t packet_offset; ///< frame offset in the packet 194 uint8_t packet_sequence_number; ///< current packet number 195 int num_saved_bits; ///< saved number of bits 196 int frame_offset; ///< frame offset in the bit reservoir 197 int subframe_offset; ///< subframe offset in the bit reservoir 198 uint8_t packet_loss; ///< set in case of bitstream error 199 uint8_t packet_done; ///< set when a packet is fully decoded 200 201 /* frame decode state */ 202 uint32_t frame_num; ///< current frame number (not used for decoding) 203 GetBitContext gb; ///< bitstream reader context 204 int buf_bit_size; ///< buffer size in bits 205 float* samples; ///< current samplebuffer pointer 206 float* samples_end; ///< maximum samplebuffer pointer 207 uint8_t drc_gain; ///< gain for the DRC tool 208 int8_t skip_frame; ///< skip output step 209 int8_t parsed_all_subframes; ///< all subframes decoded? 210 211 /* subframe/block decode state */ 212 int16_t subframe_len; ///< current subframe length 213 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe 214 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]; 215 int8_t num_bands; ///< number of scale factor bands 216 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block 217 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables 218 int8_t esc_len; ///< length of escaped coefficients 219 220 uint8_t num_chgroups; ///< number of channel groups 221 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information 222 223 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data 224} WMAProDecodeCtx; 225 226 227/** 228 *@brief helper function to print the most important members of the context 229 *@param s context 230 */ 231static void av_cold dump_context(WMAProDecodeCtx *s) 232{ 233#define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b); 234#define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b); 235 236 PRINT("ed sample bit depth", s->bits_per_sample); 237 PRINT_HEX("ed decode flags", s->decode_flags); 238 PRINT("samples per frame", s->samples_per_frame); 239 PRINT("log2 frame size", s->log2_frame_size); 240 PRINT("max num subframes", s->max_num_subframes); 241 PRINT("len prefix", s->len_prefix); 242 PRINT("num channels", s->num_channels); 243} 244 245/** 246 *@brief Uninitialize the decoder and free all resources. 247 *@param avctx codec context 248 *@return 0 on success, < 0 otherwise 249 */ 250static av_cold int decode_end(AVCodecContext *avctx) 251{ 252 WMAProDecodeCtx *s = avctx->priv_data; 253 int i; 254 255 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) 256 ff_mdct_end(&s->mdct_ctx[i]); 257 258 return 0; 259} 260 261/** 262 *@brief Initialize the decoder. 263 *@param avctx codec context 264 *@return 0 on success, -1 otherwise 265 */ 266static av_cold int decode_init(AVCodecContext *avctx) 267{ 268 WMAProDecodeCtx *s = avctx->priv_data; 269 uint8_t *edata_ptr = avctx->extradata; 270 unsigned int channel_mask; 271 int i; 272 int log2_max_num_subframes; 273 int num_possible_block_sizes; 274 275 s->avctx = avctx; 276 dsputil_init(&s->dsp, avctx); 277 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); 278 279 avctx->sample_fmt = SAMPLE_FMT_FLT; 280 281 if (avctx->extradata_size >= 18) { 282 s->decode_flags = AV_RL16(edata_ptr+14); 283 channel_mask = AV_RL32(edata_ptr+2); 284 s->bits_per_sample = AV_RL16(edata_ptr); 285 /** dump the extradata */ 286 for (i = 0; i < avctx->extradata_size; i++) 287 dprintf(avctx, "[%x] ", avctx->extradata[i]); 288 dprintf(avctx, "\n"); 289 290 } else { 291 av_log_ask_for_sample(avctx, "Unknown extradata size\n"); 292 return AVERROR_INVALIDDATA; 293 } 294 295 /** generic init */ 296 s->log2_frame_size = av_log2(avctx->block_align) + 4; 297 298 /** frame info */ 299 s->skip_frame = 1; /** skip first frame */ 300 s->packet_loss = 1; 301 s->len_prefix = (s->decode_flags & 0x40); 302 303 if (!s->len_prefix) { 304 av_log_ask_for_sample(avctx, "no length prefix\n"); 305 return AVERROR_INVALIDDATA; 306 } 307 308 /** get frame len */ 309 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate, 310 3, s->decode_flags); 311 312 /** init previous block len */ 313 for (i = 0; i < avctx->channels; i++) 314 s->channel[i].prev_block_len = s->samples_per_frame; 315 316 /** subframe info */ 317 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3); 318 s->max_num_subframes = 1 << log2_max_num_subframes; 319 if (s->max_num_subframes == 16) 320 s->max_subframe_len_bit = 1; 321 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1; 322 323 num_possible_block_sizes = log2_max_num_subframes + 1; 324 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes; 325 s->dynamic_range_compression = (s->decode_flags & 0x80); 326 327 if (s->max_num_subframes > MAX_SUBFRAMES) { 328 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n", 329 s->max_num_subframes); 330 return AVERROR_INVALIDDATA; 331 } 332 333 s->num_channels = avctx->channels; 334 335 /** extract lfe channel position */ 336 s->lfe_channel = -1; 337 338 if (channel_mask & 8) { 339 unsigned int mask; 340 for (mask = 1; mask < 16; mask <<= 1) { 341 if (channel_mask & mask) 342 ++s->lfe_channel; 343 } 344 } 345 346 if (s->num_channels < 0) { 347 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels); 348 return AVERROR_INVALIDDATA; 349 } else if (s->num_channels > WMAPRO_MAX_CHANNELS) { 350 av_log_ask_for_sample(avctx, "unsupported number of channels\n"); 351 return AVERROR_PATCHWELCOME; 352 } 353 354 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE, 355 scale_huffbits, 1, 1, 356 scale_huffcodes, 2, 2, 616); 357 358 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE, 359 scale_rl_huffbits, 1, 1, 360 scale_rl_huffcodes, 4, 4, 1406); 361 362 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE, 363 coef0_huffbits, 1, 1, 364 coef0_huffcodes, 4, 4, 2108); 365 366 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE, 367 coef1_huffbits, 1, 1, 368 coef1_huffcodes, 4, 4, 3912); 369 370 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE, 371 vec4_huffbits, 1, 1, 372 vec4_huffcodes, 2, 2, 604); 373 374 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE, 375 vec2_huffbits, 1, 1, 376 vec2_huffcodes, 2, 2, 562); 377 378 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE, 379 vec1_huffbits, 1, 1, 380 vec1_huffcodes, 2, 2, 562); 381 382 /** calculate number of scale factor bands and their offsets 383 for every possible block size */ 384 for (i = 0; i < num_possible_block_sizes; i++) { 385 int subframe_len = s->samples_per_frame >> i; 386 int x; 387 int band = 1; 388 389 s->sfb_offsets[i][0] = 0; 390 391 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) { 392 int offset = (subframe_len * 2 * critical_freq[x]) 393 / s->avctx->sample_rate + 2; 394 offset &= ~3; 395 if (offset > s->sfb_offsets[i][band - 1]) 396 s->sfb_offsets[i][band++] = offset; 397 } 398 s->sfb_offsets[i][band - 1] = subframe_len; 399 s->num_sfb[i] = band - 1; 400 } 401 402 403 /** Scale factors can be shared between blocks of different size 404 as every block has a different scale factor band layout. 405 The matrix sf_offsets is needed to find the correct scale factor. 406 */ 407 408 for (i = 0; i < num_possible_block_sizes; i++) { 409 int b; 410 for (b = 0; b < s->num_sfb[i]; b++) { 411 int x; 412 int offset = ((s->sfb_offsets[i][b] 413 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1; 414 for (x = 0; x < num_possible_block_sizes; x++) { 415 int v = 0; 416 while (s->sfb_offsets[x][v + 1] << x < offset) 417 ++v; 418 s->sf_offsets[i][x][b] = v; 419 } 420 } 421 } 422 423 /** init MDCT, FIXME: only init needed sizes */ 424 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) 425 ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1, 426 1.0 / (1 << (BLOCK_MIN_BITS + i - 1)) 427 / (1 << (s->bits_per_sample - 1))); 428 429 /** init MDCT windows: simple sinus window */ 430 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) { 431 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i; 432 ff_init_ff_sine_windows(win_idx); 433 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx]; 434 } 435 436 /** calculate subwoofer cutoff values */ 437 for (i = 0; i < num_possible_block_sizes; i++) { 438 int block_size = s->samples_per_frame >> i; 439 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1) 440 / s->avctx->sample_rate; 441 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size); 442 } 443 444 /** calculate sine values for the decorrelation matrix */ 445 for (i = 0; i < 33; i++) 446 sin64[i] = sin(i*M_PI / 64.0); 447 448 if (avctx->debug & FF_DEBUG_BITSTREAM) 449 dump_context(s); 450 451 avctx->channel_layout = channel_mask; 452 return 0; 453} 454 455/** 456 *@brief Decode the subframe length. 457 *@param s context 458 *@param offset sample offset in the frame 459 *@return decoded subframe length on success, < 0 in case of an error 460 */ 461static int decode_subframe_length(WMAProDecodeCtx *s, int offset) 462{ 463 int frame_len_shift = 0; 464 int subframe_len; 465 466 /** no need to read from the bitstream when only one length is possible */ 467 if (offset == s->samples_per_frame - s->min_samples_per_subframe) 468 return s->min_samples_per_subframe; 469 470 /** 1 bit indicates if the subframe is of maximum length */ 471 if (s->max_subframe_len_bit) { 472 if (get_bits1(&s->gb)) 473 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1); 474 } else 475 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits); 476 477 subframe_len = s->samples_per_frame >> frame_len_shift; 478 479 /** sanity check the length */ 480 if (subframe_len < s->min_samples_per_subframe || 481 subframe_len > s->samples_per_frame) { 482 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n", 483 subframe_len); 484 return AVERROR_INVALIDDATA; 485 } 486 return subframe_len; 487} 488 489/** 490 *@brief Decode how the data in the frame is split into subframes. 491 * Every WMA frame contains the encoded data for a fixed number of 492 * samples per channel. The data for every channel might be split 493 * into several subframes. This function will reconstruct the list of 494 * subframes for every channel. 495 * 496 * If the subframes are not evenly split, the algorithm estimates the 497 * channels with the lowest number of total samples. 498 * Afterwards, for each of these channels a bit is read from the 499 * bitstream that indicates if the channel contains a subframe with the 500 * next subframe size that is going to be read from the bitstream or not. 501 * If a channel contains such a subframe, the subframe size gets added to 502 * the channel's subframe list. 503 * The algorithm repeats these steps until the frame is properly divided 504 * between the individual channels. 505 * 506 *@param s context 507 *@return 0 on success, < 0 in case of an error 508 */ 509static int decode_tilehdr(WMAProDecodeCtx *s) 510{ 511 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /** sum of samples for all currently known subframes of a channel */ 512 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /** flag indicating if a channel contains the current subframe */ 513 int channels_for_cur_subframe = s->num_channels; /** number of channels that contain the current subframe */ 514 int fixed_channel_layout = 0; /** flag indicating that all channels use the same subframe offsets and sizes */ 515 int min_channel_len = 0; /** smallest sum of samples (channels with this length will be processed first) */ 516 int c; 517 518 /* Should never consume more than 3073 bits (256 iterations for the 519 * while loop when always the minimum amount of 128 samples is substracted 520 * from missing samples in the 8 channel case). 521 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4) 522 */ 523 524 /** reset tiling information */ 525 for (c = 0; c < s->num_channels; c++) 526 s->channel[c].num_subframes = 0; 527 528 memset(num_samples, 0, sizeof(num_samples)); 529 530 if (s->max_num_subframes == 1 || get_bits1(&s->gb)) 531 fixed_channel_layout = 1; 532 533 /** loop until the frame data is split between the subframes */ 534 do { 535 int subframe_len; 536 537 /** check which channels contain the subframe */ 538 for (c = 0; c < s->num_channels; c++) { 539 if (num_samples[c] == min_channel_len) { 540 if (fixed_channel_layout || channels_for_cur_subframe == 1 || 541 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) 542 contains_subframe[c] = 1; 543 else 544 contains_subframe[c] = get_bits1(&s->gb); 545 } else 546 contains_subframe[c] = 0; 547 } 548 549 /** get subframe length, subframe_len == 0 is not allowed */ 550 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0) 551 return AVERROR_INVALIDDATA; 552 553 /** add subframes to the individual channels and find new min_channel_len */ 554 min_channel_len += subframe_len; 555 for (c = 0; c < s->num_channels; c++) { 556 WMAProChannelCtx* chan = &s->channel[c]; 557 558 if (contains_subframe[c]) { 559 if (chan->num_subframes >= MAX_SUBFRAMES) { 560 av_log(s->avctx, AV_LOG_ERROR, 561 "broken frame: num subframes > 31\n"); 562 return AVERROR_INVALIDDATA; 563 } 564 chan->subframe_len[chan->num_subframes] = subframe_len; 565 num_samples[c] += subframe_len; 566 ++chan->num_subframes; 567 if (num_samples[c] > s->samples_per_frame) { 568 av_log(s->avctx, AV_LOG_ERROR, "broken frame: " 569 "channel len > samples_per_frame\n"); 570 return AVERROR_INVALIDDATA; 571 } 572 } else if (num_samples[c] <= min_channel_len) { 573 if (num_samples[c] < min_channel_len) { 574 channels_for_cur_subframe = 0; 575 min_channel_len = num_samples[c]; 576 } 577 ++channels_for_cur_subframe; 578 } 579 } 580 } while (min_channel_len < s->samples_per_frame); 581 582 for (c = 0; c < s->num_channels; c++) { 583 int i; 584 int offset = 0; 585 for (i = 0; i < s->channel[c].num_subframes; i++) { 586 dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]" 587 " len %i\n", s->frame_num, c, i, 588 s->channel[c].subframe_len[i]); 589 s->channel[c].subframe_offset[i] = offset; 590 offset += s->channel[c].subframe_len[i]; 591 } 592 } 593 594 return 0; 595} 596 597/** 598 *@brief Calculate a decorrelation matrix from the bitstream parameters. 599 *@param s codec context 600 *@param chgroup channel group for which the matrix needs to be calculated 601 */ 602static void decode_decorrelation_matrix(WMAProDecodeCtx *s, 603 WMAProChannelGrp *chgroup) 604{ 605 int i; 606 int offset = 0; 607 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS]; 608 memset(chgroup->decorrelation_matrix, 0, s->num_channels * 609 s->num_channels * sizeof(*chgroup->decorrelation_matrix)); 610 611 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++) 612 rotation_offset[i] = get_bits(&s->gb, 6); 613 614 for (i = 0; i < chgroup->num_channels; i++) 615 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] = 616 get_bits1(&s->gb) ? 1.0 : -1.0; 617 618 for (i = 1; i < chgroup->num_channels; i++) { 619 int x; 620 for (x = 0; x < i; x++) { 621 int y; 622 for (y = 0; y < i + 1; y++) { 623 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y]; 624 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y]; 625 int n = rotation_offset[offset + x]; 626 float sinv; 627 float cosv; 628 629 if (n < 32) { 630 sinv = sin64[n]; 631 cosv = sin64[32 - n]; 632 } else { 633 sinv = sin64[64 - n]; 634 cosv = -sin64[n - 32]; 635 } 636 637 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] = 638 (v1 * sinv) - (v2 * cosv); 639 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] = 640 (v1 * cosv) + (v2 * sinv); 641 } 642 } 643 offset += i; 644 } 645} 646 647/** 648 *@brief Decode channel transformation parameters 649 *@param s codec context 650 *@return 0 in case of success, < 0 in case of bitstream errors 651 */ 652static int decode_channel_transform(WMAProDecodeCtx* s) 653{ 654 int i; 655 /* should never consume more than 1921 bits for the 8 channel case 656 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS 657 * + MAX_CHANNELS + MAX_BANDS + 1) 658 */ 659 660 /** in the one channel case channel transforms are pointless */ 661 s->num_chgroups = 0; 662 if (s->num_channels > 1) { 663 int remaining_channels = s->channels_for_cur_subframe; 664 665 if (get_bits1(&s->gb)) { 666 av_log_ask_for_sample(s->avctx, 667 "unsupported channel transform bit\n"); 668 return AVERROR_INVALIDDATA; 669 } 670 671 for (s->num_chgroups = 0; remaining_channels && 672 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) { 673 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups]; 674 float** channel_data = chgroup->channel_data; 675 chgroup->num_channels = 0; 676 chgroup->transform = 0; 677 678 /** decode channel mask */ 679 if (remaining_channels > 2) { 680 for (i = 0; i < s->channels_for_cur_subframe; i++) { 681 int channel_idx = s->channel_indexes_for_cur_subframe[i]; 682 if (!s->channel[channel_idx].grouped 683 && get_bits1(&s->gb)) { 684 ++chgroup->num_channels; 685 s->channel[channel_idx].grouped = 1; 686 *channel_data++ = s->channel[channel_idx].coeffs; 687 } 688 } 689 } else { 690 chgroup->num_channels = remaining_channels; 691 for (i = 0; i < s->channels_for_cur_subframe; i++) { 692 int channel_idx = s->channel_indexes_for_cur_subframe[i]; 693 if (!s->channel[channel_idx].grouped) 694 *channel_data++ = s->channel[channel_idx].coeffs; 695 s->channel[channel_idx].grouped = 1; 696 } 697 } 698 699 /** decode transform type */ 700 if (chgroup->num_channels == 2) { 701 if (get_bits1(&s->gb)) { 702 if (get_bits1(&s->gb)) { 703 av_log_ask_for_sample(s->avctx, 704 "unsupported channel transform type\n"); 705 } 706 } else { 707 chgroup->transform = 1; 708 if (s->num_channels == 2) { 709 chgroup->decorrelation_matrix[0] = 1.0; 710 chgroup->decorrelation_matrix[1] = -1.0; 711 chgroup->decorrelation_matrix[2] = 1.0; 712 chgroup->decorrelation_matrix[3] = 1.0; 713 } else { 714 /** cos(pi/4) */ 715 chgroup->decorrelation_matrix[0] = 0.70703125; 716 chgroup->decorrelation_matrix[1] = -0.70703125; 717 chgroup->decorrelation_matrix[2] = 0.70703125; 718 chgroup->decorrelation_matrix[3] = 0.70703125; 719 } 720 } 721 } else if (chgroup->num_channels > 2) { 722 if (get_bits1(&s->gb)) { 723 chgroup->transform = 1; 724 if (get_bits1(&s->gb)) { 725 decode_decorrelation_matrix(s, chgroup); 726 } else { 727 /** FIXME: more than 6 coupled channels not supported */ 728 if (chgroup->num_channels > 6) { 729 av_log_ask_for_sample(s->avctx, 730 "coupled channels > 6\n"); 731 } else { 732 memcpy(chgroup->decorrelation_matrix, 733 default_decorrelation[chgroup->num_channels], 734 chgroup->num_channels * chgroup->num_channels * 735 sizeof(*chgroup->decorrelation_matrix)); 736 } 737 } 738 } 739 } 740 741 /** decode transform on / off */ 742 if (chgroup->transform) { 743 if (!get_bits1(&s->gb)) { 744 int i; 745 /** transform can be enabled for individual bands */ 746 for (i = 0; i < s->num_bands; i++) { 747 chgroup->transform_band[i] = get_bits1(&s->gb); 748 } 749 } else { 750 memset(chgroup->transform_band, 1, s->num_bands); 751 } 752 } 753 remaining_channels -= chgroup->num_channels; 754 } 755 } 756 return 0; 757} 758 759/** 760 *@brief Extract the coefficients from the bitstream. 761 *@param s codec context 762 *@param c current channel number 763 *@return 0 on success, < 0 in case of bitstream errors 764 */ 765static int decode_coeffs(WMAProDecodeCtx *s, int c) 766{ 767 /* Integers 0..15 as single-precision floats. The table saves a 768 costly int to float conversion, and storing the values as 769 integers allows fast sign-flipping. */ 770 static const int fval_tab[16] = { 771 0x00000000, 0x3f800000, 0x40000000, 0x40400000, 772 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000, 773 0x41000000, 0x41100000, 0x41200000, 0x41300000, 774 0x41400000, 0x41500000, 0x41600000, 0x41700000, 775 }; 776 int vlctable; 777 VLC* vlc; 778 WMAProChannelCtx* ci = &s->channel[c]; 779 int rl_mode = 0; 780 int cur_coeff = 0; 781 int num_zeros = 0; 782 const uint16_t* run; 783 const float* level; 784 785 dprintf(s->avctx, "decode coefficients for channel %i\n", c); 786 787 vlctable = get_bits1(&s->gb); 788 vlc = &coef_vlc[vlctable]; 789 790 if (vlctable) { 791 run = coef1_run; 792 level = coef1_level; 793 } else { 794 run = coef0_run; 795 level = coef0_level; 796 } 797 798 /** decode vector coefficients (consumes up to 167 bits per iteration for 799 4 vector coded large values) */ 800 while (!rl_mode && cur_coeff + 3 < s->subframe_len) { 801 int vals[4]; 802 int i; 803 unsigned int idx; 804 805 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); 806 807 if (idx == HUFF_VEC4_SIZE - 1) { 808 for (i = 0; i < 4; i += 2) { 809 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); 810 if (idx == HUFF_VEC2_SIZE - 1) { 811 int v0, v1; 812 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); 813 if (v0 == HUFF_VEC1_SIZE - 1) 814 v0 += ff_wma_get_large_val(&s->gb); 815 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); 816 if (v1 == HUFF_VEC1_SIZE - 1) 817 v1 += ff_wma_get_large_val(&s->gb); 818 ((float*)vals)[i ] = v0; 819 ((float*)vals)[i+1] = v1; 820 } else { 821 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ]; 822 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF]; 823 } 824 } 825 } else { 826 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ]; 827 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF]; 828 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF]; 829 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF]; 830 } 831 832 /** decode sign */ 833 for (i = 0; i < 4; i++) { 834 if (vals[i]) { 835 int sign = get_bits1(&s->gb) - 1; 836 *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31; 837 num_zeros = 0; 838 } else { 839 ci->coeffs[cur_coeff] = 0; 840 /** switch to run level mode when subframe_len / 128 zeros 841 were found in a row */ 842 rl_mode |= (++num_zeros > s->subframe_len >> 8); 843 } 844 ++cur_coeff; 845 } 846 } 847 848 /** decode run level coded coefficients */ 849 if (rl_mode) { 850 memset(&ci->coeffs[cur_coeff], 0, 851 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff)); 852 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc, 853 level, run, 1, ci->coeffs, 854 cur_coeff, s->subframe_len, 855 s->subframe_len, s->esc_len, 0)) 856 return AVERROR_INVALIDDATA; 857 } 858 859 return 0; 860} 861 862/** 863 *@brief Extract scale factors from the bitstream. 864 *@param s codec context 865 *@return 0 on success, < 0 in case of bitstream errors 866 */ 867static int decode_scale_factors(WMAProDecodeCtx* s) 868{ 869 int i; 870 871 /** should never consume more than 5344 bits 872 * MAX_CHANNELS * (1 + MAX_BANDS * 23) 873 */ 874 875 for (i = 0; i < s->channels_for_cur_subframe; i++) { 876 int c = s->channel_indexes_for_cur_subframe[i]; 877 int* sf; 878 int* sf_end; 879 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx]; 880 sf_end = s->channel[c].scale_factors + s->num_bands; 881 882 /** resample scale factors for the new block size 883 * as the scale factors might need to be resampled several times 884 * before some new values are transmitted, a backup of the last 885 * transmitted scale factors is kept in saved_scale_factors 886 */ 887 if (s->channel[c].reuse_sf) { 888 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx]; 889 int b; 890 for (b = 0; b < s->num_bands; b++) 891 s->channel[c].scale_factors[b] = 892 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++]; 893 } 894 895 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) { 896 897 if (!s->channel[c].reuse_sf) { 898 int val; 899 /** decode DPCM coded scale factors */ 900 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1; 901 val = 45 / s->channel[c].scale_factor_step; 902 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) { 903 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60; 904 *sf = val; 905 } 906 } else { 907 int i; 908 /** run level decode differences to the resampled factors */ 909 for (i = 0; i < s->num_bands; i++) { 910 int idx; 911 int skip; 912 int val; 913 int sign; 914 915 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); 916 917 if (!idx) { 918 uint32_t code = get_bits(&s->gb, 14); 919 val = code >> 6; 920 sign = (code & 1) - 1; 921 skip = (code & 0x3f) >> 1; 922 } else if (idx == 1) { 923 break; 924 } else { 925 skip = scale_rl_run[idx]; 926 val = scale_rl_level[idx]; 927 sign = get_bits1(&s->gb)-1; 928 } 929 930 i += skip; 931 if (i >= s->num_bands) { 932 av_log(s->avctx, AV_LOG_ERROR, 933 "invalid scale factor coding\n"); 934 return AVERROR_INVALIDDATA; 935 } 936 s->channel[c].scale_factors[i] += (val ^ sign) - sign; 937 } 938 } 939 /** swap buffers */ 940 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx; 941 s->channel[c].table_idx = s->table_idx; 942 s->channel[c].reuse_sf = 1; 943 } 944 945 /** calculate new scale factor maximum */ 946 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0]; 947 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) { 948 s->channel[c].max_scale_factor = 949 FFMAX(s->channel[c].max_scale_factor, *sf); 950 } 951 952 } 953 return 0; 954} 955 956/** 957 *@brief Reconstruct the individual channel data. 958 *@param s codec context 959 */ 960static void inverse_channel_transform(WMAProDecodeCtx *s) 961{ 962 int i; 963 964 for (i = 0; i < s->num_chgroups; i++) { 965 if (s->chgroup[i].transform) { 966 float data[WMAPRO_MAX_CHANNELS]; 967 const int num_channels = s->chgroup[i].num_channels; 968 float** ch_data = s->chgroup[i].channel_data; 969 float** ch_end = ch_data + num_channels; 970 const int8_t* tb = s->chgroup[i].transform_band; 971 int16_t* sfb; 972 973 /** multichannel decorrelation */ 974 for (sfb = s->cur_sfb_offsets; 975 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) { 976 int y; 977 if (*tb++ == 1) { 978 /** multiply values with the decorrelation_matrix */ 979 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) { 980 const float* mat = s->chgroup[i].decorrelation_matrix; 981 const float* data_end = data + num_channels; 982 float* data_ptr = data; 983 float** ch; 984 985 for (ch = ch_data; ch < ch_end; ch++) 986 *data_ptr++ = (*ch)[y]; 987 988 for (ch = ch_data; ch < ch_end; ch++) { 989 float sum = 0; 990 data_ptr = data; 991 while (data_ptr < data_end) 992 sum += *data_ptr++ * *mat++; 993 994 (*ch)[y] = sum; 995 } 996 } 997 } else if (s->num_channels == 2) { 998 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0]; 999 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0], 1000 ch_data[0] + sfb[0], 1001 181.0 / 128, len); 1002 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0], 1003 ch_data[1] + sfb[0], 1004 181.0 / 128, len); 1005 } 1006 } 1007 } 1008 } 1009} 1010 1011/** 1012 *@brief Apply sine window and reconstruct the output buffer. 1013 *@param s codec context 1014 */ 1015static void wmapro_window(WMAProDecodeCtx *s) 1016{ 1017 int i; 1018 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1019 int c = s->channel_indexes_for_cur_subframe[i]; 1020 float* window; 1021 int winlen = s->channel[c].prev_block_len; 1022 float* start = s->channel[c].coeffs - (winlen >> 1); 1023 1024 if (s->subframe_len < winlen) { 1025 start += (winlen - s->subframe_len) >> 1; 1026 winlen = s->subframe_len; 1027 } 1028 1029 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS]; 1030 1031 winlen >>= 1; 1032 1033 s->dsp.vector_fmul_window(start, start, start + winlen, 1034 window, 0, winlen); 1035 1036 s->channel[c].prev_block_len = s->subframe_len; 1037 } 1038} 1039 1040/** 1041 *@brief Decode a single subframe (block). 1042 *@param s codec context 1043 *@return 0 on success, < 0 when decoding failed 1044 */ 1045static int decode_subframe(WMAProDecodeCtx *s) 1046{ 1047 int offset = s->samples_per_frame; 1048 int subframe_len = s->samples_per_frame; 1049 int i; 1050 int total_samples = s->samples_per_frame * s->num_channels; 1051 int transmit_coeffs = 0; 1052 int cur_subwoofer_cutoff; 1053 1054 s->subframe_offset = get_bits_count(&s->gb); 1055 1056 /** reset channel context and find the next block offset and size 1057 == the next block of the channel with the smallest number of 1058 decoded samples 1059 */ 1060 for (i = 0; i < s->num_channels; i++) { 1061 s->channel[i].grouped = 0; 1062 if (offset > s->channel[i].decoded_samples) { 1063 offset = s->channel[i].decoded_samples; 1064 subframe_len = 1065 s->channel[i].subframe_len[s->channel[i].cur_subframe]; 1066 } 1067 } 1068 1069 dprintf(s->avctx, 1070 "processing subframe with offset %i len %i\n", offset, subframe_len); 1071 1072 /** get a list of all channels that contain the estimated block */ 1073 s->channels_for_cur_subframe = 0; 1074 for (i = 0; i < s->num_channels; i++) { 1075 const int cur_subframe = s->channel[i].cur_subframe; 1076 /** substract already processed samples */ 1077 total_samples -= s->channel[i].decoded_samples; 1078 1079 /** and count if there are multiple subframes that match our profile */ 1080 if (offset == s->channel[i].decoded_samples && 1081 subframe_len == s->channel[i].subframe_len[cur_subframe]) { 1082 total_samples -= s->channel[i].subframe_len[cur_subframe]; 1083 s->channel[i].decoded_samples += 1084 s->channel[i].subframe_len[cur_subframe]; 1085 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i; 1086 ++s->channels_for_cur_subframe; 1087 } 1088 } 1089 1090 /** check if the frame will be complete after processing the 1091 estimated block */ 1092 if (!total_samples) 1093 s->parsed_all_subframes = 1; 1094 1095 1096 dprintf(s->avctx, "subframe is part of %i channels\n", 1097 s->channels_for_cur_subframe); 1098 1099 /** calculate number of scale factor bands and their offsets */ 1100 s->table_idx = av_log2(s->samples_per_frame/subframe_len); 1101 s->num_bands = s->num_sfb[s->table_idx]; 1102 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx]; 1103 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx]; 1104 1105 /** configure the decoder for the current subframe */ 1106 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1107 int c = s->channel_indexes_for_cur_subframe[i]; 1108 1109 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1) 1110 + offset]; 1111 } 1112 1113 s->subframe_len = subframe_len; 1114 s->esc_len = av_log2(s->subframe_len - 1) + 1; 1115 1116 /** skip extended header if any */ 1117 if (get_bits1(&s->gb)) { 1118 int num_fill_bits; 1119 if (!(num_fill_bits = get_bits(&s->gb, 2))) { 1120 int len = get_bits(&s->gb, 4); 1121 num_fill_bits = get_bits(&s->gb, len) + 1; 1122 } 1123 1124 if (num_fill_bits >= 0) { 1125 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) { 1126 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n"); 1127 return AVERROR_INVALIDDATA; 1128 } 1129 1130 skip_bits_long(&s->gb, num_fill_bits); 1131 } 1132 } 1133 1134 /** no idea for what the following bit is used */ 1135 if (get_bits1(&s->gb)) { 1136 av_log_ask_for_sample(s->avctx, "reserved bit set\n"); 1137 return AVERROR_INVALIDDATA; 1138 } 1139 1140 1141 if (decode_channel_transform(s) < 0) 1142 return AVERROR_INVALIDDATA; 1143 1144 1145 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1146 int c = s->channel_indexes_for_cur_subframe[i]; 1147 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb))) 1148 transmit_coeffs = 1; 1149 } 1150 1151 if (transmit_coeffs) { 1152 int step; 1153 int quant_step = 90 * s->bits_per_sample >> 4; 1154 if ((get_bits1(&s->gb))) { 1155 /** FIXME: might change run level mode decision */ 1156 av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n"); 1157 return AVERROR_INVALIDDATA; 1158 } 1159 /** decode quantization step */ 1160 step = get_sbits(&s->gb, 6); 1161 quant_step += step; 1162 if (step == -32 || step == 31) { 1163 const int sign = (step == 31) - 1; 1164 int quant = 0; 1165 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits && 1166 (step = get_bits(&s->gb, 5)) == 31) { 1167 quant += 31; 1168 } 1169 quant_step += ((quant + step) ^ sign) - sign; 1170 } 1171 if (quant_step < 0) { 1172 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n"); 1173 } 1174 1175 /** decode quantization step modifiers for every channel */ 1176 1177 if (s->channels_for_cur_subframe == 1) { 1178 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step; 1179 } else { 1180 int modifier_len = get_bits(&s->gb, 3); 1181 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1182 int c = s->channel_indexes_for_cur_subframe[i]; 1183 s->channel[c].quant_step = quant_step; 1184 if (get_bits1(&s->gb)) { 1185 if (modifier_len) { 1186 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1; 1187 } else 1188 ++s->channel[c].quant_step; 1189 } 1190 } 1191 } 1192 1193 /** decode scale factors */ 1194 if (decode_scale_factors(s) < 0) 1195 return AVERROR_INVALIDDATA; 1196 } 1197 1198 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n", 1199 get_bits_count(&s->gb) - s->subframe_offset); 1200 1201 /** parse coefficients */ 1202 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1203 int c = s->channel_indexes_for_cur_subframe[i]; 1204 if (s->channel[c].transmit_coefs && 1205 get_bits_count(&s->gb) < s->num_saved_bits) { 1206 decode_coeffs(s, c); 1207 } else 1208 memset(s->channel[c].coeffs, 0, 1209 sizeof(*s->channel[c].coeffs) * subframe_len); 1210 } 1211 1212 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n", 1213 get_bits_count(&s->gb) - s->subframe_offset); 1214 1215 if (transmit_coeffs) { 1216 /** reconstruct the per channel data */ 1217 inverse_channel_transform(s); 1218 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1219 int c = s->channel_indexes_for_cur_subframe[i]; 1220 const int* sf = s->channel[c].scale_factors; 1221 int b; 1222 1223 if (c == s->lfe_channel) 1224 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) * 1225 (subframe_len - cur_subwoofer_cutoff)); 1226 1227 /** inverse quantization and rescaling */ 1228 for (b = 0; b < s->num_bands; b++) { 1229 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len); 1230 const int exp = s->channel[c].quant_step - 1231 (s->channel[c].max_scale_factor - *sf++) * 1232 s->channel[c].scale_factor_step; 1233 const float quant = pow(10.0, exp / 20.0); 1234 int start = s->cur_sfb_offsets[b]; 1235 s->dsp.vector_fmul_scalar(s->tmp + start, 1236 s->channel[c].coeffs + start, 1237 quant, end - start); 1238 } 1239 1240 /** apply imdct (ff_imdct_half == DCTIV with reverse) */ 1241 ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS], 1242 s->channel[c].coeffs, s->tmp); 1243 } 1244 } 1245 1246 /** window and overlapp-add */ 1247 wmapro_window(s); 1248 1249 /** handled one subframe */ 1250 for (i = 0; i < s->channels_for_cur_subframe; i++) { 1251 int c = s->channel_indexes_for_cur_subframe[i]; 1252 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) { 1253 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n"); 1254 return AVERROR_INVALIDDATA; 1255 } 1256 ++s->channel[c].cur_subframe; 1257 } 1258 1259 return 0; 1260} 1261 1262/** 1263 *@brief Decode one WMA frame. 1264 *@param s codec context 1265 *@return 0 if the trailer bit indicates that this is the last frame, 1266 * 1 if there are additional frames 1267 */ 1268static int decode_frame(WMAProDecodeCtx *s) 1269{ 1270 GetBitContext* gb = &s->gb; 1271 int more_frames = 0; 1272 int len = 0; 1273 int i; 1274 1275 /** check for potential output buffer overflow */ 1276 if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) { 1277 /** return an error if no frame could be decoded at all */ 1278 av_log(s->avctx, AV_LOG_ERROR, 1279 "not enough space for the output samples\n"); 1280 s->packet_loss = 1; 1281 return 0; 1282 } 1283 1284 /** get frame length */ 1285 if (s->len_prefix) 1286 len = get_bits(gb, s->log2_frame_size); 1287 1288 dprintf(s->avctx, "decoding frame with length %x\n", len); 1289 1290 /** decode tile information */ 1291 if (decode_tilehdr(s)) { 1292 s->packet_loss = 1; 1293 return 0; 1294 } 1295 1296 /** read postproc transform */ 1297 if (s->num_channels > 1 && get_bits1(gb)) { 1298 av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n"); 1299 s->packet_loss = 1; 1300 return 0; 1301 } 1302 1303 /** read drc info */ 1304 if (s->dynamic_range_compression) { 1305 s->drc_gain = get_bits(gb, 8); 1306 dprintf(s->avctx, "drc_gain %i\n", s->drc_gain); 1307 } 1308 1309 /** no idea what these are for, might be the number of samples 1310 that need to be skipped at the beginning or end of a stream */ 1311 if (get_bits1(gb)) { 1312 int skip; 1313 1314 /** usually true for the first frame */ 1315 if (get_bits1(gb)) { 1316 skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); 1317 dprintf(s->avctx, "start skip: %i\n", skip); 1318 } 1319 1320 /** sometimes true for the last frame */ 1321 if (get_bits1(gb)) { 1322 skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); 1323 dprintf(s->avctx, "end skip: %i\n", skip); 1324 } 1325 1326 } 1327 1328 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n", 1329 get_bits_count(gb) - s->frame_offset); 1330 1331 /** reset subframe states */ 1332 s->parsed_all_subframes = 0; 1333 for (i = 0; i < s->num_channels; i++) { 1334 s->channel[i].decoded_samples = 0; 1335 s->channel[i].cur_subframe = 0; 1336 s->channel[i].reuse_sf = 0; 1337 } 1338 1339 /** decode all subframes */ 1340 while (!s->parsed_all_subframes) { 1341 if (decode_subframe(s) < 0) { 1342 s->packet_loss = 1; 1343 return 0; 1344 } 1345 } 1346 1347 /** interleave samples and write them to the output buffer */ 1348 for (i = 0; i < s->num_channels; i++) { 1349 float* ptr = s->samples + i; 1350 int incr = s->num_channels; 1351 float* iptr = s->channel[i].out; 1352 float* iend = iptr + s->samples_per_frame; 1353 1354 // FIXME should create/use a DSP function here 1355 while (iptr < iend) { 1356 *ptr = *iptr++; 1357 ptr += incr; 1358 } 1359 1360 /** reuse second half of the IMDCT output for the next frame */ 1361 memcpy(&s->channel[i].out[0], 1362 &s->channel[i].out[s->samples_per_frame], 1363 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1); 1364 } 1365 1366 if (s->skip_frame) { 1367 s->skip_frame = 0; 1368 } else 1369 s->samples += s->num_channels * s->samples_per_frame; 1370 1371 if (len != (get_bits_count(gb) - s->frame_offset) + 2) { 1372 /** FIXME: not sure if this is always an error */ 1373 av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n", 1374 s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1); 1375 s->packet_loss = 1; 1376 return 0; 1377 } 1378 1379 /** skip the rest of the frame data */ 1380 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1); 1381 1382 /** decode trailer bit */ 1383 more_frames = get_bits1(gb); 1384 1385 ++s->frame_num; 1386 return more_frames; 1387} 1388 1389/** 1390 *@brief Calculate remaining input buffer length. 1391 *@param s codec context 1392 *@param gb bitstream reader context 1393 *@return remaining size in bits 1394 */ 1395static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) 1396{ 1397 return s->buf_bit_size - get_bits_count(gb); 1398} 1399 1400/** 1401 *@brief Fill the bit reservoir with a (partial) frame. 1402 *@param s codec context 1403 *@param gb bitstream reader context 1404 *@param len length of the partial frame 1405 *@param append decides wether to reset the buffer or not 1406 */ 1407static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, 1408 int append) 1409{ 1410 int buflen; 1411 1412 /** when the frame data does not need to be concatenated, the input buffer 1413 is resetted and additional bits from the previous frame are copyed 1414 and skipped later so that a fast byte copy is possible */ 1415 1416 if (!append) { 1417 s->frame_offset = get_bits_count(gb) & 7; 1418 s->num_saved_bits = s->frame_offset; 1419 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); 1420 } 1421 1422 buflen = (s->num_saved_bits + len + 8) >> 3; 1423 1424 if (len <= 0 || buflen > MAX_FRAMESIZE) { 1425 av_log_ask_for_sample(s->avctx, "input buffer too small\n"); 1426 s->packet_loss = 1; 1427 return; 1428 } 1429 1430 s->num_saved_bits += len; 1431 if (!append) { 1432 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), 1433 s->num_saved_bits); 1434 } else { 1435 int align = 8 - (get_bits_count(gb) & 7); 1436 align = FFMIN(align, len); 1437 put_bits(&s->pb, align, get_bits(gb, align)); 1438 len -= align; 1439 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len); 1440 } 1441 skip_bits_long(gb, len); 1442 1443 { 1444 PutBitContext tmp = s->pb; 1445 flush_put_bits(&tmp); 1446 } 1447 1448 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits); 1449 skip_bits(&s->gb, s->frame_offset); 1450} 1451 1452/** 1453 *@brief Decode a single WMA packet. 1454 *@param avctx codec context 1455 *@param data the output buffer 1456 *@param data_size number of bytes that were written to the output buffer 1457 *@param avpkt input packet 1458 *@return number of bytes that were read from the input buffer 1459 */ 1460static int decode_packet(AVCodecContext *avctx, 1461 void *data, int *data_size, AVPacket* avpkt) 1462{ 1463 WMAProDecodeCtx *s = avctx->priv_data; 1464 GetBitContext* gb = &s->pgb; 1465 const uint8_t* buf = avpkt->data; 1466 int buf_size = avpkt->size; 1467 int num_bits_prev_frame; 1468 int packet_sequence_number; 1469 1470 s->samples = data; 1471 s->samples_end = (float*)((int8_t*)data + *data_size); 1472 *data_size = 0; 1473 1474 if (s->packet_done || s->packet_loss) { 1475 s->packet_done = 0; 1476 s->buf_bit_size = buf_size << 3; 1477 1478 /** sanity check for the buffer length */ 1479 if (buf_size < avctx->block_align) 1480 return 0; 1481 1482 buf_size = avctx->block_align; 1483 1484 /** parse packet header */ 1485 init_get_bits(gb, buf, s->buf_bit_size); 1486 packet_sequence_number = get_bits(gb, 4); 1487 skip_bits(gb, 2); 1488 1489 /** get number of bits that need to be added to the previous frame */ 1490 num_bits_prev_frame = get_bits(gb, s->log2_frame_size); 1491 dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number, 1492 num_bits_prev_frame); 1493 1494 /** check for packet loss */ 1495 if (!s->packet_loss && 1496 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) { 1497 s->packet_loss = 1; 1498 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n", 1499 s->packet_sequence_number, packet_sequence_number); 1500 } 1501 s->packet_sequence_number = packet_sequence_number; 1502 1503 if (num_bits_prev_frame > 0) { 1504 /** append the previous frame data to the remaining data from the 1505 previous packet to create a full frame */ 1506 save_bits(s, gb, num_bits_prev_frame, 1); 1507 dprintf(avctx, "accumulated %x bits of frame data\n", 1508 s->num_saved_bits - s->frame_offset); 1509 1510 /** decode the cross packet frame if it is valid */ 1511 if (!s->packet_loss) 1512 decode_frame(s); 1513 } else if (s->num_saved_bits - s->frame_offset) { 1514 dprintf(avctx, "ignoring %x previously saved bits\n", 1515 s->num_saved_bits - s->frame_offset); 1516 } 1517 1518 s->packet_loss = 0; 1519 1520 } else { 1521 int frame_size; 1522 s->buf_bit_size = avpkt->size << 3; 1523 init_get_bits(gb, avpkt->data, s->buf_bit_size); 1524 skip_bits(gb, s->packet_offset); 1525 if (remaining_bits(s, gb) > s->log2_frame_size && 1526 (frame_size = show_bits(gb, s->log2_frame_size)) && 1527 frame_size <= remaining_bits(s, gb)) { 1528 save_bits(s, gb, frame_size, 0); 1529 s->packet_done = !decode_frame(s); 1530 } else 1531 s->packet_done = 1; 1532 } 1533 1534 if (s->packet_done && !s->packet_loss && 1535 remaining_bits(s, gb) > 0) { 1536 /** save the rest of the data so that it can be decoded 1537 with the next packet */ 1538 save_bits(s, gb, remaining_bits(s, gb), 0); 1539 } 1540 1541 *data_size = (int8_t *)s->samples - (int8_t *)data; 1542 s->packet_offset = get_bits_count(gb) & 7; 1543 1544 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3; 1545} 1546 1547/** 1548 *@brief Clear decoder buffers (for seeking). 1549 *@param avctx codec context 1550 */ 1551static void flush(AVCodecContext *avctx) 1552{ 1553 WMAProDecodeCtx *s = avctx->priv_data; 1554 int i; 1555 /** reset output buffer as a part of it is used during the windowing of a 1556 new frame */ 1557 for (i = 0; i < s->num_channels; i++) 1558 memset(s->channel[i].out, 0, s->samples_per_frame * 1559 sizeof(*s->channel[i].out)); 1560 s->packet_loss = 1; 1561} 1562 1563 1564/** 1565 *@brief wmapro decoder 1566 */ 1567AVCodec wmapro_decoder = { 1568 "wmapro", 1569 AVMEDIA_TYPE_AUDIO, 1570 CODEC_ID_WMAPRO, 1571 sizeof(WMAProDecodeCtx), 1572 decode_init, 1573 NULL, 1574 decode_end, 1575 decode_packet, 1576 .capabilities = CODEC_CAP_SUBFRAMES, 1577 .flush= flush, 1578 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"), 1579}; 1580