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