2 * Wmall compatible decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5 * Copyright (c) 2011 Andreas Ă–man
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * @brief wmall decoder implementation
27 * Wmall is an MDCT based codec comparable to wma standard or AAC.
28 * The decoding therefore consists of the following steps:
29 * - bitstream decoding
30 * - reconstruction of per-channel data
31 * - rescaling and inverse quantization
33 * - windowing and overlapp-add
35 * The compressed wmall bitstream is split into individual packets.
36 * Every such packet contains one or more wma frames.
37 * The compressed frames may have a variable length and frames may
38 * cross packet boundaries.
39 * Common to all wmall frames is the number of samples that are stored in
41 * The number of samples and a few other decode flags are stored
42 * as extradata that has to be passed to the decoder.
44 * The wmall frames themselves are again split into a variable number of
45 * subframes. Every subframe contains the data for 2^N time domain samples
46 * where N varies between 7 and 12.
48 * Example wmall bitstream (in samples):
50 * || packet 0 || packet 1 || packet 2 packets
51 * ---------------------------------------------------
52 * || frame 0 || frame 1 || frame 2 || frames
53 * ---------------------------------------------------
54 * || | | || | | | || || subframes of channel 0
55 * ---------------------------------------------------
56 * || | | || | | | || || subframes of channel 1
57 * ---------------------------------------------------
59 * The frame layouts for the individual channels of a wma frame does not need
62 * However, if the offsets and lengths of several subframes of a frame are the
63 * same, the subframes of the channels can be grouped.
64 * Every group may then use special coding techniques like M/S stereo coding
65 * to improve the compression ratio. These channel transformations do not
66 * need to be applied to a whole subframe. Instead, they can also work on
67 * individual scale factor bands (see below).
68 * The coefficients that carry the audio signal in the frequency domain
69 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
70 * In addition to that, the encoder can switch to a runlevel coding scheme
71 * by transmitting subframe_length / 128 zero coefficients.
73 * Before the audio signal can be converted to the time domain, the
74 * coefficients have to be rescaled and inverse quantized.
75 * A subframe is therefore split into several scale factor bands that get
76 * scaled individually.
77 * Scale factors are submitted for every frame but they might be shared
78 * between the subframes of a channel. Scale factors are initially DPCM-coded.
79 * Once scale factors are shared, the differences are transmitted as runlevel
81 * Every subframe length and offset combination in the frame layout shares a
82 * common quantization factor that can be adjusted for every channel by a
84 * After the inverse quantization, the coefficients get processed by an IMDCT.
85 * The resulting values are then windowed with a sine window and the first half
86 * of the values are added to the second half of the output from the previous
87 * subframe in order to reconstruct the output samples.
97 /** current decoder limitations */
98 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
99 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
100 #define MAX_BANDS 29 ///< max number of scale factor bands
101 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
103 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
104 #define WMALL_BLOCK_MAX_BITS 12 ///< log2 of max block size
105 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
106 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
110 #define SCALEVLCBITS 8
111 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
112 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
113 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
114 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
115 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
117 static float sin64[33]; ///< sinus table for decorrelation
120 * @brief frame specific decoder context for a single channel
123 int16_t prev_block_len; ///< length of the previous block
124 uint8_t transmit_coefs;
125 uint8_t num_subframes;
126 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
127 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
128 uint8_t cur_subframe; ///< current subframe number
129 uint16_t decoded_samples; ///< number of already processed samples
130 uint8_t grouped; ///< channel is part of a group
131 int quant_step; ///< quantization step for the current subframe
132 int8_t reuse_sf; ///< share scale factors between subframes
133 int8_t scale_factor_step; ///< scaling step for the current subframe
134 int max_scale_factor; ///< maximum scale factor for the current subframe
135 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
136 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
137 int* scale_factors; ///< pointer to the scale factor values used for decoding
138 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
139 float* coeffs; ///< pointer to the subframe decode buffer
140 uint16_t num_vec_coeffs; ///< number of vector coded coefficients
141 DECLARE_ALIGNED(16, float, out)[WMALL_BLOCK_MAX_SIZE + WMALL_BLOCK_MAX_SIZE / 2]; ///< output buffer
142 int transient_counter; ///< number of transient samples from the beginning of transient zone
146 * @brief channel group for channel transformations
149 uint8_t num_channels; ///< number of channels in the group
150 int8_t transform; ///< transform on / off
151 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
152 float decorrelation_matrix[WMALL_MAX_CHANNELS*WMALL_MAX_CHANNELS];
153 float* channel_data[WMALL_MAX_CHANNELS]; ///< transformation coefficients
157 * @brief main decoder context
159 typedef struct WmallDecodeCtx {
160 /* generic decoder variables */
161 AVCodecContext* avctx; ///< codec context for av_log
162 DSPContext dsp; ///< accelerated DSP functions
163 uint8_t frame_data[MAX_FRAMESIZE +
164 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
165 PutBitContext pb; ///< context for filling the frame_data buffer
166 FFTContext mdct_ctx[WMALL_BLOCK_SIZES]; ///< MDCT context per block size
167 DECLARE_ALIGNED(16, float, tmp)[WMALL_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
168 float* windows[WMALL_BLOCK_SIZES]; ///< windows for the different block sizes
170 /* frame size dependent frame information (set during initialization) */
171 uint32_t decode_flags; ///< used compression features
172 uint8_t len_prefix; ///< frame is prefixed with its length
173 uint8_t dynamic_range_compression; ///< frame contains DRC data
174 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
175 uint16_t samples_per_frame; ///< number of samples to output
176 uint16_t log2_frame_size;
177 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
178 int8_t lfe_channel; ///< lfe channel index
179 uint8_t max_num_subframes;
180 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
181 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
182 uint16_t min_samples_per_subframe;
183 int8_t num_sfb[WMALL_BLOCK_SIZES]; ///< scale factor bands per block size
184 int16_t sfb_offsets[WMALL_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
185 int8_t sf_offsets[WMALL_BLOCK_SIZES][WMALL_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
186 int16_t subwoofer_cutoffs[WMALL_BLOCK_SIZES]; ///< subwoofer cutoff values
188 /* packet decode state */
189 GetBitContext pgb; ///< bitstream reader context for the packet
190 int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
191 uint8_t packet_offset; ///< frame offset in the packet
192 uint8_t packet_sequence_number; ///< current packet number
193 int num_saved_bits; ///< saved number of bits
194 int frame_offset; ///< frame offset in the bit reservoir
195 int subframe_offset; ///< subframe offset in the bit reservoir
196 uint8_t packet_loss; ///< set in case of bitstream error
197 uint8_t packet_done; ///< set when a packet is fully decoded
199 /* frame decode state */
200 uint32_t frame_num; ///< current frame number (not used for decoding)
201 GetBitContext gb; ///< bitstream reader context
202 int buf_bit_size; ///< buffer size in bits
203 int16_t* samples_16; ///< current samplebuffer pointer (16-bit)
204 int16_t* samples_16_end; ///< maximum samplebuffer pointer
205 int *samples_32; ///< current samplebuffer pointer (24-bit)
206 int *samples_32_end; ///< maximum samplebuffer pointer
207 uint8_t drc_gain; ///< gain for the DRC tool
208 int8_t skip_frame; ///< skip output step
209 int8_t parsed_all_subframes; ///< all subframes decoded?
211 /* subframe/block decode state */
212 int16_t subframe_len; ///< current subframe length
213 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
214 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
215 int8_t num_bands; ///< number of scale factor bands
216 int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
217 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
218 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
219 int8_t esc_len; ///< length of escaped coefficients
221 uint8_t num_chgroups; ///< number of channel groups
222 WmallChannelGrp chgroup[WMALL_MAX_CHANNELS]; ///< channel group information
224 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
228 uint8_t do_arith_coding;
229 uint8_t do_ac_filter;
230 uint8_t do_inter_ch_decorr;
234 int8_t acfilter_order;
235 int8_t acfilter_scaling;
236 int64_t acfilter_coeffs[16];
237 int acfilter_prevvalues[2][16];
240 int8_t mclms_scaling;
241 int16_t mclms_coeffs[128];
242 int16_t mclms_coeffs_cur[4];
243 int16_t mclms_prevvalues[64]; // FIXME: should be 32-bit / 16-bit depending on bit-depth
244 int16_t mclms_updates[64];
256 int16_t lms_prevvalues[512]; // FIXME: see above
257 int16_t lms_updates[512]; // and here too
259 } cdlms[2][9]; /* XXX: Here, 2 is the max. no. of channels allowed,
260 9 is the maximum no. of filters per channel.
261 Question is, why 2 if WMALL_MAX_CHANNELS == 8 */
268 int is_channel_coded[2]; // XXX: same question as above applies here too (and below)
272 int transient_pos[2];
277 int channel_residues[2][2048];
280 int lpc_coefs[2][40];
285 int channel_coeffs[2][2048]; // FIXME: should be 32-bit / 16-bit depending on bit-depth
291 #define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
294 static int num_logged_tiles = 0;
295 static int num_logged_subframes = 0;
296 static int num_lms_update_call = 0;
299 *@brief helper function to print the most important members of the context
302 static void av_cold dump_context(WmallDecodeCtx *s)
304 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
305 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
307 PRINT("ed sample bit depth", s->bits_per_sample);
308 PRINT_HEX("ed decode flags", s->decode_flags);
309 PRINT("samples per frame", s->samples_per_frame);
310 PRINT("log2 frame size", s->log2_frame_size);
311 PRINT("max num subframes", s->max_num_subframes);
312 PRINT("len prefix", s->len_prefix);
313 PRINT("num channels", s->num_channels);
316 static void dump_int_buffer(uint8_t *buffer, int size, int length, int delimiter)
320 for (i=0 ; i<length ; i++) {
322 av_log(0, 0, "\n[%d] ", i);
323 av_log(0, 0, "%d, ", *(int16_t *)(buffer + i * size));
329 *@brief Uninitialize the decoder and free all resources.
330 *@param avctx codec context
331 *@return 0 on success, < 0 otherwise
333 static av_cold int decode_end(AVCodecContext *avctx)
335 WmallDecodeCtx *s = avctx->priv_data;
338 for (i = 0; i < WMALL_BLOCK_SIZES; i++)
339 ff_mdct_end(&s->mdct_ctx[i]);
345 *@brief Initialize the decoder.
346 *@param avctx codec context
347 *@return 0 on success, -1 otherwise
349 static av_cold int decode_init(AVCodecContext *avctx)
351 WmallDecodeCtx *s = avctx->priv_data;
352 uint8_t *edata_ptr = avctx->extradata;
353 unsigned int channel_mask;
355 int log2_max_num_subframes;
356 int num_possible_block_sizes;
359 dsputil_init(&s->dsp, avctx);
360 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
362 if (avctx->extradata_size >= 18) {
363 s->decode_flags = AV_RL16(edata_ptr+14);
364 channel_mask = AV_RL32(edata_ptr+2);
365 s->bits_per_sample = AV_RL16(edata_ptr);
366 if (s->bits_per_sample == 16)
367 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
368 else if (s->bits_per_sample == 24)
369 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
371 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %d\n",
373 return AVERROR_INVALIDDATA;
375 /** dump the extradata */
376 for (i = 0; i < avctx->extradata_size; i++)
377 dprintf(avctx, "[%x] ", avctx->extradata[i]);
378 dprintf(avctx, "\n");
381 av_log_ask_for_sample(avctx, "Unknown extradata size\n");
382 return AVERROR_INVALIDDATA;
386 s->log2_frame_size = av_log2(avctx->block_align) + 4;
389 s->skip_frame = 1; /* skip first frame */
391 s->len_prefix = (s->decode_flags & 0x40);
394 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
397 /** init previous block len */
398 for (i = 0; i < avctx->channels; i++)
399 s->channel[i].prev_block_len = s->samples_per_frame;
402 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
403 s->max_num_subframes = 1 << log2_max_num_subframes;
404 s->max_subframe_len_bit = 0;
405 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
407 num_possible_block_sizes = log2_max_num_subframes + 1;
408 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
409 s->dynamic_range_compression = (s->decode_flags & 0x80);
411 s->bV3RTM = s->decode_flags & 0x100;
413 if (s->max_num_subframes > MAX_SUBFRAMES) {
414 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
415 s->max_num_subframes);
416 return AVERROR_INVALIDDATA;
419 s->num_channels = avctx->channels;
421 /** extract lfe channel position */
424 if (channel_mask & 8) {
426 for (mask = 1; mask < 16; mask <<= 1) {
427 if (channel_mask & mask)
432 if (s->num_channels < 0) {
433 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
434 return AVERROR_INVALIDDATA;
435 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
436 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
437 return AVERROR_PATCHWELCOME;
440 avctx->channel_layout = channel_mask;
445 *@brief Decode the subframe length.
447 *@param offset sample offset in the frame
448 *@return decoded subframe length on success, < 0 in case of an error
450 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
453 int subframe_len, len;
455 /** no need to read from the bitstream when only one length is possible */
456 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
457 return s->min_samples_per_subframe;
459 len = av_log2(s->max_num_subframes - 1) + 1;
460 frame_len_ratio = get_bits(&s->gb, len);
462 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
464 /** sanity check the length */
465 if (subframe_len < s->min_samples_per_subframe ||
466 subframe_len > s->samples_per_frame) {
467 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
469 return AVERROR_INVALIDDATA;
475 *@brief Decode how the data in the frame is split into subframes.
476 * Every WMA frame contains the encoded data for a fixed number of
477 * samples per channel. The data for every channel might be split
478 * into several subframes. This function will reconstruct the list of
479 * subframes for every channel.
481 * If the subframes are not evenly split, the algorithm estimates the
482 * channels with the lowest number of total samples.
483 * Afterwards, for each of these channels a bit is read from the
484 * bitstream that indicates if the channel contains a subframe with the
485 * next subframe size that is going to be read from the bitstream or not.
486 * If a channel contains such a subframe, the subframe size gets added to
487 * the channel's subframe list.
488 * The algorithm repeats these steps until the frame is properly divided
489 * between the individual channels.
492 *@return 0 on success, < 0 in case of an error
494 static int decode_tilehdr(WmallDecodeCtx *s)
496 uint16_t num_samples[WMALL_MAX_CHANNELS]; /**< sum of samples for all currently known subframes of a channel */
497 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
498 int channels_for_cur_subframe = s->num_channels; /**< number of channels that contain the current subframe */
499 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subfra2me offsets and sizes */
500 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
503 /* Should never consume more than 3073 bits (256 iterations for the
504 * while loop when always the minimum amount of 128 samples is substracted
505 * from missing samples in the 8 channel case).
506 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
509 /** reset tiling information */
510 for (c = 0; c < s->num_channels; c++)
511 s->channel[c].num_subframes = 0;
513 memset(num_samples, 0, sizeof(num_samples));
515 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
516 fixed_channel_layout = 1;
518 /** loop until the frame data is split between the subframes */
522 /** check which channels contain the subframe */
523 for (c = 0; c < s->num_channels; c++) {
524 if (num_samples[c] == min_channel_len) {
525 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
526 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
527 contains_subframe[c] = 1;
530 contains_subframe[c] = get_bits1(&s->gb);
533 contains_subframe[c] = 0;
536 /** get subframe length, subframe_len == 0 is not allowed */
537 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
538 return AVERROR_INVALIDDATA;
539 /** add subframes to the individual channels and find new min_channel_len */
540 min_channel_len += subframe_len;
541 for (c = 0; c < s->num_channels; c++) {
542 WmallChannelCtx* chan = &s->channel[c];
544 if (contains_subframe[c]) {
545 if (chan->num_subframes >= MAX_SUBFRAMES) {
546 av_log(s->avctx, AV_LOG_ERROR,
547 "broken frame: num subframes > 31\n");
548 return AVERROR_INVALIDDATA;
550 chan->subframe_len[chan->num_subframes] = subframe_len;
551 num_samples[c] += subframe_len;
552 ++chan->num_subframes;
553 if (num_samples[c] > s->samples_per_frame) {
554 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
555 "channel len(%d) > samples_per_frame(%d)\n",
556 num_samples[c], s->samples_per_frame);
557 return AVERROR_INVALIDDATA;
559 } else if (num_samples[c] <= min_channel_len) {
560 if (num_samples[c] < min_channel_len) {
561 channels_for_cur_subframe = 0;
562 min_channel_len = num_samples[c];
564 ++channels_for_cur_subframe;
567 } while (min_channel_len < s->samples_per_frame);
569 for (c = 0; c < s->num_channels; c++) {
572 for (i = 0; i < s->channel[c].num_subframes; i++) {
573 s->channel[c].subframe_offset[i] = offset;
574 offset += s->channel[c].subframe_len[i];
582 static int my_log2(unsigned int i)
584 unsigned int iLog2 = 0;
585 while ((i >> iLog2) > 1)
594 static void decode_ac_filter(WmallDecodeCtx *s)
597 s->acfilter_order = get_bits(&s->gb, 4) + 1;
598 s->acfilter_scaling = get_bits(&s->gb, 4);
600 for(i = 0; i < s->acfilter_order; i++) {
601 s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
609 static void decode_mclms(WmallDecodeCtx *s)
611 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
612 s->mclms_scaling = get_bits(&s->gb, 4);
613 if(get_bits1(&s->gb)) {
617 int cbits = av_log2(s->mclms_scaling + 1);
618 assert(cbits == my_log2(s->mclms_scaling + 1));
619 if(1 << cbits < s->mclms_scaling + 1)
622 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
624 for(i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++) {
625 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
628 for(i = 0; i < s->num_channels; i++) {
630 for(c = 0; c < i; c++) {
631 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
641 static void decode_cdlms(WmallDecodeCtx *s)
644 int cdlms_send_coef = get_bits1(&s->gb);
646 for(c = 0; c < s->num_channels; c++) {
647 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
648 for(i = 0; i < s->cdlms_ttl[c]; i++) {
649 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
652 for(i = 0; i < s->cdlms_ttl[c]; i++) {
653 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
656 if(cdlms_send_coef) {
657 for(i = 0; i < s->cdlms_ttl[c]; i++) {
658 int cbits, shift_l, shift_r, j;
659 cbits = av_log2(s->cdlms[c][i].order);
660 if(1 << cbits < s->cdlms[c][i].order)
662 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
664 cbits = av_log2(s->cdlms[c][i].scaling + 1);
665 if(1 << cbits < s->cdlms[c][i].scaling + 1)
668 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
669 shift_l = 32 - s->cdlms[c][i].bitsend;
670 shift_r = 32 - 2 - s->cdlms[c][i].scaling;
671 for(j = 0; j < s->cdlms[c][i].coefsend; j++) {
672 s->cdlms[c][i].coefs[j] =
673 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
683 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
686 unsigned int ave_mean;
687 s->transient[ch] = get_bits1(&s->gb);
688 if(s->transient[ch]) {
689 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
690 if (s->transient_pos[ch])
691 s->transient[ch] = 0;
692 s->channel[ch].transient_counter =
693 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
694 } else if (s->channel[ch].transient_counter)
695 s->transient[ch] = 1;
697 if(s->seekable_tile) {
698 ave_mean = get_bits(&s->gb, s->bits_per_sample);
699 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
700 // s->ave_sum[ch] *= 2;
703 if(s->seekable_tile) {
704 if(s->do_inter_ch_decorr)
705 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
707 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
710 //av_log(0, 0, "%8d: ", num_logged_tiles++);
711 for(; i < tile_size; i++) {
712 int quo = 0, rem, rem_bits, residue;
713 while(get_bits1(&s->gb))
716 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
718 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
719 rem_bits = av_ceil_log2(ave_mean);
720 rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
721 residue = (quo << rem_bits) + rem;
723 s->ave_sum[ch] = residue + s->ave_sum[ch] - (s->ave_sum[ch] >> s->movave_scaling);
726 residue = -(residue >> 1) - 1;
728 residue = residue >> 1;
729 s->channel_residues[ch][i] = residue;
731 //dump_int_buffer(s->channel_residues[ch], 4, tile_size, 16);
742 decode_lpc(WmallDecodeCtx *s)
745 s->lpc_order = get_bits(&s->gb, 5) + 1;
746 s->lpc_scaling = get_bits(&s->gb, 4);
747 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
748 cbits = s->lpc_scaling + s->lpc_intbits;
749 for(ch = 0; ch < s->num_channels; ch++) {
750 for(i = 0; i < s->lpc_order; i++) {
751 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
757 static void clear_codec_buffers(WmallDecodeCtx *s)
761 memset(s->acfilter_coeffs , 0, 16 * sizeof(int));
762 memset(s->acfilter_prevvalues, 0, 16 * 2 * sizeof(int)); // may be wrong
763 memset(s->lpc_coefs , 0, 40 * 2 * sizeof(int));
765 memset(s->mclms_coeffs , 0, 128 * sizeof(int16_t));
766 memset(s->mclms_coeffs_cur, 0, 4 * sizeof(int16_t));
767 memset(s->mclms_prevvalues, 0, 64 * sizeof(int));
768 memset(s->mclms_updates , 0, 64 * sizeof(int16_t));
770 for (ich = 0; ich < s->num_channels; ich++) {
771 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
772 memset(s->cdlms[ich][ilms].coefs , 0, 256 * sizeof(int16_t));
773 memset(s->cdlms[ich][ilms].lms_prevvalues, 0, 512 * sizeof(int16_t));
774 memset(s->cdlms[ich][ilms].lms_updates , 0, 512 * sizeof(int16_t));
781 *@brief Resets filter parameters and transient area at new seekable tile
783 static void reset_codec(WmallDecodeCtx *s)
786 s->mclms_recent = s->mclms_order * s->num_channels;
787 for (ich = 0; ich < s->num_channels; ich++) {
788 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
789 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
790 /* first sample of a seekable subframe is considered as the starting of
791 a transient area which is samples_per_frame samples long */
792 s->channel[ich].transient_counter = s->samples_per_frame;
793 s->transient[ich] = 1;
794 s->transient_pos[ich] = 0;
800 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
804 int order = s->mclms_order;
805 int num_channels = s->num_channels;
806 int range = 1 << (s->bits_per_sample - 1);
807 int bps = s->bits_per_sample > 16 ? 4 : 2; // bytes per sample
809 for (ich = 0; ich < num_channels; ich++) {
810 pred_error = s->channel_residues[ich][icoef] - pred[ich];
811 if (pred_error > 0) {
812 for (i = 0; i < order * num_channels; i++)
813 s->mclms_coeffs[i + ich * order * num_channels] +=
814 s->mclms_updates[s->mclms_recent + i];
815 for (j = 0; j < ich; j++) {
816 if (s->channel_residues[j][icoef] > 0)
817 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
818 else if (s->channel_residues[j][icoef] < 0)
819 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
821 } else if (pred_error < 0) {
822 for (i = 0; i < order * num_channels; i++)
823 s->mclms_coeffs[i + ich * order * num_channels] -=
824 s->mclms_updates[s->mclms_recent + i];
825 for (j = 0; j < ich; j++) {
826 if (s->channel_residues[j][icoef] > 0)
827 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
828 else if (s->channel_residues[j][icoef] < 0)
829 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
834 for (ich = num_channels - 1; ich >= 0; ich--) {
836 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
837 if (s->channel_residues[ich][icoef] > range - 1)
838 s->mclms_prevvalues[s->mclms_recent] = range - 1;
839 else if (s->channel_residues[ich][icoef] < -range)
840 s->mclms_prevvalues[s->mclms_recent] = -range;
842 s->mclms_updates[s->mclms_recent] = 0;
843 if (s->channel_residues[ich][icoef] > 0)
844 s->mclms_updates[s->mclms_recent] = 1;
845 else if (s->channel_residues[ich][icoef] < 0)
846 s->mclms_updates[s->mclms_recent] = -1;
849 if (s->mclms_recent == 0) {
850 memcpy(&s->mclms_prevvalues[order * num_channels],
852 bps * order * num_channels);
853 memcpy(&s->mclms_updates[order * num_channels],
855 bps * order * num_channels);
856 s->mclms_recent = num_channels * order;
860 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
863 int order = s->mclms_order;
864 int num_channels = s->num_channels;
866 for (ich = 0; ich < num_channels; ich++) {
867 if (!s->is_channel_coded[ich])
870 for (i = 0; i < order * num_channels; i++)
871 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
872 s->mclms_coeffs[i + order * num_channels * ich];
873 for (i = 0; i < ich; i++)
874 pred[ich] += s->channel_residues[i][icoef] *
875 s->mclms_coeffs_cur[i + num_channels * ich];
876 pred[ich] += 1 << s->mclms_scaling - 1;
877 pred[ich] >>= s->mclms_scaling;
878 s->channel_residues[ich][icoef] += pred[ich];
882 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
884 int icoef, pred[s->num_channels];
885 for (icoef = 0; icoef < tile_size; icoef++) {
886 mclms_predict(s, icoef, pred);
887 mclms_update(s, icoef, pred);
891 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
895 int recent = s->cdlms[ich][ilms].recent;
897 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
898 pred += s->cdlms[ich][ilms].coefs[icoef] *
899 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
901 //pred += (1 << (s->cdlms[ich][ilms].scaling - 1));
902 /* XXX: Table 29 has:
903 iPred >= cdlms[iCh][ilms].scaling;
904 seems to me like a missing > */
905 //pred >>= s->cdlms[ich][ilms].scaling;
909 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input, int residue)
912 int recent = s->cdlms[ich][ilms].recent;
913 int range = 1 << s->bits_per_sample - 1;
914 int bps = s->bits_per_sample > 16 ? 4 : 2; // bytes per sample
917 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
918 s->cdlms[ich][ilms].coefs[icoef] -=
919 s->cdlms[ich][ilms].lms_updates[icoef + recent];
920 } else if (residue > 0) {
921 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
922 s->cdlms[ich][ilms].coefs[icoef] +=
923 s->cdlms[ich][ilms].lms_updates[icoef + recent]; /* spec mistakenly
924 dropped the recent */
930 /* XXX: This memcpy()s will probably fail if a fixed 32-bit buffer is used.
931 follow kshishkov's suggestion of using a union. */
932 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
933 s->cdlms[ich][ilms].lms_prevvalues,
934 bps * s->cdlms[ich][ilms].order);
935 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
936 s->cdlms[ich][ilms].lms_updates,
937 bps * s->cdlms[ich][ilms].order);
938 recent = s->cdlms[ich][ilms].order - 1;
941 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
943 s->cdlms[ich][ilms].lms_updates[recent] = 0;
945 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
947 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
950 cdlms[iCh][ilms].updates[iRecent + cdlms[iCh][ilms].order >> 4] >>= 2;
951 lms_updates[iCh][ilms][iRecent + cdlms[iCh][ilms].order >> 3] >>= 1;
953 Questions is - are cdlms[iCh][ilms].updates[] and lms_updates[][][] two
954 seperate buffers? Here I've assumed that the two are same which makes
957 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
958 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
959 s->cdlms[ich][ilms].recent = recent;
962 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
964 int ilms, recent, icoef;
965 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
966 recent = s->cdlms[ich][ilms].recent;
967 if (s->update_speed[ich] == 16)
970 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
971 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
973 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
974 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
977 s->update_speed[ich] = 16;
980 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
982 int ilms, recent, icoef;
983 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
984 recent = s->cdlms[ich][ilms].recent;
985 if (s->update_speed[ich] == 8)
988 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
989 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
991 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
992 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
995 s->update_speed[ich] = 8;
998 static void revert_cdlms(WmallDecodeCtx *s, int ch, int coef_begin, int coef_end)
1005 num_lms = s->cdlms_ttl[ch];
1006 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
1007 //s->cdlms[ch][ilms].recent = s->cdlms[ch][ilms].order;
1008 for (icoef = coef_begin; icoef < coef_end; icoef++) {
1009 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
1010 residue = s->channel_residues[ch][icoef];
1011 pred += lms_predict(s, ch, ilms);
1012 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
1013 lms_update(s, ch, ilms, input, residue);
1014 s->channel_residues[ch][icoef] = input;
1019 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
1022 if (s->num_channels != 2)
1025 for (icoef = 0; icoef < tile_size; icoef++) {
1026 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
1027 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
1032 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
1037 int64_t *filter_coeffs = s->acfilter_coeffs;
1038 int scaling = s->acfilter_scaling;
1039 int order = s->acfilter_order;
1041 for (ich = 0; ich < s->num_channels; ich++) {
1042 int *prevvalues = s->acfilter_prevvalues[ich];
1043 for (i = 0; i < order; i++) {
1045 for (j = 0; j < order; j++) {
1047 pred += filter_coeffs[j] * prevvalues[j - i];
1049 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
1052 s->channel_residues[ich][i] += pred;
1054 for (i = order; i < tile_size; i++) {
1056 for (j = 0; j < order; j++)
1057 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
1059 s->channel_residues[ich][i] += pred;
1061 for (j = 0; j < order; j++)
1062 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
1067 *@brief Decode a single subframe (block).
1068 *@param s codec context
1069 *@return 0 on success, < 0 when decoding failed
1071 static int decode_subframe(WmallDecodeCtx *s)
1073 int offset = s->samples_per_frame;
1074 int subframe_len = s->samples_per_frame;
1076 int total_samples = s->samples_per_frame * s->num_channels;
1080 s->subframe_offset = get_bits_count(&s->gb);
1082 /** reset channel context and find the next block offset and size
1083 == the next block of the channel with the smallest number of
1086 for (i = 0; i < s->num_channels; i++) {
1087 s->channel[i].grouped = 0;
1088 if (offset > s->channel[i].decoded_samples) {
1089 offset = s->channel[i].decoded_samples;
1091 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1095 /** get a list of all channels that contain the estimated block */
1096 s->channels_for_cur_subframe = 0;
1097 for (i = 0; i < s->num_channels; i++) {
1098 const int cur_subframe = s->channel[i].cur_subframe;
1099 /** substract already processed samples */
1100 total_samples -= s->channel[i].decoded_samples;
1102 /** and count if there are multiple subframes that match our profile */
1103 if (offset == s->channel[i].decoded_samples &&
1104 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1105 total_samples -= s->channel[i].subframe_len[cur_subframe];
1106 s->channel[i].decoded_samples +=
1107 s->channel[i].subframe_len[cur_subframe];
1108 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1109 ++s->channels_for_cur_subframe;
1113 /** check if the frame will be complete after processing the
1116 s->parsed_all_subframes = 1;
1119 s->seekable_tile = get_bits1(&s->gb);
1120 if(s->seekable_tile) {
1121 clear_codec_buffers(s);
1123 s->do_arith_coding = get_bits1(&s->gb);
1124 if(s->do_arith_coding) {
1125 dprintf(s->avctx, "do_arith_coding == 1");
1128 s->do_ac_filter = get_bits1(&s->gb);
1129 s->do_inter_ch_decorr = get_bits1(&s->gb);
1130 s->do_mclms = get_bits1(&s->gb);
1133 decode_ac_filter(s);
1139 s->movave_scaling = get_bits(&s->gb, 3);
1140 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
1145 rawpcm_tile = get_bits1(&s->gb);
1147 for(i = 0; i < s->num_channels; i++) {
1148 s->is_channel_coded[i] = 1;
1153 for(i = 0; i < s->num_channels; i++) {
1154 s->is_channel_coded[i] = get_bits1(&s->gb);
1159 s->do_lpc = get_bits1(&s->gb);
1169 if(get_bits1(&s->gb)) {
1170 padding_zeroes = get_bits(&s->gb, 5);
1177 int bits = s->bits_per_sample - padding_zeroes;
1178 dprintf(s->avctx, "RAWPCM %d bits per sample. total %d bits, remain=%d\n", bits,
1179 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
1180 for(i = 0; i < s->num_channels; i++) {
1181 for(j = 0; j < subframe_len; j++) {
1182 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
1183 // dprintf(s->avctx, "PCM[%d][%d] = 0x%04x\n", i, j, s->channel_coeffs[i][j]);
1187 for(i = 0; i < s->num_channels; i++)
1188 if(s->is_channel_coded[i]) {
1189 decode_channel_residues(s, i, subframe_len);
1190 if (s->seekable_tile)
1191 use_high_update_speed(s, i);
1193 use_normal_update_speed(s, i);
1194 revert_cdlms(s, i, 0, subframe_len);
1198 revert_mclms(s, subframe_len);
1199 if (s->do_inter_ch_decorr)
1200 revert_inter_ch_decorr(s, subframe_len);
1202 revert_acfilter(s, subframe_len);
1205 if (s->quant_stepsize != 1)
1206 for (i = 0; i < s->num_channels; i++)
1207 for (j = 0; j < subframe_len; j++)
1208 s->channel_residues[i][j] *= s->quant_stepsize;
1210 // Write to proper output buffer depending on bit-depth
1211 for (i = 0; i < subframe_len; i++)
1212 for (j = 0; j < s->num_channels; j++) {
1213 if (s->bits_per_sample == 16)
1214 *s->samples_16++ = (int16_t) s->channel_residues[j][i];
1216 *s->samples_32++ = s->channel_residues[j][i];
1219 /** handled one subframe */
1221 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1222 int c = s->channel_indexes_for_cur_subframe[i];
1223 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1224 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1225 return AVERROR_INVALIDDATA;
1227 ++s->channel[c].cur_subframe;
1229 num_logged_subframes++;
1234 *@brief Decode one WMA frame.
1235 *@param s codec context
1236 *@return 0 if the trailer bit indicates that this is the last frame,
1237 * 1 if there are additional frames
1239 static int decode_frame(WmallDecodeCtx *s)
1241 GetBitContext* gb = &s->gb;
1242 int more_frames = 0;
1247 /** check for potential output buffer overflow */
1248 if (s->bits_per_sample == 16)
1249 buffer_len = s->samples_16_end - s->samples_16;
1251 buffer_len = s->samples_32_end - s->samples_32;
1252 if (s->num_channels * s->samples_per_frame > buffer_len) {
1253 /** return an error if no frame could be decoded at all */
1254 av_log(s->avctx, AV_LOG_ERROR,
1255 "not enough space for the output samples\n");
1260 /** get frame length */
1262 len = get_bits(gb, s->log2_frame_size);
1264 /** decode tile information */
1265 if (decode_tilehdr(s)) {
1270 /** read drc info */
1271 if (s->dynamic_range_compression) {
1272 s->drc_gain = get_bits(gb, 8);
1275 /** no idea what these are for, might be the number of samples
1276 that need to be skipped at the beginning or end of a stream */
1277 if (get_bits1(gb)) {
1280 /** usually true for the first frame */
1281 if (get_bits1(gb)) {
1282 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1283 dprintf(s->avctx, "start skip: %i\n", skip);
1286 /** sometimes true for the last frame */
1287 if (get_bits1(gb)) {
1288 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1289 dprintf(s->avctx, "end skip: %i\n", skip);
1294 /** reset subframe states */
1295 s->parsed_all_subframes = 0;
1296 for (i = 0; i < s->num_channels; i++) {
1297 s->channel[i].decoded_samples = 0;
1298 s->channel[i].cur_subframe = 0;
1299 s->channel[i].reuse_sf = 0;
1302 /** decode all subframes */
1303 while (!s->parsed_all_subframes) {
1304 if (decode_subframe(s) < 0) {
1310 dprintf(s->avctx, "Frame done\n");
1312 if (s->skip_frame) {
1316 if (s->len_prefix) {
1317 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1318 /** FIXME: not sure if this is always an error */
1319 av_log(s->avctx, AV_LOG_ERROR,
1320 "frame[%i] would have to skip %i bits\n", s->frame_num,
1321 len - (get_bits_count(gb) - s->frame_offset) - 1);
1326 /** skip the rest of the frame data */
1327 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1330 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1331 dprintf(s->avctx, "skip1\n");
1336 /** decode trailer bit */
1337 more_frames = get_bits1(gb);
1343 *@brief Calculate remaining input buffer length.
1344 *@param s codec context
1345 *@param gb bitstream reader context
1346 *@return remaining size in bits
1348 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1350 return s->buf_bit_size - get_bits_count(gb);
1354 *@brief Fill the bit reservoir with a (partial) frame.
1355 *@param s codec context
1356 *@param gb bitstream reader context
1357 *@param len length of the partial frame
1358 *@param append decides wether to reset the buffer or not
1360 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1365 /** when the frame data does not need to be concatenated, the input buffer
1366 is resetted and additional bits from the previous frame are copyed
1367 and skipped later so that a fast byte copy is possible */
1370 s->frame_offset = get_bits_count(gb) & 7;
1371 s->num_saved_bits = s->frame_offset;
1372 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1375 buflen = (s->num_saved_bits + len + 8) >> 3;
1377 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1378 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1383 s->num_saved_bits += len;
1385 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1388 int align = 8 - (get_bits_count(gb) & 7);
1389 align = FFMIN(align, len);
1390 put_bits(&s->pb, align, get_bits(gb, align));
1392 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1394 skip_bits_long(gb, len);
1397 PutBitContext tmp = s->pb;
1398 flush_put_bits(&tmp);
1401 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1402 skip_bits(&s->gb, s->frame_offset);
1406 *@brief Decode a single WMA packet.
1407 *@param avctx codec context
1408 *@param data the output buffer
1409 *@param data_size number of bytes that were written to the output buffer
1410 *@param avpkt input packet
1411 *@return number of bytes that were read from the input buffer
1413 static int decode_packet(AVCodecContext *avctx,
1414 void *data, int *data_size, AVPacket* avpkt)
1416 WmallDecodeCtx *s = avctx->priv_data;
1417 GetBitContext* gb = &s->pgb;
1418 const uint8_t* buf = avpkt->data;
1419 int buf_size = avpkt->size;
1420 int num_bits_prev_frame;
1421 int packet_sequence_number;
1423 if (s->bits_per_sample == 16) {
1424 s->samples_16 = (int16_t *) data;
1425 s->samples_16_end = (int16_t *) ((int8_t*)data + *data_size);
1427 s->samples_32 = (void *) data;
1428 s->samples_32_end = (void *) ((int8_t*)data + *data_size);
1432 if (s->packet_done || s->packet_loss) {
1433 int seekable_frame_in_packet, spliced_packet;
1436 /** sanity check for the buffer length */
1437 if (buf_size < avctx->block_align)
1440 s->next_packet_start = buf_size - avctx->block_align;
1441 buf_size = avctx->block_align;
1442 s->buf_bit_size = buf_size << 3;
1444 /** parse packet header */
1445 init_get_bits(gb, buf, s->buf_bit_size);
1446 packet_sequence_number = get_bits(gb, 4);
1447 seekable_frame_in_packet = get_bits1(gb);
1448 spliced_packet = get_bits1(gb);
1450 /** get number of bits that need to be added to the previous frame */
1451 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1453 /** check for packet loss */
1454 if (!s->packet_loss &&
1455 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1457 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1458 s->packet_sequence_number, packet_sequence_number);
1460 s->packet_sequence_number = packet_sequence_number;
1462 if (num_bits_prev_frame > 0) {
1463 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1464 if (num_bits_prev_frame >= remaining_packet_bits) {
1465 num_bits_prev_frame = remaining_packet_bits;
1469 /** append the previous frame data to the remaining data from the
1470 previous packet to create a full frame */
1471 save_bits(s, gb, num_bits_prev_frame, 1);
1473 /** decode the cross packet frame if it is valid */
1474 if (!s->packet_loss)
1476 } else if (s->num_saved_bits - s->frame_offset) {
1477 dprintf(avctx, "ignoring %x previously saved bits\n",
1478 s->num_saved_bits - s->frame_offset);
1481 if (s->packet_loss) {
1482 /** reset number of saved bits so that the decoder
1483 does not start to decode incomplete frames in the
1484 s->len_prefix == 0 case */
1485 s->num_saved_bits = 0;
1492 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1493 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1494 skip_bits(gb, s->packet_offset);
1496 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1497 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1498 frame_size <= remaining_bits(s, gb)) {
1499 save_bits(s, gb, frame_size, 0);
1500 s->packet_done = !decode_frame(s);
1501 } else if (!s->len_prefix
1502 && s->num_saved_bits > get_bits_count(&s->gb)) {
1503 /** when the frames do not have a length prefix, we don't know
1504 the compressed length of the individual frames
1505 however, we know what part of a new packet belongs to the
1507 therefore we save the incoming packet first, then we append
1508 the "previous frame" data from the next packet so that
1509 we get a buffer that only contains full frames */
1510 s->packet_done = !decode_frame(s);
1516 if (s->packet_done && !s->packet_loss &&
1517 remaining_bits(s, gb) > 0) {
1518 /** save the rest of the data so that it can be decoded
1519 with the next packet */
1520 save_bits(s, gb, remaining_bits(s, gb), 0);
1523 if (s->bits_per_sample == 16)
1524 *data_size = (int8_t *)s->samples_16 - (int8_t *)data;
1526 *data_size = (int8_t *)s->samples_32 - (int8_t *)data;
1527 s->packet_offset = get_bits_count(gb) & 7;
1529 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1533 *@brief Clear decoder buffers (for seeking).
1534 *@param avctx codec context
1536 static void flush(AVCodecContext *avctx)
1538 WmallDecodeCtx *s = avctx->priv_data;
1540 /** reset output buffer as a part of it is used during the windowing of a
1542 for (i = 0; i < s->num_channels; i++)
1543 memset(s->channel[i].out, 0, s->samples_per_frame *
1544 sizeof(*s->channel[i].out));
1550 *@brief wmall decoder
1552 AVCodec ff_wmalossless_decoder = {
1553 .name = "wmalossless",
1554 .type = AVMEDIA_TYPE_AUDIO,
1555 .id = CODEC_ID_WMALOSSLESS,
1556 .priv_data_size = sizeof(WmallDecodeCtx),
1557 .init = decode_init,
1558 .close = decode_end,
1559 .decode = decode_packet,
1561 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_EXPERIMENTAL,
1562 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Lossless"),