error_concealment: optimize guess_dc()
[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     int      transient_counter;                       ///< number of transient samples from the beginning of transient zone
143 } WmallChannelCtx;
144
145 /**
146  * @brief channel group for channel transformations
147  */
148 typedef struct {
149     uint8_t num_channels;                                     ///< number of channels in the group
150     int8_t  transform;                                        ///< transform on / off
151     int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
152     float   decorrelation_matrix[WMALL_MAX_CHANNELS*WMALL_MAX_CHANNELS];
153     float*  channel_data[WMALL_MAX_CHANNELS];                ///< transformation coefficients
154 } WmallChannelGrp;
155
156 /**
157  * @brief main decoder context
158  */
159 typedef struct WmallDecodeCtx {
160     /* generic decoder variables */
161     AVCodecContext*  avctx;                         ///< codec context for av_log
162     DSPContext       dsp;                           ///< accelerated DSP functions
163     uint8_t          frame_data[MAX_FRAMESIZE +
164                       FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
165     PutBitContext    pb;                            ///< context for filling the frame_data buffer
166     FFTContext       mdct_ctx[WMALL_BLOCK_SIZES];  ///< MDCT context per block size
167     DECLARE_ALIGNED(16, float, tmp)[WMALL_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
168     float*           windows[WMALL_BLOCK_SIZES];   ///< windows for the different block sizes
169
170     /* frame size dependent frame information (set during initialization) */
171     uint32_t         decode_flags;                  ///< used compression features
172     uint8_t          len_prefix;                    ///< frame is prefixed with its length
173     uint8_t          dynamic_range_compression;     ///< frame contains DRC data
174     uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
175     uint16_t         samples_per_frame;             ///< number of samples to output
176     uint16_t         log2_frame_size;
177     int8_t           num_channels;                  ///< number of channels in the stream (same as AVCodecContext.num_channels)
178     int8_t           lfe_channel;                   ///< lfe channel index
179     uint8_t          max_num_subframes;
180     uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
181     uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
182     uint16_t         min_samples_per_subframe;
183     int8_t           num_sfb[WMALL_BLOCK_SIZES];   ///< scale factor bands per block size
184     int16_t          sfb_offsets[WMALL_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
185     int8_t           sf_offsets[WMALL_BLOCK_SIZES][WMALL_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
186     int16_t          subwoofer_cutoffs[WMALL_BLOCK_SIZES]; ///< subwoofer cutoff values
187
188     /* packet decode state */
189     GetBitContext    pgb;                           ///< bitstream reader context for the packet
190     int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
191     uint8_t          packet_offset;                 ///< frame offset in the packet
192     uint8_t          packet_sequence_number;        ///< current packet number
193     int              num_saved_bits;                ///< saved number of bits
194     int              frame_offset;                  ///< frame offset in the bit reservoir
195     int              subframe_offset;               ///< subframe offset in the bit reservoir
196     uint8_t          packet_loss;                   ///< set in case of bitstream error
197     uint8_t          packet_done;                   ///< set when a packet is fully decoded
198
199     /* frame decode state */
200     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
201     GetBitContext    gb;                            ///< bitstream reader context
202     int              buf_bit_size;                  ///< buffer size in bits
203     float*           samples;                       ///< current samplebuffer pointer
204     float*           samples_end;                   ///< maximum samplebuffer pointer
205     uint8_t          drc_gain;                      ///< gain for the DRC tool
206     int8_t           skip_frame;                    ///< skip output step
207     int8_t           parsed_all_subframes;          ///< all subframes decoded?
208
209     /* subframe/block decode state */
210     int16_t          subframe_len;                  ///< current subframe length
211     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
212     int8_t           channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
213     int8_t           num_bands;                     ///< number of scale factor bands
214     int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
215     int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
216     uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
217     int8_t           esc_len;                       ///< length of escaped coefficients
218
219     uint8_t          num_chgroups;                  ///< number of channel groups
220     WmallChannelGrp chgroup[WMALL_MAX_CHANNELS];    ///< channel group information
221
222     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
223
224     // WMA lossless
225
226     uint8_t do_arith_coding;
227     uint8_t do_ac_filter;
228     uint8_t do_inter_ch_decorr;
229     uint8_t do_mclms;
230     uint8_t do_lpc;
231
232     int8_t acfilter_order;
233     int8_t acfilter_scaling;
234     int acfilter_coeffs[16];
235
236     int8_t mclms_order;
237     int8_t mclms_scaling;
238     int16_t mclms_coeffs[128];
239     int16_t mclms_coeffs_cur[4];
240     int16_t mclms_prevvalues[64];   // FIXME: should be 32-bit / 16-bit depending on bit-depth
241     int16_t mclms_updates[64];
242     int mclms_recent;
243
244     int movave_scaling;
245     int quant_stepsize;
246
247     struct {
248         int order;
249         int scaling;
250         int coefsend;
251         int bitsend;
252         int16_t coefs[256];
253     int16_t lms_prevvalues[512];    // FIXME: see above
254     int16_t lms_updates[512];   // and here too
255     int recent;
256     } cdlms[2][9];              /* XXX: Here, 2 is the max. no. of channels allowed,
257                                         9 is the maximum no. of filters per channel.
258                                         Question is, why 2 if WMALL_MAX_CHANNELS == 8 */
259
260
261     int cdlms_ttl[2];
262
263     int bV3RTM;
264
265     int is_channel_coded[2];    // XXX: same question as above applies here too (and below)
266     int update_speed[2];
267
268     int transient[2];
269     int transient_pos[2];
270     int seekable_tile;
271
272     int ave_sum[2];
273
274     int channel_residues[2][2048];
275
276
277     int lpc_coefs[2][40];
278     int lpc_order;
279     int lpc_scaling;
280     int lpc_intbits;
281
282     int16_t channel_coeffs[2][2048]; // FIXME: should be 32-bit / 16-bit depending on bit-depth
283
284 } WmallDecodeCtx;
285
286
287 #undef dprintf
288 #define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
289
290
291 static int num_logged_tiles = 0;
292 static int num_logged_subframes = 0;
293 static int num_lms_update_call = 0;
294
295 /**
296  *@brief helper function to print the most important members of the context
297  *@param s context
298  */
299 static void av_cold dump_context(WmallDecodeCtx *s)
300 {
301 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
302 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
303
304     PRINT("ed sample bit depth", s->bits_per_sample);
305     PRINT_HEX("ed decode flags", s->decode_flags);
306     PRINT("samples per frame",   s->samples_per_frame);
307     PRINT("log2 frame size",     s->log2_frame_size);
308     PRINT("max num subframes",   s->max_num_subframes);
309     PRINT("len prefix",          s->len_prefix);
310     PRINT("num channels",        s->num_channels);
311 }
312
313 static void dump_int_buffer(uint8_t *buffer, int size, int length, int delimiter)
314 {
315     int i;
316
317     for (i=0 ; i<length ; i++) {
318         if (!(i%delimiter))
319             av_log(0, 0, "\n[%d] ", i);
320         av_log(0, 0, "%d, ", *(int16_t *)(buffer + i * size));
321     }
322     av_log(0, 0, "\n");
323
324 }
325
326 /**
327  *@brief Uninitialize the decoder and free all resources.
328  *@param avctx codec context
329  *@return 0 on success, < 0 otherwise
330  */
331 static av_cold int decode_end(AVCodecContext *avctx)
332 {
333     WmallDecodeCtx *s = avctx->priv_data;
334     int i;
335
336     for (i = 0; i < WMALL_BLOCK_SIZES; i++)
337         ff_mdct_end(&s->mdct_ctx[i]);
338
339     return 0;
340 }
341
342 /**
343  *@brief Initialize the decoder.
344  *@param avctx codec context
345  *@return 0 on success, -1 otherwise
346  */
347 static av_cold int decode_init(AVCodecContext *avctx)
348 {
349     WmallDecodeCtx *s = avctx->priv_data;
350     uint8_t *edata_ptr = avctx->extradata;
351     unsigned int channel_mask;
352     int i;
353     int log2_max_num_subframes;
354     int num_possible_block_sizes;
355
356     s->avctx = avctx;
357     dsputil_init(&s->dsp, avctx);
358     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
359
360     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
361
362     if (avctx->extradata_size >= 18) {
363         s->decode_flags    = AV_RL16(edata_ptr+14);
364         channel_mask       = AV_RL32(edata_ptr+2);
365         s->bits_per_sample = AV_RL16(edata_ptr);
366         /** dump the extradata */
367         for (i = 0; i < avctx->extradata_size; i++)
368             dprintf(avctx, "[%x] ", avctx->extradata[i]);
369         dprintf(avctx, "\n");
370
371     } else {
372         av_log_ask_for_sample(avctx, "Unknown extradata size\n");
373         return AVERROR_INVALIDDATA;
374     }
375
376     /** generic init */
377     s->log2_frame_size = av_log2(avctx->block_align) + 4;
378
379     /** frame info */
380     s->skip_frame  = 1; /* skip first frame */
381     s->packet_loss = 1;
382     s->len_prefix  = (s->decode_flags & 0x40);
383
384     /** get frame len */
385     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
386                                                           3, s->decode_flags);
387
388     /** init previous block len */
389     for (i = 0; i < avctx->channels; i++)
390         s->channel[i].prev_block_len = s->samples_per_frame;
391
392     /** subframe info */
393     log2_max_num_subframes  = ((s->decode_flags & 0x38) >> 3);
394     s->max_num_subframes    = 1 << log2_max_num_subframes;
395     s->max_subframe_len_bit = 0;
396     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
397
398     num_possible_block_sizes     = log2_max_num_subframes + 1;
399     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
400     s->dynamic_range_compression = (s->decode_flags & 0x80);
401
402     s->bV3RTM = s->decode_flags & 0x100;
403
404     if (s->max_num_subframes > MAX_SUBFRAMES) {
405         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
406                s->max_num_subframes);
407         return AVERROR_INVALIDDATA;
408     }
409
410     s->num_channels = avctx->channels;
411
412     /** extract lfe channel position */
413     s->lfe_channel = -1;
414
415     if (channel_mask & 8) {
416         unsigned int mask;
417         for (mask = 1; mask < 16; mask <<= 1) {
418             if (channel_mask & mask)
419                 ++s->lfe_channel;
420         }
421     }
422
423     if (s->num_channels < 0) {
424         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
425         return AVERROR_INVALIDDATA;
426     } else if (s->num_channels > WMALL_MAX_CHANNELS) {
427         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
428         return AVERROR_PATCHWELCOME;
429     }
430
431     avctx->channel_layout = channel_mask;
432     return 0;
433 }
434
435 /**
436  *@brief Decode the subframe length.
437  *@param s context
438  *@param offset sample offset in the frame
439  *@return decoded subframe length on success, < 0 in case of an error
440  */
441 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
442 {
443     int frame_len_ratio;
444     int subframe_len, len;
445
446     /** no need to read from the bitstream when only one length is possible */
447     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
448         return s->min_samples_per_subframe;
449
450     len = av_log2(s->max_num_subframes - 1) + 1;
451     frame_len_ratio = get_bits(&s->gb, len);
452
453     subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
454
455     /** sanity check the length */
456     if (subframe_len < s->min_samples_per_subframe ||
457         subframe_len > s->samples_per_frame) {
458         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
459                subframe_len);
460         return AVERROR_INVALIDDATA;
461     }
462     return subframe_len;
463 }
464
465 /**
466  *@brief Decode how the data in the frame is split into subframes.
467  *       Every WMA frame contains the encoded data for a fixed number of
468  *       samples per channel. The data for every channel might be split
469  *       into several subframes. This function will reconstruct the list of
470  *       subframes for every channel.
471  *
472  *       If the subframes are not evenly split, the algorithm estimates the
473  *       channels with the lowest number of total samples.
474  *       Afterwards, for each of these channels a bit is read from the
475  *       bitstream that indicates if the channel contains a subframe with the
476  *       next subframe size that is going to be read from the bitstream or not.
477  *       If a channel contains such a subframe, the subframe size gets added to
478  *       the channel's subframe list.
479  *       The algorithm repeats these steps until the frame is properly divided
480  *       between the individual channels.
481  *
482  *@param s context
483  *@return 0 on success, < 0 in case of an error
484  */
485 static int decode_tilehdr(WmallDecodeCtx *s)
486 {
487     uint16_t num_samples[WMALL_MAX_CHANNELS];        /**< sum of samples for all currently known subframes of a channel */
488     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
489     int channels_for_cur_subframe = s->num_channels;  /**< number of channels that contain the current subframe */
490     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subfra2me offsets and sizes */
491     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
492     int c;
493
494     /* Should never consume more than 3073 bits (256 iterations for the
495      * while loop when always the minimum amount of 128 samples is substracted
496      * from missing samples in the 8 channel case).
497      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
498      */
499
500     /** reset tiling information */
501     for (c = 0; c < s->num_channels; c++)
502         s->channel[c].num_subframes = 0;
503
504     memset(num_samples, 0, sizeof(num_samples));
505
506     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
507         fixed_channel_layout = 1;
508
509     /** loop until the frame data is split between the subframes */
510     do {
511         int subframe_len;
512
513         /** check which channels contain the subframe */
514         for (c = 0; c < s->num_channels; c++) {
515             if (num_samples[c] == min_channel_len) {
516                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
517                     (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
518                     contains_subframe[c] = 1;
519                 }
520                 else {
521                     contains_subframe[c] = get_bits1(&s->gb);
522                 }
523             } else
524                 contains_subframe[c] = 0;
525         }
526
527         /** get subframe length, subframe_len == 0 is not allowed */
528         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
529             return AVERROR_INVALIDDATA;
530         /** add subframes to the individual channels and find new min_channel_len */
531         min_channel_len += subframe_len;
532         for (c = 0; c < s->num_channels; c++) {
533             WmallChannelCtx* chan = &s->channel[c];
534
535             if (contains_subframe[c]) {
536                 if (chan->num_subframes >= MAX_SUBFRAMES) {
537                     av_log(s->avctx, AV_LOG_ERROR,
538                            "broken frame: num subframes > 31\n");
539                     return AVERROR_INVALIDDATA;
540                 }
541                 chan->subframe_len[chan->num_subframes] = subframe_len;
542                 num_samples[c] += subframe_len;
543                 ++chan->num_subframes;
544                 if (num_samples[c] > s->samples_per_frame) {
545                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
546                            "channel len(%d) > samples_per_frame(%d)\n",
547                            num_samples[c], s->samples_per_frame);
548                     return AVERROR_INVALIDDATA;
549                 }
550             } else if (num_samples[c] <= min_channel_len) {
551                 if (num_samples[c] < min_channel_len) {
552                     channels_for_cur_subframe = 0;
553                     min_channel_len = num_samples[c];
554                 }
555                 ++channels_for_cur_subframe;
556             }
557         }
558     } while (min_channel_len < s->samples_per_frame);
559
560     for (c = 0; c < s->num_channels; c++) {
561         int i;
562         int offset = 0;
563         for (i = 0; i < s->channel[c].num_subframes; i++) {
564             s->channel[c].subframe_offset[i] = offset;
565             offset += s->channel[c].subframe_len[i];
566         }
567     }
568
569     return 0;
570 }
571
572
573 static int my_log2(unsigned int i)
574 {
575     unsigned int iLog2 = 0;
576     while ((i >> iLog2) > 1)
577         iLog2++;
578     return iLog2;
579 }
580
581
582 /**
583  *
584  */
585 static void decode_ac_filter(WmallDecodeCtx *s)
586 {
587     int i;
588     s->acfilter_order = get_bits(&s->gb, 4) + 1;
589     s->acfilter_scaling = get_bits(&s->gb, 4);
590
591     for(i = 0; i < s->acfilter_order; i++) {
592         s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
593     }
594 }
595
596
597 /**
598  *
599  */
600 static void decode_mclms(WmallDecodeCtx *s)
601 {
602     s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
603     s->mclms_scaling = get_bits(&s->gb, 4);
604     if(get_bits1(&s->gb)) {
605         // mclms_send_coef
606         int i;
607         int send_coef_bits;
608         int cbits = av_log2(s->mclms_scaling + 1);
609         assert(cbits == my_log2(s->mclms_scaling + 1));
610         if(1 << cbits < s->mclms_scaling + 1)
611             cbits++;
612
613         send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
614
615         for(i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++) {
616             s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
617         }
618
619         for(i = 0; i < s->num_channels; i++) {
620             int c;
621             for(c = 0; c < i; c++) {
622                 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
623             }
624         }
625     }
626 }
627
628
629 /**
630  *
631  */
632 static void decode_cdlms(WmallDecodeCtx *s)
633 {
634     int c, i;
635     int cdlms_send_coef = get_bits1(&s->gb);
636
637     for(c = 0; c < s->num_channels; c++) {
638         s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
639         for(i = 0; i < s->cdlms_ttl[c]; i++) {
640             s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
641         }
642
643         for(i = 0; i < s->cdlms_ttl[c]; i++) {
644             s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
645         }
646
647         if(cdlms_send_coef) {
648             for(i = 0; i < s->cdlms_ttl[c]; i++) {
649                 int cbits, shift_l, shift_r, j;
650                 cbits = av_log2(s->cdlms[c][i].order);
651                 if(1 << cbits < s->cdlms[c][i].order)
652                     cbits++;
653                 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
654
655                 cbits = av_log2(s->cdlms[c][i].scaling + 1);
656                 if(1 << cbits < s->cdlms[c][i].scaling + 1)
657                     cbits++;
658
659                 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
660                 shift_l = 32 - s->cdlms[c][i].bitsend;
661                 shift_r = 32 - 2 - s->cdlms[c][i].scaling;
662                 for(j = 0; j < s->cdlms[c][i].coefsend; j++) {
663                     s->cdlms[c][i].coefs[j] =
664                         (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
665                 }
666             }
667         }
668     }
669 }
670
671 /**
672  *
673  */
674 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
675 {
676     int i = 0;
677     unsigned int ave_mean;
678     s->transient[ch] = get_bits1(&s->gb);
679     if(s->transient[ch]) {
680             s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
681         if (s->transient_pos[ch])
682                 s->transient[ch] = 0;
683             s->channel[ch].transient_counter =
684                 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
685         } else if (s->channel[ch].transient_counter)
686             s->transient[ch] = 1;
687
688     if(s->seekable_tile) {
689         ave_mean = get_bits(&s->gb, s->bits_per_sample);
690         s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
691 //        s->ave_sum[ch] *= 2;
692     }
693
694     if(s->seekable_tile) {
695         if(s->do_inter_ch_decorr)
696             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
697         else
698             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
699         i++;
700     }
701     //av_log(0, 0, "%8d: ", num_logged_tiles++);
702     for(; i < tile_size; i++) {
703         int quo = 0, rem, rem_bits, residue;
704         while(get_bits1(&s->gb))
705             quo++;
706         if(quo >= 32)
707             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
708
709                ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
710         rem_bits = av_ceil_log2(ave_mean);
711         rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
712         residue = (quo << rem_bits) + rem;
713
714         s->ave_sum[ch] = residue + s->ave_sum[ch] - (s->ave_sum[ch] >> s->movave_scaling);
715
716         if(residue & 1)
717             residue = -(residue >> 1) - 1;
718         else
719             residue = residue >> 1;
720         s->channel_residues[ch][i] = residue;
721     }
722     dump_int_buffer(s->channel_residues[ch], 4, tile_size, 16);
723
724     return 0;
725
726 }
727
728
729 /**
730  *
731  */
732 static void
733 decode_lpc(WmallDecodeCtx *s)
734 {
735     int ch, i, cbits;
736     s->lpc_order = get_bits(&s->gb, 5) + 1;
737     s->lpc_scaling = get_bits(&s->gb, 4);
738     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
739     cbits = s->lpc_scaling + s->lpc_intbits;
740     for(ch = 0; ch < s->num_channels; ch++) {
741         for(i = 0; i < s->lpc_order; i++) {
742             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
743         }
744     }
745 }
746
747
748 static void clear_codec_buffers(WmallDecodeCtx *s)
749 {
750     int ich, ilms;
751
752     memset(s->acfilter_coeffs, 0,     16 * sizeof(int));
753     memset(s->lpc_coefs      , 0, 40 * 2 * sizeof(int));
754
755     memset(s->mclms_coeffs    , 0, 128 * sizeof(int16_t));
756     memset(s->mclms_coeffs_cur, 0,   4 * sizeof(int16_t));
757     memset(s->mclms_prevvalues, 0,  64 * sizeof(int));
758     memset(s->mclms_updates   , 0,  64 * sizeof(int16_t));
759
760     for (ich = 0; ich < s->num_channels; ich++) {
761         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
762             memset(s->cdlms[ich][ilms].coefs         , 0, 256 * sizeof(int16_t));
763             memset(s->cdlms[ich][ilms].lms_prevvalues, 0, 512 * sizeof(int16_t));
764             memset(s->cdlms[ich][ilms].lms_updates   , 0, 512 * sizeof(int16_t));
765         }
766         s->ave_sum[ich] = 0;
767     }
768 }
769
770 /**
771  *@brief Resets filter parameters and transient area at new seekable tile
772  */
773 static void reset_codec(WmallDecodeCtx *s)
774 {
775     int ich, ilms;
776     s->mclms_recent = s->mclms_order * s->num_channels;
777     for (ich = 0; ich < s->num_channels; ich++) {
778         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
779             s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
780         /* first sample of a seekable subframe is considered as the starting of
781            a transient area which is samples_per_frame samples long */
782         s->channel[ich].transient_counter = s->samples_per_frame;
783         s->transient[ich] = 1;
784         s->transient_pos[ich] = 0;
785     }
786 }
787
788
789
790 static void mclms_update(WmallDecodeCtx *s, int icoef)
791 {
792     int i, j, ich;
793     int16_t pred_error;
794     int order = s->mclms_order;
795     int num_channels = s->num_channels;
796     int16_t range = 1 << (s->bits_per_sample - 1);
797     int bps = s->bits_per_sample > 16 ? 4 : 2; // bytes per sample
798
799     for (ich = 0; ich < num_channels; ich++) {
800         pred_error = s->channel_coeffs[ich][icoef] -
801                      s->channel_residues[ich][icoef];
802         if (pred_error > 0) {
803             for (i = 0; i < order * num_channels; i++)
804                 s->mclms_coeffs[i + ich * order * num_channels] +=
805                     s->mclms_updates[s->mclms_recent + i];
806             for (j = 0; j < i; j++) {
807                 if (s->channel_coeffs[ich][icoef] > 0)
808                     s->mclms_coeffs_cur[ich * num_channels + j] += 1;
809                 else if (s->channel_coeffs[ich][icoef] < 0)
810                     s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
811             }
812         } else if (pred_error < 0) {
813             for (i = 0; i < order * num_channels; i++)
814                 s->mclms_coeffs[i + ich * order * num_channels] -=
815                     s->mclms_updates[s->mclms_recent + i];
816             for (j = 0; j < i; j++) {
817                 if (s->channel_coeffs[ich][icoef] > 0)
818                     s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
819                 else if (s->channel_coeffs[ich][icoef] < 0)
820                     s->mclms_coeffs_cur[ich * num_channels + j] += 1;
821             }
822         }
823     }
824
825     for (ich = num_channels - 1; ich >= 0; ich--) {
826         s->mclms_recent--;
827         if (s->channel_coeffs[ich][icoef] > range - 1)
828             s->mclms_prevvalues[s->mclms_recent] = range - 1;
829         else if (s->channel_coeffs[ich][icoef] <= -range)
830             s->mclms_prevvalues[s->mclms_recent] = -range;
831
832         s->mclms_updates[s->mclms_recent] =
833             av_clip(-1, s->channel_coeffs[ich][icoef], 1);
834     }
835
836     if (s->mclms_recent == 0) {
837         memcpy(&s->mclms_prevvalues[order * num_channels],
838                s->mclms_prevvalues,
839                bps * order * num_channels);
840         memcpy(&s->mclms_updates[order * num_channels],
841                s->mclms_updates,
842                bps * order * num_channels);
843         s->mclms_recent = num_channels * order;
844     }
845 }
846 static void mclms_predict(WmallDecodeCtx *s, int icoef)
847 {
848     int ich, i;
849     int16_t pred;
850     int order = s->mclms_order;
851     int num_channels = s->num_channels;
852
853     for (ich = 0; ich < num_channels; ich++) {
854         if (!s->is_channel_coded[ich])
855             continue;
856         pred = 0;
857         for (i = 0; i < order * num_channels; i++)
858             pred += s->mclms_prevvalues[i] *
859                     s->mclms_coeffs[i + order * num_channels * ich];
860         for (i = 0; i < ich; i++)
861             pred += s->channel_coeffs[ich][icoef] *
862                     s->mclms_coeffs_cur[i + order * num_channels * ich];
863         s->channel_coeffs[ich][icoef] =
864                     s->channel_residues[ich][icoef] + pred;
865     }
866 }
867
868 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
869 {
870     int icoef;
871     for (icoef = 0; icoef < tile_size; icoef++) {
872         mclms_predict(s, icoef);
873         mclms_update(s, icoef);
874     }
875 }
876
877 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
878 {
879     int pred = 0;
880     int icoef;
881     int recent = s->cdlms[ich][ilms].recent;
882
883     for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
884         pred += s->cdlms[ich][ilms].coefs[icoef] *
885                     s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
886
887     //pred += (1 << (s->cdlms[ich][ilms].scaling - 1));
888     /* XXX: Table 29 has:
889             iPred >= cdlms[iCh][ilms].scaling;
890        seems to me like a missing > */
891     //pred >>= s->cdlms[ich][ilms].scaling;
892     return pred;
893 }
894
895 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input, int residue)
896 {
897     int icoef;
898     int recent = s->cdlms[ich][ilms].recent;
899     int range = 1 << s->bits_per_sample - 1;
900     int bps = s->bits_per_sample > 16 ? 4 : 2; // bytes per sample
901
902     if (residue < 0) {
903         for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
904             s->cdlms[ich][ilms].coefs[icoef] -=
905                 s->cdlms[ich][ilms].lms_updates[icoef + recent];
906     } else if (residue > 0) {
907         for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
908             s->cdlms[ich][ilms].coefs[icoef] +=
909                 s->cdlms[ich][ilms].lms_updates[icoef + recent];    /* spec mistakenly
910                                                                     dropped the recent */
911     }
912
913     if (recent)
914         recent--;
915     else {
916         /* XXX: This memcpy()s will probably fail if a fixed 32-bit buffer is used.
917                 follow kshishkov's suggestion of using a union. */
918         memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
919                s->cdlms[ich][ilms].lms_prevvalues,
920                bps * s->cdlms[ich][ilms].order);
921         memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
922                s->cdlms[ich][ilms].lms_updates,
923                bps * s->cdlms[ich][ilms].order);
924         recent = s->cdlms[ich][ilms].order - 1;
925     }
926
927     s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
928     if (!input)
929         s->cdlms[ich][ilms].lms_updates[recent] = 0;
930     else if (input < 0)
931         s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
932     else
933         s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
934
935     /* XXX: spec says:
936     cdlms[iCh][ilms].updates[iRecent + cdlms[iCh][ilms].order >> 4] >>= 2;
937     lms_updates[iCh][ilms][iRecent + cdlms[iCh][ilms].order >> 3] >>= 1;
938
939         Questions is - are cdlms[iCh][ilms].updates[] and lms_updates[][][] two
940         seperate buffers? Here I've assumed that the two are same which makes
941         more sense to me.
942     */
943     s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
944     s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
945     s->cdlms[ich][ilms].recent = recent;
946 }
947
948 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
949 {
950     int ilms, recent, icoef;
951     s->update_speed[ich] = 16;
952     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
953         recent = s->cdlms[ich][ilms].recent;
954         if (s->bV3RTM) {
955             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
956                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
957         } else {
958             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
959                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
960         }
961     }
962 }
963
964 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
965 {
966     int ilms, recent, icoef;
967     s->update_speed[ich] = 8;
968     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
969         recent = s->cdlms[ich][ilms].recent;
970         if (s->bV3RTM) {
971             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
972                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
973         } else {
974             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
975                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
976         }
977     }
978 }
979
980 static void revert_cdlms(WmallDecodeCtx *s, int ch, int coef_begin, int coef_end)
981 {
982     int icoef;
983     int pred;
984     int ilms, num_lms;
985     int residue, input;
986
987     num_lms = s->cdlms_ttl[ch];
988     for (ilms = num_lms - 1; ilms >= 0; ilms--) {
989         //s->cdlms[ch][ilms].recent = s->cdlms[ch][ilms].order;
990         for (icoef = coef_begin; icoef < coef_end; icoef++) {
991             pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
992             residue = s->channel_residues[ch][icoef];
993             pred += lms_predict(s, ch, ilms);
994             input = residue + (pred >> s->cdlms[ch][ilms].scaling);
995             lms_update(s, ch, ilms, input, residue);
996             s->channel_residues[ch][icoef] = input;
997         }
998     }
999 }
1000
1001
1002
1003 /**
1004  *@brief Decode a single subframe (block).
1005  *@param s codec context
1006  *@return 0 on success, < 0 when decoding failed
1007  */
1008 static int decode_subframe(WmallDecodeCtx *s)
1009 {
1010     int offset = s->samples_per_frame;
1011     int subframe_len = s->samples_per_frame;
1012     int i;
1013     int total_samples   = s->samples_per_frame * s->num_channels;
1014     int rawpcm_tile;
1015     int padding_zeroes;
1016
1017     s->subframe_offset = get_bits_count(&s->gb);
1018
1019     /** reset channel context and find the next block offset and size
1020         == the next block of the channel with the smallest number of
1021         decoded samples
1022     */
1023     for (i = 0; i < s->num_channels; i++) {
1024         s->channel[i].grouped = 0;
1025         if (offset > s->channel[i].decoded_samples) {
1026             offset = s->channel[i].decoded_samples;
1027             subframe_len =
1028                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1029         }
1030     }
1031
1032     /** get a list of all channels that contain the estimated block */
1033     s->channels_for_cur_subframe = 0;
1034     for (i = 0; i < s->num_channels; i++) {
1035         const int cur_subframe = s->channel[i].cur_subframe;
1036         /** substract already processed samples */
1037         total_samples -= s->channel[i].decoded_samples;
1038
1039         /** and count if there are multiple subframes that match our profile */
1040         if (offset == s->channel[i].decoded_samples &&
1041             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1042             total_samples -= s->channel[i].subframe_len[cur_subframe];
1043             s->channel[i].decoded_samples +=
1044                 s->channel[i].subframe_len[cur_subframe];
1045             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1046             ++s->channels_for_cur_subframe;
1047         }
1048     }
1049
1050     /** check if the frame will be complete after processing the
1051         estimated block */
1052     if (!total_samples)
1053         s->parsed_all_subframes = 1;
1054
1055
1056     s->seekable_tile = get_bits1(&s->gb);
1057     if(s->seekable_tile) {
1058         clear_codec_buffers(s);
1059
1060         s->do_arith_coding    = get_bits1(&s->gb);
1061         if(s->do_arith_coding) {
1062             dprintf(s->avctx, "do_arith_coding == 1");
1063             abort();
1064         }
1065         s->do_ac_filter       = get_bits1(&s->gb);
1066         s->do_inter_ch_decorr = get_bits1(&s->gb);
1067         s->do_mclms           = get_bits1(&s->gb);
1068
1069         if(s->do_ac_filter)
1070             decode_ac_filter(s);
1071
1072         if(s->do_mclms)
1073             decode_mclms(s);
1074
1075         decode_cdlms(s);
1076         s->movave_scaling = get_bits(&s->gb, 3);
1077         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
1078
1079             reset_codec(s);
1080     }
1081
1082     rawpcm_tile = get_bits1(&s->gb);
1083
1084     for(i = 0; i < s->num_channels; i++) {
1085         s->is_channel_coded[i] = 1;
1086     }
1087
1088     if(!rawpcm_tile) {
1089
1090         for(i = 0; i < s->num_channels; i++) {
1091             s->is_channel_coded[i] = get_bits1(&s->gb);
1092         }
1093
1094         if(s->bV3RTM) {
1095             // LPC
1096             s->do_lpc = get_bits1(&s->gb);
1097             if(s->do_lpc) {
1098                 decode_lpc(s);
1099             }
1100         } else {
1101             s->do_lpc = 0;
1102         }
1103     }
1104
1105
1106     if(get_bits1(&s->gb)) {
1107         padding_zeroes = get_bits(&s->gb, 5);
1108     } else {
1109         padding_zeroes = 0;
1110     }
1111
1112     if(rawpcm_tile) {
1113
1114         int bits = s->bits_per_sample - padding_zeroes;
1115         int j;
1116         dprintf(s->avctx, "RAWPCM %d bits per sample. total %d bits, remain=%d\n", bits,
1117                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
1118         for(i = 0; i < s->num_channels; i++) {
1119             for(j = 0; j < subframe_len; j++) {
1120                 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
1121 //                dprintf(s->avctx, "PCM[%d][%d] = 0x%04x\n", i, j, s->channel_coeffs[i][j]);
1122             }
1123         }
1124     } else {
1125         for(i = 0; i < s->num_channels; i++)
1126             if(s->is_channel_coded[i]) {
1127             decode_channel_residues(s, i, subframe_len);
1128             if (s->seekable_tile)
1129                 use_high_update_speed(s, i);
1130             else
1131                 use_normal_update_speed(s, i);
1132             revert_cdlms(s, i, 0, subframe_len);
1133         }
1134     }
1135
1136     /** handled one subframe */
1137
1138     for (i = 0; i < s->channels_for_cur_subframe; i++) {
1139         int c = s->channel_indexes_for_cur_subframe[i];
1140         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1141             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1142             return AVERROR_INVALIDDATA;
1143         }
1144         ++s->channel[c].cur_subframe;
1145     }
1146     num_logged_subframes++;
1147     return 0;
1148 }
1149
1150 /**
1151  *@brief Decode one WMA frame.
1152  *@param s codec context
1153  *@return 0 if the trailer bit indicates that this is the last frame,
1154  *        1 if there are additional frames
1155  */
1156 static int decode_frame(WmallDecodeCtx *s)
1157 {
1158     GetBitContext* gb = &s->gb;
1159     int more_frames = 0;
1160     int len = 0;
1161     int i;
1162
1163     /** check for potential output buffer overflow */
1164     if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1165         /** return an error if no frame could be decoded at all */
1166         av_log(s->avctx, AV_LOG_ERROR,
1167                "not enough space for the output samples\n");
1168         s->packet_loss = 1;
1169         return 0;
1170     }
1171
1172     /** get frame length */
1173     if (s->len_prefix)
1174         len = get_bits(gb, s->log2_frame_size);
1175
1176     /** decode tile information */
1177     if (decode_tilehdr(s)) {
1178         s->packet_loss = 1;
1179         return 0;
1180     }
1181
1182     /** read drc info */
1183     if (s->dynamic_range_compression) {
1184         s->drc_gain = get_bits(gb, 8);
1185     }
1186
1187     /** no idea what these are for, might be the number of samples
1188         that need to be skipped at the beginning or end of a stream */
1189     if (get_bits1(gb)) {
1190         int skip;
1191
1192         /** usually true for the first frame */
1193         if (get_bits1(gb)) {
1194             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1195             dprintf(s->avctx, "start skip: %i\n", skip);
1196         }
1197
1198         /** sometimes true for the last frame */
1199         if (get_bits1(gb)) {
1200             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1201             dprintf(s->avctx, "end skip: %i\n", skip);
1202         }
1203
1204     }
1205
1206     /** reset subframe states */
1207     s->parsed_all_subframes = 0;
1208     for (i = 0; i < s->num_channels; i++) {
1209         s->channel[i].decoded_samples = 0;
1210         s->channel[i].cur_subframe    = 0;
1211         s->channel[i].reuse_sf        = 0;
1212     }
1213
1214     /** decode all subframes */
1215     while (!s->parsed_all_subframes) {
1216         if (decode_subframe(s) < 0) {
1217             s->packet_loss = 1;
1218             return 0;
1219         }
1220     }
1221
1222     dprintf(s->avctx, "Frame done\n");
1223
1224     if (s->skip_frame) {
1225         s->skip_frame = 0;
1226     } else
1227         s->samples += s->num_channels * s->samples_per_frame;
1228
1229     if (s->len_prefix) {
1230         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1231             /** FIXME: not sure if this is always an error */
1232             av_log(s->avctx, AV_LOG_ERROR,
1233                    "frame[%i] would have to skip %i bits\n", s->frame_num,
1234                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1235             s->packet_loss = 1;
1236             return 0;
1237         }
1238
1239         /** skip the rest of the frame data */
1240         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1241     } else {
1242 /*
1243         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1244             dprintf(s->avctx, "skip1\n");
1245         }
1246 */
1247     }
1248
1249     /** decode trailer bit */
1250     more_frames = get_bits1(gb);
1251     ++s->frame_num;
1252     return more_frames;
1253 }
1254
1255 /**
1256  *@brief Calculate remaining input buffer length.
1257  *@param s codec context
1258  *@param gb bitstream reader context
1259  *@return remaining size in bits
1260  */
1261 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1262 {
1263     return s->buf_bit_size - get_bits_count(gb);
1264 }
1265
1266 /**
1267  *@brief Fill the bit reservoir with a (partial) frame.
1268  *@param s codec context
1269  *@param gb bitstream reader context
1270  *@param len length of the partial frame
1271  *@param append decides wether to reset the buffer or not
1272  */
1273 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1274                       int append)
1275 {
1276     int buflen;
1277
1278     /** when the frame data does not need to be concatenated, the input buffer
1279         is resetted and additional bits from the previous frame are copyed
1280         and skipped later so that a fast byte copy is possible */
1281
1282     if (!append) {
1283         s->frame_offset = get_bits_count(gb) & 7;
1284         s->num_saved_bits = s->frame_offset;
1285         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1286     }
1287
1288     buflen = (s->num_saved_bits + len + 8) >> 3;
1289
1290     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1291         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1292         s->packet_loss = 1;
1293         return;
1294     }
1295
1296     s->num_saved_bits += len;
1297     if (!append) {
1298         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1299                      s->num_saved_bits);
1300     } else {
1301         int align = 8 - (get_bits_count(gb) & 7);
1302         align = FFMIN(align, len);
1303         put_bits(&s->pb, align, get_bits(gb, align));
1304         len -= align;
1305         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1306     }
1307     skip_bits_long(gb, len);
1308
1309     {
1310         PutBitContext tmp = s->pb;
1311         flush_put_bits(&tmp);
1312     }
1313
1314     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1315     skip_bits(&s->gb, s->frame_offset);
1316 }
1317
1318 /**
1319  *@brief Decode a single WMA packet.
1320  *@param avctx codec context
1321  *@param data the output buffer
1322  *@param data_size number of bytes that were written to the output buffer
1323  *@param avpkt input packet
1324  *@return number of bytes that were read from the input buffer
1325  */
1326 static int decode_packet(AVCodecContext *avctx,
1327                          void *data, int *data_size, AVPacket* avpkt)
1328 {
1329     WmallDecodeCtx *s = avctx->priv_data;
1330     GetBitContext* gb  = &s->pgb;
1331     const uint8_t* buf = avpkt->data;
1332     int buf_size       = avpkt->size;
1333     int num_bits_prev_frame;
1334     int packet_sequence_number;
1335
1336     s->samples       = data;
1337     s->samples_end   = (float*)((int8_t*)data + *data_size);
1338     *data_size = 0;
1339
1340     if (s->packet_done || s->packet_loss) {
1341         s->packet_done = 0;
1342
1343         /** sanity check for the buffer length */
1344         if (buf_size < avctx->block_align)
1345             return 0;
1346
1347         s->next_packet_start = buf_size - avctx->block_align;
1348         buf_size = avctx->block_align;
1349         s->buf_bit_size = buf_size << 3;
1350
1351         /** parse packet header */
1352         init_get_bits(gb, buf, s->buf_bit_size);
1353         packet_sequence_number = get_bits(gb, 4);
1354         int seekable_frame_in_packet = get_bits1(gb);
1355         int spliced_packet = get_bits1(gb);
1356
1357         /** get number of bits that need to be added to the previous frame */
1358         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1359
1360         /** check for packet loss */
1361         if (!s->packet_loss &&
1362             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1363             s->packet_loss = 1;
1364             av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1365                    s->packet_sequence_number, packet_sequence_number);
1366         }
1367         s->packet_sequence_number = packet_sequence_number;
1368
1369         if (num_bits_prev_frame > 0) {
1370             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1371             if (num_bits_prev_frame >= remaining_packet_bits) {
1372                 num_bits_prev_frame = remaining_packet_bits;
1373                 s->packet_done = 1;
1374             }
1375
1376             /** append the previous frame data to the remaining data from the
1377                 previous packet to create a full frame */
1378             save_bits(s, gb, num_bits_prev_frame, 1);
1379
1380             /** decode the cross packet frame if it is valid */
1381             if (!s->packet_loss)
1382                 decode_frame(s);
1383         } else if (s->num_saved_bits - s->frame_offset) {
1384             dprintf(avctx, "ignoring %x previously saved bits\n",
1385                     s->num_saved_bits - s->frame_offset);
1386         }
1387
1388         if (s->packet_loss) {
1389             /** reset number of saved bits so that the decoder
1390                 does not start to decode incomplete frames in the
1391                 s->len_prefix == 0 case */
1392             s->num_saved_bits = 0;
1393             s->packet_loss = 0;
1394         }
1395
1396     } else {
1397         int frame_size;
1398
1399         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1400         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1401         skip_bits(gb, s->packet_offset);
1402
1403         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1404             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1405             frame_size <= remaining_bits(s, gb)) {
1406             save_bits(s, gb, frame_size, 0);
1407             s->packet_done = !decode_frame(s);
1408         } else if (!s->len_prefix
1409                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1410             /** when the frames do not have a length prefix, we don't know
1411                 the compressed length of the individual frames
1412                 however, we know what part of a new packet belongs to the
1413                 previous frame
1414                 therefore we save the incoming packet first, then we append
1415                 the "previous frame" data from the next packet so that
1416                 we get a buffer that only contains full frames */
1417             s->packet_done = !decode_frame(s);
1418         } else {
1419             s->packet_done = 1;
1420         }
1421     }
1422
1423     if (s->packet_done && !s->packet_loss &&
1424         remaining_bits(s, gb) > 0) {
1425         /** save the rest of the data so that it can be decoded
1426             with the next packet */
1427         save_bits(s, gb, remaining_bits(s, gb), 0);
1428     }
1429
1430     *data_size = 0; // (int8_t *)s->samples - (int8_t *)data;
1431     s->packet_offset = get_bits_count(gb) & 7;
1432
1433     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1434 }
1435
1436 /**
1437  *@brief Clear decoder buffers (for seeking).
1438  *@param avctx codec context
1439  */
1440 static void flush(AVCodecContext *avctx)
1441 {
1442     WmallDecodeCtx *s = avctx->priv_data;
1443     int i;
1444     /** reset output buffer as a part of it is used during the windowing of a
1445         new frame */
1446     for (i = 0; i < s->num_channels; i++)
1447         memset(s->channel[i].out, 0, s->samples_per_frame *
1448                sizeof(*s->channel[i].out));
1449     s->packet_loss = 1;
1450 }
1451
1452
1453 /**
1454  *@brief wmall decoder
1455  */
1456 AVCodec ff_wmalossless_decoder = {
1457     "wmalossless",
1458     AVMEDIA_TYPE_AUDIO,
1459     CODEC_ID_WMALOSSLESS,
1460     sizeof(WmallDecodeCtx),
1461     decode_init,
1462     NULL,
1463     decode_end,
1464     decode_packet,
1465     .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_EXPERIMENTAL,
1466     .flush= flush,
1467     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Lossless"),
1468 };