FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wmalosslessdec.c
Go to the documentation of this file.
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
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
62 
63 /**
64  * @brief main decoder context
65  */
66 typedef struct WmallDecodeCtx {
67  /* generic decoder variables */
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
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
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
112 
114 
115  // WMA Lossless-specific
116 
122 
125  int64_t acfilter_coeffs[16];
127 
128  int8_t mclms_order;
130  int16_t mclms_coeffs[128];
131  int16_t mclms_coeffs_cur[4];
135 
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 
155  int update_speed[2];
156 
157  int transient[2];
160 
161  int ave_sum[2];
162 
164 
165  int lpc_coefs[2][40];
169 
172 
173 
175 {
176  WmallDecodeCtx *s = avctx->priv_data;
177  uint8_t *edata_ptr = avctx->extradata;
178  unsigned int channel_mask;
179  int i, log2_max_num_subframes;
180 
181  s->avctx = avctx;
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)
190  else if (s->bits_per_sample == 24) {
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_PATCHWELCOME;
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 */
219  3, s->decode_flags);
221 
222  /* init previous block len */
223  for (i = 0; i < avctx->channels; i++)
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 
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 
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  */
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  */
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) {
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) {
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 
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 ?
410  get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
411 }
412 
414 {
415  s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
416  s->mclms_scaling = get_bits(&s->gb, 4);
417  if (get_bits1(&s->gb)) {
418  int i, send_coef_bits;
419  int cbits = av_log2(s->mclms_scaling + 1);
420  if (1 << cbits < s->mclms_scaling + 1)
421  cbits++;
422 
423  send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
424 
425  for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
426  s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
427 
428  for (i = 0; i < s->num_channels; i++) {
429  int c;
430  for (c = 0; c < i; c++)
431  s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
432  }
433  }
434 }
435 
437 {
438  int c, i;
439  int cdlms_send_coef = get_bits1(&s->gb);
440 
441  for (c = 0; c < s->num_channels; c++) {
442  s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
443  for (i = 0; i < s->cdlms_ttl[c]; i++) {
444  s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
445  if (s->cdlms[c][i].order > MAX_ORDER) {
447  "Order[%d][%d] %d > max (%d), not supported\n",
448  c, i, s->cdlms[c][i].order, MAX_ORDER);
449  s->cdlms[0][0].order = 0;
450  return AVERROR_INVALIDDATA;
451  }
452  }
453 
454  for (i = 0; i < s->cdlms_ttl[c]; i++)
455  s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
456 
457  if (cdlms_send_coef) {
458  for (i = 0; i < s->cdlms_ttl[c]; i++) {
459  int cbits, shift_l, shift_r, j;
460  cbits = av_log2(s->cdlms[c][i].order);
461  if ((1 << cbits) < s->cdlms[c][i].order)
462  cbits++;
463  s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
464 
465  cbits = av_log2(s->cdlms[c][i].scaling + 1);
466  if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
467  cbits++;
468 
469  s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
470  shift_l = 32 - s->cdlms[c][i].bitsend;
471  shift_r = 32 - s->cdlms[c][i].scaling - 2;
472  for (j = 0; j < s->cdlms[c][i].coefsend; j++)
473  s->cdlms[c][i].coefs[j] =
474  (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
475  }
476  }
477  }
478 
479  return 0;
480 }
481 
482 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
483 {
484  int i = 0;
485  unsigned int ave_mean;
486  s->transient[ch] = get_bits1(&s->gb);
487  if (s->transient[ch]) {
488  s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
489  if (s->transient_pos[ch])
490  s->transient[ch] = 0;
491  s->channel[ch].transient_counter =
493  } else if (s->channel[ch].transient_counter)
494  s->transient[ch] = 1;
495 
496  if (s->seekable_tile) {
497  ave_mean = get_bits(&s->gb, s->bits_per_sample);
498  s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
499  }
500 
501  if (s->seekable_tile) {
502  if (s->do_inter_ch_decorr)
503  s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
504  else
505  s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
506  i++;
507  }
508  for (; i < tile_size; i++) {
509  int quo = 0, rem, rem_bits, residue;
510  while(get_bits1(&s->gb)) {
511  quo++;
512  if (get_bits_left(&s->gb) <= 0)
513  return -1;
514  }
515  if (quo >= 32)
516  quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
517 
518  ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
519  if (ave_mean <= 1)
520  residue = quo;
521  else {
522  rem_bits = av_ceil_log2(ave_mean);
523  rem = get_bits_long(&s->gb, rem_bits);
524  residue = (quo << rem_bits) + rem;
525  }
526 
527  s->ave_sum[ch] = residue + s->ave_sum[ch] -
528  (s->ave_sum[ch] >> s->movave_scaling);
529 
530  if (residue & 1)
531  residue = -(residue >> 1) - 1;
532  else
533  residue = residue >> 1;
534  s->channel_residues[ch][i] = residue;
535  }
536 
537  return 0;
538 
539 }
540 
541 static void decode_lpc(WmallDecodeCtx *s)
542 {
543  int ch, i, cbits;
544  s->lpc_order = get_bits(&s->gb, 5) + 1;
545  s->lpc_scaling = get_bits(&s->gb, 4);
546  s->lpc_intbits = get_bits(&s->gb, 3) + 1;
547  cbits = s->lpc_scaling + s->lpc_intbits;
548  for (ch = 0; ch < s->num_channels; ch++)
549  for (i = 0; i < s->lpc_order; i++)
550  s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
551 }
552 
554 {
555  int ich, ilms;
556 
557  memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
558  memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
559  memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
560 
561  memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
562  memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
563  memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
564  memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
565 
566  for (ich = 0; ich < s->num_channels; ich++) {
567  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
568  memset(s->cdlms[ich][ilms].coefs, 0,
569  sizeof(s->cdlms[ich][ilms].coefs));
570  memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
571  sizeof(s->cdlms[ich][ilms].lms_prevvalues));
572  memset(s->cdlms[ich][ilms].lms_updates, 0,
573  sizeof(s->cdlms[ich][ilms].lms_updates));
574  }
575  s->ave_sum[ich] = 0;
576  }
577 }
578 
579 /**
580  * @brief Reset filter parameters and transient area at new seekable tile.
581  */
583 {
584  int ich, ilms;
586  for (ich = 0; ich < s->num_channels; ich++) {
587  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
588  s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
589  /* first sample of a seekable subframe is considered as the starting of
590  a transient area which is samples_per_frame samples long */
592  s->transient[ich] = 1;
593  s->transient_pos[ich] = 0;
594  }
595 }
596 
597 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
598 {
599  int i, j, ich, pred_error;
600  int order = s->mclms_order;
601  int num_channels = s->num_channels;
602  int range = 1 << (s->bits_per_sample - 1);
603 
604  for (ich = 0; ich < num_channels; ich++) {
605  pred_error = s->channel_residues[ich][icoef] - pred[ich];
606  if (pred_error > 0) {
607  for (i = 0; i < order * num_channels; i++)
608  s->mclms_coeffs[i + ich * order * num_channels] +=
609  s->mclms_updates[s->mclms_recent + i];
610  for (j = 0; j < ich; j++) {
611  if (s->channel_residues[j][icoef] > 0)
612  s->mclms_coeffs_cur[ich * num_channels + j] += 1;
613  else if (s->channel_residues[j][icoef] < 0)
614  s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
615  }
616  } else if (pred_error < 0) {
617  for (i = 0; i < order * num_channels; i++)
618  s->mclms_coeffs[i + ich * order * num_channels] -=
619  s->mclms_updates[s->mclms_recent + i];
620  for (j = 0; j < ich; j++) {
621  if (s->channel_residues[j][icoef] > 0)
622  s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
623  else if (s->channel_residues[j][icoef] < 0)
624  s->mclms_coeffs_cur[ich * num_channels + j] += 1;
625  }
626  }
627  }
628 
629  for (ich = num_channels - 1; ich >= 0; ich--) {
630  s->mclms_recent--;
631  s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
632  if (s->channel_residues[ich][icoef] > range - 1)
633  s->mclms_prevvalues[s->mclms_recent] = range - 1;
634  else if (s->channel_residues[ich][icoef] < -range)
635  s->mclms_prevvalues[s->mclms_recent] = -range;
636 
637  s->mclms_updates[s->mclms_recent] = 0;
638  if (s->channel_residues[ich][icoef] > 0)
639  s->mclms_updates[s->mclms_recent] = 1;
640  else if (s->channel_residues[ich][icoef] < 0)
641  s->mclms_updates[s->mclms_recent] = -1;
642  }
643 
644  if (s->mclms_recent == 0) {
645  memcpy(&s->mclms_prevvalues[order * num_channels],
646  s->mclms_prevvalues,
647  2 * order * num_channels);
648  memcpy(&s->mclms_updates[order * num_channels],
649  s->mclms_updates,
650  2 * order * num_channels);
651  s->mclms_recent = num_channels * order;
652  }
653 }
654 
655 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
656 {
657  int ich, i;
658  int order = s->mclms_order;
659  int num_channels = s->num_channels;
660 
661  for (ich = 0; ich < num_channels; ich++) {
662  pred[ich] = 0;
663  if (!s->is_channel_coded[ich])
664  continue;
665  for (i = 0; i < order * num_channels; i++)
666  pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
667  s->mclms_coeffs[i + order * num_channels * ich];
668  for (i = 0; i < ich; i++)
669  pred[ich] += s->channel_residues[i][icoef] *
670  s->mclms_coeffs_cur[i + num_channels * ich];
671  pred[ich] += 1 << s->mclms_scaling - 1;
672  pred[ich] >>= s->mclms_scaling;
673  s->channel_residues[ich][icoef] += pred[ich];
674  }
675 }
676 
677 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
678 {
679  int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
680  for (icoef = 0; icoef < tile_size; icoef++) {
681  mclms_predict(s, icoef, pred);
682  mclms_update(s, icoef, pred);
683  }
684 }
685 
686 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
687 {
688  int pred = 0, icoef;
689  int recent = s->cdlms[ich][ilms].recent;
690 
691  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
692  pred += s->cdlms[ich][ilms].coefs[icoef] *
693  s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
694 
695  return pred;
696 }
697 
698 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
699  int input, int residue)
700 {
701  int icoef;
702  int recent = s->cdlms[ich][ilms].recent;
703  int range = 1 << s->bits_per_sample - 1;
704 
705  if (residue < 0) {
706  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
707  s->cdlms[ich][ilms].coefs[icoef] -=
708  s->cdlms[ich][ilms].lms_updates[icoef + recent];
709  } else if (residue > 0) {
710  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
711  s->cdlms[ich][ilms].coefs[icoef] +=
712  s->cdlms[ich][ilms].lms_updates[icoef + recent];
713  }
714 
715  if (recent)
716  recent--;
717  else {
718  memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
719  s->cdlms[ich][ilms].lms_prevvalues,
720  2 * s->cdlms[ich][ilms].order);
721  memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
722  s->cdlms[ich][ilms].lms_updates,
723  2 * s->cdlms[ich][ilms].order);
724  recent = s->cdlms[ich][ilms].order - 1;
725  }
726 
727  s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
728  if (!input)
729  s->cdlms[ich][ilms].lms_updates[recent] = 0;
730  else if (input < 0)
731  s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
732  else
733  s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
734 
735  s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
736  s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
737  s->cdlms[ich][ilms].recent = recent;
738 }
739 
740 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
741 {
742  int ilms, recent, icoef;
743  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
744  recent = s->cdlms[ich][ilms].recent;
745  if (s->update_speed[ich] == 16)
746  continue;
747  if (s->bV3RTM) {
748  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
749  s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
750  } else {
751  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
752  s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
753  }
754  }
755  s->update_speed[ich] = 16;
756 }
757 
758 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
759 {
760  int ilms, recent, icoef;
761  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
762  recent = s->cdlms[ich][ilms].recent;
763  if (s->update_speed[ich] == 8)
764  continue;
765  if (s->bV3RTM)
766  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
767  s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
768  else
769  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
770  s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
771  }
772  s->update_speed[ich] = 8;
773 }
774 
775 static void revert_cdlms(WmallDecodeCtx *s, int ch,
776  int coef_begin, int coef_end)
777 {
778  int icoef, pred, ilms, num_lms, residue, input;
779 
780  num_lms = s->cdlms_ttl[ch];
781  for (ilms = num_lms - 1; ilms >= 0; ilms--) {
782  for (icoef = coef_begin; icoef < coef_end; icoef++) {
783  pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
784  residue = s->channel_residues[ch][icoef];
785  pred += lms_predict(s, ch, ilms);
786  input = residue + (pred >> s->cdlms[ch][ilms].scaling);
787  lms_update(s, ch, ilms, input, residue);
788  s->channel_residues[ch][icoef] = input;
789  }
790  }
791 }
792 
793 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
794 {
795  if (s->num_channels != 2)
796  return;
797  else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
798  int icoef;
799  for (icoef = 0; icoef < tile_size; icoef++) {
800  s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
801  s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
802  }
803  }
804 }
805 
806 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
807 {
808  int ich, pred, i, j;
809  int64_t *filter_coeffs = s->acfilter_coeffs;
810  int scaling = s->acfilter_scaling;
811  int order = s->acfilter_order;
812 
813  for (ich = 0; ich < s->num_channels; ich++) {
814  int *prevvalues = s->acfilter_prevvalues[ich];
815  for (i = 0; i < order; i++) {
816  pred = 0;
817  for (j = 0; j < order; j++) {
818  if (i <= j)
819  pred += filter_coeffs[j] * prevvalues[j - i];
820  else
821  pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
822  }
823  pred >>= scaling;
824  s->channel_residues[ich][i] += pred;
825  }
826  for (i = order; i < tile_size; i++) {
827  pred = 0;
828  for (j = 0; j < order; j++)
829  pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
830  pred >>= scaling;
831  s->channel_residues[ich][i] += pred;
832  }
833  for (j = 0; j < order; j++)
834  prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
835  }
836 }
837 
839 {
840  int offset = s->samples_per_frame;
841  int subframe_len = s->samples_per_frame;
842  int total_samples = s->samples_per_frame * s->num_channels;
843  int i, j, rawpcm_tile, padding_zeroes, res;
844 
846 
847  /* reset channel context and find the next block offset and size
848  == the next block of the channel with the smallest number of
849  decoded samples */
850  for (i = 0; i < s->num_channels; i++) {
851  if (offset > s->channel[i].decoded_samples) {
852  offset = s->channel[i].decoded_samples;
853  subframe_len =
855  }
856  }
857 
858  /* get a list of all channels that contain the estimated block */
860  for (i = 0; i < s->num_channels; i++) {
861  const int cur_subframe = s->channel[i].cur_subframe;
862  /* subtract already processed samples */
863  total_samples -= s->channel[i].decoded_samples;
864 
865  /* and count if there are multiple subframes that match our profile */
866  if (offset == s->channel[i].decoded_samples &&
867  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
868  total_samples -= s->channel[i].subframe_len[cur_subframe];
869  s->channel[i].decoded_samples +=
870  s->channel[i].subframe_len[cur_subframe];
873  }
874  }
875 
876  /* check if the frame will be complete after processing the
877  estimated block */
878  if (!total_samples)
879  s->parsed_all_subframes = 1;
880 
881 
882  s->seekable_tile = get_bits1(&s->gb);
883  if (s->seekable_tile) {
885 
886  s->do_arith_coding = get_bits1(&s->gb);
887  if (s->do_arith_coding) {
888  av_log_missing_feature(s->avctx, "Arithmetic coding", 1);
889  return AVERROR_PATCHWELCOME;
890  }
891  s->do_ac_filter = get_bits1(&s->gb);
892  s->do_inter_ch_decorr = get_bits1(&s->gb);
893  s->do_mclms = get_bits1(&s->gb);
894 
895  if (s->do_ac_filter)
896  decode_ac_filter(s);
897 
898  if (s->do_mclms)
899  decode_mclms(s);
900 
901  if ((res = decode_cdlms(s)) < 0)
902  return res;
903  s->movave_scaling = get_bits(&s->gb, 3);
904  s->quant_stepsize = get_bits(&s->gb, 8) + 1;
905 
906  reset_codec(s);
907  } else if (!s->cdlms[0][0].order) {
909  "Waiting for seekable tile\n");
910  s->frame.nb_samples = 0;
911  return -1;
912  }
913 
914  rawpcm_tile = get_bits1(&s->gb);
915 
916  for (i = 0; i < s->num_channels; i++)
917  s->is_channel_coded[i] = 1;
918 
919  if (!rawpcm_tile) {
920  for (i = 0; i < s->num_channels; i++)
921  s->is_channel_coded[i] = get_bits1(&s->gb);
922 
923  if (s->bV3RTM) {
924  // LPC
925  s->do_lpc = get_bits1(&s->gb);
926  if (s->do_lpc) {
927  decode_lpc(s);
928  av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
929  "implemented. Expect wrong output.\n");
930  }
931  } else
932  s->do_lpc = 0;
933  }
934 
935 
936  if (get_bits1(&s->gb))
937  padding_zeroes = get_bits(&s->gb, 5);
938  else
939  padding_zeroes = 0;
940 
941  if (rawpcm_tile) {
942  int bits = s->bits_per_sample - padding_zeroes;
943  if (bits <= 0) {
945  "Invalid number of padding bits in raw PCM tile\n");
946  return AVERROR_INVALIDDATA;
947  }
948  av_dlog(s->avctx, "RAWPCM %d bits per sample. "
949  "total %d bits, remain=%d\n", bits,
950  bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
951  for (i = 0; i < s->num_channels; i++)
952  for (j = 0; j < subframe_len; j++)
953  s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
954  } else {
955  for (i = 0; i < s->num_channels; i++)
956  if (s->is_channel_coded[i]) {
957  decode_channel_residues(s, i, subframe_len);
958  if (s->seekable_tile)
959  use_high_update_speed(s, i);
960  else
962  revert_cdlms(s, i, 0, subframe_len);
963  } else {
964  memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
965  }
966  }
967  if (s->do_mclms)
968  revert_mclms(s, subframe_len);
969  if (s->do_inter_ch_decorr)
970  revert_inter_ch_decorr(s, subframe_len);
971  if (s->do_ac_filter)
972  revert_acfilter(s, subframe_len);
973 
974  /* Dequantize */
975  if (s->quant_stepsize != 1)
976  for (i = 0; i < s->num_channels; i++)
977  for (j = 0; j < subframe_len; j++)
978  s->channel_residues[i][j] *= s->quant_stepsize;
979 
980  /* Write to proper output buffer depending on bit-depth */
981  for (i = 0; i < s->channels_for_cur_subframe; i++) {
983  int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
984 
985  for (j = 0; j < subframe_len; j++) {
986  if (s->bits_per_sample == 16) {
987  *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
988  } else {
989  *s->samples_32[c]++ = s->channel_residues[c][j] << padding_zeroes;
990  }
991  }
992  }
993 
994  /* handled one subframe */
995  for (i = 0; i < s->channels_for_cur_subframe; i++) {
997  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
998  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001  ++s->channel[c].cur_subframe;
1002  }
1003  return 0;
1004 }
1005 
1006 /**
1007  * @brief Decode one WMA frame.
1008  * @param s codec context
1009  * @return 0 if the trailer bit indicates that this is the last frame,
1010  * 1 if there are additional frames
1011  */
1013 {
1014  GetBitContext* gb = &s->gb;
1015  int more_frames = 0, len = 0, i, ret;
1016 
1018  if ((ret = ff_get_buffer(s->avctx, &s->frame)) < 0) {
1019  /* return an error if no frame could be decoded at all */
1021  "not enough space for the output samples\n");
1022  s->packet_loss = 1;
1023  return ret;
1024  }
1025  for (i = 0; i < s->num_channels; i++) {
1026  s->samples_16[i] = (int16_t *)s->frame.extended_data[i];
1027  s->samples_32[i] = (int32_t *)s->frame.extended_data[i];
1028  }
1029 
1030  /* get frame length */
1031  if (s->len_prefix)
1032  len = get_bits(gb, s->log2_frame_size);
1033 
1034  /* decode tile information */
1035  if (decode_tilehdr(s)) {
1036  s->packet_loss = 1;
1037  return 0;
1038  }
1039 
1040  /* read drc info */
1042  s->drc_gain = get_bits(gb, 8);
1043 
1044  /* no idea what these are for, might be the number of samples
1045  that need to be skipped at the beginning or end of a stream */
1046  if (get_bits1(gb)) {
1047  int av_unused skip;
1048 
1049  /* usually true for the first frame */
1050  if (get_bits1(gb)) {
1051  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1052  av_dlog(s->avctx, "start skip: %i\n", skip);
1053  }
1054 
1055  /* sometimes true for the last frame */
1056  if (get_bits1(gb)) {
1057  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1058  av_dlog(s->avctx, "end skip: %i\n", skip);
1059  }
1060 
1061  }
1062 
1063  /* reset subframe states */
1064  s->parsed_all_subframes = 0;
1065  for (i = 0; i < s->num_channels; i++) {
1066  s->channel[i].decoded_samples = 0;
1067  s->channel[i].cur_subframe = 0;
1068  }
1069 
1070  /* decode all subframes */
1071  while (!s->parsed_all_subframes) {
1072  if (decode_subframe(s) < 0) {
1073  s->packet_loss = 1;
1074  return 0;
1075  }
1076  }
1077 
1078  av_dlog(s->avctx, "Frame done\n");
1079 
1080  if (s->skip_frame)
1081  s->skip_frame = 0;
1082 
1083  if (s->len_prefix) {
1084  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1085  /* FIXME: not sure if this is always an error */
1087  "frame[%i] would have to skip %i bits\n", s->frame_num,
1088  len - (get_bits_count(gb) - s->frame_offset) - 1);
1089  s->packet_loss = 1;
1090  return 0;
1091  }
1092 
1093  /* skip the rest of the frame data */
1094  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1095  }
1096 
1097  /* decode trailer bit */
1098  more_frames = get_bits1(gb);
1099  ++s->frame_num;
1100  return more_frames;
1101 }
1102 
1103 /**
1104  * @brief Calculate remaining input buffer length.
1105  * @param s codec context
1106  * @param gb bitstream reader context
1107  * @return remaining size in bits
1108  */
1110 {
1111  return s->buf_bit_size - get_bits_count(gb);
1112 }
1113 
1114 /**
1115  * @brief Fill the bit reservoir with a (partial) frame.
1116  * @param s codec context
1117  * @param gb bitstream reader context
1118  * @param len length of the partial frame
1119  * @param append decides whether to reset the buffer or not
1120  */
1121 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1122  int append)
1123 {
1124  int buflen;
1125  PutBitContext tmp;
1126 
1127  /* when the frame data does not need to be concatenated, the input buffer
1128  is reset and additional bits from the previous frame are copied
1129  and skipped later so that a fast byte copy is possible */
1130 
1131  if (!append) {
1132  s->frame_offset = get_bits_count(gb) & 7;
1133  s->num_saved_bits = s->frame_offset;
1135  }
1136 
1137  buflen = (s->num_saved_bits + len + 8) >> 3;
1138 
1139  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1140  av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1141  s->packet_loss = 1;
1142  return;
1143  }
1144 
1145  s->num_saved_bits += len;
1146  if (!append) {
1147  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1148  s->num_saved_bits);
1149  } else {
1150  int align = 8 - (get_bits_count(gb) & 7);
1151  align = FFMIN(align, len);
1152  put_bits(&s->pb, align, get_bits(gb, align));
1153  len -= align;
1154  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1155  }
1156  skip_bits_long(gb, len);
1157 
1158  tmp = s->pb;
1159  flush_put_bits(&tmp);
1160 
1162  skip_bits(&s->gb, s->frame_offset);
1163 }
1164 
1165 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1166  AVPacket* avpkt)
1167 {
1168  WmallDecodeCtx *s = avctx->priv_data;
1169  GetBitContext* gb = &s->pgb;
1170  const uint8_t* buf = avpkt->data;
1171  int buf_size = avpkt->size;
1172  int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1173 
1174  s->frame.nb_samples = 0;
1175 
1176  if (s->packet_done || s->packet_loss) {
1177  s->packet_done = 0;
1178 
1179  /* sanity check for the buffer length */
1180  if (buf_size < avctx->block_align)
1181  return 0;
1182 
1183  s->next_packet_start = buf_size - avctx->block_align;
1184  buf_size = avctx->block_align;
1185  s->buf_bit_size = buf_size << 3;
1186 
1187  /* parse packet header */
1188  init_get_bits(gb, buf, s->buf_bit_size);
1189  packet_sequence_number = get_bits(gb, 4);
1190  skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1191  spliced_packet = get_bits1(gb);
1192  if (spliced_packet)
1193  av_log_missing_feature(avctx, "Bitstream splicing", 1);
1194 
1195  /* get number of bits that need to be added to the previous frame */
1196  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1197 
1198  /* check for packet loss */
1199  if (!s->packet_loss &&
1200  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1201  s->packet_loss = 1;
1202  av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1203  s->packet_sequence_number, packet_sequence_number);
1204  }
1205  s->packet_sequence_number = packet_sequence_number;
1206 
1207  if (num_bits_prev_frame > 0) {
1208  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1209  if (num_bits_prev_frame >= remaining_packet_bits) {
1210  num_bits_prev_frame = remaining_packet_bits;
1211  s->packet_done = 1;
1212  }
1213 
1214  /* Append the previous frame data to the remaining data from the
1215  * previous packet to create a full frame. */
1216  save_bits(s, gb, num_bits_prev_frame, 1);
1217 
1218  /* decode the cross packet frame if it is valid */
1219  if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1220  decode_frame(s);
1221  } else if (s->num_saved_bits - s->frame_offset) {
1222  av_dlog(avctx, "ignoring %x previously saved bits\n",
1223  s->num_saved_bits - s->frame_offset);
1224  }
1225 
1226  if (s->packet_loss) {
1227  /* Reset number of saved bits so that the decoder does not start
1228  * to decode incomplete frames in the s->len_prefix == 0 case. */
1229  s->num_saved_bits = 0;
1230  s->packet_loss = 0;
1232  }
1233 
1234  } else {
1235  int frame_size;
1236 
1237  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1238  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1239  skip_bits(gb, s->packet_offset);
1240 
1241  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1242  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1243  frame_size <= remaining_bits(s, gb)) {
1244  save_bits(s, gb, frame_size, 0);
1245  s->packet_done = !decode_frame(s);
1246  } else if (!s->len_prefix
1247  && s->num_saved_bits > get_bits_count(&s->gb)) {
1248  /* when the frames do not have a length prefix, we don't know the
1249  * compressed length of the individual frames however, we know what
1250  * part of a new packet belongs to the previous frame therefore we
1251  * save the incoming packet first, then we append the "previous
1252  * frame" data from the next packet so that we get a buffer that
1253  * only contains full frames */
1254  s->packet_done = !decode_frame(s);
1255  } else {
1256  s->packet_done = 1;
1257  }
1258  }
1259 
1260  if (s->packet_done && !s->packet_loss &&
1261  remaining_bits(s, gb) > 0) {
1262  /* save the rest of the data so that it can be decoded
1263  * with the next packet */
1264  save_bits(s, gb, remaining_bits(s, gb), 0);
1265  }
1266 
1267  *(AVFrame *)data = s->frame;
1268  *got_frame_ptr = s->frame.nb_samples > 0;
1269  s->packet_offset = get_bits_count(gb) & 7;
1270 
1271  return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1272 }
1273 
1274 static void flush(AVCodecContext *avctx)
1275 {
1276  WmallDecodeCtx *s = avctx->priv_data;
1277  s->packet_loss = 1;
1278  s->packet_done = 0;
1279  s->num_saved_bits = 0;
1280  s->frame_offset = 0;
1281  s->next_packet_start = 0;
1282  s->cdlms[0][0].order = 0;
1283  s->frame.nb_samples = 0;
1285 }
1286 
1288  .name = "wmalossless",
1289  .type = AVMEDIA_TYPE_AUDIO,
1291  .priv_data_size = sizeof(WmallDecodeCtx),
1292  .init = decode_init,
1293  .decode = decode_packet,
1294  .flush = flush,
1296  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1297  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1300 };