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.
91 #include "libavutil/float_dsp.h"
92 #include "libavutil/intfloat.h"
93 #include "libavutil/intreadwrite.h"
98 #include "wmaprodata.h"
101 #include "wma_common.h"
103 /** current decoder limitations */
104 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels
105 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
106 #define MAX_BANDS 29 ///< max number of scale factor bands
107 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
109 #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size
110 #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size
111 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS) ///< minimum block size
112 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size
113 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
117 #define SCALEVLCBITS 8
118 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
119 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
120 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
121 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
122 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
124 static VLC sf_vlc; ///< scale factor DPCM vlc
125 static VLC sf_rl_vlc; ///< scale factor run length vlc
126 static VLC vec4_vlc; ///< 4 coefficients per symbol
127 static VLC vec2_vlc; ///< 2 coefficients per symbol
128 static VLC vec1_vlc; ///< 1 coefficient per symbol
129 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
130 static float sin64[33]; ///< sine table for decorrelation
133 * @brief frame specific decoder context for a single channel
135 typedef struct WMAProChannelCtx {
136 int16_t prev_block_len; ///< length of the previous block
137 uint8_t transmit_coefs;
138 uint8_t num_subframes;
139 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
140 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
141 uint8_t cur_subframe; ///< current subframe number
142 uint16_t decoded_samples; ///< number of already processed samples
143 uint8_t grouped; ///< channel is part of a group
144 int quant_step; ///< quantization step for the current subframe
145 int8_t reuse_sf; ///< share scale factors between subframes
146 int8_t scale_factor_step; ///< scaling step for the current subframe
147 int max_scale_factor; ///< maximum scale factor for the current subframe
148 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
149 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
150 int* scale_factors; ///< pointer to the scale factor values used for decoding
151 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
152 float* coeffs; ///< pointer to the subframe decode buffer
153 uint16_t num_vec_coeffs; ///< number of vector coded coefficients
154 DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
158 * @brief channel group for channel transformations
160 typedef struct WMAProChannelGrp {
161 uint8_t num_channels; ///< number of channels in the group
162 int8_t transform; ///< transform on / off
163 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
164 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
165 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
169 * @brief main decoder context
171 typedef struct WMAProDecodeCtx {
172 /* generic decoder variables */
173 AVCodecContext* avctx; ///< codec context for av_log
174 AVFloatDSPContext *fdsp;
175 uint8_t frame_data[MAX_FRAMESIZE +
176 AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
177 PutBitContext pb; ///< context for filling the frame_data buffer
178 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
179 DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
180 const float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
182 /* frame size dependent frame information (set during initialization) */
183 uint32_t decode_flags; ///< used compression features
184 uint8_t len_prefix; ///< frame is prefixed with its length
185 uint8_t dynamic_range_compression; ///< frame contains DRC data
186 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
187 uint16_t samples_per_frame; ///< number of samples to output
188 uint16_t log2_frame_size;
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
209 uint8_t skip_packets;
211 /* frame decode state */
212 uint32_t frame_num; ///< current frame number (not used for decoding)
214 GetBitContext gb; ///< bitstream reader context
215 int buf_bit_size; ///< buffer size in bits
216 uint8_t drc_gain; ///< gain for the DRC tool
217 int8_t skip_frame; ///< skip output step
218 int8_t parsed_all_subframes; ///< all subframes decoded?
220 /* subframe/block decode state */
221 int16_t subframe_len; ///< current subframe length
222 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
223 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
224 int8_t num_bands; ///< number of scale factor bands
225 int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
226 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
227 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
228 int8_t esc_len; ///< length of escaped coefficients
230 uint8_t num_chgroups; ///< number of channel groups
231 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
233 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
238 *@brief helper function to print the most important members of the context
241 static av_cold void dump_context(WMAProDecodeCtx *s)
243 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
244 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
246 PRINT("ed sample bit depth", s->bits_per_sample);
247 PRINT_HEX("ed decode flags", s->decode_flags);
248 PRINT("samples per frame", s->samples_per_frame);
249 PRINT("log2 frame size", s->log2_frame_size);
250 PRINT("max num subframes", s->max_num_subframes);
251 PRINT("len prefix", s->len_prefix);
252 PRINT("num channels", s->avctx->channels);
256 *@brief Uninitialize the decoder and free all resources.
257 *@param avctx codec context
258 *@return 0 on success, < 0 otherwise
260 static av_cold int decode_end(AVCodecContext *avctx)
262 WMAProDecodeCtx *s = avctx->priv_data;
267 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
268 ff_mdct_end(&s->mdct_ctx[i]);
273 static av_cold int get_rate(AVCodecContext *avctx)
275 if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
276 if (avctx->sample_rate > 44100)
278 else if (avctx->sample_rate > 32000)
280 else if (avctx->sample_rate > 24000)
285 return avctx->sample_rate;
289 *@brief Initialize the decoder.
290 *@param avctx codec context
291 *@return 0 on success, -1 otherwise
293 static av_cold int decode_init(AVCodecContext *avctx)
295 WMAProDecodeCtx *s = avctx->priv_data;
296 uint8_t *edata_ptr = avctx->extradata;
297 unsigned int channel_mask;
299 int log2_max_num_subframes;
300 int num_possible_block_sizes;
302 if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
303 avctx->block_align = 2048;
305 if (!avctx->block_align) {
306 av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
307 return AVERROR(EINVAL);
311 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
313 return AVERROR(ENOMEM);
315 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
317 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
319 if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 34) {
320 s->decode_flags = 0x10d6;
321 channel_mask = AV_RL32(edata_ptr+2);
322 s->bits_per_sample = 16;
323 /** dump the extradata */
324 for (i = 0; i < avctx->extradata_size; i++)
325 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
326 ff_dlog(avctx, "\n");
328 } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 28) {
329 s->decode_flags = 0x10d6;
330 s->bits_per_sample = 16;
332 /** dump the extradata */
333 for (i = 0; i < avctx->extradata_size; i++)
334 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
335 ff_dlog(avctx, "\n");
337 } else if (avctx->extradata_size >= 18) {
338 s->decode_flags = AV_RL16(edata_ptr+14);
339 channel_mask = AV_RL32(edata_ptr+2);
340 s->bits_per_sample = AV_RL16(edata_ptr);
342 if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
343 avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
344 return AVERROR_PATCHWELCOME;
347 /** dump the extradata */
348 for (i = 0; i < avctx->extradata_size; i++)
349 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
350 ff_dlog(avctx, "\n");
353 avpriv_request_sample(avctx, "Unknown extradata size");
354 return AVERROR_PATCHWELCOME;
357 if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {
358 avpriv_report_missing_feature(avctx, ">2 channels support");
359 return AVERROR_PATCHWELCOME;
363 s->log2_frame_size = av_log2(avctx->block_align) + 4;
364 if (s->log2_frame_size > 25) {
365 avpriv_request_sample(avctx, "Large block align");
366 return AVERROR_PATCHWELCOME;
370 if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
373 s->skip_frame = 1; /* skip first frame */
376 s->len_prefix = (s->decode_flags & 0x40);
379 if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
380 bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
381 if (bits > WMAPRO_BLOCK_MAX_BITS) {
382 avpriv_request_sample(avctx, "14-bit block sizes");
383 return AVERROR_PATCHWELCOME;
385 s->samples_per_frame = 1 << bits;
387 s->samples_per_frame = 512;
391 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
392 s->max_num_subframes = 1 << log2_max_num_subframes;
393 if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
394 s->max_subframe_len_bit = 1;
395 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
397 num_possible_block_sizes = log2_max_num_subframes + 1;
398 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
399 s->dynamic_range_compression = (s->decode_flags & 0x80);
401 if (s->max_num_subframes > MAX_SUBFRAMES) {
402 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
403 s->max_num_subframes);
404 return AVERROR_INVALIDDATA;
407 if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
408 av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
409 s->min_samples_per_subframe);
410 return AVERROR_INVALIDDATA;
413 if (s->avctx->sample_rate <= 0) {
414 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
415 return AVERROR_INVALIDDATA;
418 if (avctx->channels < 0) {
419 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
421 return AVERROR_INVALIDDATA;
422 } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
423 avpriv_request_sample(avctx,
424 "More than %d channels", WMAPRO_MAX_CHANNELS);
425 return AVERROR_PATCHWELCOME;
428 /** init previous block len */
429 for (i = 0; i < avctx->channels; i++)
430 s->channel[i].prev_block_len = s->samples_per_frame;
432 /** extract lfe channel position */
435 if (channel_mask & 8) {
437 for (mask = 1; mask < 16; mask <<= 1) {
438 if (channel_mask & mask)
443 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
444 scale_huffbits, 1, 1,
445 scale_huffcodes, 2, 2, 616);
447 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
448 scale_rl_huffbits, 1, 1,
449 scale_rl_huffcodes, 4, 4, 1406);
451 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
452 coef0_huffbits, 1, 1,
453 coef0_huffcodes, 4, 4, 2108);
455 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
456 coef1_huffbits, 1, 1,
457 coef1_huffcodes, 4, 4, 3912);
459 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
461 vec4_huffcodes, 2, 2, 604);
463 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
465 vec2_huffcodes, 2, 2, 562);
467 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
469 vec1_huffcodes, 2, 2, 562);
471 /** calculate number of scale factor bands and their offsets
472 for every possible block size */
473 for (i = 0; i < num_possible_block_sizes; i++) {
474 int subframe_len = s->samples_per_frame >> i;
477 int rate = get_rate(avctx);
479 s->sfb_offsets[i][0] = 0;
481 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
482 int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
484 if (offset > s->sfb_offsets[i][band - 1])
485 s->sfb_offsets[i][band++] = offset;
487 if (offset >= subframe_len)
490 s->sfb_offsets[i][band - 1] = subframe_len;
491 s->num_sfb[i] = band - 1;
492 if (s->num_sfb[i] <= 0) {
493 av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
494 return AVERROR_INVALIDDATA;
499 /** Scale factors can be shared between blocks of different size
500 as every block has a different scale factor band layout.
501 The matrix sf_offsets is needed to find the correct scale factor.
504 for (i = 0; i < num_possible_block_sizes; i++) {
506 for (b = 0; b < s->num_sfb[i]; b++) {
508 int offset = ((s->sfb_offsets[i][b]
509 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
510 for (x = 0; x < num_possible_block_sizes; x++) {
512 while (s->sfb_offsets[x][v + 1] << x < offset) {
514 av_assert0(v < MAX_BANDS);
516 s->sf_offsets[i][x][b] = v;
521 /** init MDCT, FIXME: only init needed sizes */
522 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
523 ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
524 1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
525 / (1 << (s->bits_per_sample - 1)));
527 /** init MDCT windows: simple sine window */
528 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
529 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
530 ff_init_ff_sine_windows(win_idx);
531 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
534 /** calculate subwoofer cutoff values */
535 for (i = 0; i < num_possible_block_sizes; i++) {
536 int block_size = s->samples_per_frame >> i;
537 int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
538 / s->avctx->sample_rate;
539 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
542 /** calculate sine values for the decorrelation matrix */
543 for (i = 0; i < 33; i++)
544 sin64[i] = sin(i*M_PI / 64.0);
546 if (avctx->debug & FF_DEBUG_BITSTREAM)
549 avctx->channel_layout = channel_mask;
555 *@brief Decode the subframe length.
557 *@param offset sample offset in the frame
558 *@return decoded subframe length on success, < 0 in case of an error
560 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
562 int frame_len_shift = 0;
565 /** no need to read from the bitstream when only one length is possible */
566 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
567 return s->min_samples_per_subframe;
569 if (get_bits_left(&s->gb) < 1)
570 return AVERROR_INVALIDDATA;
572 /** 1 bit indicates if the subframe is of maximum length */
573 if (s->max_subframe_len_bit) {
574 if (get_bits1(&s->gb))
575 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
577 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
579 subframe_len = s->samples_per_frame >> frame_len_shift;
581 /** sanity check the length */
582 if (subframe_len < s->min_samples_per_subframe ||
583 subframe_len > s->samples_per_frame) {
584 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
586 return AVERROR_INVALIDDATA;
592 *@brief Decode how the data in the frame is split into subframes.
593 * Every WMA frame contains the encoded data for a fixed number of
594 * samples per channel. The data for every channel might be split
595 * into several subframes. This function will reconstruct the list of
596 * subframes for every channel.
598 * If the subframes are not evenly split, the algorithm estimates the
599 * channels with the lowest number of total samples.
600 * Afterwards, for each of these channels a bit is read from the
601 * bitstream that indicates if the channel contains a subframe with the
602 * next subframe size that is going to be read from the bitstream or not.
603 * If a channel contains such a subframe, the subframe size gets added to
604 * the channel's subframe list.
605 * The algorithm repeats these steps until the frame is properly divided
606 * between the individual channels.
609 *@return 0 on success, < 0 in case of an error
611 static int decode_tilehdr(WMAProDecodeCtx *s)
613 uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
614 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
615 int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
616 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
617 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
620 /* Should never consume more than 3073 bits (256 iterations for the
621 * while loop when always the minimum amount of 128 samples is subtracted
622 * from missing samples in the 8 channel case).
623 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
626 /** reset tiling information */
627 for (c = 0; c < s->avctx->channels; c++)
628 s->channel[c].num_subframes = 0;
630 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
631 fixed_channel_layout = 1;
633 /** loop until the frame data is split between the subframes */
637 /** check which channels contain the subframe */
638 for (c = 0; c < s->avctx->channels; c++) {
639 if (num_samples[c] == min_channel_len) {
640 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
641 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
642 contains_subframe[c] = 1;
644 contains_subframe[c] = get_bits1(&s->gb);
646 contains_subframe[c] = 0;
649 /** get subframe length, subframe_len == 0 is not allowed */
650 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
651 return AVERROR_INVALIDDATA;
653 /** add subframes to the individual channels and find new min_channel_len */
654 min_channel_len += subframe_len;
655 for (c = 0; c < s->avctx->channels; c++) {
656 WMAProChannelCtx* chan = &s->channel[c];
658 if (contains_subframe[c]) {
659 if (chan->num_subframes >= MAX_SUBFRAMES) {
660 av_log(s->avctx, AV_LOG_ERROR,
661 "broken frame: num subframes > 31\n");
662 return AVERROR_INVALIDDATA;
664 chan->subframe_len[chan->num_subframes] = subframe_len;
665 num_samples[c] += subframe_len;
666 ++chan->num_subframes;
667 if (num_samples[c] > s->samples_per_frame) {
668 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
669 "channel len > samples_per_frame\n");
670 return AVERROR_INVALIDDATA;
672 } else if (num_samples[c] <= min_channel_len) {
673 if (num_samples[c] < min_channel_len) {
674 channels_for_cur_subframe = 0;
675 min_channel_len = num_samples[c];
677 ++channels_for_cur_subframe;
680 } while (min_channel_len < s->samples_per_frame);
682 for (c = 0; c < s->avctx->channels; c++) {
685 for (i = 0; i < s->channel[c].num_subframes; i++) {
686 ff_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
687 " len %i\n", s->frame_num, c, i,
688 s->channel[c].subframe_len[i]);
689 s->channel[c].subframe_offset[i] = offset;
690 offset += s->channel[c].subframe_len[i];
698 *@brief Calculate a decorrelation matrix from the bitstream parameters.
699 *@param s codec context
700 *@param chgroup channel group for which the matrix needs to be calculated
702 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
703 WMAProChannelGrp *chgroup)
707 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
708 memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
709 s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
711 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
712 rotation_offset[i] = get_bits(&s->gb, 6);
714 for (i = 0; i < chgroup->num_channels; i++)
715 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
716 get_bits1(&s->gb) ? 1.0 : -1.0;
718 for (i = 1; i < chgroup->num_channels; i++) {
720 for (x = 0; x < i; x++) {
722 for (y = 0; y < i + 1; y++) {
723 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
724 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
725 int n = rotation_offset[offset + x];
731 cosv = sin64[32 - n];
733 sinv = sin64[64 - n];
734 cosv = -sin64[n - 32];
737 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
738 (v1 * sinv) - (v2 * cosv);
739 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
740 (v1 * cosv) + (v2 * sinv);
748 *@brief Decode channel transformation parameters
749 *@param s codec context
750 *@return >= 0 in case of success, < 0 in case of bitstream errors
752 static int decode_channel_transform(WMAProDecodeCtx* s)
755 /* should never consume more than 1921 bits for the 8 channel case
756 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
757 * + MAX_CHANNELS + MAX_BANDS + 1)
760 /** in the one channel case channel transforms are pointless */
762 if (s->avctx->channels > 1) {
763 int remaining_channels = s->channels_for_cur_subframe;
765 if (get_bits1(&s->gb)) {
766 avpriv_request_sample(s->avctx,
767 "Channel transform bit");
768 return AVERROR_PATCHWELCOME;
771 for (s->num_chgroups = 0; remaining_channels &&
772 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
773 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
774 float** channel_data = chgroup->channel_data;
775 chgroup->num_channels = 0;
776 chgroup->transform = 0;
778 /** decode channel mask */
779 if (remaining_channels > 2) {
780 for (i = 0; i < s->channels_for_cur_subframe; i++) {
781 int channel_idx = s->channel_indexes_for_cur_subframe[i];
782 if (!s->channel[channel_idx].grouped
783 && get_bits1(&s->gb)) {
784 ++chgroup->num_channels;
785 s->channel[channel_idx].grouped = 1;
786 *channel_data++ = s->channel[channel_idx].coeffs;
790 chgroup->num_channels = remaining_channels;
791 for (i = 0; i < s->channels_for_cur_subframe; i++) {
792 int channel_idx = s->channel_indexes_for_cur_subframe[i];
793 if (!s->channel[channel_idx].grouped)
794 *channel_data++ = s->channel[channel_idx].coeffs;
795 s->channel[channel_idx].grouped = 1;
799 /** decode transform type */
800 if (chgroup->num_channels == 2) {
801 if (get_bits1(&s->gb)) {
802 if (get_bits1(&s->gb)) {
803 avpriv_request_sample(s->avctx,
804 "Unknown channel transform type");
805 return AVERROR_PATCHWELCOME;
808 chgroup->transform = 1;
809 if (s->avctx->channels == 2) {
810 chgroup->decorrelation_matrix[0] = 1.0;
811 chgroup->decorrelation_matrix[1] = -1.0;
812 chgroup->decorrelation_matrix[2] = 1.0;
813 chgroup->decorrelation_matrix[3] = 1.0;
816 chgroup->decorrelation_matrix[0] = 0.70703125;
817 chgroup->decorrelation_matrix[1] = -0.70703125;
818 chgroup->decorrelation_matrix[2] = 0.70703125;
819 chgroup->decorrelation_matrix[3] = 0.70703125;
822 } else if (chgroup->num_channels > 2) {
823 if (get_bits1(&s->gb)) {
824 chgroup->transform = 1;
825 if (get_bits1(&s->gb)) {
826 decode_decorrelation_matrix(s, chgroup);
828 /** FIXME: more than 6 coupled channels not supported */
829 if (chgroup->num_channels > 6) {
830 avpriv_request_sample(s->avctx,
831 "Coupled channels > 6");
833 memcpy(chgroup->decorrelation_matrix,
834 default_decorrelation[chgroup->num_channels],
835 chgroup->num_channels * chgroup->num_channels *
836 sizeof(*chgroup->decorrelation_matrix));
842 /** decode transform on / off */
843 if (chgroup->transform) {
844 if (!get_bits1(&s->gb)) {
846 /** transform can be enabled for individual bands */
847 for (i = 0; i < s->num_bands; i++) {
848 chgroup->transform_band[i] = get_bits1(&s->gb);
851 memset(chgroup->transform_band, 1, s->num_bands);
854 remaining_channels -= chgroup->num_channels;
861 *@brief Extract the coefficients from the bitstream.
862 *@param s codec context
863 *@param c current channel number
864 *@return 0 on success, < 0 in case of bitstream errors
866 static int decode_coeffs(WMAProDecodeCtx *s, int c)
868 /* Integers 0..15 as single-precision floats. The table saves a
869 costly int to float conversion, and storing the values as
870 integers allows fast sign-flipping. */
871 static const uint32_t fval_tab[16] = {
872 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
873 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
874 0x41000000, 0x41100000, 0x41200000, 0x41300000,
875 0x41400000, 0x41500000, 0x41600000, 0x41700000,
879 WMAProChannelCtx* ci = &s->channel[c];
886 ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
888 vlctable = get_bits1(&s->gb);
889 vlc = &coef_vlc[vlctable];
899 /** decode vector coefficients (consumes up to 167 bits per iteration for
900 4 vector coded large values) */
901 while ((s->transmit_num_vec_coeffs || !rl_mode) &&
902 (cur_coeff + 3 < ci->num_vec_coeffs)) {
907 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
909 if (idx == HUFF_VEC4_SIZE - 1) {
910 for (i = 0; i < 4; i += 2) {
911 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
912 if (idx == HUFF_VEC2_SIZE - 1) {
914 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
915 if (v0 == HUFF_VEC1_SIZE - 1)
916 v0 += ff_wma_get_large_val(&s->gb);
917 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
918 if (v1 == HUFF_VEC1_SIZE - 1)
919 v1 += ff_wma_get_large_val(&s->gb);
920 vals[i ] = av_float2int(v0);
921 vals[i+1] = av_float2int(v1);
923 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
924 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
928 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
929 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
930 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
931 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
935 for (i = 0; i < 4; i++) {
937 uint32_t sign = get_bits1(&s->gb) - 1;
938 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
941 ci->coeffs[cur_coeff] = 0;
942 /** switch to run level mode when subframe_len / 128 zeros
943 were found in a row */
944 rl_mode |= (++num_zeros > s->subframe_len >> 8);
950 /** decode run level coded coefficients */
951 if (cur_coeff < s->subframe_len) {
952 memset(&ci->coeffs[cur_coeff], 0,
953 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
954 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
955 level, run, 1, ci->coeffs,
956 cur_coeff, s->subframe_len,
957 s->subframe_len, s->esc_len, 0))
958 return AVERROR_INVALIDDATA;
965 *@brief Extract scale factors from the bitstream.
966 *@param s codec context
967 *@return 0 on success, < 0 in case of bitstream errors
969 static int decode_scale_factors(WMAProDecodeCtx* s)
973 /** should never consume more than 5344 bits
974 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
977 for (i = 0; i < s->channels_for_cur_subframe; i++) {
978 int c = s->channel_indexes_for_cur_subframe[i];
981 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
982 sf_end = s->channel[c].scale_factors + s->num_bands;
984 /** resample scale factors for the new block size
985 * as the scale factors might need to be resampled several times
986 * before some new values are transmitted, a backup of the last
987 * transmitted scale factors is kept in saved_scale_factors
989 if (s->channel[c].reuse_sf) {
990 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
992 for (b = 0; b < s->num_bands; b++)
993 s->channel[c].scale_factors[b] =
994 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
997 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
999 if (!s->channel[c].reuse_sf) {
1001 /** decode DPCM coded scale factors */
1002 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1003 val = 45 / s->channel[c].scale_factor_step;
1004 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1005 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1010 /** run level decode differences to the resampled factors */
1011 for (i = 0; i < s->num_bands; i++) {
1017 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1020 uint32_t code = get_bits(&s->gb, 14);
1022 sign = (code & 1) - 1;
1023 skip = (code & 0x3f) >> 1;
1024 } else if (idx == 1) {
1027 skip = scale_rl_run[idx];
1028 val = scale_rl_level[idx];
1029 sign = get_bits1(&s->gb)-1;
1033 if (i >= s->num_bands) {
1034 av_log(s->avctx, AV_LOG_ERROR,
1035 "invalid scale factor coding\n");
1036 return AVERROR_INVALIDDATA;
1038 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1042 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1043 s->channel[c].table_idx = s->table_idx;
1044 s->channel[c].reuse_sf = 1;
1047 /** calculate new scale factor maximum */
1048 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1049 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1050 s->channel[c].max_scale_factor =
1051 FFMAX(s->channel[c].max_scale_factor, *sf);
1059 *@brief Reconstruct the individual channel data.
1060 *@param s codec context
1062 static void inverse_channel_transform(WMAProDecodeCtx *s)
1066 for (i = 0; i < s->num_chgroups; i++) {
1067 if (s->chgroup[i].transform) {
1068 float data[WMAPRO_MAX_CHANNELS];
1069 const int num_channels = s->chgroup[i].num_channels;
1070 float** ch_data = s->chgroup[i].channel_data;
1071 float** ch_end = ch_data + num_channels;
1072 const int8_t* tb = s->chgroup[i].transform_band;
1075 /** multichannel decorrelation */
1076 for (sfb = s->cur_sfb_offsets;
1077 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1080 /** multiply values with the decorrelation_matrix */
1081 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1082 const float* mat = s->chgroup[i].decorrelation_matrix;
1083 const float* data_end = data + num_channels;
1084 float* data_ptr = data;
1087 for (ch = ch_data; ch < ch_end; ch++)
1088 *data_ptr++ = (*ch)[y];
1090 for (ch = ch_data; ch < ch_end; ch++) {
1093 while (data_ptr < data_end)
1094 sum += *data_ptr++ * *mat++;
1099 } else if (s->avctx->channels == 2) {
1100 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1101 s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1102 ch_data[0] + sfb[0],
1104 s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1105 ch_data[1] + sfb[0],
1114 *@brief Apply sine window and reconstruct the output buffer.
1115 *@param s codec context
1117 static void wmapro_window(WMAProDecodeCtx *s)
1120 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1121 int c = s->channel_indexes_for_cur_subframe[i];
1122 const float* window;
1123 int winlen = s->channel[c].prev_block_len;
1124 float* start = s->channel[c].coeffs - (winlen >> 1);
1126 if (s->subframe_len < winlen) {
1127 start += (winlen - s->subframe_len) >> 1;
1128 winlen = s->subframe_len;
1131 window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1135 s->fdsp->vector_fmul_window(start, start, start + winlen,
1138 s->channel[c].prev_block_len = s->subframe_len;
1143 *@brief Decode a single subframe (block).
1144 *@param s codec context
1145 *@return 0 on success, < 0 when decoding failed
1147 static int decode_subframe(WMAProDecodeCtx *s)
1149 int offset = s->samples_per_frame;
1150 int subframe_len = s->samples_per_frame;
1152 int total_samples = s->samples_per_frame * s->avctx->channels;
1153 int transmit_coeffs = 0;
1154 int cur_subwoofer_cutoff;
1156 s->subframe_offset = get_bits_count(&s->gb);
1158 /** reset channel context and find the next block offset and size
1159 == the next block of the channel with the smallest number of
1162 for (i = 0; i < s->avctx->channels; i++) {
1163 s->channel[i].grouped = 0;
1164 if (offset > s->channel[i].decoded_samples) {
1165 offset = s->channel[i].decoded_samples;
1167 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1172 "processing subframe with offset %i len %i\n", offset, subframe_len);
1174 /** get a list of all channels that contain the estimated block */
1175 s->channels_for_cur_subframe = 0;
1176 for (i = 0; i < s->avctx->channels; i++) {
1177 const int cur_subframe = s->channel[i].cur_subframe;
1178 /** subtract already processed samples */
1179 total_samples -= s->channel[i].decoded_samples;
1181 /** and count if there are multiple subframes that match our profile */
1182 if (offset == s->channel[i].decoded_samples &&
1183 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1184 total_samples -= s->channel[i].subframe_len[cur_subframe];
1185 s->channel[i].decoded_samples +=
1186 s->channel[i].subframe_len[cur_subframe];
1187 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1188 ++s->channels_for_cur_subframe;
1192 /** check if the frame will be complete after processing the
1195 s->parsed_all_subframes = 1;
1198 ff_dlog(s->avctx, "subframe is part of %i channels\n",
1199 s->channels_for_cur_subframe);
1201 /** calculate number of scale factor bands and their offsets */
1202 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1203 s->num_bands = s->num_sfb[s->table_idx];
1204 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1205 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1207 /** configure the decoder for the current subframe */
1208 offset += s->samples_per_frame >> 1;
1210 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1211 int c = s->channel_indexes_for_cur_subframe[i];
1213 s->channel[c].coeffs = &s->channel[c].out[offset];
1216 s->subframe_len = subframe_len;
1217 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1219 /** skip extended header if any */
1220 if (get_bits1(&s->gb)) {
1222 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1223 int len = get_bits(&s->gb, 4);
1224 num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
1227 if (num_fill_bits >= 0) {
1228 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1229 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1230 return AVERROR_INVALIDDATA;
1233 skip_bits_long(&s->gb, num_fill_bits);
1237 /** no idea for what the following bit is used */
1238 if (get_bits1(&s->gb)) {
1239 avpriv_request_sample(s->avctx, "Reserved bit");
1240 return AVERROR_PATCHWELCOME;
1244 if (decode_channel_transform(s) < 0)
1245 return AVERROR_INVALIDDATA;
1248 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1249 int c = s->channel_indexes_for_cur_subframe[i];
1250 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1251 transmit_coeffs = 1;
1254 av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1255 if (transmit_coeffs) {
1257 int quant_step = 90 * s->bits_per_sample >> 4;
1259 /** decode number of vector coded coefficients */
1260 if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1261 int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1262 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1263 int c = s->channel_indexes_for_cur_subframe[i];
1264 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1265 if (num_vec_coeffs > s->subframe_len) {
1266 av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1267 return AVERROR_INVALIDDATA;
1269 av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1270 s->channel[c].num_vec_coeffs = num_vec_coeffs;
1273 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1274 int c = s->channel_indexes_for_cur_subframe[i];
1275 s->channel[c].num_vec_coeffs = s->subframe_len;
1278 /** decode quantization step */
1279 step = get_sbits(&s->gb, 6);
1281 if (step == -32 || step == 31) {
1282 const int sign = (step == 31) - 1;
1284 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1285 (step = get_bits(&s->gb, 5)) == 31) {
1288 quant_step += ((quant + step) ^ sign) - sign;
1290 if (quant_step < 0) {
1291 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1294 /** decode quantization step modifiers for every channel */
1296 if (s->channels_for_cur_subframe == 1) {
1297 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1299 int modifier_len = get_bits(&s->gb, 3);
1300 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1301 int c = s->channel_indexes_for_cur_subframe[i];
1302 s->channel[c].quant_step = quant_step;
1303 if (get_bits1(&s->gb)) {
1305 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1307 ++s->channel[c].quant_step;
1312 /** decode scale factors */
1313 if (decode_scale_factors(s) < 0)
1314 return AVERROR_INVALIDDATA;
1317 ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1318 get_bits_count(&s->gb) - s->subframe_offset);
1320 /** parse coefficients */
1321 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1322 int c = s->channel_indexes_for_cur_subframe[i];
1323 if (s->channel[c].transmit_coefs &&
1324 get_bits_count(&s->gb) < s->num_saved_bits) {
1325 decode_coeffs(s, c);
1327 memset(s->channel[c].coeffs, 0,
1328 sizeof(*s->channel[c].coeffs) * subframe_len);
1331 ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1332 get_bits_count(&s->gb) - s->subframe_offset);
1334 if (transmit_coeffs) {
1335 FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1336 /** reconstruct the per channel data */
1337 inverse_channel_transform(s);
1338 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1339 int c = s->channel_indexes_for_cur_subframe[i];
1340 const int* sf = s->channel[c].scale_factors;
1343 if (c == s->lfe_channel)
1344 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1345 (subframe_len - cur_subwoofer_cutoff));
1347 /** inverse quantization and rescaling */
1348 for (b = 0; b < s->num_bands; b++) {
1349 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1350 const int exp = s->channel[c].quant_step -
1351 (s->channel[c].max_scale_factor - *sf++) *
1352 s->channel[c].scale_factor_step;
1353 const float quant = pow(10.0, exp / 20.0);
1354 int start = s->cur_sfb_offsets[b];
1355 s->fdsp->vector_fmul_scalar(s->tmp + start,
1356 s->channel[c].coeffs + start,
1357 quant, end - start);
1360 /** apply imdct (imdct_half == DCTIV with reverse) */
1361 mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1365 /** window and overlapp-add */
1368 /** handled one subframe */
1369 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1370 int c = s->channel_indexes_for_cur_subframe[i];
1371 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1372 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1373 return AVERROR_INVALIDDATA;
1375 ++s->channel[c].cur_subframe;
1382 *@brief Decode one WMA frame.
1383 *@param s codec context
1384 *@return 0 if the trailer bit indicates that this is the last frame,
1385 * 1 if there are additional frames
1387 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1389 AVCodecContext *avctx = s->avctx;
1390 GetBitContext* gb = &s->gb;
1391 int more_frames = 0;
1395 /** get frame length */
1397 len = get_bits(gb, s->log2_frame_size);
1399 ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1401 /** decode tile information */
1402 if (decode_tilehdr(s)) {
1407 /** read postproc transform */
1408 if (s->avctx->channels > 1 && get_bits1(gb)) {
1409 if (get_bits1(gb)) {
1410 for (i = 0; i < avctx->channels * avctx->channels; i++)
1415 /** read drc info */
1416 if (s->dynamic_range_compression) {
1417 s->drc_gain = get_bits(gb, 8);
1418 ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1421 /** no idea what these are for, might be the number of samples
1422 that need to be skipped at the beginning or end of a stream */
1423 if (get_bits1(gb)) {
1426 /** usually true for the first frame */
1427 if (get_bits1(gb)) {
1428 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1429 ff_dlog(s->avctx, "start skip: %i\n", skip);
1432 /** sometimes true for the last frame */
1433 if (get_bits1(gb)) {
1434 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1435 ff_dlog(s->avctx, "end skip: %i\n", skip);
1440 ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1441 get_bits_count(gb) - s->frame_offset);
1443 /** reset subframe states */
1444 s->parsed_all_subframes = 0;
1445 for (i = 0; i < avctx->channels; i++) {
1446 s->channel[i].decoded_samples = 0;
1447 s->channel[i].cur_subframe = 0;
1448 s->channel[i].reuse_sf = 0;
1451 /** decode all subframes */
1452 while (!s->parsed_all_subframes) {
1453 if (decode_subframe(s) < 0) {
1459 /* get output buffer */
1460 frame->nb_samples = s->samples_per_frame;
1461 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1466 /** copy samples to the output buffer */
1467 for (i = 0; i < avctx->channels; i++)
1468 memcpy(frame->extended_data[i], s->channel[i].out,
1469 s->samples_per_frame * sizeof(*s->channel[i].out));
1471 for (i = 0; i < avctx->channels; i++) {
1472 /** reuse second half of the IMDCT output for the next frame */
1473 memcpy(&s->channel[i].out[0],
1474 &s->channel[i].out[s->samples_per_frame],
1475 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1478 if (s->skip_frame) {
1481 av_frame_unref(frame);
1486 if (s->len_prefix) {
1487 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1488 /** FIXME: not sure if this is always an error */
1489 av_log(s->avctx, AV_LOG_ERROR,
1490 "frame[%"PRIu32"] would have to skip %i bits\n",
1492 len - (get_bits_count(gb) - s->frame_offset) - 1);
1497 /** skip the rest of the frame data */
1498 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1500 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1504 /** decode trailer bit */
1505 more_frames = get_bits1(gb);
1512 *@brief Calculate remaining input buffer length.
1513 *@param s codec context
1514 *@param gb bitstream reader context
1515 *@return remaining size in bits
1517 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1519 return s->buf_bit_size - get_bits_count(gb);
1523 *@brief Fill the bit reservoir with a (partial) frame.
1524 *@param s codec context
1525 *@param gb bitstream reader context
1526 *@param len length of the partial frame
1527 *@param append decides whether to reset the buffer or not
1529 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1534 /** when the frame data does not need to be concatenated, the input buffer
1535 is reset and additional bits from the previous frame are copied
1536 and skipped later so that a fast byte copy is possible */
1539 s->frame_offset = get_bits_count(gb) & 7;
1540 s->num_saved_bits = s->frame_offset;
1541 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1544 buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1546 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1547 avpriv_request_sample(s->avctx, "Too small input buffer");
1552 av_assert0(len <= put_bits_left(&s->pb));
1554 s->num_saved_bits += len;
1556 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1559 int align = 8 - (get_bits_count(gb) & 7);
1560 align = FFMIN(align, len);
1561 put_bits(&s->pb, align, get_bits(gb, align));
1563 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1565 skip_bits_long(gb, len);
1568 PutBitContext tmp = s->pb;
1569 flush_put_bits(&tmp);
1572 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1573 skip_bits(&s->gb, s->frame_offset);
1577 *@brief Decode a single WMA packet.
1578 *@param avctx codec context
1579 *@param data the output buffer
1580 *@param avpkt input packet
1581 *@return number of bytes that were read from the input buffer
1583 static int decode_packet(AVCodecContext *avctx, void *data,
1584 int *got_frame_ptr, AVPacket* avpkt)
1586 WMAProDecodeCtx *s = avctx->priv_data;
1587 GetBitContext* gb = &s->pgb;
1588 const uint8_t* buf = avpkt->data;
1589 int buf_size = avpkt->size;
1590 int num_bits_prev_frame;
1591 int packet_sequence_number;
1595 if (s->skip_packets > 0) {
1597 return FFMIN(avpkt->size, avctx->block_align);
1600 if (s->packet_done || s->packet_loss) {
1603 /** sanity check for the buffer length */
1604 if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1605 av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1606 buf_size, avctx->block_align);
1607 return AVERROR_INVALIDDATA;
1610 if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1611 s->next_packet_start = buf_size - avctx->block_align;
1612 buf_size = avctx->block_align;
1614 s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1615 buf_size = FFMIN(buf_size, avctx->block_align);
1617 s->buf_bit_size = buf_size << 3;
1619 /** parse packet header */
1620 init_get_bits(gb, buf, s->buf_bit_size);
1621 if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1622 packet_sequence_number = get_bits(gb, 4);
1625 s->num_frames = get_bits(gb, 6);
1626 packet_sequence_number = 0;
1629 /** get number of bits that need to be added to the previous frame */
1630 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1631 if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1633 s->skip_packets = get_bits(gb, 8);
1636 ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1637 num_bits_prev_frame);
1639 /** check for packet loss */
1640 if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
1641 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1643 av_log(avctx, AV_LOG_ERROR,
1644 "Packet loss detected! seq %"PRIx8" vs %x\n",
1645 s->packet_sequence_number, packet_sequence_number);
1647 s->packet_sequence_number = packet_sequence_number;
1649 if (num_bits_prev_frame > 0) {
1650 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1651 if (num_bits_prev_frame >= remaining_packet_bits) {
1652 num_bits_prev_frame = remaining_packet_bits;
1656 /** append the previous frame data to the remaining data from the
1657 previous packet to create a full frame */
1658 save_bits(s, gb, num_bits_prev_frame, 1);
1659 ff_dlog(avctx, "accumulated %x bits of frame data\n",
1660 s->num_saved_bits - s->frame_offset);
1662 /** decode the cross packet frame if it is valid */
1663 if (!s->packet_loss)
1664 decode_frame(s, data, got_frame_ptr);
1665 } else if (s->num_saved_bits - s->frame_offset) {
1666 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1667 s->num_saved_bits - s->frame_offset);
1670 if (s->packet_loss) {
1671 /** reset number of saved bits so that the decoder
1672 does not start to decode incomplete frames in the
1673 s->len_prefix == 0 case */
1674 s->num_saved_bits = 0;
1680 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1681 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1682 skip_bits(gb, s->packet_offset);
1683 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1684 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1685 frame_size <= remaining_bits(s, gb)) {
1686 save_bits(s, gb, frame_size, 0);
1687 if (!s->packet_loss)
1688 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1689 } else if (!s->len_prefix
1690 && s->num_saved_bits > get_bits_count(&s->gb)) {
1691 /** when the frames do not have a length prefix, we don't know
1692 the compressed length of the individual frames
1693 however, we know what part of a new packet belongs to the
1695 therefore we save the incoming packet first, then we append
1696 the "previous frame" data from the next packet so that
1697 we get a buffer that only contains full frames */
1698 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1703 if (remaining_bits(s, gb) < 0) {
1704 av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1708 if (s->packet_done && !s->packet_loss &&
1709 remaining_bits(s, gb) > 0) {
1710 /** save the rest of the data so that it can be decoded
1711 with the next packet */
1712 save_bits(s, gb, remaining_bits(s, gb), 0);
1715 s->packet_offset = get_bits_count(gb) & 7;
1717 return AVERROR_INVALIDDATA;
1719 return get_bits_count(gb) >> 3;
1723 *@brief Clear decoder buffers (for seeking).
1724 *@param avctx codec context
1726 static void flush(AVCodecContext *avctx)
1728 WMAProDecodeCtx *s = avctx->priv_data;
1730 /** reset output buffer as a part of it is used during the windowing of a
1732 for (i = 0; i < avctx->channels; i++)
1733 memset(s->channel[i].out, 0, s->samples_per_frame *
1734 sizeof(*s->channel[i].out));
1740 *@brief wmapro decoder
1742 AVCodec ff_wmapro_decoder = {
1744 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1745 .type = AVMEDIA_TYPE_AUDIO,
1746 .id = AV_CODEC_ID_WMAPRO,
1747 .priv_data_size = sizeof(WMAProDecodeCtx),
1748 .init = decode_init,
1749 .close = decode_end,
1750 .decode = decode_packet,
1751 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1753 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1754 AV_SAMPLE_FMT_NONE },
1757 AVCodec ff_xma1_decoder = {
1759 .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
1760 .type = AVMEDIA_TYPE_AUDIO,
1761 .id = AV_CODEC_ID_XMA1,
1762 .priv_data_size = sizeof(WMAProDecodeCtx),
1763 .init = decode_init,
1764 .close = decode_end,
1765 .decode = decode_packet,
1766 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1768 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1769 AV_SAMPLE_FMT_NONE },
1772 AVCodec ff_xma2_decoder = {
1774 .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
1775 .type = AVMEDIA_TYPE_AUDIO,
1776 .id = AV_CODEC_ID_XMA2,
1777 .priv_data_size = sizeof(WMAProDecodeCtx),
1778 .init = decode_init,
1779 .close = decode_end,
1780 .decode = decode_packet,
1781 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1783 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1784 AV_SAMPLE_FMT_NONE },