2 * Wmapro compatible decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * @brief wmapro decoder implementation
26 * Wmapro is an MDCT based codec comparable to wma standard or AAC.
27 * The decoding therefore consists of the following steps:
28 * - bitstream decoding
29 * - reconstruction of per-channel data
30 * - rescaling and inverse quantization
32 * - windowing and overlapp-add
34 * The compressed wmapro bitstream is split into individual packets.
35 * Every such packet contains one or more wma frames.
36 * The compressed frames may have a variable length and frames may
37 * cross packet boundaries.
38 * Common to all wmapro frames is the number of samples that are stored in
40 * The number of samples and a few other decode flags are stored
41 * as extradata that has to be passed to the decoder.
43 * The wmapro frames themselves are again split into a variable number of
44 * subframes. Every subframe contains the data for 2^N time domain samples
45 * where N varies between 7 and 12.
47 * Example wmapro bitstream (in samples):
49 * || packet 0 || packet 1 || packet 2 packets
50 * ---------------------------------------------------
51 * || frame 0 || frame 1 || frame 2 || frames
52 * ---------------------------------------------------
53 * || | | || | | | || || subframes of channel 0
54 * ---------------------------------------------------
55 * || | | || | | | || || subframes of channel 1
56 * ---------------------------------------------------
58 * The frame layouts for the individual channels of a wma frame does not need
61 * However, if the offsets and lengths of several subframes of a frame are the
62 * same, the subframes of the channels can be grouped.
63 * Every group may then use special coding techniques like M/S stereo coding
64 * to improve the compression ratio. These channel transformations do not
65 * need to be applied to a whole subframe. Instead, they can also work on
66 * individual scale factor bands (see below).
67 * The coefficients that carry the audio signal in the frequency domain
68 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
69 * In addition to that, the encoder can switch to a runlevel coding scheme
70 * by transmitting subframe_length / 128 zero coefficients.
72 * Before the audio signal can be converted to the time domain, the
73 * coefficients have to be rescaled and inverse quantized.
74 * A subframe is therefore split into several scale factor bands that get
75 * scaled individually.
76 * Scale factors are submitted for every frame but they might be shared
77 * between the subframes of a channel. Scale factors are initially DPCM-coded.
78 * Once scale factors are shared, the differences are transmitted as runlevel
80 * Every subframe length and offset combination in the frame layout shares a
81 * common quantization factor that can be adjusted for every channel by a
83 * After the inverse quantization, the coefficients get processed by an IMDCT.
84 * The resulting values are then windowed with a sine window and the first half
85 * of the values are added to the second half of the output from the previous
86 * subframe in order to reconstruct the output samples.
89 #include "libavutil/intfloat.h"
90 #include "libavutil/intreadwrite.h"
95 #include "wmaprodata.h"
99 #include "wma_common.h"
101 /** current decoder limitations */
102 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels
103 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
104 #define MAX_BANDS 29 ///< max number of scale factor bands
105 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
107 #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size
108 #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size
109 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size
110 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
114 #define SCALEVLCBITS 8
115 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
116 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
117 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
118 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
119 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
121 static VLC sf_vlc; ///< scale factor DPCM vlc
122 static VLC sf_rl_vlc; ///< scale factor run length vlc
123 static VLC vec4_vlc; ///< 4 coefficients per symbol
124 static VLC vec2_vlc; ///< 2 coefficients per symbol
125 static VLC vec1_vlc; ///< 1 coefficient per symbol
126 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
127 static float sin64[33]; ///< sinus table for decorrelation
130 * @brief frame specific decoder context for a single channel
133 int16_t prev_block_len; ///< length of the previous block
134 uint8_t transmit_coefs;
135 uint8_t num_subframes;
136 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
137 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
138 uint8_t cur_subframe; ///< current subframe number
139 uint16_t decoded_samples; ///< number of already processed samples
140 uint8_t grouped; ///< channel is part of a group
141 int quant_step; ///< quantization step for the current subframe
142 int8_t reuse_sf; ///< share scale factors between subframes
143 int8_t scale_factor_step; ///< scaling step for the current subframe
144 int max_scale_factor; ///< maximum scale factor for the current subframe
145 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
146 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
147 int* scale_factors; ///< pointer to the scale factor values used for decoding
148 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
149 float* coeffs; ///< pointer to the subframe decode buffer
150 uint16_t num_vec_coeffs; ///< number of vector coded coefficients
151 DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
155 * @brief channel group for channel transformations
158 uint8_t num_channels; ///< number of channels in the group
159 int8_t transform; ///< transform on / off
160 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
161 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
162 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
166 * @brief main decoder context
168 typedef struct WMAProDecodeCtx {
169 /* generic decoder variables */
170 AVCodecContext* avctx; ///< codec context for av_log
171 AVFrame frame; ///< AVFrame for decoded output
172 DSPContext dsp; ///< accelerated DSP functions
173 uint8_t frame_data[MAX_FRAMESIZE +
174 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
175 PutBitContext pb; ///< context for filling the frame_data buffer
176 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
177 DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
178 float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
180 /* frame size dependent frame information (set during initialization) */
181 uint32_t decode_flags; ///< used compression features
182 uint8_t len_prefix; ///< frame is prefixed with its length
183 uint8_t dynamic_range_compression; ///< frame contains DRC data
184 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
185 uint16_t samples_per_frame; ///< number of samples to output
186 uint16_t log2_frame_size;
187 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
188 int8_t lfe_channel; ///< lfe channel index
189 uint8_t max_num_subframes;
190 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
191 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
192 uint16_t min_samples_per_subframe;
193 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
194 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
195 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
196 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
198 /* packet decode state */
199 GetBitContext pgb; ///< bitstream reader context for the packet
200 int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
201 uint8_t packet_offset; ///< frame offset in the packet
202 uint8_t packet_sequence_number; ///< current packet number
203 int num_saved_bits; ///< saved number of bits
204 int frame_offset; ///< frame offset in the bit reservoir
205 int subframe_offset; ///< subframe offset in the bit reservoir
206 uint8_t packet_loss; ///< set in case of bitstream error
207 uint8_t packet_done; ///< set when a packet is fully decoded
209 /* frame decode state */
210 uint32_t frame_num; ///< current frame number (not used for decoding)
211 GetBitContext gb; ///< bitstream reader context
212 int buf_bit_size; ///< buffer size in bits
213 uint8_t drc_gain; ///< gain for the DRC tool
214 int8_t skip_frame; ///< skip output step
215 int8_t parsed_all_subframes; ///< all subframes decoded?
217 /* subframe/block decode state */
218 int16_t subframe_len; ///< current subframe length
219 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
220 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
221 int8_t num_bands; ///< number of scale factor bands
222 int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
223 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
224 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
225 int8_t esc_len; ///< length of escaped coefficients
227 uint8_t num_chgroups; ///< number of channel groups
228 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
230 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
235 *@brief helper function to print the most important members of the context
238 static av_cold void dump_context(WMAProDecodeCtx *s)
240 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
241 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
243 PRINT("ed sample bit depth", s->bits_per_sample);
244 PRINT_HEX("ed decode flags", s->decode_flags);
245 PRINT("samples per frame", s->samples_per_frame);
246 PRINT("log2 frame size", s->log2_frame_size);
247 PRINT("max num subframes", s->max_num_subframes);
248 PRINT("len prefix", s->len_prefix);
249 PRINT("num channels", s->num_channels);
253 *@brief Uninitialize the decoder and free all resources.
254 *@param avctx codec context
255 *@return 0 on success, < 0 otherwise
257 static av_cold int decode_end(AVCodecContext *avctx)
259 WMAProDecodeCtx *s = avctx->priv_data;
262 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
263 ff_mdct_end(&s->mdct_ctx[i]);
269 *@brief Initialize the decoder.
270 *@param avctx codec context
271 *@return 0 on success, -1 otherwise
273 static av_cold int decode_init(AVCodecContext *avctx)
275 WMAProDecodeCtx *s = avctx->priv_data;
276 uint8_t *edata_ptr = avctx->extradata;
277 unsigned int channel_mask;
279 int log2_max_num_subframes;
280 int num_possible_block_sizes;
283 ff_dsputil_init(&s->dsp, avctx);
284 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
286 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
288 if (avctx->extradata_size >= 18) {
289 s->decode_flags = AV_RL16(edata_ptr+14);
290 channel_mask = AV_RL32(edata_ptr+2);
291 s->bits_per_sample = AV_RL16(edata_ptr);
292 /** dump the extradata */
293 for (i = 0; i < avctx->extradata_size; i++)
294 av_dlog(avctx, "[%x] ", avctx->extradata[i]);
295 av_dlog(avctx, "\n");
298 av_log_ask_for_sample(avctx, "Unknown extradata size\n");
299 return AVERROR_INVALIDDATA;
303 s->log2_frame_size = av_log2(avctx->block_align) + 4;
306 s->skip_frame = 1; /* skip first frame */
308 s->len_prefix = (s->decode_flags & 0x40);
311 bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
312 if (bits > WMAPRO_BLOCK_MAX_BITS) {
313 av_log_missing_feature(avctx, "14-bits block sizes", 1);
314 return AVERROR_PATCHWELCOME;
316 s->samples_per_frame = 1 << bits;
319 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
320 s->max_num_subframes = 1 << log2_max_num_subframes;
321 if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
322 s->max_subframe_len_bit = 1;
323 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
325 num_possible_block_sizes = log2_max_num_subframes + 1;
326 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
327 s->dynamic_range_compression = (s->decode_flags & 0x80);
329 if (s->max_num_subframes > MAX_SUBFRAMES) {
330 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
331 s->max_num_subframes);
332 return AVERROR_INVALIDDATA;
335 if (s->min_samples_per_subframe < (1<<WMAPRO_BLOCK_MIN_BITS)) {
336 av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
337 s->min_samples_per_subframe);
338 return AVERROR_INVALIDDATA;
341 if (s->avctx->sample_rate <= 0) {
342 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
343 return AVERROR_INVALIDDATA;
346 s->num_channels = avctx->channels;
348 if (s->num_channels < 0) {
349 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
350 return AVERROR_INVALIDDATA;
351 } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
352 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
353 return AVERROR_PATCHWELCOME;
356 /** init previous block len */
357 for (i = 0; i < s->num_channels; i++)
358 s->channel[i].prev_block_len = s->samples_per_frame;
360 /** extract lfe channel position */
363 if (channel_mask & 8) {
365 for (mask = 1; mask < 16; mask <<= 1) {
366 if (channel_mask & mask)
371 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
372 scale_huffbits, 1, 1,
373 scale_huffcodes, 2, 2, 616);
375 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
376 scale_rl_huffbits, 1, 1,
377 scale_rl_huffcodes, 4, 4, 1406);
379 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
380 coef0_huffbits, 1, 1,
381 coef0_huffcodes, 4, 4, 2108);
383 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
384 coef1_huffbits, 1, 1,
385 coef1_huffcodes, 4, 4, 3912);
387 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
389 vec4_huffcodes, 2, 2, 604);
391 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
393 vec2_huffcodes, 2, 2, 562);
395 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
397 vec1_huffcodes, 2, 2, 562);
399 /** calculate number of scale factor bands and their offsets
400 for every possible block size */
401 for (i = 0; i < num_possible_block_sizes; i++) {
402 int subframe_len = s->samples_per_frame >> i;
406 s->sfb_offsets[i][0] = 0;
408 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
409 int offset = (subframe_len * 2 * critical_freq[x])
410 / s->avctx->sample_rate + 2;
412 if (offset > s->sfb_offsets[i][band - 1])
413 s->sfb_offsets[i][band++] = offset;
415 s->sfb_offsets[i][band - 1] = subframe_len;
416 s->num_sfb[i] = band - 1;
420 /** Scale factors can be shared between blocks of different size
421 as every block has a different scale factor band layout.
422 The matrix sf_offsets is needed to find the correct scale factor.
425 for (i = 0; i < num_possible_block_sizes; i++) {
427 for (b = 0; b < s->num_sfb[i]; b++) {
429 int offset = ((s->sfb_offsets[i][b]
430 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
431 for (x = 0; x < num_possible_block_sizes; x++) {
433 while (s->sfb_offsets[x][v + 1] << x < offset)
435 s->sf_offsets[i][x][b] = v;
440 /** init MDCT, FIXME: only init needed sizes */
441 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
442 ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
443 1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
444 / (1 << (s->bits_per_sample - 1)));
446 /** init MDCT windows: simple sinus window */
447 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
448 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
449 ff_init_ff_sine_windows(win_idx);
450 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
453 /** calculate subwoofer cutoff values */
454 for (i = 0; i < num_possible_block_sizes; i++) {
455 int block_size = s->samples_per_frame >> i;
456 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
457 / s->avctx->sample_rate;
458 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
461 /** calculate sine values for the decorrelation matrix */
462 for (i = 0; i < 33; i++)
463 sin64[i] = sin(i*M_PI / 64.0);
465 if (avctx->debug & FF_DEBUG_BITSTREAM)
468 avctx->channel_layout = channel_mask;
470 avcodec_get_frame_defaults(&s->frame);
471 avctx->coded_frame = &s->frame;
477 *@brief Decode the subframe length.
479 *@param offset sample offset in the frame
480 *@return decoded subframe length on success, < 0 in case of an error
482 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
484 int frame_len_shift = 0;
487 /** no need to read from the bitstream when only one length is possible */
488 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
489 return s->min_samples_per_subframe;
491 /** 1 bit indicates if the subframe is of maximum length */
492 if (s->max_subframe_len_bit) {
493 if (get_bits1(&s->gb))
494 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
496 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
498 subframe_len = s->samples_per_frame >> frame_len_shift;
500 /** sanity check the length */
501 if (subframe_len < s->min_samples_per_subframe ||
502 subframe_len > s->samples_per_frame) {
503 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
505 return AVERROR_INVALIDDATA;
511 *@brief Decode how the data in the frame is split into subframes.
512 * Every WMA frame contains the encoded data for a fixed number of
513 * samples per channel. The data for every channel might be split
514 * into several subframes. This function will reconstruct the list of
515 * subframes for every channel.
517 * If the subframes are not evenly split, the algorithm estimates the
518 * channels with the lowest number of total samples.
519 * Afterwards, for each of these channels a bit is read from the
520 * bitstream that indicates if the channel contains a subframe with the
521 * next subframe size that is going to be read from the bitstream or not.
522 * If a channel contains such a subframe, the subframe size gets added to
523 * the channel's subframe list.
524 * The algorithm repeats these steps until the frame is properly divided
525 * between the individual channels.
528 *@return 0 on success, < 0 in case of an error
530 static int decode_tilehdr(WMAProDecodeCtx *s)
532 uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
533 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
534 int channels_for_cur_subframe = s->num_channels; /**< number of channels that contain the current subframe */
535 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
536 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
539 /* Should never consume more than 3073 bits (256 iterations for the
540 * while loop when always the minimum amount of 128 samples is subtracted
541 * from missing samples in the 8 channel case).
542 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
545 /** reset tiling information */
546 for (c = 0; c < s->num_channels; c++)
547 s->channel[c].num_subframes = 0;
549 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
550 fixed_channel_layout = 1;
552 /** loop until the frame data is split between the subframes */
556 /** check which channels contain the subframe */
557 for (c = 0; c < s->num_channels; c++) {
558 if (num_samples[c] == min_channel_len) {
559 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
560 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
561 contains_subframe[c] = 1;
563 contains_subframe[c] = get_bits1(&s->gb);
565 contains_subframe[c] = 0;
568 /** get subframe length, subframe_len == 0 is not allowed */
569 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
570 return AVERROR_INVALIDDATA;
572 /** add subframes to the individual channels and find new min_channel_len */
573 min_channel_len += subframe_len;
574 for (c = 0; c < s->num_channels; c++) {
575 WMAProChannelCtx* chan = &s->channel[c];
577 if (contains_subframe[c]) {
578 if (chan->num_subframes >= MAX_SUBFRAMES) {
579 av_log(s->avctx, AV_LOG_ERROR,
580 "broken frame: num subframes > 31\n");
581 return AVERROR_INVALIDDATA;
583 chan->subframe_len[chan->num_subframes] = subframe_len;
584 num_samples[c] += subframe_len;
585 ++chan->num_subframes;
586 if (num_samples[c] > s->samples_per_frame) {
587 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
588 "channel len > samples_per_frame\n");
589 return AVERROR_INVALIDDATA;
591 } else if (num_samples[c] <= min_channel_len) {
592 if (num_samples[c] < min_channel_len) {
593 channels_for_cur_subframe = 0;
594 min_channel_len = num_samples[c];
596 ++channels_for_cur_subframe;
599 } while (min_channel_len < s->samples_per_frame);
601 for (c = 0; c < s->num_channels; c++) {
604 for (i = 0; i < s->channel[c].num_subframes; i++) {
605 av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
606 " len %i\n", s->frame_num, c, i,
607 s->channel[c].subframe_len[i]);
608 s->channel[c].subframe_offset[i] = offset;
609 offset += s->channel[c].subframe_len[i];
617 *@brief Calculate a decorrelation matrix from the bitstream parameters.
618 *@param s codec context
619 *@param chgroup channel group for which the matrix needs to be calculated
621 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
622 WMAProChannelGrp *chgroup)
626 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
627 memset(chgroup->decorrelation_matrix, 0, s->num_channels *
628 s->num_channels * sizeof(*chgroup->decorrelation_matrix));
630 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
631 rotation_offset[i] = get_bits(&s->gb, 6);
633 for (i = 0; i < chgroup->num_channels; i++)
634 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
635 get_bits1(&s->gb) ? 1.0 : -1.0;
637 for (i = 1; i < chgroup->num_channels; i++) {
639 for (x = 0; x < i; x++) {
641 for (y = 0; y < i + 1; y++) {
642 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
643 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
644 int n = rotation_offset[offset + x];
650 cosv = sin64[32 - n];
652 sinv = sin64[64 - n];
653 cosv = -sin64[n - 32];
656 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
657 (v1 * sinv) - (v2 * cosv);
658 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
659 (v1 * cosv) + (v2 * sinv);
667 *@brief Decode channel transformation parameters
668 *@param s codec context
669 *@return 0 in case of success, < 0 in case of bitstream errors
671 static int decode_channel_transform(WMAProDecodeCtx* s)
674 /* should never consume more than 1921 bits for the 8 channel case
675 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
676 * + MAX_CHANNELS + MAX_BANDS + 1)
679 /** in the one channel case channel transforms are pointless */
681 if (s->num_channels > 1) {
682 int remaining_channels = s->channels_for_cur_subframe;
684 if (get_bits1(&s->gb)) {
685 av_log_ask_for_sample(s->avctx,
686 "unsupported channel transform bit\n");
687 return AVERROR_INVALIDDATA;
690 for (s->num_chgroups = 0; remaining_channels &&
691 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
692 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
693 float** channel_data = chgroup->channel_data;
694 chgroup->num_channels = 0;
695 chgroup->transform = 0;
697 /** decode channel mask */
698 if (remaining_channels > 2) {
699 for (i = 0; i < s->channels_for_cur_subframe; i++) {
700 int channel_idx = s->channel_indexes_for_cur_subframe[i];
701 if (!s->channel[channel_idx].grouped
702 && get_bits1(&s->gb)) {
703 ++chgroup->num_channels;
704 s->channel[channel_idx].grouped = 1;
705 *channel_data++ = s->channel[channel_idx].coeffs;
709 chgroup->num_channels = remaining_channels;
710 for (i = 0; i < s->channels_for_cur_subframe; i++) {
711 int channel_idx = s->channel_indexes_for_cur_subframe[i];
712 if (!s->channel[channel_idx].grouped)
713 *channel_data++ = s->channel[channel_idx].coeffs;
714 s->channel[channel_idx].grouped = 1;
718 /** decode transform type */
719 if (chgroup->num_channels == 2) {
720 if (get_bits1(&s->gb)) {
721 if (get_bits1(&s->gb)) {
722 av_log_ask_for_sample(s->avctx,
723 "unsupported channel transform type\n");
726 chgroup->transform = 1;
727 if (s->num_channels == 2) {
728 chgroup->decorrelation_matrix[0] = 1.0;
729 chgroup->decorrelation_matrix[1] = -1.0;
730 chgroup->decorrelation_matrix[2] = 1.0;
731 chgroup->decorrelation_matrix[3] = 1.0;
734 chgroup->decorrelation_matrix[0] = 0.70703125;
735 chgroup->decorrelation_matrix[1] = -0.70703125;
736 chgroup->decorrelation_matrix[2] = 0.70703125;
737 chgroup->decorrelation_matrix[3] = 0.70703125;
740 } else if (chgroup->num_channels > 2) {
741 if (get_bits1(&s->gb)) {
742 chgroup->transform = 1;
743 if (get_bits1(&s->gb)) {
744 decode_decorrelation_matrix(s, chgroup);
746 /** FIXME: more than 6 coupled channels not supported */
747 if (chgroup->num_channels > 6) {
748 av_log_ask_for_sample(s->avctx,
749 "coupled channels > 6\n");
751 memcpy(chgroup->decorrelation_matrix,
752 default_decorrelation[chgroup->num_channels],
753 chgroup->num_channels * chgroup->num_channels *
754 sizeof(*chgroup->decorrelation_matrix));
760 /** decode transform on / off */
761 if (chgroup->transform) {
762 if (!get_bits1(&s->gb)) {
764 /** transform can be enabled for individual bands */
765 for (i = 0; i < s->num_bands; i++) {
766 chgroup->transform_band[i] = get_bits1(&s->gb);
769 memset(chgroup->transform_band, 1, s->num_bands);
772 remaining_channels -= chgroup->num_channels;
779 *@brief Extract the coefficients from the bitstream.
780 *@param s codec context
781 *@param c current channel number
782 *@return 0 on success, < 0 in case of bitstream errors
784 static int decode_coeffs(WMAProDecodeCtx *s, int c)
786 /* Integers 0..15 as single-precision floats. The table saves a
787 costly int to float conversion, and storing the values as
788 integers allows fast sign-flipping. */
789 static const uint32_t fval_tab[16] = {
790 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
791 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
792 0x41000000, 0x41100000, 0x41200000, 0x41300000,
793 0x41400000, 0x41500000, 0x41600000, 0x41700000,
797 WMAProChannelCtx* ci = &s->channel[c];
804 av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
806 vlctable = get_bits1(&s->gb);
807 vlc = &coef_vlc[vlctable];
817 /** decode vector coefficients (consumes up to 167 bits per iteration for
818 4 vector coded large values) */
819 while ((s->transmit_num_vec_coeffs || !rl_mode) &&
820 (cur_coeff + 3 < ci->num_vec_coeffs)) {
825 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
827 if (idx == HUFF_VEC4_SIZE - 1) {
828 for (i = 0; i < 4; i += 2) {
829 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
830 if (idx == HUFF_VEC2_SIZE - 1) {
832 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
833 if (v0 == HUFF_VEC1_SIZE - 1)
834 v0 += ff_wma_get_large_val(&s->gb);
835 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
836 if (v1 == HUFF_VEC1_SIZE - 1)
837 v1 += ff_wma_get_large_val(&s->gb);
838 vals[i ] = av_float2int(v0);
839 vals[i+1] = av_float2int(v1);
841 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
842 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
846 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
847 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
848 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
849 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
853 for (i = 0; i < 4; i++) {
855 uint32_t sign = get_bits1(&s->gb) - 1;
856 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
859 ci->coeffs[cur_coeff] = 0;
860 /** switch to run level mode when subframe_len / 128 zeros
861 were found in a row */
862 rl_mode |= (++num_zeros > s->subframe_len >> 8);
868 /** decode run level coded coefficients */
869 if (cur_coeff < s->subframe_len) {
870 memset(&ci->coeffs[cur_coeff], 0,
871 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
872 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
873 level, run, 1, ci->coeffs,
874 cur_coeff, s->subframe_len,
875 s->subframe_len, s->esc_len, 0))
876 return AVERROR_INVALIDDATA;
883 *@brief Extract scale factors from the bitstream.
884 *@param s codec context
885 *@return 0 on success, < 0 in case of bitstream errors
887 static int decode_scale_factors(WMAProDecodeCtx* s)
891 /** should never consume more than 5344 bits
892 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
895 for (i = 0; i < s->channels_for_cur_subframe; i++) {
896 int c = s->channel_indexes_for_cur_subframe[i];
899 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
900 sf_end = s->channel[c].scale_factors + s->num_bands;
902 /** resample scale factors for the new block size
903 * as the scale factors might need to be resampled several times
904 * before some new values are transmitted, a backup of the last
905 * transmitted scale factors is kept in saved_scale_factors
907 if (s->channel[c].reuse_sf) {
908 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
910 for (b = 0; b < s->num_bands; b++)
911 s->channel[c].scale_factors[b] =
912 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
915 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
917 if (!s->channel[c].reuse_sf) {
919 /** decode DPCM coded scale factors */
920 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
921 val = 45 / s->channel[c].scale_factor_step;
922 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
923 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
928 /** run level decode differences to the resampled factors */
929 for (i = 0; i < s->num_bands; i++) {
935 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
938 uint32_t code = get_bits(&s->gb, 14);
940 sign = (code & 1) - 1;
941 skip = (code & 0x3f) >> 1;
942 } else if (idx == 1) {
945 skip = scale_rl_run[idx];
946 val = scale_rl_level[idx];
947 sign = get_bits1(&s->gb)-1;
951 if (i >= s->num_bands) {
952 av_log(s->avctx, AV_LOG_ERROR,
953 "invalid scale factor coding\n");
954 return AVERROR_INVALIDDATA;
956 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
960 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
961 s->channel[c].table_idx = s->table_idx;
962 s->channel[c].reuse_sf = 1;
965 /** calculate new scale factor maximum */
966 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
967 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
968 s->channel[c].max_scale_factor =
969 FFMAX(s->channel[c].max_scale_factor, *sf);
977 *@brief Reconstruct the individual channel data.
978 *@param s codec context
980 static void inverse_channel_transform(WMAProDecodeCtx *s)
984 for (i = 0; i < s->num_chgroups; i++) {
985 if (s->chgroup[i].transform) {
986 float data[WMAPRO_MAX_CHANNELS];
987 const int num_channels = s->chgroup[i].num_channels;
988 float** ch_data = s->chgroup[i].channel_data;
989 float** ch_end = ch_data + num_channels;
990 const int8_t* tb = s->chgroup[i].transform_band;
993 /** multichannel decorrelation */
994 for (sfb = s->cur_sfb_offsets;
995 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
998 /** multiply values with the decorrelation_matrix */
999 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1000 const float* mat = s->chgroup[i].decorrelation_matrix;
1001 const float* data_end = data + num_channels;
1002 float* data_ptr = data;
1005 for (ch = ch_data; ch < ch_end; ch++)
1006 *data_ptr++ = (*ch)[y];
1008 for (ch = ch_data; ch < ch_end; ch++) {
1011 while (data_ptr < data_end)
1012 sum += *data_ptr++ * *mat++;
1017 } else if (s->num_channels == 2) {
1018 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1019 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1020 ch_data[0] + sfb[0],
1022 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1023 ch_data[1] + sfb[0],
1032 *@brief Apply sine window and reconstruct the output buffer.
1033 *@param s codec context
1035 static void wmapro_window(WMAProDecodeCtx *s)
1038 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1039 int c = s->channel_indexes_for_cur_subframe[i];
1041 int winlen = s->channel[c].prev_block_len;
1042 float* start = s->channel[c].coeffs - (winlen >> 1);
1044 if (s->subframe_len < winlen) {
1045 start += (winlen - s->subframe_len) >> 1;
1046 winlen = s->subframe_len;
1049 window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1053 s->dsp.vector_fmul_window(start, start, start + winlen,
1056 s->channel[c].prev_block_len = s->subframe_len;
1061 *@brief Decode a single subframe (block).
1062 *@param s codec context
1063 *@return 0 on success, < 0 when decoding failed
1065 static int decode_subframe(WMAProDecodeCtx *s)
1067 int offset = s->samples_per_frame;
1068 int subframe_len = s->samples_per_frame;
1070 int total_samples = s->samples_per_frame * s->num_channels;
1071 int transmit_coeffs = 0;
1072 int cur_subwoofer_cutoff;
1074 s->subframe_offset = get_bits_count(&s->gb);
1076 /** reset channel context and find the next block offset and size
1077 == the next block of the channel with the smallest number of
1080 for (i = 0; i < s->num_channels; i++) {
1081 s->channel[i].grouped = 0;
1082 if (offset > s->channel[i].decoded_samples) {
1083 offset = s->channel[i].decoded_samples;
1085 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1090 "processing subframe with offset %i len %i\n", offset, subframe_len);
1092 /** get a list of all channels that contain the estimated block */
1093 s->channels_for_cur_subframe = 0;
1094 for (i = 0; i < s->num_channels; i++) {
1095 const int cur_subframe = s->channel[i].cur_subframe;
1096 /** substract already processed samples */
1097 total_samples -= s->channel[i].decoded_samples;
1099 /** and count if there are multiple subframes that match our profile */
1100 if (offset == s->channel[i].decoded_samples &&
1101 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1102 total_samples -= s->channel[i].subframe_len[cur_subframe];
1103 s->channel[i].decoded_samples +=
1104 s->channel[i].subframe_len[cur_subframe];
1105 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1106 ++s->channels_for_cur_subframe;
1110 /** check if the frame will be complete after processing the
1113 s->parsed_all_subframes = 1;
1116 av_dlog(s->avctx, "subframe is part of %i channels\n",
1117 s->channels_for_cur_subframe);
1119 /** calculate number of scale factor bands and their offsets */
1120 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1121 s->num_bands = s->num_sfb[s->table_idx];
1122 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1123 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1125 /** configure the decoder for the current subframe */
1126 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1127 int c = s->channel_indexes_for_cur_subframe[i];
1129 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1133 s->subframe_len = subframe_len;
1134 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1136 /** skip extended header if any */
1137 if (get_bits1(&s->gb)) {
1139 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1140 int len = get_bits(&s->gb, 4);
1141 num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
1144 if (num_fill_bits >= 0) {
1145 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1146 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1147 return AVERROR_INVALIDDATA;
1150 skip_bits_long(&s->gb, num_fill_bits);
1154 /** no idea for what the following bit is used */
1155 if (get_bits1(&s->gb)) {
1156 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1157 return AVERROR_INVALIDDATA;
1161 if (decode_channel_transform(s) < 0)
1162 return AVERROR_INVALIDDATA;
1165 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1166 int c = s->channel_indexes_for_cur_subframe[i];
1167 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1168 transmit_coeffs = 1;
1171 av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1172 if (transmit_coeffs) {
1174 int quant_step = 90 * s->bits_per_sample >> 4;
1176 /** decode number of vector coded coefficients */
1177 if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1178 int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1179 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1180 int c = s->channel_indexes_for_cur_subframe[i];
1181 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1182 if (num_vec_coeffs > s->subframe_len) {
1183 av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1184 return AVERROR_INVALIDDATA;
1186 s->channel[c].num_vec_coeffs = num_vec_coeffs;
1189 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1190 int c = s->channel_indexes_for_cur_subframe[i];
1191 s->channel[c].num_vec_coeffs = s->subframe_len;
1194 /** decode quantization step */
1195 step = get_sbits(&s->gb, 6);
1197 if (step == -32 || step == 31) {
1198 const int sign = (step == 31) - 1;
1200 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1201 (step = get_bits(&s->gb, 5)) == 31) {
1204 quant_step += ((quant + step) ^ sign) - sign;
1206 if (quant_step < 0) {
1207 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1210 /** decode quantization step modifiers for every channel */
1212 if (s->channels_for_cur_subframe == 1) {
1213 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1215 int modifier_len = get_bits(&s->gb, 3);
1216 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1217 int c = s->channel_indexes_for_cur_subframe[i];
1218 s->channel[c].quant_step = quant_step;
1219 if (get_bits1(&s->gb)) {
1221 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1223 ++s->channel[c].quant_step;
1228 /** decode scale factors */
1229 if (decode_scale_factors(s) < 0)
1230 return AVERROR_INVALIDDATA;
1233 av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1234 get_bits_count(&s->gb) - s->subframe_offset);
1236 /** parse coefficients */
1237 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1238 int c = s->channel_indexes_for_cur_subframe[i];
1239 if (s->channel[c].transmit_coefs &&
1240 get_bits_count(&s->gb) < s->num_saved_bits) {
1241 decode_coeffs(s, c);
1243 memset(s->channel[c].coeffs, 0,
1244 sizeof(*s->channel[c].coeffs) * subframe_len);
1247 av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1248 get_bits_count(&s->gb) - s->subframe_offset);
1250 if (transmit_coeffs) {
1251 FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1252 /** reconstruct the per channel data */
1253 inverse_channel_transform(s);
1254 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1255 int c = s->channel_indexes_for_cur_subframe[i];
1256 const int* sf = s->channel[c].scale_factors;
1259 if (c == s->lfe_channel)
1260 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1261 (subframe_len - cur_subwoofer_cutoff));
1263 /** inverse quantization and rescaling */
1264 for (b = 0; b < s->num_bands; b++) {
1265 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1266 const int exp = s->channel[c].quant_step -
1267 (s->channel[c].max_scale_factor - *sf++) *
1268 s->channel[c].scale_factor_step;
1269 const float quant = pow(10.0, exp / 20.0);
1270 int start = s->cur_sfb_offsets[b];
1271 s->dsp.vector_fmul_scalar(s->tmp + start,
1272 s->channel[c].coeffs + start,
1273 quant, end - start);
1276 /** apply imdct (imdct_half == DCTIV with reverse) */
1277 mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1281 /** window and overlapp-add */
1284 /** handled one subframe */
1285 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1286 int c = s->channel_indexes_for_cur_subframe[i];
1287 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1288 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1289 return AVERROR_INVALIDDATA;
1291 ++s->channel[c].cur_subframe;
1298 *@brief Decode one WMA frame.
1299 *@param s codec context
1300 *@return 0 if the trailer bit indicates that this is the last frame,
1301 * 1 if there are additional frames
1303 static int decode_frame(WMAProDecodeCtx *s, int *got_frame_ptr)
1305 AVCodecContext *avctx = s->avctx;
1306 GetBitContext* gb = &s->gb;
1307 int more_frames = 0;
1311 /** get frame length */
1313 len = get_bits(gb, s->log2_frame_size);
1315 av_dlog(s->avctx, "decoding frame with length %x\n", len);
1317 /** decode tile information */
1318 if (decode_tilehdr(s)) {
1323 /** read postproc transform */
1324 if (s->num_channels > 1 && get_bits1(gb)) {
1325 if (get_bits1(gb)) {
1326 for (i = 0; i < s->num_channels * s->num_channels; i++)
1331 /** read drc info */
1332 if (s->dynamic_range_compression) {
1333 s->drc_gain = get_bits(gb, 8);
1334 av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1337 /** no idea what these are for, might be the number of samples
1338 that need to be skipped at the beginning or end of a stream */
1339 if (get_bits1(gb)) {
1342 /** usually true for the first frame */
1343 if (get_bits1(gb)) {
1344 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1345 av_dlog(s->avctx, "start skip: %i\n", skip);
1348 /** sometimes true for the last frame */
1349 if (get_bits1(gb)) {
1350 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1351 av_dlog(s->avctx, "end skip: %i\n", skip);
1356 av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1357 get_bits_count(gb) - s->frame_offset);
1359 /** reset subframe states */
1360 s->parsed_all_subframes = 0;
1361 for (i = 0; i < s->num_channels; i++) {
1362 s->channel[i].decoded_samples = 0;
1363 s->channel[i].cur_subframe = 0;
1364 s->channel[i].reuse_sf = 0;
1367 /** decode all subframes */
1368 while (!s->parsed_all_subframes) {
1369 if (decode_subframe(s) < 0) {
1375 /* get output buffer */
1376 s->frame.nb_samples = s->samples_per_frame;
1377 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1378 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1383 /** copy samples to the output buffer */
1384 for (i = 0; i < s->num_channels; i++)
1385 memcpy(s->frame.extended_data[i], s->channel[i].out,
1386 s->samples_per_frame * sizeof(*s->channel[i].out));
1388 for (i = 0; i < s->num_channels; i++) {
1389 /** reuse second half of the IMDCT output for the next frame */
1390 memcpy(&s->channel[i].out[0],
1391 &s->channel[i].out[s->samples_per_frame],
1392 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1395 if (s->skip_frame) {
1402 if (s->len_prefix) {
1403 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1404 /** FIXME: not sure if this is always an error */
1405 av_log(s->avctx, AV_LOG_ERROR,
1406 "frame[%i] would have to skip %i bits\n", s->frame_num,
1407 len - (get_bits_count(gb) - s->frame_offset) - 1);
1412 /** skip the rest of the frame data */
1413 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1415 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1419 /** decode trailer bit */
1420 more_frames = get_bits1(gb);
1427 *@brief Calculate remaining input buffer length.
1428 *@param s codec context
1429 *@param gb bitstream reader context
1430 *@return remaining size in bits
1432 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1434 return s->buf_bit_size - get_bits_count(gb);
1438 *@brief Fill the bit reservoir with a (partial) frame.
1439 *@param s codec context
1440 *@param gb bitstream reader context
1441 *@param len length of the partial frame
1442 *@param append decides whether to reset the buffer or not
1444 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1449 /** when the frame data does not need to be concatenated, the input buffer
1450 is reset and additional bits from the previous frame are copied
1451 and skipped later so that a fast byte copy is possible */
1454 s->frame_offset = get_bits_count(gb) & 7;
1455 s->num_saved_bits = s->frame_offset;
1456 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1459 buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1461 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1462 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1467 s->num_saved_bits += len;
1469 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1472 int align = 8 - (get_bits_count(gb) & 7);
1473 align = FFMIN(align, len);
1474 put_bits(&s->pb, align, get_bits(gb, align));
1476 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1478 skip_bits_long(gb, len);
1481 PutBitContext tmp = s->pb;
1482 flush_put_bits(&tmp);
1485 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1486 skip_bits(&s->gb, s->frame_offset);
1490 *@brief Decode a single WMA packet.
1491 *@param avctx codec context
1492 *@param data the output buffer
1493 *@param avpkt input packet
1494 *@return number of bytes that were read from the input buffer
1496 static int decode_packet(AVCodecContext *avctx, void *data,
1497 int *got_frame_ptr, AVPacket* avpkt)
1499 WMAProDecodeCtx *s = avctx->priv_data;
1500 GetBitContext* gb = &s->pgb;
1501 const uint8_t* buf = avpkt->data;
1502 int buf_size = avpkt->size;
1503 int num_bits_prev_frame;
1504 int packet_sequence_number;
1508 if (s->packet_done || s->packet_loss) {
1511 /** sanity check for the buffer length */
1512 if (buf_size < avctx->block_align)
1515 s->next_packet_start = buf_size - avctx->block_align;
1516 buf_size = avctx->block_align;
1517 s->buf_bit_size = buf_size << 3;
1519 /** parse packet header */
1520 init_get_bits(gb, buf, s->buf_bit_size);
1521 packet_sequence_number = get_bits(gb, 4);
1524 /** get number of bits that need to be added to the previous frame */
1525 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1526 av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1527 num_bits_prev_frame);
1529 /** check for packet loss */
1530 if (!s->packet_loss &&
1531 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1533 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1534 s->packet_sequence_number, packet_sequence_number);
1536 s->packet_sequence_number = packet_sequence_number;
1538 if (num_bits_prev_frame > 0) {
1539 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1540 if (num_bits_prev_frame >= remaining_packet_bits) {
1541 num_bits_prev_frame = remaining_packet_bits;
1545 /** append the previous frame data to the remaining data from the
1546 previous packet to create a full frame */
1547 save_bits(s, gb, num_bits_prev_frame, 1);
1548 av_dlog(avctx, "accumulated %x bits of frame data\n",
1549 s->num_saved_bits - s->frame_offset);
1551 /** decode the cross packet frame if it is valid */
1552 if (!s->packet_loss)
1553 decode_frame(s, got_frame_ptr);
1554 } else if (s->num_saved_bits - s->frame_offset) {
1555 av_dlog(avctx, "ignoring %x previously saved bits\n",
1556 s->num_saved_bits - s->frame_offset);
1559 if (s->packet_loss) {
1560 /** reset number of saved bits so that the decoder
1561 does not start to decode incomplete frames in the
1562 s->len_prefix == 0 case */
1563 s->num_saved_bits = 0;
1569 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1570 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1571 skip_bits(gb, s->packet_offset);
1572 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1573 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1574 frame_size <= remaining_bits(s, gb)) {
1575 save_bits(s, gb, frame_size, 0);
1576 s->packet_done = !decode_frame(s, got_frame_ptr);
1577 } else if (!s->len_prefix
1578 && s->num_saved_bits > get_bits_count(&s->gb)) {
1579 /** when the frames do not have a length prefix, we don't know
1580 the compressed length of the individual frames
1581 however, we know what part of a new packet belongs to the
1583 therefore we save the incoming packet first, then we append
1584 the "previous frame" data from the next packet so that
1585 we get a buffer that only contains full frames */
1586 s->packet_done = !decode_frame(s, got_frame_ptr);
1591 if (s->packet_done && !s->packet_loss &&
1592 remaining_bits(s, gb) > 0) {
1593 /** save the rest of the data so that it can be decoded
1594 with the next packet */
1595 save_bits(s, gb, remaining_bits(s, gb), 0);
1598 s->packet_offset = get_bits_count(gb) & 7;
1600 return AVERROR_INVALIDDATA;
1603 *(AVFrame *)data = s->frame;
1605 return get_bits_count(gb) >> 3;
1609 *@brief Clear decoder buffers (for seeking).
1610 *@param avctx codec context
1612 static void flush(AVCodecContext *avctx)
1614 WMAProDecodeCtx *s = avctx->priv_data;
1616 /** reset output buffer as a part of it is used during the windowing of a
1618 for (i = 0; i < s->num_channels; i++)
1619 memset(s->channel[i].out, 0, s->samples_per_frame *
1620 sizeof(*s->channel[i].out));
1626 *@brief wmapro decoder
1628 AVCodec ff_wmapro_decoder = {
1630 .type = AVMEDIA_TYPE_AUDIO,
1631 .id = AV_CODEC_ID_WMAPRO,
1632 .priv_data_size = sizeof(WMAProDecodeCtx),
1633 .init = decode_init,
1634 .close = decode_end,
1635 .decode = decode_packet,
1636 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1638 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1639 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1640 AV_SAMPLE_FMT_NONE },