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 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 || s->num_channels > WMAPRO_MAX_CHANNELS) {
347 av_log_ask_for_sample(avctx, "invalid number of channels\n");
348 return AVERROR_NOTSUPP;
351 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
352 scale_huffbits, 1, 1,
353 scale_huffcodes, 2, 2, 616);
355 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
356 scale_rl_huffbits, 1, 1,
357 scale_rl_huffcodes, 4, 4, 1406);
359 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
360 coef0_huffbits, 1, 1,
361 coef0_huffcodes, 4, 4, 2108);
363 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
364 coef1_huffbits, 1, 1,
365 coef1_huffcodes, 4, 4, 3912);
367 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
369 vec4_huffcodes, 2, 2, 604);
371 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
373 vec2_huffcodes, 2, 2, 562);
375 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
377 vec1_huffcodes, 2, 2, 562);
379 /** calculate number of scale factor bands and their offsets
380 for every possible block size */
381 for (i = 0; i < num_possible_block_sizes; i++) {
382 int subframe_len = s->samples_per_frame >> i;
386 s->sfb_offsets[i][0] = 0;
388 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
389 int offset = (subframe_len * 2 * critical_freq[x])
390 / s->avctx->sample_rate + 2;
392 if (offset > s->sfb_offsets[i][band - 1])
393 s->sfb_offsets[i][band++] = offset;
395 s->sfb_offsets[i][band - 1] = subframe_len;
396 s->num_sfb[i] = band - 1;
400 /** Scale factors can be shared between blocks of different size
401 as every block has a different scale factor band layout.
402 The matrix sf_offsets is needed to find the correct scale factor.
405 for (i = 0; i < num_possible_block_sizes; i++) {
407 for (b = 0; b < s->num_sfb[i]; b++) {
409 int offset = ((s->sfb_offsets[i][b]
410 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
411 for (x = 0; x < num_possible_block_sizes; x++) {
413 while (s->sfb_offsets[x][v + 1] << x < offset)
415 s->sf_offsets[i][x][b] = v;
420 /** init MDCT, FIXME: only init needed sizes */
421 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
422 ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1,
423 1.0 / (1 << (BLOCK_MIN_BITS + i - 1))
424 / (1 << (s->bits_per_sample - 1)));
426 /** init MDCT windows: simple sinus window */
427 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
428 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
429 ff_init_ff_sine_windows(win_idx);
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)
764 /* Integers 0..15 as single-precision floats. The table saves a
765 costly int to float conversion, and storing the values as
766 integers allows fast sign-flipping. */
767 static const int fval_tab[16] = {
768 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
769 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
770 0x41000000, 0x41100000, 0x41200000, 0x41300000,
771 0x41400000, 0x41500000, 0x41600000, 0x41700000,
775 WMAProChannelCtx* ci = &s->channel[c];
782 dprintf(s->avctx, "decode coefficients for channel %i\n", c);
784 vlctable = get_bits1(&s->gb);
785 vlc = &coef_vlc[vlctable];
795 /** decode vector coefficients (consumes up to 167 bits per iteration for
796 4 vector coded large values) */
797 while (!rl_mode && cur_coeff + 3 < s->subframe_len) {
802 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
804 if (idx == HUFF_VEC4_SIZE - 1) {
805 for (i = 0; i < 4; i += 2) {
806 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
807 if (idx == HUFF_VEC2_SIZE - 1) {
809 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
810 if (v0 == HUFF_VEC1_SIZE - 1)
811 v0 += ff_wma_get_large_val(&s->gb);
812 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
813 if (v1 == HUFF_VEC1_SIZE - 1)
814 v1 += ff_wma_get_large_val(&s->gb);
815 ((float*)vals)[i ] = v0;
816 ((float*)vals)[i+1] = v1;
818 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
819 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
823 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
824 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
825 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
826 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
830 for (i = 0; i < 4; i++) {
832 int sign = get_bits1(&s->gb) - 1;
833 *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31;
836 ci->coeffs[cur_coeff] = 0;
837 /** switch to run level mode when subframe_len / 128 zeros
838 were found in a row */
839 rl_mode |= (++num_zeros > s->subframe_len >> 8);
845 /** decode run level coded coefficients */
847 memset(&ci->coeffs[cur_coeff], 0,
848 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
849 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
850 level, run, 1, ci->coeffs,
851 cur_coeff, s->subframe_len,
852 s->subframe_len, s->esc_len, 0))
853 return AVERROR_INVALIDDATA;
860 *@brief Extract scale factors from the bitstream.
861 *@param s codec context
862 *@return 0 on success, < 0 in case of bitstream errors
864 static int decode_scale_factors(WMAProDecodeCtx* s)
868 /** should never consume more than 5344 bits
869 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
872 for (i = 0; i < s->channels_for_cur_subframe; i++) {
873 int c = s->channel_indexes_for_cur_subframe[i];
876 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
877 sf_end = s->channel[c].scale_factors + s->num_bands;
879 /** resample scale factors for the new block size
880 * as the scale factors might need to be resampled several times
881 * before some new values are transmitted, a backup of the last
882 * transmitted scale factors is kept in saved_scale_factors
884 if (s->channel[c].reuse_sf) {
885 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
887 for (b = 0; b < s->num_bands; b++)
888 s->channel[c].scale_factors[b] =
889 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
892 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
894 if (!s->channel[c].reuse_sf) {
896 /** decode DPCM coded scale factors */
897 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
898 val = 45 / s->channel[c].scale_factor_step;
899 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
900 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
905 /** run level decode differences to the resampled factors */
906 for (i = 0; i < s->num_bands; i++) {
912 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
915 uint32_t code = get_bits(&s->gb, 14);
917 sign = (code & 1) - 1;
918 skip = (code & 0x3f) >> 1;
919 } else if (idx == 1) {
922 skip = scale_rl_run[idx];
923 val = scale_rl_level[idx];
924 sign = get_bits1(&s->gb)-1;
928 if (i >= s->num_bands) {
929 av_log(s->avctx, AV_LOG_ERROR,
930 "invalid scale factor coding\n");
931 return AVERROR_INVALIDDATA;
933 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
937 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
938 s->channel[c].table_idx = s->table_idx;
939 s->channel[c].reuse_sf = 1;
942 /** calculate new scale factor maximum */
943 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
944 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
945 s->channel[c].max_scale_factor =
946 FFMAX(s->channel[c].max_scale_factor, *sf);
954 *@brief Reconstruct the individual channel data.
955 *@param s codec context
957 static void inverse_channel_transform(WMAProDecodeCtx *s)
961 for (i = 0; i < s->num_chgroups; i++) {
962 if (s->chgroup[i].transform) {
963 float data[WMAPRO_MAX_CHANNELS];
964 const int num_channels = s->chgroup[i].num_channels;
965 float** ch_data = s->chgroup[i].channel_data;
966 float** ch_end = ch_data + num_channels;
967 const int8_t* tb = s->chgroup[i].transform_band;
970 /** multichannel decorrelation */
971 for (sfb = s->cur_sfb_offsets;
972 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
975 /** multiply values with the decorrelation_matrix */
976 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
977 const float* mat = s->chgroup[i].decorrelation_matrix;
978 const float* data_end = data + num_channels;
979 float* data_ptr = data;
982 for (ch = ch_data; ch < ch_end; ch++)
983 *data_ptr++ = (*ch)[y];
985 for (ch = ch_data; ch < ch_end; ch++) {
988 while (data_ptr < data_end)
989 sum += *data_ptr++ * *mat++;
994 } else if (s->num_channels == 2) {
995 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
996 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
999 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1000 ch_data[1] + sfb[0],
1009 *@brief Apply sine window and reconstruct the output buffer.
1010 *@param s codec context
1012 static void wmapro_window(WMAProDecodeCtx *s)
1015 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1016 int c = s->channel_indexes_for_cur_subframe[i];
1018 int winlen = s->channel[c].prev_block_len;
1019 float* start = s->channel[c].coeffs - (winlen >> 1);
1021 if (s->subframe_len < winlen) {
1022 start += (winlen - s->subframe_len) >> 1;
1023 winlen = s->subframe_len;
1026 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1030 s->dsp.vector_fmul_window(start, start, start + winlen,
1033 s->channel[c].prev_block_len = s->subframe_len;
1038 *@brief Decode a single subframe (block).
1039 *@param s codec context
1040 *@return 0 on success, < 0 when decoding failed
1042 static int decode_subframe(WMAProDecodeCtx *s)
1044 int offset = s->samples_per_frame;
1045 int subframe_len = s->samples_per_frame;
1047 int total_samples = s->samples_per_frame * s->num_channels;
1048 int transmit_coeffs = 0;
1049 int cur_subwoofer_cutoff;
1051 s->subframe_offset = get_bits_count(&s->gb);
1053 /** reset channel context and find the next block offset and size
1054 == the next block of the channel with the smallest number of
1057 for (i = 0; i < s->num_channels; i++) {
1058 s->channel[i].grouped = 0;
1059 if (offset > s->channel[i].decoded_samples) {
1060 offset = s->channel[i].decoded_samples;
1062 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1067 "processing subframe with offset %i len %i\n", offset, subframe_len);
1069 /** get a list of all channels that contain the estimated block */
1070 s->channels_for_cur_subframe = 0;
1071 for (i = 0; i < s->num_channels; i++) {
1072 const int cur_subframe = s->channel[i].cur_subframe;
1073 /** substract already processed samples */
1074 total_samples -= s->channel[i].decoded_samples;
1076 /** and count if there are multiple subframes that match our profile */
1077 if (offset == s->channel[i].decoded_samples &&
1078 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1079 total_samples -= s->channel[i].subframe_len[cur_subframe];
1080 s->channel[i].decoded_samples +=
1081 s->channel[i].subframe_len[cur_subframe];
1082 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1083 ++s->channels_for_cur_subframe;
1087 /** check if the frame will be complete after processing the
1090 s->parsed_all_subframes = 1;
1093 dprintf(s->avctx, "subframe is part of %i channels\n",
1094 s->channels_for_cur_subframe);
1096 /** calculate number of scale factor bands and their offsets */
1097 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1098 s->num_bands = s->num_sfb[s->table_idx];
1099 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1100 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1102 /** configure the decoder for the current subframe */
1103 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1104 int c = s->channel_indexes_for_cur_subframe[i];
1106 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1110 s->subframe_len = subframe_len;
1111 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1113 /** skip extended header if any */
1114 if (get_bits1(&s->gb)) {
1116 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1117 int len = get_bits(&s->gb, 4);
1118 num_fill_bits = get_bits(&s->gb, len) + 1;
1121 if (num_fill_bits >= 0) {
1122 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1123 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1124 return AVERROR_INVALIDDATA;
1127 skip_bits_long(&s->gb, num_fill_bits);
1131 /** no idea for what the following bit is used */
1132 if (get_bits1(&s->gb)) {
1133 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1134 return AVERROR_INVALIDDATA;
1138 if (decode_channel_transform(s) < 0)
1139 return AVERROR_INVALIDDATA;
1142 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1143 int c = s->channel_indexes_for_cur_subframe[i];
1144 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1145 transmit_coeffs = 1;
1148 if (transmit_coeffs) {
1150 int quant_step = 90 * s->bits_per_sample >> 4;
1151 if ((get_bits1(&s->gb))) {
1152 /** FIXME: might change run level mode decision */
1153 av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1154 return AVERROR_INVALIDDATA;
1156 /** decode quantization step */
1157 step = get_sbits(&s->gb, 6);
1159 if (step == -32 || step == 31) {
1160 const int sign = (step == 31) - 1;
1162 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1163 (step = get_bits(&s->gb, 5)) == 31) {
1166 quant_step += ((quant + step) ^ sign) - sign;
1168 if (quant_step < 0) {
1169 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1172 /** decode quantization step modifiers for every channel */
1174 if (s->channels_for_cur_subframe == 1) {
1175 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1177 int modifier_len = get_bits(&s->gb, 3);
1178 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1179 int c = s->channel_indexes_for_cur_subframe[i];
1180 s->channel[c].quant_step = quant_step;
1181 if (get_bits1(&s->gb)) {
1183 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1185 ++s->channel[c].quant_step;
1190 /** decode scale factors */
1191 if (decode_scale_factors(s) < 0)
1192 return AVERROR_INVALIDDATA;
1195 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1196 get_bits_count(&s->gb) - s->subframe_offset);
1198 /** parse coefficients */
1199 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1200 int c = s->channel_indexes_for_cur_subframe[i];
1201 if (s->channel[c].transmit_coefs &&
1202 get_bits_count(&s->gb) < s->num_saved_bits) {
1203 decode_coeffs(s, c);
1205 memset(s->channel[c].coeffs, 0,
1206 sizeof(*s->channel[c].coeffs) * subframe_len);
1209 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1210 get_bits_count(&s->gb) - s->subframe_offset);
1212 if (transmit_coeffs) {
1213 /** reconstruct the per channel data */
1214 inverse_channel_transform(s);
1215 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1216 int c = s->channel_indexes_for_cur_subframe[i];
1217 const int* sf = s->channel[c].scale_factors;
1220 if (c == s->lfe_channel)
1221 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1222 (subframe_len - cur_subwoofer_cutoff));
1224 /** inverse quantization and rescaling */
1225 for (b = 0; b < s->num_bands; b++) {
1226 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1227 const int exp = s->channel[c].quant_step -
1228 (s->channel[c].max_scale_factor - *sf++) *
1229 s->channel[c].scale_factor_step;
1230 const float quant = pow(10.0, exp / 20.0);
1231 int start = s->cur_sfb_offsets[b];
1232 s->dsp.vector_fmul_scalar(s->tmp + start,
1233 s->channel[c].coeffs + start,
1234 quant, end - start);
1237 /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1238 ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS],
1239 s->channel[c].coeffs, s->tmp);
1243 /** window and overlapp-add */
1246 /** handled one subframe */
1247 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1248 int c = s->channel_indexes_for_cur_subframe[i];
1249 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1250 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1251 return AVERROR_INVALIDDATA;
1253 ++s->channel[c].cur_subframe;
1260 *@brief Decode one WMA frame.
1261 *@param s codec context
1262 *@return 0 if the trailer bit indicates that this is the last frame,
1263 * 1 if there are additional frames
1265 static int decode_frame(WMAProDecodeCtx *s)
1267 GetBitContext* gb = &s->gb;
1268 int more_frames = 0;
1272 /** check for potential output buffer overflow */
1273 if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1274 /** return an error if no frame could be decoded at all */
1275 av_log(s->avctx, AV_LOG_ERROR,
1276 "not enough space for the output samples\n");
1281 /** get frame length */
1283 len = get_bits(gb, s->log2_frame_size);
1285 dprintf(s->avctx, "decoding frame with length %x\n", len);
1287 /** decode tile information */
1288 if (decode_tilehdr(s)) {
1293 /** read postproc transform */
1294 if (s->num_channels > 1 && get_bits1(gb)) {
1295 av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1300 /** read drc info */
1301 if (s->dynamic_range_compression) {
1302 s->drc_gain = get_bits(gb, 8);
1303 dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1306 /** no idea what these are for, might be the number of samples
1307 that need to be skipped at the beginning or end of a stream */
1308 if (get_bits1(gb)) {
1311 /** usually true for the first frame */
1312 if (get_bits1(gb)) {
1313 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1314 dprintf(s->avctx, "start skip: %i\n", skip);
1317 /** sometimes true for the last frame */
1318 if (get_bits1(gb)) {
1319 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1320 dprintf(s->avctx, "end skip: %i\n", skip);
1325 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1326 get_bits_count(gb) - s->frame_offset);
1328 /** reset subframe states */
1329 s->parsed_all_subframes = 0;
1330 for (i = 0; i < s->num_channels; i++) {
1331 s->channel[i].decoded_samples = 0;
1332 s->channel[i].cur_subframe = 0;
1333 s->channel[i].reuse_sf = 0;
1336 /** decode all subframes */
1337 while (!s->parsed_all_subframes) {
1338 if (decode_subframe(s) < 0) {
1344 /** interleave samples and write them to the output buffer */
1345 for (i = 0; i < s->num_channels; i++) {
1347 int incr = s->num_channels;
1348 float* iptr = s->channel[i].out;
1351 ptr = s->samples + i;
1353 for (x = 0; x < s->samples_per_frame; x++) {
1354 *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1358 /** reuse second half of the IMDCT output for the next frame */
1359 memcpy(&s->channel[i].out[0],
1360 &s->channel[i].out[s->samples_per_frame],
1361 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1364 if (s->skip_frame) {
1367 s->samples += s->num_channels * s->samples_per_frame;
1369 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1370 /** FIXME: not sure if this is always an error */
1371 av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n",
1372 s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1377 /** skip the rest of the frame data */
1378 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1380 /** decode trailer bit */
1381 more_frames = get_bits1(gb);
1388 *@brief Calculate remaining input buffer length.
1389 *@param s codec context
1390 *@param gb bitstream reader context
1391 *@return remaining size in bits
1393 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1395 return s->buf_bit_size - get_bits_count(gb);
1399 *@brief Fill the bit reservoir with a (partial) frame.
1400 *@param s codec context
1401 *@param gb bitstream reader context
1402 *@param len length of the partial frame
1403 *@param append decides wether to reset the buffer or not
1405 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1410 /** when the frame data does not need to be concatenated, the input buffer
1411 is resetted and additional bits from the previous frame are copyed
1412 and skipped later so that a fast byte copy is possible */
1415 s->frame_offset = get_bits_count(gb) & 7;
1416 s->num_saved_bits = s->frame_offset;
1417 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1420 buflen = (s->num_saved_bits + len + 8) >> 3;
1422 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1423 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1428 s->num_saved_bits += len;
1430 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1433 int align = 8 - (get_bits_count(gb) & 7);
1434 align = FFMIN(align, len);
1435 put_bits(&s->pb, align, get_bits(gb, align));
1437 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1439 skip_bits_long(gb, len);
1442 PutBitContext tmp = s->pb;
1443 flush_put_bits(&tmp);
1446 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1447 skip_bits(&s->gb, s->frame_offset);
1451 *@brief Decode a single WMA packet.
1452 *@param avctx codec context
1453 *@param data the output buffer
1454 *@param data_size number of bytes that were written to the output buffer
1455 *@param avpkt input packet
1456 *@return number of bytes that were read from the input buffer
1458 static int decode_packet(AVCodecContext *avctx,
1459 void *data, int *data_size, AVPacket* avpkt)
1461 WMAProDecodeCtx *s = avctx->priv_data;
1462 GetBitContext* gb = &s->pgb;
1463 const uint8_t* buf = avpkt->data;
1464 int buf_size = avpkt->size;
1465 int num_bits_prev_frame;
1466 int packet_sequence_number;
1469 s->samples_end = (float*)((int8_t*)data + *data_size);
1472 if (s->packet_done || s->packet_loss) {
1474 s->buf_bit_size = buf_size << 3;
1476 /** sanity check for the buffer length */
1477 if (buf_size < avctx->block_align)
1480 buf_size = avctx->block_align;
1482 /** parse packet header */
1483 init_get_bits(gb, buf, s->buf_bit_size);
1484 packet_sequence_number = get_bits(gb, 4);
1487 /** get number of bits that need to be added to the previous frame */
1488 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1489 dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1490 num_bits_prev_frame);
1492 /** check for packet loss */
1493 if (!s->packet_loss &&
1494 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1496 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1497 s->packet_sequence_number, packet_sequence_number);
1499 s->packet_sequence_number = packet_sequence_number;
1501 if (num_bits_prev_frame > 0) {
1502 /** append the previous frame data to the remaining data from the
1503 previous packet to create a full frame */
1504 save_bits(s, gb, num_bits_prev_frame, 1);
1505 dprintf(avctx, "accumulated %x bits of frame data\n",
1506 s->num_saved_bits - s->frame_offset);
1508 /** decode the cross packet frame if it is valid */
1509 if (!s->packet_loss)
1511 } else if (s->num_saved_bits - s->frame_offset) {
1512 dprintf(avctx, "ignoring %x previously saved bits\n",
1513 s->num_saved_bits - s->frame_offset);
1520 s->buf_bit_size = avpkt->size << 3;
1521 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1522 skip_bits(gb, s->packet_offset);
1523 if (remaining_bits(s, gb) > s->log2_frame_size &&
1524 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1525 frame_size <= remaining_bits(s, gb)) {
1526 save_bits(s, gb, frame_size, 0);
1527 s->packet_done = !decode_frame(s);
1532 if (s->packet_done && !s->packet_loss &&
1533 remaining_bits(s, gb) > 0) {
1534 /** save the rest of the data so that it can be decoded
1535 with the next packet */
1536 save_bits(s, gb, remaining_bits(s, gb), 0);
1539 *data_size = (int8_t *)s->samples - (int8_t *)data;
1540 s->packet_offset = get_bits_count(gb) & 7;
1542 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1546 *@brief Clear decoder buffers (for seeking).
1547 *@param avctx codec context
1549 static void flush(AVCodecContext *avctx)
1551 WMAProDecodeCtx *s = avctx->priv_data;
1553 /** reset output buffer as a part of it is used during the windowing of a
1555 for (i = 0; i < s->num_channels; i++)
1556 memset(s->channel[i].out, 0, s->samples_per_frame *
1557 sizeof(*s->channel[i].out));
1563 *@brief wmapro decoder
1565 AVCodec wmapro_decoder = {
1569 sizeof(WMAProDecodeCtx),
1574 .capabilities = CODEC_CAP_SUBFRAMES,
1576 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),