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
24 * @file libavcodec/wmaprodec.c
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 16384 ///< 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 scale_factors[MAX_BANDS]; ///< scale factor values for the current subframe
141 int saved_scale_factors[MAX_BANDS]; ///< scale factors from a previous subframe
142 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
143 float* coeffs; ///< pointer to the subframe decode buffer
144 DECLARE_ALIGNED_16(float, out[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]); ///< output buffer
148 * @brief channel group for channel transformations
151 uint8_t num_channels; ///< number of channels in the group
152 int8_t transform; ///< transform on / off
153 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
154 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
155 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
159 * @brief main decoder context
161 typedef struct WMAProDecodeCtx {
162 /* generic decoder variables */
163 AVCodecContext* avctx; ///< codec context for av_log
164 DSPContext dsp; ///< accelerated DSP functions
165 uint8_t frame_data[MAX_FRAMESIZE +
166 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
167 PutBitContext pb; ///< context for filling the frame_data buffer
168 MDCTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
169 DECLARE_ALIGNED_16(float, tmp[WMAPRO_BLOCK_MAX_SIZE]); ///< IMDCT output buffer
170 float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
172 /* frame size dependent frame information (set during initialization) */
173 uint32_t decode_flags; ///< used compression features
174 uint8_t len_prefix; ///< frame is prefixed with its length
175 uint8_t dynamic_range_compression; ///< frame contains DRC data
176 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
177 uint16_t samples_per_frame; ///< number of samples to output
178 uint16_t log2_frame_size;
179 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
180 int8_t lfe_channel; ///< lfe channel index
181 uint8_t max_num_subframes;
182 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
183 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
184 uint16_t min_samples_per_subframe;
185 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
186 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
187 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
188 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
190 /* packet decode state */
191 GetBitContext pgb; ///< bitstream reader context for the packet
192 uint8_t packet_sequence_number; ///< current packet number
193 int num_saved_bits; ///< saved number of bits
194 int frame_offset; ///< frame offset in the bit reservoir
195 int subframe_offset; ///< subframe offset in the bit reservoir
196 uint8_t packet_loss; ///< set in case of bitstream error
197 uint8_t output_buffer_full; ///< flag indicating that the output buffer is full
199 /* frame decode state */
200 uint32_t frame_num; ///< current frame number (not used for decoding)
201 GetBitContext gb; ///< bitstream reader context
202 int buf_bit_size; ///< buffer size in bits
203 float* samples_start; ///< start samplebuffer pointer
204 float* samples; ///< current samplebuffer pointer
205 float* samples_end; ///< maximum samplebuffer pointer
206 uint8_t drc_gain; ///< gain for the DRC tool
207 int8_t skip_frame; ///< skip output step
208 int8_t parsed_all_subframes; ///< all subframes decoded?
210 /* subframe/block decode state */
211 int16_t subframe_len; ///< current subframe length
212 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
213 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
214 int8_t num_bands; ///< number of scale factor bands
215 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
216 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
217 int8_t esc_len; ///< length of escaped coefficients
219 uint8_t num_chgroups; ///< number of channel groups
220 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
222 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
227 *@brief helper function to print the most important members of the context
230 static void av_cold dump_context(WMAProDecodeCtx *s)
232 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
233 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
235 PRINT("ed sample bit depth", s->bits_per_sample);
236 PRINT_HEX("ed decode flags", s->decode_flags);
237 PRINT("samples per frame", s->samples_per_frame);
238 PRINT("log2 frame size", s->log2_frame_size);
239 PRINT("max num subframes", s->max_num_subframes);
240 PRINT("len prefix", s->len_prefix);
241 PRINT("num channels", s->num_channels);
245 *@brief Uninitialize the decoder and free all resources.
246 *@param avctx codec context
247 *@return 0 on success, < 0 otherwise
249 static av_cold int decode_end(AVCodecContext *avctx)
251 WMAProDecodeCtx *s = avctx->priv_data;
254 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
255 ff_mdct_end(&s->mdct_ctx[i]);
261 *@brief Initialize the decoder.
262 *@param avctx codec context
263 *@return 0 on success, -1 otherwise
265 static av_cold int decode_init(AVCodecContext *avctx)
267 WMAProDecodeCtx *s = avctx->priv_data;
268 uint8_t *edata_ptr = avctx->extradata;
269 unsigned int channel_mask;
271 int log2_max_num_subframes;
272 int num_possible_block_sizes;
275 dsputil_init(&s->dsp, avctx);
276 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
278 avctx->sample_fmt = SAMPLE_FMT_FLT;
280 if (avctx->extradata_size >= 18) {
281 s->decode_flags = AV_RL16(edata_ptr+14);
282 channel_mask = AV_RL32(edata_ptr+2);
283 s->bits_per_sample = AV_RL16(edata_ptr);
284 /** dump the extradata */
285 for (i = 0; i < avctx->extradata_size; i++)
286 dprintf(avctx, "[%x] ", avctx->extradata[i]);
287 dprintf(avctx, "\n");
290 av_log_ask_for_sample(avctx, "Unknown extradata size\n");
291 return AVERROR_INVALIDDATA;
295 s->log2_frame_size = av_log2(avctx->block_align) + 4;
298 s->skip_frame = 1; /** skip first frame */
300 s->len_prefix = (s->decode_flags & 0x40);
302 if (!s->len_prefix) {
303 av_log_ask_for_sample(avctx, "no length prefix\n");
304 return AVERROR_INVALIDDATA;
308 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
311 /** init previous block len */
312 for (i = 0; i < avctx->channels; i++)
313 s->channel[i].prev_block_len = s->samples_per_frame;
316 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
317 s->max_num_subframes = 1 << log2_max_num_subframes;
318 if (s->max_num_subframes == 16)
319 s->max_subframe_len_bit = 1;
320 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
322 num_possible_block_sizes = log2_max_num_subframes + 1;
323 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
324 s->dynamic_range_compression = (s->decode_flags & 0x80);
326 if (s->max_num_subframes > MAX_SUBFRAMES) {
327 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
328 s->max_num_subframes);
329 return AVERROR_INVALIDDATA;
332 s->num_channels = avctx->channels;
334 /** extract lfe channel position */
337 if (channel_mask & 8) {
339 for (mask = 1; mask < 16; mask <<= 1) {
340 if (channel_mask & mask)
345 if (s->num_channels < 0 || s->num_channels > WMAPRO_MAX_CHANNELS) {
346 av_log_ask_for_sample(avctx, "invalid number of channels\n");
347 return AVERROR_NOTSUPP;
350 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
351 scale_huffbits, 1, 1,
352 scale_huffcodes, 2, 2, 616);
354 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
355 scale_rl_huffbits, 1, 1,
356 scale_rl_huffcodes, 4, 4, 1406);
358 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
359 coef0_huffbits, 1, 1,
360 coef0_huffcodes, 4, 4, 2108);
362 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
363 coef1_huffbits, 1, 1,
364 coef1_huffcodes, 4, 4, 3912);
366 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
368 vec4_huffcodes, 2, 2, 604);
370 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
372 vec2_huffcodes, 2, 2, 562);
374 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
376 vec1_huffcodes, 2, 2, 562);
378 /** calculate number of scale factor bands and their offsets
379 for every possible block size */
380 for (i = 0; i < num_possible_block_sizes; i++) {
381 int subframe_len = s->samples_per_frame >> i;
385 s->sfb_offsets[i][0] = 0;
387 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
388 int offset = (subframe_len * 2 * critical_freq[x])
389 / s->avctx->sample_rate + 2;
391 if (offset > s->sfb_offsets[i][band - 1])
392 s->sfb_offsets[i][band++] = offset;
394 s->sfb_offsets[i][band - 1] = subframe_len;
395 s->num_sfb[i] = band - 1;
399 /** Scale factors can be shared between blocks of different size
400 as every block has a different scale factor band layout.
401 The matrix sf_offsets is needed to find the correct scale factor.
404 for (i = 0; i < num_possible_block_sizes; i++) {
406 for (b = 0; b < s->num_sfb[i]; b++) {
408 int offset = ((s->sfb_offsets[i][b]
409 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
410 for (x = 0; x < num_possible_block_sizes; x++) {
412 while (s->sfb_offsets[x][v + 1] << x < offset)
414 s->sf_offsets[i][x][b] = v;
419 /** init MDCT, FIXME: only init needed sizes */
420 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
421 ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1,
422 1.0 / (1 << (BLOCK_MIN_BITS + i - 1))
423 / (1 << (s->bits_per_sample - 1)));
425 /** init MDCT windows: simple sinus window */
426 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
427 const int n = 1 << (WMAPRO_BLOCK_MAX_BITS - i);
428 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i - 7;
429 ff_sine_window_init(ff_sine_windows[win_idx], n);
430 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
433 /** calculate subwoofer cutoff values */
434 for (i = 0; i < num_possible_block_sizes; i++) {
435 int block_size = s->samples_per_frame >> i;
436 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
437 / s->avctx->sample_rate;
438 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
441 /** calculate sine values for the decorrelation matrix */
442 for (i = 0; i < 33; i++)
443 sin64[i] = sin(i*M_PI / 64.0);
445 if (avctx->debug & FF_DEBUG_BITSTREAM)
448 avctx->channel_layout = channel_mask;
453 *@brief Decode the subframe length.
455 *@param offset sample offset in the frame
456 *@return decoded subframe length on success, < 0 in case of an error
458 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
460 int frame_len_shift = 0;
463 /** no need to read from the bitstream when only one length is possible */
464 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
465 return s->min_samples_per_subframe;
467 /** 1 bit indicates if the subframe is of maximum length */
468 if (s->max_subframe_len_bit) {
469 if (get_bits1(&s->gb))
470 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
472 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
474 subframe_len = s->samples_per_frame >> frame_len_shift;
476 /** sanity check the length */
477 if (subframe_len < s->min_samples_per_subframe ||
478 subframe_len > s->samples_per_frame) {
479 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
481 return AVERROR_INVALIDDATA;
487 *@brief Decode how the data in the frame is split into subframes.
488 * Every WMA frame contains the encoded data for a fixed number of
489 * samples per channel. The data for every channel might be split
490 * into several subframes. This function will reconstruct the list of
491 * subframes for every channel.
493 * If the subframes are not evenly split, the algorithm estimates the
494 * channels with the lowest number of total samples.
495 * Afterwards, for each of these channels a bit is read from the
496 * bitstream that indicates if the channel contains a subframe with the
497 * next subframe size that is going to be read from the bitstream or not.
498 * If a channel contains such a subframe, the subframe size gets added to
499 * the channel's subframe list.
500 * The algorithm repeats these steps until the frame is properly divided
501 * between the individual channels.
504 *@return 0 on success, < 0 in case of an error
506 static int decode_tilehdr(WMAProDecodeCtx *s)
508 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /** sum of samples for all currently known subframes of a channel */
509 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /** flag indicating if a channel contains the current subframe */
510 int channels_for_cur_subframe = s->num_channels; /** number of channels that contain the current subframe */
511 int fixed_channel_layout = 0; /** flag indicating that all channels use the same subframe offsets and sizes */
512 int min_channel_len = 0; /** smallest sum of samples (channels with this length will be processed first) */
515 /* Should never consume more than 3073 bits (256 iterations for the
516 * while loop when always the minimum amount of 128 samples is substracted
517 * from missing samples in the 8 channel case).
518 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
521 /** reset tiling information */
522 for (c = 0; c < s->num_channels; c++)
523 s->channel[c].num_subframes = 0;
525 memset(num_samples, 0, sizeof(num_samples));
527 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
528 fixed_channel_layout = 1;
530 /** loop until the frame data is split between the subframes */
534 /** check which channels contain the subframe */
535 for (c = 0; c < s->num_channels; c++) {
536 if (num_samples[c] == min_channel_len) {
537 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
538 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
539 contains_subframe[c] = 1;
541 contains_subframe[c] = get_bits1(&s->gb);
543 contains_subframe[c] = 0;
546 /** get subframe length, subframe_len == 0 is not allowed */
547 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
548 return AVERROR_INVALIDDATA;
550 /** add subframes to the individual channels and find new min_channel_len */
551 min_channel_len += subframe_len;
552 for (c = 0; c < s->num_channels; c++) {
553 WMAProChannelCtx* chan = &s->channel[c];
555 if (contains_subframe[c]) {
556 if (chan->num_subframes >= MAX_SUBFRAMES) {
557 av_log(s->avctx, AV_LOG_ERROR,
558 "broken frame: num subframes > 31\n");
559 return AVERROR_INVALIDDATA;
561 chan->subframe_len[chan->num_subframes] = subframe_len;
562 num_samples[c] += subframe_len;
563 ++chan->num_subframes;
564 if (num_samples[c] > s->samples_per_frame) {
565 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
566 "channel len > samples_per_frame\n");
567 return AVERROR_INVALIDDATA;
569 } else if (num_samples[c] <= min_channel_len) {
570 if (num_samples[c] < min_channel_len) {
571 channels_for_cur_subframe = 0;
572 min_channel_len = num_samples[c];
574 ++channels_for_cur_subframe;
577 } while (min_channel_len < s->samples_per_frame);
579 for (c = 0; c < s->num_channels; c++) {
582 for (i = 0; i < s->channel[c].num_subframes; i++) {
583 dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
584 " len %i\n", s->frame_num, c, i,
585 s->channel[c].subframe_len[i]);
586 s->channel[c].subframe_offset[i] = offset;
587 offset += s->channel[c].subframe_len[i];
595 *@brief Calculate a decorrelation matrix from the bitstream parameters.
596 *@param s codec context
597 *@param chgroup channel group for which the matrix needs to be calculated
599 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
600 WMAProChannelGrp *chgroup)
604 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
605 memset(chgroup->decorrelation_matrix, 0, s->num_channels *
606 s->num_channels * sizeof(*chgroup->decorrelation_matrix));
608 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
609 rotation_offset[i] = get_bits(&s->gb, 6);
611 for (i = 0; i < chgroup->num_channels; i++)
612 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
613 get_bits1(&s->gb) ? 1.0 : -1.0;
615 for (i = 1; i < chgroup->num_channels; i++) {
617 for (x = 0; x < i; x++) {
619 for (y = 0; y < i + 1; y++) {
620 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
621 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
622 int n = rotation_offset[offset + x];
628 cosv = sin64[32 - n];
630 sinv = sin64[64 - n];
631 cosv = -sin64[n - 32];
634 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
635 (v1 * sinv) - (v2 * cosv);
636 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
637 (v1 * cosv) + (v2 * sinv);
645 *@brief Decode channel transformation parameters
646 *@param s codec context
647 *@return 0 in case of success, < 0 in case of bitstream errors
649 static int decode_channel_transform(WMAProDecodeCtx* s)
652 /* should never consume more than 1921 bits for the 8 channel case
653 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
654 * + MAX_CHANNELS + MAX_BANDS + 1)
657 /** in the one channel case channel transforms are pointless */
659 if (s->num_channels > 1) {
660 int remaining_channels = s->channels_for_cur_subframe;
662 if (get_bits1(&s->gb)) {
663 av_log_ask_for_sample(s->avctx,
664 "unsupported channel transform bit\n");
665 return AVERROR_INVALIDDATA;
668 for (s->num_chgroups = 0; remaining_channels &&
669 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
670 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
671 float** channel_data = chgroup->channel_data;
672 chgroup->num_channels = 0;
673 chgroup->transform = 0;
675 /** decode channel mask */
676 if (remaining_channels > 2) {
677 for (i = 0; i < s->channels_for_cur_subframe; i++) {
678 int channel_idx = s->channel_indexes_for_cur_subframe[i];
679 if (!s->channel[channel_idx].grouped
680 && get_bits1(&s->gb)) {
681 ++chgroup->num_channels;
682 s->channel[channel_idx].grouped = 1;
683 *channel_data++ = s->channel[channel_idx].coeffs;
687 chgroup->num_channels = remaining_channels;
688 for (i = 0; i < s->channels_for_cur_subframe; i++) {
689 int channel_idx = s->channel_indexes_for_cur_subframe[i];
690 if (!s->channel[channel_idx].grouped)
691 *channel_data++ = s->channel[channel_idx].coeffs;
692 s->channel[channel_idx].grouped = 1;
696 /** decode transform type */
697 if (chgroup->num_channels == 2) {
698 if (get_bits1(&s->gb)) {
699 if (get_bits1(&s->gb)) {
700 av_log_ask_for_sample(s->avctx,
701 "unsupported channel transform type\n");
704 chgroup->transform = 1;
705 if (s->num_channels == 2) {
706 chgroup->decorrelation_matrix[0] = 1.0;
707 chgroup->decorrelation_matrix[1] = -1.0;
708 chgroup->decorrelation_matrix[2] = 1.0;
709 chgroup->decorrelation_matrix[3] = 1.0;
712 chgroup->decorrelation_matrix[0] = 0.70703125;
713 chgroup->decorrelation_matrix[1] = -0.70703125;
714 chgroup->decorrelation_matrix[2] = 0.70703125;
715 chgroup->decorrelation_matrix[3] = 0.70703125;
718 } else if (chgroup->num_channels > 2) {
719 if (get_bits1(&s->gb)) {
720 chgroup->transform = 1;
721 if (get_bits1(&s->gb)) {
722 decode_decorrelation_matrix(s, chgroup);
724 /** FIXME: more than 6 coupled channels not supported */
725 if (chgroup->num_channels > 6) {
726 av_log_ask_for_sample(s->avctx,
727 "coupled channels > 6\n");
729 memcpy(chgroup->decorrelation_matrix,
730 default_decorrelation[chgroup->num_channels],
731 chgroup->num_channels * chgroup->num_channels *
732 sizeof(*chgroup->decorrelation_matrix));
738 /** decode transform on / off */
739 if (chgroup->transform) {
740 if (!get_bits1(&s->gb)) {
742 /** transform can be enabled for individual bands */
743 for (i = 0; i < s->num_bands; i++) {
744 chgroup->transform_band[i] = get_bits1(&s->gb);
747 memset(chgroup->transform_band, 1, s->num_bands);
750 remaining_channels -= chgroup->num_channels;
757 *@brief Extract the coefficients from the bitstream.
758 *@param s codec context
759 *@param c current channel number
760 *@return 0 on success, < 0 in case of bitstream errors
762 static int decode_coeffs(WMAProDecodeCtx *s, int c)
766 WMAProChannelCtx* ci = &s->channel[c];
771 const uint16_t* level;
773 dprintf(s->avctx, "decode coefficients for channel %i\n", c);
775 vlctable = get_bits1(&s->gb);
776 vlc = &coef_vlc[vlctable];
786 /** decode vector coefficients (consumes up to 167 bits per iteration for
787 4 vector coded large values) */
788 while (!rl_mode && cur_coeff + 3 < s->subframe_len) {
793 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
795 if (idx == HUFF_VEC4_SIZE - 1) {
796 for (i = 0; i < 4; i += 2) {
797 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
798 if (idx == HUFF_VEC2_SIZE - 1) {
799 vals[i] = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
800 if (vals[i] == HUFF_VEC1_SIZE - 1)
801 vals[i] += ff_wma_get_large_val(&s->gb);
802 vals[i+1] = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
803 if (vals[i+1] == HUFF_VEC1_SIZE - 1)
804 vals[i+1] += ff_wma_get_large_val(&s->gb);
806 vals[i] = symbol_to_vec2[idx] >> 4;
807 vals[i+1] = symbol_to_vec2[idx] & 0xF;
811 vals[0] = symbol_to_vec4[idx] >> 12;
812 vals[1] = (symbol_to_vec4[idx] >> 8) & 0xF;
813 vals[2] = (symbol_to_vec4[idx] >> 4) & 0xF;
814 vals[3] = symbol_to_vec4[idx] & 0xF;
818 for (i = 0; i < 4; i++) {
820 int sign = get_bits1(&s->gb) - 1;
821 ci->coeffs[cur_coeff] = (vals[i] ^ sign) - sign;
824 ci->coeffs[cur_coeff] = 0;
825 /** switch to run level mode when subframe_len / 128 zeros
826 were found in a row */
827 rl_mode |= (++num_zeros > s->subframe_len >> 8);
833 /** decode run level coded coefficients */
835 memset(&ci->coeffs[cur_coeff], 0,
836 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
837 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
838 level, run, 1, ci->coeffs,
839 cur_coeff, s->subframe_len,
840 s->subframe_len, s->esc_len, 0))
841 return AVERROR_INVALIDDATA;
848 *@brief Extract scale factors from the bitstream.
849 *@param s codec context
850 *@return 0 on success, < 0 in case of bitstream errors
852 static int decode_scale_factors(WMAProDecodeCtx* s)
856 /** should never consume more than 5344 bits
857 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
860 for (i = 0; i < s->channels_for_cur_subframe; i++) {
861 int c = s->channel_indexes_for_cur_subframe[i];
863 int* sf_end = s->channel[c].scale_factors + s->num_bands;
865 /** resample scale factors for the new block size
866 * as the scale factors might need to be resampled several times
867 * before some new values are transmitted, a backup of the last
868 * transmitted scale factors is kept in saved_scale_factors
870 if (s->channel[c].reuse_sf) {
871 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
873 for (b = 0; b < s->num_bands; b++)
874 s->channel[c].scale_factors[b] =
875 s->channel[c].saved_scale_factors[*sf_offsets++];
878 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
880 if (!s->channel[c].reuse_sf) {
882 /** decode DPCM coded scale factors */
883 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
884 val = 45 / s->channel[c].scale_factor_step;
885 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
886 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
891 /** run level decode differences to the resampled factors */
892 for (i = 0; i < s->num_bands; i++) {
898 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
901 uint32_t code = get_bits(&s->gb, 14);
903 sign = (code & 1) - 1;
904 skip = (code & 0x3f) >> 1;
905 } else if (idx == 1) {
908 skip = scale_rl_run[idx];
909 val = scale_rl_level[idx];
910 sign = get_bits1(&s->gb)-1;
914 if (i >= s->num_bands) {
915 av_log(s->avctx, AV_LOG_ERROR,
916 "invalid scale factor coding\n");
917 return AVERROR_INVALIDDATA;
919 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
923 /** save transmitted scale factors so that they can be reused for
925 memcpy(s->channel[c].saved_scale_factors,
926 s->channel[c].scale_factors, s->num_bands *
927 sizeof(*s->channel[c].saved_scale_factors));
928 s->channel[c].table_idx = s->table_idx;
929 s->channel[c].reuse_sf = 1;
932 /** calculate new scale factor maximum */
933 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
934 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
935 s->channel[c].max_scale_factor =
936 FFMAX(s->channel[c].max_scale_factor, *sf);
944 *@brief Reconstruct the individual channel data.
945 *@param s codec context
947 static void inverse_channel_transform(WMAProDecodeCtx *s)
951 for (i = 0; i < s->num_chgroups; i++) {
952 if (s->chgroup[i].transform) {
953 float data[WMAPRO_MAX_CHANNELS];
954 const int num_channels = s->chgroup[i].num_channels;
955 float** ch_data = s->chgroup[i].channel_data;
956 float** ch_end = ch_data + num_channels;
957 const int8_t* tb = s->chgroup[i].transform_band;
960 /** multichannel decorrelation */
961 for (sfb = s->cur_sfb_offsets;
962 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
965 /** multiply values with the decorrelation_matrix */
966 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
967 const float* mat = s->chgroup[i].decorrelation_matrix;
968 const float* data_end = data + num_channels;
969 float* data_ptr = data;
972 for (ch = ch_data; ch < ch_end; ch++)
973 *data_ptr++ = (*ch)[y];
975 for (ch = ch_data; ch < ch_end; ch++) {
978 while (data_ptr < data_end)
979 sum += *data_ptr++ * *mat++;
984 } else if (s->num_channels == 2) {
985 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
986 ch_data[0][y] *= 181.0 / 128;
987 ch_data[1][y] *= 181.0 / 128;
996 *@brief Apply sine window and reconstruct the output buffer.
997 *@param s codec context
999 static void wmapro_window(WMAProDecodeCtx *s)
1002 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1003 int c = s->channel_indexes_for_cur_subframe[i];
1005 int winlen = s->channel[c].prev_block_len;
1006 float* start = s->channel[c].coeffs - (winlen >> 1);
1008 if (s->subframe_len < winlen) {
1009 start += (winlen - s->subframe_len) >> 1;
1010 winlen = s->subframe_len;
1013 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1017 s->dsp.vector_fmul_window(start, start, start + winlen,
1020 s->channel[c].prev_block_len = s->subframe_len;
1025 *@brief Decode a single subframe (block).
1026 *@param s codec context
1027 *@return 0 on success, < 0 when decoding failed
1029 static int decode_subframe(WMAProDecodeCtx *s)
1031 int offset = s->samples_per_frame;
1032 int subframe_len = s->samples_per_frame;
1034 int total_samples = s->samples_per_frame * s->num_channels;
1035 int transmit_coeffs = 0;
1036 int cur_subwoofer_cutoff;
1038 s->subframe_offset = get_bits_count(&s->gb);
1040 /** reset channel context and find the next block offset and size
1041 == the next block of the channel with the smallest number of
1044 for (i = 0; i < s->num_channels; i++) {
1045 s->channel[i].grouped = 0;
1046 if (offset > s->channel[i].decoded_samples) {
1047 offset = s->channel[i].decoded_samples;
1049 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1054 "processing subframe with offset %i len %i\n", offset, subframe_len);
1056 /** get a list of all channels that contain the estimated block */
1057 s->channels_for_cur_subframe = 0;
1058 for (i = 0; i < s->num_channels; i++) {
1059 const int cur_subframe = s->channel[i].cur_subframe;
1060 /** substract already processed samples */
1061 total_samples -= s->channel[i].decoded_samples;
1063 /** and count if there are multiple subframes that match our profile */
1064 if (offset == s->channel[i].decoded_samples &&
1065 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1066 total_samples -= s->channel[i].subframe_len[cur_subframe];
1067 s->channel[i].decoded_samples +=
1068 s->channel[i].subframe_len[cur_subframe];
1069 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1070 ++s->channels_for_cur_subframe;
1074 /** check if the frame will be complete after processing the
1077 s->parsed_all_subframes = 1;
1080 dprintf(s->avctx, "subframe is part of %i channels\n",
1081 s->channels_for_cur_subframe);
1083 /** calculate number of scale factor bands and their offsets */
1084 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1085 s->num_bands = s->num_sfb[s->table_idx];
1086 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1087 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1089 /** configure the decoder for the current subframe */
1090 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1091 int c = s->channel_indexes_for_cur_subframe[i];
1093 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1097 s->subframe_len = subframe_len;
1098 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1100 /** skip extended header if any */
1101 if (get_bits1(&s->gb)) {
1103 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1104 int len = get_bits(&s->gb, 4);
1105 num_fill_bits = get_bits(&s->gb, len) + 1;
1108 if (num_fill_bits >= 0) {
1109 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1110 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1111 return AVERROR_INVALIDDATA;
1114 skip_bits_long(&s->gb, num_fill_bits);
1118 /** no idea for what the following bit is used */
1119 if (get_bits1(&s->gb)) {
1120 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1121 return AVERROR_INVALIDDATA;
1125 if (decode_channel_transform(s) < 0)
1126 return AVERROR_INVALIDDATA;
1129 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1130 int c = s->channel_indexes_for_cur_subframe[i];
1131 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1132 transmit_coeffs = 1;
1135 if (transmit_coeffs) {
1137 int quant_step = 90 * s->bits_per_sample >> 4;
1138 if ((get_bits1(&s->gb))) {
1139 /** FIXME: might change run level mode decision */
1140 av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1141 return AVERROR_INVALIDDATA;
1143 /** decode quantization step */
1144 step = get_sbits(&s->gb, 6);
1146 if (step == -32 || step == 31) {
1147 const int sign = (step == 31) - 1;
1149 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1150 (step = get_bits(&s->gb, 5)) == 31) {
1153 quant_step += ((quant + step) ^ sign) - sign;
1155 if (quant_step < 0) {
1156 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1159 /** decode quantization step modifiers for every channel */
1161 if (s->channels_for_cur_subframe == 1) {
1162 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1164 int modifier_len = get_bits(&s->gb, 3);
1165 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1166 int c = s->channel_indexes_for_cur_subframe[i];
1167 s->channel[c].quant_step = quant_step;
1168 if (get_bits1(&s->gb)) {
1170 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1172 ++s->channel[c].quant_step;
1177 /** decode scale factors */
1178 if (decode_scale_factors(s) < 0)
1179 return AVERROR_INVALIDDATA;
1182 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1183 get_bits_count(&s->gb) - s->subframe_offset);
1185 /** parse coefficients */
1186 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1187 int c = s->channel_indexes_for_cur_subframe[i];
1188 if (s->channel[c].transmit_coefs &&
1189 get_bits_count(&s->gb) < s->num_saved_bits) {
1190 decode_coeffs(s, c);
1192 memset(s->channel[c].coeffs, 0,
1193 sizeof(*s->channel[c].coeffs) * subframe_len);
1196 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1197 get_bits_count(&s->gb) - s->subframe_offset);
1199 if (transmit_coeffs) {
1200 /** reconstruct the per channel data */
1201 inverse_channel_transform(s);
1202 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1203 int c = s->channel_indexes_for_cur_subframe[i];
1204 const int* sf = s->channel[c].scale_factors;
1207 if (c == s->lfe_channel)
1208 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1209 (subframe_len - cur_subwoofer_cutoff));
1211 /** inverse quantization and rescaling */
1212 for (b = 0; b < s->num_bands; b++) {
1213 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1214 const int exp = s->channel[c].quant_step -
1215 (s->channel[c].max_scale_factor - *sf++) *
1216 s->channel[c].scale_factor_step;
1217 const float quant = pow(10.0, exp / 20.0);
1220 for (start = s->cur_sfb_offsets[b]; start < end; start++)
1221 s->tmp[start] = s->channel[c].coeffs[start] * quant;
1224 /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1225 ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS],
1226 s->channel[c].coeffs, s->tmp);
1230 /** window and overlapp-add */
1233 /** handled one subframe */
1234 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1235 int c = s->channel_indexes_for_cur_subframe[i];
1236 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1237 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1238 return AVERROR_INVALIDDATA;
1240 ++s->channel[c].cur_subframe;
1247 *@brief Decode one WMA frame.
1248 *@param s codec context
1249 *@return 0 if the trailer bit indicates that this is the last frame,
1250 * 1 if there are additional frames
1252 static int decode_frame(WMAProDecodeCtx *s)
1254 GetBitContext* gb = &s->gb;
1255 int more_frames = 0;
1259 /** check for potential output buffer overflow */
1260 if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1261 /** return an error if no frame could be decoded at all */
1262 if (s->samples_start == s->samples) {
1263 av_log(s->avctx, AV_LOG_ERROR,
1264 "not enough space for the output samples\n");
1267 s->output_buffer_full = 1;
1271 /** get frame length */
1273 len = get_bits(gb, s->log2_frame_size);
1275 dprintf(s->avctx, "decoding frame with length %x\n", len);
1277 /** decode tile information */
1278 if (decode_tilehdr(s)) {
1283 /** read postproc transform */
1284 if (s->num_channels > 1 && get_bits1(gb)) {
1285 av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1290 /** read drc info */
1291 if (s->dynamic_range_compression) {
1292 s->drc_gain = get_bits(gb, 8);
1293 dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1296 /** no idea what these are for, might be the number of samples
1297 that need to be skipped at the beginning or end of a stream */
1298 if (get_bits1(gb)) {
1301 /** usually true for the first frame */
1302 if (get_bits1(gb)) {
1303 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1304 dprintf(s->avctx, "start skip: %i\n", skip);
1307 /** sometimes true for the last frame */
1308 if (get_bits1(gb)) {
1309 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1310 dprintf(s->avctx, "end skip: %i\n", skip);
1315 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1316 get_bits_count(gb) - s->frame_offset);
1318 /** reset subframe states */
1319 s->parsed_all_subframes = 0;
1320 for (i = 0; i < s->num_channels; i++) {
1321 s->channel[i].decoded_samples = 0;
1322 s->channel[i].cur_subframe = 0;
1323 s->channel[i].reuse_sf = 0;
1326 /** decode all subframes */
1327 while (!s->parsed_all_subframes) {
1328 if (decode_subframe(s) < 0) {
1334 /** interleave samples and write them to the output buffer */
1335 for (i = 0; i < s->num_channels; i++) {
1337 int incr = s->num_channels;
1338 float* iptr = s->channel[i].out;
1341 ptr = s->samples + i;
1343 for (x = 0; x < s->samples_per_frame; x++) {
1344 *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1348 /** reuse second half of the IMDCT output for the next frame */
1349 memcpy(&s->channel[i].out[0],
1350 &s->channel[i].out[s->samples_per_frame],
1351 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1354 if (s->skip_frame) {
1357 s->samples += s->num_channels * s->samples_per_frame;
1359 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1360 /** FIXME: not sure if this is always an error */
1361 av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n",
1362 s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1367 /** skip the rest of the frame data */
1368 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1370 /** decode trailer bit */
1371 more_frames = get_bits1(gb);
1378 *@brief Calculate remaining input buffer length.
1379 *@param s codec context
1380 *@param gb bitstream reader context
1381 *@return remaining size in bits
1383 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1385 return s->buf_bit_size - get_bits_count(gb);
1389 *@brief Fill the bit reservoir with a (partial) frame.
1390 *@param s codec context
1391 *@param gb bitstream reader context
1392 *@param len length of the partial frame
1393 *@param append decides wether to reset the buffer or not
1395 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1400 /** when the frame data does not need to be concatenated, the input buffer
1401 is resetted and additional bits from the previous frame are copyed
1402 and skipped later so that a fast byte copy is possible */
1405 s->frame_offset = get_bits_count(gb) & 7;
1406 s->num_saved_bits = s->frame_offset;
1407 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1410 buflen = (s->num_saved_bits + len + 8) >> 3;
1412 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1413 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1418 s->num_saved_bits += len;
1420 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1423 int align = 8 - (get_bits_count(gb) & 7);
1424 align = FFMIN(align, len);
1425 put_bits(&s->pb, align, get_bits(gb, align));
1427 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1429 skip_bits_long(gb, len);
1432 PutBitContext tmp = s->pb;
1433 flush_put_bits(&tmp);
1436 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1437 skip_bits(&s->gb, s->frame_offset);
1441 *@brief Decode a single WMA packet.
1442 *@param avctx codec context
1443 *@param data the output buffer
1444 *@param data_size number of bytes that were written to the output buffer
1445 *@param avpkt input packet
1446 *@return number of bytes that were read from the input buffer
1448 static int decode_packet(AVCodecContext *avctx,
1449 void *data, int *data_size, AVPacket* avpkt)
1451 WMAProDecodeCtx *s = avctx->priv_data;
1452 GetBitContext* gb = &s->pgb;
1453 const uint8_t* buf = avpkt->data;
1454 int buf_size = avpkt->size;
1455 int more_frames = 1;
1456 int num_bits_prev_frame;
1457 int packet_sequence_number;
1460 s->samples_start = data;
1461 s->samples_end = (float*)((int8_t*)data + *data_size);
1464 if (!s->output_buffer_full) {
1465 s->buf_bit_size = buf_size << 3;
1467 /** sanity check for the buffer length */
1468 if (buf_size < avctx->block_align)
1471 buf_size = avctx->block_align;
1473 /** parse packet header */
1474 init_get_bits(gb, buf, s->buf_bit_size);
1475 packet_sequence_number = get_bits(gb, 4);
1478 /** get number of bits that need to be added to the previous frame */
1479 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1480 dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1481 num_bits_prev_frame);
1483 /** check for packet loss */
1484 if (!s->packet_loss &&
1485 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1487 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1488 s->packet_sequence_number, packet_sequence_number);
1490 s->packet_sequence_number = packet_sequence_number;
1492 if (num_bits_prev_frame > 0) {
1493 /** append the previous frame data to the remaining data from the
1494 previous packet to create a full frame */
1495 save_bits(s, gb, num_bits_prev_frame, 1);
1496 dprintf(avctx, "accumulated %x bits of frame data\n",
1497 s->num_saved_bits - s->frame_offset);
1499 /** decode the cross packet frame if it is valid */
1500 if (!s->packet_loss)
1502 } else if (s->num_saved_bits - s->frame_offset) {
1503 dprintf(avctx, "ignoring %x previously saved bits\n",
1504 s->num_saved_bits - s->frame_offset);
1510 /** continue decoding */
1511 s->output_buffer_full = 0;
1512 more_frames = decode_frame(s);
1515 /** decode the rest of the packet */
1516 while (!s->packet_loss && !s->output_buffer_full && more_frames &&
1517 remaining_bits(s, gb) > s->log2_frame_size) {
1518 int frame_size = show_bits(gb, s->log2_frame_size);
1520 /** there is enough data for a full frame */
1521 if (remaining_bits(s, gb) >= frame_size && frame_size > 0) {
1522 save_bits(s, gb, frame_size, 0);
1524 /** decode the frame */
1525 more_frames = decode_frame(s);
1531 if (!s->output_buffer_full && !s->packet_loss &&
1532 remaining_bits(s, gb) > 0) {
1533 /** save the rest of the data so that it can be decoded
1534 with the next packet */
1535 save_bits(s, gb, remaining_bits(s, gb), 0);
1538 *data_size = (int8_t *)s->samples - (int8_t *)data;
1540 return (s->output_buffer_full)?0: avctx->block_align;
1544 *@brief Clear decoder buffers (for seeking).
1545 *@param avctx codec context
1547 static void flush(AVCodecContext *avctx)
1549 WMAProDecodeCtx *s = avctx->priv_data;
1551 /** reset output buffer as a part of it is used during the windowing of a
1553 for (i = 0; i < s->num_channels; i++)
1554 memset(s->channel[i].out, 0, s->samples_per_frame *
1555 sizeof(*s->channel[i].out));
1561 *@brief wmapro decoder
1563 AVCodec wmapro_decoder = {
1567 sizeof(WMAProDecodeCtx),
1573 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),