FFmpeg
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 <inttypes.h>
26 
27 #include "libavutil/attributes.h"
28 #include "libavutil/avassert.h"
29 
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "get_bits.h"
33 #include "put_bits.h"
34 #include "lossless_audiodsp.h"
35 #include "wma.h"
36 #include "wma_common.h"
37 
38 /** current decoder limitations */
39 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
40 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
41 #define MAX_BANDS 29 ///< max number of scale factor bands
42 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
43 #define MAX_ORDER 256
44 
45 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
46 #define WMALL_BLOCK_MAX_BITS 14 ///< log2 of max block size
47 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
48 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
49 
50 #define WMALL_COEFF_PAD_SIZE 16 ///< pad coef buffers with 0 for use with SIMD
51 
52 /**
53  * @brief frame-specific decoder context for a single channel
54  */
55 typedef struct WmallChannelCtx {
56  int16_t prev_block_len; ///< length of the previous block
59  uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
60  uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
61  uint8_t cur_subframe; ///< current subframe number
62  uint16_t decoded_samples; ///< number of already processed samples
63  int quant_step; ///< quantization step for the current subframe
64  int transient_counter; ///< number of transient samples from the beginning of the transient zone
66 
67 /**
68  * @brief main decoder context
69  */
70 typedef struct WmallDecodeCtx {
71  /* generic decoder variables */
74  LLAudDSPContext dsp; ///< accelerated DSP functions
75  uint8_t *frame_data; ///< compressed frame data
76  int max_frame_size; ///< max bitstream size
77  PutBitContext pb; ///< context for filling the frame_data buffer
78 
79  /* frame size dependent frame information (set during initialization) */
80  uint32_t decode_flags; ///< used compression features
81  int len_prefix; ///< frame is prefixed with its length
82  int dynamic_range_compression; ///< frame contains DRC data
83  uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
84  uint16_t samples_per_frame; ///< number of samples to output
85  uint16_t log2_frame_size;
86  int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
87  int8_t lfe_channel; ///< lfe channel index
89  uint8_t subframe_len_bits; ///< number of bits used for the subframe length
90  uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
92 
93  /* packet decode state */
94  GetBitContext pgb; ///< bitstream reader context for the packet
95  int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
96  uint8_t packet_offset; ///< offset to the frame in the packet
97  uint8_t packet_sequence_number; ///< current packet number
98  int num_saved_bits; ///< saved number of bits
99  int frame_offset; ///< frame offset in the bit reservoir
100  int subframe_offset; ///< subframe offset in the bit reservoir
101  uint8_t packet_loss; ///< set in case of bitstream error
102  uint8_t packet_done; ///< set when a packet is fully decoded
103 
104  /* frame decode state */
105  uint32_t frame_num; ///< current frame number (not used for decoding)
106  GetBitContext gb; ///< bitstream reader context
107  int buf_bit_size; ///< buffer size in bits
108  int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
109  int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
110  uint8_t drc_gain; ///< gain for the DRC tool
111  int8_t skip_frame; ///< skip output step
112  int8_t parsed_all_subframes; ///< all subframes decoded?
113 
114  /* subframe/block decode state */
115  int16_t subframe_len; ///< current subframe length
116  int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
117  int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
118 
120 
121  // WMA Lossless-specific
122 
128 
131  int16_t acfilter_coeffs[16];
132  int acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
133 
134  int8_t mclms_order;
136  int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
137  int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
138  int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
139  int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
141 
144 
145  struct {
146  int order;
147  int scaling;
148  int coefsend;
149  int bitsend;
150  DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
151  DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
152  DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153  int recent;
154  } cdlms[WMALL_MAX_CHANNELS][9];
155 
156  int cdlms_ttl[WMALL_MAX_CHANNELS];
157 
158  int bV3RTM;
159 
160  int is_channel_coded[WMALL_MAX_CHANNELS];
161  int update_speed[WMALL_MAX_CHANNELS];
162 
163  int transient[WMALL_MAX_CHANNELS];
164  int transient_pos[WMALL_MAX_CHANNELS];
166 
167  unsigned ave_sum[WMALL_MAX_CHANNELS];
168 
169  int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
170 
171  int lpc_coefs[WMALL_MAX_CHANNELS][40];
176 
177 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
178 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
179 
181 {
182  WmallDecodeCtx *s = avctx->priv_data;
183  uint8_t *edata_ptr = avctx->extradata;
184  unsigned int channel_mask;
185  int i, log2_max_num_subframes;
186 
187  if (avctx->block_align <= 0 || avctx->block_align > (1<<21)) {
188  av_log(avctx, AV_LOG_ERROR, "block_align is not set or invalid\n");
189  return AVERROR(EINVAL);
190  }
191 
192  av_assert0(avctx->channels >= 0);
193  if (avctx->channels > WMALL_MAX_CHANNELS) {
194  avpriv_request_sample(avctx,
195  "More than " AV_STRINGIFY(WMALL_MAX_CHANNELS) " channels");
196  return AVERROR_PATCHWELCOME;
197  }
198 
199  s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
201  if (!s->frame_data)
202  return AVERROR(ENOMEM);
203 
204  s->avctx = avctx;
205  ff_llauddsp_init(&s->dsp);
207 
208  if (avctx->extradata_size >= 18) {
209  s->decode_flags = AV_RL16(edata_ptr + 14);
210  channel_mask = AV_RL32(edata_ptr + 2);
211  s->bits_per_sample = AV_RL16(edata_ptr);
212  if (s->bits_per_sample == 16)
214  else if (s->bits_per_sample == 24) {
216  avctx->bits_per_raw_sample = 24;
217  } else {
218  av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
219  s->bits_per_sample);
220  return AVERROR_INVALIDDATA;
221  }
222  /* dump the extradata */
223  for (i = 0; i < avctx->extradata_size; i++)
224  ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
225  ff_dlog(avctx, "\n");
226 
227  } else {
228  avpriv_request_sample(avctx, "Unsupported extradata size");
229  return AVERROR_PATCHWELCOME;
230  }
231 
232  /* generic init */
233  s->log2_frame_size = av_log2(avctx->block_align) + 4;
234 
235  /* frame info */
236  s->skip_frame = 1; /* skip first frame */
237  s->packet_loss = 1;
238  s->len_prefix = s->decode_flags & 0x40;
239 
240  /* get frame len */
242  3, s->decode_flags);
244 
245  /* init previous block len */
246  for (i = 0; i < avctx->channels; i++)
248 
249  /* subframe info */
250  log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
251  s->max_num_subframes = 1 << log2_max_num_subframes;
252  s->max_subframe_len_bit = 0;
253  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
254 
257  s->bV3RTM = s->decode_flags & 0x100;
258 
259  if (s->max_num_subframes > MAX_SUBFRAMES) {
260  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
261  s->max_num_subframes);
262  return AVERROR_INVALIDDATA;
263  }
264 
265  s->num_channels = avctx->channels;
266 
267  /* extract lfe channel position */
268  s->lfe_channel = -1;
269 
270  if (channel_mask & 8) {
271  unsigned int mask;
272  for (mask = 1; mask < 16; mask <<= 1)
273  if (channel_mask & mask)
274  ++s->lfe_channel;
275  }
276 
277  s->frame = av_frame_alloc();
278  if (!s->frame)
279  return AVERROR(ENOMEM);
280 
281  avctx->channel_layout = channel_mask;
282  return 0;
283 }
284 
285 /**
286  * @brief Decode the subframe length.
287  * @param s context
288  * @param offset sample offset in the frame
289  * @return decoded subframe length on success, < 0 in case of an error
290  */
292 {
293  int frame_len_ratio, subframe_len, len;
294 
295  /* no need to read from the bitstream when only one length is possible */
296  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
297  return s->min_samples_per_subframe;
298 
299  len = av_log2(s->max_num_subframes - 1) + 1;
300  frame_len_ratio = get_bits(&s->gb, len);
301  subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
302 
303  /* sanity check the length */
304  if (subframe_len < s->min_samples_per_subframe ||
305  subframe_len > s->samples_per_frame) {
306  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
307  subframe_len);
308  return AVERROR_INVALIDDATA;
309  }
310  return subframe_len;
311 }
312 
313 /**
314  * @brief Decode how the data in the frame is split into subframes.
315  * Every WMA frame contains the encoded data for a fixed number of
316  * samples per channel. The data for every channel might be split
317  * into several subframes. This function will reconstruct the list of
318  * subframes for every channel.
319  *
320  * If the subframes are not evenly split, the algorithm estimates the
321  * channels with the lowest number of total samples.
322  * Afterwards, for each of these channels a bit is read from the
323  * bitstream that indicates if the channel contains a subframe with the
324  * next subframe size that is going to be read from the bitstream or not.
325  * If a channel contains such a subframe, the subframe size gets added to
326  * the channel's subframe list.
327  * The algorithm repeats these steps until the frame is properly divided
328  * between the individual channels.
329  *
330  * @param s context
331  * @return 0 on success, < 0 in case of an error
332  */
334 {
335  uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
336  uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
337  int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
338  int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
339  int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
340  int c, tile_aligned;
341 
342  /* reset tiling information */
343  for (c = 0; c < s->num_channels; c++)
344  s->channel[c].num_subframes = 0;
345 
346  tile_aligned = get_bits1(&s->gb);
347  if (s->max_num_subframes == 1 || tile_aligned)
348  fixed_channel_layout = 1;
349 
350  /* loop until the frame data is split between the subframes */
351  do {
352  int subframe_len, in_use = 0;
353 
354  /* check which channels contain the subframe */
355  for (c = 0; c < s->num_channels; c++) {
356  if (num_samples[c] == min_channel_len) {
357  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
358  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
359  contains_subframe[c] = 1;
360  } else {
361  contains_subframe[c] = get_bits1(&s->gb);
362  }
363  in_use |= contains_subframe[c];
364  } else
365  contains_subframe[c] = 0;
366  }
367 
368  if (!in_use) {
370  "Found empty subframe\n");
371  return AVERROR_INVALIDDATA;
372  }
373 
374  /* get subframe length, subframe_len == 0 is not allowed */
375  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
376  return AVERROR_INVALIDDATA;
377  /* add subframes to the individual channels and find new min_channel_len */
378  min_channel_len += subframe_len;
379  for (c = 0; c < s->num_channels; c++) {
380  WmallChannelCtx *chan = &s->channel[c];
381 
382  if (contains_subframe[c]) {
383  if (chan->num_subframes >= MAX_SUBFRAMES) {
385  "broken frame: num subframes > 31\n");
386  return AVERROR_INVALIDDATA;
387  }
388  chan->subframe_len[chan->num_subframes] = subframe_len;
389  num_samples[c] += subframe_len;
390  ++chan->num_subframes;
391  if (num_samples[c] > s->samples_per_frame) {
392  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
393  "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
394  num_samples[c], s->samples_per_frame);
395  return AVERROR_INVALIDDATA;
396  }
397  } else if (num_samples[c] <= min_channel_len) {
398  if (num_samples[c] < min_channel_len) {
399  channels_for_cur_subframe = 0;
400  min_channel_len = num_samples[c];
401  }
402  ++channels_for_cur_subframe;
403  }
404  }
405  } while (min_channel_len < s->samples_per_frame);
406 
407  for (c = 0; c < s->num_channels; c++) {
408  int i, offset = 0;
409  for (i = 0; i < s->channel[c].num_subframes; i++) {
411  offset += s->channel[c].subframe_len[i];
412  }
413  }
414 
415  return 0;
416 }
417 
419 {
420  int i;
421  s->acfilter_order = get_bits(&s->gb, 4) + 1;
422  s->acfilter_scaling = get_bits(&s->gb, 4);
423 
424  for (i = 0; i < s->acfilter_order; i++)
425  s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
426 }
427 
429 {
430  s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
431  s->mclms_scaling = get_bits(&s->gb, 4);
432  if (get_bits1(&s->gb)) {
433  int i, send_coef_bits;
434  int cbits = av_log2(s->mclms_scaling + 1);
435  if (1 << cbits < s->mclms_scaling + 1)
436  cbits++;
437 
438  send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
439 
440  for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
441  s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
442 
443  for (i = 0; i < s->num_channels; i++) {
444  int c;
445  for (c = 0; c < i; c++)
446  s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
447  }
448  }
449 }
450 
452 {
453  int c, i;
454  int cdlms_send_coef = get_bits1(&s->gb);
455 
456  for (c = 0; c < s->num_channels; c++) {
457  s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
458  for (i = 0; i < s->cdlms_ttl[c]; i++) {
459  s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
460  if (s->cdlms[c][i].order > MAX_ORDER) {
462  "Order[%d][%d] %d > max (%d), not supported\n",
463  c, i, s->cdlms[c][i].order, MAX_ORDER);
464  s->cdlms[0][0].order = 0;
465  return AVERROR_INVALIDDATA;
466  }
467  if(s->cdlms[c][i].order & 8 && s->bits_per_sample == 16) {
468  static int warned;
469  if(!warned)
470  avpriv_request_sample(s->avctx, "CDLMS of order %d",
471  s->cdlms[c][i].order);
472  warned = 1;
473  }
474  }
475 
476  for (i = 0; i < s->cdlms_ttl[c]; i++)
477  s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
478 
479  if (cdlms_send_coef) {
480  for (i = 0; i < s->cdlms_ttl[c]; i++) {
481  int cbits, shift_l, shift_r, j;
482  cbits = av_log2(s->cdlms[c][i].order);
483  if ((1 << cbits) < s->cdlms[c][i].order)
484  cbits++;
485  s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
486 
487  cbits = av_log2(s->cdlms[c][i].scaling + 1);
488  if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
489  cbits++;
490 
491  s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
492  shift_l = 32 - s->cdlms[c][i].bitsend;
493  shift_r = 32 - s->cdlms[c][i].scaling - 2;
494  for (j = 0; j < s->cdlms[c][i].coefsend; j++)
495  s->cdlms[c][i].coefs[j] =
496  (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
497  }
498  }
499 
500  for (i = 0; i < s->cdlms_ttl[c]; i++)
501  memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
503  }
504 
505  return 0;
506 }
507 
508 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
509 {
510  int i = 0;
511  unsigned int ave_mean;
512  s->transient[ch] = get_bits1(&s->gb);
513  if (s->transient[ch]) {
514  s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
515  if (s->transient_pos[ch])
516  s->transient[ch] = 0;
517  s->channel[ch].transient_counter =
519  } else if (s->channel[ch].transient_counter)
520  s->transient[ch] = 1;
521 
522  if (s->seekable_tile) {
523  ave_mean = get_bits(&s->gb, s->bits_per_sample);
524  s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
525  }
526 
527  if (s->seekable_tile) {
528  if (s->do_inter_ch_decorr)
529  s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
530  else
531  s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
532  i++;
533  }
534  for (; i < tile_size; i++) {
535  int rem, rem_bits;
536  unsigned quo = 0, residue;
537  while(get_bits1(&s->gb)) {
538  quo++;
539  if (get_bits_left(&s->gb) <= 0)
540  return -1;
541  }
542  if (quo >= 32)
543  quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
544 
545  ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
546  if (ave_mean <= 1)
547  residue = quo;
548  else {
549  rem_bits = av_ceil_log2(ave_mean);
550  rem = get_bits_long(&s->gb, rem_bits);
551  residue = (quo << rem_bits) + rem;
552  }
553 
554  s->ave_sum[ch] = residue + s->ave_sum[ch] -
555  (s->ave_sum[ch] >> s->movave_scaling);
556 
557  residue = (residue >> 1) ^ -(residue & 1);
558  s->channel_residues[ch][i] = residue;
559  }
560 
561  return 0;
562 
563 }
564 
566 {
567  int ch, i, cbits;
568  s->lpc_order = get_bits(&s->gb, 5) + 1;
569  s->lpc_scaling = get_bits(&s->gb, 4);
570  s->lpc_intbits = get_bits(&s->gb, 3) + 1;
571  cbits = s->lpc_scaling + s->lpc_intbits;
572  for (ch = 0; ch < s->num_channels; ch++)
573  for (i = 0; i < s->lpc_order; i++)
574  s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
575 }
576 
578 {
579  int ich, ilms;
580 
581  memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
582  memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
583  memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
584 
585  memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
586  memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
587  memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
588  memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
589 
590  for (ich = 0; ich < s->num_channels; ich++) {
591  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
592  memset(s->cdlms[ich][ilms].coefs, 0,
593  sizeof(s->cdlms[ich][ilms].coefs));
594  memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
595  sizeof(s->cdlms[ich][ilms].lms_prevvalues));
596  memset(s->cdlms[ich][ilms].lms_updates, 0,
597  sizeof(s->cdlms[ich][ilms].lms_updates));
598  }
599  s->ave_sum[ich] = 0;
600  }
601 }
602 
603 /**
604  * @brief Reset filter parameters and transient area at new seekable tile.
605  */
607 {
608  int ich, ilms;
610  for (ich = 0; ich < s->num_channels; ich++) {
611  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
612  s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
613  /* first sample of a seekable subframe is considered as the starting of
614  a transient area which is samples_per_frame samples long */
616  s->transient[ich] = 1;
617  s->transient_pos[ich] = 0;
618  }
619 }
620 
621 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
622 {
623  int i, j, ich, pred_error;
624  int order = s->mclms_order;
625  int num_channels = s->num_channels;
626  int range = 1 << (s->bits_per_sample - 1);
627 
628  for (ich = 0; ich < num_channels; ich++) {
629  pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
630  if (pred_error > 0) {
631  for (i = 0; i < order * num_channels; i++)
632  s->mclms_coeffs[i + ich * order * num_channels] +=
633  s->mclms_updates[s->mclms_recent + i];
634  for (j = 0; j < ich; j++)
635  s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
636  } else if (pred_error < 0) {
637  for (i = 0; i < order * num_channels; i++)
638  s->mclms_coeffs[i + ich * order * num_channels] -=
639  s->mclms_updates[s->mclms_recent + i];
640  for (j = 0; j < ich; j++)
641  s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
642  }
643  }
644 
645  for (ich = num_channels - 1; ich >= 0; ich--) {
646  s->mclms_recent--;
647  s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
648  -range, range - 1);
649  s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
650  }
651 
652  if (s->mclms_recent == 0) {
653  memcpy(&s->mclms_prevvalues[order * num_channels],
654  s->mclms_prevvalues,
655  sizeof(int32_t) * order * num_channels);
656  memcpy(&s->mclms_updates[order * num_channels],
657  s->mclms_updates,
658  sizeof(int32_t) * order * num_channels);
659  s->mclms_recent = num_channels * order;
660  }
661 }
662 
663 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
664 {
665  int ich, i;
666  int order = s->mclms_order;
667  int num_channels = s->num_channels;
668 
669  for (ich = 0; ich < num_channels; ich++) {
670  pred[ich] = 0;
671  if (!s->is_channel_coded[ich])
672  continue;
673  for (i = 0; i < order * num_channels; i++)
674  pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
675  s->mclms_coeffs[i + order * num_channels * ich];
676  for (i = 0; i < ich; i++)
677  pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
678  s->mclms_coeffs_cur[i + num_channels * ich];
679  pred[ich] += (1U << s->mclms_scaling) >> 1;
680  pred[ich] >>= s->mclms_scaling;
681  s->channel_residues[ich][icoef] += (unsigned)pred[ich];
682  }
683 }
684 
685 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
686 {
687  int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
688  for (icoef = 0; icoef < tile_size; icoef++) {
689  mclms_predict(s, icoef, pred);
690  mclms_update(s, icoef, pred);
691  }
692 }
693 
694 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
695 {
696  int ilms, recent, icoef;
697  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
698  recent = s->cdlms[ich][ilms].recent;
699  if (s->update_speed[ich] == 16)
700  continue;
701  if (s->bV3RTM) {
702  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
703  s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
704  } else {
705  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
706  s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
707  }
708  }
709  s->update_speed[ich] = 16;
710 }
711 
713 {
714  int ilms, recent, icoef;
715  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
716  recent = s->cdlms[ich][ilms].recent;
717  if (s->update_speed[ich] == 8)
718  continue;
719  if (s->bV3RTM)
720  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
721  s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
722  else
723  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
724  s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
725  }
726  s->update_speed[ich] = 8;
727 }
728 
729 #define CD_LMS(bits, ROUND) \
730 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
731 { \
732  int recent = s->cdlms[ich][ilms].recent; \
733  int range = 1 << s->bits_per_sample - 1; \
734  int order = s->cdlms[ich][ilms].order; \
735  int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
736  \
737  if (recent) \
738  recent--; \
739  else { \
740  memcpy(prev + order, prev, (bits/8) * order); \
741  memcpy(s->cdlms[ich][ilms].lms_updates + order, \
742  s->cdlms[ich][ilms].lms_updates, \
743  sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
744  recent = order - 1; \
745  } \
746  \
747  prev[recent] = av_clip(input, -range, range - 1); \
748  s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
749  \
750  s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
751  s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
752  s->cdlms[ich][ilms].recent = recent; \
753  memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
754  sizeof(s->cdlms[ich][ilms].lms_updates) - \
755  sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
756 } \
757  \
758 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
759  int coef_begin, int coef_end) \
760 { \
761  int icoef, ilms, num_lms, residue, input; \
762  unsigned pred;\
763  \
764  num_lms = s->cdlms_ttl[ch]; \
765  for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
766  for (icoef = coef_begin; icoef < coef_end; icoef++) { \
767  int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
768  pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
769  residue = s->channel_residues[ch][icoef]; \
770  pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
771  prevvalues + s->cdlms[ch][ilms].recent, \
772  s->cdlms[ch][ilms].lms_updates + \
773  s->cdlms[ch][ilms].recent, \
774  FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
775  WMASIGN(residue)); \
776  input = residue + (unsigned)((int)pred >> s->cdlms[ch][ilms].scaling); \
777  lms_update ## bits(s, ch, ilms, input); \
778  s->channel_residues[ch][icoef] = input; \
779  } \
780  } \
781  if (bits <= 16) emms_c(); \
782 }
783 
785 CD_LMS(32, 8)
786 
787 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
788 {
789  if (s->num_channels != 2)
790  return;
791  else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
792  int icoef;
793  for (icoef = 0; icoef < tile_size; icoef++) {
794  s->channel_residues[0][icoef] -= (unsigned)(s->channel_residues[1][icoef] >> 1);
795  s->channel_residues[1][icoef] += (unsigned) s->channel_residues[0][icoef];
796  }
797  }
798 }
799 
800 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
801 {
802  int ich, pred, i, j;
803  int16_t *filter_coeffs = s->acfilter_coeffs;
804  int scaling = s->acfilter_scaling;
805  int order = s->acfilter_order;
806 
807  for (ich = 0; ich < s->num_channels; ich++) {
808  int *prevvalues = s->acfilter_prevvalues[ich];
809  for (i = 0; i < order; i++) {
810  pred = 0;
811  for (j = 0; j < order; j++) {
812  if (i <= j)
813  pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
814  else
815  pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
816  }
817  pred >>= scaling;
818  s->channel_residues[ich][i] += (unsigned)pred;
819  }
820  for (i = order; i < tile_size; i++) {
821  pred = 0;
822  for (j = 0; j < order; j++)
823  pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
824  pred >>= scaling;
825  s->channel_residues[ich][i] += (unsigned)pred;
826  }
827  for (j = order - 1; j >= 0; j--)
828  if (tile_size <= j) {
829  prevvalues[j] = prevvalues[j - tile_size];
830  }else
831  prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
832  }
833 }
834 
836 {
837  int offset = s->samples_per_frame;
839  int total_samples = s->samples_per_frame * s->num_channels;
840  int i, j, rawpcm_tile, padding_zeroes, res;
841 
843 
844  /* reset channel context and find the next block offset and size
845  == the next block of the channel with the smallest number of
846  decoded samples */
847  for (i = 0; i < s->num_channels; i++) {
848  if (offset > s->channel[i].decoded_samples) {
849  offset = s->channel[i].decoded_samples;
850  subframe_len =
852  }
853  }
854 
855  /* get a list of all channels that contain the estimated block */
857  for (i = 0; i < s->num_channels; i++) {
858  const int cur_subframe = s->channel[i].cur_subframe;
859  /* subtract already processed samples */
860  total_samples -= s->channel[i].decoded_samples;
861 
862  /* and count if there are multiple subframes that match our profile */
863  if (offset == s->channel[i].decoded_samples &&
864  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
865  total_samples -= s->channel[i].subframe_len[cur_subframe];
866  s->channel[i].decoded_samples +=
870  }
871  }
872 
873  /* check if the frame will be complete after processing the
874  estimated block */
875  if (!total_samples)
876  s->parsed_all_subframes = 1;
877 
878 
879  s->seekable_tile = get_bits1(&s->gb);
880  if (s->seekable_tile) {
882 
883  s->do_arith_coding = get_bits1(&s->gb);
884  if (s->do_arith_coding) {
885  avpriv_request_sample(s->avctx, "Arithmetic coding");
886  return AVERROR_PATCHWELCOME;
887  }
888  s->do_ac_filter = get_bits1(&s->gb);
889  s->do_inter_ch_decorr = get_bits1(&s->gb);
890  s->do_mclms = get_bits1(&s->gb);
891 
892  if (s->do_ac_filter)
893  decode_ac_filter(s);
894 
895  if (s->do_mclms)
896  decode_mclms(s);
897 
898  if ((res = decode_cdlms(s)) < 0)
899  return res;
900  s->movave_scaling = get_bits(&s->gb, 3);
901  s->quant_stepsize = get_bits(&s->gb, 8) + 1;
902 
903  reset_codec(s);
904  }
905 
906  rawpcm_tile = get_bits1(&s->gb);
907 
908  if (!rawpcm_tile && !s->cdlms[0][0].order) {
910  "Waiting for seekable tile\n");
911  av_frame_unref(s->frame);
912  return -1;
913  }
914 
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  avpriv_request_sample(s->avctx, "Expect wrong output since "
929  "inverse LPC filter");
930  }
931  } else
932  s->do_lpc = 0;
933  }
934 
935  if (get_bits_left(&s->gb) < 1)
936  return AVERROR_INVALIDDATA;
937 
938  if (get_bits1(&s->gb))
939  padding_zeroes = get_bits(&s->gb, 5);
940  else
941  padding_zeroes = 0;
942 
943  if (rawpcm_tile) {
944  int bits = s->bits_per_sample - padding_zeroes;
945  if (bits <= 0) {
947  "Invalid number of padding bits in raw PCM tile\n");
948  return AVERROR_INVALIDDATA;
949  }
950  ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
951  "total %d bits, remain=%d\n", bits,
952  bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
953  for (i = 0; i < s->num_channels; i++)
954  for (j = 0; j < subframe_len; j++)
955  s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
956  } else {
957  if (s->bits_per_sample < padding_zeroes)
958  return AVERROR_INVALIDDATA;
959  for (i = 0; i < s->num_channels; i++) {
960  if (s->is_channel_coded[i]) {
961  decode_channel_residues(s, i, subframe_len);
962  if (s->seekable_tile)
963  use_high_update_speed(s, i);
964  else
966  if (s->bits_per_sample > 16)
967  revert_cdlms32(s, i, 0, subframe_len);
968  else
969  revert_cdlms16(s, i, 0, subframe_len);
970  } else {
971  memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
972  }
973  }
974 
975  if (s->do_mclms)
976  revert_mclms(s, subframe_len);
977  if (s->do_inter_ch_decorr)
978  revert_inter_ch_decorr(s, subframe_len);
979  if (s->do_ac_filter)
980  revert_acfilter(s, subframe_len);
981 
982  /* Dequantize */
983  if (s->quant_stepsize != 1)
984  for (i = 0; i < s->num_channels; i++)
985  for (j = 0; j < subframe_len; j++)
986  s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
987  }
988 
989  /* Write to proper output buffer depending on bit-depth */
990  for (i = 0; i < s->channels_for_cur_subframe; i++) {
992  int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
993 
994  for (j = 0; j < subframe_len; j++) {
995  if (s->bits_per_sample == 16) {
996  *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
997  } else {
998  *s->samples_32[c]++ = s->channel_residues[c][j] * (256U << padding_zeroes);
999  }
1000  }
1001  }
1002 
1003  /* handled one subframe */
1004  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1006  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1007  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1008  return AVERROR_INVALIDDATA;
1009  }
1010  ++s->channel[c].cur_subframe;
1011  }
1012  return 0;
1013 }
1014 
1015 /**
1016  * @brief Decode one WMA frame.
1017  * @param s codec context
1018  * @return 0 if the trailer bit indicates that this is the last frame,
1019  * 1 if there are additional frames
1020  */
1022 {
1023  GetBitContext* gb = &s->gb;
1024  int more_frames = 0, len = 0, i, ret;
1025 
1027  if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1028  /* return an error if no frame could be decoded at all */
1029  s->packet_loss = 1;
1030  s->frame->nb_samples = 0;
1031  return ret;
1032  }
1033  for (i = 0; i < s->num_channels; i++) {
1034  s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1035  s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1036  }
1037 
1038  /* get frame length */
1039  if (s->len_prefix)
1040  len = get_bits(gb, s->log2_frame_size);
1041 
1042  /* decode tile information */
1043  if ((ret = decode_tilehdr(s))) {
1044  s->packet_loss = 1;
1045  av_frame_unref(s->frame);
1046  return ret;
1047  }
1048 
1049  /* read drc info */
1051  s->drc_gain = get_bits(gb, 8);
1052 
1053  /* no idea what these are for, might be the number of samples
1054  that need to be skipped at the beginning or end of a stream */
1055  if (get_bits1(gb)) {
1056  int av_unused skip;
1057 
1058  /* usually true for the first frame */
1059  if (get_bits1(gb)) {
1060  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1061  ff_dlog(s->avctx, "start skip: %i\n", skip);
1062  }
1063 
1064  /* sometimes true for the last frame */
1065  if (get_bits1(gb)) {
1066  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1067  ff_dlog(s->avctx, "end skip: %i\n", skip);
1068  s->frame->nb_samples -= skip;
1069  if (s->frame->nb_samples <= 0)
1070  return AVERROR_INVALIDDATA;
1071  }
1072 
1073  }
1074 
1075  /* reset subframe states */
1076  s->parsed_all_subframes = 0;
1077  for (i = 0; i < s->num_channels; i++) {
1078  s->channel[i].decoded_samples = 0;
1079  s->channel[i].cur_subframe = 0;
1080  }
1081 
1082  /* decode all subframes */
1083  while (!s->parsed_all_subframes) {
1085  if (decode_subframe(s) < 0) {
1086  s->packet_loss = 1;
1087  if (s->frame->nb_samples)
1089  return 0;
1090  }
1091  }
1092 
1093  ff_dlog(s->avctx, "Frame done\n");
1094 
1095  s->skip_frame = 0;
1096 
1097  if (s->len_prefix) {
1098  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1099  /* FIXME: not sure if this is always an error */
1101  "frame[%"PRIu32"] would have to skip %i bits\n",
1102  s->frame_num,
1103  len - (get_bits_count(gb) - s->frame_offset) - 1);
1104  s->packet_loss = 1;
1105  return 0;
1106  }
1107 
1108  /* skip the rest of the frame data */
1109  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1110  }
1111 
1112  /* decode trailer bit */
1113  more_frames = get_bits1(gb);
1114  ++s->frame_num;
1115  return more_frames;
1116 }
1117 
1118 /**
1119  * @brief Calculate remaining input buffer length.
1120  * @param s codec context
1121  * @param gb bitstream reader context
1122  * @return remaining size in bits
1123  */
1125 {
1126  return s->buf_bit_size - get_bits_count(gb);
1127 }
1128 
1129 /**
1130  * @brief Fill the bit reservoir with a (partial) frame.
1131  * @param s codec context
1132  * @param gb bitstream reader context
1133  * @param len length of the partial frame
1134  * @param append decides whether to reset the buffer or not
1135  */
1136 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1137  int append)
1138 {
1139  int buflen;
1141 
1142  /* when the frame data does not need to be concatenated, the input buffer
1143  is reset and additional bits from the previous frame are copied
1144  and skipped later so that a fast byte copy is possible */
1145 
1146  if (!append) {
1147  s->frame_offset = get_bits_count(gb) & 7;
1148  s->num_saved_bits = s->frame_offset;
1150  }
1151 
1152  buflen = (s->num_saved_bits + len + 8) >> 3;
1153 
1154  if (len <= 0 || buflen > s->max_frame_size) {
1155  avpriv_request_sample(s->avctx, "Too small input buffer");
1156  s->packet_loss = 1;
1157  s->num_saved_bits = 0;
1158  return;
1159  }
1160 
1161  s->num_saved_bits += len;
1162  if (!append) {
1163  ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1164  s->num_saved_bits);
1165  } else {
1166  int align = 8 - (get_bits_count(gb) & 7);
1167  align = FFMIN(align, len);
1168  put_bits(&s->pb, align, get_bits(gb, align));
1169  len -= align;
1170  ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1171  }
1172  skip_bits_long(gb, len);
1173 
1174  tmp = s->pb;
1175  flush_put_bits(&tmp);
1176 
1178  skip_bits(&s->gb, s->frame_offset);
1179 }
1180 
1181 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1182  AVPacket* avpkt)
1183 {
1184  WmallDecodeCtx *s = avctx->priv_data;
1185  GetBitContext* gb = &s->pgb;
1186  const uint8_t* buf = avpkt->data;
1187  int buf_size = avpkt->size;
1188  int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1189 
1190  s->frame->nb_samples = 0;
1191 
1192  if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1193  s->packet_done = 0;
1194  if (!decode_frame(s))
1195  s->num_saved_bits = 0;
1196  } else if (s->packet_done || s->packet_loss) {
1197  s->packet_done = 0;
1198 
1199  if (!buf_size)
1200  return 0;
1201 
1202  s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1203  buf_size = FFMIN(avctx->block_align, buf_size);
1204  s->buf_bit_size = buf_size << 3;
1205 
1206  /* parse packet header */
1207  init_get_bits(gb, buf, s->buf_bit_size);
1208  packet_sequence_number = get_bits(gb, 4);
1209  skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently unused
1210  spliced_packet = get_bits1(gb);
1211  if (spliced_packet)
1212  avpriv_request_sample(avctx, "Bitstream splicing");
1213 
1214  /* get number of bits that need to be added to the previous frame */
1215  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1216 
1217  /* check for packet loss */
1218  if (!s->packet_loss &&
1219  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1220  s->packet_loss = 1;
1221  av_log(avctx, AV_LOG_ERROR,
1222  "Packet loss detected! seq %"PRIx8" vs %x\n",
1223  s->packet_sequence_number, packet_sequence_number);
1224  }
1225  s->packet_sequence_number = packet_sequence_number;
1226 
1227  if (num_bits_prev_frame > 0) {
1228  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1229  if (num_bits_prev_frame >= remaining_packet_bits) {
1230  num_bits_prev_frame = remaining_packet_bits;
1231  s->packet_done = 1;
1232  }
1233 
1234  /* Append the previous frame data to the remaining data from the
1235  * previous packet to create a full frame. */
1236  save_bits(s, gb, num_bits_prev_frame, 1);
1237 
1238  /* decode the cross packet frame if it is valid */
1239  if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1240  decode_frame(s);
1241  } else if (s->num_saved_bits - s->frame_offset) {
1242  ff_dlog(avctx, "ignoring %x previously saved bits\n",
1243  s->num_saved_bits - s->frame_offset);
1244  }
1245 
1246  if (s->packet_loss) {
1247  /* Reset number of saved bits so that the decoder does not start
1248  * to decode incomplete frames in the s->len_prefix == 0 case. */
1249  s->num_saved_bits = 0;
1250  s->packet_loss = 0;
1252  }
1253 
1254  } else {
1255  int frame_size;
1256 
1257  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1258  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1259  skip_bits(gb, s->packet_offset);
1260 
1261  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1262  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1263  frame_size <= remaining_bits(s, gb)) {
1264  save_bits(s, gb, frame_size, 0);
1265 
1266  if (!s->packet_loss)
1267  s->packet_done = !decode_frame(s);
1268  } else if (!s->len_prefix
1269  && s->num_saved_bits > get_bits_count(&s->gb)) {
1270  /* when the frames do not have a length prefix, we don't know the
1271  * compressed length of the individual frames however, we know what
1272  * part of a new packet belongs to the previous frame therefore we
1273  * save the incoming packet first, then we append the "previous
1274  * frame" data from the next packet so that we get a buffer that
1275  * only contains full frames */
1276  s->packet_done = !decode_frame(s);
1277  } else {
1278  s->packet_done = 1;
1279  }
1280  }
1281 
1282  if (remaining_bits(s, gb) < 0) {
1283  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1284  s->packet_loss = 1;
1285  }
1286 
1287  if (s->packet_done && !s->packet_loss &&
1288  remaining_bits(s, gb) > 0) {
1289  /* save the rest of the data so that it can be decoded
1290  * with the next packet */
1291  save_bits(s, gb, remaining_bits(s, gb), 0);
1292  }
1293 
1294  *got_frame_ptr = s->frame->nb_samples > 0;
1295  av_frame_move_ref(data, s->frame);
1296 
1297  s->packet_offset = get_bits_count(gb) & 7;
1298 
1299  return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1300 }
1301 
1302 static void flush(AVCodecContext *avctx)
1303 {
1304  WmallDecodeCtx *s = avctx->priv_data;
1305  s->packet_loss = 1;
1306  s->packet_done = 0;
1307  s->num_saved_bits = 0;
1308  s->frame_offset = 0;
1309  s->next_packet_start = 0;
1310  s->cdlms[0][0].order = 0;
1311  s->frame->nb_samples = 0;
1313 }
1314 
1316 {
1317  WmallDecodeCtx *s = avctx->priv_data;
1318 
1319  av_frame_free(&s->frame);
1320  av_freep(&s->frame_data);
1321 
1322  return 0;
1323 }
1324 
1326  .name = "wmalossless",
1327  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1328  .type = AVMEDIA_TYPE_AUDIO,
1330  .priv_data_size = sizeof(WmallDecodeCtx),
1331  .init = decode_init,
1332  .close = decode_close,
1333  .decode = decode_packet,
1334  .flush = flush,
1336  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1337  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1340 };
static void decode_ac_filter(WmallDecodeCtx *s)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
int16_t prev_block_len
length of the previous block
uint8_t subframe_len_bits
number of bits used for the subframe length
uint8_t bits_per_sample
integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
uint8_t max_subframe_len_bit
flag indicating that the subframe is of maximum size when the first subframe length bit is 1 ...
unsigned ave_sum[WMALL_MAX_CHANNELS]
uint8_t max_num_subframes
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint16_t subframe_offsets[MAX_SUBFRAMES]
subframe positions in the current frame
int32_t * samples_32[WMALL_MAX_CHANNELS]
current sample buffer pointer (24-bit)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t drc_gain
gain for the DRC tool
#define avpriv_request_sample(...)
int acfilter_prevvalues[WMALL_MAX_CHANNELS][16]
int size
Definition: packet.h:364
const uint8_t * buffer
Definition: get_bits.h:62
int av_log2(unsigned v)
Definition: intmath.c:26
PutBitContext pb
context for filling the frame_data buffer
uint8_t cur_subframe
current subframe number
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:582
LLAudDSPContext dsp
accelerated DSP functions
static void decode_mclms(WmallDecodeCtx *s)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1762
struct WmallDecodeCtx::@194 cdlms[WMALL_MAX_CHANNELS][9]
int cdlms_ttl[WMALL_MAX_CHANNELS]
static int decode_subframe_length(WmallDecodeCtx *s, int offset)
Decode the subframe length.
AVCodec.
Definition: codec.h:190
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1228
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
#define MAX_ORDER
int8_t channels_for_cur_subframe
number of channels that contain the subframe
Macro definitions for various function/variable attributes.
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
uint8_t packet_sequence_number
current packet number
int max_frame_size
max bitstream size
int32_t mclms_updates[WMALL_MAX_CHANNELS *2 *32]
int16_t subframe_len
current subframe length
uint16_t decoded_samples
number of already processed samples
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:75
GetBitContext pgb
bitstream reader context for the packet
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int quant_step
quantization step for the current subframe
int16_t coefs[MAX_ORDER+WMALL_COEFF_PAD_SIZE/sizeof(int16_t)]
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int16_t acfilter_coeffs[16]
int8_t num_channels
number of channels in the stream (same as AVCodecContext.num_channels)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:69
static void reset_codec(WmallDecodeCtx *s)
Reset filter parameters and transient area at new seekable tile.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
int update_speed[WMALL_MAX_CHANNELS]
int is_channel_coded[WMALL_MAX_CHANNELS]
int frame_offset
frame offset in the bit reservoir
static uint8_t * append(uint8_t *buf, const uint8_t *src, int size)
#define WMASIGN(x)
Get sign of integer (1 for positive, -1 for negative and 0 for zero)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint16_t min_samples_per_subframe
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
bitstream reader API header.
#define CD_LMS(bits, ROUND)
AVFrame * frame
#define av_log(a,...)
frame-specific decoder context for a single channel
int8_t lfe_channel
lfe channel index
uint8_t do_arith_coding
#define U(x)
Definition: vp56_arith.h:37
int buf_bit_size
buffer size in bits
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int16_t mclms_coeffs[WMALL_MAX_CHANNELS *WMALL_MAX_CHANNELS *32]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static const uint16_t mask[17]
Definition: lzw.c:38
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
static av_cold int decode_init(AVCodecContext *avctx)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
simple assert() macros that are a bit more flexible than ISO C assert().
int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS]
const char * name
Name of the codec implementation.
Definition: codec.h:197
static int decode_subframe(WmallDecodeCtx *s)
uint8_t bits
Definition: vp3data.h:202
static int decode_cdlms(WmallDecodeCtx *s)
uint8_t transmit_coefs
static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
#define WMALL_BLOCK_MAX_SIZE
maximum block size
AVCodecContext * avctx
#define FFMAX(a, b)
Definition: common.h:94
int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE]
int8_t parsed_all_subframes
all subframes decoded?
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
static int decode_tilehdr(WmallDecodeCtx *s)
Decode how the data in the frame is split into subframes.
int32_t lms_prevvalues[MAX_ORDER *2+WMALL_COEFF_PAD_SIZE/sizeof(int16_t)]
static void use_high_update_speed(WmallDecodeCtx *s, int ich)
#define MAX_SUBFRAMES
max number of subframes per channel
static av_cold int decode_close(AVCodecContext *avctx)
uint8_t packet_loss
set in case of bitstream error
static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
static void clear_codec_buffers(WmallDecodeCtx *s)
#define FFMIN(a, b)
Definition: common.h:96
uint16_t log2_frame_size
signed 32 bits, planar
Definition: samplefmt.h:68
uint32_t decode_flags
used compression features
uint8_t * frame_data
compressed frame data
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
int8_t skip_frame
skip output step
#define s(width, name)
Definition: cbs_vp9.c:257
uint8_t packet_offset
offset to the frame in the packet
av_cold void ff_llauddsp_init(LLAudDSPContext *c)
static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
uint8_t packet_done
set when a packet is fully decoded
main decoder context
uint8_t do_ac_filter
static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS *WMALL_MAX_CHANNELS]
uint16_t samples_per_frame
number of samples to output
if(ret)
static const float pred[4]
Definition: siprdata.h:259
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int next_packet_start
start offset of the next WMA packet in the demuxer packet
int frame_size
Definition: mxfenc.c:2166
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:1191
#define WMALL_MAX_CHANNELS
current decoder limitations
main external API structure.
Definition: avcodec.h:531
int16_t * samples_16[WMALL_MAX_CHANNELS]
current sample buffer pointer (16-bit)
static void decode_lpc(WmallDecodeCtx *s)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1879
int extradata_size
Definition: avcodec.h:633
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define AV_STRINGIFY(s)
Definition: macros.h:36
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: codec.h:93
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
uint8_t num_subframes
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
Calculate remaining input buffer length.
GetBitContext gb
bitstream reader context
uint32_t frame_num
current frame number (not used for decoding)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version, unsigned int decode_flags)
Get the samples per frame for this stream.
Definition: wma_common.c:32
uint8_t do_inter_ch_decorr
uint16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
WmallChannelCtx channel[WMALL_MAX_CHANNELS]
per channel data
#define MAX_FRAMESIZE
maximum compressed frame size
common internal api header.
#define WMALL_COEFF_PAD_SIZE
pad coef buffers with 0 for use with SIMD
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:117
int dynamic_range_compression
frame contains DRC data
int transient_counter
number of transient samples from the beginning of the transient zone
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
static void save_bits(WmallDecodeCtx *s, GetBitContext *gb, int len, int append)
Fill the bit reservoir with a (partial) frame.
int transient_pos[WMALL_MAX_CHANNELS]
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void * priv_data
Definition: avcodec.h:558
int len
int channels
number of audio channels
Definition: avcodec.h:1192
int16_t lms_updates[MAX_ORDER *2+WMALL_COEFF_PAD_SIZE/sizeof(int16_t)]
AVCodec ff_wmalossless_decoder
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:940
static void flush(AVCodecContext *avctx)
int8_t acfilter_scaling
int len_prefix
frame is prefixed with its length
static int decode_frame(WmallDecodeCtx *s)
Decode one WMA frame.
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
int transient[WMALL_MAX_CHANNELS]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
int32_t mclms_prevvalues[WMALL_MAX_CHANNELS *2 *32]
int num_saved_bits
saved number of bits
int subframe_offset
subframe offset in the bit reservoir
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
int lpc_coefs[WMALL_MAX_CHANNELS][40]
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
for(j=16;j >0;--j)
int i
Definition: input.c:407
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
#define av_unused
Definition: attributes.h:131
static void revert_mclms(WmallDecodeCtx *s, int tile_size)
static uint8_t tmp[11]
Definition: aes_ctr.c:26
bitstream writer API