Implement clear_codec_buffers()
[ffmpeg.git] / libavcodec / wmalosslessdec.c
1 /*
2  * Wmall compatible decoder
3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5  * Copyright (c) 2011 Andreas Ă–man
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * @brief wmall decoder implementation
27  * Wmall is an MDCT based codec comparable to wma standard or AAC.
28  * The decoding therefore consists of the following steps:
29  * - bitstream decoding
30  * - reconstruction of per-channel data
31  * - rescaling and inverse quantization
32  * - IMDCT
33  * - windowing and overlapp-add
34  *
35  * The compressed wmall bitstream is split into individual packets.
36  * Every such packet contains one or more wma frames.
37  * The compressed frames may have a variable length and frames may
38  * cross packet boundaries.
39  * Common to all wmall frames is the number of samples that are stored in
40  * a frame.
41  * The number of samples and a few other decode flags are stored
42  * as extradata that has to be passed to the decoder.
43  *
44  * The wmall frames themselves are again split into a variable number of
45  * subframes. Every subframe contains the data for 2^N time domain samples
46  * where N varies between 7 and 12.
47  *
48  * Example wmall bitstream (in samples):
49  *
50  * ||   packet 0           || packet 1 || packet 2      packets
51  * ---------------------------------------------------
52  * || frame 0      || frame 1       || frame 2    ||    frames
53  * ---------------------------------------------------
54  * ||   |      |   ||   |   |   |   ||            ||    subframes of channel 0
55  * ---------------------------------------------------
56  * ||      |   |   ||   |   |   |   ||            ||    subframes of channel 1
57  * ---------------------------------------------------
58  *
59  * The frame layouts for the individual channels of a wma frame does not need
60  * to be the same.
61  *
62  * However, if the offsets and lengths of several subframes of a frame are the
63  * same, the subframes of the channels can be grouped.
64  * Every group may then use special coding techniques like M/S stereo coding
65  * to improve the compression ratio. These channel transformations do not
66  * need to be applied to a whole subframe. Instead, they can also work on
67  * individual scale factor bands (see below).
68  * The coefficients that carry the audio signal in the frequency domain
69  * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
70  * In addition to that, the encoder can switch to a runlevel coding scheme
71  * by transmitting subframe_length / 128 zero coefficients.
72  *
73  * Before the audio signal can be converted to the time domain, the
74  * coefficients have to be rescaled and inverse quantized.
75  * A subframe is therefore split into several scale factor bands that get
76  * scaled individually.
77  * Scale factors are submitted for every frame but they might be shared
78  * between the subframes of a channel. Scale factors are initially DPCM-coded.
79  * Once scale factors are shared, the differences are transmitted as runlevel
80  * codes.
81  * Every subframe length and offset combination in the frame layout shares a
82  * common quantization factor that can be adjusted for every channel by a
83  * modifier.
84  * After the inverse quantization, the coefficients get processed by an IMDCT.
85  * The resulting values are then windowed with a sine window and the first half
86  * of the values are added to the second half of the output from the previous
87  * subframe in order to reconstruct the output samples.
88  */
89
90 #include "avcodec.h"
91 #include "internal.h"
92 #include "get_bits.h"
93 #include "put_bits.h"
94 #include "dsputil.h"
95 #include "wma.h"
96
97 /** current decoder limitations */
98 #define WMALL_MAX_CHANNELS    8                             ///< max number of handled channels
99 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
100 #define MAX_BANDS      29                                    ///< max number of scale factor bands
101 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
102
103 #define WMALL_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
104 #define WMALL_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
105 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)                 ///< maximum block size
106 #define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
107
108
109 #define VLCBITS            9
110 #define SCALEVLCBITS       8
111 #define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
112 #define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
113 #define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
114 #define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
115 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
116
117 static float            sin64[33];        ///< sinus table for decorrelation
118
119 /**
120  * @brief frame specific decoder context for a single channel
121  */
122 typedef struct {
123     int16_t  prev_block_len;                          ///< length of the previous block
124     uint8_t  transmit_coefs;
125     uint8_t  num_subframes;
126     uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
127     uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
128     uint8_t  cur_subframe;                            ///< current subframe number
129     uint16_t decoded_samples;                         ///< number of already processed samples
130     uint8_t  grouped;                                 ///< channel is part of a group
131     int      quant_step;                              ///< quantization step for the current subframe
132     int8_t   reuse_sf;                                ///< share scale factors between subframes
133     int8_t   scale_factor_step;                       ///< scaling step for the current subframe
134     int      max_scale_factor;                        ///< maximum scale factor for the current subframe
135     int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
136     int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
137     int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
138     uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
139     float*   coeffs;                                  ///< pointer to the subframe decode buffer
140     uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
141     DECLARE_ALIGNED(16, float, out)[WMALL_BLOCK_MAX_SIZE + WMALL_BLOCK_MAX_SIZE / 2]; ///< output buffer
142 } WmallChannelCtx;
143
144 /**
145  * @brief channel group for channel transformations
146  */
147 typedef struct {
148     uint8_t num_channels;                                     ///< number of channels in the group
149     int8_t  transform;                                        ///< transform on / off
150     int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
151     float   decorrelation_matrix[WMALL_MAX_CHANNELS*WMALL_MAX_CHANNELS];
152     float*  channel_data[WMALL_MAX_CHANNELS];                ///< transformation coefficients
153 } WmallChannelGrp;
154
155 /**
156  * @brief main decoder context
157  */
158 typedef struct WmallDecodeCtx {
159     /* generic decoder variables */
160     AVCodecContext*  avctx;                         ///< codec context for av_log
161     DSPContext       dsp;                           ///< accelerated DSP functions
162     uint8_t          frame_data[MAX_FRAMESIZE +
163                       FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
164     PutBitContext    pb;                            ///< context for filling the frame_data buffer
165     FFTContext       mdct_ctx[WMALL_BLOCK_SIZES];  ///< MDCT context per block size
166     DECLARE_ALIGNED(16, float, tmp)[WMALL_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
167     float*           windows[WMALL_BLOCK_SIZES];   ///< windows for the different block sizes
168
169     /* frame size dependent frame information (set during initialization) */
170     uint32_t         decode_flags;                  ///< used compression features
171     uint8_t          len_prefix;                    ///< frame is prefixed with its length
172     uint8_t          dynamic_range_compression;     ///< frame contains DRC data
173     uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
174     uint16_t         samples_per_frame;             ///< number of samples to output
175     uint16_t         log2_frame_size;
176     int8_t           num_channels;                  ///< number of channels in the stream (same as AVCodecContext.num_channels)
177     int8_t           lfe_channel;                   ///< lfe channel index
178     uint8_t          max_num_subframes;
179     uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
180     uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
181     uint16_t         min_samples_per_subframe;
182     int8_t           num_sfb[WMALL_BLOCK_SIZES];   ///< scale factor bands per block size
183     int16_t          sfb_offsets[WMALL_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
184     int8_t           sf_offsets[WMALL_BLOCK_SIZES][WMALL_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
185     int16_t          subwoofer_cutoffs[WMALL_BLOCK_SIZES]; ///< subwoofer cutoff values
186
187     /* packet decode state */
188     GetBitContext    pgb;                           ///< bitstream reader context for the packet
189     int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
190     uint8_t          packet_offset;                 ///< frame offset in the packet
191     uint8_t          packet_sequence_number;        ///< current packet number
192     int              num_saved_bits;                ///< saved number of bits
193     int              frame_offset;                  ///< frame offset in the bit reservoir
194     int              subframe_offset;               ///< subframe offset in the bit reservoir
195     uint8_t          packet_loss;                   ///< set in case of bitstream error
196     uint8_t          packet_done;                   ///< set when a packet is fully decoded
197
198     /* frame decode state */
199     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
200     GetBitContext    gb;                            ///< bitstream reader context
201     int              buf_bit_size;                  ///< buffer size in bits
202     float*           samples;                       ///< current samplebuffer pointer
203     float*           samples_end;                   ///< maximum samplebuffer pointer
204     uint8_t          drc_gain;                      ///< gain for the DRC tool
205     int8_t           skip_frame;                    ///< skip output step
206     int8_t           parsed_all_subframes;          ///< all subframes decoded?
207
208     /* subframe/block decode state */
209     int16_t          subframe_len;                  ///< current subframe length
210     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
211     int8_t           channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
212     int8_t           num_bands;                     ///< number of scale factor bands
213     int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
214     int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
215     uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
216     int8_t           esc_len;                       ///< length of escaped coefficients
217
218     uint8_t          num_chgroups;                  ///< number of channel groups
219     WmallChannelGrp chgroup[WMALL_MAX_CHANNELS];    ///< channel group information
220
221     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
222
223     // WMA lossless
224     
225     uint8_t do_arith_coding;
226     uint8_t do_ac_filter;
227     uint8_t do_inter_ch_decorr;
228     uint8_t do_mclms;
229     uint8_t do_lpc;
230
231     int8_t acfilter_order;
232     int8_t acfilter_scaling;
233     int acfilter_coeffs[16];
234
235     int8_t mclms_order;
236     int8_t mclms_scaling;
237     int16_t mclms_coeffs[128];
238     int16_t mclms_coeffs_cur[4];
239     int mclms_prevvalues[64];   // FIXME: should be 32-bit / 16-bit depending on bit-depth
240     int16_t mclms_updates[64];
241
242     int movave_scaling;
243     int quant_stepsize;
244
245     struct {
246         int order;
247         int scaling;
248         int coefsend;
249         int bitsend;
250         int16_t coefs[256];
251     int lms_prevvalues[512];    // FIXME: see above
252     int16_t lms_updates[512];   // and here too
253     } cdlms[2][9];
254
255
256     int cdlms_ttl[2];
257
258     int bV3RTM;
259
260     int is_channel_coded[2];
261
262     int transient[2];
263     int transient_pos[2];
264     int seekable_tile;
265
266     int ave_sum[2];
267
268     int channel_residues[2][2048];
269
270
271     int lpc_coefs[2][40];
272     int lpc_order;
273     int lpc_scaling;
274     int lpc_intbits;
275
276     int channel_coeffs[2][2048];
277
278 } WmallDecodeCtx;
279
280
281 #undef dprintf
282 #define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
283
284
285 /**
286  *@brief helper function to print the most important members of the context
287  *@param s context
288  */
289 static void av_cold dump_context(WmallDecodeCtx *s)
290 {
291 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
292 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
293
294     PRINT("ed sample bit depth", s->bits_per_sample);
295     PRINT_HEX("ed decode flags", s->decode_flags);
296     PRINT("samples per frame",   s->samples_per_frame);
297     PRINT("log2 frame size",     s->log2_frame_size);
298     PRINT("max num subframes",   s->max_num_subframes);
299     PRINT("len prefix",          s->len_prefix);
300     PRINT("num channels",        s->num_channels);
301 }
302
303 /**
304  *@brief Uninitialize the decoder and free all resources.
305  *@param avctx codec context
306  *@return 0 on success, < 0 otherwise
307  */
308 static av_cold int decode_end(AVCodecContext *avctx)
309 {
310     WmallDecodeCtx *s = avctx->priv_data;
311     int i;
312
313     for (i = 0; i < WMALL_BLOCK_SIZES; i++)
314         ff_mdct_end(&s->mdct_ctx[i]);
315
316     return 0;
317 }
318
319 /**
320  *@brief Initialize the decoder.
321  *@param avctx codec context
322  *@return 0 on success, -1 otherwise
323  */
324 static av_cold int decode_init(AVCodecContext *avctx)
325 {
326     WmallDecodeCtx *s = avctx->priv_data;
327     uint8_t *edata_ptr = avctx->extradata;
328     unsigned int channel_mask;
329     int i;
330     int log2_max_num_subframes;
331     int num_possible_block_sizes;
332
333     s->avctx = avctx;
334     dsputil_init(&s->dsp, avctx);
335     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
336
337     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
338
339     if (avctx->extradata_size >= 18) {
340         s->decode_flags    = AV_RL16(edata_ptr+14);
341         channel_mask       = AV_RL32(edata_ptr+2);
342         s->bits_per_sample = AV_RL16(edata_ptr);
343         /** dump the extradata */
344         for (i = 0; i < avctx->extradata_size; i++)
345             dprintf(avctx, "[%x] ", avctx->extradata[i]);
346         dprintf(avctx, "\n");
347
348     } else {
349         av_log_ask_for_sample(avctx, "Unknown extradata size\n");
350         return AVERROR_INVALIDDATA;
351     }
352
353     /** generic init */
354     s->log2_frame_size = av_log2(avctx->block_align) + 4;
355
356     /** frame info */
357     s->skip_frame  = 1; /* skip first frame */
358     s->packet_loss = 1;
359     s->len_prefix  = (s->decode_flags & 0x40);
360
361     /** get frame len */
362     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
363                                                           3, s->decode_flags);
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     /** subframe info */
370     log2_max_num_subframes  = ((s->decode_flags & 0x38) >> 3);
371     s->max_num_subframes    = 1 << log2_max_num_subframes;
372     s->max_subframe_len_bit = 0;
373     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
374
375     num_possible_block_sizes     = log2_max_num_subframes + 1;
376     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
377     s->dynamic_range_compression = (s->decode_flags & 0x80);
378
379     s->bV3RTM = s->decode_flags & 0x100;
380
381     if (s->max_num_subframes > MAX_SUBFRAMES) {
382         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
383                s->max_num_subframes);
384         return AVERROR_INVALIDDATA;
385     }
386
387     s->num_channels = avctx->channels;
388
389     /** extract lfe channel position */
390     s->lfe_channel = -1;
391
392     if (channel_mask & 8) {
393         unsigned int mask;
394         for (mask = 1; mask < 16; mask <<= 1) {
395             if (channel_mask & mask)
396                 ++s->lfe_channel;
397         }
398     }
399
400     if (s->num_channels < 0) {
401         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
402         return AVERROR_INVALIDDATA;
403     } else if (s->num_channels > WMALL_MAX_CHANNELS) {
404         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
405         return AVERROR_PATCHWELCOME;
406     }
407
408     avctx->channel_layout = channel_mask;
409     return 0;
410 }
411
412 /**
413  *@brief Decode the subframe length.
414  *@param s context
415  *@param offset sample offset in the frame
416  *@return decoded subframe length on success, < 0 in case of an error
417  */
418 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
419 {
420     int frame_len_ratio;
421     int subframe_len, len;
422
423     /** no need to read from the bitstream when only one length is possible */
424     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
425         return s->min_samples_per_subframe;
426
427     len = av_log2(s->max_num_subframes - 1) + 1;
428     frame_len_ratio = get_bits(&s->gb, len);
429
430     subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
431
432     /** sanity check the length */
433     if (subframe_len < s->min_samples_per_subframe ||
434         subframe_len > s->samples_per_frame) {
435         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
436                subframe_len);
437         return AVERROR_INVALIDDATA;
438     }
439     return subframe_len;
440 }
441
442 /**
443  *@brief Decode how the data in the frame is split into subframes.
444  *       Every WMA frame contains the encoded data for a fixed number of
445  *       samples per channel. The data for every channel might be split
446  *       into several subframes. This function will reconstruct the list of
447  *       subframes for every channel.
448  *
449  *       If the subframes are not evenly split, the algorithm estimates the
450  *       channels with the lowest number of total samples.
451  *       Afterwards, for each of these channels a bit is read from the
452  *       bitstream that indicates if the channel contains a subframe with the
453  *       next subframe size that is going to be read from the bitstream or not.
454  *       If a channel contains such a subframe, the subframe size gets added to
455  *       the channel's subframe list.
456  *       The algorithm repeats these steps until the frame is properly divided
457  *       between the individual channels.
458  *
459  *@param s context
460  *@return 0 on success, < 0 in case of an error
461  */
462 static int decode_tilehdr(WmallDecodeCtx *s)
463 {
464     uint16_t num_samples[WMALL_MAX_CHANNELS];        /**< sum of samples for all currently known subframes of a channel */
465     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
466     int channels_for_cur_subframe = s->num_channels;  /**< number of channels that contain the current subframe */
467     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subfra2me offsets and sizes */
468     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
469     int c;
470
471     /* Should never consume more than 3073 bits (256 iterations for the
472      * while loop when always the minimum amount of 128 samples is substracted
473      * from missing samples in the 8 channel case).
474      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
475      */
476
477     /** reset tiling information */
478     for (c = 0; c < s->num_channels; c++)
479         s->channel[c].num_subframes = 0;
480
481     memset(num_samples, 0, sizeof(num_samples));
482
483     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
484         fixed_channel_layout = 1;
485
486     /** loop until the frame data is split between the subframes */
487     do {
488         int subframe_len;
489
490         /** check which channels contain the subframe */
491         for (c = 0; c < s->num_channels; c++) {
492             if (num_samples[c] == min_channel_len) {
493                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
494                     (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
495                     contains_subframe[c] = 1;
496                 }                   
497                 else {
498                     contains_subframe[c] = get_bits1(&s->gb);
499                 }
500             } else
501                 contains_subframe[c] = 0;
502         }
503
504         /** get subframe length, subframe_len == 0 is not allowed */
505         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
506             return AVERROR_INVALIDDATA;
507         /** add subframes to the individual channels and find new min_channel_len */
508         min_channel_len += subframe_len;
509         for (c = 0; c < s->num_channels; c++) {
510             WmallChannelCtx* chan = &s->channel[c];
511
512             if (contains_subframe[c]) {
513                 if (chan->num_subframes >= MAX_SUBFRAMES) {
514                     av_log(s->avctx, AV_LOG_ERROR,
515                            "broken frame: num subframes > 31\n");
516                     return AVERROR_INVALIDDATA;
517                 }
518                 chan->subframe_len[chan->num_subframes] = subframe_len;
519                 num_samples[c] += subframe_len;
520                 ++chan->num_subframes;
521                 if (num_samples[c] > s->samples_per_frame) {
522                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
523                            "channel len(%d) > samples_per_frame(%d)\n",
524                            num_samples[c], s->samples_per_frame);
525                     return AVERROR_INVALIDDATA;
526                 }
527             } else if (num_samples[c] <= min_channel_len) {
528                 if (num_samples[c] < min_channel_len) {
529                     channels_for_cur_subframe = 0;
530                     min_channel_len = num_samples[c];
531                 }
532                 ++channels_for_cur_subframe;
533             }
534         }
535     } while (min_channel_len < s->samples_per_frame);
536
537     for (c = 0; c < s->num_channels; c++) {
538         int i;
539         int offset = 0;
540         for (i = 0; i < s->channel[c].num_subframes; i++) {
541             s->channel[c].subframe_offset[i] = offset;
542             offset += s->channel[c].subframe_len[i];
543         }
544     }
545
546     return 0;
547 }
548
549
550 static int my_log2(unsigned int i)
551 {
552     unsigned int iLog2 = 0;
553     while ((i >> iLog2) > 1)
554         iLog2++;
555     return iLog2;
556 }
557
558
559 /**
560  *
561  */
562 static void decode_ac_filter(WmallDecodeCtx *s)
563 {
564     int i;
565     s->acfilter_order = get_bits(&s->gb, 4) + 1;
566     s->acfilter_scaling = get_bits(&s->gb, 4);
567
568     for(i = 0; i < s->acfilter_order; i++) {
569         s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
570     }
571 }
572
573
574 /**
575  *
576  */
577 static void decode_mclms(WmallDecodeCtx *s)
578 {
579     s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
580     s->mclms_scaling = get_bits(&s->gb, 4);
581     if(get_bits1(&s->gb)) {
582         // mclms_send_coef
583         int i;
584         int send_coef_bits;
585         int cbits = av_log2(s->mclms_scaling + 1);
586         assert(cbits == my_log2(s->mclms_scaling + 1));
587         if(1 << cbits < s->mclms_scaling + 1)
588             cbits++;
589
590         send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
591
592         for(i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++) {
593             s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
594         }           
595
596         for(i = 0; i < s->num_channels; i++) {
597             int c;
598             for(c = 0; c < i; c++) {
599                 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
600             }
601         }
602     }
603 }
604
605
606 /**
607  *
608  */
609 static void decode_cdlms(WmallDecodeCtx *s)
610 {
611     int c, i;
612     int cdlms_send_coef = get_bits1(&s->gb);
613
614     for(c = 0; c < s->num_channels; c++) {
615         s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
616         for(i = 0; i < s->cdlms_ttl[c]; i++) {
617             s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
618         }
619
620         for(i = 0; i < s->cdlms_ttl[c]; i++) {
621             s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
622         }
623
624         if(cdlms_send_coef) {
625             for(i = 0; i < s->cdlms_ttl[c]; i++) {
626                 int cbits, shift_l, shift_r, j;
627                 cbits = av_log2(s->cdlms[c][i].order);
628                 if(1 << cbits < s->cdlms[c][i].order)
629                     cbits++;
630                 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
631
632                 cbits = av_log2(s->cdlms[c][i].scaling + 1);
633                 if(1 << cbits < s->cdlms[c][i].scaling + 1)
634                     cbits++;
635                 
636                 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
637                 shift_l = 32 - s->cdlms[c][i].bitsend;
638                 shift_r = 32 - 2 - s->cdlms[c][i].scaling;
639                 for(j = 0; j < s->cdlms[c][i].coefsend; j++) {
640                     s->cdlms[c][i].coefs[j] = 
641                         (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
642                 }
643             }
644         }
645     }
646 }
647
648 /**
649  *
650  */
651 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
652 {
653     int i = 0;
654     unsigned int ave_mean;
655     s->transient[ch] = get_bits1(&s->gb);
656     if(s->transient[ch])
657         s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
658     
659     if(s->seekable_tile) {
660         ave_mean = get_bits(&s->gb, s->bits_per_sample);
661         s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
662 //      s->ave_sum[ch] *= 2;
663     }
664
665     if(s->seekable_tile) {
666         if(s->do_inter_ch_decorr)
667             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
668         else
669             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
670         i++;
671     }
672     for(; i < tile_size; i++) {
673         int quo = 0, rem, rem_bits, residue;
674         while(get_bits1(&s->gb))
675             quo++;
676         if(quo >= 32)
677             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
678
679         ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
680         rem_bits = av_ceil_log2(ave_mean);
681         rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
682         residue = (quo << rem_bits) + rem;
683
684         s->ave_sum[ch] = residue + s->ave_sum[ch] - (s->ave_sum[ch] >> s->movave_scaling);
685
686         if(residue & 1)
687             residue = -(residue >> 1) - 1;
688         else
689             residue = residue >> 1;
690         s->channel_residues[ch][i] = residue;
691
692 //      dprintf(s->avctx, "%5d: %5d %10d %12d %12d %5d %-16d %04x\n",i, quo, ave_mean, s->ave_sum[ch], rem, rem_bits, s->channel_residues[ch][i], show_bits(&s->gb, 16));
693     }
694
695     return 0;
696
697 }
698
699
700 /**
701  *
702  */
703 static void
704 decode_lpc(WmallDecodeCtx *s)
705 {
706     int ch, i, cbits;
707     s->lpc_order = get_bits(&s->gb, 5) + 1;
708     s->lpc_scaling = get_bits(&s->gb, 4);
709     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
710     cbits = s->lpc_scaling + s->lpc_intbits;
711     for(ch = 0; ch < s->num_channels; ch++) {
712         for(i = 0; i < s->lpc_order; i++) {
713             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
714         }
715     }
716 }
717
718
719 static void clear_codec_buffers(WmallDecodeCtx *s)
720 {
721     int ich, ilms;
722
723     memset(s->acfilter_coeffs, 0,     16 * sizeof(int));
724     memset(s->lpc_coefs      , 0, 40 * 2 * sizeof(int));
725
726     memset(s->mclms_coeffs    , 0, 128 * sizeof(int16_t));
727     memset(s->mclms_coeffs_cur, 0,   4 * sizeof(int16_t));
728     memset(s->mclms_prevvalues, 0,  64 * sizeof(int));
729     memset(s->mclms_updates   , 0,  64 * sizeof(int16_t));
730
731     for (ich = 0; ich < s->num_channels; ich++) {
732         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
733             memset(s->cdlms[ich][ilms].coefs         , 0, 256 * sizeof(int16_t));
734             memset(s->cdlms[ich][ilms].lms_prevvalues, 0, 512 * sizeof(int));
735             memset(s->cdlms[ich][ilms].lms_updates   , 0, 512 * sizeof(int16_t));
736         }
737         s->ave_sum[ich] = 0;
738     }
739 }
740
741 /**
742  *@brief Decode a single subframe (block).
743  *@param s codec context
744  *@return 0 on success, < 0 when decoding failed
745  */
746 static int decode_subframe(WmallDecodeCtx *s)
747 {
748     int offset = s->samples_per_frame;
749     int subframe_len = s->samples_per_frame;
750     int i;
751     int total_samples   = s->samples_per_frame * s->num_channels;
752     int rawpcm_tile;
753     int padding_zeroes;
754
755     s->subframe_offset = get_bits_count(&s->gb);
756
757     /** reset channel context and find the next block offset and size
758         == the next block of the channel with the smallest number of
759         decoded samples
760     */
761     for (i = 0; i < s->num_channels; i++) {
762         s->channel[i].grouped = 0;
763         if (offset > s->channel[i].decoded_samples) {
764             offset = s->channel[i].decoded_samples;
765             subframe_len =
766                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
767         }
768     }
769
770     /** get a list of all channels that contain the estimated block */
771     s->channels_for_cur_subframe = 0;
772     for (i = 0; i < s->num_channels; i++) {
773         const int cur_subframe = s->channel[i].cur_subframe;
774         /** substract already processed samples */
775         total_samples -= s->channel[i].decoded_samples;
776
777         /** and count if there are multiple subframes that match our profile */
778         if (offset == s->channel[i].decoded_samples &&
779             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
780             total_samples -= s->channel[i].subframe_len[cur_subframe];
781             s->channel[i].decoded_samples +=
782                 s->channel[i].subframe_len[cur_subframe];
783             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
784             ++s->channels_for_cur_subframe;
785         }
786     }
787
788     /** check if the frame will be complete after processing the
789         estimated block */
790     if (!total_samples)
791         s->parsed_all_subframes = 1;
792
793
794     s->seekable_tile = get_bits1(&s->gb);
795     if(s->seekable_tile) {
796         s->do_arith_coding    = get_bits1(&s->gb);
797         if(s->do_arith_coding) {
798             dprintf(s->avctx, "do_arith_coding == 1");
799             abort();
800         }
801         s->do_ac_filter       = get_bits1(&s->gb);
802         s->do_inter_ch_decorr = get_bits1(&s->gb);
803         s->do_mclms           = get_bits1(&s->gb);
804         
805         if(s->do_ac_filter)
806             decode_ac_filter(s);
807
808         if(s->do_mclms)
809             decode_mclms(s);
810
811         decode_cdlms(s);
812         s->movave_scaling = get_bits(&s->gb, 3);
813         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
814     }
815
816     rawpcm_tile = get_bits1(&s->gb);
817
818     for(i = 0; i < s->num_channels; i++) {
819         s->is_channel_coded[i] = 1;
820     }
821
822     if(!rawpcm_tile) {
823
824         for(i = 0; i < s->num_channels; i++) {
825             s->is_channel_coded[i] = get_bits1(&s->gb);
826         }
827
828         if(s->bV3RTM) {
829             // LPC
830             s->do_lpc = get_bits1(&s->gb);
831             if(s->do_lpc) {
832                 decode_lpc(s);
833             }
834         } else {
835             s->do_lpc = 0;
836         }
837     }
838
839
840     if(get_bits1(&s->gb)) {
841         padding_zeroes = get_bits(&s->gb, 5);
842     } else {
843         padding_zeroes = 0;
844     }
845
846     if(rawpcm_tile) {
847         
848         int bits = s->bits_per_sample - padding_zeroes;
849         int j;
850         dprintf(s->avctx, "RAWPCM %d bits per sample. total %d bits, remain=%d\n", bits,
851                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
852         for(i = 0; i < s->num_channels; i++) {
853             for(j = 0; j < subframe_len; j++) {
854                 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
855 //              dprintf(s->avctx, "PCM[%d][%d] = 0x%04x\n", i, j, s->channel_coeffs[i][j]);
856             }
857         }
858     } else {
859         for(i = 0; i < s->num_channels; i++)
860             if(s->is_channel_coded[i])
861                 decode_channel_residues(s, i, subframe_len);
862     }
863
864     /** handled one subframe */
865
866     for (i = 0; i < s->channels_for_cur_subframe; i++) {
867         int c = s->channel_indexes_for_cur_subframe[i];
868         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
869             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
870             return AVERROR_INVALIDDATA;
871         }
872         ++s->channel[c].cur_subframe;
873     }
874     return 0;
875 }
876
877 /**
878  *@brief Decode one WMA frame.
879  *@param s codec context
880  *@return 0 if the trailer bit indicates that this is the last frame,
881  *        1 if there are additional frames
882  */
883 static int decode_frame(WmallDecodeCtx *s)
884 {
885     GetBitContext* gb = &s->gb;
886     int more_frames = 0;
887     int len = 0;
888     int i;
889
890     /** check for potential output buffer overflow */
891     if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
892         /** return an error if no frame could be decoded at all */
893         av_log(s->avctx, AV_LOG_ERROR,
894                "not enough space for the output samples\n");
895         s->packet_loss = 1;
896         return 0;
897     }
898
899     /** get frame length */
900     if (s->len_prefix)
901         len = get_bits(gb, s->log2_frame_size);
902
903     /** decode tile information */
904     if (decode_tilehdr(s)) {
905         s->packet_loss = 1;
906         return 0;
907     }
908
909     /** read drc info */
910     if (s->dynamic_range_compression) {
911         s->drc_gain = get_bits(gb, 8);
912     }
913
914     /** no idea what these are for, might be the number of samples
915         that need to be skipped at the beginning or end of a stream */
916     if (get_bits1(gb)) {
917         int skip;
918
919         /** usually true for the first frame */
920         if (get_bits1(gb)) {
921             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
922             dprintf(s->avctx, "start skip: %i\n", skip);
923         }
924
925         /** sometimes true for the last frame */
926         if (get_bits1(gb)) {
927             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
928             dprintf(s->avctx, "end skip: %i\n", skip);
929         }
930
931     }
932
933     /** reset subframe states */
934     s->parsed_all_subframes = 0;
935     for (i = 0; i < s->num_channels; i++) {
936         s->channel[i].decoded_samples = 0;
937         s->channel[i].cur_subframe    = 0;
938         s->channel[i].reuse_sf        = 0;
939     }
940
941     /** decode all subframes */
942     while (!s->parsed_all_subframes) {
943         if (decode_subframe(s) < 0) {
944             s->packet_loss = 1;
945             return 0;
946         }
947     }
948
949     dprintf(s->avctx, "Frame done\n");
950
951     if (s->skip_frame) {
952         s->skip_frame = 0;
953     } else
954         s->samples += s->num_channels * s->samples_per_frame;
955
956     if (s->len_prefix) {
957         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
958             /** FIXME: not sure if this is always an error */
959             av_log(s->avctx, AV_LOG_ERROR,
960                    "frame[%i] would have to skip %i bits\n", s->frame_num,
961                    len - (get_bits_count(gb) - s->frame_offset) - 1);
962             s->packet_loss = 1;
963             return 0;
964         }
965
966         /** skip the rest of the frame data */
967         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
968     } else {
969 /*
970         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
971             dprintf(s->avctx, "skip1\n");
972         }
973 */
974     }
975
976     /** decode trailer bit */
977     more_frames = get_bits1(gb);
978     ++s->frame_num;
979     return more_frames;
980 }
981
982 /**
983  *@brief Calculate remaining input buffer length.
984  *@param s codec context
985  *@param gb bitstream reader context
986  *@return remaining size in bits
987  */
988 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
989 {
990     return s->buf_bit_size - get_bits_count(gb);
991 }
992
993 /**
994  *@brief Fill the bit reservoir with a (partial) frame.
995  *@param s codec context
996  *@param gb bitstream reader context
997  *@param len length of the partial frame
998  *@param append decides wether to reset the buffer or not
999  */
1000 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1001                       int append)
1002 {
1003     int buflen;
1004
1005     /** when the frame data does not need to be concatenated, the input buffer
1006         is resetted and additional bits from the previous frame are copyed
1007         and skipped later so that a fast byte copy is possible */
1008
1009     if (!append) {
1010         s->frame_offset = get_bits_count(gb) & 7;
1011         s->num_saved_bits = s->frame_offset;
1012         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1013     }
1014
1015     buflen = (s->num_saved_bits + len + 8) >> 3;
1016
1017     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1018         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1019         s->packet_loss = 1;
1020         return;
1021     }
1022
1023     s->num_saved_bits += len;
1024     if (!append) {
1025         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1026                      s->num_saved_bits);
1027     } else {
1028         int align = 8 - (get_bits_count(gb) & 7);
1029         align = FFMIN(align, len);
1030         put_bits(&s->pb, align, get_bits(gb, align));
1031         len -= align;
1032         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1033     }
1034     skip_bits_long(gb, len);
1035
1036     {
1037         PutBitContext tmp = s->pb;
1038         flush_put_bits(&tmp);
1039     }
1040
1041     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1042     skip_bits(&s->gb, s->frame_offset);
1043 }
1044
1045 /**
1046  *@brief Decode a single WMA packet.
1047  *@param avctx codec context
1048  *@param data the output buffer
1049  *@param data_size number of bytes that were written to the output buffer
1050  *@param avpkt input packet
1051  *@return number of bytes that were read from the input buffer
1052  */
1053 static int decode_packet(AVCodecContext *avctx,
1054                          void *data, int *data_size, AVPacket* avpkt)
1055 {
1056     WmallDecodeCtx *s = avctx->priv_data;
1057     GetBitContext* gb  = &s->pgb;
1058     const uint8_t* buf = avpkt->data;
1059     int buf_size       = avpkt->size;
1060     int num_bits_prev_frame;
1061     int packet_sequence_number;
1062
1063     s->samples       = data;
1064     s->samples_end   = (float*)((int8_t*)data + *data_size);
1065     *data_size = 0;
1066
1067     if (s->packet_done || s->packet_loss) {
1068         s->packet_done = 0;
1069
1070         /** sanity check for the buffer length */
1071         if (buf_size < avctx->block_align)
1072             return 0;
1073
1074         s->next_packet_start = buf_size - avctx->block_align;
1075         buf_size = avctx->block_align;
1076         s->buf_bit_size = buf_size << 3;
1077
1078         /** parse packet header */
1079         init_get_bits(gb, buf, s->buf_bit_size);
1080         packet_sequence_number = get_bits(gb, 4);
1081         int seekable_frame_in_packet = get_bits1(gb);
1082         int spliced_packet = get_bits1(gb);
1083
1084         /** get number of bits that need to be added to the previous frame */
1085         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1086
1087         /** check for packet loss */
1088         if (!s->packet_loss &&
1089             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1090             s->packet_loss = 1;
1091             av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1092                    s->packet_sequence_number, packet_sequence_number);
1093         }
1094         s->packet_sequence_number = packet_sequence_number;
1095
1096         if (num_bits_prev_frame > 0) {
1097             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1098             if (num_bits_prev_frame >= remaining_packet_bits) {
1099                 num_bits_prev_frame = remaining_packet_bits;
1100                 s->packet_done = 1;
1101             }
1102
1103             /** append the previous frame data to the remaining data from the
1104                 previous packet to create a full frame */
1105             save_bits(s, gb, num_bits_prev_frame, 1);
1106
1107             /** decode the cross packet frame if it is valid */
1108             if (!s->packet_loss)
1109                 decode_frame(s);
1110         } else if (s->num_saved_bits - s->frame_offset) {
1111             dprintf(avctx, "ignoring %x previously saved bits\n",
1112                     s->num_saved_bits - s->frame_offset);
1113         }
1114
1115         if (s->packet_loss) {
1116             /** reset number of saved bits so that the decoder
1117                 does not start to decode incomplete frames in the
1118                 s->len_prefix == 0 case */
1119             s->num_saved_bits = 0;
1120             s->packet_loss = 0;
1121         }
1122
1123     } else {
1124         int frame_size;
1125
1126         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1127         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1128         skip_bits(gb, s->packet_offset);
1129         
1130         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1131             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1132             frame_size <= remaining_bits(s, gb)) {
1133             save_bits(s, gb, frame_size, 0);
1134             s->packet_done = !decode_frame(s);
1135         } else if (!s->len_prefix
1136                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1137             /** when the frames do not have a length prefix, we don't know
1138                 the compressed length of the individual frames
1139                 however, we know what part of a new packet belongs to the
1140                 previous frame
1141                 therefore we save the incoming packet first, then we append
1142                 the "previous frame" data from the next packet so that
1143                 we get a buffer that only contains full frames */
1144             s->packet_done = !decode_frame(s);
1145         } else {
1146             s->packet_done = 1;
1147         }
1148     }
1149
1150     if (s->packet_done && !s->packet_loss &&
1151         remaining_bits(s, gb) > 0) {
1152         /** save the rest of the data so that it can be decoded
1153             with the next packet */
1154         save_bits(s, gb, remaining_bits(s, gb), 0);
1155     }
1156
1157     *data_size = 0; // (int8_t *)s->samples - (int8_t *)data;
1158     s->packet_offset = get_bits_count(gb) & 7;
1159
1160     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1161 }
1162
1163 /**
1164  *@brief Clear decoder buffers (for seeking).
1165  *@param avctx codec context
1166  */
1167 static void flush(AVCodecContext *avctx)
1168 {
1169     WmallDecodeCtx *s = avctx->priv_data;
1170     int i;
1171     /** reset output buffer as a part of it is used during the windowing of a
1172         new frame */
1173     for (i = 0; i < s->num_channels; i++)
1174         memset(s->channel[i].out, 0, s->samples_per_frame *
1175                sizeof(*s->channel[i].out));
1176     s->packet_loss = 1;
1177 }
1178
1179
1180 /**
1181  *@brief wmall decoder
1182  */
1183 AVCodec ff_wmalossless_decoder = {
1184     "wmalossless",
1185     AVMEDIA_TYPE_AUDIO,
1186     CODEC_ID_WMALOSSLESS,
1187     sizeof(WmallDecodeCtx),
1188     decode_init,
1189     NULL,
1190     decode_end,
1191     decode_packet,
1192     .capabilities = CODEC_CAP_SUBFRAMES,
1193     .flush= flush,
1194     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Lossless"),
1195 };