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