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