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