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  int 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) {
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;
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
532  i++;
533  }
534  for (; i < tile_size; i++) {
535  int quo = 0, rem, rem_bits, residue;
536  while(get_bits1(&s->gb)) {
537  quo++;
538  if (get_bits_left(&s->gb) <= 0)
539  return -1;
540  }
541  if (quo >= 32)
542  quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
543 
544  ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
545  if (ave_mean <= 1)
546  residue = quo;
547  else {
548  rem_bits = av_ceil_log2(ave_mean);
549  rem = get_bits_long(&s->gb, rem_bits);
550  residue = (quo << rem_bits) + rem;
551  }
552 
553  s->ave_sum[ch] = residue + s->ave_sum[ch] -
554  (s->ave_sum[ch] >> s->movave_scaling);
555 
556  residue = (residue >> 1) ^ -(residue & 1);
557  s->channel_residues[ch][i] = residue;
558  }
559 
560  return 0;
561 
562 }
563 
565 {
566  int ch, i, cbits;
567  s->lpc_order = get_bits(&s->gb, 5) + 1;
568  s->lpc_scaling = get_bits(&s->gb, 4);
569  s->lpc_intbits = get_bits(&s->gb, 3) + 1;
570  cbits = s->lpc_scaling + s->lpc_intbits;
571  for (ch = 0; ch < s->num_channels; ch++)
572  for (i = 0; i < s->lpc_order; i++)
573  s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
574 }
575 
577 {
578  int ich, ilms;
579 
580  memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
581  memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
582  memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
583 
584  memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
585  memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
586  memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
587  memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
588 
589  for (ich = 0; ich < s->num_channels; ich++) {
590  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
591  memset(s->cdlms[ich][ilms].coefs, 0,
592  sizeof(s->cdlms[ich][ilms].coefs));
593  memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
594  sizeof(s->cdlms[ich][ilms].lms_prevvalues));
595  memset(s->cdlms[ich][ilms].lms_updates, 0,
596  sizeof(s->cdlms[ich][ilms].lms_updates));
597  }
598  s->ave_sum[ich] = 0;
599  }
600 }
601 
602 /**
603  * @brief Reset filter parameters and transient area at new seekable tile.
604  */
606 {
607  int ich, ilms;
609  for (ich = 0; ich < s->num_channels; ich++) {
610  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
611  s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
612  /* first sample of a seekable subframe is considered as the starting of
613  a transient area which is samples_per_frame samples long */
615  s->transient[ich] = 1;
616  s->transient_pos[ich] = 0;
617  }
618 }
619 
620 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
621 {
622  int i, j, ich, pred_error;
623  int order = s->mclms_order;
624  int num_channels = s->num_channels;
625  int range = 1 << (s->bits_per_sample - 1);
626 
627  for (ich = 0; ich < num_channels; ich++) {
628  pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
629  if (pred_error > 0) {
630  for (i = 0; i < order * num_channels; i++)
631  s->mclms_coeffs[i + ich * order * num_channels] +=
632  s->mclms_updates[s->mclms_recent + i];
633  for (j = 0; j < ich; j++)
634  s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
635  } else if (pred_error < 0) {
636  for (i = 0; i < order * num_channels; i++)
637  s->mclms_coeffs[i + ich * order * num_channels] -=
638  s->mclms_updates[s->mclms_recent + i];
639  for (j = 0; j < ich; j++)
640  s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
641  }
642  }
643 
644  for (ich = num_channels - 1; ich >= 0; ich--) {
645  s->mclms_recent--;
646  s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
647  -range, range - 1);
648  s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
649  }
650 
651  if (s->mclms_recent == 0) {
652  memcpy(&s->mclms_prevvalues[order * num_channels],
653  s->mclms_prevvalues,
654  sizeof(int32_t) * order * num_channels);
655  memcpy(&s->mclms_updates[order * num_channels],
656  s->mclms_updates,
657  sizeof(int32_t) * order * num_channels);
658  s->mclms_recent = num_channels * order;
659  }
660 }
661 
662 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
663 {
664  int ich, i;
665  int order = s->mclms_order;
666  int num_channels = s->num_channels;
667 
668  for (ich = 0; ich < num_channels; ich++) {
669  pred[ich] = 0;
670  if (!s->is_channel_coded[ich])
671  continue;
672  for (i = 0; i < order * num_channels; i++)
673  pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
674  s->mclms_coeffs[i + order * num_channels * ich];
675  for (i = 0; i < ich; i++)
676  pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
677  s->mclms_coeffs_cur[i + num_channels * ich];
678  pred[ich] += (1 << s->mclms_scaling) >> 1;
679  pred[ich] >>= s->mclms_scaling;
680  s->channel_residues[ich][icoef] += (unsigned)pred[ich];
681  }
682 }
683 
684 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
685 {
686  int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
687  for (icoef = 0; icoef < tile_size; icoef++) {
688  mclms_predict(s, icoef, pred);
689  mclms_update(s, icoef, pred);
690  }
691 }
692 
693 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
694 {
695  int ilms, recent, icoef;
696  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
697  recent = s->cdlms[ich][ilms].recent;
698  if (s->update_speed[ich] == 16)
699  continue;
700  if (s->bV3RTM) {
701  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
702  s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
703  } else {
704  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
705  s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
706  }
707  }
708  s->update_speed[ich] = 16;
709 }
710 
712 {
713  int ilms, recent, icoef;
714  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
715  recent = s->cdlms[ich][ilms].recent;
716  if (s->update_speed[ich] == 8)
717  continue;
718  if (s->bV3RTM)
719  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
720  s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
721  else
722  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
723  s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
724  }
725  s->update_speed[ich] = 8;
726 }
727 
728 #define CD_LMS(bits, ROUND) \
729 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
730 { \
731  int recent = s->cdlms[ich][ilms].recent; \
732  int range = 1 << s->bits_per_sample - 1; \
733  int order = s->cdlms[ich][ilms].order; \
734  int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
735  \
736  if (recent) \
737  recent--; \
738  else { \
739  memcpy(prev + order, prev, (bits/8) * order); \
740  memcpy(s->cdlms[ich][ilms].lms_updates + order, \
741  s->cdlms[ich][ilms].lms_updates, \
742  sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
743  recent = order - 1; \
744  } \
745  \
746  prev[recent] = av_clip(input, -range, range - 1); \
747  s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
748  \
749  s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
750  s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
751  s->cdlms[ich][ilms].recent = recent; \
752  memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
753  sizeof(s->cdlms[ich][ilms].lms_updates) - \
754  sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
755 } \
756  \
757 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
758  int coef_begin, int coef_end) \
759 { \
760  int icoef, pred, ilms, num_lms, residue, input; \
761  \
762  num_lms = s->cdlms_ttl[ch]; \
763  for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
764  for (icoef = coef_begin; icoef < coef_end; icoef++) { \
765  int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
766  pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
767  residue = s->channel_residues[ch][icoef]; \
768  pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
769  prevvalues + s->cdlms[ch][ilms].recent, \
770  s->cdlms[ch][ilms].lms_updates + \
771  s->cdlms[ch][ilms].recent, \
772  FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
773  WMASIGN(residue)); \
774  input = residue + (pred >> s->cdlms[ch][ilms].scaling); \
775  lms_update ## bits(s, ch, ilms, input); \
776  s->channel_residues[ch][icoef] = input; \
777  } \
778  } \
779  if (bits <= 16) emms_c(); \
780 }
781 
783 CD_LMS(32, 8)
784 
785 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
786 {
787  if (s->num_channels != 2)
788  return;
789  else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
790  int icoef;
791  for (icoef = 0; icoef < tile_size; icoef++) {
792  s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
793  s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
794  }
795  }
796 }
797 
798 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
799 {
800  int ich, pred, i, j;
801  int16_t *filter_coeffs = s->acfilter_coeffs;
802  int scaling = s->acfilter_scaling;
803  int order = s->acfilter_order;
804 
805  for (ich = 0; ich < s->num_channels; ich++) {
806  int *prevvalues = s->acfilter_prevvalues[ich];
807  for (i = 0; i < order; i++) {
808  pred = 0;
809  for (j = 0; j < order; j++) {
810  if (i <= j)
811  pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
812  else
813  pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
814  }
815  pred >>= scaling;
816  s->channel_residues[ich][i] += (unsigned)pred;
817  }
818  for (i = order; i < tile_size; i++) {
819  pred = 0;
820  for (j = 0; j < order; j++)
821  pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
822  pred >>= scaling;
823  s->channel_residues[ich][i] += (unsigned)pred;
824  }
825  for (j = 0; j < order; j++)
826  prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
827  }
828 }
829 
831 {
832  int offset = s->samples_per_frame;
834  int total_samples = s->samples_per_frame * s->num_channels;
835  int i, j, rawpcm_tile, padding_zeroes, res;
836 
838 
839  /* reset channel context and find the next block offset and size
840  == the next block of the channel with the smallest number of
841  decoded samples */
842  for (i = 0; i < s->num_channels; i++) {
843  if (offset > s->channel[i].decoded_samples) {
844  offset = s->channel[i].decoded_samples;
845  subframe_len =
847  }
848  }
849 
850  /* get a list of all channels that contain the estimated block */
852  for (i = 0; i < s->num_channels; i++) {
853  const int cur_subframe = s->channel[i].cur_subframe;
854  /* subtract already processed samples */
855  total_samples -= s->channel[i].decoded_samples;
856 
857  /* and count if there are multiple subframes that match our profile */
858  if (offset == s->channel[i].decoded_samples &&
859  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
860  total_samples -= s->channel[i].subframe_len[cur_subframe];
861  s->channel[i].decoded_samples +=
865  }
866  }
867 
868  /* check if the frame will be complete after processing the
869  estimated block */
870  if (!total_samples)
871  s->parsed_all_subframes = 1;
872 
873 
874  s->seekable_tile = get_bits1(&s->gb);
875  if (s->seekable_tile) {
877 
878  s->do_arith_coding = get_bits1(&s->gb);
879  if (s->do_arith_coding) {
880  avpriv_request_sample(s->avctx, "Arithmetic coding");
881  return AVERROR_PATCHWELCOME;
882  }
883  s->do_ac_filter = get_bits1(&s->gb);
884  s->do_inter_ch_decorr = get_bits1(&s->gb);
885  s->do_mclms = get_bits1(&s->gb);
886 
887  if (s->do_ac_filter)
888  decode_ac_filter(s);
889 
890  if (s->do_mclms)
891  decode_mclms(s);
892 
893  if ((res = decode_cdlms(s)) < 0)
894  return res;
895  s->movave_scaling = get_bits(&s->gb, 3);
896  s->quant_stepsize = get_bits(&s->gb, 8) + 1;
897 
898  reset_codec(s);
899  }
900 
901  rawpcm_tile = get_bits1(&s->gb);
902 
903  if (!rawpcm_tile && !s->cdlms[0][0].order) {
905  "Waiting for seekable tile\n");
906  av_frame_unref(s->frame);
907  return -1;
908  }
909 
910 
911  for (i = 0; i < s->num_channels; i++)
912  s->is_channel_coded[i] = 1;
913 
914  if (!rawpcm_tile) {
915  for (i = 0; i < s->num_channels; i++)
916  s->is_channel_coded[i] = get_bits1(&s->gb);
917 
918  if (s->bV3RTM) {
919  // LPC
920  s->do_lpc = get_bits1(&s->gb);
921  if (s->do_lpc) {
922  decode_lpc(s);
923  avpriv_request_sample(s->avctx, "Expect wrong output since "
924  "inverse LPC filter");
925  }
926  } else
927  s->do_lpc = 0;
928  }
929 
930 
931  if (get_bits1(&s->gb))
932  padding_zeroes = get_bits(&s->gb, 5);
933  else
934  padding_zeroes = 0;
935 
936  if (rawpcm_tile) {
937  int bits = s->bits_per_sample - padding_zeroes;
938  if (bits <= 0) {
940  "Invalid number of padding bits in raw PCM tile\n");
941  return AVERROR_INVALIDDATA;
942  }
943  ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
944  "total %d bits, remain=%d\n", bits,
945  bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
946  for (i = 0; i < s->num_channels; i++)
947  for (j = 0; j < subframe_len; j++)
948  s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
949  } else {
950  if (s->bits_per_sample < padding_zeroes)
951  return AVERROR_INVALIDDATA;
952  for (i = 0; i < s->num_channels; i++) {
953  if (s->is_channel_coded[i]) {
954  decode_channel_residues(s, i, subframe_len);
955  if (s->seekable_tile)
956  use_high_update_speed(s, i);
957  else
959  if (s->bits_per_sample > 16)
960  revert_cdlms32(s, i, 0, subframe_len);
961  else
962  revert_cdlms16(s, i, 0, subframe_len);
963  } else {
964  memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
965  }
966  }
967 
968  if (s->do_mclms)
969  revert_mclms(s, subframe_len);
970  if (s->do_inter_ch_decorr)
971  revert_inter_ch_decorr(s, subframe_len);
972  if (s->do_ac_filter)
973  revert_acfilter(s, subframe_len);
974 
975  /* Dequantize */
976  if (s->quant_stepsize != 1)
977  for (i = 0; i < s->num_channels; i++)
978  for (j = 0; j < subframe_len; j++)
979  s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
980  }
981 
982  /* Write to proper output buffer depending on bit-depth */
983  for (i = 0; i < s->channels_for_cur_subframe; i++) {
985  int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
986 
987  for (j = 0; j < subframe_len; j++) {
988  if (s->bits_per_sample == 16) {
989  *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
990  } else {
991  *s->samples_32[c]++ = s->channel_residues[c][j] * (256 << padding_zeroes);
992  }
993  }
994  }
995 
996  /* handled one subframe */
997  for (i = 0; i < s->channels_for_cur_subframe; i++) {
999  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1000  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1001  return AVERROR_INVALIDDATA;
1002  }
1003  ++s->channel[c].cur_subframe;
1004  }
1005  return 0;
1006 }
1007 
1008 /**
1009  * @brief Decode one WMA frame.
1010  * @param s codec context
1011  * @return 0 if the trailer bit indicates that this is the last frame,
1012  * 1 if there are additional frames
1013  */
1015 {
1016  GetBitContext* gb = &s->gb;
1017  int more_frames = 0, len = 0, i, ret;
1018 
1020  if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1021  /* return an error if no frame could be decoded at all */
1022  s->packet_loss = 1;
1023  s->frame->nb_samples = 0;
1024  return ret;
1025  }
1026  for (i = 0; i < s->num_channels; i++) {
1027  s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1028  s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1029  }
1030 
1031  /* get frame length */
1032  if (s->len_prefix)
1033  len = get_bits(gb, s->log2_frame_size);
1034 
1035  /* decode tile information */
1036  if ((ret = decode_tilehdr(s))) {
1037  s->packet_loss = 1;
1038  av_frame_unref(s->frame);
1039  return ret;
1040  }
1041 
1042  /* read drc info */
1044  s->drc_gain = get_bits(gb, 8);
1045 
1046  /* no idea what these are for, might be the number of samples
1047  that need to be skipped at the beginning or end of a stream */
1048  if (get_bits1(gb)) {
1049  int av_unused skip;
1050 
1051  /* usually true for the first frame */
1052  if (get_bits1(gb)) {
1053  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1054  ff_dlog(s->avctx, "start skip: %i\n", skip);
1055  }
1056 
1057  /* sometimes true for the last frame */
1058  if (get_bits1(gb)) {
1059  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1060  ff_dlog(s->avctx, "end skip: %i\n", skip);
1061  s->frame->nb_samples -= skip;
1062  if (s->frame->nb_samples <= 0)
1063  return AVERROR_INVALIDDATA;
1064  }
1065 
1066  }
1067 
1068  /* reset subframe states */
1069  s->parsed_all_subframes = 0;
1070  for (i = 0; i < s->num_channels; i++) {
1071  s->channel[i].decoded_samples = 0;
1072  s->channel[i].cur_subframe = 0;
1073  }
1074 
1075  /* decode all subframes */
1076  while (!s->parsed_all_subframes) {
1078  if (decode_subframe(s) < 0) {
1079  s->packet_loss = 1;
1080  if (s->frame->nb_samples)
1082  return 0;
1083  }
1084  }
1085 
1086  ff_dlog(s->avctx, "Frame done\n");
1087 
1088  s->skip_frame = 0;
1089 
1090  if (s->len_prefix) {
1091  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1092  /* FIXME: not sure if this is always an error */
1094  "frame[%"PRIu32"] would have to skip %i bits\n",
1095  s->frame_num,
1096  len - (get_bits_count(gb) - s->frame_offset) - 1);
1097  s->packet_loss = 1;
1098  return 0;
1099  }
1100 
1101  /* skip the rest of the frame data */
1102  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1103  }
1104 
1105  /* decode trailer bit */
1106  more_frames = get_bits1(gb);
1107  ++s->frame_num;
1108  return more_frames;
1109 }
1110 
1111 /**
1112  * @brief Calculate remaining input buffer length.
1113  * @param s codec context
1114  * @param gb bitstream reader context
1115  * @return remaining size in bits
1116  */
1118 {
1119  return s->buf_bit_size - get_bits_count(gb);
1120 }
1121 
1122 /**
1123  * @brief Fill the bit reservoir with a (partial) frame.
1124  * @param s codec context
1125  * @param gb bitstream reader context
1126  * @param len length of the partial frame
1127  * @param append decides whether to reset the buffer or not
1128  */
1129 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1130  int append)
1131 {
1132  int buflen;
1134 
1135  /* when the frame data does not need to be concatenated, the input buffer
1136  is reset and additional bits from the previous frame are copied
1137  and skipped later so that a fast byte copy is possible */
1138 
1139  if (!append) {
1140  s->frame_offset = get_bits_count(gb) & 7;
1141  s->num_saved_bits = s->frame_offset;
1143  }
1144 
1145  buflen = (s->num_saved_bits + len + 8) >> 3;
1146 
1147  if (len <= 0 || buflen > s->max_frame_size) {
1148  avpriv_request_sample(s->avctx, "Too small input buffer");
1149  s->packet_loss = 1;
1150  s->num_saved_bits = 0;
1151  return;
1152  }
1153 
1154  s->num_saved_bits += len;
1155  if (!append) {
1156  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1157  s->num_saved_bits);
1158  } else {
1159  int align = 8 - (get_bits_count(gb) & 7);
1160  align = FFMIN(align, len);
1161  put_bits(&s->pb, align, get_bits(gb, align));
1162  len -= align;
1163  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1164  }
1165  skip_bits_long(gb, len);
1166 
1167  tmp = s->pb;
1168  flush_put_bits(&tmp);
1169 
1171  skip_bits(&s->gb, s->frame_offset);
1172 }
1173 
1174 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1175  AVPacket* avpkt)
1176 {
1177  WmallDecodeCtx *s = avctx->priv_data;
1178  GetBitContext* gb = &s->pgb;
1179  const uint8_t* buf = avpkt->data;
1180  int buf_size = avpkt->size;
1181  int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1182 
1183  s->frame->nb_samples = 0;
1184 
1185  if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1186  s->packet_done = 0;
1187  if (!decode_frame(s))
1188  s->num_saved_bits = 0;
1189  } else if (s->packet_done || s->packet_loss) {
1190  s->packet_done = 0;
1191 
1192  if (!buf_size)
1193  return 0;
1194 
1195  s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1196  buf_size = FFMIN(avctx->block_align, buf_size);
1197  s->buf_bit_size = buf_size << 3;
1198 
1199  /* parse packet header */
1200  init_get_bits(gb, buf, s->buf_bit_size);
1201  packet_sequence_number = get_bits(gb, 4);
1202  skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently unused
1203  spliced_packet = get_bits1(gb);
1204  if (spliced_packet)
1205  avpriv_request_sample(avctx, "Bitstream splicing");
1206 
1207  /* get number of bits that need to be added to the previous frame */
1208  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1209 
1210  /* check for packet loss */
1211  if (!s->packet_loss &&
1212  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1213  s->packet_loss = 1;
1214  av_log(avctx, AV_LOG_ERROR,
1215  "Packet loss detected! seq %"PRIx8" vs %x\n",
1216  s->packet_sequence_number, packet_sequence_number);
1217  }
1218  s->packet_sequence_number = packet_sequence_number;
1219 
1220  if (num_bits_prev_frame > 0) {
1221  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1222  if (num_bits_prev_frame >= remaining_packet_bits) {
1223  num_bits_prev_frame = remaining_packet_bits;
1224  s->packet_done = 1;
1225  }
1226 
1227  /* Append the previous frame data to the remaining data from the
1228  * previous packet to create a full frame. */
1229  save_bits(s, gb, num_bits_prev_frame, 1);
1230 
1231  /* decode the cross packet frame if it is valid */
1232  if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1233  decode_frame(s);
1234  } else if (s->num_saved_bits - s->frame_offset) {
1235  ff_dlog(avctx, "ignoring %x previously saved bits\n",
1236  s->num_saved_bits - s->frame_offset);
1237  }
1238 
1239  if (s->packet_loss) {
1240  /* Reset number of saved bits so that the decoder does not start
1241  * to decode incomplete frames in the s->len_prefix == 0 case. */
1242  s->num_saved_bits = 0;
1243  s->packet_loss = 0;
1245  }
1246 
1247  } else {
1248  int frame_size;
1249 
1250  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1251  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1252  skip_bits(gb, s->packet_offset);
1253 
1254  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1255  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1256  frame_size <= remaining_bits(s, gb)) {
1257  save_bits(s, gb, frame_size, 0);
1258 
1259  if (!s->packet_loss)
1260  s->packet_done = !decode_frame(s);
1261  } else if (!s->len_prefix
1262  && s->num_saved_bits > get_bits_count(&s->gb)) {
1263  /* when the frames do not have a length prefix, we don't know the
1264  * compressed length of the individual frames however, we know what
1265  * part of a new packet belongs to the previous frame therefore we
1266  * save the incoming packet first, then we append the "previous
1267  * frame" data from the next packet so that we get a buffer that
1268  * only contains full frames */
1269  s->packet_done = !decode_frame(s);
1270  } else {
1271  s->packet_done = 1;
1272  }
1273  }
1274 
1275  if (remaining_bits(s, gb) < 0) {
1276  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1277  s->packet_loss = 1;
1278  }
1279 
1280  if (s->packet_done && !s->packet_loss &&
1281  remaining_bits(s, gb) > 0) {
1282  /* save the rest of the data so that it can be decoded
1283  * with the next packet */
1284  save_bits(s, gb, remaining_bits(s, gb), 0);
1285  }
1286 
1287  *got_frame_ptr = s->frame->nb_samples > 0;
1288  av_frame_move_ref(data, s->frame);
1289 
1290  s->packet_offset = get_bits_count(gb) & 7;
1291 
1292  return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1293 }
1294 
1295 static void flush(AVCodecContext *avctx)
1296 {
1297  WmallDecodeCtx *s = avctx->priv_data;
1298  s->packet_loss = 1;
1299  s->packet_done = 0;
1300  s->num_saved_bits = 0;
1301  s->frame_offset = 0;
1302  s->next_packet_start = 0;
1303  s->cdlms[0][0].order = 0;
1304  s->frame->nb_samples = 0;
1306 }
1307 
1309 {
1310  WmallDecodeCtx *s = avctx->priv_data;
1311 
1312  av_frame_free(&s->frame);
1313  av_freep(&s->frame_data);
1314 
1315  return 0;
1316 }
1317 
1319  .name = "wmalossless",
1320  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1321  .type = AVMEDIA_TYPE_AUDIO,
1323  .priv_data_size = sizeof(WmallDecodeCtx),
1324  .init = decode_init,
1325  .close = decode_close,
1326  .decode = decode_packet,
1327  .flush = flush,
1329  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1330  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1333 };
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:295
uint8_t max_subframe_len_bit
flag indicating that the subframe is of maximum size when the first subframe length bit is 1 ...
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:208
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: avcodec.h:1495
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:64
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:236
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2813
int cdlms_ttl[WMALL_MAX_CHANNELS]
static int decode_subframe_length(WmallDecodeCtx *s, int offset)
Decode the subframe length.
AVCodec.
Definition: avcodec.h:3506
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2279
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: avcodec.h:1013
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:2250
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
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
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:1683
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: avcodec.h:1494
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
int buf_bit_size
buffer size in bits
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:176
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:202
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:186
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:197
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: avcodec.h:3513
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]
struct WmallDecodeCtx::@205 cdlms[WMALL_MAX_CHANNELS][9]
int8_t parsed_all_subframes
all subframes decoded?
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2293
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
const AVS_VideoInfo int align
Definition: avisynth_c.h:887
int next_packet_start
start offset of the next WMA packet in the demuxer packet
int frame_size
Definition: mxfenc.c:2140
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2242
#define WMALL_MAX_CHANNELS
current decoder limitations
main external API structure.
Definition: avcodec.h:1582
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:1968
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1684
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: avcodec.h:1031
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.
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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
int ave_sum[WMALL_MAX_CHANNELS]
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:101
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:48
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:797
void * priv_data
Definition: avcodec.h:1609
int len
int channels
number of audio channels
Definition: avcodec.h:2243
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:701
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:342
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:87
This structure stores compressed data.
Definition: avcodec.h:1471
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
int lpc_coefs[WMALL_MAX_CHANNELS][40]
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:988
for(j=16;j >0;--j)
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:125
static void revert_mclms(WmallDecodeCtx *s, int tile_size)
static uint8_t tmp[11]
Definition: aes_ctr.c:26
bitstream writer API