e87291a01c6df9ecfaf1031d14e7bdb878735adc
[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 WmallChannelCtx {
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 + AV_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             ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
214         ff_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 = (cbits ? get_bits(&s->gb, cbits) : 0) + 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         residue = (residue >> 1) ^ -(residue & 1);
557         s->channel_residues[ch][i] = residue;
558     }
559
560     return 0;
561
562 }
563
564 static void decode_lpc(WmallDecodeCtx *s)
565 {
566     int ch, i, cbits;
567     s->lpc_order   = get_bits(&s->gb, 5) + 1;
568     s->lpc_scaling = get_bits(&s->gb, 4);
569     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
570     cbits = s->lpc_scaling + s->lpc_intbits;
571     for (ch = 0; ch < s->num_channels; ch++)
572         for (i = 0; i < s->lpc_order; i++)
573             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
574 }
575
576 static void clear_codec_buffers(WmallDecodeCtx *s)
577 {
578     int ich, ilms;
579
580     memset(s->acfilter_coeffs,     0, sizeof(s->acfilter_coeffs));
581     memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
582     memset(s->lpc_coefs,           0, sizeof(s->lpc_coefs));
583
584     memset(s->mclms_coeffs,     0, sizeof(s->mclms_coeffs));
585     memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
586     memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
587     memset(s->mclms_updates,    0, sizeof(s->mclms_updates));
588
589     for (ich = 0; ich < s->num_channels; ich++) {
590         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
591             memset(s->cdlms[ich][ilms].coefs, 0,
592                    sizeof(s->cdlms[ich][ilms].coefs));
593             memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
594                    sizeof(s->cdlms[ich][ilms].lms_prevvalues));
595             memset(s->cdlms[ich][ilms].lms_updates, 0,
596                    sizeof(s->cdlms[ich][ilms].lms_updates));
597         }
598         s->ave_sum[ich] = 0;
599     }
600 }
601
602 /**
603  * @brief Reset filter parameters and transient area at new seekable tile.
604  */
605 static void reset_codec(WmallDecodeCtx *s)
606 {
607     int ich, ilms;
608     s->mclms_recent = s->mclms_order * s->num_channels;
609     for (ich = 0; ich < s->num_channels; ich++) {
610         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
611             s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
612         /* first sample of a seekable subframe is considered as the starting of
613             a transient area which is samples_per_frame samples long */
614         s->channel[ich].transient_counter = s->samples_per_frame;
615         s->transient[ich]     = 1;
616         s->transient_pos[ich] = 0;
617     }
618 }
619
620 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
621 {
622     int i, j, ich, pred_error;
623     int order        = s->mclms_order;
624     int num_channels = s->num_channels;
625     int range        = 1 << (s->bits_per_sample - 1);
626
627     for (ich = 0; ich < num_channels; ich++) {
628         pred_error = s->channel_residues[ich][icoef] - pred[ich];
629         if (pred_error > 0) {
630             for (i = 0; i < order * num_channels; i++)
631                 s->mclms_coeffs[i + ich * order * num_channels] +=
632                     s->mclms_updates[s->mclms_recent + i];
633             for (j = 0; j < ich; j++)
634                 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
635         } else if (pred_error < 0) {
636             for (i = 0; i < order * num_channels; i++)
637                 s->mclms_coeffs[i + ich * order * num_channels] -=
638                     s->mclms_updates[s->mclms_recent + i];
639             for (j = 0; j < ich; j++)
640                 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
641         }
642     }
643
644     for (ich = num_channels - 1; ich >= 0; ich--) {
645         s->mclms_recent--;
646         s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
647             -range, range - 1);
648         s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
649     }
650
651     if (s->mclms_recent == 0) {
652         memcpy(&s->mclms_prevvalues[order * num_channels],
653                s->mclms_prevvalues,
654                sizeof(int16_t) * order * num_channels);
655         memcpy(&s->mclms_updates[order * num_channels],
656                s->mclms_updates,
657                sizeof(int16_t) * order * num_channels);
658         s->mclms_recent = num_channels * order;
659     }
660 }
661
662 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
663 {
664     int ich, i;
665     int order        = s->mclms_order;
666     int num_channels = s->num_channels;
667
668     for (ich = 0; ich < num_channels; ich++) {
669         pred[ich] = 0;
670         if (!s->is_channel_coded[ich])
671             continue;
672         for (i = 0; i < order * num_channels; i++)
673             pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
674                          s->mclms_coeffs[i + order * num_channels * ich];
675         for (i = 0; i < ich; i++)
676             pred[ich] += s->channel_residues[i][icoef] *
677                          s->mclms_coeffs_cur[i + num_channels * ich];
678         pred[ich] += 1 << s->mclms_scaling - 1;
679         pred[ich] >>= s->mclms_scaling;
680         s->channel_residues[ich][icoef] += pred[ich];
681     }
682 }
683
684 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
685 {
686     int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
687     for (icoef = 0; icoef < tile_size; icoef++) {
688         mclms_predict(s, icoef, pred);
689         mclms_update(s, icoef, pred);
690     }
691 }
692
693 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input)
694 {
695     int recent = s->cdlms[ich][ilms].recent;
696     int range  = 1 << s->bits_per_sample - 1;
697     int order  = s->cdlms[ich][ilms].order;
698
699     if (recent)
700         recent--;
701     else {
702         memcpy(s->cdlms[ich][ilms].lms_prevvalues + order,
703                s->cdlms[ich][ilms].lms_prevvalues, sizeof(*s->cdlms[ich][ilms].lms_prevvalues) * order);
704         memcpy(s->cdlms[ich][ilms].lms_updates + order,
705                s->cdlms[ich][ilms].lms_updates, sizeof(*s->cdlms[ich][ilms].lms_updates) * order);
706         recent = order - 1;
707     }
708
709     s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
710     s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich];
711
712     s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2;
713     s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1;
714     s->cdlms[ich][ilms].recent = recent;
715     memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0,
716            sizeof(s->cdlms[ich][ilms].lms_updates) - 2*(recent+order));
717 }
718
719 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
720 {
721     int ilms, recent, icoef;
722     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
723         recent = s->cdlms[ich][ilms].recent;
724         if (s->update_speed[ich] == 16)
725             continue;
726         if (s->bV3RTM) {
727             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
728                 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
729         } else {
730             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
731                 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
732         }
733     }
734     s->update_speed[ich] = 16;
735 }
736
737 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
738 {
739     int ilms, recent, icoef;
740     for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
741         recent = s->cdlms[ich][ilms].recent;
742         if (s->update_speed[ich] == 8)
743             continue;
744         if (s->bV3RTM)
745             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
746                 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
747         else
748             for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
749                 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
750     }
751     s->update_speed[ich] = 8;
752 }
753
754 static void revert_cdlms(WmallDecodeCtx *s, int ch,
755                          int coef_begin, int coef_end)
756 {
757     int icoef, pred, ilms, num_lms, residue, input;
758
759     num_lms = s->cdlms_ttl[ch];
760     for (ilms = num_lms - 1; ilms >= 0; ilms--) {
761         for (icoef = coef_begin; icoef < coef_end; icoef++) {
762             pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
763             residue = s->channel_residues[ch][icoef];
764             pred += s->dsp.scalarproduct_and_madd_int16(s->cdlms[ch][ilms].coefs,
765                                                         s->cdlms[ch][ilms].lms_prevvalues
766                                                             + s->cdlms[ch][ilms].recent,
767                                                         s->cdlms[ch][ilms].lms_updates
768                                                             + s->cdlms[ch][ilms].recent,
769                                                         FFALIGN(s->cdlms[ch][ilms].order,
770                                                                 WMALL_COEFF_PAD_SIZE),
771                                                         WMASIGN(residue));
772             input = residue + (pred >> s->cdlms[ch][ilms].scaling);
773             lms_update(s, ch, ilms, input);
774             s->channel_residues[ch][icoef] = input;
775         }
776     }
777     emms_c();
778 }
779
780 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
781 {
782     if (s->num_channels != 2)
783         return;
784     else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
785         int icoef;
786         for (icoef = 0; icoef < tile_size; icoef++) {
787             s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
788             s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
789         }
790     }
791 }
792
793 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
794 {
795     int ich, pred, i, j;
796     int16_t *filter_coeffs = s->acfilter_coeffs;
797     int scaling            = s->acfilter_scaling;
798     int order              = s->acfilter_order;
799
800     for (ich = 0; ich < s->num_channels; ich++) {
801         int *prevvalues = s->acfilter_prevvalues[ich];
802         for (i = 0; i < order; i++) {
803             pred = 0;
804             for (j = 0; j < order; j++) {
805                 if (i <= j)
806                     pred += filter_coeffs[j] * prevvalues[j - i];
807                 else
808                     pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
809             }
810             pred >>= scaling;
811             s->channel_residues[ich][i] += pred;
812         }
813         for (i = order; i < tile_size; i++) {
814             pred = 0;
815             for (j = 0; j < order; j++)
816                 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
817             pred >>= scaling;
818             s->channel_residues[ich][i] += pred;
819         }
820         for (j = 0; j < order; j++)
821             prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
822     }
823 }
824
825 static int decode_subframe(WmallDecodeCtx *s)
826 {
827     int offset        = s->samples_per_frame;
828     int subframe_len  = s->samples_per_frame;
829     int total_samples = s->samples_per_frame * s->num_channels;
830     int i, j, rawpcm_tile, padding_zeroes, res;
831
832     s->subframe_offset = get_bits_count(&s->gb);
833
834     /* reset channel context and find the next block offset and size
835         == the next block of the channel with the smallest number of
836         decoded samples */
837     for (i = 0; i < s->num_channels; i++) {
838         if (offset > s->channel[i].decoded_samples) {
839             offset = s->channel[i].decoded_samples;
840             subframe_len =
841                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
842         }
843     }
844
845     /* get a list of all channels that contain the estimated block */
846     s->channels_for_cur_subframe = 0;
847     for (i = 0; i < s->num_channels; i++) {
848         const int cur_subframe = s->channel[i].cur_subframe;
849         /* subtract already processed samples */
850         total_samples -= s->channel[i].decoded_samples;
851
852         /* and count if there are multiple subframes that match our profile */
853         if (offset == s->channel[i].decoded_samples &&
854             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
855             total_samples -= s->channel[i].subframe_len[cur_subframe];
856             s->channel[i].decoded_samples +=
857                 s->channel[i].subframe_len[cur_subframe];
858             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
859             ++s->channels_for_cur_subframe;
860         }
861     }
862
863     /* check if the frame will be complete after processing the
864         estimated block */
865     if (!total_samples)
866         s->parsed_all_subframes = 1;
867
868
869     s->seekable_tile = get_bits1(&s->gb);
870     if (s->seekable_tile) {
871         clear_codec_buffers(s);
872
873         s->do_arith_coding    = get_bits1(&s->gb);
874         if (s->do_arith_coding) {
875             avpriv_request_sample(s->avctx, "Arithmetic coding");
876             return AVERROR_PATCHWELCOME;
877         }
878         s->do_ac_filter       = get_bits1(&s->gb);
879         s->do_inter_ch_decorr = get_bits1(&s->gb);
880         s->do_mclms           = get_bits1(&s->gb);
881
882         if (s->do_ac_filter)
883             decode_ac_filter(s);
884
885         if (s->do_mclms)
886             decode_mclms(s);
887
888         if ((res = decode_cdlms(s)) < 0)
889             return res;
890         s->movave_scaling = get_bits(&s->gb, 3);
891         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
892
893         reset_codec(s);
894     } else if (!s->cdlms[0][0].order) {
895         av_log(s->avctx, AV_LOG_DEBUG,
896                "Waiting for seekable tile\n");
897         av_frame_unref(s->frame);
898         return -1;
899     }
900
901     rawpcm_tile = get_bits1(&s->gb);
902
903     for (i = 0; i < s->num_channels; i++)
904         s->is_channel_coded[i] = 1;
905
906     if (!rawpcm_tile) {
907         for (i = 0; i < s->num_channels; i++)
908             s->is_channel_coded[i] = get_bits1(&s->gb);
909
910         if (s->bV3RTM) {
911             // LPC
912             s->do_lpc = get_bits1(&s->gb);
913             if (s->do_lpc) {
914                 decode_lpc(s);
915                 avpriv_request_sample(s->avctx, "Expect wrong output since "
916                                       "inverse LPC filter");
917             }
918         } else
919             s->do_lpc = 0;
920     }
921
922
923     if (get_bits1(&s->gb))
924         padding_zeroes = get_bits(&s->gb, 5);
925     else
926         padding_zeroes = 0;
927
928     if (rawpcm_tile) {
929         int bits = s->bits_per_sample - padding_zeroes;
930         if (bits <= 0) {
931             av_log(s->avctx, AV_LOG_ERROR,
932                    "Invalid number of padding bits in raw PCM tile\n");
933             return AVERROR_INVALIDDATA;
934         }
935         ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
936                 "total %d bits, remain=%d\n", bits,
937                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
938         for (i = 0; i < s->num_channels; i++)
939             for (j = 0; j < subframe_len; j++)
940                 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
941     } else {
942         for (i = 0; i < s->num_channels; i++)
943             if (s->is_channel_coded[i]) {
944                 decode_channel_residues(s, i, subframe_len);
945                 if (s->seekable_tile)
946                     use_high_update_speed(s, i);
947                 else
948                     use_normal_update_speed(s, i);
949                 revert_cdlms(s, i, 0, subframe_len);
950             } else {
951                 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
952             }
953     }
954     if (s->do_mclms)
955         revert_mclms(s, subframe_len);
956     if (s->do_inter_ch_decorr)
957         revert_inter_ch_decorr(s, subframe_len);
958     if (s->do_ac_filter)
959         revert_acfilter(s, subframe_len);
960
961     /* Dequantize */
962     if (s->quant_stepsize != 1)
963         for (i = 0; i < s->num_channels; i++)
964             for (j = 0; j < subframe_len; j++)
965                 s->channel_residues[i][j] *= s->quant_stepsize;
966
967     /* Write to proper output buffer depending on bit-depth */
968     for (i = 0; i < s->channels_for_cur_subframe; i++) {
969         int c = s->channel_indexes_for_cur_subframe[i];
970         int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
971
972         for (j = 0; j < subframe_len; j++) {
973             if (s->bits_per_sample == 16) {
974                 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
975             } else {
976                 *s->samples_32[c]++ = s->channel_residues[c][j] << (padding_zeroes + 8);
977             }
978         }
979     }
980
981     /* handled one subframe */
982     for (i = 0; i < s->channels_for_cur_subframe; i++) {
983         int c = s->channel_indexes_for_cur_subframe[i];
984         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
985             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
986             return AVERROR_INVALIDDATA;
987         }
988         ++s->channel[c].cur_subframe;
989     }
990     return 0;
991 }
992
993 /**
994  * @brief Decode one WMA frame.
995  * @param s codec context
996  * @return 0 if the trailer bit indicates that this is the last frame,
997  *         1 if there are additional frames
998  */
999 static int decode_frame(WmallDecodeCtx *s)
1000 {
1001     GetBitContext* gb = &s->gb;
1002     int more_frames = 0, len = 0, i, ret;
1003
1004     s->frame->nb_samples = s->samples_per_frame;
1005     if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1006         /* return an error if no frame could be decoded at all */
1007         s->packet_loss = 1;
1008         s->frame->nb_samples = 0;
1009         return ret;
1010     }
1011     for (i = 0; i < s->num_channels; i++) {
1012         s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1013         s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1014     }
1015
1016     /* get frame length */
1017     if (s->len_prefix)
1018         len = get_bits(gb, s->log2_frame_size);
1019
1020     /* decode tile information */
1021     if ((ret = decode_tilehdr(s))) {
1022         s->packet_loss = 1;
1023         av_frame_unref(s->frame);
1024         return ret;
1025     }
1026
1027     /* read drc info */
1028     if (s->dynamic_range_compression)
1029         s->drc_gain = get_bits(gb, 8);
1030
1031     /* no idea what these are for, might be the number of samples
1032        that need to be skipped at the beginning or end of a stream */
1033     if (get_bits1(gb)) {
1034         int av_unused skip;
1035
1036         /* usually true for the first frame */
1037         if (get_bits1(gb)) {
1038             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1039             ff_dlog(s->avctx, "start skip: %i\n", skip);
1040         }
1041
1042         /* sometimes true for the last frame */
1043         if (get_bits1(gb)) {
1044             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1045             ff_dlog(s->avctx, "end skip: %i\n", skip);
1046         }
1047
1048     }
1049
1050     /* reset subframe states */
1051     s->parsed_all_subframes = 0;
1052     for (i = 0; i < s->num_channels; i++) {
1053         s->channel[i].decoded_samples = 0;
1054         s->channel[i].cur_subframe    = 0;
1055     }
1056
1057     /* decode all subframes */
1058     while (!s->parsed_all_subframes) {
1059         int decoded_samples = s->channel[0].decoded_samples;
1060         if (decode_subframe(s) < 0) {
1061             s->packet_loss = 1;
1062             if (s->frame->nb_samples)
1063                 s->frame->nb_samples = decoded_samples;
1064             return 0;
1065         }
1066     }
1067
1068     ff_dlog(s->avctx, "Frame done\n");
1069
1070     s->skip_frame = 0;
1071
1072     if (s->len_prefix) {
1073         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1074             /* FIXME: not sure if this is always an error */
1075             av_log(s->avctx, AV_LOG_ERROR,
1076                    "frame[%"PRIu32"] would have to skip %i bits\n",
1077                    s->frame_num,
1078                    len - (get_bits_count(gb) - s->frame_offset) - 1);
1079             s->packet_loss = 1;
1080             return 0;
1081         }
1082
1083         /* skip the rest of the frame data */
1084         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1085     }
1086
1087     /* decode trailer bit */
1088     more_frames = get_bits1(gb);
1089     ++s->frame_num;
1090     return more_frames;
1091 }
1092
1093 /**
1094  * @brief Calculate remaining input buffer length.
1095  * @param s  codec context
1096  * @param gb bitstream reader context
1097  * @return remaining size in bits
1098  */
1099 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1100 {
1101     return s->buf_bit_size - get_bits_count(gb);
1102 }
1103
1104 /**
1105  * @brief Fill the bit reservoir with a (partial) frame.
1106  * @param s      codec context
1107  * @param gb     bitstream reader context
1108  * @param len    length of the partial frame
1109  * @param append decides whether to reset the buffer or not
1110  */
1111 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1112                       int append)
1113 {
1114     int buflen;
1115     PutBitContext tmp;
1116
1117     /* when the frame data does not need to be concatenated, the input buffer
1118         is reset and additional bits from the previous frame are copied
1119         and skipped later so that a fast byte copy is possible */
1120
1121     if (!append) {
1122         s->frame_offset   = get_bits_count(gb) & 7;
1123         s->num_saved_bits = s->frame_offset;
1124         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1125     }
1126
1127     buflen = (s->num_saved_bits + len + 8) >> 3;
1128
1129     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1130         avpriv_request_sample(s->avctx, "Too small input buffer");
1131         s->packet_loss = 1;
1132         return;
1133     }
1134
1135     s->num_saved_bits += len;
1136     if (!append) {
1137         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1138                          s->num_saved_bits);
1139     } else {
1140         int align = 8 - (get_bits_count(gb) & 7);
1141         align = FFMIN(align, len);
1142         put_bits(&s->pb, align, get_bits(gb, align));
1143         len -= align;
1144         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1145     }
1146     skip_bits_long(gb, len);
1147
1148     tmp = s->pb;
1149     flush_put_bits(&tmp);
1150
1151     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1152     skip_bits(&s->gb, s->frame_offset);
1153 }
1154
1155 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1156                          AVPacket* avpkt)
1157 {
1158     WmallDecodeCtx *s = avctx->priv_data;
1159     GetBitContext* gb  = &s->pgb;
1160     const uint8_t* buf = avpkt->data;
1161     int buf_size       = avpkt->size;
1162     int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1163
1164     s->frame->nb_samples = 0;
1165
1166     if (s->packet_done || s->packet_loss) {
1167         s->packet_done = 0;
1168
1169         if (!buf_size)
1170             return 0;
1171         /* sanity check for the buffer length */
1172         if (buf_size < avctx->block_align) {
1173             av_log(avctx, AV_LOG_ERROR, "buf size %d invalid\n", buf_size);
1174             return AVERROR_INVALIDDATA;
1175         }
1176
1177         s->next_packet_start = buf_size - avctx->block_align;
1178         buf_size             = avctx->block_align;
1179         s->buf_bit_size      = buf_size << 3;
1180
1181         /* parse packet header */
1182         init_get_bits(gb, buf, s->buf_bit_size);
1183         packet_sequence_number = get_bits(gb, 4);
1184         skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently ununused
1185         spliced_packet = get_bits1(gb);
1186         if (spliced_packet)
1187             avpriv_request_sample(avctx, "Bitstream splicing");
1188
1189         /* get number of bits that need to be added to the previous frame */
1190         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1191
1192         /* check for packet loss */
1193         if (!s->packet_loss &&
1194             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1195             s->packet_loss = 1;
1196             av_log(avctx, AV_LOG_ERROR,
1197                    "Packet loss detected! seq %"PRIx8" vs %x\n",
1198                    s->packet_sequence_number, packet_sequence_number);
1199         }
1200         s->packet_sequence_number = packet_sequence_number;
1201
1202         if (num_bits_prev_frame > 0) {
1203             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1204             if (num_bits_prev_frame >= remaining_packet_bits) {
1205                 num_bits_prev_frame = remaining_packet_bits;
1206                 s->packet_done = 1;
1207             }
1208
1209             /* Append the previous frame data to the remaining data from the
1210              * previous packet to create a full frame. */
1211             save_bits(s, gb, num_bits_prev_frame, 1);
1212
1213             /* decode the cross packet frame if it is valid */
1214             if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1215                 decode_frame(s);
1216         } else if (s->num_saved_bits - s->frame_offset) {
1217             ff_dlog(avctx, "ignoring %x previously saved bits\n",
1218                     s->num_saved_bits - s->frame_offset);
1219         }
1220
1221         if (s->packet_loss) {
1222             /* Reset number of saved bits so that the decoder does not start
1223              * to decode incomplete frames in the s->len_prefix == 0 case. */
1224             s->num_saved_bits = 0;
1225             s->packet_loss    = 0;
1226             init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1227         }
1228
1229     } else {
1230         int frame_size;
1231
1232         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1233         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1234         skip_bits(gb, s->packet_offset);
1235
1236         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1237             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1238             frame_size <= remaining_bits(s, gb)) {
1239             save_bits(s, gb, frame_size, 0);
1240             s->packet_done = !decode_frame(s);
1241         } else if (!s->len_prefix
1242                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1243             /* when the frames do not have a length prefix, we don't know the
1244              * compressed length of the individual frames however, we know what
1245              * part of a new packet belongs to the previous frame therefore we
1246              * save the incoming packet first, then we append the "previous
1247              * frame" data from the next packet so that we get a buffer that
1248              * only contains full frames */
1249             s->packet_done = !decode_frame(s);
1250         } else {
1251             s->packet_done = 1;
1252         }
1253     }
1254
1255     if (s->packet_done && !s->packet_loss &&
1256         remaining_bits(s, gb) > 0) {
1257         /* save the rest of the data so that it can be decoded
1258          * with the next packet */
1259         save_bits(s, gb, remaining_bits(s, gb), 0);
1260     }
1261
1262     *got_frame_ptr   = s->frame->nb_samples > 0;
1263     av_frame_move_ref(data, s->frame);
1264
1265     s->packet_offset = get_bits_count(gb) & 7;
1266
1267     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1268 }
1269
1270 static void flush(AVCodecContext *avctx)
1271 {
1272     WmallDecodeCtx *s    = avctx->priv_data;
1273     s->packet_loss       = 1;
1274     s->packet_done       = 0;
1275     s->num_saved_bits    = 0;
1276     s->frame_offset      = 0;
1277     s->next_packet_start = 0;
1278     s->cdlms[0][0].order = 0;
1279     s->frame->nb_samples = 0;
1280     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1281 }
1282
1283 static av_cold int decode_close(AVCodecContext *avctx)
1284 {
1285     WmallDecodeCtx *s = avctx->priv_data;
1286
1287     av_frame_free(&s->frame);
1288
1289     return 0;
1290 }
1291
1292 AVCodec ff_wmalossless_decoder = {
1293     .name           = "wmalossless",
1294     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1295     .type           = AVMEDIA_TYPE_AUDIO,
1296     .id             = AV_CODEC_ID_WMALOSSLESS,
1297     .priv_data_size = sizeof(WmallDecodeCtx),
1298     .init           = decode_init,
1299     .close          = decode_close,
1300     .decode         = decode_packet,
1301     .flush          = flush,
1302     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1303     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1304                                                       AV_SAMPLE_FMT_S32P,
1305                                                       AV_SAMPLE_FMT_NONE },
1306 };