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