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