Add missing syntax elements to WmallDecodeCtx
[ffmpeg.git] / libavcodec / wmalosslessdec.c
1 /*
2  * Wmall compatible 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  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * @brief wmall decoder implementation
27  * Wmall is an MDCT based codec comparable to wma standard or AAC.
28  * The decoding therefore consists of the following steps:
29  * - bitstream decoding
30  * - reconstruction of per-channel data
31  * - rescaling and inverse quantization
32  * - IMDCT
33  * - windowing and overlapp-add
34  *
35  * The compressed wmall bitstream is split into individual packets.
36  * Every such packet contains one or more wma frames.
37  * The compressed frames may have a variable length and frames may
38  * cross packet boundaries.
39  * Common to all wmall frames is the number of samples that are stored in
40  * a frame.
41  * The number of samples and a few other decode flags are stored
42  * as extradata that has to be passed to the decoder.
43  *
44  * The wmall frames themselves are again split into a variable number of
45  * subframes. Every subframe contains the data for 2^N time domain samples
46  * where N varies between 7 and 12.
47  *
48  * Example wmall bitstream (in samples):
49  *
50  * ||   packet 0           || packet 1 || packet 2      packets
51  * ---------------------------------------------------
52  * || frame 0      || frame 1       || frame 2    ||    frames
53  * ---------------------------------------------------
54  * ||   |      |   ||   |   |   |   ||            ||    subframes of channel 0
55  * ---------------------------------------------------
56  * ||      |   |   ||   |   |   |   ||            ||    subframes of channel 1
57  * ---------------------------------------------------
58  *
59  * The frame layouts for the individual channels of a wma frame does not need
60  * to be the same.
61  *
62  * However, if the offsets and lengths of several subframes of a frame are the
63  * same, the subframes of the channels can be grouped.
64  * Every group may then use special coding techniques like M/S stereo coding
65  * to improve the compression ratio. These channel transformations do not
66  * need to be applied to a whole subframe. Instead, they can also work on
67  * individual scale factor bands (see below).
68  * The coefficients that carry the audio signal in the frequency domain
69  * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
70  * In addition to that, the encoder can switch to a runlevel coding scheme
71  * by transmitting subframe_length / 128 zero coefficients.
72  *
73  * Before the audio signal can be converted to the time domain, the
74  * coefficients have to be rescaled and inverse quantized.
75  * A subframe is therefore split into several scale factor bands that get
76  * scaled individually.
77  * Scale factors are submitted for every frame but they might be shared
78  * between the subframes of a channel. Scale factors are initially DPCM-coded.
79  * Once scale factors are shared, the differences are transmitted as runlevel
80  * codes.
81  * Every subframe length and offset combination in the frame layout shares a
82  * common quantization factor that can be adjusted for every channel by a
83  * modifier.
84  * After the inverse quantization, the coefficients get processed by an IMDCT.
85  * The resulting values are then windowed with a sine window and the first half
86  * of the values are added to the second half of the output from the previous
87  * subframe in order to reconstruct the output samples.
88  */
89
90 #include "avcodec.h"
91 #include "internal.h"
92 #include "get_bits.h"
93 #include "put_bits.h"
94 #include "dsputil.h"
95 #include "wma.h"
96
97 /** current decoder limitations */
98 #define WMALL_MAX_CHANNELS    8                             ///< max number of handled channels
99 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
100 #define MAX_BANDS      29                                    ///< max number of scale factor bands
101 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
102
103 #define WMALL_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
104 #define WMALL_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
105 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)                 ///< maximum block size
106 #define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
107
108
109 #define VLCBITS            9
110 #define SCALEVLCBITS       8
111 #define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
112 #define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
113 #define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
114 #define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
115 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
116
117 static float            sin64[33];        ///< sinus table for decorrelation
118
119 /**
120  * @brief frame specific decoder context for a single channel
121  */
122 typedef struct {
123     int16_t  prev_block_len;                          ///< length of the previous block
124     uint8_t  transmit_coefs;
125     uint8_t  num_subframes;
126     uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
127     uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
128     uint8_t  cur_subframe;                            ///< current subframe number
129     uint16_t decoded_samples;                         ///< number of already processed samples
130     uint8_t  grouped;                                 ///< channel is part of a group
131     int      quant_step;                              ///< quantization step for the current subframe
132     int8_t   reuse_sf;                                ///< share scale factors between subframes
133     int8_t   scale_factor_step;                       ///< scaling step for the current subframe
134     int      max_scale_factor;                        ///< maximum scale factor for the current subframe
135     int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
136     int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
137     int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
138     uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
139     float*   coeffs;                                  ///< pointer to the subframe decode buffer
140     uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
141     DECLARE_ALIGNED(16, float, out)[WMALL_BLOCK_MAX_SIZE + WMALL_BLOCK_MAX_SIZE / 2]; ///< output buffer
142 } WmallChannelCtx;
143
144                                                     /* XXX: probably we don't need subframe_config[],
145                                                     WmallChannelCtx holds all the necessary data. */
146
147 /**
148  * @brief channel group for channel transformations
149  */
150 typedef struct {
151     uint8_t num_channels;                                     ///< number of channels in the group
152     int8_t  transform;                                        ///< transform on / off
153     int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
154     float   decorrelation_matrix[WMALL_MAX_CHANNELS*WMALL_MAX_CHANNELS];
155     float*  channel_data[WMALL_MAX_CHANNELS];                ///< transformation coefficients
156 } WmallChannelGrp;
157
158 /**
159  * @brief main decoder context
160  */
161 typedef struct WmallDecodeCtx {
162     /* generic decoder variables */
163     AVCodecContext*  avctx;                         ///< codec context for av_log
164     DSPContext       dsp;                           ///< accelerated DSP functions
165     uint8_t          frame_data[MAX_FRAMESIZE +
166                       FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
167     PutBitContext    pb;                            ///< context for filling the frame_data buffer
168     FFTContext       mdct_ctx[WMALL_BLOCK_SIZES];  ///< MDCT context per block size
169     DECLARE_ALIGNED(16, float, tmp)[WMALL_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
170     float*           windows[WMALL_BLOCK_SIZES];   ///< windows for the different block sizes
171
172     /* frame size dependent frame information (set during initialization) */
173     uint32_t         decode_flags;                  ///< used compression features
174     uint8_t          len_prefix;                    ///< frame is prefixed with its length
175     uint8_t          dynamic_range_compression;     ///< frame contains DRC data
176     uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
177     uint16_t         samples_per_frame;             ///< number of samples to output
178     uint16_t         log2_frame_size;
179     int8_t           num_channels;                  ///< number of channels in the stream (same as AVCodecContext.num_channels)
180     int8_t           lfe_channel;                   ///< lfe channel index
181     uint8_t          max_num_subframes;
182     uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
183     uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
184     uint16_t         min_samples_per_subframe;
185     int8_t           num_sfb[WMALL_BLOCK_SIZES];   ///< scale factor bands per block size
186     int16_t          sfb_offsets[WMALL_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
187     int8_t           sf_offsets[WMALL_BLOCK_SIZES][WMALL_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
188     int16_t          subwoofer_cutoffs[WMALL_BLOCK_SIZES]; ///< subwoofer cutoff values
189
190     /* packet decode state */
191     GetBitContext    pgb;                           ///< bitstream reader context for the packet
192     int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
193     uint8_t          packet_offset;                 ///< frame offset in the packet
194     uint8_t          packet_sequence_number;        ///< current packet number
195     int              num_saved_bits;                ///< saved number of bits
196     int              frame_offset;                  ///< frame offset in the bit reservoir
197     int              subframe_offset;               ///< subframe offset in the bit reservoir
198     uint8_t          packet_loss;                   ///< set in case of bitstream error
199     uint8_t          packet_done;                   ///< set when a packet is fully decoded
200
201     /* frame decode state */
202     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
203     GetBitContext    gb;                            ///< bitstream reader context
204     int              buf_bit_size;                  ///< buffer size in bits
205     float*           samples;                       ///< current samplebuffer pointer
206     float*           samples_end;                   ///< maximum samplebuffer pointer
207     uint8_t          drc_gain;                      ///< gain for the DRC tool
208     int8_t           skip_frame;                    ///< skip output step
209     int8_t           parsed_all_subframes;          ///< all subframes decoded?
210
211     /* subframe/block decode state */
212     int16_t          subframe_len;                  ///< current subframe length
213     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
214     int8_t           channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
215     int8_t           num_bands;                     ///< number of scale factor bands
216     int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
217     int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
218     uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
219     int8_t           esc_len;                       ///< length of escaped coefficients
220
221     uint8_t          num_chgroups;                  ///< number of channel groups
222     WmallChannelGrp chgroup[WMALL_MAX_CHANNELS];    ///< channel group information
223
224     WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
225
226     // WMA lossless
227
228     uint8_t do_arith_coding;
229     uint8_t do_ac_filter;
230     uint8_t do_inter_ch_decorr;
231     uint8_t do_mclms;
232     uint8_t do_lpc;
233
234     int8_t acfilter_order;
235     int8_t acfilter_scaling;
236     int acfilter_coeffs[16];
237
238     int8_t mclms_order;
239     int8_t mclms_scaling;
240     int16_t mclms_coeffs[128];
241     int16_t mclms_coeffs_cur[4];
242     int mclms_prevvalues[64];   // FIXME: should be 32-bit / 16-bit depending on bit-depth
243     int16_t mclms_updates[64];
244     int mclms_recent;
245
246     int movave_scaling;
247     int quant_stepsize;
248
249     struct {
250         int order;
251         int scaling;
252         int coefsend;
253         int bitsend;
254         int16_t coefs[256];
255     int lms_prevvalues[512];    // FIXME: see above
256     int16_t lms_updates[512];   // and here too
257     int recent;
258     } cdlms[2][9];              /* XXX: Here, 2 is the max. no. of channels allowed,
259                                         9 is the maximum no. of filters per channel.
260                                         Question is, why 2 if WMALL_MAX_CHANNELS == 8 */
261
262
263     int cdlms_ttl[2];
264
265     int bV3RTM;
266
267     int is_channel_coded[2];    // XXX: same question as above applies here too (and below)
268     int update_speed[2];
269
270     int transient[2];
271     int transient_pos[2];
272     int seekable_tile;
273
274     int ave_sum[2];
275
276     int channel_residues[2][2048];
277
278
279     int lpc_coefs[2][40];
280     int lpc_order;
281     int lpc_scaling;
282     int lpc_intbits;
283
284     int channel_coeffs[2][2048];
285
286 } WmallDecodeCtx;
287
288
289 #undef dprintf
290 #define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
291
292
293 /**
294  *@brief helper function to print the most important members of the context
295  *@param s context
296  */
297 static void av_cold dump_context(WmallDecodeCtx *s)
298 {
299 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
300 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
301
302     PRINT("ed sample bit depth", s->bits_per_sample);
303     PRINT_HEX("ed decode flags", s->decode_flags);
304     PRINT("samples per frame",   s->samples_per_frame);
305     PRINT("log2 frame size",     s->log2_frame_size);
306     PRINT("max num subframes",   s->max_num_subframes);
307     PRINT("len prefix",          s->len_prefix);
308     PRINT("num channels",        s->num_channels);
309 }
310
311 /**
312  *@brief Uninitialize the decoder and free all resources.
313  *@param avctx codec context
314  *@return 0 on success, < 0 otherwise
315  */
316 static av_cold int decode_end(AVCodecContext *avctx)
317 {
318     WmallDecodeCtx *s = avctx->priv_data;
319     int i;
320
321     for (i = 0; i < WMALL_BLOCK_SIZES; i++)
322         ff_mdct_end(&s->mdct_ctx[i]);
323
324     return 0;
325 }
326
327 /**
328  *@brief Initialize the decoder.
329  *@param avctx codec context
330  *@return 0 on success, -1 otherwise
331  */
332 static av_cold int decode_init(AVCodecContext *avctx)
333 {
334     WmallDecodeCtx *s = avctx->priv_data;
335     uint8_t *edata_ptr = avctx->extradata;
336     unsigned int channel_mask;
337     int i;
338     int log2_max_num_subframes;
339     int num_possible_block_sizes;
340
341     s->avctx = avctx;
342     dsputil_init(&s->dsp, avctx);
343     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
344
345     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
346
347     if (avctx->extradata_size >= 18) {
348         s->decode_flags    = AV_RL16(edata_ptr+14);
349         channel_mask       = AV_RL32(edata_ptr+2);
350         s->bits_per_sample = AV_RL16(edata_ptr);
351         /** dump the extradata */
352         for (i = 0; i < avctx->extradata_size; i++)
353             dprintf(avctx, "[%x] ", avctx->extradata[i]);
354         dprintf(avctx, "\n");
355
356     } else {
357         av_log_ask_for_sample(avctx, "Unknown extradata size\n");
358         return AVERROR_INVALIDDATA;
359     }
360
361     /** generic init */
362     s->log2_frame_size = av_log2(avctx->block_align) + 4;
363
364     /** frame info */
365     s->skip_frame  = 1; /* skip first frame */
366     s->packet_loss = 1;
367     s->len_prefix  = (s->decode_flags & 0x40);
368
369     /** get frame len */
370     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
371                                                           3, s->decode_flags);
372
373     /** init previous block len */
374     for (i = 0; i < avctx->channels; i++)
375         s->channel[i].prev_block_len = s->samples_per_frame;
376
377     /** subframe info */
378     log2_max_num_subframes  = ((s->decode_flags & 0x38) >> 3);
379     s->max_num_subframes    = 1 << log2_max_num_subframes;
380     s->max_subframe_len_bit = 0;
381     s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
382
383     num_possible_block_sizes     = log2_max_num_subframes + 1;
384     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
385     s->dynamic_range_compression = (s->decode_flags & 0x80);
386
387     s->bV3RTM = s->decode_flags & 0x100;
388
389     if (s->max_num_subframes > MAX_SUBFRAMES) {
390         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
391                s->max_num_subframes);
392         return AVERROR_INVALIDDATA;
393     }
394
395     s->num_channels = avctx->channels;
396
397     /** extract lfe channel position */
398     s->lfe_channel = -1;
399
400     if (channel_mask & 8) {
401         unsigned int mask;
402         for (mask = 1; mask < 16; mask <<= 1) {
403             if (channel_mask & mask)
404                 ++s->lfe_channel;
405         }
406     }
407
408     if (s->num_channels < 0) {
409         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
410         return AVERROR_INVALIDDATA;
411     } else if (s->num_channels > WMALL_MAX_CHANNELS) {
412         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
413         return AVERROR_PATCHWELCOME;
414     }
415
416     avctx->channel_layout = channel_mask;
417     return 0;
418 }
419
420 /**
421  *@brief Decode the subframe length.
422  *@param s context
423  *@param offset sample offset in the frame
424  *@return decoded subframe length on success, < 0 in case of an error
425  */
426 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
427 {
428     int frame_len_ratio;
429     int subframe_len, len;
430
431     /** no need to read from the bitstream when only one length is possible */
432     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
433         return s->min_samples_per_subframe;
434
435     len = av_log2(s->max_num_subframes - 1) + 1;    // XXX: 5.3.3
436     frame_len_ratio = get_bits(&s->gb, len);        // XXX: tile_size_ratio
437
438     subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
439
440     /** sanity check the length */
441     if (subframe_len < s->min_samples_per_subframe ||
442         subframe_len > s->samples_per_frame) {
443         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
444                subframe_len);
445         return AVERROR_INVALIDDATA;
446     }
447     return subframe_len;
448 }
449
450 /**
451  *@brief Decode how the data in the frame is split into subframes.
452  *       Every WMA frame contains the encoded data for a fixed number of
453  *       samples per channel. The data for every channel might be split
454  *       into several subframes. This function will reconstruct the list of
455  *       subframes for every channel.
456  *
457  *       If the subframes are not evenly split, the algorithm estimates the
458  *       channels with the lowest number of total samples.
459  *       Afterwards, for each of these channels a bit is read from the
460  *       bitstream that indicates if the channel contains a subframe with the
461  *       next subframe size that is going to be read from the bitstream or not.
462  *       If a channel contains such a subframe, the subframe size gets added to
463  *       the channel's subframe list.
464  *       The algorithm repeats these steps until the frame is properly divided
465  *       between the individual channels.
466  *
467  *@param s context
468  *@return 0 on success, < 0 in case of an error
469  */
470 static int decode_tilehdr(WmallDecodeCtx *s)        /* XXX: decode_tile_configuration() [Table 9] */
471 {
472     uint16_t num_samples[WMALL_MAX_CHANNELS];        /**< sum of samples for all currently known subframes of a channel */
473     uint8_t  contains_subframe[WMALL_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
474     int channels_for_cur_subframe = s->num_channels;  /**< number of channels that contain the current subframe */
475     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subfra2me offsets and sizes */
476     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
477     int c;
478
479     /* Should never consume more than 3073 bits (256 iterations for the
480      * while loop when always the minimum amount of 128 samples is substracted
481      * from missing samples in the 8 channel case).
482      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
483      */
484
485     /** reset tiling information */
486     for (c = 0; c < s->num_channels; c++)
487         s->channel[c].num_subframes = 0;
488
489     memset(num_samples, 0, sizeof(num_samples));
490
491     if (s->max_num_subframes == 1 || get_bits1(&s->gb))     // XXX: locate in the spec
492         fixed_channel_layout = 1;                           // XXX: tile_aligned ?
493
494     /** loop until the frame data is split between the subframes */
495     do {
496         int subframe_len;
497
498         /** check which channels contain the subframe */
499         for (c = 0; c < s->num_channels; c++) {
500             if (num_samples[c] == min_channel_len) {
501                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
502                     (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
503                     contains_subframe[c] = 1;
504                 }
505                 else {
506                     contains_subframe[c] = get_bits1(&s->gb);   // XXX: locate in the spec
507                 }
508             } else
509                 contains_subframe[c] = 0;
510         }
511
512         /** get subframe length, subframe_len == 0 is not allowed */
513         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)   //XXX: this reads tile_size_ratio
514             return AVERROR_INVALIDDATA;
515         /** add subframes to the individual channels and find new min_channel_len */
516         min_channel_len += subframe_len;
517         for (c = 0; c < s->num_channels; c++) {
518             WmallChannelCtx* chan = &s->channel[c];
519
520             if (contains_subframe[c]) {
521                 if (chan->num_subframes >= MAX_SUBFRAMES) {
522                     av_log(s->avctx, AV_LOG_ERROR,
523                            "broken frame: num subframes > 31\n");
524                     return AVERROR_INVALIDDATA;
525                 }
526                 chan->subframe_len[chan->num_subframes] = subframe_len;
527                 num_samples[c] += subframe_len;
528                 ++chan->num_subframes;
529                 if (num_samples[c] > s->samples_per_frame) {
530                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
531                            "channel len(%d) > samples_per_frame(%d)\n",
532                            num_samples[c], s->samples_per_frame);
533                     return AVERROR_INVALIDDATA;
534                 }
535             } else if (num_samples[c] <= min_channel_len) {
536                 if (num_samples[c] < min_channel_len) {
537                     channels_for_cur_subframe = 0;
538                     min_channel_len = num_samples[c];
539                 }
540                 ++channels_for_cur_subframe;
541             }
542         }
543     } while (min_channel_len < s->samples_per_frame);
544
545     for (c = 0; c < s->num_channels; c++) {
546         int i;
547         int offset = 0;
548         for (i = 0; i < s->channel[c].num_subframes; i++) {
549             s->channel[c].subframe_offset[i] = offset;
550             offset += s->channel[c].subframe_len[i];
551         }
552     }
553
554     return 0;
555 }
556
557
558 static int my_log2(unsigned int i)
559 {
560     unsigned int iLog2 = 0;
561     while ((i >> iLog2) > 1)
562         iLog2++;
563     return iLog2;
564 }
565
566
567 /**
568  *
569  */
570 static void decode_ac_filter(WmallDecodeCtx *s)
571 {
572     int i;
573     s->acfilter_order = get_bits(&s->gb, 4) + 1;
574     s->acfilter_scaling = get_bits(&s->gb, 4);
575
576     for(i = 0; i < s->acfilter_order; i++) {
577         s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
578     }
579 }
580
581
582 /**
583  *
584  */
585 static void decode_mclms(WmallDecodeCtx *s)
586 {
587     s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
588     s->mclms_scaling = get_bits(&s->gb, 4);
589     if(get_bits1(&s->gb)) {
590         // mclms_send_coef
591         int i;
592         int send_coef_bits;
593         int cbits = av_log2(s->mclms_scaling + 1);
594         assert(cbits == my_log2(s->mclms_scaling + 1));
595         if(1 << cbits < s->mclms_scaling + 1)
596             cbits++;
597
598         send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
599
600         for(i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++) {
601             s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
602         }
603
604         for(i = 0; i < s->num_channels; i++) {
605             int c;
606             for(c = 0; c < i; c++) {
607                 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
608             }
609         }
610     }
611 }
612
613
614 /**
615  *
616  */
617 static void decode_cdlms(WmallDecodeCtx *s)
618 {
619     int c, i;
620     int cdlms_send_coef = get_bits1(&s->gb);
621
622     for(c = 0; c < s->num_channels; c++) {
623         s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
624         for(i = 0; i < s->cdlms_ttl[c]; i++) {
625             s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
626         }
627
628         for(i = 0; i < s->cdlms_ttl[c]; i++) {
629             s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
630         }
631
632         if(cdlms_send_coef) {
633             for(i = 0; i < s->cdlms_ttl[c]; i++) {
634                 int cbits, shift_l, shift_r, j;
635                 cbits = av_log2(s->cdlms[c][i].order);
636                 if(1 << cbits < s->cdlms[c][i].order)
637                     cbits++;
638                 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
639
640                 cbits = av_log2(s->cdlms[c][i].scaling + 1);
641                 if(1 << cbits < s->cdlms[c][i].scaling + 1)
642                     cbits++;
643
644                 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
645                 shift_l = 32 - s->cdlms[c][i].bitsend;
646                 shift_r = 32 - 2 - s->cdlms[c][i].scaling;
647                 for(j = 0; j < s->cdlms[c][i].coefsend; j++) {
648                     s->cdlms[c][i].coefs[j] =
649                         (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
650                 }
651             }
652         }
653     }
654 }
655
656 /**
657  *
658  */
659 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
660 {
661     int i = 0;
662     unsigned int ave_mean;
663     s->transient[ch] = get_bits1(&s->gb);
664     if(s->transient[ch])
665         s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
666
667     if(s->seekable_tile) {
668         ave_mean = get_bits(&s->gb, s->bits_per_sample);
669         s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
670 //        s->ave_sum[ch] *= 2;
671     }
672
673     if(s->seekable_tile) {
674         if(s->do_inter_ch_decorr)
675             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
676         else
677             s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
678         i++;
679     }
680     for(; i < tile_size; i++) {
681         int quo = 0, rem, rem_bits, residue;
682         while(get_bits1(&s->gb))
683             quo++;
684         if(quo >= 32)
685             quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
686
687                ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
688         rem_bits = av_ceil_log2(ave_mean);
689         rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
690         residue = (quo << rem_bits) + rem;
691
692         s->ave_sum[ch] = residue + s->ave_sum[ch] - (s->ave_sum[ch] >> s->movave_scaling);
693
694         if(residue & 1)
695             residue = -(residue >> 1) - 1;
696         else
697             residue = residue >> 1;
698         s->channel_residues[ch][i] = residue;
699
700 //        dprintf(s->avctx, "%5d: %5d %10d %12d %12d %5d %-16d %04x\n",i, quo, ave_mean, s->ave_sum[ch], rem, rem_bits, s->channel_residues[ch][i], show_bits(&s->gb, 16));
701     }
702
703     return 0;
704
705 }
706
707
708 /**
709  *
710  */
711 static void
712 decode_lpc(WmallDecodeCtx *s)
713 {
714     int ch, i, cbits;
715     s->lpc_order = get_bits(&s->gb, 5) + 1;
716     s->lpc_scaling = get_bits(&s->gb, 4);
717     s->lpc_intbits = get_bits(&s->gb, 3) + 1;
718     cbits = s->lpc_scaling + s->lpc_intbits;
719     for(ch = 0; ch < s->num_channels; ch++) {
720         for(i = 0; i < s->lpc_order; i++) {
721             s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
722         }
723     }
724 }
725
726
727 static void clear_codec_buffers(WmallDecodeCtx *s)
728 {
729     int ich, ilms;
730
731     memset(s->acfilter_coeffs, 0,     16 * sizeof(int));
732     memset(s->lpc_coefs      , 0, 40 * 2 * sizeof(int));
733
734     memset(s->mclms_coeffs    , 0, 128 * sizeof(int16_t));
735     memset(s->mclms_coeffs_cur, 0,   4 * sizeof(int16_t));
736     memset(s->mclms_prevvalues, 0,  64 * sizeof(int));
737     memset(s->mclms_updates   , 0,  64 * sizeof(int16_t));
738
739     for (ich = 0; ich < s->num_channels; ich++) {
740         for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
741             memset(s->cdlms[ich][ilms].coefs         , 0, 256 * sizeof(int16_t));
742             memset(s->cdlms[ich][ilms].lms_prevvalues, 0, 512 * sizeof(int));
743             memset(s->cdlms[ich][ilms].lms_updates   , 0, 512 * sizeof(int16_t));
744         }
745         s->ave_sum[ich] = 0;
746     }
747 }
748
749 /**
750  *@brief Decode a single subframe (block).
751  *@param s codec context
752  *@return 0 on success, < 0 when decoding failed
753  */
754 static int decode_subframe(WmallDecodeCtx *s)
755 {
756     int offset = s->samples_per_frame;
757     int subframe_len = s->samples_per_frame;
758     int i;
759     int total_samples   = s->samples_per_frame * s->num_channels;
760     int rawpcm_tile;
761     int padding_zeroes;
762
763     s->subframe_offset = get_bits_count(&s->gb);
764
765     /** reset channel context and find the next block offset and size
766         == the next block of the channel with the smallest number of
767         decoded samples
768     */
769     for (i = 0; i < s->num_channels; i++) {
770         s->channel[i].grouped = 0;
771         if (offset > s->channel[i].decoded_samples) {
772             offset = s->channel[i].decoded_samples;
773             subframe_len =
774                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
775         }
776     }
777
778     /** get a list of all channels that contain the estimated block */
779     s->channels_for_cur_subframe = 0;
780     for (i = 0; i < s->num_channels; i++) {
781         const int cur_subframe = s->channel[i].cur_subframe;
782         /** substract already processed samples */
783         total_samples -= s->channel[i].decoded_samples;
784
785         /** and count if there are multiple subframes that match our profile */
786         if (offset == s->channel[i].decoded_samples &&
787             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
788             total_samples -= s->channel[i].subframe_len[cur_subframe];
789             s->channel[i].decoded_samples +=
790                 s->channel[i].subframe_len[cur_subframe];
791             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
792             ++s->channels_for_cur_subframe;
793         }
794     }
795
796     /** check if the frame will be complete after processing the
797         estimated block */
798     if (!total_samples)
799         s->parsed_all_subframes = 1;
800
801
802     s->seekable_tile = get_bits1(&s->gb);
803     if(s->seekable_tile) {
804         // XXX: 6.2.2 clear_codec_buffers()
805
806         s->do_arith_coding    = get_bits1(&s->gb);
807         if(s->do_arith_coding) {
808             dprintf(s->avctx, "do_arith_coding == 1");
809             abort();
810         }
811         s->do_ac_filter       = get_bits1(&s->gb);
812         s->do_inter_ch_decorr = get_bits1(&s->gb);
813         s->do_mclms           = get_bits1(&s->gb);
814
815         if(s->do_ac_filter)
816             decode_ac_filter(s);
817
818         if(s->do_mclms)
819             decode_mclms(s);
820
821         decode_cdlms(s);
822         s->movave_scaling = get_bits(&s->gb, 3);
823         s->quant_stepsize = get_bits(&s->gb, 8) + 1;
824
825             // XXX: 6.2.2 reset_codec()
826     }
827
828     rawpcm_tile = get_bits1(&s->gb);
829
830     for(i = 0; i < s->num_channels; i++) {
831         s->is_channel_coded[i] = 1;
832     }
833
834     if(!rawpcm_tile) {
835
836         for(i = 0; i < s->num_channels; i++) {
837             s->is_channel_coded[i] = get_bits1(&s->gb);
838         }
839
840         if(s->bV3RTM) {
841             // LPC
842             s->do_lpc = get_bits1(&s->gb);
843             if(s->do_lpc) {
844                 decode_lpc(s);
845             }
846         } else {
847             s->do_lpc = 0;
848         }
849     }
850
851
852     if(get_bits1(&s->gb)) {
853         padding_zeroes = get_bits(&s->gb, 5);
854     } else {
855         padding_zeroes = 0;
856     }
857
858     if(rawpcm_tile) {
859
860         int bits = s->bits_per_sample - padding_zeroes;
861         int j;
862         dprintf(s->avctx, "RAWPCM %d bits per sample. total %d bits, remain=%d\n", bits,
863                 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
864         for(i = 0; i < s->num_channels; i++) {
865             for(j = 0; j < subframe_len; j++) {
866                 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
867 //                dprintf(s->avctx, "PCM[%d][%d] = 0x%04x\n", i, j, s->channel_coeffs[i][j]);
868             }
869         }
870     } else {
871         for(i = 0; i < s->num_channels; i++)
872             if(s->is_channel_coded[i])
873                 decode_channel_residues(s, i, subframe_len);
874     }
875
876     /** handled one subframe */
877
878     for (i = 0; i < s->channels_for_cur_subframe; i++) {
879         int c = s->channel_indexes_for_cur_subframe[i];
880         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
881             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
882             return AVERROR_INVALIDDATA;
883         }
884         ++s->channel[c].cur_subframe;       // XXX: 6.4
885     }
886     return 0;
887 }
888
889 /**
890  *@brief Decode one WMA frame.
891  *@param s codec context
892  *@return 0 if the trailer bit indicates that this is the last frame,
893  *        1 if there are additional frames
894  */
895 static int decode_frame(WmallDecodeCtx *s)
896 {
897     GetBitContext* gb = &s->gb;
898     int more_frames = 0;
899     int len = 0;
900     int i;
901
902     /** check for potential output buffer overflow */
903     if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
904         /** return an error if no frame could be decoded at all */
905         av_log(s->avctx, AV_LOG_ERROR,
906                "not enough space for the output samples\n");
907         s->packet_loss = 1;
908         return 0;
909     }
910
911     /** get frame length */
912     if (s->len_prefix)
913         len = get_bits(gb, s->log2_frame_size);     // XXX: compressed_frame_size_bits [Table 8]
914
915     /** decode tile information */
916     if (decode_tilehdr(s)) {    // should include decode_tile_configuration() [Table 9]
917         s->packet_loss = 1;
918         return 0;
919     }
920
921     /** read drc info */
922     if (s->dynamic_range_compression) {
923         s->drc_gain = get_bits(gb, 8);      // XXX: drc_frame_scale_factor [Table 8]
924     }
925
926     /** no idea what these are for, might be the number of samples
927         that need to be skipped at the beginning or end of a stream */
928     if (get_bits1(gb)) {
929         int skip;
930
931         /** usually true for the first frame */
932         if (get_bits1(gb)) {
933             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
934             dprintf(s->avctx, "start skip: %i\n", skip);
935         }
936
937         /** sometimes true for the last frame */
938         if (get_bits1(gb)) {
939             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
940             dprintf(s->avctx, "end skip: %i\n", skip);
941         }
942
943     }
944
945     /** reset subframe states */
946     s->parsed_all_subframes = 0;
947     for (i = 0; i < s->num_channels; i++) {
948         s->channel[i].decoded_samples = 0;
949         s->channel[i].cur_subframe    = 0;
950         s->channel[i].reuse_sf        = 0;
951     }
952
953     /** decode all subframes */
954     while (!s->parsed_all_subframes) {
955         if (decode_subframe(s) < 0) {
956             s->packet_loss = 1;
957             return 0;
958         }
959     }
960
961     dprintf(s->avctx, "Frame done\n");
962
963     if (s->skip_frame) {
964         s->skip_frame = 0;
965     } else
966         s->samples += s->num_channels * s->samples_per_frame;
967
968     if (s->len_prefix) {
969         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
970             /** FIXME: not sure if this is always an error */
971             av_log(s->avctx, AV_LOG_ERROR,
972                    "frame[%i] would have to skip %i bits\n", s->frame_num,
973                    len - (get_bits_count(gb) - s->frame_offset) - 1);
974             s->packet_loss = 1;
975             return 0;
976         }
977
978         /** skip the rest of the frame data */
979         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
980     } else {
981 /*
982         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
983             dprintf(s->avctx, "skip1\n");
984         }
985 */
986     }
987
988     /** decode trailer bit */
989     more_frames = get_bits1(gb);
990     ++s->frame_num;
991     return more_frames;
992 }
993
994 /**
995  *@brief Calculate remaining input buffer length.
996  *@param s codec context
997  *@param gb bitstream reader context
998  *@return remaining size in bits
999  */
1000 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1001 {
1002     return s->buf_bit_size - get_bits_count(gb);
1003 }
1004
1005 /**
1006  *@brief Fill the bit reservoir with a (partial) frame.
1007  *@param s codec context
1008  *@param gb bitstream reader context
1009  *@param len length of the partial frame
1010  *@param append decides wether to reset the buffer or not
1011  */
1012 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1013                       int append)
1014 {
1015     int buflen;
1016
1017     /** when the frame data does not need to be concatenated, the input buffer
1018         is resetted and additional bits from the previous frame are copyed
1019         and skipped later so that a fast byte copy is possible */
1020
1021     if (!append) {
1022         s->frame_offset = get_bits_count(gb) & 7;
1023         s->num_saved_bits = s->frame_offset;
1024         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1025     }
1026
1027     buflen = (s->num_saved_bits + len + 8) >> 3;
1028
1029     if (len <= 0 || buflen > MAX_FRAMESIZE) {
1030         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1031         s->packet_loss = 1;
1032         return;
1033     }
1034
1035     s->num_saved_bits += len;
1036     if (!append) {
1037         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1038                      s->num_saved_bits);
1039     } else {
1040         int align = 8 - (get_bits_count(gb) & 7);
1041         align = FFMIN(align, len);
1042         put_bits(&s->pb, align, get_bits(gb, align));
1043         len -= align;
1044         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1045     }
1046     skip_bits_long(gb, len);
1047
1048     {
1049         PutBitContext tmp = s->pb;
1050         flush_put_bits(&tmp);
1051     }
1052
1053     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1054     skip_bits(&s->gb, s->frame_offset);
1055 }
1056
1057 /**
1058  *@brief Decode a single WMA packet.
1059  *@param avctx codec context
1060  *@param data the output buffer
1061  *@param data_size number of bytes that were written to the output buffer
1062  *@param avpkt input packet
1063  *@return number of bytes that were read from the input buffer
1064  */
1065 static int decode_packet(AVCodecContext *avctx,
1066                          void *data, int *data_size, AVPacket* avpkt)
1067 {
1068     WmallDecodeCtx *s = avctx->priv_data;
1069     GetBitContext* gb  = &s->pgb;
1070     const uint8_t* buf = avpkt->data;
1071     int buf_size       = avpkt->size;
1072     int num_bits_prev_frame;
1073     int packet_sequence_number;
1074
1075     s->samples       = data;
1076     s->samples_end   = (float*)((int8_t*)data + *data_size);
1077     *data_size = 0;
1078
1079     if (s->packet_done || s->packet_loss) {
1080         s->packet_done = 0;
1081
1082         /** sanity check for the buffer length */
1083         if (buf_size < avctx->block_align)
1084             return 0;
1085
1086         s->next_packet_start = buf_size - avctx->block_align;
1087         buf_size = avctx->block_align;
1088         s->buf_bit_size = buf_size << 3;
1089
1090         /** parse packet header */
1091         init_get_bits(gb, buf, s->buf_bit_size);
1092         packet_sequence_number = get_bits(gb, 4);
1093         int seekable_frame_in_packet = get_bits1(gb);
1094         int spliced_packet = get_bits1(gb);
1095
1096         /** get number of bits that need to be added to the previous frame */
1097         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1098
1099         /** check for packet loss */
1100         if (!s->packet_loss &&
1101             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1102             s->packet_loss = 1;
1103             av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1104                    s->packet_sequence_number, packet_sequence_number);
1105         }
1106         s->packet_sequence_number = packet_sequence_number;
1107
1108         if (num_bits_prev_frame > 0) {
1109             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1110             if (num_bits_prev_frame >= remaining_packet_bits) {
1111                 num_bits_prev_frame = remaining_packet_bits;
1112                 s->packet_done = 1;
1113             }
1114
1115             /** append the previous frame data to the remaining data from the
1116                 previous packet to create a full frame */
1117             save_bits(s, gb, num_bits_prev_frame, 1);
1118
1119             /** decode the cross packet frame if it is valid */
1120             if (!s->packet_loss)
1121                 decode_frame(s);
1122         } else if (s->num_saved_bits - s->frame_offset) {
1123             dprintf(avctx, "ignoring %x previously saved bits\n",
1124                     s->num_saved_bits - s->frame_offset);
1125         }
1126
1127         if (s->packet_loss) {
1128             /** reset number of saved bits so that the decoder
1129                 does not start to decode incomplete frames in the
1130                 s->len_prefix == 0 case */
1131             s->num_saved_bits = 0;
1132             s->packet_loss = 0;
1133         }
1134
1135     } else {
1136         int frame_size;
1137
1138         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1139         init_get_bits(gb, avpkt->data, s->buf_bit_size);
1140         skip_bits(gb, s->packet_offset);
1141
1142         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1143             (frame_size = show_bits(gb, s->log2_frame_size)) &&
1144             frame_size <= remaining_bits(s, gb)) {
1145             save_bits(s, gb, frame_size, 0);
1146             s->packet_done = !decode_frame(s);
1147         } else if (!s->len_prefix
1148                    && s->num_saved_bits > get_bits_count(&s->gb)) {
1149             /** when the frames do not have a length prefix, we don't know
1150                 the compressed length of the individual frames
1151                 however, we know what part of a new packet belongs to the
1152                 previous frame
1153                 therefore we save the incoming packet first, then we append
1154                 the "previous frame" data from the next packet so that
1155                 we get a buffer that only contains full frames */
1156             s->packet_done = !decode_frame(s);
1157         } else {
1158             s->packet_done = 1;
1159         }
1160     }
1161
1162     if (s->packet_done && !s->packet_loss &&
1163         remaining_bits(s, gb) > 0) {
1164         /** save the rest of the data so that it can be decoded
1165             with the next packet */
1166         save_bits(s, gb, remaining_bits(s, gb), 0);
1167     }
1168
1169     *data_size = 0; // (int8_t *)s->samples - (int8_t *)data;
1170     s->packet_offset = get_bits_count(gb) & 7;
1171
1172     return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1173 }
1174
1175 /**
1176  *@brief Clear decoder buffers (for seeking).
1177  *@param avctx codec context
1178  */
1179 static void flush(AVCodecContext *avctx)
1180 {
1181     WmallDecodeCtx *s = avctx->priv_data;
1182     int i;
1183     /** reset output buffer as a part of it is used during the windowing of a
1184         new frame */
1185     for (i = 0; i < s->num_channels; i++)
1186         memset(s->channel[i].out, 0, s->samples_per_frame *
1187                sizeof(*s->channel[i].out));
1188     s->packet_loss = 1;
1189 }
1190
1191
1192 /**
1193  *@brief wmall decoder
1194  */
1195 AVCodec ff_wmalossless_decoder = {
1196     "wmalossless",
1197     AVMEDIA_TYPE_AUDIO,
1198     CODEC_ID_WMALOSSLESS,
1199     sizeof(WmallDecodeCtx),
1200     decode_init,
1201     NULL,
1202     decode_end,
1203     decode_packet,
1204     .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_EXPERIMENTAL,
1205     .flush= flush,
1206     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Lossless"),
1207 };