2 * Wmapro compatible decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2009 Sascha Sommer, Benjamin Larsson
6 * This file is part of FFmpeg.
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.
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.
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
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
32 * - windowing and overlapp-add
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
40 * The number of samples and a few other decode flags are stored
41 * as extradata that has to be passed to the decoder.
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.
47 * Example wmapro bitstream (in samples):
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 * ---------------------------------------------------
58 * The frame layouts for the individual channels of a wma frame does not need
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.
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
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
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.
93 #include "wmaprodata.h"
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
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
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)
116 static VLC sf_vlc; ///< scale factor DPCM vlc
117 static VLC sf_rl_vlc; ///< scale factor run length vlc
118 static VLC vec4_vlc; ///< 4 coefficients per symbol
119 static VLC vec2_vlc; ///< 2 coefficients per symbol
120 static VLC vec1_vlc; ///< 1 coefficient per symbol
121 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
122 static float sin64[33]; ///< sinus table for decorrelation
125 * @brief frame specific decoder context for a single channel
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
149 * @brief channel group for channel transformations
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
160 * @brief main decoder context
162 typedef 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
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
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
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?
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
220 uint8_t num_chgroups; ///< number of channel groups
221 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
223 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
228 *@brief helper function to print the most important members of the context
231 static void av_cold dump_context(WMAProDecodeCtx *s)
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);
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);
246 *@brief Uninitialize the decoder and free all resources.
247 *@param avctx codec context
248 *@return 0 on success, < 0 otherwise
250 static av_cold int decode_end(AVCodecContext *avctx)
252 WMAProDecodeCtx *s = avctx->priv_data;
255 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
256 ff_mdct_end(&s->mdct_ctx[i]);
262 *@brief Initialize the decoder.
263 *@param avctx codec context
264 *@return 0 on success, -1 otherwise
266 static av_cold int decode_init(AVCodecContext *avctx)
268 WMAProDecodeCtx *s = avctx->priv_data;
269 uint8_t *edata_ptr = avctx->extradata;
270 unsigned int channel_mask;
272 int log2_max_num_subframes;
273 int num_possible_block_sizes;
276 dsputil_init(&s->dsp, avctx);
277 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
279 avctx->sample_fmt = SAMPLE_FMT_FLT;
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");
291 av_log_ask_for_sample(avctx, "Unknown extradata size\n");
292 return AVERROR_INVALIDDATA;
296 s->log2_frame_size = av_log2(avctx->block_align) + 4;
299 s->skip_frame = 1; /* skip first frame */
301 s->len_prefix = (s->decode_flags & 0x40);
303 if (!s->len_prefix) {
304 av_log_ask_for_sample(avctx, "no length prefix\n");
305 return AVERROR_INVALIDDATA;
309 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
312 /** init previous block len */
313 for (i = 0; i < avctx->channels; i++)
314 s->channel[i].prev_block_len = s->samples_per_frame;
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;
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);
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;
333 s->num_channels = avctx->channels;
335 /** extract lfe channel position */
338 if (channel_mask & 8) {
340 for (mask = 1; mask < 16; mask <<= 1) {
341 if (channel_mask & mask)
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;
354 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
355 scale_huffbits, 1, 1,
356 scale_huffcodes, 2, 2, 616);
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);
362 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
363 coef0_huffbits, 1, 1,
364 coef0_huffcodes, 4, 4, 2108);
366 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
367 coef1_huffbits, 1, 1,
368 coef1_huffcodes, 4, 4, 3912);
370 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
372 vec4_huffcodes, 2, 2, 604);
374 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
376 vec2_huffcodes, 2, 2, 562);
378 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
380 vec1_huffcodes, 2, 2, 562);
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;
389 s->sfb_offsets[i][0] = 0;
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;
395 if (offset > s->sfb_offsets[i][band - 1])
396 s->sfb_offsets[i][band++] = offset;
398 s->sfb_offsets[i][band - 1] = subframe_len;
399 s->num_sfb[i] = band - 1;
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.
408 for (i = 0; i < num_possible_block_sizes; i++) {
410 for (b = 0; b < s->num_sfb[i]; b++) {
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++) {
416 while (s->sfb_offsets[x][v + 1] << x < offset)
418 s->sf_offsets[i][x][b] = v;
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)));
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];
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);
444 /** calculate sine values for the decorrelation matrix */
445 for (i = 0; i < 33; i++)
446 sin64[i] = sin(i*M_PI / 64.0);
448 if (avctx->debug & FF_DEBUG_BITSTREAM)
451 avctx->channel_layout = channel_mask;
456 *@brief Decode the subframe length.
458 *@param offset sample offset in the frame
459 *@return decoded subframe length on success, < 0 in case of an error
461 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
463 int frame_len_shift = 0;
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;
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);
475 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
477 subframe_len = s->samples_per_frame >> frame_len_shift;
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",
484 return AVERROR_INVALIDDATA;
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.
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.
507 *@return 0 on success, < 0 in case of an error
509 static int decode_tilehdr(WMAProDecodeCtx *s)
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) */
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)
524 /** reset tiling information */
525 for (c = 0; c < s->num_channels; c++)
526 s->channel[c].num_subframes = 0;
528 memset(num_samples, 0, sizeof(num_samples));
530 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
531 fixed_channel_layout = 1;
533 /** loop until the frame data is split between the subframes */
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;
544 contains_subframe[c] = get_bits1(&s->gb);
546 contains_subframe[c] = 0;
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;
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];
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;
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;
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];
577 ++channels_for_cur_subframe;
580 } while (min_channel_len < s->samples_per_frame);
582 for (c = 0; c < s->num_channels; c++) {
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];
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
602 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
603 WMAProChannelGrp *chgroup)
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));
611 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
612 rotation_offset[i] = get_bits(&s->gb, 6);
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;
618 for (i = 1; i < chgroup->num_channels; i++) {
620 for (x = 0; x < i; x++) {
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];
631 cosv = sin64[32 - n];
633 sinv = sin64[64 - n];
634 cosv = -sin64[n - 32];
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);
648 *@brief Decode channel transformation parameters
649 *@param s codec context
650 *@return 0 in case of success, < 0 in case of bitstream errors
652 static int decode_channel_transform(WMAProDecodeCtx* s)
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)
660 /** in the one channel case channel transforms are pointless */
662 if (s->num_channels > 1) {
663 int remaining_channels = s->channels_for_cur_subframe;
665 if (get_bits1(&s->gb)) {
666 av_log_ask_for_sample(s->avctx,
667 "unsupported channel transform bit\n");
668 return AVERROR_INVALIDDATA;
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;
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;
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;
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");
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;
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;
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);
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");
732 memcpy(chgroup->decorrelation_matrix,
733 default_decorrelation[chgroup->num_channels],
734 chgroup->num_channels * chgroup->num_channels *
735 sizeof(*chgroup->decorrelation_matrix));
741 /** decode transform on / off */
742 if (chgroup->transform) {
743 if (!get_bits1(&s->gb)) {
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);
750 memset(chgroup->transform_band, 1, s->num_bands);
753 remaining_channels -= chgroup->num_channels;
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
765 static int decode_coeffs(WMAProDecodeCtx *s, int c)
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,
778 WMAProChannelCtx* ci = &s->channel[c];
785 dprintf(s->avctx, "decode coefficients for channel %i\n", c);
787 vlctable = get_bits1(&s->gb);
788 vlc = &coef_vlc[vlctable];
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) {
805 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
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) {
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;
821 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
822 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
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];
833 for (i = 0; i < 4; i++) {
835 int sign = get_bits1(&s->gb) - 1;
836 *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31;
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);
848 /** decode run level coded coefficients */
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;
863 *@brief Extract scale factors from the bitstream.
864 *@param s codec context
865 *@return 0 on success, < 0 in case of bitstream errors
867 static int decode_scale_factors(WMAProDecodeCtx* s)
871 /** should never consume more than 5344 bits
872 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
875 for (i = 0; i < s->channels_for_cur_subframe; i++) {
876 int c = s->channel_indexes_for_cur_subframe[i];
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;
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
887 if (s->channel[c].reuse_sf) {
888 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
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++];
895 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
897 if (!s->channel[c].reuse_sf) {
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;
908 /** run level decode differences to the resampled factors */
909 for (i = 0; i < s->num_bands; i++) {
915 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
918 uint32_t code = get_bits(&s->gb, 14);
920 sign = (code & 1) - 1;
921 skip = (code & 0x3f) >> 1;
922 } else if (idx == 1) {
925 skip = scale_rl_run[idx];
926 val = scale_rl_level[idx];
927 sign = get_bits1(&s->gb)-1;
931 if (i >= s->num_bands) {
932 av_log(s->avctx, AV_LOG_ERROR,
933 "invalid scale factor coding\n");
934 return AVERROR_INVALIDDATA;
936 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
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;
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);
957 *@brief Reconstruct the individual channel data.
958 *@param s codec context
960 static void inverse_channel_transform(WMAProDecodeCtx *s)
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;
973 /** multichannel decorrelation */
974 for (sfb = s->cur_sfb_offsets;
975 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
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;
985 for (ch = ch_data; ch < ch_end; ch++)
986 *data_ptr++ = (*ch)[y];
988 for (ch = ch_data; ch < ch_end; ch++) {
991 while (data_ptr < data_end)
992 sum += *data_ptr++ * *mat++;
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],
1002 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1003 ch_data[1] + sfb[0],
1012 *@brief Apply sine window and reconstruct the output buffer.
1013 *@param s codec context
1015 static void wmapro_window(WMAProDecodeCtx *s)
1018 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1019 int c = s->channel_indexes_for_cur_subframe[i];
1021 int winlen = s->channel[c].prev_block_len;
1022 float* start = s->channel[c].coeffs - (winlen >> 1);
1024 if (s->subframe_len < winlen) {
1025 start += (winlen - s->subframe_len) >> 1;
1026 winlen = s->subframe_len;
1029 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1033 s->dsp.vector_fmul_window(start, start, start + winlen,
1036 s->channel[c].prev_block_len = s->subframe_len;
1041 *@brief Decode a single subframe (block).
1042 *@param s codec context
1043 *@return 0 on success, < 0 when decoding failed
1045 static int decode_subframe(WMAProDecodeCtx *s)
1047 int offset = s->samples_per_frame;
1048 int subframe_len = s->samples_per_frame;
1050 int total_samples = s->samples_per_frame * s->num_channels;
1051 int transmit_coeffs = 0;
1052 int cur_subwoofer_cutoff;
1054 s->subframe_offset = get_bits_count(&s->gb);
1056 /** reset channel context and find the next block offset and size
1057 == the next block of the channel with the smallest number of
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;
1065 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1070 "processing subframe with offset %i len %i\n", offset, subframe_len);
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;
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;
1090 /** check if the frame will be complete after processing the
1093 s->parsed_all_subframes = 1;
1096 dprintf(s->avctx, "subframe is part of %i channels\n",
1097 s->channels_for_cur_subframe);
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];
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];
1109 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1113 s->subframe_len = subframe_len;
1114 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1116 /** skip extended header if any */
1117 if (get_bits1(&s->gb)) {
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;
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;
1130 skip_bits_long(&s->gb, num_fill_bits);
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;
1141 if (decode_channel_transform(s) < 0)
1142 return AVERROR_INVALIDDATA;
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;
1151 if (transmit_coeffs) {
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;
1159 /** decode quantization step */
1160 step = get_sbits(&s->gb, 6);
1162 if (step == -32 || step == 31) {
1163 const int sign = (step == 31) - 1;
1165 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1166 (step = get_bits(&s->gb, 5)) == 31) {
1169 quant_step += ((quant + step) ^ sign) - sign;
1171 if (quant_step < 0) {
1172 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1175 /** decode quantization step modifiers for every channel */
1177 if (s->channels_for_cur_subframe == 1) {
1178 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
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)) {
1186 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1188 ++s->channel[c].quant_step;
1193 /** decode scale factors */
1194 if (decode_scale_factors(s) < 0)
1195 return AVERROR_INVALIDDATA;
1198 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1199 get_bits_count(&s->gb) - s->subframe_offset);
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);
1208 memset(s->channel[c].coeffs, 0,
1209 sizeof(*s->channel[c].coeffs) * subframe_len);
1212 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1213 get_bits_count(&s->gb) - s->subframe_offset);
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;
1223 if (c == s->lfe_channel)
1224 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1225 (subframe_len - cur_subwoofer_cutoff));
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);
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);
1246 /** window and overlapp-add */
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;
1256 ++s->channel[c].cur_subframe;
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
1268 static int decode_frame(WMAProDecodeCtx *s)
1270 GetBitContext* gb = &s->gb;
1271 int more_frames = 0;
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");
1284 /** get frame length */
1286 len = get_bits(gb, s->log2_frame_size);
1288 dprintf(s->avctx, "decoding frame with length %x\n", len);
1290 /** decode tile information */
1291 if (decode_tilehdr(s)) {
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");
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);
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)) {
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);
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);
1328 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1329 get_bits_count(gb) - s->frame_offset);
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;
1339 /** decode all subframes */
1340 while (!s->parsed_all_subframes) {
1341 if (decode_subframe(s) < 0) {
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;
1354 // FIXME should create/use a DSP function here
1355 while (iptr < iend) {
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);
1366 if (s->skip_frame) {
1369 s->samples += s->num_channels * s->samples_per_frame;
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);
1379 /** skip the rest of the frame data */
1380 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1382 /** decode trailer bit */
1383 more_frames = get_bits1(gb);
1390 *@brief Calculate remaining input buffer length.
1391 *@param s codec context
1392 *@param gb bitstream reader context
1393 *@return remaining size in bits
1395 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1397 return s->buf_bit_size - get_bits_count(gb);
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
1407 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
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 */
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);
1422 buflen = (s->num_saved_bits + len + 8) >> 3;
1424 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1425 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1430 s->num_saved_bits += len;
1432 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1435 int align = 8 - (get_bits_count(gb) & 7);
1436 align = FFMIN(align, len);
1437 put_bits(&s->pb, align, get_bits(gb, align));
1439 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1441 skip_bits_long(gb, len);
1444 PutBitContext tmp = s->pb;
1445 flush_put_bits(&tmp);
1448 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1449 skip_bits(&s->gb, s->frame_offset);
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
1460 static int decode_packet(AVCodecContext *avctx,
1461 void *data, int *data_size, AVPacket* avpkt)
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;
1471 s->samples_end = (float*)((int8_t*)data + *data_size);
1474 if (s->packet_done || s->packet_loss) {
1476 s->buf_bit_size = buf_size << 3;
1478 /** sanity check for the buffer length */
1479 if (buf_size < avctx->block_align)
1482 buf_size = avctx->block_align;
1484 /** parse packet header */
1485 init_get_bits(gb, buf, s->buf_bit_size);
1486 packet_sequence_number = get_bits(gb, 4);
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);
1494 /** check for packet loss */
1495 if (!s->packet_loss &&
1496 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1498 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1499 s->packet_sequence_number, packet_sequence_number);
1501 s->packet_sequence_number = packet_sequence_number;
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);
1510 /** decode the cross packet frame if it is valid */
1511 if (!s->packet_loss)
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);
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);
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);
1541 *data_size = (int8_t *)s->samples - (int8_t *)data;
1542 s->packet_offset = get_bits_count(gb) & 7;
1544 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1548 *@brief Clear decoder buffers (for seeking).
1549 *@param avctx codec context
1551 static void flush(AVCodecContext *avctx)
1553 WMAProDecodeCtx *s = avctx->priv_data;
1555 /** reset output buffer as a part of it is used during the windowing of a
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));
1565 *@brief wmapro decoder
1567 AVCodec wmapro_decoder = {
1571 sizeof(WMAProDecodeCtx),
1576 .capabilities = CODEC_CAP_SUBFRAMES,
1578 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),