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