Merge commit '36ef5369ee9b336febc2c270f8718cec4476cb85'
[ffmpeg.git] / libavcodec / wmalosslessdec.c
1 /*
2  * Windows Media Audio Lossless 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  * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 #include "libavutil/attributes.h"
26 #include "avcodec.h"
27 #include "internal.h"
28 #include "get_bits.h"
29 #include "put_bits.h"
30 #include "wma.h"
31 #include "wma_common.h"
32
33 /** current decoder limitations */
34 #define WMALL_MAX_CHANNELS      8                       ///< max number of handled channels
35 #define MAX_SUBFRAMES          32                       ///< max number of subframes per channel
36 #define MAX_BANDS              29                       ///< max number of scale factor bands
37 #define MAX_FRAMESIZE       32768                       ///< maximum compressed frame size
38 #define MAX_ORDER             256
39
40 #define WMALL_BLOCK_MIN_BITS    6                       ///< log2 of min block size
41 #define WMALL_BLOCK_MAX_BITS   12                       ///< log2 of max block size
42 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)    ///< maximum block size
43 #define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
44
45
46 /**
47  * @brief frame-specific decoder context for a single channel
48  */
49 typedef struct {
50     int16_t     prev_block_len;                         ///< length of the previous block
51     uint8_t     transmit_coefs;
52     uint8_t     num_subframes;
53     uint16_t    subframe_len[MAX_SUBFRAMES];            ///< subframe length in samples
54     uint16_t    subframe_offsets[MAX_SUBFRAMES];        ///< subframe positions in the current frame
55     uint8_t     cur_subframe;                           ///< current subframe number
56     uint16_t    decoded_samples;                        ///< number of already processed samples
57     int         quant_step;                             ///< quantization step for the current subframe
58     int         transient_counter;                      ///< number of transient samples from the beginning of the transient zone
59 } WmallChannelCtx;
60
61 /**
62  * @brief main decoder context
63  */
64 typedef struct WmallDecodeCtx {
65     /* generic decoder variables */
66     AVCodecContext  *avctx;
67     AVFrame         frame;
68     uint8_t         frame_data[MAX_FRAMESIZE + FF_INPUT_BUFFER_PADDING_SIZE];  ///< compressed frame data
69     PutBitContext   pb;                             ///< context for filling the frame_data buffer
70
71     /* frame size dependent frame information (set during initialization) */
72     uint32_t        decode_flags;                   ///< used compression features
73     int             len_prefix;                     ///< frame is prefixed with its length
74     int             dynamic_range_compression;      ///< frame contains DRC data
75     uint8_t         bits_per_sample;                ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
76     uint16_t        samples_per_frame;              ///< number of samples to output
77     uint16_t        log2_frame_size;
78     int8_t          num_channels;                   ///< number of channels in the stream (same as AVCodecContext.num_channels)
79     int8_t          lfe_channel;                    ///< lfe channel index
80     uint8_t         max_num_subframes;
81     uint8_t         subframe_len_bits;              ///< number of bits used for the subframe length
82     uint8_t         max_subframe_len_bit;           ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
83     uint16_t        min_samples_per_subframe;
84
85     /* packet decode state */
86     GetBitContext   pgb;                            ///< bitstream reader context for the packet
87     int             next_packet_start;              ///< start offset of the next WMA packet in the demuxer packet
88     uint8_t         packet_offset;                  ///< offset to the frame in the packet
89     uint8_t         packet_sequence_number;         ///< current packet number
90     int             num_saved_bits;                 ///< saved number of bits
91     int             frame_offset;                   ///< frame offset in the bit reservoir
92     int             subframe_offset;                ///< subframe offset in the bit reservoir
93     uint8_t         packet_loss;                    ///< set in case of bitstream error
94     uint8_t         packet_done;                    ///< set when a packet is fully decoded
95
96     /* frame decode state */
97     uint32_t        frame_num;                      ///< current frame number (not used for decoding)
98     GetBitContext   gb;                             ///< bitstream reader context
99     int             buf_bit_size;                   ///< buffer size in bits
100     int16_t         *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
101     int32_t         *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
102     uint8_t         drc_gain;                       ///< gain for the DRC tool
103     int8_t          skip_frame;                     ///< skip output step
104     int8_t          parsed_all_subframes;           ///< all subframes decoded?
105
106     /* subframe/block decode state */
107     int16_t         subframe_len;                   ///< current subframe length
108     int8_t          channels_for_cur_subframe;      ///< number of channels that contain the subframe
109     int8_t          channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
110
111     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
112
113     // WMA Lossless-specific
114
115     uint8_t do_arith_coding;
116     uint8_t do_ac_filter;
117     uint8_t do_inter_ch_decorr;
118     uint8_t do_mclms;
119     uint8_t do_lpc;
120
121     int8_t  acfilter_order;
122     int8_t  acfilter_scaling;
123     int64_t acfilter_coeffs[16];
124     int     acfilter_prevvalues[2][16];
125
126     int8_t  mclms_order;
127     int8_t  mclms_scaling;
128     int16_t mclms_coeffs[128];
129     int16_t mclms_coeffs_cur[4];
130     int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
131     int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
132     int     mclms_recent;
133
134     int     movave_scaling;
135     int     quant_stepsize;
136
137     struct {
138         int order;
139         int scaling;
140         int coefsend;
141         int bitsend;
142         int16_t coefs[MAX_ORDER];
143         int16_t lms_prevvalues[MAX_ORDER * 2];
144         int16_t lms_updates[MAX_ORDER * 2];
145         int recent;
146     } cdlms[2][9];
147
148     int cdlms_ttl[2];
149
150     int bV3RTM;
151
152     int is_channel_coded[2];
153     int update_speed[2];
154
155     int transient[2];
156     int transient_pos[2];
157     int seekable_tile;
158
159     int ave_sum[2];
160
161     int channel_residues[2][WMALL_BLOCK_MAX_SIZE];
162
163     int lpc_coefs[2][40];
164     int lpc_order;
165     int lpc_scaling;
166     int lpc_intbits;
167
168     int channel_coeffs[2][WMALL_BLOCK_MAX_SIZE];
169 } WmallDecodeCtx;
170
171
172 static av_cold int decode_init(AVCodecContext *avctx)
173 {
174     WmallDecodeCtx *s  = avctx->priv_data;
175     uint8_t *edata_ptr = avctx->extradata;
176     unsigned int channel_mask;
177     int i, bits, log2_max_num_subframes, num_possible_block_sizes;
178
179     s->avctx = avctx;
180     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
181
182     if (avctx->extradata_size >= 18) {
183         s->decode_flags    = AV_RL16(edata_ptr + 14);
184         channel_mask       = AV_RL32(edata_ptr +  2);
185         s->bits_per_sample = AV_RL16(edata_ptr);
186         if (s->bits_per_sample == 16)
187             avctx->sample_fmt = AV_SAMPLE_FMT_S16;
188         else if (s->bits_per_sample == 24) {
189             avctx->sample_fmt = AV_SAMPLE_FMT_S32;
190             av_log_missing_feature(avctx, "bit-depth higher than 16", 0);
191             return AVERROR_PATCHWELCOME;
192         } else {
193             av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %d\n",
194                    s->bits_per_sample);
195             return AVERROR_INVALIDDATA;
196         }
197         /* dump the extradata */
198         for (i = 0; i < avctx->extradata_size; i++)
199             av_dlog(avctx, "[%x] ", avctx->extradata[i]);
200         av_dlog(avctx, "\n");
201
202     } else {
203         av_log_ask_for_sample(avctx, "Unsupported extradata size\n");
204         return AVERROR_INVALIDDATA;
205     }
206
207     /* generic init */
208     s->log2_frame_size = av_log2(avctx->block_align) + 4;
209
210     /* frame info */
211     s->skip_frame  = 1; /* skip first frame */
212     s->packet_loss = 1;
213     s->len_prefix  = s->decode_flags & 0x40;
214
215     /* get frame len */
216     bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
217     if (bits > WMALL_BLOCK_MAX_BITS) {
218         av_log_missing_feature(avctx, "big-bits block sizes", 1);
219         return AVERROR_INVALIDDATA;
220     }
221     s->samples_per_frame = 1 << bits;
222
223     /* init previous block len */
224     for (i = 0; i < avctx->channels; i++)
225         s->channel[i].prev_block_len = s->samples_per_frame;
226
227     /* subframe info */
228     log2_max_num_subframes  = (s->decode_flags & 0x38) >> 3;
229     s->max_num_subframes    = 1 << log2_max_num_subframes;
230     s->max_subframe_len_bit = 0;
231     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
232
233     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
234     s->dynamic_range_compression = s->decode_flags & 0x80;
235     s->bV3RTM                    = s->decode_flags & 0x100;
236
237     if (s->max_num_subframes > MAX_SUBFRAMES) {
238         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
239                s->max_num_subframes);
240         return AVERROR_INVALIDDATA;
241     }
242
243     s->num_channels = avctx->channels;
244
245     /* extract lfe channel position */
246     s->lfe_channel = -1;
247
248     if (channel_mask & 8) {
249         unsigned int mask;
250         for (mask = 1; mask < 16; mask <<= 1)
251             if (channel_mask & mask)
252                 ++s->lfe_channel;
253     }
254
255     if (s->num_channels < 0) {
256         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
257                s->num_channels);
258         return AVERROR_INVALIDDATA;
259     } else if (s->num_channels > WMALL_MAX_CHANNELS) {
260         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
261         return AVERROR_PATCHWELCOME;
262     }
263
264     avcodec_get_frame_defaults(&s->frame);
265     avctx->coded_frame    = &s->frame;
266     avctx->channel_layout = channel_mask;
267     return 0;
268 }
269
270 /**
271  * @brief Decode the subframe length.
272  * @param s      context
273  * @param offset sample offset in the frame
274  * @return decoded subframe length on success, < 0 in case of an error
275  */
276 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
277 {
278     int frame_len_ratio, subframe_len, len;
279
280     /* no need to read from the bitstream when only one length is possible */
281     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
282         return s->min_samples_per_subframe;
283
284     len             = av_log2(s->max_num_subframes - 1) + 1;
285     frame_len_ratio = get_bits(&s->gb, len);
286     subframe_len    = s->min_samples_per_subframe * (frame_len_ratio + 1);
287
288     /* sanity check the length */
289     if (subframe_len < s->min_samples_per_subframe ||
290         subframe_len > s->samples_per_frame) {
291         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
292                subframe_len);
293         return AVERROR_INVALIDDATA;
294     }
295     return subframe_len;
296 }
297
298 /**
299  * @brief Decode how the data in the frame is split into subframes.
300  *       Every WMA frame contains the encoded data for a fixed number of
301  *       samples per channel. The data for every channel might be split
302  *       into several subframes. This function will reconstruct the list of
303  *       subframes for every channel.
304  *
305  *       If the subframes are not evenly split, the algorithm estimates the
306  *       channels with the lowest number of total samples.
307  *       Afterwards, for each of these channels a bit is read from the
308  *       bitstream that indicates if the channel contains a subframe with the
309  *       next subframe size that is going to be read from the bitstream or not.
310  *       If a channel contains such a subframe, the subframe size gets added to
311  *       the channel's subframe list.
312  *       The algorithm repeats these steps until the frame is properly divided
313  *       between the individual channels.
314  *
315  * @param s context
316  * @return 0 on success, < 0 in case of an error
317  */
318 static int decode_tilehdr(WmallDecodeCtx *s)
319 {
320     uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
321     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];   /* flag indicating if a channel contains the current subframe */
322     int channels_for_cur_subframe = s->num_channels;  /* number of channels that contain the current subframe */
323     int fixed_channel_layout = 0;                     /* flag indicating that all channels use the same subfra2me offsets and sizes */
324     int min_channel_len = 0;                          /* smallest sum of samples (channels with this length will be processed first) */
325     int c, tile_aligned;
326
327     /* reset tiling information */
328     for (c = 0; c < s->num_channels; c++)
329         s->channel[c].num_subframes = 0;
330
331     tile_aligned = get_bits1(&s->gb);
332     if (s->max_num_subframes == 1 || tile_aligned)
333         fixed_channel_layout = 1;
334
335     /* loop until the frame data is split between the subframes */
336     do {
337         int subframe_len, in_use = 0;
338
339         /* check which channels contain the subframe */
340         for (c = 0; c < s->num_channels; c++) {
341             if (num_samples[c] == min_channel_len) {
342                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
343                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
344                     contains_subframe[c] = in_use = 1;
345                 } else {
346                     if (get_bits1(&s->gb))
347                         contains_subframe[c] = in_use = 1;
348                 }
349             } else
350                 contains_subframe[c] = 0;
351         }
352
353         if (!in_use) {
354             av_log(s->avctx, AV_LOG_ERROR,
355                    "Found empty subframe\n");
356             return AVERROR_INVALIDDATA;
357         }
358
359         /* get subframe length, subframe_len == 0 is not allowed */
360         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
361             return AVERROR_INVALIDDATA;
362         /* add subframes to the individual channels and find new min_channel_len */
363         min_channel_len += subframe_len;
364         for (c = 0; c < s->num_channels; c++) {
365             WmallChannelCtx *chan = &s->channel[c];
366
367             if (contains_subframe[c]) {
368                 if (chan->num_subframes >= MAX_SUBFRAMES) {
369                     av_log(s->avctx, AV_LOG_ERROR,
370                            "broken frame: num subframes > 31\n");
371                     return AVERROR_INVALIDDATA;
372                 }
373                 chan->subframe_len[chan->num_subframes] = subframe_len;
374                 num_samples[c] += subframe_len;
375                 ++chan->num_subframes;
376                 if (num_samples[c] > s->samples_per_frame) {
377                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
378                            "channel len(%d) > samples_per_frame(%d)\n",
379                            num_samples[c], s->samples_per_frame);
380                     return AVERROR_INVALIDDATA;
381                 }
382             } else if (num_samples[c] <= min_channel_len) {
383                 if (num_samples[c] < min_channel_len) {
384                     channels_for_cur_subframe = 0;
385                     min_channel_len = num_samples[c];
386                 }
387                 ++channels_for_cur_subframe;
388             }
389         }
390     } while (min_channel_len < s->samples_per_frame);
391
392     for (c = 0; c < s->num_channels; c++) {
393         int i, offset = 0;
394         for (i = 0; i < s->channel[c].num_subframes; i++) {
395             s->channel[c].subframe_offsets[i] = offset;
396             offset += s->channel[c].subframe_len[i];
397         }
398     }
399
400     return 0;
401 }
402
403 static void decode_ac_filter(WmallDecodeCtx *s)
404 {
405     int i;
406     s->acfilter_order   = get_bits(&s->gb, 4) + 1;
407     s->acfilter_scaling = get_bits(&s->gb, 4);
408
409     for (i = 0; i < s->acfilter_order; i++)
410         s->acfilter_coeffs[i] = (s->acfilter_scaling ? get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
411 }
412
413 static void decode_mclms(WmallDecodeCtx *s)
414 {
415     s->mclms_order   = (get_bits(&s->gb, 4) + 1) * 2;
416     s->mclms_scaling = get_bits(&s->gb, 4);
417     if (get_bits1(&s->gb)) {
418         int i, send_coef_bits;
419         int cbits = av_log2(s->mclms_scaling + 1);
420         if (1 << cbits < s->mclms_scaling + 1)
421             cbits++;
422
423         send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
424
425         for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
426             s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
427
428         for (i = 0; i < s->num_channels; i++) {
429             int c;
430             for (c = 0; c < i; c++)
431                 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
432         }
433     }
434 }
435
436 static int decode_cdlms(WmallDecodeCtx *s)
437 {
438     int c, i;
439     int cdlms_send_coef = get_bits1(&s->gb);
440
441     for (c = 0; c < s->num_channels; c++) {
442         s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
443         for (i = 0; i < s->cdlms_ttl[c]; i++) {
444             s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
445             if (s->cdlms[c][i].order > MAX_ORDER) {
446                 av_log(s->avctx, AV_LOG_ERROR,
447                        "Order[%d][%d] %d > max (%d), not supported\n",
448                        c, i, s->cdlms[c][i].order, MAX_ORDER);
449                 s->cdlms[0][0].order = 0;
450                 return AVERROR_INVALIDDATA;
451             }
452         }
453
454         for (i = 0; i < s->cdlms_ttl[c]; i++)
455             s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
456
457         if (cdlms_send_coef) {
458             for (i = 0; i < s->cdlms_ttl[c]; i++) {
459                 int cbits, shift_l, shift_r, j;
460                 cbits = av_log2(s->cdlms[c][i].order);
461                 if ((1 << cbits) < s->cdlms[c][i].order)
462                     cbits++;
463                 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
464
465                 cbits = av_log2(s->cdlms[c][i].scaling + 1);
466                 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
467                     cbits++;
468
469                 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
470                 shift_l = 32 - s->cdlms[c][i].bitsend;
471                 shift_r = 32 - s->cdlms[c][i].scaling - 2;
472                 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
473                     s->cdlms[c][i].coefs[j] =
474                         (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
475             }
476         }
477     }
478
479     return 0;
480 }
481
482 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
483 {
484     int i = 0;
485     unsigned int ave_mean;
486     s->transient[ch] = get_bits1(&s->gb);
487     if (s->transient[ch]) {
488         s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
489         if (s->transient_pos[ch])
490             s->transient[ch] = 0;
491         s->channel[ch].transient_counter =
492             FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
493     } else if (s->channel[ch].transient_counter)
494         s->transient[ch] = 1;
495
496     if (s->seekable_tile) {
497         ave_mean = get_bits(&s->gb, s->bits_per_sample);
498         s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
499     }
500
501     if (s->seekable_tile) {
502         if (s->do_inter_ch_decorr)
503             s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
504         else
505             s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
506         i++;
507     }
508     for (; i < tile_size; i++) {
509         int quo = 0, rem, rem_bits, residue;
510         while(get_bits1(&s->gb)) {
511             quo++;
512             if (get_bits_left(&s->gb) <= 0)
513                 return -1;
514         }
515         if (quo >= 32)
516             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
517
518         ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
519         if (ave_mean <= 1)
520             residue = quo;
521         else {
522             rem_bits = av_ceil_log2(ave_mean);
523             rem      = get_bits_long(&s->gb, rem_bits);
524             residue  = (quo << rem_bits) + rem;
525         }
526
527         s->ave_sum[ch] = residue + s->ave_sum[ch] -
528                          (s->ave_sum[ch] >> s->movave_scaling);
529
530         if (residue & 1)
531             residue = -(residue >> 1) - 1;
532         else
533             residue = residue >> 1;
534         s->channel_residues[ch][i] = residue;
535     }
536
537     return 0;
538
539 }
540
541 static void decode_lpc(WmallDecodeCtx *s)
542 {
543     int ch, i, cbits;
544     s->lpc_order   = get_bits(&s->gb, 5) + 1;
545     s->lpc_scaling = get_bits(&s->gb, 4);
546     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
547     cbits = s->lpc_scaling + s->lpc_intbits;
548     for (ch = 0; ch < s->num_channels; ch++)
549         for (i = 0; i < s->lpc_order; i++)
550             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
551 }
552
553 static void clear_codec_buffers(WmallDecodeCtx *s)
554 {
555     int ich, ilms;
556
557     memset(s->acfilter_coeffs,     0, sizeof(s->acfilter_coeffs));
558     memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
559     memset(s->lpc_coefs,           0, sizeof(s->lpc_coefs));
560
561     memset(s->mclms_coeffs,     0, sizeof(s->mclms_coeffs));
562     memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
563     memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
564     memset(s->mclms_updates,    0, sizeof(s->mclms_updates));
565
566     for (ich = 0; ich < s->num_channels; ich++) {
567         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
568             memset(s->cdlms[ich][ilms].coefs, 0,
569                    sizeof(s->cdlms[ich][ilms].coefs));
570             memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
571                    sizeof(s->cdlms[ich][ilms].lms_prevvalues));
572             memset(s->cdlms[ich][ilms].lms_updates, 0,
573                    sizeof(s->cdlms[ich][ilms].lms_updates));
574         }
575         s->ave_sum[ich] = 0;
576     }
577 }
578
579 /**
580  * @brief Reset filter parameters and transient area at new seekable tile.
581  */
582 static void reset_codec(WmallDecodeCtx *s)
583 {
584     int ich, ilms;
585     s->mclms_recent = s->mclms_order * s->num_channels;
586     for (ich = 0; ich < s->num_channels; ich++) {
587         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
588             s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
589         /* first sample of a seekable subframe is considered as the starting of
590             a transient area which is samples_per_frame samples long */
591         s->channel[ich].transient_counter = s->samples_per_frame;
592         s->transient[ich]     = 1;
593         s->transient_pos[ich] = 0;
594     }
595 }
596
597 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
598 {
599     int i, j, ich, pred_error;
600     int order        = s->mclms_order;
601     int num_channels = s->num_channels;
602     int range        = 1 << (s->bits_per_sample - 1);
603
604     for (ich = 0; ich < num_channels; ich++) {
605         pred_error = s->channel_residues[ich][icoef] - pred[ich];
606         if (pred_error > 0) {
607             for (i = 0; i < order * num_channels; i++)
608                 s->mclms_coeffs[i + ich * order * num_channels] +=
609                     s->mclms_updates[s->mclms_recent + i];
610             for (j = 0; j < ich; j++) {
611                 if (s->channel_residues[j][icoef] > 0)
612                     s->mclms_coeffs_cur[ich * num_channels + j] += 1;
613                 else if (s->channel_residues[j][icoef] < 0)
614                     s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
615             }
616         } else if (pred_error < 0) {
617             for (i = 0; i < order * num_channels; i++)
618                 s->mclms_coeffs[i + ich * order * num_channels] -=
619                     s->mclms_updates[s->mclms_recent + i];
620             for (j = 0; j < ich; j++) {
621                 if (s->channel_residues[j][icoef] > 0)
622                     s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
623                 else if (s->channel_residues[j][icoef] < 0)
624                     s->mclms_coeffs_cur[ich * num_channels + j] += 1;
625             }
626         }
627     }
628
629     for (ich = num_channels - 1; ich >= 0; ich--) {
630         s->mclms_recent--;
631         s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
632         if (s->channel_residues[ich][icoef] > range - 1)
633             s->mclms_prevvalues[s->mclms_recent] = range - 1;
634         else if (s->channel_residues[ich][icoef] < -range)
635             s->mclms_prevvalues[s->mclms_recent] = -range;
636
637         s->mclms_updates[s->mclms_recent] = 0;
638         if (s->channel_residues[ich][icoef] > 0)
639             s->mclms_updates[s->mclms_recent] = 1;
640         else if (s->channel_residues[ich][icoef] < 0)
641             s->mclms_updates[s->mclms_recent] = -1;
642     }
643
644     if (s->mclms_recent == 0) {
645         memcpy(&s->mclms_prevvalues[order * num_channels],
646                s->mclms_prevvalues,
647                2 * order * num_channels);
648         memcpy(&s->mclms_updates[order * num_channels],
649                s->mclms_updates,
650                2 * order * num_channels);
651         s->mclms_recent = num_channels * order;
652     }
653 }
654
655 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
656 {
657     int ich, i;
658     int order        = s->mclms_order;
659     int num_channels = s->num_channels;
660
661     for (ich = 0; ich < num_channels; ich++) {
662         pred[ich] = 0;
663         if (!s->is_channel_coded[ich])
664             continue;
665         for (i = 0; i < order * num_channels; i++)
666             pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
667                          s->mclms_coeffs[i + order * num_channels * ich];
668         for (i = 0; i < ich; i++)
669             pred[ich] += s->channel_residues[i][icoef] *
670                          s->mclms_coeffs_cur[i + num_channels * ich];
671         pred[ich] += 1 << s->mclms_scaling - 1;
672         pred[ich] >>= s->mclms_scaling;
673         s->channel_residues[ich][icoef] += pred[ich];
674     }
675 }
676
677 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
678 {
679     int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
680     for (icoef = 0; icoef < tile_size; icoef++) {
681         mclms_predict(s, icoef, pred);
682         mclms_update(s, icoef, pred);
683     }
684 }
685
686 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
687 {
688     int pred = 0, icoef;
689     int recent = s->cdlms[ich][ilms].recent;
690
691     for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
692         pred += s->cdlms[ich][ilms].coefs[icoef] *
693                 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
694
695     return pred;
696 }
697
698 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
699                        int input, int residue)
700 {
701     int icoef;
702     int recent = s->cdlms[ich][ilms].recent;
703     int range  = 1 << s->bits_per_sample - 1;
704
705     if (residue < 0) {
706         for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
707             s->cdlms[ich][ilms].coefs[icoef] -=
708                 s->cdlms[ich][ilms].lms_updates[icoef + recent];
709     } else if (residue > 0) {
710         for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
711             s->cdlms[ich][ilms].coefs[icoef] +=
712                 s->cdlms[ich][ilms].lms_updates[icoef + recent];
713     }
714
715     if (recent)
716         recent--;
717     else {
718         memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
719                s->cdlms[ich][ilms].lms_prevvalues,
720                2 * s->cdlms[ich][ilms].order);
721         memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
722                s->cdlms[ich][ilms].lms_updates,
723                2 * s->cdlms[ich][ilms].order);
724         recent = s->cdlms[ich][ilms].order - 1;
725     }
726
727     s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
728     if (!input)
729         s->cdlms[ich][ilms].lms_updates[recent] = 0;
730     else if (input < 0)
731         s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
732     else
733         s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
734
735     s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
736     s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
737     s->cdlms[ich][ilms].recent = recent;
738 }
739
740 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
741 {
742     int ilms, recent, icoef;
743     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
744         recent = s->cdlms[ich][ilms].recent;
745         if (s->update_speed[ich] == 16)
746             continue;
747         if (s->bV3RTM) {
748             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
749                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
750         } else {
751             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
752                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
753         }
754     }
755     s->update_speed[ich] = 16;
756 }
757
758 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
759 {
760     int ilms, recent, icoef;
761     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
762         recent = s->cdlms[ich][ilms].recent;
763         if (s->update_speed[ich] == 8)
764             continue;
765         if (s->bV3RTM)
766             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
767                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
768         else
769             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
770                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
771     }
772     s->update_speed[ich] = 8;
773 }
774
775 static void revert_cdlms(WmallDecodeCtx *s, int ch,
776                          int coef_begin, int coef_end)
777 {
778     int icoef, pred, ilms, num_lms, residue, input;
779
780     num_lms = s->cdlms_ttl[ch];
781     for (ilms = num_lms - 1; ilms >= 0; ilms--) {
782         for (icoef = coef_begin; icoef < coef_end; icoef++) {
783             pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
784             residue = s->channel_residues[ch][icoef];
785             pred += lms_predict(s, ch, ilms);
786             input = residue + (pred >> s->cdlms[ch][ilms].scaling);
787             lms_update(s, ch, ilms, input, residue);
788             s->channel_residues[ch][icoef] = input;
789         }
790     }
791 }
792
793 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
794 {
795     if (s->num_channels != 2)
796         return;
797     else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
798         int icoef;
799         for (icoef = 0; icoef < tile_size; icoef++) {
800             s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
801             s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
802         }
803     }
804 }
805
806 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
807 {
808     int ich, pred, i, j;
809     int64_t *filter_coeffs = s->acfilter_coeffs;
810     int scaling            = s->acfilter_scaling;
811     int order              = s->acfilter_order;
812
813     for (ich = 0; ich < s->num_channels; ich++) {
814         int *prevvalues = s->acfilter_prevvalues[ich];
815         for (i = 0; i < order; i++) {
816             pred = 0;
817             for (j = 0; j < order; j++) {
818                 if (i <= j)
819                     pred += filter_coeffs[j] * prevvalues[j - i];
820                 else
821                     pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
822             }
823             pred >>= scaling;
824             s->channel_residues[ich][i] += pred;
825         }
826         for (i = order; i < tile_size; i++) {
827             pred = 0;
828             for (j = 0; j < order; j++)
829                 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
830             pred >>= scaling;
831             s->channel_residues[ich][i] += pred;
832         }
833         for (j = 0; j < order; j++)
834             prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
835     }
836 }
837
838 static int decode_subframe(WmallDecodeCtx *s)
839 {
840     int offset        = s->samples_per_frame;
841     int subframe_len  = s->samples_per_frame;
842     int total_samples = s->samples_per_frame * s->num_channels;
843     int i, j, rawpcm_tile, padding_zeroes, res;
844
845     s->subframe_offset = get_bits_count(&s->gb);
846
847     /* reset channel context and find the next block offset and size
848         == the next block of the channel with the smallest number of
849         decoded samples */
850     for (i = 0; i < s->num_channels; i++) {
851         if (offset > s->channel[i].decoded_samples) {
852             offset = s->channel[i].decoded_samples;
853             subframe_len =
854                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
855         }
856     }
857
858     /* get a list of all channels that contain the estimated block */
859     s->channels_for_cur_subframe = 0;
860     for (i = 0; i < s->num_channels; i++) {
861         const int cur_subframe = s->channel[i].cur_subframe;
862         /* subtract already processed samples */
863         total_samples -= s->channel[i].decoded_samples;
864
865         /* and count if there are multiple subframes that match our profile */
866         if (offset == s->channel[i].decoded_samples &&
867             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
868             total_samples -= s->channel[i].subframe_len[cur_subframe];
869             s->channel[i].decoded_samples +=
870                 s->channel[i].subframe_len[cur_subframe];
871             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
872             ++s->channels_for_cur_subframe;
873         }
874     }
875
876     /* check if the frame will be complete after processing the
877         estimated block */
878     if (!total_samples)
879         s->parsed_all_subframes = 1;
880
881
882     s->seekable_tile = get_bits1(&s->gb);
883     if (s->seekable_tile) {
884         clear_codec_buffers(s);
885
886         s->do_arith_coding    = get_bits1(&s->gb);
887         if (s->do_arith_coding) {
888             av_log_missing_feature(s->avctx, "arithmetic coding", 1);
889             return AVERROR_PATCHWELCOME;
890         }
891         s->do_ac_filter       = get_bits1(&s->gb);
892         s->do_inter_ch_decorr = get_bits1(&s->gb);
893         s->do_mclms           = get_bits1(&s->gb);
894
895         if (s->do_ac_filter)
896             decode_ac_filter(s);
897
898         if (s->do_mclms)
899             decode_mclms(s);
900
901         if ((res = decode_cdlms(s)) < 0)
902             return res;
903         s->movave_scaling = get_bits(&s->gb, 3);
904         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
905
906         reset_codec(s);
907     } else if (!s->cdlms[0][0].order) {
908         av_log(s->avctx, AV_LOG_DEBUG,
909                "Waiting for seekable tile\n");
910         s->frame.nb_samples = 0;
911         return -1;
912     }
913
914     rawpcm_tile = get_bits1(&s->gb);
915
916     for (i = 0; i < s->num_channels; i++)
917         s->is_channel_coded[i] = 1;
918
919     if (!rawpcm_tile) {
920         for (i = 0; i < s->num_channels; i++)
921             s->is_channel_coded[i] = get_bits1(&s->gb);
922
923         if (s->bV3RTM) {
924             // LPC
925             s->do_lpc = get_bits1(&s->gb);
926             if (s->do_lpc) {
927                 decode_lpc(s);
928                 av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
929                                       "implemented. Expect wrong output.\n");
930             }
931         } else
932             s->do_lpc = 0;
933     }
934
935
936     if (get_bits1(&s->gb))
937         padding_zeroes = get_bits(&s->gb, 5);
938     else
939         padding_zeroes = 0;
940
941     if (rawpcm_tile) {
942         int bits = s->bits_per_sample - padding_zeroes;
943         if (bits <= 0) {
944             av_log(s->avctx, AV_LOG_ERROR,
945                    "Invalid number of padding bits in raw PCM tile\n");
946             return AVERROR_INVALIDDATA;
947         }
948         av_dlog(s->avctx, "RAWPCM %d bits per sample. "
949                 "total %d bits, remain=%d\n", bits,
950                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
951         for (i = 0; i < s->num_channels; i++)
952             for (j = 0; j < subframe_len; j++)
953                 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
954     } else {
955         for (i = 0; i < s->num_channels; i++)
956             if (s->is_channel_coded[i]) {
957                 decode_channel_residues(s, i, subframe_len);
958                 if (s->seekable_tile)
959                     use_high_update_speed(s, i);
960                 else
961                     use_normal_update_speed(s, i);
962                 revert_cdlms(s, i, 0, subframe_len);
963             } else {
964                 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
965             }
966     }
967     if (s->do_mclms)
968         revert_mclms(s, subframe_len);
969     if (s->do_inter_ch_decorr)
970         revert_inter_ch_decorr(s, subframe_len);
971     if (s->do_ac_filter)
972         revert_acfilter(s, subframe_len);
973
974     /* Dequantize */
975     if (s->quant_stepsize != 1)
976         for (i = 0; i < s->num_channels; i++)
977             for (j = 0; j < subframe_len; j++)
978                 s->channel_residues[i][j] *= s->quant_stepsize;
979
980     /* Write to proper output buffer depending on bit-depth */
981     for (i = 0; i < s->channels_for_cur_subframe; i++) {
982         int c = s->channel_indexes_for_cur_subframe[i];
983         int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
984
985         for (j = 0; j < subframe_len; j++) {
986             if (s->bits_per_sample == 16) {
987                 *s->samples_16[c] = (int16_t) s->channel_residues[c][j] << padding_zeroes;
988                 s->samples_16[c] += s->num_channels;
989             } else {
990                 *s->samples_32[c] = s->channel_residues[c][j] << padding_zeroes;
991                 s->samples_32[c] += s->num_channels;
992             }
993         }
994     }
995
996     /* handled one subframe */
997     for (i = 0; i < s->channels_for_cur_subframe; i++) {
998         int c = s->channel_indexes_for_cur_subframe[i];
999         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1000             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1001             return AVERROR_INVALIDDATA;
1002         }
1003         ++s->channel[c].cur_subframe;
1004     }
1005     return 0;
1006 }
1007
1008 /**
1009  * @brief Decode one WMA frame.
1010  * @param s codec context
1011  * @return 0 if the trailer bit indicates that this is the last frame,
1012  *         1 if there are additional frames
1013  */
1014 static int decode_frame(WmallDecodeCtx *s)
1015 {
1016     GetBitContext* gb = &s->gb;
1017     int more_frames = 0, len = 0, i, ret;
1018
1019     s->frame.nb_samples = s->samples_per_frame;
1020     if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1021         /* return an error if no frame could be decoded at all */
1022         av_log(s->avctx, AV_LOG_ERROR,
1023                "not enough space for the output samples\n");
1024         s->packet_loss = 1;
1025         return ret;
1026     }
1027     for (i = 0; i < s->num_channels; i++) {
1028         s->samples_16[i] = (int16_t *)s->frame.data[0] + i;
1029         s->samples_32[i] = (int32_t *)s->frame.data[0] + i;
1030     }
1031
1032     /* get frame length */
1033     if (s->len_prefix)
1034         len = get_bits(gb, s->log2_frame_size);
1035
1036     /* decode tile information */
1037     if (decode_tilehdr(s)) {
1038         s->packet_loss = 1;
1039         return 0;
1040     }
1041
1042     /* read drc info */
1043     if (s->dynamic_range_compression)
1044         s->drc_gain = get_bits(gb, 8);
1045
1046     /* no idea what these are for, might be the number of samples
1047        that need to be skipped at the beginning or end of a stream */
1048     if (get_bits1(gb)) {
1049         int av_unused skip;
1050
1051         /* usually true for the first frame */
1052         if (get_bits1(gb)) {
1053             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1054             av_dlog(s->avctx, "start skip: %i\n", skip);
1055         }
1056
1057         /* sometimes true for the last frame */
1058         if (get_bits1(gb)) {
1059             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1060             av_dlog(s->avctx, "end skip: %i\n", skip);
1061         }
1062
1063     }
1064
1065     /* reset subframe states */
1066     s->parsed_all_subframes = 0;
1067     for (i = 0; i < s->num_channels; i++) {
1068         s->channel[i].decoded_samples = 0;
1069         s->channel[i].cur_subframe    = 0;
1070     }
1071
1072     /* decode all subframes */
1073     while (!s->parsed_all_subframes) {
1074         if (decode_subframe(s) < 0) {
1075             s->packet_loss = 1;
1076             return 0;
1077         }
1078     }
1079
1080     av_dlog(s->avctx, "Frame done\n");
1081
1082     if (s->skip_frame)
1083         s->skip_frame = 0;
1084
1085     if (s->len_prefix) {
1086         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1087             /* FIXME: not sure if this is always an error */
1088             av_log(s->avctx, AV_LOG_ERROR,
1089                    "frame[%i] would have to skip %i bits\n", s->frame_num,
1090                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1091             s->packet_loss = 1;
1092             return 0;
1093         }
1094
1095         /* skip the rest of the frame data */
1096         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1097     }
1098
1099     /* decode trailer bit */
1100     more_frames = get_bits1(gb);
1101     ++s->frame_num;
1102     return more_frames;
1103 }
1104
1105 /**
1106  * @brief Calculate remaining input buffer length.
1107  * @param s  codec context
1108  * @param gb bitstream reader context
1109  * @return remaining size in bits
1110  */
1111 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1112 {
1113     return s->buf_bit_size - get_bits_count(gb);
1114 }
1115
1116 /**
1117  * @brief Fill the bit reservoir with a (partial) frame.
1118  * @param s      codec context
1119  * @param gb     bitstream reader context
1120  * @param len    length of the partial frame
1121  * @param append decides whether to reset the buffer or not
1122  */
1123 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1124                       int append)
1125 {
1126     int buflen;
1127     PutBitContext tmp;
1128
1129     /* when the frame data does not need to be concatenated, the input buffer
1130         is reset and additional bits from the previous frame are copied
1131         and skipped later so that a fast byte copy is possible */
1132
1133     if (!append) {
1134         s->frame_offset   = get_bits_count(gb) & 7;
1135         s->num_saved_bits = s->frame_offset;
1136         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1137     }
1138
1139     buflen = (s->num_saved_bits + len + 8) >> 3;
1140
1141     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1142         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1143         s->packet_loss = 1;
1144         return;
1145     }
1146
1147     s->num_saved_bits += len;
1148     if (!append) {
1149         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1150                          s->num_saved_bits);
1151     } else {
1152         int align = 8 - (get_bits_count(gb) & 7);
1153         align = FFMIN(align, len);
1154         put_bits(&s->pb, align, get_bits(gb, align));
1155         len -= align;
1156         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1157     }
1158     skip_bits_long(gb, len);
1159
1160     tmp = s->pb;
1161     flush_put_bits(&tmp);
1162
1163     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1164     skip_bits(&s->gb, s->frame_offset);
1165 }
1166
1167 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1168                          AVPacket* avpkt)
1169 {
1170     WmallDecodeCtx *s = avctx->priv_data;
1171     GetBitContext* gb  = &s->pgb;
1172     const uint8_t* buf = avpkt->data;
1173     int buf_size       = avpkt->size;
1174     int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1175
1176     s->frame.nb_samples = 0;
1177
1178     if (s->packet_done || s->packet_loss) {
1179         s->packet_done = 0;
1180
1181         /* sanity check for the buffer length */
1182         if (buf_size < avctx->block_align)
1183             return 0;
1184
1185         s->next_packet_start = buf_size - avctx->block_align;
1186         buf_size             = avctx->block_align;
1187         s->buf_bit_size      = buf_size << 3;
1188
1189         /* parse packet header */
1190         init_get_bits(gb, buf, s->buf_bit_size);
1191         packet_sequence_number = get_bits(gb, 4);
1192         skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently ununused
1193         spliced_packet = get_bits1(gb);
1194         if (spliced_packet)
1195             av_log_missing_feature(avctx, "Bitstream splicing", 1);
1196
1197         /* get number of bits that need to be added to the previous frame */
1198         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1199
1200         /* check for packet loss */
1201         if (!s->packet_loss &&
1202             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1203             s->packet_loss = 1;
1204             av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1205                    s->packet_sequence_number, packet_sequence_number);
1206         }
1207         s->packet_sequence_number = packet_sequence_number;
1208
1209         if (num_bits_prev_frame > 0) {
1210             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1211             if (num_bits_prev_frame >= remaining_packet_bits) {
1212                 num_bits_prev_frame = remaining_packet_bits;
1213                 s->packet_done = 1;
1214             }
1215
1216             /* Append the previous frame data to the remaining data from the
1217              * previous packet to create a full frame. */
1218             save_bits(s, gb, num_bits_prev_frame, 1);
1219
1220             /* decode the cross packet frame if it is valid */
1221             if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1222                 decode_frame(s);
1223         } else if (s->num_saved_bits - s->frame_offset) {
1224             av_dlog(avctx, "ignoring %x previously saved bits\n",
1225                     s->num_saved_bits - s->frame_offset);
1226         }
1227
1228         if (s->packet_loss) {
1229             /* Reset number of saved bits so that the decoder does not start
1230              * to decode incomplete frames in the s->len_prefix == 0 case. */
1231             s->num_saved_bits = 0;
1232             init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1233             s->packet_loss    = 0;
1234         }
1235
1236     } else {
1237         int frame_size;
1238
1239         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1240         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1241         skip_bits(gb, s->packet_offset);
1242
1243         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1244             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1245             frame_size <= remaining_bits(s, gb)) {
1246             save_bits(s, gb, frame_size, 0);
1247             s->packet_done = !decode_frame(s);
1248         } else if (!s->len_prefix
1249                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1250             /* when the frames do not have a length prefix, we don't know the
1251              * compressed length of the individual frames however, we know what
1252              * part of a new packet belongs to the previous frame therefore we
1253              * save the incoming packet first, then we append the "previous
1254              * frame" data from the next packet so that we get a buffer that
1255              * only contains full frames */
1256             s->packet_done = !decode_frame(s);
1257         } else {
1258             s->packet_done = 1;
1259         }
1260     }
1261
1262     if (s->packet_done && !s->packet_loss &&
1263         remaining_bits(s, gb) > 0) {
1264         /* save the rest of the data so that it can be decoded
1265          * with the next packet */
1266         save_bits(s, gb, remaining_bits(s, gb), 0);
1267     }
1268
1269     *(AVFrame *)data = s->frame;
1270     *got_frame_ptr   = s->frame.nb_samples > 0;
1271     s->packet_offset = get_bits_count(gb) & 7;
1272
1273     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1274 }
1275
1276 static void flush(AVCodecContext *avctx)
1277 {
1278     WmallDecodeCtx *s    = avctx->priv_data;
1279     s->packet_loss       = 1;
1280     s->packet_done       = 0;
1281     s->num_saved_bits    = 0;
1282     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1283     s->frame_offset      = 0;
1284     s->next_packet_start = 0;
1285     s->cdlms[0][0].order = 0;
1286     s->frame.nb_samples  = 0;
1287 }
1288
1289 AVCodec ff_wmalossless_decoder = {
1290     .name           = "wmalossless",
1291     .type           = AVMEDIA_TYPE_AUDIO,
1292     .id             = AV_CODEC_ID_WMALOSSLESS,
1293     .priv_data_size = sizeof(WmallDecodeCtx),
1294     .init           = decode_init,
1295     .decode         = decode_packet,
1296     .flush          = flush,
1297     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1298     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1299 };