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 Libav.
8 * Libav 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 * Libav 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 Libav; 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 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 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 ff_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 bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
314 if (bits > WMAPRO_BLOCK_MAX_BITS) {
315 av_log_missing_feature(avctx, "14-bits block sizes", 1);
316 return AVERROR_INVALIDDATA;
318 s->samples_per_frame = 1 << bits;
321 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
322 s->max_num_subframes = 1 << log2_max_num_subframes;
323 if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
324 s->max_subframe_len_bit = 1;
325 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
327 num_possible_block_sizes = log2_max_num_subframes + 1;
328 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
329 s->dynamic_range_compression = (s->decode_flags & 0x80);
331 if (s->max_num_subframes > MAX_SUBFRAMES) {
332 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
333 s->max_num_subframes);
334 return AVERROR_INVALIDDATA;
337 s->num_channels = avctx->channels;
339 if (s->num_channels < 0) {
340 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
341 return AVERROR_INVALIDDATA;
342 } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
343 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
344 return AVERROR_PATCHWELCOME;
347 /** init previous block len */
348 for (i = 0; i < s->num_channels; i++)
349 s->channel[i].prev_block_len = s->samples_per_frame;
351 /** extract lfe channel position */
354 if (channel_mask & 8) {
356 for (mask = 1; mask < 16; mask <<= 1) {
357 if (channel_mask & mask)
362 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
363 scale_huffbits, 1, 1,
364 scale_huffcodes, 2, 2, 616);
366 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
367 scale_rl_huffbits, 1, 1,
368 scale_rl_huffcodes, 4, 4, 1406);
370 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
371 coef0_huffbits, 1, 1,
372 coef0_huffcodes, 4, 4, 2108);
374 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
375 coef1_huffbits, 1, 1,
376 coef1_huffcodes, 4, 4, 3912);
378 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
380 vec4_huffcodes, 2, 2, 604);
382 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
384 vec2_huffcodes, 2, 2, 562);
386 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
388 vec1_huffcodes, 2, 2, 562);
390 /** calculate number of scale factor bands and their offsets
391 for every possible block size */
392 for (i = 0; i < num_possible_block_sizes; i++) {
393 int subframe_len = s->samples_per_frame >> i;
397 s->sfb_offsets[i][0] = 0;
399 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
400 int offset = (subframe_len * 2 * critical_freq[x])
401 / s->avctx->sample_rate + 2;
403 if (offset > s->sfb_offsets[i][band - 1])
404 s->sfb_offsets[i][band++] = offset;
406 s->sfb_offsets[i][band - 1] = subframe_len;
407 s->num_sfb[i] = band - 1;
411 /** Scale factors can be shared between blocks of different size
412 as every block has a different scale factor band layout.
413 The matrix sf_offsets is needed to find the correct scale factor.
416 for (i = 0; i < num_possible_block_sizes; i++) {
418 for (b = 0; b < s->num_sfb[i]; b++) {
420 int offset = ((s->sfb_offsets[i][b]
421 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
422 for (x = 0; x < num_possible_block_sizes; x++) {
424 while (s->sfb_offsets[x][v + 1] << x < offset)
426 s->sf_offsets[i][x][b] = v;
431 /** init MDCT, FIXME: only init needed sizes */
432 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
433 ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
434 1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
435 / (1 << (s->bits_per_sample - 1)));
437 /** init MDCT windows: simple sinus window */
438 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
439 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
440 ff_init_ff_sine_windows(win_idx);
441 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
444 /** calculate subwoofer cutoff values */
445 for (i = 0; i < num_possible_block_sizes; i++) {
446 int block_size = s->samples_per_frame >> i;
447 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
448 / s->avctx->sample_rate;
449 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
452 /** calculate sine values for the decorrelation matrix */
453 for (i = 0; i < 33; i++)
454 sin64[i] = sin(i*M_PI / 64.0);
456 if (avctx->debug & FF_DEBUG_BITSTREAM)
459 avctx->channel_layout = channel_mask;
461 avcodec_get_frame_defaults(&s->frame);
462 avctx->coded_frame = &s->frame;
468 *@brief Decode the subframe length.
470 *@param offset sample offset in the frame
471 *@return decoded subframe length on success, < 0 in case of an error
473 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
475 int frame_len_shift = 0;
478 /** no need to read from the bitstream when only one length is possible */
479 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
480 return s->min_samples_per_subframe;
482 /** 1 bit indicates if the subframe is of maximum length */
483 if (s->max_subframe_len_bit) {
484 if (get_bits1(&s->gb))
485 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
487 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
489 subframe_len = s->samples_per_frame >> frame_len_shift;
491 /** sanity check the length */
492 if (subframe_len < s->min_samples_per_subframe ||
493 subframe_len > s->samples_per_frame) {
494 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
496 return AVERROR_INVALIDDATA;
502 *@brief Decode how the data in the frame is split into subframes.
503 * Every WMA frame contains the encoded data for a fixed number of
504 * samples per channel. The data for every channel might be split
505 * into several subframes. This function will reconstruct the list of
506 * subframes for every channel.
508 * If the subframes are not evenly split, the algorithm estimates the
509 * channels with the lowest number of total samples.
510 * Afterwards, for each of these channels a bit is read from the
511 * bitstream that indicates if the channel contains a subframe with the
512 * next subframe size that is going to be read from the bitstream or not.
513 * If a channel contains such a subframe, the subframe size gets added to
514 * the channel's subframe list.
515 * The algorithm repeats these steps until the frame is properly divided
516 * between the individual channels.
519 *@return 0 on success, < 0 in case of an error
521 static int decode_tilehdr(WMAProDecodeCtx *s)
523 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /**< sum of samples for all currently known subframes of a channel */
524 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
525 int channels_for_cur_subframe = s->num_channels; /**< number of channels that contain the current subframe */
526 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
527 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
530 /* Should never consume more than 3073 bits (256 iterations for the
531 * while loop when always the minimum amount of 128 samples is substracted
532 * from missing samples in the 8 channel case).
533 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
536 /** reset tiling information */
537 for (c = 0; c < s->num_channels; c++)
538 s->channel[c].num_subframes = 0;
540 memset(num_samples, 0, sizeof(num_samples));
542 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
543 fixed_channel_layout = 1;
545 /** loop until the frame data is split between the subframes */
549 /** check which channels contain the subframe */
550 for (c = 0; c < s->num_channels; c++) {
551 if (num_samples[c] == min_channel_len) {
552 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
553 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
554 contains_subframe[c] = 1;
556 contains_subframe[c] = get_bits1(&s->gb);
558 contains_subframe[c] = 0;
561 /** get subframe length, subframe_len == 0 is not allowed */
562 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
563 return AVERROR_INVALIDDATA;
565 /** add subframes to the individual channels and find new min_channel_len */
566 min_channel_len += subframe_len;
567 for (c = 0; c < s->num_channels; c++) {
568 WMAProChannelCtx* chan = &s->channel[c];
570 if (contains_subframe[c]) {
571 if (chan->num_subframes >= MAX_SUBFRAMES) {
572 av_log(s->avctx, AV_LOG_ERROR,
573 "broken frame: num subframes > 31\n");
574 return AVERROR_INVALIDDATA;
576 chan->subframe_len[chan->num_subframes] = subframe_len;
577 num_samples[c] += subframe_len;
578 ++chan->num_subframes;
579 if (num_samples[c] > s->samples_per_frame) {
580 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
581 "channel len > samples_per_frame\n");
582 return AVERROR_INVALIDDATA;
584 } else if (num_samples[c] <= min_channel_len) {
585 if (num_samples[c] < min_channel_len) {
586 channels_for_cur_subframe = 0;
587 min_channel_len = num_samples[c];
589 ++channels_for_cur_subframe;
592 } while (min_channel_len < s->samples_per_frame);
594 for (c = 0; c < s->num_channels; c++) {
597 for (i = 0; i < s->channel[c].num_subframes; i++) {
598 av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
599 " len %i\n", s->frame_num, c, i,
600 s->channel[c].subframe_len[i]);
601 s->channel[c].subframe_offset[i] = offset;
602 offset += s->channel[c].subframe_len[i];
610 *@brief Calculate a decorrelation matrix from the bitstream parameters.
611 *@param s codec context
612 *@param chgroup channel group for which the matrix needs to be calculated
614 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
615 WMAProChannelGrp *chgroup)
619 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
620 memset(chgroup->decorrelation_matrix, 0, s->num_channels *
621 s->num_channels * sizeof(*chgroup->decorrelation_matrix));
623 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
624 rotation_offset[i] = get_bits(&s->gb, 6);
626 for (i = 0; i < chgroup->num_channels; i++)
627 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
628 get_bits1(&s->gb) ? 1.0 : -1.0;
630 for (i = 1; i < chgroup->num_channels; i++) {
632 for (x = 0; x < i; x++) {
634 for (y = 0; y < i + 1; y++) {
635 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
636 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
637 int n = rotation_offset[offset + x];
643 cosv = sin64[32 - n];
645 sinv = sin64[64 - n];
646 cosv = -sin64[n - 32];
649 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
650 (v1 * sinv) - (v2 * cosv);
651 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
652 (v1 * cosv) + (v2 * sinv);
660 *@brief Decode channel transformation parameters
661 *@param s codec context
662 *@return 0 in case of success, < 0 in case of bitstream errors
664 static int decode_channel_transform(WMAProDecodeCtx* s)
667 /* should never consume more than 1921 bits for the 8 channel case
668 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
669 * + MAX_CHANNELS + MAX_BANDS + 1)
672 /** in the one channel case channel transforms are pointless */
674 if (s->num_channels > 1) {
675 int remaining_channels = s->channels_for_cur_subframe;
677 if (get_bits1(&s->gb)) {
678 av_log_ask_for_sample(s->avctx,
679 "unsupported channel transform bit\n");
680 return AVERROR_INVALIDDATA;
683 for (s->num_chgroups = 0; remaining_channels &&
684 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
685 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
686 float** channel_data = chgroup->channel_data;
687 chgroup->num_channels = 0;
688 chgroup->transform = 0;
690 /** decode channel mask */
691 if (remaining_channels > 2) {
692 for (i = 0; i < s->channels_for_cur_subframe; i++) {
693 int channel_idx = s->channel_indexes_for_cur_subframe[i];
694 if (!s->channel[channel_idx].grouped
695 && get_bits1(&s->gb)) {
696 ++chgroup->num_channels;
697 s->channel[channel_idx].grouped = 1;
698 *channel_data++ = s->channel[channel_idx].coeffs;
702 chgroup->num_channels = remaining_channels;
703 for (i = 0; i < s->channels_for_cur_subframe; i++) {
704 int channel_idx = s->channel_indexes_for_cur_subframe[i];
705 if (!s->channel[channel_idx].grouped)
706 *channel_data++ = s->channel[channel_idx].coeffs;
707 s->channel[channel_idx].grouped = 1;
711 /** decode transform type */
712 if (chgroup->num_channels == 2) {
713 if (get_bits1(&s->gb)) {
714 if (get_bits1(&s->gb)) {
715 av_log_ask_for_sample(s->avctx,
716 "unsupported channel transform type\n");
719 chgroup->transform = 1;
720 if (s->num_channels == 2) {
721 chgroup->decorrelation_matrix[0] = 1.0;
722 chgroup->decorrelation_matrix[1] = -1.0;
723 chgroup->decorrelation_matrix[2] = 1.0;
724 chgroup->decorrelation_matrix[3] = 1.0;
727 chgroup->decorrelation_matrix[0] = 0.70703125;
728 chgroup->decorrelation_matrix[1] = -0.70703125;
729 chgroup->decorrelation_matrix[2] = 0.70703125;
730 chgroup->decorrelation_matrix[3] = 0.70703125;
733 } else if (chgroup->num_channels > 2) {
734 if (get_bits1(&s->gb)) {
735 chgroup->transform = 1;
736 if (get_bits1(&s->gb)) {
737 decode_decorrelation_matrix(s, chgroup);
739 /** FIXME: more than 6 coupled channels not supported */
740 if (chgroup->num_channels > 6) {
741 av_log_ask_for_sample(s->avctx,
742 "coupled channels > 6\n");
744 memcpy(chgroup->decorrelation_matrix,
745 default_decorrelation[chgroup->num_channels],
746 chgroup->num_channels * chgroup->num_channels *
747 sizeof(*chgroup->decorrelation_matrix));
753 /** decode transform on / off */
754 if (chgroup->transform) {
755 if (!get_bits1(&s->gb)) {
757 /** transform can be enabled for individual bands */
758 for (i = 0; i < s->num_bands; i++) {
759 chgroup->transform_band[i] = get_bits1(&s->gb);
762 memset(chgroup->transform_band, 1, s->num_bands);
765 remaining_channels -= chgroup->num_channels;
772 *@brief Extract the coefficients from the bitstream.
773 *@param s codec context
774 *@param c current channel number
775 *@return 0 on success, < 0 in case of bitstream errors
777 static int decode_coeffs(WMAProDecodeCtx *s, int c)
779 /* Integers 0..15 as single-precision floats. The table saves a
780 costly int to float conversion, and storing the values as
781 integers allows fast sign-flipping. */
782 static const uint32_t fval_tab[16] = {
783 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
784 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
785 0x41000000, 0x41100000, 0x41200000, 0x41300000,
786 0x41400000, 0x41500000, 0x41600000, 0x41700000,
790 WMAProChannelCtx* ci = &s->channel[c];
797 av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
799 vlctable = get_bits1(&s->gb);
800 vlc = &coef_vlc[vlctable];
810 /** decode vector coefficients (consumes up to 167 bits per iteration for
811 4 vector coded large values) */
812 while ((s->transmit_num_vec_coeffs || !rl_mode) &&
813 (cur_coeff + 3 < ci->num_vec_coeffs)) {
818 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
820 if (idx == HUFF_VEC4_SIZE - 1) {
821 for (i = 0; i < 4; i += 2) {
822 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
823 if (idx == HUFF_VEC2_SIZE - 1) {
825 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
826 if (v0 == HUFF_VEC1_SIZE - 1)
827 v0 += ff_wma_get_large_val(&s->gb);
828 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
829 if (v1 == HUFF_VEC1_SIZE - 1)
830 v1 += ff_wma_get_large_val(&s->gb);
831 vals[i ] = av_float2int(v0);
832 vals[i+1] = av_float2int(v1);
834 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
835 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
839 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
840 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
841 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
842 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
846 for (i = 0; i < 4; i++) {
848 uint32_t sign = get_bits1(&s->gb) - 1;
849 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
852 ci->coeffs[cur_coeff] = 0;
853 /** switch to run level mode when subframe_len / 128 zeros
854 were found in a row */
855 rl_mode |= (++num_zeros > s->subframe_len >> 8);
861 /** decode run level coded coefficients */
862 if (cur_coeff < s->subframe_len) {
863 memset(&ci->coeffs[cur_coeff], 0,
864 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
865 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
866 level, run, 1, ci->coeffs,
867 cur_coeff, s->subframe_len,
868 s->subframe_len, s->esc_len, 0))
869 return AVERROR_INVALIDDATA;
876 *@brief Extract scale factors from the bitstream.
877 *@param s codec context
878 *@return 0 on success, < 0 in case of bitstream errors
880 static int decode_scale_factors(WMAProDecodeCtx* s)
884 /** should never consume more than 5344 bits
885 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
888 for (i = 0; i < s->channels_for_cur_subframe; i++) {
889 int c = s->channel_indexes_for_cur_subframe[i];
892 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
893 sf_end = s->channel[c].scale_factors + s->num_bands;
895 /** resample scale factors for the new block size
896 * as the scale factors might need to be resampled several times
897 * before some new values are transmitted, a backup of the last
898 * transmitted scale factors is kept in saved_scale_factors
900 if (s->channel[c].reuse_sf) {
901 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
903 for (b = 0; b < s->num_bands; b++)
904 s->channel[c].scale_factors[b] =
905 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
908 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
910 if (!s->channel[c].reuse_sf) {
912 /** decode DPCM coded scale factors */
913 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
914 val = 45 / s->channel[c].scale_factor_step;
915 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
916 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
921 /** run level decode differences to the resampled factors */
922 for (i = 0; i < s->num_bands; i++) {
928 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
931 uint32_t code = get_bits(&s->gb, 14);
933 sign = (code & 1) - 1;
934 skip = (code & 0x3f) >> 1;
935 } else if (idx == 1) {
938 skip = scale_rl_run[idx];
939 val = scale_rl_level[idx];
940 sign = get_bits1(&s->gb)-1;
944 if (i >= s->num_bands) {
945 av_log(s->avctx, AV_LOG_ERROR,
946 "invalid scale factor coding\n");
947 return AVERROR_INVALIDDATA;
949 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
953 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
954 s->channel[c].table_idx = s->table_idx;
955 s->channel[c].reuse_sf = 1;
958 /** calculate new scale factor maximum */
959 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
960 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
961 s->channel[c].max_scale_factor =
962 FFMAX(s->channel[c].max_scale_factor, *sf);
970 *@brief Reconstruct the individual channel data.
971 *@param s codec context
973 static void inverse_channel_transform(WMAProDecodeCtx *s)
977 for (i = 0; i < s->num_chgroups; i++) {
978 if (s->chgroup[i].transform) {
979 float data[WMAPRO_MAX_CHANNELS];
980 const int num_channels = s->chgroup[i].num_channels;
981 float** ch_data = s->chgroup[i].channel_data;
982 float** ch_end = ch_data + num_channels;
983 const int8_t* tb = s->chgroup[i].transform_band;
986 /** multichannel decorrelation */
987 for (sfb = s->cur_sfb_offsets;
988 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
991 /** multiply values with the decorrelation_matrix */
992 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
993 const float* mat = s->chgroup[i].decorrelation_matrix;
994 const float* data_end = data + num_channels;
995 float* data_ptr = data;
998 for (ch = ch_data; ch < ch_end; ch++)
999 *data_ptr++ = (*ch)[y];
1001 for (ch = ch_data; ch < ch_end; ch++) {
1004 while (data_ptr < data_end)
1005 sum += *data_ptr++ * *mat++;
1010 } else if (s->num_channels == 2) {
1011 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1012 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1013 ch_data[0] + sfb[0],
1015 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1016 ch_data[1] + sfb[0],
1025 *@brief Apply sine window and reconstruct the output buffer.
1026 *@param s codec context
1028 static void wmapro_window(WMAProDecodeCtx *s)
1031 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1032 int c = s->channel_indexes_for_cur_subframe[i];
1034 int winlen = s->channel[c].prev_block_len;
1035 float* start = s->channel[c].coeffs - (winlen >> 1);
1037 if (s->subframe_len < winlen) {
1038 start += (winlen - s->subframe_len) >> 1;
1039 winlen = s->subframe_len;
1042 window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1046 s->dsp.vector_fmul_window(start, start, start + winlen,
1049 s->channel[c].prev_block_len = s->subframe_len;
1054 *@brief Decode a single subframe (block).
1055 *@param s codec context
1056 *@return 0 on success, < 0 when decoding failed
1058 static int decode_subframe(WMAProDecodeCtx *s)
1060 int offset = s->samples_per_frame;
1061 int subframe_len = s->samples_per_frame;
1063 int total_samples = s->samples_per_frame * s->num_channels;
1064 int transmit_coeffs = 0;
1065 int cur_subwoofer_cutoff;
1067 s->subframe_offset = get_bits_count(&s->gb);
1069 /** reset channel context and find the next block offset and size
1070 == the next block of the channel with the smallest number of
1073 for (i = 0; i < s->num_channels; i++) {
1074 s->channel[i].grouped = 0;
1075 if (offset > s->channel[i].decoded_samples) {
1076 offset = s->channel[i].decoded_samples;
1078 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1083 "processing subframe with offset %i len %i\n", offset, subframe_len);
1085 /** get a list of all channels that contain the estimated block */
1086 s->channels_for_cur_subframe = 0;
1087 for (i = 0; i < s->num_channels; i++) {
1088 const int cur_subframe = s->channel[i].cur_subframe;
1089 /** substract already processed samples */
1090 total_samples -= s->channel[i].decoded_samples;
1092 /** and count if there are multiple subframes that match our profile */
1093 if (offset == s->channel[i].decoded_samples &&
1094 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1095 total_samples -= s->channel[i].subframe_len[cur_subframe];
1096 s->channel[i].decoded_samples +=
1097 s->channel[i].subframe_len[cur_subframe];
1098 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1099 ++s->channels_for_cur_subframe;
1103 /** check if the frame will be complete after processing the
1106 s->parsed_all_subframes = 1;
1109 av_dlog(s->avctx, "subframe is part of %i channels\n",
1110 s->channels_for_cur_subframe);
1112 /** calculate number of scale factor bands and their offsets */
1113 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1114 s->num_bands = s->num_sfb[s->table_idx];
1115 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1116 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1118 /** configure the decoder for the current subframe */
1119 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1120 int c = s->channel_indexes_for_cur_subframe[i];
1122 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1126 s->subframe_len = subframe_len;
1127 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1129 /** skip extended header if any */
1130 if (get_bits1(&s->gb)) {
1132 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1133 int len = get_bits(&s->gb, 4);
1134 num_fill_bits = get_bits(&s->gb, len) + 1;
1137 if (num_fill_bits >= 0) {
1138 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1139 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1140 return AVERROR_INVALIDDATA;
1143 skip_bits_long(&s->gb, num_fill_bits);
1147 /** no idea for what the following bit is used */
1148 if (get_bits1(&s->gb)) {
1149 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1150 return AVERROR_INVALIDDATA;
1154 if (decode_channel_transform(s) < 0)
1155 return AVERROR_INVALIDDATA;
1158 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1159 int c = s->channel_indexes_for_cur_subframe[i];
1160 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1161 transmit_coeffs = 1;
1164 if (transmit_coeffs) {
1166 int quant_step = 90 * s->bits_per_sample >> 4;
1168 /** decode number of vector coded coefficients */
1169 if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1170 int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1171 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1172 int c = s->channel_indexes_for_cur_subframe[i];
1173 s->channel[c].num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1176 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1177 int c = s->channel_indexes_for_cur_subframe[i];
1178 s->channel[c].num_vec_coeffs = s->subframe_len;
1181 /** decode quantization step */
1182 step = get_sbits(&s->gb, 6);
1184 if (step == -32 || step == 31) {
1185 const int sign = (step == 31) - 1;
1187 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1188 (step = get_bits(&s->gb, 5)) == 31) {
1191 quant_step += ((quant + step) ^ sign) - sign;
1193 if (quant_step < 0) {
1194 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1197 /** decode quantization step modifiers for every channel */
1199 if (s->channels_for_cur_subframe == 1) {
1200 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1202 int modifier_len = get_bits(&s->gb, 3);
1203 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1204 int c = s->channel_indexes_for_cur_subframe[i];
1205 s->channel[c].quant_step = quant_step;
1206 if (get_bits1(&s->gb)) {
1208 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1210 ++s->channel[c].quant_step;
1215 /** decode scale factors */
1216 if (decode_scale_factors(s) < 0)
1217 return AVERROR_INVALIDDATA;
1220 av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1221 get_bits_count(&s->gb) - s->subframe_offset);
1223 /** parse coefficients */
1224 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1225 int c = s->channel_indexes_for_cur_subframe[i];
1226 if (s->channel[c].transmit_coefs &&
1227 get_bits_count(&s->gb) < s->num_saved_bits) {
1228 decode_coeffs(s, c);
1230 memset(s->channel[c].coeffs, 0,
1231 sizeof(*s->channel[c].coeffs) * subframe_len);
1234 av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1235 get_bits_count(&s->gb) - s->subframe_offset);
1237 if (transmit_coeffs) {
1238 FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1239 /** reconstruct the per channel data */
1240 inverse_channel_transform(s);
1241 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1242 int c = s->channel_indexes_for_cur_subframe[i];
1243 const int* sf = s->channel[c].scale_factors;
1246 if (c == s->lfe_channel)
1247 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1248 (subframe_len - cur_subwoofer_cutoff));
1250 /** inverse quantization and rescaling */
1251 for (b = 0; b < s->num_bands; b++) {
1252 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1253 const int exp = s->channel[c].quant_step -
1254 (s->channel[c].max_scale_factor - *sf++) *
1255 s->channel[c].scale_factor_step;
1256 const float quant = pow(10.0, exp / 20.0);
1257 int start = s->cur_sfb_offsets[b];
1258 s->dsp.vector_fmul_scalar(s->tmp + start,
1259 s->channel[c].coeffs + start,
1260 quant, end - start);
1263 /** apply imdct (imdct_half == DCTIV with reverse) */
1264 mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1268 /** window and overlapp-add */
1271 /** handled one subframe */
1272 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1273 int c = s->channel_indexes_for_cur_subframe[i];
1274 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1275 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1276 return AVERROR_INVALIDDATA;
1278 ++s->channel[c].cur_subframe;
1285 *@brief Decode one WMA frame.
1286 *@param s codec context
1287 *@return 0 if the trailer bit indicates that this is the last frame,
1288 * 1 if there are additional frames
1290 static int decode_frame(WMAProDecodeCtx *s, int *got_frame_ptr)
1292 AVCodecContext *avctx = s->avctx;
1293 GetBitContext* gb = &s->gb;
1294 int more_frames = 0;
1297 const float *out_ptr[WMAPRO_MAX_CHANNELS];
1300 /** get frame length */
1302 len = get_bits(gb, s->log2_frame_size);
1304 av_dlog(s->avctx, "decoding frame with length %x\n", len);
1306 /** decode tile information */
1307 if (decode_tilehdr(s)) {
1312 /** read postproc transform */
1313 if (s->num_channels > 1 && get_bits1(gb)) {
1314 if (get_bits1(gb)) {
1315 for (i = 0; i < s->num_channels * s->num_channels; i++)
1320 /** read drc info */
1321 if (s->dynamic_range_compression) {
1322 s->drc_gain = get_bits(gb, 8);
1323 av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1326 /** no idea what these are for, might be the number of samples
1327 that need to be skipped at the beginning or end of a stream */
1328 if (get_bits1(gb)) {
1331 /** usually true for the first frame */
1332 if (get_bits1(gb)) {
1333 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1334 av_dlog(s->avctx, "start skip: %i\n", skip);
1337 /** sometimes true for the last frame */
1338 if (get_bits1(gb)) {
1339 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1340 av_dlog(s->avctx, "end skip: %i\n", skip);
1345 av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1346 get_bits_count(gb) - s->frame_offset);
1348 /** reset subframe states */
1349 s->parsed_all_subframes = 0;
1350 for (i = 0; i < s->num_channels; i++) {
1351 s->channel[i].decoded_samples = 0;
1352 s->channel[i].cur_subframe = 0;
1353 s->channel[i].reuse_sf = 0;
1356 /** decode all subframes */
1357 while (!s->parsed_all_subframes) {
1358 if (decode_subframe(s) < 0) {
1364 /* get output buffer */
1365 s->frame.nb_samples = s->samples_per_frame;
1366 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1367 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1371 samples = (float *)s->frame.data[0];
1373 /** interleave samples and write them to the output buffer */
1374 for (i = 0; i < s->num_channels; i++)
1375 out_ptr[i] = s->channel[i].out;
1376 s->fmt_conv.float_interleave(samples, out_ptr, s->samples_per_frame,
1379 for (i = 0; i < s->num_channels; i++) {
1380 /** reuse second half of the IMDCT output for the next frame */
1381 memcpy(&s->channel[i].out[0],
1382 &s->channel[i].out[s->samples_per_frame],
1383 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1386 if (s->skip_frame) {
1393 if (s->len_prefix) {
1394 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1395 /** FIXME: not sure if this is always an error */
1396 av_log(s->avctx, AV_LOG_ERROR,
1397 "frame[%i] would have to skip %i bits\n", s->frame_num,
1398 len - (get_bits_count(gb) - s->frame_offset) - 1);
1403 /** skip the rest of the frame data */
1404 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1406 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1410 /** decode trailer bit */
1411 more_frames = get_bits1(gb);
1418 *@brief Calculate remaining input buffer length.
1419 *@param s codec context
1420 *@param gb bitstream reader context
1421 *@return remaining size in bits
1423 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1425 return s->buf_bit_size - get_bits_count(gb);
1429 *@brief Fill the bit reservoir with a (partial) frame.
1430 *@param s codec context
1431 *@param gb bitstream reader context
1432 *@param len length of the partial frame
1433 *@param append decides whether to reset the buffer or not
1435 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1440 /** when the frame data does not need to be concatenated, the input buffer
1441 is resetted and additional bits from the previous frame are copyed
1442 and skipped later so that a fast byte copy is possible */
1445 s->frame_offset = get_bits_count(gb) & 7;
1446 s->num_saved_bits = s->frame_offset;
1447 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1450 buflen = (s->num_saved_bits + len + 8) >> 3;
1452 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1453 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1458 s->num_saved_bits += len;
1460 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1463 int align = 8 - (get_bits_count(gb) & 7);
1464 align = FFMIN(align, len);
1465 put_bits(&s->pb, align, get_bits(gb, align));
1467 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1469 skip_bits_long(gb, len);
1472 PutBitContext tmp = s->pb;
1473 flush_put_bits(&tmp);
1476 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1477 skip_bits(&s->gb, s->frame_offset);
1481 *@brief Decode a single WMA packet.
1482 *@param avctx codec context
1483 *@param data the output buffer
1484 *@param data_size number of bytes that were written to the output buffer
1485 *@param avpkt input packet
1486 *@return number of bytes that were read from the input buffer
1488 static int decode_packet(AVCodecContext *avctx, void *data,
1489 int *got_frame_ptr, AVPacket* avpkt)
1491 WMAProDecodeCtx *s = avctx->priv_data;
1492 GetBitContext* gb = &s->pgb;
1493 const uint8_t* buf = avpkt->data;
1494 int buf_size = avpkt->size;
1495 int num_bits_prev_frame;
1496 int packet_sequence_number;
1500 if (s->packet_done || s->packet_loss) {
1503 /** sanity check for the buffer length */
1504 if (buf_size < avctx->block_align)
1507 s->next_packet_start = buf_size - avctx->block_align;
1508 buf_size = avctx->block_align;
1509 s->buf_bit_size = buf_size << 3;
1511 /** parse packet header */
1512 init_get_bits(gb, buf, s->buf_bit_size);
1513 packet_sequence_number = get_bits(gb, 4);
1516 /** get number of bits that need to be added to the previous frame */
1517 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1518 av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1519 num_bits_prev_frame);
1521 /** check for packet loss */
1522 if (!s->packet_loss &&
1523 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1525 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1526 s->packet_sequence_number, packet_sequence_number);
1528 s->packet_sequence_number = packet_sequence_number;
1530 if (num_bits_prev_frame > 0) {
1531 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1532 if (num_bits_prev_frame >= remaining_packet_bits) {
1533 num_bits_prev_frame = remaining_packet_bits;
1537 /** append the previous frame data to the remaining data from the
1538 previous packet to create a full frame */
1539 save_bits(s, gb, num_bits_prev_frame, 1);
1540 av_dlog(avctx, "accumulated %x bits of frame data\n",
1541 s->num_saved_bits - s->frame_offset);
1543 /** decode the cross packet frame if it is valid */
1544 if (!s->packet_loss)
1545 decode_frame(s, got_frame_ptr);
1546 } else if (s->num_saved_bits - s->frame_offset) {
1547 av_dlog(avctx, "ignoring %x previously saved bits\n",
1548 s->num_saved_bits - s->frame_offset);
1551 if (s->packet_loss) {
1552 /** reset number of saved bits so that the decoder
1553 does not start to decode incomplete frames in the
1554 s->len_prefix == 0 case */
1555 s->num_saved_bits = 0;
1561 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1562 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1563 skip_bits(gb, s->packet_offset);
1564 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1565 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1566 frame_size <= remaining_bits(s, gb)) {
1567 save_bits(s, gb, frame_size, 0);
1568 s->packet_done = !decode_frame(s, got_frame_ptr);
1569 } else if (!s->len_prefix
1570 && s->num_saved_bits > get_bits_count(&s->gb)) {
1571 /** when the frames do not have a length prefix, we don't know
1572 the compressed length of the individual frames
1573 however, we know what part of a new packet belongs to the
1575 therefore we save the incoming packet first, then we append
1576 the "previous frame" data from the next packet so that
1577 we get a buffer that only contains full frames */
1578 s->packet_done = !decode_frame(s, got_frame_ptr);
1583 if (s->packet_done && !s->packet_loss &&
1584 remaining_bits(s, gb) > 0) {
1585 /** save the rest of the data so that it can be decoded
1586 with the next packet */
1587 save_bits(s, gb, remaining_bits(s, gb), 0);
1590 s->packet_offset = get_bits_count(gb) & 7;
1592 return AVERROR_INVALIDDATA;
1595 *(AVFrame *)data = s->frame;
1597 return get_bits_count(gb) >> 3;
1601 *@brief Clear decoder buffers (for seeking).
1602 *@param avctx codec context
1604 static void flush(AVCodecContext *avctx)
1606 WMAProDecodeCtx *s = avctx->priv_data;
1608 /** reset output buffer as a part of it is used during the windowing of a
1610 for (i = 0; i < s->num_channels; i++)
1611 memset(s->channel[i].out, 0, s->samples_per_frame *
1612 sizeof(*s->channel[i].out));
1618 *@brief wmapro decoder
1620 AVCodec ff_wmapro_decoder = {
1622 .type = AVMEDIA_TYPE_AUDIO,
1623 .id = CODEC_ID_WMAPRO,
1624 .priv_data_size = sizeof(WMAProDecodeCtx),
1625 .init = decode_init,
1626 .close = decode_end,
1627 .decode = decode_packet,
1628 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1630 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),