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"
97 #include "fmtconvert.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 12 ///< 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 FmtConvertContext fmt_conv;
174 uint8_t frame_data[MAX_FRAMESIZE +
175 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
176 PutBitContext pb; ///< context for filling the frame_data buffer
177 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
178 DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
179 float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
181 /* frame size dependent frame information (set during initialization) */
182 uint32_t decode_flags; ///< used compression features
183 uint8_t len_prefix; ///< frame is prefixed with its length
184 uint8_t dynamic_range_compression; ///< frame contains DRC data
185 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
186 uint16_t samples_per_frame; ///< number of samples to output
187 uint16_t log2_frame_size;
188 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
189 int8_t lfe_channel; ///< lfe channel index
190 uint8_t max_num_subframes;
191 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
192 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
193 uint16_t min_samples_per_subframe;
194 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
195 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
196 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
197 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
199 /* packet decode state */
200 GetBitContext pgb; ///< bitstream reader context for the packet
201 int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
202 uint8_t packet_offset; ///< frame offset in the packet
203 uint8_t packet_sequence_number; ///< current packet number
204 int num_saved_bits; ///< saved number of bits
205 int frame_offset; ///< frame offset in the bit reservoir
206 int subframe_offset; ///< subframe offset in the bit reservoir
207 uint8_t packet_loss; ///< set in case of bitstream error
208 uint8_t packet_done; ///< set when a packet is fully decoded
210 /* frame decode state */
211 uint32_t frame_num; ///< current frame number (not used for decoding)
212 GetBitContext gb; ///< bitstream reader context
213 int buf_bit_size; ///< buffer size in bits
214 uint8_t drc_gain; ///< gain for the DRC tool
215 int8_t skip_frame; ///< skip output step
216 int8_t parsed_all_subframes; ///< all subframes decoded?
218 /* subframe/block decode state */
219 int16_t subframe_len; ///< current subframe length
220 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
221 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
222 int8_t num_bands; ///< number of scale factor bands
223 int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
224 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
225 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
226 int8_t esc_len; ///< length of escaped coefficients
228 uint8_t num_chgroups; ///< number of channel groups
229 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
231 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
236 *@brief helper function to print the most important members of the context
239 static void av_cold dump_context(WMAProDecodeCtx *s)
241 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
242 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
244 PRINT("ed sample bit depth", s->bits_per_sample);
245 PRINT_HEX("ed decode flags", s->decode_flags);
246 PRINT("samples per frame", s->samples_per_frame);
247 PRINT("log2 frame size", s->log2_frame_size);
248 PRINT("max num subframes", s->max_num_subframes);
249 PRINT("len prefix", s->len_prefix);
250 PRINT("num channels", s->num_channels);
254 *@brief Uninitialize the decoder and free all resources.
255 *@param avctx codec context
256 *@return 0 on success, < 0 otherwise
258 static av_cold int decode_end(AVCodecContext *avctx)
260 WMAProDecodeCtx *s = avctx->priv_data;
263 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
264 ff_mdct_end(&s->mdct_ctx[i]);
270 *@brief Initialize the decoder.
271 *@param avctx codec context
272 *@return 0 on success, -1 otherwise
274 static av_cold int decode_init(AVCodecContext *avctx)
276 WMAProDecodeCtx *s = avctx->priv_data;
277 uint8_t *edata_ptr = avctx->extradata;
278 unsigned int channel_mask;
280 int log2_max_num_subframes;
281 int num_possible_block_sizes;
284 dsputil_init(&s->dsp, avctx);
285 ff_fmt_convert_init(&s->fmt_conv, avctx);
286 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
288 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
290 if (avctx->extradata_size >= 18) {
291 s->decode_flags = AV_RL16(edata_ptr+14);
292 channel_mask = AV_RL32(edata_ptr+2);
293 s->bits_per_sample = AV_RL16(edata_ptr);
294 /** dump the extradata */
295 for (i = 0; i < avctx->extradata_size; i++)
296 av_dlog(avctx, "[%x] ", avctx->extradata[i]);
297 av_dlog(avctx, "\n");
300 av_log_ask_for_sample(avctx, "Unknown extradata size\n");
301 return AVERROR_INVALIDDATA;
305 s->log2_frame_size = av_log2(avctx->block_align) + 4;
308 s->skip_frame = 1; /* skip first frame */
310 s->len_prefix = (s->decode_flags & 0x40);
313 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
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 || s->max_num_subframes == 4)
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 if (s->num_channels < 0) {
336 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
337 return AVERROR_INVALIDDATA;
338 } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
339 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
340 return AVERROR_PATCHWELCOME;
343 /** init previous block len */
344 for (i = 0; i < s->num_channels; i++)
345 s->channel[i].prev_block_len = s->samples_per_frame;
347 /** extract lfe channel position */
350 if (channel_mask & 8) {
352 for (mask = 1; mask < 16; mask <<= 1) {
353 if (channel_mask & mask)
358 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
359 scale_huffbits, 1, 1,
360 scale_huffcodes, 2, 2, 616);
362 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
363 scale_rl_huffbits, 1, 1,
364 scale_rl_huffcodes, 4, 4, 1406);
366 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
367 coef0_huffbits, 1, 1,
368 coef0_huffcodes, 4, 4, 2108);
370 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
371 coef1_huffbits, 1, 1,
372 coef1_huffcodes, 4, 4, 3912);
374 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
376 vec4_huffcodes, 2, 2, 604);
378 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
380 vec2_huffcodes, 2, 2, 562);
382 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
384 vec1_huffcodes, 2, 2, 562);
386 /** calculate number of scale factor bands and their offsets
387 for every possible block size */
388 for (i = 0; i < num_possible_block_sizes; i++) {
389 int subframe_len = s->samples_per_frame >> i;
393 s->sfb_offsets[i][0] = 0;
395 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
396 int offset = (subframe_len * 2 * critical_freq[x])
397 / s->avctx->sample_rate + 2;
399 if (offset > s->sfb_offsets[i][band - 1])
400 s->sfb_offsets[i][band++] = offset;
402 s->sfb_offsets[i][band - 1] = subframe_len;
403 s->num_sfb[i] = band - 1;
407 /** Scale factors can be shared between blocks of different size
408 as every block has a different scale factor band layout.
409 The matrix sf_offsets is needed to find the correct scale factor.
412 for (i = 0; i < num_possible_block_sizes; i++) {
414 for (b = 0; b < s->num_sfb[i]; b++) {
416 int offset = ((s->sfb_offsets[i][b]
417 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
418 for (x = 0; x < num_possible_block_sizes; x++) {
420 while (s->sfb_offsets[x][v + 1] << x < offset)
422 s->sf_offsets[i][x][b] = v;
427 /** init MDCT, FIXME: only init needed sizes */
428 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
429 ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
430 1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
431 / (1 << (s->bits_per_sample - 1)));
433 /** init MDCT windows: simple sinus window */
434 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
435 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
436 ff_init_ff_sine_windows(win_idx);
437 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
440 /** calculate subwoofer cutoff values */
441 for (i = 0; i < num_possible_block_sizes; i++) {
442 int block_size = s->samples_per_frame >> i;
443 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
444 / s->avctx->sample_rate;
445 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
448 /** calculate sine values for the decorrelation matrix */
449 for (i = 0; i < 33; i++)
450 sin64[i] = sin(i*M_PI / 64.0);
452 if (avctx->debug & FF_DEBUG_BITSTREAM)
455 avctx->channel_layout = channel_mask;
457 avcodec_get_frame_defaults(&s->frame);
458 avctx->coded_frame = &s->frame;
464 *@brief Decode the subframe length.
466 *@param offset sample offset in the frame
467 *@return decoded subframe length on success, < 0 in case of an error
469 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
471 int frame_len_shift = 0;
474 /** no need to read from the bitstream when only one length is possible */
475 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
476 return s->min_samples_per_subframe;
478 /** 1 bit indicates if the subframe is of maximum length */
479 if (s->max_subframe_len_bit) {
480 if (get_bits1(&s->gb))
481 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
483 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
485 subframe_len = s->samples_per_frame >> frame_len_shift;
487 /** sanity check the length */
488 if (subframe_len < s->min_samples_per_subframe ||
489 subframe_len > s->samples_per_frame) {
490 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
492 return AVERROR_INVALIDDATA;
498 *@brief Decode how the data in the frame is split into subframes.
499 * Every WMA frame contains the encoded data for a fixed number of
500 * samples per channel. The data for every channel might be split
501 * into several subframes. This function will reconstruct the list of
502 * subframes for every channel.
504 * If the subframes are not evenly split, the algorithm estimates the
505 * channels with the lowest number of total samples.
506 * Afterwards, for each of these channels a bit is read from the
507 * bitstream that indicates if the channel contains a subframe with the
508 * next subframe size that is going to be read from the bitstream or not.
509 * If a channel contains such a subframe, the subframe size gets added to
510 * the channel's subframe list.
511 * The algorithm repeats these steps until the frame is properly divided
512 * between the individual channels.
515 *@return 0 on success, < 0 in case of an error
517 static int decode_tilehdr(WMAProDecodeCtx *s)
519 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /**< sum of samples for all currently known subframes of a channel */
520 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
521 int channels_for_cur_subframe = s->num_channels; /**< number of channels that contain the current subframe */
522 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
523 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
526 /* Should never consume more than 3073 bits (256 iterations for the
527 * while loop when always the minimum amount of 128 samples is substracted
528 * from missing samples in the 8 channel case).
529 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
532 /** reset tiling information */
533 for (c = 0; c < s->num_channels; c++)
534 s->channel[c].num_subframes = 0;
536 memset(num_samples, 0, sizeof(num_samples));
538 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
539 fixed_channel_layout = 1;
541 /** loop until the frame data is split between the subframes */
545 /** check which channels contain the subframe */
546 for (c = 0; c < s->num_channels; c++) {
547 if (num_samples[c] == min_channel_len) {
548 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
549 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
550 contains_subframe[c] = 1;
552 contains_subframe[c] = get_bits1(&s->gb);
554 contains_subframe[c] = 0;
557 /** get subframe length, subframe_len == 0 is not allowed */
558 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
559 return AVERROR_INVALIDDATA;
561 /** add subframes to the individual channels and find new min_channel_len */
562 min_channel_len += subframe_len;
563 for (c = 0; c < s->num_channels; c++) {
564 WMAProChannelCtx* chan = &s->channel[c];
566 if (contains_subframe[c]) {
567 if (chan->num_subframes >= MAX_SUBFRAMES) {
568 av_log(s->avctx, AV_LOG_ERROR,
569 "broken frame: num subframes > 31\n");
570 return AVERROR_INVALIDDATA;
572 chan->subframe_len[chan->num_subframes] = subframe_len;
573 num_samples[c] += subframe_len;
574 ++chan->num_subframes;
575 if (num_samples[c] > s->samples_per_frame) {
576 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
577 "channel len > samples_per_frame\n");
578 return AVERROR_INVALIDDATA;
580 } else if (num_samples[c] <= min_channel_len) {
581 if (num_samples[c] < min_channel_len) {
582 channels_for_cur_subframe = 0;
583 min_channel_len = num_samples[c];
585 ++channels_for_cur_subframe;
588 } while (min_channel_len < s->samples_per_frame);
590 for (c = 0; c < s->num_channels; c++) {
593 for (i = 0; i < s->channel[c].num_subframes; i++) {
594 av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
595 " len %i\n", s->frame_num, c, i,
596 s->channel[c].subframe_len[i]);
597 s->channel[c].subframe_offset[i] = offset;
598 offset += s->channel[c].subframe_len[i];
606 *@brief Calculate a decorrelation matrix from the bitstream parameters.
607 *@param s codec context
608 *@param chgroup channel group for which the matrix needs to be calculated
610 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
611 WMAProChannelGrp *chgroup)
615 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
616 memset(chgroup->decorrelation_matrix, 0, s->num_channels *
617 s->num_channels * sizeof(*chgroup->decorrelation_matrix));
619 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
620 rotation_offset[i] = get_bits(&s->gb, 6);
622 for (i = 0; i < chgroup->num_channels; i++)
623 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
624 get_bits1(&s->gb) ? 1.0 : -1.0;
626 for (i = 1; i < chgroup->num_channels; i++) {
628 for (x = 0; x < i; x++) {
630 for (y = 0; y < i + 1; y++) {
631 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
632 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
633 int n = rotation_offset[offset + x];
639 cosv = sin64[32 - n];
641 sinv = sin64[64 - n];
642 cosv = -sin64[n - 32];
645 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
646 (v1 * sinv) - (v2 * cosv);
647 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
648 (v1 * cosv) + (v2 * sinv);
656 *@brief Decode channel transformation parameters
657 *@param s codec context
658 *@return 0 in case of success, < 0 in case of bitstream errors
660 static int decode_channel_transform(WMAProDecodeCtx* s)
663 /* should never consume more than 1921 bits for the 8 channel case
664 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
665 * + MAX_CHANNELS + MAX_BANDS + 1)
668 /** in the one channel case channel transforms are pointless */
670 if (s->num_channels > 1) {
671 int remaining_channels = s->channels_for_cur_subframe;
673 if (get_bits1(&s->gb)) {
674 av_log_ask_for_sample(s->avctx,
675 "unsupported channel transform bit\n");
676 return AVERROR_INVALIDDATA;
679 for (s->num_chgroups = 0; remaining_channels &&
680 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
681 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
682 float** channel_data = chgroup->channel_data;
683 chgroup->num_channels = 0;
684 chgroup->transform = 0;
686 /** decode channel mask */
687 if (remaining_channels > 2) {
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 && get_bits1(&s->gb)) {
692 ++chgroup->num_channels;
693 s->channel[channel_idx].grouped = 1;
694 *channel_data++ = s->channel[channel_idx].coeffs;
698 chgroup->num_channels = remaining_channels;
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 *channel_data++ = s->channel[channel_idx].coeffs;
703 s->channel[channel_idx].grouped = 1;
707 /** decode transform type */
708 if (chgroup->num_channels == 2) {
709 if (get_bits1(&s->gb)) {
710 if (get_bits1(&s->gb)) {
711 av_log_ask_for_sample(s->avctx,
712 "unsupported channel transform type\n");
715 chgroup->transform = 1;
716 if (s->num_channels == 2) {
717 chgroup->decorrelation_matrix[0] = 1.0;
718 chgroup->decorrelation_matrix[1] = -1.0;
719 chgroup->decorrelation_matrix[2] = 1.0;
720 chgroup->decorrelation_matrix[3] = 1.0;
723 chgroup->decorrelation_matrix[0] = 0.70703125;
724 chgroup->decorrelation_matrix[1] = -0.70703125;
725 chgroup->decorrelation_matrix[2] = 0.70703125;
726 chgroup->decorrelation_matrix[3] = 0.70703125;
729 } else if (chgroup->num_channels > 2) {
730 if (get_bits1(&s->gb)) {
731 chgroup->transform = 1;
732 if (get_bits1(&s->gb)) {
733 decode_decorrelation_matrix(s, chgroup);
735 /** FIXME: more than 6 coupled channels not supported */
736 if (chgroup->num_channels > 6) {
737 av_log_ask_for_sample(s->avctx,
738 "coupled channels > 6\n");
740 memcpy(chgroup->decorrelation_matrix,
741 default_decorrelation[chgroup->num_channels],
742 chgroup->num_channels * chgroup->num_channels *
743 sizeof(*chgroup->decorrelation_matrix));
749 /** decode transform on / off */
750 if (chgroup->transform) {
751 if (!get_bits1(&s->gb)) {
753 /** transform can be enabled for individual bands */
754 for (i = 0; i < s->num_bands; i++) {
755 chgroup->transform_band[i] = get_bits1(&s->gb);
758 memset(chgroup->transform_band, 1, s->num_bands);
761 remaining_channels -= chgroup->num_channels;
768 *@brief Extract the coefficients from the bitstream.
769 *@param s codec context
770 *@param c current channel number
771 *@return 0 on success, < 0 in case of bitstream errors
773 static int decode_coeffs(WMAProDecodeCtx *s, int c)
775 /* Integers 0..15 as single-precision floats. The table saves a
776 costly int to float conversion, and storing the values as
777 integers allows fast sign-flipping. */
778 static const uint32_t fval_tab[16] = {
779 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
780 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
781 0x41000000, 0x41100000, 0x41200000, 0x41300000,
782 0x41400000, 0x41500000, 0x41600000, 0x41700000,
786 WMAProChannelCtx* ci = &s->channel[c];
793 av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
795 vlctable = get_bits1(&s->gb);
796 vlc = &coef_vlc[vlctable];
806 /** decode vector coefficients (consumes up to 167 bits per iteration for
807 4 vector coded large values) */
808 while ((s->transmit_num_vec_coeffs || !rl_mode) &&
809 (cur_coeff + 3 < ci->num_vec_coeffs)) {
814 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
816 if (idx == HUFF_VEC4_SIZE - 1) {
817 for (i = 0; i < 4; i += 2) {
818 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
819 if (idx == HUFF_VEC2_SIZE - 1) {
821 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
822 if (v0 == HUFF_VEC1_SIZE - 1)
823 v0 += ff_wma_get_large_val(&s->gb);
824 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
825 if (v1 == HUFF_VEC1_SIZE - 1)
826 v1 += ff_wma_get_large_val(&s->gb);
827 vals[i ] = av_float2int(v0);
828 vals[i+1] = av_float2int(v1);
830 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
831 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
835 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
836 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
837 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
838 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
842 for (i = 0; i < 4; i++) {
844 uint32_t sign = get_bits1(&s->gb) - 1;
845 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
848 ci->coeffs[cur_coeff] = 0;
849 /** switch to run level mode when subframe_len / 128 zeros
850 were found in a row */
851 rl_mode |= (++num_zeros > s->subframe_len >> 8);
857 /** decode run level coded coefficients */
858 if (cur_coeff < s->subframe_len) {
859 memset(&ci->coeffs[cur_coeff], 0,
860 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
861 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
862 level, run, 1, ci->coeffs,
863 cur_coeff, s->subframe_len,
864 s->subframe_len, s->esc_len, 0))
865 return AVERROR_INVALIDDATA;
872 *@brief Extract scale factors from the bitstream.
873 *@param s codec context
874 *@return 0 on success, < 0 in case of bitstream errors
876 static int decode_scale_factors(WMAProDecodeCtx* s)
880 /** should never consume more than 5344 bits
881 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
884 for (i = 0; i < s->channels_for_cur_subframe; i++) {
885 int c = s->channel_indexes_for_cur_subframe[i];
888 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
889 sf_end = s->channel[c].scale_factors + s->num_bands;
891 /** resample scale factors for the new block size
892 * as the scale factors might need to be resampled several times
893 * before some new values are transmitted, a backup of the last
894 * transmitted scale factors is kept in saved_scale_factors
896 if (s->channel[c].reuse_sf) {
897 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
899 for (b = 0; b < s->num_bands; b++)
900 s->channel[c].scale_factors[b] =
901 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
904 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
906 if (!s->channel[c].reuse_sf) {
908 /** decode DPCM coded scale factors */
909 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
910 val = 45 / s->channel[c].scale_factor_step;
911 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
912 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
917 /** run level decode differences to the resampled factors */
918 for (i = 0; i < s->num_bands; i++) {
924 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
927 uint32_t code = get_bits(&s->gb, 14);
929 sign = (code & 1) - 1;
930 skip = (code & 0x3f) >> 1;
931 } else if (idx == 1) {
934 skip = scale_rl_run[idx];
935 val = scale_rl_level[idx];
936 sign = get_bits1(&s->gb)-1;
940 if (i >= s->num_bands) {
941 av_log(s->avctx, AV_LOG_ERROR,
942 "invalid scale factor coding\n");
943 return AVERROR_INVALIDDATA;
945 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
949 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
950 s->channel[c].table_idx = s->table_idx;
951 s->channel[c].reuse_sf = 1;
954 /** calculate new scale factor maximum */
955 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
956 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
957 s->channel[c].max_scale_factor =
958 FFMAX(s->channel[c].max_scale_factor, *sf);
966 *@brief Reconstruct the individual channel data.
967 *@param s codec context
969 static void inverse_channel_transform(WMAProDecodeCtx *s)
973 for (i = 0; i < s->num_chgroups; i++) {
974 if (s->chgroup[i].transform) {
975 float data[WMAPRO_MAX_CHANNELS];
976 const int num_channels = s->chgroup[i].num_channels;
977 float** ch_data = s->chgroup[i].channel_data;
978 float** ch_end = ch_data + num_channels;
979 const int8_t* tb = s->chgroup[i].transform_band;
982 /** multichannel decorrelation */
983 for (sfb = s->cur_sfb_offsets;
984 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
987 /** multiply values with the decorrelation_matrix */
988 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
989 const float* mat = s->chgroup[i].decorrelation_matrix;
990 const float* data_end = data + num_channels;
991 float* data_ptr = data;
994 for (ch = ch_data; ch < ch_end; ch++)
995 *data_ptr++ = (*ch)[y];
997 for (ch = ch_data; ch < ch_end; ch++) {
1000 while (data_ptr < data_end)
1001 sum += *data_ptr++ * *mat++;
1006 } else if (s->num_channels == 2) {
1007 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1008 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1009 ch_data[0] + sfb[0],
1011 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1012 ch_data[1] + sfb[0],
1021 *@brief Apply sine window and reconstruct the output buffer.
1022 *@param s codec context
1024 static void wmapro_window(WMAProDecodeCtx *s)
1027 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1028 int c = s->channel_indexes_for_cur_subframe[i];
1030 int winlen = s->channel[c].prev_block_len;
1031 float* start = s->channel[c].coeffs - (winlen >> 1);
1033 if (s->subframe_len < winlen) {
1034 start += (winlen - s->subframe_len) >> 1;
1035 winlen = s->subframe_len;
1038 window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1042 s->dsp.vector_fmul_window(start, start, start + winlen,
1045 s->channel[c].prev_block_len = s->subframe_len;
1050 *@brief Decode a single subframe (block).
1051 *@param s codec context
1052 *@return 0 on success, < 0 when decoding failed
1054 static int decode_subframe(WMAProDecodeCtx *s)
1056 int offset = s->samples_per_frame;
1057 int subframe_len = s->samples_per_frame;
1059 int total_samples = s->samples_per_frame * s->num_channels;
1060 int transmit_coeffs = 0;
1061 int cur_subwoofer_cutoff;
1063 s->subframe_offset = get_bits_count(&s->gb);
1065 /** reset channel context and find the next block offset and size
1066 == the next block of the channel with the smallest number of
1069 for (i = 0; i < s->num_channels; i++) {
1070 s->channel[i].grouped = 0;
1071 if (offset > s->channel[i].decoded_samples) {
1072 offset = s->channel[i].decoded_samples;
1074 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1079 "processing subframe with offset %i len %i\n", offset, subframe_len);
1081 /** get a list of all channels that contain the estimated block */
1082 s->channels_for_cur_subframe = 0;
1083 for (i = 0; i < s->num_channels; i++) {
1084 const int cur_subframe = s->channel[i].cur_subframe;
1085 /** substract already processed samples */
1086 total_samples -= s->channel[i].decoded_samples;
1088 /** and count if there are multiple subframes that match our profile */
1089 if (offset == s->channel[i].decoded_samples &&
1090 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1091 total_samples -= s->channel[i].subframe_len[cur_subframe];
1092 s->channel[i].decoded_samples +=
1093 s->channel[i].subframe_len[cur_subframe];
1094 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1095 ++s->channels_for_cur_subframe;
1099 /** check if the frame will be complete after processing the
1102 s->parsed_all_subframes = 1;
1105 av_dlog(s->avctx, "subframe is part of %i channels\n",
1106 s->channels_for_cur_subframe);
1108 /** calculate number of scale factor bands and their offsets */
1109 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1110 s->num_bands = s->num_sfb[s->table_idx];
1111 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1112 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1114 /** configure the decoder for the current subframe */
1115 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1116 int c = s->channel_indexes_for_cur_subframe[i];
1118 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1122 s->subframe_len = subframe_len;
1123 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1125 /** skip extended header if any */
1126 if (get_bits1(&s->gb)) {
1128 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1129 int len = get_bits(&s->gb, 4);
1130 num_fill_bits = get_bits(&s->gb, len) + 1;
1133 if (num_fill_bits >= 0) {
1134 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1135 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1136 return AVERROR_INVALIDDATA;
1139 skip_bits_long(&s->gb, num_fill_bits);
1143 /** no idea for what the following bit is used */
1144 if (get_bits1(&s->gb)) {
1145 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1146 return AVERROR_INVALIDDATA;
1150 if (decode_channel_transform(s) < 0)
1151 return AVERROR_INVALIDDATA;
1154 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1155 int c = s->channel_indexes_for_cur_subframe[i];
1156 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1157 transmit_coeffs = 1;
1160 if (transmit_coeffs) {
1162 int quant_step = 90 * s->bits_per_sample >> 4;
1164 /** decode number of vector coded coefficients */
1165 if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1166 int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1167 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1168 int c = s->channel_indexes_for_cur_subframe[i];
1169 s->channel[c].num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1172 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1173 int c = s->channel_indexes_for_cur_subframe[i];
1174 s->channel[c].num_vec_coeffs = s->subframe_len;
1177 /** decode quantization step */
1178 step = get_sbits(&s->gb, 6);
1180 if (step == -32 || step == 31) {
1181 const int sign = (step == 31) - 1;
1183 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1184 (step = get_bits(&s->gb, 5)) == 31) {
1187 quant_step += ((quant + step) ^ sign) - sign;
1189 if (quant_step < 0) {
1190 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1193 /** decode quantization step modifiers for every channel */
1195 if (s->channels_for_cur_subframe == 1) {
1196 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1198 int modifier_len = get_bits(&s->gb, 3);
1199 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1200 int c = s->channel_indexes_for_cur_subframe[i];
1201 s->channel[c].quant_step = quant_step;
1202 if (get_bits1(&s->gb)) {
1204 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1206 ++s->channel[c].quant_step;
1211 /** decode scale factors */
1212 if (decode_scale_factors(s) < 0)
1213 return AVERROR_INVALIDDATA;
1216 av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1217 get_bits_count(&s->gb) - s->subframe_offset);
1219 /** parse coefficients */
1220 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1221 int c = s->channel_indexes_for_cur_subframe[i];
1222 if (s->channel[c].transmit_coefs &&
1223 get_bits_count(&s->gb) < s->num_saved_bits) {
1224 decode_coeffs(s, c);
1226 memset(s->channel[c].coeffs, 0,
1227 sizeof(*s->channel[c].coeffs) * subframe_len);
1230 av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1231 get_bits_count(&s->gb) - s->subframe_offset);
1233 if (transmit_coeffs) {
1234 FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1235 /** reconstruct the per channel data */
1236 inverse_channel_transform(s);
1237 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1238 int c = s->channel_indexes_for_cur_subframe[i];
1239 const int* sf = s->channel[c].scale_factors;
1242 if (c == s->lfe_channel)
1243 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1244 (subframe_len - cur_subwoofer_cutoff));
1246 /** inverse quantization and rescaling */
1247 for (b = 0; b < s->num_bands; b++) {
1248 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1249 const int exp = s->channel[c].quant_step -
1250 (s->channel[c].max_scale_factor - *sf++) *
1251 s->channel[c].scale_factor_step;
1252 const float quant = pow(10.0, exp / 20.0);
1253 int start = s->cur_sfb_offsets[b];
1254 s->dsp.vector_fmul_scalar(s->tmp + start,
1255 s->channel[c].coeffs + start,
1256 quant, end - start);
1259 /** apply imdct (imdct_half == DCTIV with reverse) */
1260 mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1264 /** window and overlapp-add */
1267 /** handled one subframe */
1268 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1269 int c = s->channel_indexes_for_cur_subframe[i];
1270 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1271 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1272 return AVERROR_INVALIDDATA;
1274 ++s->channel[c].cur_subframe;
1281 *@brief Decode one WMA frame.
1282 *@param s codec context
1283 *@return 0 if the trailer bit indicates that this is the last frame,
1284 * 1 if there are additional frames
1286 static int decode_frame(WMAProDecodeCtx *s, int *got_frame_ptr)
1288 AVCodecContext *avctx = s->avctx;
1289 GetBitContext* gb = &s->gb;
1290 int more_frames = 0;
1293 const float *out_ptr[WMAPRO_MAX_CHANNELS];
1296 /** get frame length */
1298 len = get_bits(gb, s->log2_frame_size);
1300 av_dlog(s->avctx, "decoding frame with length %x\n", len);
1302 /** decode tile information */
1303 if (decode_tilehdr(s)) {
1308 /** read postproc transform */
1309 if (s->num_channels > 1 && get_bits1(gb)) {
1310 if (get_bits1(gb)) {
1311 for (i = 0; i < s->num_channels * s->num_channels; i++)
1316 /** read drc info */
1317 if (s->dynamic_range_compression) {
1318 s->drc_gain = get_bits(gb, 8);
1319 av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1322 /** no idea what these are for, might be the number of samples
1323 that need to be skipped at the beginning or end of a stream */
1324 if (get_bits1(gb)) {
1327 /** usually true for the first frame */
1328 if (get_bits1(gb)) {
1329 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1330 av_dlog(s->avctx, "start skip: %i\n", skip);
1333 /** sometimes true for the last frame */
1334 if (get_bits1(gb)) {
1335 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1336 av_dlog(s->avctx, "end skip: %i\n", skip);
1341 av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1342 get_bits_count(gb) - s->frame_offset);
1344 /** reset subframe states */
1345 s->parsed_all_subframes = 0;
1346 for (i = 0; i < s->num_channels; i++) {
1347 s->channel[i].decoded_samples = 0;
1348 s->channel[i].cur_subframe = 0;
1349 s->channel[i].reuse_sf = 0;
1352 /** decode all subframes */
1353 while (!s->parsed_all_subframes) {
1354 if (decode_subframe(s) < 0) {
1360 /* get output buffer */
1361 s->frame.nb_samples = s->samples_per_frame;
1362 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1363 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1367 samples = (float *)s->frame.data[0];
1369 /** interleave samples and write them to the output buffer */
1370 for (i = 0; i < s->num_channels; i++)
1371 out_ptr[i] = s->channel[i].out;
1372 s->fmt_conv.float_interleave(samples, out_ptr, s->samples_per_frame,
1375 for (i = 0; i < s->num_channels; i++) {
1376 /** reuse second half of the IMDCT output for the next frame */
1377 memcpy(&s->channel[i].out[0],
1378 &s->channel[i].out[s->samples_per_frame],
1379 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1382 if (s->skip_frame) {
1389 if (s->len_prefix) {
1390 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1391 /** FIXME: not sure if this is always an error */
1392 av_log(s->avctx, AV_LOG_ERROR,
1393 "frame[%i] would have to skip %i bits\n", s->frame_num,
1394 len - (get_bits_count(gb) - s->frame_offset) - 1);
1399 /** skip the rest of the frame data */
1400 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1402 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1406 /** decode trailer bit */
1407 more_frames = get_bits1(gb);
1414 *@brief Calculate remaining input buffer length.
1415 *@param s codec context
1416 *@param gb bitstream reader context
1417 *@return remaining size in bits
1419 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1421 return s->buf_bit_size - get_bits_count(gb);
1425 *@brief Fill the bit reservoir with a (partial) frame.
1426 *@param s codec context
1427 *@param gb bitstream reader context
1428 *@param len length of the partial frame
1429 *@param append decides whether to reset the buffer or not
1431 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1436 /** when the frame data does not need to be concatenated, the input buffer
1437 is resetted and additional bits from the previous frame are copyed
1438 and skipped later so that a fast byte copy is possible */
1441 s->frame_offset = get_bits_count(gb) & 7;
1442 s->num_saved_bits = s->frame_offset;
1443 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1446 buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1448 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1449 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1454 s->num_saved_bits += len;
1456 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1459 int align = 8 - (get_bits_count(gb) & 7);
1460 align = FFMIN(align, len);
1461 put_bits(&s->pb, align, get_bits(gb, align));
1463 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1465 skip_bits_long(gb, len);
1468 PutBitContext tmp = s->pb;
1469 flush_put_bits(&tmp);
1472 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1473 skip_bits(&s->gb, s->frame_offset);
1477 *@brief Decode a single WMA packet.
1478 *@param avctx codec context
1479 *@param data the output buffer
1480 *@param data_size number of bytes that were written to the output buffer
1481 *@param avpkt input packet
1482 *@return number of bytes that were read from the input buffer
1484 static int decode_packet(AVCodecContext *avctx, void *data,
1485 int *got_frame_ptr, AVPacket* avpkt)
1487 WMAProDecodeCtx *s = avctx->priv_data;
1488 GetBitContext* gb = &s->pgb;
1489 const uint8_t* buf = avpkt->data;
1490 int buf_size = avpkt->size;
1491 int num_bits_prev_frame;
1492 int packet_sequence_number;
1496 if (s->packet_done || s->packet_loss) {
1499 /** sanity check for the buffer length */
1500 if (buf_size < avctx->block_align)
1503 s->next_packet_start = buf_size - avctx->block_align;
1504 buf_size = avctx->block_align;
1505 s->buf_bit_size = buf_size << 3;
1507 /** parse packet header */
1508 init_get_bits(gb, buf, s->buf_bit_size);
1509 packet_sequence_number = get_bits(gb, 4);
1512 /** get number of bits that need to be added to the previous frame */
1513 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1514 av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1515 num_bits_prev_frame);
1517 /** check for packet loss */
1518 if (!s->packet_loss &&
1519 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1521 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1522 s->packet_sequence_number, packet_sequence_number);
1524 s->packet_sequence_number = packet_sequence_number;
1526 if (num_bits_prev_frame > 0) {
1527 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1528 if (num_bits_prev_frame >= remaining_packet_bits) {
1529 num_bits_prev_frame = remaining_packet_bits;
1533 /** append the previous frame data to the remaining data from the
1534 previous packet to create a full frame */
1535 save_bits(s, gb, num_bits_prev_frame, 1);
1536 av_dlog(avctx, "accumulated %x bits of frame data\n",
1537 s->num_saved_bits - s->frame_offset);
1539 /** decode the cross packet frame if it is valid */
1540 if (!s->packet_loss)
1541 decode_frame(s, got_frame_ptr);
1542 } else if (s->num_saved_bits - s->frame_offset) {
1543 av_dlog(avctx, "ignoring %x previously saved bits\n",
1544 s->num_saved_bits - s->frame_offset);
1547 if (s->packet_loss) {
1548 /** reset number of saved bits so that the decoder
1549 does not start to decode incomplete frames in the
1550 s->len_prefix == 0 case */
1551 s->num_saved_bits = 0;
1557 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1558 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1559 skip_bits(gb, s->packet_offset);
1560 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1561 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1562 frame_size <= remaining_bits(s, gb)) {
1563 save_bits(s, gb, frame_size, 0);
1564 s->packet_done = !decode_frame(s, got_frame_ptr);
1565 } else if (!s->len_prefix
1566 && s->num_saved_bits > get_bits_count(&s->gb)) {
1567 /** when the frames do not have a length prefix, we don't know
1568 the compressed length of the individual frames
1569 however, we know what part of a new packet belongs to the
1571 therefore we save the incoming packet first, then we append
1572 the "previous frame" data from the next packet so that
1573 we get a buffer that only contains full frames */
1574 s->packet_done = !decode_frame(s, got_frame_ptr);
1579 if (s->packet_done && !s->packet_loss &&
1580 remaining_bits(s, gb) > 0) {
1581 /** save the rest of the data so that it can be decoded
1582 with the next packet */
1583 save_bits(s, gb, remaining_bits(s, gb), 0);
1586 s->packet_offset = get_bits_count(gb) & 7;
1588 return AVERROR_INVALIDDATA;
1591 *(AVFrame *)data = s->frame;
1593 return get_bits_count(gb) >> 3;
1597 *@brief Clear decoder buffers (for seeking).
1598 *@param avctx codec context
1600 static void flush(AVCodecContext *avctx)
1602 WMAProDecodeCtx *s = avctx->priv_data;
1604 /** reset output buffer as a part of it is used during the windowing of a
1606 for (i = 0; i < s->num_channels; i++)
1607 memset(s->channel[i].out, 0, s->samples_per_frame *
1608 sizeof(*s->channel[i].out));
1614 *@brief wmapro decoder
1616 AVCodec ff_wmapro_decoder = {
1618 .type = AVMEDIA_TYPE_AUDIO,
1619 .id = CODEC_ID_WMAPRO,
1620 .priv_data_size = sizeof(WMAProDecodeCtx),
1621 .init = decode_init,
1622 .close = decode_end,
1623 .decode = decode_packet,
1624 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1626 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),