FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wmalosslessdec.c
Go to the documentation of this file.
1 /*
2  * Windows Media Audio Lossless decoder
3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5  * Copyright (c) 2011 Andreas Ă–man
6  * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include <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
118 
120 
121  // WMA Lossless-specific
122 
128 
131  int16_t acfilter_coeffs[16];
133 
134  int8_t mclms_order;
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)];
152  DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153  int recent;
155 
157 
158  int bV3RTM;
159 
162 
163  int transient[WMALL_MAX_CHANNELS];
166 
168 
170 
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) {
188  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
189  return AVERROR(EINVAL);
190  }
191 
192  s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
194  if (!s->frame_data)
195  return AVERROR(ENOMEM);
196 
197  s->avctx = avctx;
198  ff_llauddsp_init(&s->dsp);
200 
201  if (avctx->extradata_size >= 18) {
202  s->decode_flags = AV_RL16(edata_ptr + 14);
203  channel_mask = AV_RL32(edata_ptr + 2);
204  s->bits_per_sample = AV_RL16(edata_ptr);
205  if (s->bits_per_sample == 16)
207  else if (s->bits_per_sample == 24) {
209  avctx->bits_per_raw_sample = 24;
210  } else {
211  av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
212  s->bits_per_sample);
213  return AVERROR_INVALIDDATA;
214  }
215  /* dump the extradata */
216  for (i = 0; i < avctx->extradata_size; i++)
217  ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
218  ff_dlog(avctx, "\n");
219 
220  } else {
221  avpriv_request_sample(avctx, "Unsupported extradata size");
222  return AVERROR_PATCHWELCOME;
223  }
224 
225  /* generic init */
226  s->log2_frame_size = av_log2(avctx->block_align) + 4;
227 
228  /* frame info */
229  s->skip_frame = 1; /* skip first frame */
230  s->packet_loss = 1;
231  s->len_prefix = s->decode_flags & 0x40;
232 
233  /* get frame len */
235  3, s->decode_flags);
237 
238  /* init previous block len */
239  for (i = 0; i < avctx->channels; i++)
241 
242  /* subframe info */
243  log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
244  s->max_num_subframes = 1 << log2_max_num_subframes;
245  s->max_subframe_len_bit = 0;
246  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
247 
250  s->bV3RTM = s->decode_flags & 0x100;
251 
252  if (s->max_num_subframes > MAX_SUBFRAMES) {
253  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
254  s->max_num_subframes);
255  return AVERROR_INVALIDDATA;
256  }
257 
258  s->num_channels = avctx->channels;
259 
260  /* extract lfe channel position */
261  s->lfe_channel = -1;
262 
263  if (channel_mask & 8) {
264  unsigned int mask;
265  for (mask = 1; mask < 16; mask <<= 1)
266  if (channel_mask & mask)
267  ++s->lfe_channel;
268  }
269 
270  if (s->num_channels < 0) {
271  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
272  s->num_channels);
273  return AVERROR_INVALIDDATA;
274  } else if (s->num_channels > WMALL_MAX_CHANNELS) {
275  avpriv_request_sample(avctx,
276  "More than %d channels", WMALL_MAX_CHANNELS);
277  return AVERROR_PATCHWELCOME;
278  }
279 
280  s->frame = av_frame_alloc();
281  if (!s->frame)
282  return AVERROR(ENOMEM);
283 
284  avctx->channel_layout = channel_mask;
285  return 0;
286 }
287 
288 /**
289  * @brief Decode the subframe length.
290  * @param s context
291  * @param offset sample offset in the frame
292  * @return decoded subframe length on success, < 0 in case of an error
293  */
295 {
296  int frame_len_ratio, subframe_len, len;
297 
298  /* no need to read from the bitstream when only one length is possible */
299  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
300  return s->min_samples_per_subframe;
301 
302  len = av_log2(s->max_num_subframes - 1) + 1;
303  frame_len_ratio = get_bits(&s->gb, len);
304  subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
305 
306  /* sanity check the length */
307  if (subframe_len < s->min_samples_per_subframe ||
308  subframe_len > s->samples_per_frame) {
309  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
310  subframe_len);
311  return AVERROR_INVALIDDATA;
312  }
313  return subframe_len;
314 }
315 
316 /**
317  * @brief Decode how the data in the frame is split into subframes.
318  * Every WMA frame contains the encoded data for a fixed number of
319  * samples per channel. The data for every channel might be split
320  * into several subframes. This function will reconstruct the list of
321  * subframes for every channel.
322  *
323  * If the subframes are not evenly split, the algorithm estimates the
324  * channels with the lowest number of total samples.
325  * Afterwards, for each of these channels a bit is read from the
326  * bitstream that indicates if the channel contains a subframe with the
327  * next subframe size that is going to be read from the bitstream or not.
328  * If a channel contains such a subframe, the subframe size gets added to
329  * the channel's subframe list.
330  * The algorithm repeats these steps until the frame is properly divided
331  * between the individual channels.
332  *
333  * @param s context
334  * @return 0 on success, < 0 in case of an error
335  */
337 {
338  uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
339  uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
340  int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
341  int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
342  int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
343  int c, tile_aligned;
344 
345  /* reset tiling information */
346  for (c = 0; c < s->num_channels; c++)
347  s->channel[c].num_subframes = 0;
348 
349  tile_aligned = get_bits1(&s->gb);
350  if (s->max_num_subframes == 1 || tile_aligned)
351  fixed_channel_layout = 1;
352 
353  /* loop until the frame data is split between the subframes */
354  do {
355  int subframe_len, in_use = 0;
356 
357  /* check which channels contain the subframe */
358  for (c = 0; c < s->num_channels; c++) {
359  if (num_samples[c] == min_channel_len) {
360  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
361  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
362  contains_subframe[c] = 1;
363  } else {
364  contains_subframe[c] = get_bits1(&s->gb);
365  }
366  in_use |= contains_subframe[c];
367  } else
368  contains_subframe[c] = 0;
369  }
370 
371  if (!in_use) {
373  "Found empty subframe\n");
374  return AVERROR_INVALIDDATA;
375  }
376 
377  /* get subframe length, subframe_len == 0 is not allowed */
378  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
379  return AVERROR_INVALIDDATA;
380  /* add subframes to the individual channels and find new min_channel_len */
381  min_channel_len += subframe_len;
382  for (c = 0; c < s->num_channels; c++) {
383  WmallChannelCtx *chan = &s->channel[c];
384 
385  if (contains_subframe[c]) {
386  if (chan->num_subframes >= MAX_SUBFRAMES) {
388  "broken frame: num subframes > 31\n");
389  return AVERROR_INVALIDDATA;
390  }
391  chan->subframe_len[chan->num_subframes] = subframe_len;
392  num_samples[c] += subframe_len;
393  ++chan->num_subframes;
394  if (num_samples[c] > s->samples_per_frame) {
395  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
396  "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
397  num_samples[c], s->samples_per_frame);
398  return AVERROR_INVALIDDATA;
399  }
400  } else if (num_samples[c] <= min_channel_len) {
401  if (num_samples[c] < min_channel_len) {
402  channels_for_cur_subframe = 0;
403  min_channel_len = num_samples[c];
404  }
405  ++channels_for_cur_subframe;
406  }
407  }
408  } while (min_channel_len < s->samples_per_frame);
409 
410  for (c = 0; c < s->num_channels; c++) {
411  int i, offset = 0;
412  for (i = 0; i < s->channel[c].num_subframes; i++) {
413  s->channel[c].subframe_offsets[i] = offset;
414  offset += s->channel[c].subframe_len[i];
415  }
416  }
417 
418  return 0;
419 }
420 
422 {
423  int i;
424  s->acfilter_order = get_bits(&s->gb, 4) + 1;
425  s->acfilter_scaling = get_bits(&s->gb, 4);
426 
427  for (i = 0; i < s->acfilter_order; i++)
428  s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
429 }
430 
432 {
433  s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
434  s->mclms_scaling = get_bits(&s->gb, 4);
435  if (get_bits1(&s->gb)) {
436  int i, send_coef_bits;
437  int cbits = av_log2(s->mclms_scaling + 1);
438  if (1 << cbits < s->mclms_scaling + 1)
439  cbits++;
440 
441  send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
442 
443  for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
444  s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
445 
446  for (i = 0; i < s->num_channels; i++) {
447  int c;
448  for (c = 0; c < i; c++)
449  s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
450  }
451  }
452 }
453 
455 {
456  int c, i;
457  int cdlms_send_coef = get_bits1(&s->gb);
458 
459  for (c = 0; c < s->num_channels; c++) {
460  s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
461  for (i = 0; i < s->cdlms_ttl[c]; i++) {
462  s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
463  if (s->cdlms[c][i].order > MAX_ORDER) {
465  "Order[%d][%d] %d > max (%d), not supported\n",
466  c, i, s->cdlms[c][i].order, MAX_ORDER);
467  s->cdlms[0][0].order = 0;
468  return AVERROR_INVALIDDATA;
469  }
470  if(s->cdlms[c][i].order & 8 && s->bits_per_sample == 16) {
471  static int warned;
472  if(!warned)
473  avpriv_request_sample(s->avctx, "CDLMS of order %d",
474  s->cdlms[c][i].order);
475  warned = 1;
476  }
477  }
478 
479  for (i = 0; i < s->cdlms_ttl[c]; i++)
480  s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
481 
482  if (cdlms_send_coef) {
483  for (i = 0; i < s->cdlms_ttl[c]; i++) {
484  int cbits, shift_l, shift_r, j;
485  cbits = av_log2(s->cdlms[c][i].order);
486  if ((1 << cbits) < s->cdlms[c][i].order)
487  cbits++;
488  s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
489 
490  cbits = av_log2(s->cdlms[c][i].scaling + 1);
491  if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
492  cbits++;
493 
494  s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
495  shift_l = 32 - s->cdlms[c][i].bitsend;
496  shift_r = 32 - s->cdlms[c][i].scaling - 2;
497  for (j = 0; j < s->cdlms[c][i].coefsend; j++)
498  s->cdlms[c][i].coefs[j] =
499  (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
500  }
501  }
502 
503  for (i = 0; i < s->cdlms_ttl[c]; i++)
504  memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
506  }
507 
508  return 0;
509 }
510 
511 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
512 {
513  int i = 0;
514  unsigned int ave_mean;
515  s->transient[ch] = get_bits1(&s->gb);
516  if (s->transient[ch]) {
517  s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
518  if (s->transient_pos[ch])
519  s->transient[ch] = 0;
522  } else if (s->channel[ch].transient_counter)
523  s->transient[ch] = 1;
524 
525  if (s->seekable_tile) {
526  ave_mean = get_bits(&s->gb, s->bits_per_sample);
527  s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
528  }
529 
530  if (s->seekable_tile) {
531  if (s->do_inter_ch_decorr)
532  s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
533  else
535  i++;
536  }
537  for (; i < tile_size; i++) {
538  int quo = 0, rem, rem_bits, residue;
539  while(get_bits1(&s->gb)) {
540  quo++;
541  if (get_bits_left(&s->gb) <= 0)
542  return -1;
543  }
544  if (quo >= 32)
545  quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
546 
547  ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
548  if (ave_mean <= 1)
549  residue = quo;
550  else {
551  rem_bits = av_ceil_log2(ave_mean);
552  rem = get_bits_long(&s->gb, rem_bits);
553  residue = (quo << rem_bits) + rem;
554  }
555 
556  s->ave_sum[ch] = residue + s->ave_sum[ch] -
557  (s->ave_sum[ch] >> s->movave_scaling);
558 
559  residue = (residue >> 1) ^ -(residue & 1);
560  s->channel_residues[ch][i] = residue;
561  }
562 
563  return 0;
564 
565 }
566 
568 {
569  int ch, i, cbits;
570  s->lpc_order = get_bits(&s->gb, 5) + 1;
571  s->lpc_scaling = get_bits(&s->gb, 4);
572  s->lpc_intbits = get_bits(&s->gb, 3) + 1;
573  cbits = s->lpc_scaling + s->lpc_intbits;
574  for (ch = 0; ch < s->num_channels; ch++)
575  for (i = 0; i < s->lpc_order; i++)
576  s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
577 }
578 
580 {
581  int ich, ilms;
582 
583  memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
584  memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
585  memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
586 
587  memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
588  memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
589  memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
590  memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
591 
592  for (ich = 0; ich < s->num_channels; ich++) {
593  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
594  memset(s->cdlms[ich][ilms].coefs, 0,
595  sizeof(s->cdlms[ich][ilms].coefs));
596  memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
597  sizeof(s->cdlms[ich][ilms].lms_prevvalues));
598  memset(s->cdlms[ich][ilms].lms_updates, 0,
599  sizeof(s->cdlms[ich][ilms].lms_updates));
600  }
601  s->ave_sum[ich] = 0;
602  }
603 }
604 
605 /**
606  * @brief Reset filter parameters and transient area at new seekable tile.
607  */
609 {
610  int ich, ilms;
612  for (ich = 0; ich < s->num_channels; ich++) {
613  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
614  s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
615  /* first sample of a seekable subframe is considered as the starting of
616  a transient area which is samples_per_frame samples long */
618  s->transient[ich] = 1;
619  s->transient_pos[ich] = 0;
620  }
621 }
622 
623 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
624 {
625  int i, j, ich, pred_error;
626  int order = s->mclms_order;
627  int num_channels = s->num_channels;
628  int range = 1 << (s->bits_per_sample - 1);
629 
630  for (ich = 0; ich < num_channels; ich++) {
631  pred_error = s->channel_residues[ich][icoef] - pred[ich];
632  if (pred_error > 0) {
633  for (i = 0; i < order * num_channels; i++)
634  s->mclms_coeffs[i + ich * order * num_channels] +=
635  s->mclms_updates[s->mclms_recent + i];
636  for (j = 0; j < ich; j++)
637  s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
638  } else if (pred_error < 0) {
639  for (i = 0; i < order * num_channels; i++)
640  s->mclms_coeffs[i + ich * order * num_channels] -=
641  s->mclms_updates[s->mclms_recent + i];
642  for (j = 0; j < ich; j++)
643  s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
644  }
645  }
646 
647  for (ich = num_channels - 1; ich >= 0; ich--) {
648  s->mclms_recent--;
649  s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
650  -range, range - 1);
651  s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
652  }
653 
654  if (s->mclms_recent == 0) {
655  memcpy(&s->mclms_prevvalues[order * num_channels],
656  s->mclms_prevvalues,
657  sizeof(int32_t) * order * num_channels);
658  memcpy(&s->mclms_updates[order * num_channels],
659  s->mclms_updates,
660  sizeof(int32_t) * order * num_channels);
661  s->mclms_recent = num_channels * order;
662  }
663 }
664 
665 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
666 {
667  int ich, i;
668  int order = s->mclms_order;
669  int num_channels = s->num_channels;
670 
671  for (ich = 0; ich < num_channels; ich++) {
672  pred[ich] = 0;
673  if (!s->is_channel_coded[ich])
674  continue;
675  for (i = 0; i < order * num_channels; i++)
676  pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
677  s->mclms_coeffs[i + order * num_channels * ich];
678  for (i = 0; i < ich; i++)
679  pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
680  s->mclms_coeffs_cur[i + num_channels * ich];
681  pred[ich] += 1 << s->mclms_scaling - 1;
682  pred[ich] >>= s->mclms_scaling;
683  s->channel_residues[ich][icoef] += pred[ich];
684  }
685 }
686 
687 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
688 {
689  int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
690  for (icoef = 0; icoef < tile_size; icoef++) {
691  mclms_predict(s, icoef, pred);
692  mclms_update(s, icoef, pred);
693  }
694 }
695 
696 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
697 {
698  int ilms, recent, icoef;
699  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
700  recent = s->cdlms[ich][ilms].recent;
701  if (s->update_speed[ich] == 16)
702  continue;
703  if (s->bV3RTM) {
704  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
705  s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
706  } else {
707  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
708  s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
709  }
710  }
711  s->update_speed[ich] = 16;
712 }
713 
715 {
716  int ilms, recent, icoef;
717  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
718  recent = s->cdlms[ich][ilms].recent;
719  if (s->update_speed[ich] == 8)
720  continue;
721  if (s->bV3RTM)
722  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
723  s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
724  else
725  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
726  s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
727  }
728  s->update_speed[ich] = 8;
729 }
730 
731 #define CD_LMS(bits, ROUND) \
732 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
733 { \
734  int recent = s->cdlms[ich][ilms].recent; \
735  int range = 1 << s->bits_per_sample - 1; \
736  int order = s->cdlms[ich][ilms].order; \
737  int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
738  \
739  if (recent) \
740  recent--; \
741  else { \
742  memcpy(prev + order, prev, (bits/8) * order); \
743  memcpy(s->cdlms[ich][ilms].lms_updates + order, \
744  s->cdlms[ich][ilms].lms_updates, \
745  sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
746  recent = order - 1; \
747  } \
748  \
749  prev[recent] = av_clip(input, -range, range - 1); \
750  s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
751  \
752  s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
753  s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
754  s->cdlms[ich][ilms].recent = recent; \
755  memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
756  sizeof(s->cdlms[ich][ilms].lms_updates) - \
757  sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
758 } \
759  \
760 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
761  int coef_begin, int coef_end) \
762 { \
763  int icoef, pred, ilms, num_lms, residue, input; \
764  \
765  num_lms = s->cdlms_ttl[ch]; \
766  for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
767  for (icoef = coef_begin; icoef < coef_end; icoef++) { \
768  int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
769  pred = 1 << (s->cdlms[ch][ilms].scaling - 1); \
770  residue = s->channel_residues[ch][icoef]; \
771  pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
772  prevvalues + s->cdlms[ch][ilms].recent, \
773  s->cdlms[ch][ilms].lms_updates + \
774  s->cdlms[ch][ilms].recent, \
775  FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
776  WMASIGN(residue)); \
777  input = residue + (pred >> s->cdlms[ch][ilms].scaling); \
778  lms_update ## bits(s, ch, ilms, input); \
779  s->channel_residues[ch][icoef] = input; \
780  } \
781  } \
782  if (bits <= 16) emms_c(); \
783 }
784 
786 CD_LMS(32, 8)
787 
788 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
789 {
790  if (s->num_channels != 2)
791  return;
792  else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
793  int icoef;
794  for (icoef = 0; icoef < tile_size; icoef++) {
795  s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
796  s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
797  }
798  }
799 }
800 
801 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
802 {
803  int ich, pred, i, j;
804  int16_t *filter_coeffs = s->acfilter_coeffs;
805  int scaling = s->acfilter_scaling;
806  int order = s->acfilter_order;
807 
808  for (ich = 0; ich < s->num_channels; ich++) {
809  int *prevvalues = s->acfilter_prevvalues[ich];
810  for (i = 0; i < order; i++) {
811  pred = 0;
812  for (j = 0; j < order; j++) {
813  if (i <= j)
814  pred += filter_coeffs[j] * prevvalues[j - i];
815  else
816  pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
817  }
818  pred >>= scaling;
819  s->channel_residues[ich][i] += pred;
820  }
821  for (i = order; i < tile_size; i++) {
822  pred = 0;
823  for (j = 0; j < order; j++)
824  pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
825  pred >>= scaling;
826  s->channel_residues[ich][i] += pred;
827  }
828  for (j = 0; j < order; j++)
829  prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
830  }
831 }
832 
834 {
835  int offset = s->samples_per_frame;
836  int subframe_len = s->samples_per_frame;
837  int total_samples = s->samples_per_frame * s->num_channels;
838  int i, j, rawpcm_tile, padding_zeroes, res;
839 
841 
842  /* reset channel context and find the next block offset and size
843  == the next block of the channel with the smallest number of
844  decoded samples */
845  for (i = 0; i < s->num_channels; i++) {
846  if (offset > s->channel[i].decoded_samples) {
847  offset = s->channel[i].decoded_samples;
848  subframe_len =
850  }
851  }
852 
853  /* get a list of all channels that contain the estimated block */
855  for (i = 0; i < s->num_channels; i++) {
856  const int cur_subframe = s->channel[i].cur_subframe;
857  /* subtract already processed samples */
858  total_samples -= s->channel[i].decoded_samples;
859 
860  /* and count if there are multiple subframes that match our profile */
861  if (offset == s->channel[i].decoded_samples &&
862  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
863  total_samples -= s->channel[i].subframe_len[cur_subframe];
864  s->channel[i].decoded_samples +=
865  s->channel[i].subframe_len[cur_subframe];
868  }
869  }
870 
871  /* check if the frame will be complete after processing the
872  estimated block */
873  if (!total_samples)
874  s->parsed_all_subframes = 1;
875 
876 
877  s->seekable_tile = get_bits1(&s->gb);
878  if (s->seekable_tile) {
880 
881  s->do_arith_coding = get_bits1(&s->gb);
882  if (s->do_arith_coding) {
883  avpriv_request_sample(s->avctx, "Arithmetic coding");
884  return AVERROR_PATCHWELCOME;
885  }
886  s->do_ac_filter = get_bits1(&s->gb);
887  s->do_inter_ch_decorr = get_bits1(&s->gb);
888  s->do_mclms = get_bits1(&s->gb);
889 
890  if (s->do_ac_filter)
891  decode_ac_filter(s);
892 
893  if (s->do_mclms)
894  decode_mclms(s);
895 
896  if ((res = decode_cdlms(s)) < 0)
897  return res;
898  s->movave_scaling = get_bits(&s->gb, 3);
899  s->quant_stepsize = get_bits(&s->gb, 8) + 1;
900 
901  reset_codec(s);
902  }
903 
904  rawpcm_tile = get_bits1(&s->gb);
905 
906  if (!rawpcm_tile && !s->cdlms[0][0].order) {
908  "Waiting for seekable tile\n");
909  av_frame_unref(s->frame);
910  return -1;
911  }
912 
913 
914  for (i = 0; i < s->num_channels; i++)
915  s->is_channel_coded[i] = 1;
916 
917  if (!rawpcm_tile) {
918  for (i = 0; i < s->num_channels; i++)
919  s->is_channel_coded[i] = get_bits1(&s->gb);
920 
921  if (s->bV3RTM) {
922  // LPC
923  s->do_lpc = get_bits1(&s->gb);
924  if (s->do_lpc) {
925  decode_lpc(s);
926  avpriv_request_sample(s->avctx, "Expect wrong output since "
927  "inverse LPC filter");
928  }
929  } else
930  s->do_lpc = 0;
931  }
932 
933 
934  if (get_bits1(&s->gb))
935  padding_zeroes = get_bits(&s->gb, 5);
936  else
937  padding_zeroes = 0;
938 
939  if (rawpcm_tile) {
940  int bits = s->bits_per_sample - padding_zeroes;
941  if (bits <= 0) {
943  "Invalid number of padding bits in raw PCM tile\n");
944  return AVERROR_INVALIDDATA;
945  }
946  ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
947  "total %d bits, remain=%d\n", bits,
948  bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
949  for (i = 0; i < s->num_channels; i++)
950  for (j = 0; j < subframe_len; j++)
951  s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
952  } else {
953  for (i = 0; i < s->num_channels; i++) {
954  if (s->is_channel_coded[i]) {
955  decode_channel_residues(s, i, subframe_len);
956  if (s->seekable_tile)
957  use_high_update_speed(s, i);
958  else
960  if (s->bits_per_sample > 16)
961  revert_cdlms32(s, i, 0, subframe_len);
962  else
963  revert_cdlms16(s, i, 0, subframe_len);
964  } else {
965  memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
966  }
967  }
968 
969  if (s->do_mclms)
970  revert_mclms(s, subframe_len);
971  if (s->do_inter_ch_decorr)
972  revert_inter_ch_decorr(s, subframe_len);
973  if (s->do_ac_filter)
974  revert_acfilter(s, subframe_len);
975 
976  /* Dequantize */
977  if (s->quant_stepsize != 1)
978  for (i = 0; i < s->num_channels; i++)
979  for (j = 0; j < subframe_len; j++)
980  s->channel_residues[i][j] *= s->quant_stepsize;
981  }
982 
983  /* Write to proper output buffer depending on bit-depth */
984  for (i = 0; i < s->channels_for_cur_subframe; i++) {
986  int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
987 
988  for (j = 0; j < subframe_len; j++) {
989  if (s->bits_per_sample == 16) {
990  *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
991  } else {
992  *s->samples_32[c]++ = s->channel_residues[c][j] << (padding_zeroes + 8);
993  }
994  }
995  }
996 
997  /* handled one subframe */
998  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1000  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1001  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1002  return AVERROR_INVALIDDATA;
1003  }
1004  ++s->channel[c].cur_subframe;
1005  }
1006  return 0;
1007 }
1008 
1009 /**
1010  * @brief Decode one WMA frame.
1011  * @param s codec context
1012  * @return 0 if the trailer bit indicates that this is the last frame,
1013  * 1 if there are additional frames
1014  */
1016 {
1017  GetBitContext* gb = &s->gb;
1018  int more_frames = 0, len = 0, i, ret;
1019 
1021  if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1022  /* return an error if no frame could be decoded at all */
1023  s->packet_loss = 1;
1024  s->frame->nb_samples = 0;
1025  return ret;
1026  }
1027  for (i = 0; i < s->num_channels; i++) {
1028  s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1029  s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1030  }
1031 
1032  /* get frame length */
1033  if (s->len_prefix)
1034  len = get_bits(gb, s->log2_frame_size);
1035 
1036  /* decode tile information */
1037  if ((ret = decode_tilehdr(s))) {
1038  s->packet_loss = 1;
1039  av_frame_unref(s->frame);
1040  return ret;
1041  }
1042 
1043  /* read drc info */
1045  s->drc_gain = get_bits(gb, 8);
1046 
1047  /* no idea what these are for, might be the number of samples
1048  that need to be skipped at the beginning or end of a stream */
1049  if (get_bits1(gb)) {
1050  int av_unused skip;
1051 
1052  /* usually true for the first frame */
1053  if (get_bits1(gb)) {
1054  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1055  ff_dlog(s->avctx, "start skip: %i\n", skip);
1056  }
1057 
1058  /* sometimes true for the last frame */
1059  if (get_bits1(gb)) {
1060  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1061  ff_dlog(s->avctx, "end skip: %i\n", skip);
1062  s->frame->nb_samples -= skip;
1063  if (s->frame->nb_samples <= 0)
1064  return AVERROR_INVALIDDATA;
1065  }
1066 
1067  }
1068 
1069  /* reset subframe states */
1070  s->parsed_all_subframes = 0;
1071  for (i = 0; i < s->num_channels; i++) {
1072  s->channel[i].decoded_samples = 0;
1073  s->channel[i].cur_subframe = 0;
1074  }
1075 
1076  /* decode all subframes */
1077  while (!s->parsed_all_subframes) {
1078  int decoded_samples = s->channel[0].decoded_samples;
1079  if (decode_subframe(s) < 0) {
1080  s->packet_loss = 1;
1081  if (s->frame->nb_samples)
1082  s->frame->nb_samples = decoded_samples;
1083  return 0;
1084  }
1085  }
1086 
1087  ff_dlog(s->avctx, "Frame done\n");
1088 
1089  s->skip_frame = 0;
1090 
1091  if (s->len_prefix) {
1092  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1093  /* FIXME: not sure if this is always an error */
1095  "frame[%"PRIu32"] would have to skip %i bits\n",
1096  s->frame_num,
1097  len - (get_bits_count(gb) - s->frame_offset) - 1);
1098  s->packet_loss = 1;
1099  return 0;
1100  }
1101 
1102  /* skip the rest of the frame data */
1103  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1104  }
1105 
1106  /* decode trailer bit */
1107  more_frames = get_bits1(gb);
1108  ++s->frame_num;
1109  return more_frames;
1110 }
1111 
1112 /**
1113  * @brief Calculate remaining input buffer length.
1114  * @param s codec context
1115  * @param gb bitstream reader context
1116  * @return remaining size in bits
1117  */
1119 {
1120  return s->buf_bit_size - get_bits_count(gb);
1121 }
1122 
1123 /**
1124  * @brief Fill the bit reservoir with a (partial) frame.
1125  * @param s codec context
1126  * @param gb bitstream reader context
1127  * @param len length of the partial frame
1128  * @param append decides whether to reset the buffer or not
1129  */
1130 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1131  int append)
1132 {
1133  int buflen;
1135 
1136  /* when the frame data does not need to be concatenated, the input buffer
1137  is reset and additional bits from the previous frame are copied
1138  and skipped later so that a fast byte copy is possible */
1139 
1140  if (!append) {
1141  s->frame_offset = get_bits_count(gb) & 7;
1142  s->num_saved_bits = s->frame_offset;
1144  }
1145 
1146  buflen = (s->num_saved_bits + len + 8) >> 3;
1147 
1148  if (len <= 0 || buflen > s->max_frame_size) {
1149  avpriv_request_sample(s->avctx, "Too small input buffer");
1150  s->packet_loss = 1;
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  s->packet_done = !decode_frame(s);
1259  } else if (!s->len_prefix
1260  && s->num_saved_bits > get_bits_count(&s->gb)) {
1261  /* when the frames do not have a length prefix, we don't know the
1262  * compressed length of the individual frames however, we know what
1263  * part of a new packet belongs to the previous frame therefore we
1264  * save the incoming packet first, then we append the "previous
1265  * frame" data from the next packet so that we get a buffer that
1266  * only contains full frames */
1267  s->packet_done = !decode_frame(s);
1268  } else {
1269  s->packet_done = 1;
1270  }
1271  }
1272 
1273  if (remaining_bits(s, gb) < 0) {
1274  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1275  s->packet_loss = 1;
1276  }
1277 
1278  if (s->packet_done && !s->packet_loss &&
1279  remaining_bits(s, gb) > 0) {
1280  /* save the rest of the data so that it can be decoded
1281  * with the next packet */
1282  save_bits(s, gb, remaining_bits(s, gb), 0);
1283  }
1284 
1285  *got_frame_ptr = s->frame->nb_samples > 0;
1286  av_frame_move_ref(data, s->frame);
1287 
1288  s->packet_offset = get_bits_count(gb) & 7;
1289 
1290  return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1291 }
1292 
1293 static void flush(AVCodecContext *avctx)
1294 {
1295  WmallDecodeCtx *s = avctx->priv_data;
1296  s->packet_loss = 1;
1297  s->packet_done = 0;
1298  s->num_saved_bits = 0;
1299  s->frame_offset = 0;
1300  s->next_packet_start = 0;
1301  s->cdlms[0][0].order = 0;
1302  s->frame->nb_samples = 0;
1304 }
1305 
1307 {
1308  WmallDecodeCtx *s = avctx->priv_data;
1309 
1310  av_frame_free(&s->frame);
1311  av_freep(&s->frame_data);
1312 
1313  return 0;
1314 }
1315 
1317  .name = "wmalossless",
1318  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1319  .type = AVMEDIA_TYPE_AUDIO,
1321  .priv_data_size = sizeof(WmallDecodeCtx),
1322  .init = decode_init,
1323  .close = decode_close,
1324  .decode = decode_packet,
1325  .flush = flush,
1327  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1330 };
static void decode_ac_filter(WmallDecodeCtx *s)
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])
const char * s
Definition: avisynth_c.h:768
#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:193
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:101
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:206
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:261
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:204
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t drc_gain
gain for the DRC tool
struct WmallDecodeCtx::@158 cdlms[WMALL_MAX_CHANNELS][9]
int acfilter_prevvalues[WMALL_MAX_CHANNELS][16]
int size
Definition: avcodec.h:1658
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:56
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:524
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:222
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3133
int cdlms_ttl[WMALL_MAX_CHANNELS]
static int decode_subframe_length(WmallDecodeCtx *s, int offset)
Decode the subframe length.
AVCodec.
Definition: avcodec.h:3681
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:2531
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
#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:385
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:1022
GetBitContext pgb
bitstream reader context for the packet
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int quant_step
quantization step for the current subframe
int16_t coefs[MAX_ORDER+WMALL_COEFF_PAD_SIZE/sizeof(int16_t)]
uint8_t bits
Definition: crc.c:296
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2502
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:150
int16_t acfilter_coeffs[16]
int8_t num_channels
number of channels in the stream (same as AVCodecContext.num_channels)
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:1847
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:104
uint16_t min_samples_per_subframe
uint8_t * data
Definition: avcodec.h:1657
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
#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:587
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
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
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:179
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:3688
static int decode_subframe(WmallDecodeCtx *s)
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
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
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:2545
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:296
static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
int8_t skip_frame
skip output step
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
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:795
int next_packet_start
start offset of the next WMA packet in the demuxer packet
int frame_size
Definition: mxfenc.c:1820
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2494
#define WMALL_MAX_CHANNELS
current decoder limitations
main external API structure.
Definition: avcodec.h:1732
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:1601
void * buf
Definition: avisynth_c.h:690
int extradata_size
Definition: avcodec.h:1848
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:313
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:306
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: avcodec.h:1047
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:425
uint8_t num_subframes
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:346
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:498
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
if(ret< 0)
Definition: vf_mcdeint.c:282
int dynamic_range_compression
frame contains DRC data
int transient_counter
number of transient samples from the beginning of the transient zone
static double c[64]
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.
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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:772
void * priv_data
Definition: avcodec.h:1774
int len
int channels
number of audio channels
Definition: avcodec.h:2495
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]
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:240
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:1634
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:250
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:997
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:276
#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