avcodec/wmaprodec: cleanup extradata dumping
[ffmpeg.git] / libavcodec / wmaprodec.c
1 /*
2  * Wmapro compatible decoder
3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
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.
12  *
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.
17  *
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
21  */
22
23 /**
24  * @file
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
31  * - IMDCT
32  * - windowing and overlapp-add
33  *
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
39  * a frame.
40  * The number of samples and a few other decode flags are stored
41  * as extradata that has to be passed to the decoder.
42  *
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.
46  *
47  * Example wmapro bitstream (in samples):
48  *
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  * ---------------------------------------------------
57  *
58  * The frame layouts for the individual channels of a wma frame does not need
59  * to be the same.
60  *
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.
71  *
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
79  * codes.
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
82  * modifier.
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.
87  */
88
89 #include <inttypes.h>
90
91 #include "libavutil/ffmath.h"
92 #include "libavutil/float_dsp.h"
93 #include "libavutil/intfloat.h"
94 #include "libavutil/intreadwrite.h"
95 #include "avcodec.h"
96 #include "internal.h"
97 #include "get_bits.h"
98 #include "put_bits.h"
99 #include "wmaprodata.h"
100 #include "sinewin.h"
101 #include "wma.h"
102 #include "wma_common.h"
103
104 /** current decoder limitations */
105 #define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
106 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
107 #define MAX_BANDS      29                                    ///< max number of scale factor bands
108 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
109
110 #define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
111 #define WMAPRO_BLOCK_MAX_BITS 13                                           ///< log2 of max block size
112 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)                 ///< minimum block size
113 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
114 #define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
115
116
117 #define VLCBITS            9
118 #define SCALEVLCBITS       8
119 #define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
120 #define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
121 #define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
122 #define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
123 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
124
125 static VLC              sf_vlc;           ///< scale factor DPCM vlc
126 static VLC              sf_rl_vlc;        ///< scale factor run length vlc
127 static VLC              vec4_vlc;         ///< 4 coefficients per symbol
128 static VLC              vec2_vlc;         ///< 2 coefficients per symbol
129 static VLC              vec1_vlc;         ///< 1 coefficient per symbol
130 static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
131 static float            sin64[33];        ///< sine table for decorrelation
132
133 /**
134  * @brief frame specific decoder context for a single channel
135  */
136 typedef struct WMAProChannelCtx {
137     int16_t  prev_block_len;                          ///< length of the previous block
138     uint8_t  transmit_coefs;
139     uint8_t  num_subframes;
140     uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
141     uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
142     uint8_t  cur_subframe;                            ///< current subframe number
143     uint16_t decoded_samples;                         ///< number of already processed samples
144     uint8_t  grouped;                                 ///< channel is part of a group
145     int      quant_step;                              ///< quantization step for the current subframe
146     int8_t   reuse_sf;                                ///< share scale factors between subframes
147     int8_t   scale_factor_step;                       ///< scaling step for the current subframe
148     int      max_scale_factor;                        ///< maximum scale factor for the current subframe
149     int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
150     int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
151     int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
152     uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
153     float*   coeffs;                                  ///< pointer to the subframe decode buffer
154     uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
155     DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
156 } WMAProChannelCtx;
157
158 /**
159  * @brief channel group for channel transformations
160  */
161 typedef struct WMAProChannelGrp {
162     uint8_t num_channels;                                     ///< number of channels in the group
163     int8_t  transform;                                        ///< transform on / off
164     int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
165     float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
166     float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
167 } WMAProChannelGrp;
168
169 /**
170  * @brief main decoder context
171  */
172 typedef struct WMAProDecodeCtx {
173     /* generic decoder variables */
174     AVCodecContext*  avctx;                         ///< codec context for av_log
175     AVFloatDSPContext *fdsp;
176     uint8_t          frame_data[MAX_FRAMESIZE +
177                       AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
178     PutBitContext    pb;                            ///< context for filling the frame_data buffer
179     FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
180     DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
181     const float*     windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
182
183     /* frame size dependent frame information (set during initialization) */
184     uint32_t         decode_flags;                  ///< used compression features
185     uint8_t          len_prefix;                    ///< frame is prefixed with its length
186     uint8_t          dynamic_range_compression;     ///< frame contains DRC data
187     uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
188     uint16_t         samples_per_frame;             ///< number of samples to output
189     uint16_t         log2_frame_size;
190     int8_t           lfe_channel;                   ///< lfe channel index
191     uint8_t          max_num_subframes;
192     uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
193     uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
194     uint16_t         min_samples_per_subframe;
195     int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
196     int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
197     int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
198     int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
199
200     /* packet decode state */
201     GetBitContext    pgb;                           ///< bitstream reader context for the packet
202     int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
203     uint8_t          packet_offset;                 ///< frame offset in the packet
204     uint8_t          packet_sequence_number;        ///< current packet number
205     int              num_saved_bits;                ///< saved number of bits
206     int              frame_offset;                  ///< frame offset in the bit reservoir
207     int              subframe_offset;               ///< subframe offset in the bit reservoir
208     uint8_t          packet_loss;                   ///< set in case of bitstream error
209     uint8_t          packet_done;                   ///< set when a packet is fully decoded
210     uint8_t          skip_packets;
211
212     /* frame decode state */
213     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
214     int              num_frames;
215     GetBitContext    gb;                            ///< bitstream reader context
216     int              buf_bit_size;                  ///< buffer size in bits
217     uint8_t          drc_gain;                      ///< gain for the DRC tool
218     int8_t           skip_frame;                    ///< skip output step
219     int8_t           parsed_all_subframes;          ///< all subframes decoded?
220
221     /* subframe/block decode state */
222     int16_t          subframe_len;                  ///< current subframe length
223     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
224     int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
225     int8_t           num_bands;                     ///< number of scale factor bands
226     int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
227     int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
228     uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
229     int8_t           esc_len;                       ///< length of escaped coefficients
230
231     uint8_t          num_chgroups;                  ///< number of channel groups
232     WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  ///< channel group information
233
234     WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
235 } WMAProDecodeCtx;
236
237
238 /**
239  *@brief helper function to print the most important members of the context
240  *@param s context
241  */
242 static av_cold void dump_context(WMAProDecodeCtx *s)
243 {
244 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
245 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
246
247     PRINT("ed sample bit depth", s->bits_per_sample);
248     PRINT_HEX("ed decode flags", s->decode_flags);
249     PRINT("samples per frame",   s->samples_per_frame);
250     PRINT("log2 frame size",     s->log2_frame_size);
251     PRINT("max num subframes",   s->max_num_subframes);
252     PRINT("len prefix",          s->len_prefix);
253     PRINT("num channels",        s->avctx->channels);
254 }
255
256 /**
257  *@brief Uninitialize the decoder and free all resources.
258  *@param avctx codec context
259  *@return 0 on success, < 0 otherwise
260  */
261 static av_cold int decode_end(AVCodecContext *avctx)
262 {
263     WMAProDecodeCtx *s = avctx->priv_data;
264     int i;
265
266     av_freep(&s->fdsp);
267
268     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
269         ff_mdct_end(&s->mdct_ctx[i]);
270
271     return 0;
272 }
273
274 static av_cold int get_rate(AVCodecContext *avctx)
275 {
276     if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
277         if (avctx->sample_rate > 44100)
278             return 48000;
279         else if (avctx->sample_rate > 32000)
280             return 44100;
281         else if (avctx->sample_rate > 24000)
282             return 32000;
283         return 24000;
284     }
285
286     return avctx->sample_rate;
287 }
288
289 /**
290  *@brief Initialize the decoder.
291  *@param avctx codec context
292  *@return 0 on success, -1 otherwise
293  */
294 static av_cold int decode_init(AVCodecContext *avctx)
295 {
296     WMAProDecodeCtx *s = avctx->priv_data;
297     uint8_t *edata_ptr = avctx->extradata;
298     unsigned int channel_mask;
299     int i, bits;
300     int log2_max_num_subframes;
301     int num_possible_block_sizes;
302
303     if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
304         avctx->block_align = 2048;
305
306     if (!avctx->block_align) {
307         av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
308         return AVERROR(EINVAL);
309     }
310
311     s->avctx = avctx;
312     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
313     if (!s->fdsp)
314         return AVERROR(ENOMEM);
315
316     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
317
318     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
319
320     /** dump the extradata */
321     av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
322     for (i = 0; i < avctx->extradata_size; i++)
323         av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
324     av_log(avctx, AV_LOG_DEBUG, "\n");
325     if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 34) {
326         s->decode_flags    = 0x10d6;
327         channel_mask       = AV_RL32(edata_ptr+2);
328         s->bits_per_sample = 16;
329
330      } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 28) {
331         s->decode_flags    = 0x10d6;
332         s->bits_per_sample = 16;
333         channel_mask       = 0;
334      } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
335         s->decode_flags    = AV_RL16(edata_ptr+14);
336         channel_mask       = AV_RL32(edata_ptr+2);
337         s->bits_per_sample = AV_RL16(edata_ptr);
338
339         if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
340             avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
341             return AVERROR_PATCHWELCOME;
342         }
343     } else {
344         avpriv_request_sample(avctx, "Unknown extradata size");
345         return AVERROR_PATCHWELCOME;
346     }
347
348     if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {
349         avpriv_report_missing_feature(avctx, ">2 channels support");
350         return AVERROR_PATCHWELCOME;
351     }
352
353     /** generic init */
354     s->log2_frame_size = av_log2(avctx->block_align) + 4;
355     if (s->log2_frame_size > 25) {
356         avpriv_request_sample(avctx, "Large block align");
357         return AVERROR_PATCHWELCOME;
358     }
359
360     /** frame info */
361     if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
362         s->skip_frame = 0;
363     else
364         s->skip_frame = 1; /* skip first frame */
365
366     s->packet_loss = 1;
367     s->len_prefix  = (s->decode_flags & 0x40);
368
369     /** get frame len */
370     if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
371         bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
372         if (bits > WMAPRO_BLOCK_MAX_BITS) {
373             avpriv_request_sample(avctx, "14-bit block sizes");
374             return AVERROR_PATCHWELCOME;
375         }
376         s->samples_per_frame = 1 << bits;
377     } else {
378         s->samples_per_frame = 512;
379     }
380
381     /** subframe info */
382     log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
383     s->max_num_subframes         = 1 << log2_max_num_subframes;
384     if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
385         s->max_subframe_len_bit = 1;
386     s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
387
388     num_possible_block_sizes     = log2_max_num_subframes + 1;
389     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
390     s->dynamic_range_compression = (s->decode_flags & 0x80);
391
392     if (s->max_num_subframes > MAX_SUBFRAMES) {
393         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
394                s->max_num_subframes);
395         return AVERROR_INVALIDDATA;
396     }
397
398     if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
399         av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
400                s->min_samples_per_subframe);
401         return AVERROR_INVALIDDATA;
402     }
403
404     if (s->avctx->sample_rate <= 0) {
405         av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
406         return AVERROR_INVALIDDATA;
407     }
408
409     if (avctx->channels < 0) {
410         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
411                avctx->channels);
412         return AVERROR_INVALIDDATA;
413     } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
414         avpriv_request_sample(avctx,
415                               "More than %d channels", WMAPRO_MAX_CHANNELS);
416         return AVERROR_PATCHWELCOME;
417     }
418
419     /** init previous block len */
420     for (i = 0; i < avctx->channels; i++)
421         s->channel[i].prev_block_len = s->samples_per_frame;
422
423     /** extract lfe channel position */
424     s->lfe_channel = -1;
425
426     if (channel_mask & 8) {
427         unsigned int mask;
428         for (mask = 1; mask < 16; mask <<= 1) {
429             if (channel_mask & mask)
430                 ++s->lfe_channel;
431         }
432     }
433
434     INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
435                     scale_huffbits, 1, 1,
436                     scale_huffcodes, 2, 2, 616);
437
438     INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
439                     scale_rl_huffbits, 1, 1,
440                     scale_rl_huffcodes, 4, 4, 1406);
441
442     INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
443                     coef0_huffbits, 1, 1,
444                     coef0_huffcodes, 4, 4, 2108);
445
446     INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
447                     coef1_huffbits, 1, 1,
448                     coef1_huffcodes, 4, 4, 3912);
449
450     INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
451                     vec4_huffbits, 1, 1,
452                     vec4_huffcodes, 2, 2, 604);
453
454     INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
455                     vec2_huffbits, 1, 1,
456                     vec2_huffcodes, 2, 2, 562);
457
458     INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
459                     vec1_huffbits, 1, 1,
460                     vec1_huffcodes, 2, 2, 562);
461
462     /** calculate number of scale factor bands and their offsets
463         for every possible block size */
464     for (i = 0; i < num_possible_block_sizes; i++) {
465         int subframe_len = s->samples_per_frame >> i;
466         int x;
467         int band = 1;
468         int rate = get_rate(avctx);
469
470         s->sfb_offsets[i][0] = 0;
471
472         for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
473             int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
474             offset &= ~3;
475             if (offset > s->sfb_offsets[i][band - 1])
476                 s->sfb_offsets[i][band++] = offset;
477
478             if (offset >= subframe_len)
479                 break;
480         }
481         s->sfb_offsets[i][band - 1] = subframe_len;
482         s->num_sfb[i]               = band - 1;
483         if (s->num_sfb[i] <= 0) {
484             av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
485             return AVERROR_INVALIDDATA;
486         }
487     }
488
489
490     /** Scale factors can be shared between blocks of different size
491         as every block has a different scale factor band layout.
492         The matrix sf_offsets is needed to find the correct scale factor.
493      */
494
495     for (i = 0; i < num_possible_block_sizes; i++) {
496         int b;
497         for (b = 0; b < s->num_sfb[i]; b++) {
498             int x;
499             int offset = ((s->sfb_offsets[i][b]
500                            + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
501             for (x = 0; x < num_possible_block_sizes; x++) {
502                 int v = 0;
503                 while (s->sfb_offsets[x][v + 1] << x < offset) {
504                     v++;
505                     av_assert0(v < MAX_BANDS);
506                 }
507                 s->sf_offsets[i][x][b] = v;
508             }
509         }
510     }
511
512     /** init MDCT, FIXME: only init needed sizes */
513     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
514         ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
515                      1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
516                      / (1 << (s->bits_per_sample - 1)));
517
518     /** init MDCT windows: simple sine window */
519     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
520         const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
521         ff_init_ff_sine_windows(win_idx);
522         s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
523     }
524
525     /** calculate subwoofer cutoff values */
526     for (i = 0; i < num_possible_block_sizes; i++) {
527         int block_size = s->samples_per_frame >> i;
528         int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
529                      / s->avctx->sample_rate;
530         s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
531     }
532
533     /** calculate sine values for the decorrelation matrix */
534     for (i = 0; i < 33; i++)
535         sin64[i] = sin(i*M_PI / 64.0);
536
537     if (avctx->debug & FF_DEBUG_BITSTREAM)
538         dump_context(s);
539
540     avctx->channel_layout = channel_mask;
541
542     return 0;
543 }
544
545 /**
546  *@brief Decode the subframe length.
547  *@param s context
548  *@param offset sample offset in the frame
549  *@return decoded subframe length on success, < 0 in case of an error
550  */
551 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
552 {
553     int frame_len_shift = 0;
554     int subframe_len;
555
556     /** no need to read from the bitstream when only one length is possible */
557     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
558         return s->min_samples_per_subframe;
559
560     if (get_bits_left(&s->gb) < 1)
561         return AVERROR_INVALIDDATA;
562
563     /** 1 bit indicates if the subframe is of maximum length */
564     if (s->max_subframe_len_bit) {
565         if (get_bits1(&s->gb))
566             frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
567     } else
568         frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
569
570     subframe_len = s->samples_per_frame >> frame_len_shift;
571
572     /** sanity check the length */
573     if (subframe_len < s->min_samples_per_subframe ||
574         subframe_len > s->samples_per_frame) {
575         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
576                subframe_len);
577         return AVERROR_INVALIDDATA;
578     }
579     return subframe_len;
580 }
581
582 /**
583  *@brief Decode how the data in the frame is split into subframes.
584  *       Every WMA frame contains the encoded data for a fixed number of
585  *       samples per channel. The data for every channel might be split
586  *       into several subframes. This function will reconstruct the list of
587  *       subframes for every channel.
588  *
589  *       If the subframes are not evenly split, the algorithm estimates the
590  *       channels with the lowest number of total samples.
591  *       Afterwards, for each of these channels a bit is read from the
592  *       bitstream that indicates if the channel contains a subframe with the
593  *       next subframe size that is going to be read from the bitstream or not.
594  *       If a channel contains such a subframe, the subframe size gets added to
595  *       the channel's subframe list.
596  *       The algorithm repeats these steps until the frame is properly divided
597  *       between the individual channels.
598  *
599  *@param s context
600  *@return 0 on success, < 0 in case of an error
601  */
602 static int decode_tilehdr(WMAProDecodeCtx *s)
603 {
604     uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
605     uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
606     int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
607     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subframe offsets and sizes */
608     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
609     int c;
610
611     /* Should never consume more than 3073 bits (256 iterations for the
612      * while loop when always the minimum amount of 128 samples is subtracted
613      * from missing samples in the 8 channel case).
614      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
615      */
616
617     /** reset tiling information */
618     for (c = 0; c < s->avctx->channels; c++)
619         s->channel[c].num_subframes = 0;
620
621     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
622         fixed_channel_layout = 1;
623
624     /** loop until the frame data is split between the subframes */
625     do {
626         int subframe_len;
627
628         /** check which channels contain the subframe */
629         for (c = 0; c < s->avctx->channels; c++) {
630             if (num_samples[c] == min_channel_len) {
631                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
632                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
633                     contains_subframe[c] = 1;
634                 else
635                     contains_subframe[c] = get_bits1(&s->gb);
636             } else
637                 contains_subframe[c] = 0;
638         }
639
640         /** get subframe length, subframe_len == 0 is not allowed */
641         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
642             return AVERROR_INVALIDDATA;
643
644         /** add subframes to the individual channels and find new min_channel_len */
645         min_channel_len += subframe_len;
646         for (c = 0; c < s->avctx->channels; c++) {
647             WMAProChannelCtx* chan = &s->channel[c];
648
649             if (contains_subframe[c]) {
650                 if (chan->num_subframes >= MAX_SUBFRAMES) {
651                     av_log(s->avctx, AV_LOG_ERROR,
652                            "broken frame: num subframes > 31\n");
653                     return AVERROR_INVALIDDATA;
654                 }
655                 chan->subframe_len[chan->num_subframes] = subframe_len;
656                 num_samples[c] += subframe_len;
657                 ++chan->num_subframes;
658                 if (num_samples[c] > s->samples_per_frame) {
659                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
660                            "channel len > samples_per_frame\n");
661                     return AVERROR_INVALIDDATA;
662                 }
663             } else if (num_samples[c] <= min_channel_len) {
664                 if (num_samples[c] < min_channel_len) {
665                     channels_for_cur_subframe = 0;
666                     min_channel_len = num_samples[c];
667                 }
668                 ++channels_for_cur_subframe;
669             }
670         }
671     } while (min_channel_len < s->samples_per_frame);
672
673     for (c = 0; c < s->avctx->channels; c++) {
674         int i;
675         int offset = 0;
676         for (i = 0; i < s->channel[c].num_subframes; i++) {
677             ff_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
678                     " len %i\n", s->frame_num, c, i,
679                     s->channel[c].subframe_len[i]);
680             s->channel[c].subframe_offset[i] = offset;
681             offset += s->channel[c].subframe_len[i];
682         }
683     }
684
685     return 0;
686 }
687
688 /**
689  *@brief Calculate a decorrelation matrix from the bitstream parameters.
690  *@param s codec context
691  *@param chgroup channel group for which the matrix needs to be calculated
692  */
693 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
694                                         WMAProChannelGrp *chgroup)
695 {
696     int i;
697     int offset = 0;
698     int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
699     memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
700            s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
701
702     for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
703         rotation_offset[i] = get_bits(&s->gb, 6);
704
705     for (i = 0; i < chgroup->num_channels; i++)
706         chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
707             get_bits1(&s->gb) ? 1.0 : -1.0;
708
709     for (i = 1; i < chgroup->num_channels; i++) {
710         int x;
711         for (x = 0; x < i; x++) {
712             int y;
713             for (y = 0; y < i + 1; y++) {
714                 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
715                 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
716                 int n = rotation_offset[offset + x];
717                 float sinv;
718                 float cosv;
719
720                 if (n < 32) {
721                     sinv = sin64[n];
722                     cosv = sin64[32 - n];
723                 } else {
724                     sinv =  sin64[64 -  n];
725                     cosv = -sin64[n  - 32];
726                 }
727
728                 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
729                                                (v1 * sinv) - (v2 * cosv);
730                 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
731                                                (v1 * cosv) + (v2 * sinv);
732             }
733         }
734         offset += i;
735     }
736 }
737
738 /**
739  *@brief Decode channel transformation parameters
740  *@param s codec context
741  *@return >= 0 in case of success, < 0 in case of bitstream errors
742  */
743 static int decode_channel_transform(WMAProDecodeCtx* s)
744 {
745     int i;
746     /* should never consume more than 1921 bits for the 8 channel case
747      * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
748      * + MAX_CHANNELS + MAX_BANDS + 1)
749      */
750
751     /** in the one channel case channel transforms are pointless */
752     s->num_chgroups = 0;
753     if (s->avctx->channels > 1) {
754         int remaining_channels = s->channels_for_cur_subframe;
755
756         if (get_bits1(&s->gb)) {
757             avpriv_request_sample(s->avctx,
758                                   "Channel transform bit");
759             return AVERROR_PATCHWELCOME;
760         }
761
762         for (s->num_chgroups = 0; remaining_channels &&
763              s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
764             WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
765             float** channel_data = chgroup->channel_data;
766             chgroup->num_channels = 0;
767             chgroup->transform = 0;
768
769             /** decode channel mask */
770             if (remaining_channels > 2) {
771                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
772                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
773                     if (!s->channel[channel_idx].grouped
774                         && get_bits1(&s->gb)) {
775                         ++chgroup->num_channels;
776                         s->channel[channel_idx].grouped = 1;
777                         *channel_data++ = s->channel[channel_idx].coeffs;
778                     }
779                 }
780             } else {
781                 chgroup->num_channels = remaining_channels;
782                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
783                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
784                     if (!s->channel[channel_idx].grouped)
785                         *channel_data++ = s->channel[channel_idx].coeffs;
786                     s->channel[channel_idx].grouped = 1;
787                 }
788             }
789
790             /** decode transform type */
791             if (chgroup->num_channels == 2) {
792                 if (get_bits1(&s->gb)) {
793                     if (get_bits1(&s->gb)) {
794                         avpriv_request_sample(s->avctx,
795                                               "Unknown channel transform type");
796                         return AVERROR_PATCHWELCOME;
797                     }
798                 } else {
799                     chgroup->transform = 1;
800                     if (s->avctx->channels == 2) {
801                         chgroup->decorrelation_matrix[0] =  1.0;
802                         chgroup->decorrelation_matrix[1] = -1.0;
803                         chgroup->decorrelation_matrix[2] =  1.0;
804                         chgroup->decorrelation_matrix[3] =  1.0;
805                     } else {
806                         /** cos(pi/4) */
807                         chgroup->decorrelation_matrix[0] =  0.70703125;
808                         chgroup->decorrelation_matrix[1] = -0.70703125;
809                         chgroup->decorrelation_matrix[2] =  0.70703125;
810                         chgroup->decorrelation_matrix[3] =  0.70703125;
811                     }
812                 }
813             } else if (chgroup->num_channels > 2) {
814                 if (get_bits1(&s->gb)) {
815                     chgroup->transform = 1;
816                     if (get_bits1(&s->gb)) {
817                         decode_decorrelation_matrix(s, chgroup);
818                     } else {
819                         /** FIXME: more than 6 coupled channels not supported */
820                         if (chgroup->num_channels > 6) {
821                             avpriv_request_sample(s->avctx,
822                                                   "Coupled channels > 6");
823                         } else {
824                             memcpy(chgroup->decorrelation_matrix,
825                                    default_decorrelation[chgroup->num_channels],
826                                    chgroup->num_channels * chgroup->num_channels *
827                                    sizeof(*chgroup->decorrelation_matrix));
828                         }
829                     }
830                 }
831             }
832
833             /** decode transform on / off */
834             if (chgroup->transform) {
835                 if (!get_bits1(&s->gb)) {
836                     int i;
837                     /** transform can be enabled for individual bands */
838                     for (i = 0; i < s->num_bands; i++) {
839                         chgroup->transform_band[i] = get_bits1(&s->gb);
840                     }
841                 } else {
842                     memset(chgroup->transform_band, 1, s->num_bands);
843                 }
844             }
845             remaining_channels -= chgroup->num_channels;
846         }
847     }
848     return 0;
849 }
850
851 /**
852  *@brief Extract the coefficients from the bitstream.
853  *@param s codec context
854  *@param c current channel number
855  *@return 0 on success, < 0 in case of bitstream errors
856  */
857 static int decode_coeffs(WMAProDecodeCtx *s, int c)
858 {
859     /* Integers 0..15 as single-precision floats.  The table saves a
860        costly int to float conversion, and storing the values as
861        integers allows fast sign-flipping. */
862     static const uint32_t fval_tab[16] = {
863         0x00000000, 0x3f800000, 0x40000000, 0x40400000,
864         0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
865         0x41000000, 0x41100000, 0x41200000, 0x41300000,
866         0x41400000, 0x41500000, 0x41600000, 0x41700000,
867     };
868     int vlctable;
869     VLC* vlc;
870     WMAProChannelCtx* ci = &s->channel[c];
871     int rl_mode = 0;
872     int cur_coeff = 0;
873     int num_zeros = 0;
874     const uint16_t* run;
875     const float* level;
876
877     ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
878
879     vlctable = get_bits1(&s->gb);
880     vlc = &coef_vlc[vlctable];
881
882     if (vlctable) {
883         run = coef1_run;
884         level = coef1_level;
885     } else {
886         run = coef0_run;
887         level = coef0_level;
888     }
889
890     /** decode vector coefficients (consumes up to 167 bits per iteration for
891       4 vector coded large values) */
892     while ((s->transmit_num_vec_coeffs || !rl_mode) &&
893            (cur_coeff + 3 < ci->num_vec_coeffs)) {
894         uint32_t vals[4];
895         int i;
896         unsigned int idx;
897
898         idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
899
900         if (idx == HUFF_VEC4_SIZE - 1) {
901             for (i = 0; i < 4; i += 2) {
902                 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
903                 if (idx == HUFF_VEC2_SIZE - 1) {
904                     uint32_t v0, v1;
905                     v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
906                     if (v0 == HUFF_VEC1_SIZE - 1)
907                         v0 += ff_wma_get_large_val(&s->gb);
908                     v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
909                     if (v1 == HUFF_VEC1_SIZE - 1)
910                         v1 += ff_wma_get_large_val(&s->gb);
911                     vals[i  ] = av_float2int(v0);
912                     vals[i+1] = av_float2int(v1);
913                 } else {
914                     vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
915                     vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
916                 }
917             }
918         } else {
919             vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
920             vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
921             vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
922             vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
923         }
924
925         /** decode sign */
926         for (i = 0; i < 4; i++) {
927             if (vals[i]) {
928                 uint32_t sign = get_bits1(&s->gb) - 1;
929                 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
930                 num_zeros = 0;
931             } else {
932                 ci->coeffs[cur_coeff] = 0;
933                 /** switch to run level mode when subframe_len / 128 zeros
934                     were found in a row */
935                 rl_mode |= (++num_zeros > s->subframe_len >> 8);
936             }
937             ++cur_coeff;
938         }
939     }
940
941     /** decode run level coded coefficients */
942     if (cur_coeff < s->subframe_len) {
943         memset(&ci->coeffs[cur_coeff], 0,
944                sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
945         if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
946                                     level, run, 1, ci->coeffs,
947                                     cur_coeff, s->subframe_len,
948                                     s->subframe_len, s->esc_len, 0))
949             return AVERROR_INVALIDDATA;
950     }
951
952     return 0;
953 }
954
955 /**
956  *@brief Extract scale factors from the bitstream.
957  *@param s codec context
958  *@return 0 on success, < 0 in case of bitstream errors
959  */
960 static int decode_scale_factors(WMAProDecodeCtx* s)
961 {
962     int i;
963
964     /** should never consume more than 5344 bits
965      *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
966      */
967
968     for (i = 0; i < s->channels_for_cur_subframe; i++) {
969         int c = s->channel_indexes_for_cur_subframe[i];
970         int* sf;
971         int* sf_end;
972         s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
973         sf_end = s->channel[c].scale_factors + s->num_bands;
974
975         /** resample scale factors for the new block size
976          *  as the scale factors might need to be resampled several times
977          *  before some  new values are transmitted, a backup of the last
978          *  transmitted scale factors is kept in saved_scale_factors
979          */
980         if (s->channel[c].reuse_sf) {
981             const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
982             int b;
983             for (b = 0; b < s->num_bands; b++)
984                 s->channel[c].scale_factors[b] =
985                     s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
986         }
987
988         if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
989
990             if (!s->channel[c].reuse_sf) {
991                 int val;
992                 /** decode DPCM coded scale factors */
993                 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
994                 val = 45 / s->channel[c].scale_factor_step;
995                 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
996                     val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
997                     *sf = val;
998                 }
999             } else {
1000                 int i;
1001                 /** run level decode differences to the resampled factors */
1002                 for (i = 0; i < s->num_bands; i++) {
1003                     int idx;
1004                     int skip;
1005                     int val;
1006                     int sign;
1007
1008                     idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1009
1010                     if (!idx) {
1011                         uint32_t code = get_bits(&s->gb, 14);
1012                         val  =  code >> 6;
1013                         sign = (code & 1) - 1;
1014                         skip = (code & 0x3f) >> 1;
1015                     } else if (idx == 1) {
1016                         break;
1017                     } else {
1018                         skip = scale_rl_run[idx];
1019                         val  = scale_rl_level[idx];
1020                         sign = get_bits1(&s->gb)-1;
1021                     }
1022
1023                     i += skip;
1024                     if (i >= s->num_bands) {
1025                         av_log(s->avctx, AV_LOG_ERROR,
1026                                "invalid scale factor coding\n");
1027                         return AVERROR_INVALIDDATA;
1028                     }
1029                     s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1030                 }
1031             }
1032             /** swap buffers */
1033             s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1034             s->channel[c].table_idx = s->table_idx;
1035             s->channel[c].reuse_sf  = 1;
1036         }
1037
1038         /** calculate new scale factor maximum */
1039         s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1040         for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1041             s->channel[c].max_scale_factor =
1042                 FFMAX(s->channel[c].max_scale_factor, *sf);
1043         }
1044
1045     }
1046     return 0;
1047 }
1048
1049 /**
1050  *@brief Reconstruct the individual channel data.
1051  *@param s codec context
1052  */
1053 static void inverse_channel_transform(WMAProDecodeCtx *s)
1054 {
1055     int i;
1056
1057     for (i = 0; i < s->num_chgroups; i++) {
1058         if (s->chgroup[i].transform) {
1059             float data[WMAPRO_MAX_CHANNELS];
1060             const int num_channels = s->chgroup[i].num_channels;
1061             float** ch_data = s->chgroup[i].channel_data;
1062             float** ch_end = ch_data + num_channels;
1063             const int8_t* tb = s->chgroup[i].transform_band;
1064             int16_t* sfb;
1065
1066             /** multichannel decorrelation */
1067             for (sfb = s->cur_sfb_offsets;
1068                  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1069                 int y;
1070                 if (*tb++ == 1) {
1071                     /** multiply values with the decorrelation_matrix */
1072                     for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1073                         const float* mat = s->chgroup[i].decorrelation_matrix;
1074                         const float* data_end = data + num_channels;
1075                         float* data_ptr = data;
1076                         float** ch;
1077
1078                         for (ch = ch_data; ch < ch_end; ch++)
1079                             *data_ptr++ = (*ch)[y];
1080
1081                         for (ch = ch_data; ch < ch_end; ch++) {
1082                             float sum = 0;
1083                             data_ptr = data;
1084                             while (data_ptr < data_end)
1085                                 sum += *data_ptr++ * *mat++;
1086
1087                             (*ch)[y] = sum;
1088                         }
1089                     }
1090                 } else if (s->avctx->channels == 2) {
1091                     int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1092                     s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1093                                                ch_data[0] + sfb[0],
1094                                                181.0 / 128, len);
1095                     s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1096                                                ch_data[1] + sfb[0],
1097                                                181.0 / 128, len);
1098                 }
1099             }
1100         }
1101     }
1102 }
1103
1104 /**
1105  *@brief Apply sine window and reconstruct the output buffer.
1106  *@param s codec context
1107  */
1108 static void wmapro_window(WMAProDecodeCtx *s)
1109 {
1110     int i;
1111     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1112         int c = s->channel_indexes_for_cur_subframe[i];
1113         const float* window;
1114         int winlen = s->channel[c].prev_block_len;
1115         float* start = s->channel[c].coeffs - (winlen >> 1);
1116
1117         if (s->subframe_len < winlen) {
1118             start += (winlen - s->subframe_len) >> 1;
1119             winlen = s->subframe_len;
1120         }
1121
1122         window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1123
1124         winlen >>= 1;
1125
1126         s->fdsp->vector_fmul_window(start, start, start + winlen,
1127                                    window, winlen);
1128
1129         s->channel[c].prev_block_len = s->subframe_len;
1130     }
1131 }
1132
1133 /**
1134  *@brief Decode a single subframe (block).
1135  *@param s codec context
1136  *@return 0 on success, < 0 when decoding failed
1137  */
1138 static int decode_subframe(WMAProDecodeCtx *s)
1139 {
1140     int offset = s->samples_per_frame;
1141     int subframe_len = s->samples_per_frame;
1142     int i;
1143     int total_samples   = s->samples_per_frame * s->avctx->channels;
1144     int transmit_coeffs = 0;
1145     int cur_subwoofer_cutoff;
1146
1147     s->subframe_offset = get_bits_count(&s->gb);
1148
1149     /** reset channel context and find the next block offset and size
1150         == the next block of the channel with the smallest number of
1151         decoded samples
1152     */
1153     for (i = 0; i < s->avctx->channels; i++) {
1154         s->channel[i].grouped = 0;
1155         if (offset > s->channel[i].decoded_samples) {
1156             offset = s->channel[i].decoded_samples;
1157             subframe_len =
1158                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1159         }
1160     }
1161
1162     ff_dlog(s->avctx,
1163             "processing subframe with offset %i len %i\n", offset, subframe_len);
1164
1165     /** get a list of all channels that contain the estimated block */
1166     s->channels_for_cur_subframe = 0;
1167     for (i = 0; i < s->avctx->channels; i++) {
1168         const int cur_subframe = s->channel[i].cur_subframe;
1169         /** subtract already processed samples */
1170         total_samples -= s->channel[i].decoded_samples;
1171
1172         /** and count if there are multiple subframes that match our profile */
1173         if (offset == s->channel[i].decoded_samples &&
1174             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1175             total_samples -= s->channel[i].subframe_len[cur_subframe];
1176             s->channel[i].decoded_samples +=
1177                 s->channel[i].subframe_len[cur_subframe];
1178             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1179             ++s->channels_for_cur_subframe;
1180         }
1181     }
1182
1183     /** check if the frame will be complete after processing the
1184         estimated block */
1185     if (!total_samples)
1186         s->parsed_all_subframes = 1;
1187
1188
1189     ff_dlog(s->avctx, "subframe is part of %i channels\n",
1190             s->channels_for_cur_subframe);
1191
1192     /** calculate number of scale factor bands and their offsets */
1193     s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1194     s->num_bands         = s->num_sfb[s->table_idx];
1195     s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1196     cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1197
1198     /** configure the decoder for the current subframe */
1199     offset += s->samples_per_frame >> 1;
1200
1201     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1202         int c = s->channel_indexes_for_cur_subframe[i];
1203
1204         s->channel[c].coeffs = &s->channel[c].out[offset];
1205     }
1206
1207     s->subframe_len = subframe_len;
1208     s->esc_len = av_log2(s->subframe_len - 1) + 1;
1209
1210     /** skip extended header if any */
1211     if (get_bits1(&s->gb)) {
1212         int num_fill_bits;
1213         if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1214             int len = get_bits(&s->gb, 4);
1215             num_fill_bits = get_bitsz(&s->gb, len) + 1;
1216         }
1217
1218         if (num_fill_bits >= 0) {
1219             if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1220                 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1221                 return AVERROR_INVALIDDATA;
1222             }
1223
1224             skip_bits_long(&s->gb, num_fill_bits);
1225         }
1226     }
1227
1228     /** no idea for what the following bit is used */
1229     if (get_bits1(&s->gb)) {
1230         avpriv_request_sample(s->avctx, "Reserved bit");
1231         return AVERROR_PATCHWELCOME;
1232     }
1233
1234
1235     if (decode_channel_transform(s) < 0)
1236         return AVERROR_INVALIDDATA;
1237
1238
1239     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1240         int c = s->channel_indexes_for_cur_subframe[i];
1241         if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1242             transmit_coeffs = 1;
1243     }
1244
1245     av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1246     if (transmit_coeffs) {
1247         int step;
1248         int quant_step = 90 * s->bits_per_sample >> 4;
1249
1250         /** decode number of vector coded coefficients */
1251         if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1252             int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1253             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1254                 int c = s->channel_indexes_for_cur_subframe[i];
1255                 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1256                 if (num_vec_coeffs > s->subframe_len) {
1257                     av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1258                     return AVERROR_INVALIDDATA;
1259                 }
1260                 av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1261                 s->channel[c].num_vec_coeffs = num_vec_coeffs;
1262             }
1263         } else {
1264             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1265                 int c = s->channel_indexes_for_cur_subframe[i];
1266                 s->channel[c].num_vec_coeffs = s->subframe_len;
1267             }
1268         }
1269         /** decode quantization step */
1270         step = get_sbits(&s->gb, 6);
1271         quant_step += step;
1272         if (step == -32 || step == 31) {
1273             const int sign = (step == 31) - 1;
1274             int quant = 0;
1275             while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1276                    (step = get_bits(&s->gb, 5)) == 31) {
1277                 quant += 31;
1278             }
1279             quant_step += ((quant + step) ^ sign) - sign;
1280         }
1281         if (quant_step < 0) {
1282             av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1283         }
1284
1285         /** decode quantization step modifiers for every channel */
1286
1287         if (s->channels_for_cur_subframe == 1) {
1288             s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1289         } else {
1290             int modifier_len = get_bits(&s->gb, 3);
1291             for (i = 0; i < s->channels_for_cur_subframe; i++) {
1292                 int c = s->channel_indexes_for_cur_subframe[i];
1293                 s->channel[c].quant_step = quant_step;
1294                 if (get_bits1(&s->gb)) {
1295                     if (modifier_len) {
1296                         s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1297                     } else
1298                         ++s->channel[c].quant_step;
1299                 }
1300             }
1301         }
1302
1303         /** decode scale factors */
1304         if (decode_scale_factors(s) < 0)
1305             return AVERROR_INVALIDDATA;
1306     }
1307
1308     ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1309             get_bits_count(&s->gb) - s->subframe_offset);
1310
1311     /** parse coefficients */
1312     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1313         int c = s->channel_indexes_for_cur_subframe[i];
1314         if (s->channel[c].transmit_coefs &&
1315             get_bits_count(&s->gb) < s->num_saved_bits) {
1316             decode_coeffs(s, c);
1317         } else
1318             memset(s->channel[c].coeffs, 0,
1319                    sizeof(*s->channel[c].coeffs) * subframe_len);
1320     }
1321
1322     ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1323             get_bits_count(&s->gb) - s->subframe_offset);
1324
1325     if (transmit_coeffs) {
1326         FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1327         /** reconstruct the per channel data */
1328         inverse_channel_transform(s);
1329         for (i = 0; i < s->channels_for_cur_subframe; i++) {
1330             int c = s->channel_indexes_for_cur_subframe[i];
1331             const int* sf = s->channel[c].scale_factors;
1332             int b;
1333
1334             if (c == s->lfe_channel)
1335                 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1336                        (subframe_len - cur_subwoofer_cutoff));
1337
1338             /** inverse quantization and rescaling */
1339             for (b = 0; b < s->num_bands; b++) {
1340                 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1341                 const int exp = s->channel[c].quant_step -
1342                             (s->channel[c].max_scale_factor - *sf++) *
1343                             s->channel[c].scale_factor_step;
1344                 const float quant = ff_exp10(exp / 20.0);
1345                 int start = s->cur_sfb_offsets[b];
1346                 s->fdsp->vector_fmul_scalar(s->tmp + start,
1347                                            s->channel[c].coeffs + start,
1348                                            quant, end - start);
1349             }
1350
1351             /** apply imdct (imdct_half == DCTIV with reverse) */
1352             mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1353         }
1354     }
1355
1356     /** window and overlapp-add */
1357     wmapro_window(s);
1358
1359     /** handled one subframe */
1360     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1361         int c = s->channel_indexes_for_cur_subframe[i];
1362         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1363             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1364             return AVERROR_INVALIDDATA;
1365         }
1366         ++s->channel[c].cur_subframe;
1367     }
1368
1369     return 0;
1370 }
1371
1372 /**
1373  *@brief Decode one WMA frame.
1374  *@param s codec context
1375  *@return 0 if the trailer bit indicates that this is the last frame,
1376  *        1 if there are additional frames
1377  */
1378 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1379 {
1380     AVCodecContext *avctx = s->avctx;
1381     GetBitContext* gb = &s->gb;
1382     int more_frames = 0;
1383     int len = 0;
1384     int i, ret;
1385
1386     /** get frame length */
1387     if (s->len_prefix)
1388         len = get_bits(gb, s->log2_frame_size);
1389
1390     ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1391
1392     /** decode tile information */
1393     if (decode_tilehdr(s)) {
1394         s->packet_loss = 1;
1395         return 0;
1396     }
1397
1398     /** read postproc transform */
1399     if (s->avctx->channels > 1 && get_bits1(gb)) {
1400         if (get_bits1(gb)) {
1401             for (i = 0; i < avctx->channels * avctx->channels; i++)
1402                 skip_bits(gb, 4);
1403         }
1404     }
1405
1406     /** read drc info */
1407     if (s->dynamic_range_compression) {
1408         s->drc_gain = get_bits(gb, 8);
1409         ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1410     }
1411
1412     /** no idea what these are for, might be the number of samples
1413         that need to be skipped at the beginning or end of a stream */
1414     if (get_bits1(gb)) {
1415         int av_unused skip;
1416
1417         /** usually true for the first frame */
1418         if (get_bits1(gb)) {
1419             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1420             ff_dlog(s->avctx, "start skip: %i\n", skip);
1421         }
1422
1423         /** sometimes true for the last frame */
1424         if (get_bits1(gb)) {
1425             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1426             ff_dlog(s->avctx, "end skip: %i\n", skip);
1427         }
1428
1429     }
1430
1431     ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1432             get_bits_count(gb) - s->frame_offset);
1433
1434     /** reset subframe states */
1435     s->parsed_all_subframes = 0;
1436     for (i = 0; i < avctx->channels; i++) {
1437         s->channel[i].decoded_samples = 0;
1438         s->channel[i].cur_subframe    = 0;
1439         s->channel[i].reuse_sf        = 0;
1440     }
1441
1442     /** decode all subframes */
1443     while (!s->parsed_all_subframes) {
1444         if (decode_subframe(s) < 0) {
1445             s->packet_loss = 1;
1446             return 0;
1447         }
1448     }
1449
1450     /* get output buffer */
1451     frame->nb_samples = s->samples_per_frame;
1452     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1453         s->packet_loss = 1;
1454         return 0;
1455     }
1456
1457     /** copy samples to the output buffer */
1458     for (i = 0; i < avctx->channels; i++)
1459         memcpy(frame->extended_data[i], s->channel[i].out,
1460                s->samples_per_frame * sizeof(*s->channel[i].out));
1461
1462     for (i = 0; i < avctx->channels; i++) {
1463         /** reuse second half of the IMDCT output for the next frame */
1464         memcpy(&s->channel[i].out[0],
1465                &s->channel[i].out[s->samples_per_frame],
1466                s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1467     }
1468
1469     if (s->skip_frame) {
1470         s->skip_frame = 0;
1471         *got_frame_ptr = 0;
1472         av_frame_unref(frame);
1473     } else {
1474         *got_frame_ptr = 1;
1475     }
1476
1477     if (s->len_prefix) {
1478         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1479             /** FIXME: not sure if this is always an error */
1480             av_log(s->avctx, AV_LOG_ERROR,
1481                    "frame[%"PRIu32"] would have to skip %i bits\n",
1482                    s->frame_num,
1483                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1484             s->packet_loss = 1;
1485             return 0;
1486         }
1487
1488         /** skip the rest of the frame data */
1489         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1490     } else {
1491         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1492         }
1493     }
1494
1495     /** decode trailer bit */
1496     more_frames = get_bits1(gb);
1497
1498     ++s->frame_num;
1499     return more_frames;
1500 }
1501
1502 /**
1503  *@brief Calculate remaining input buffer length.
1504  *@param s codec context
1505  *@param gb bitstream reader context
1506  *@return remaining size in bits
1507  */
1508 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1509 {
1510     return s->buf_bit_size - get_bits_count(gb);
1511 }
1512
1513 /**
1514  *@brief Fill the bit reservoir with a (partial) frame.
1515  *@param s codec context
1516  *@param gb bitstream reader context
1517  *@param len length of the partial frame
1518  *@param append decides whether to reset the buffer or not
1519  */
1520 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1521                       int append)
1522 {
1523     int buflen;
1524
1525     /** when the frame data does not need to be concatenated, the input buffer
1526         is reset and additional bits from the previous frame are copied
1527         and skipped later so that a fast byte copy is possible */
1528
1529     if (!append) {
1530         s->frame_offset = get_bits_count(gb) & 7;
1531         s->num_saved_bits = s->frame_offset;
1532         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1533     }
1534
1535     buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1536
1537     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1538         avpriv_request_sample(s->avctx, "Too small input buffer");
1539         s->packet_loss = 1;
1540         return;
1541     }
1542
1543     av_assert0(len <= put_bits_left(&s->pb));
1544
1545     s->num_saved_bits += len;
1546     if (!append) {
1547         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1548                      s->num_saved_bits);
1549     } else {
1550         int align = 8 - (get_bits_count(gb) & 7);
1551         align = FFMIN(align, len);
1552         put_bits(&s->pb, align, get_bits(gb, align));
1553         len -= align;
1554         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1555     }
1556     skip_bits_long(gb, len);
1557
1558     {
1559         PutBitContext tmp = s->pb;
1560         flush_put_bits(&tmp);
1561     }
1562
1563     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1564     skip_bits(&s->gb, s->frame_offset);
1565 }
1566
1567 /**
1568  *@brief Decode a single WMA packet.
1569  *@param avctx codec context
1570  *@param data the output buffer
1571  *@param avpkt input packet
1572  *@return number of bytes that were read from the input buffer
1573  */
1574 static int decode_packet(AVCodecContext *avctx, void *data,
1575                          int *got_frame_ptr, AVPacket* avpkt)
1576 {
1577     WMAProDecodeCtx *s = avctx->priv_data;
1578     GetBitContext* gb  = &s->pgb;
1579     const uint8_t* buf = avpkt->data;
1580     int buf_size       = avpkt->size;
1581     int num_bits_prev_frame;
1582     int packet_sequence_number;
1583
1584     *got_frame_ptr = 0;
1585
1586     if (s->skip_packets > 0) {
1587         s->skip_packets--;
1588         return FFMIN(avpkt->size, avctx->block_align);
1589     }
1590
1591     if (s->packet_done || s->packet_loss) {
1592         s->packet_done = 0;
1593
1594         /** sanity check for the buffer length */
1595         if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1596             av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1597                    buf_size, avctx->block_align);
1598             return AVERROR_INVALIDDATA;
1599         }
1600
1601         if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1602             s->next_packet_start = buf_size - avctx->block_align;
1603             buf_size = avctx->block_align;
1604         } else {
1605             s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1606             buf_size = FFMIN(buf_size, avctx->block_align);
1607         }
1608         s->buf_bit_size = buf_size << 3;
1609
1610         /** parse packet header */
1611         init_get_bits(gb, buf, s->buf_bit_size);
1612         if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1613             packet_sequence_number = get_bits(gb, 4);
1614             skip_bits(gb, 2);
1615         } else {
1616             s->num_frames = get_bits(gb, 6);
1617             packet_sequence_number = 0;
1618         }
1619
1620         /** get number of bits that need to be added to the previous frame */
1621         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1622         if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1623             skip_bits(gb, 3);
1624             s->skip_packets = get_bits(gb, 8);
1625         }
1626
1627         ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1628                 num_bits_prev_frame);
1629
1630         /** check for packet loss */
1631         if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
1632             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1633             s->packet_loss = 1;
1634             av_log(avctx, AV_LOG_ERROR,
1635                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1636                    s->packet_sequence_number, packet_sequence_number);
1637         }
1638         s->packet_sequence_number = packet_sequence_number;
1639
1640         if (num_bits_prev_frame > 0) {
1641             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1642             if (num_bits_prev_frame >= remaining_packet_bits) {
1643                 num_bits_prev_frame = remaining_packet_bits;
1644                 s->packet_done = 1;
1645             }
1646
1647             /** append the previous frame data to the remaining data from the
1648                 previous packet to create a full frame */
1649             save_bits(s, gb, num_bits_prev_frame, 1);
1650             ff_dlog(avctx, "accumulated %x bits of frame data\n",
1651                     s->num_saved_bits - s->frame_offset);
1652
1653             /** decode the cross packet frame if it is valid */
1654             if (!s->packet_loss)
1655                 decode_frame(s, data, got_frame_ptr);
1656         } else if (s->num_saved_bits - s->frame_offset) {
1657             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1658                     s->num_saved_bits - s->frame_offset);
1659         }
1660
1661         if (s->packet_loss) {
1662             /** reset number of saved bits so that the decoder
1663                 does not start to decode incomplete frames in the
1664                 s->len_prefix == 0 case */
1665             s->num_saved_bits = 0;
1666             s->packet_loss = 0;
1667         }
1668
1669     } else {
1670         int frame_size;
1671         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1672         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1673         skip_bits(gb, s->packet_offset);
1674         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1675             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1676             frame_size <= remaining_bits(s, gb)) {
1677             save_bits(s, gb, frame_size, 0);
1678             if (!s->packet_loss)
1679                 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1680         } else if (!s->len_prefix
1681                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1682             /** when the frames do not have a length prefix, we don't know
1683                 the compressed length of the individual frames
1684                 however, we know what part of a new packet belongs to the
1685                 previous frame
1686                 therefore we save the incoming packet first, then we append
1687                 the "previous frame" data from the next packet so that
1688                 we get a buffer that only contains full frames */
1689             s->packet_done = !decode_frame(s, data, got_frame_ptr);
1690         } else
1691             s->packet_done = 1;
1692     }
1693
1694     if (remaining_bits(s, gb) < 0) {
1695         av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1696         s->packet_loss = 1;
1697     }
1698
1699     if (s->packet_done && !s->packet_loss &&
1700         remaining_bits(s, gb) > 0) {
1701         /** save the rest of the data so that it can be decoded
1702             with the next packet */
1703         save_bits(s, gb, remaining_bits(s, gb), 0);
1704     }
1705
1706     s->packet_offset = get_bits_count(gb) & 7;
1707     if (s->packet_loss)
1708         return AVERROR_INVALIDDATA;
1709
1710     return get_bits_count(gb) >> 3;
1711 }
1712
1713 /**
1714  *@brief Clear decoder buffers (for seeking).
1715  *@param avctx codec context
1716  */
1717 static void flush(AVCodecContext *avctx)
1718 {
1719     WMAProDecodeCtx *s = avctx->priv_data;
1720     int i;
1721     /** reset output buffer as a part of it is used during the windowing of a
1722         new frame */
1723     for (i = 0; i < avctx->channels; i++)
1724         memset(s->channel[i].out, 0, s->samples_per_frame *
1725                sizeof(*s->channel[i].out));
1726     s->packet_loss = 1;
1727 }
1728
1729
1730 /**
1731  *@brief wmapro decoder
1732  */
1733 AVCodec ff_wmapro_decoder = {
1734     .name           = "wmapro",
1735     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1736     .type           = AVMEDIA_TYPE_AUDIO,
1737     .id             = AV_CODEC_ID_WMAPRO,
1738     .priv_data_size = sizeof(WMAProDecodeCtx),
1739     .init           = decode_init,
1740     .close          = decode_end,
1741     .decode         = decode_packet,
1742     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1743     .flush          = flush,
1744     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1745                                                       AV_SAMPLE_FMT_NONE },
1746 };
1747
1748 AVCodec ff_xma1_decoder = {
1749     .name           = "xma1",
1750     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
1751     .type           = AVMEDIA_TYPE_AUDIO,
1752     .id             = AV_CODEC_ID_XMA1,
1753     .priv_data_size = sizeof(WMAProDecodeCtx),
1754     .init           = decode_init,
1755     .close          = decode_end,
1756     .decode         = decode_packet,
1757     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1758     .flush          = flush,
1759     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1760                                                       AV_SAMPLE_FMT_NONE },
1761 };
1762
1763 AVCodec ff_xma2_decoder = {
1764     .name           = "xma2",
1765     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
1766     .type           = AVMEDIA_TYPE_AUDIO,
1767     .id             = AV_CODEC_ID_XMA2,
1768     .priv_data_size = sizeof(WMAProDecodeCtx),
1769     .init           = decode_init,
1770     .close          = decode_end,
1771     .decode         = decode_packet,
1772     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1773     .flush          = flush,
1774     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1775                                                       AV_SAMPLE_FMT_NONE },
1776 };