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 Libav.
9  *
10  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include "libavutil/attributes.h"
26 #include "libavutil/avassert.h"
27 
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "get_bits.h"
31 #include "put_bits.h"
32 #include "wma.h"
33 #include "wma_common.h"
34 
36 #define WMALL_MAX_CHANNELS 8
37 #define MAX_SUBFRAMES 32
38 #define MAX_BANDS 29
39 #define MAX_FRAMESIZE 32768
40 #define MAX_ORDER 256
41 
42 #define WMALL_BLOCK_MIN_BITS 6
43 #define WMALL_BLOCK_MAX_BITS 14
44 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)
45 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1)
46 
47 
51 typedef struct {
52  int16_t prev_block_len;
55  uint16_t subframe_len[MAX_SUBFRAMES];
56  uint16_t subframe_offsets[MAX_SUBFRAMES];
58  uint16_t decoded_samples;
59  int quant_step;
62 
66 typedef struct WmallDecodeCtx {
67  /* generic decoder variables */
72 
73  /* frame size dependent frame information (set during initialization) */
74  uint32_t decode_flags;
75  int len_prefix;
78  uint16_t samples_per_frame;
79  uint16_t log2_frame_size;
80  int8_t num_channels;
81  int8_t lfe_channel;
86 
87  /* packet decode state */
97 
98  /* frame decode state */
99  uint32_t frame_num;
105  int8_t skip_frame;
107 
108  /* subframe/block decode state */
109  int16_t subframe_len;
112 
114 
115  // WMA Lossless-specific
116 
122 
125  int64_t acfilter_coeffs[16];
127 
128  int8_t mclms_order;
135 
138 
139  struct {
140  int order;
141  int scaling;
142  int coefsend;
143  int bitsend;
144  int16_t coefs[MAX_ORDER];
145  int16_t lms_prevvalues[MAX_ORDER * 2];
146  int16_t lms_updates[MAX_ORDER * 2];
147  int recent;
148  } cdlms[2][9];
149 
150  int cdlms_ttl[2];
151 
152  int bV3RTM;
153 
155  int update_speed[2];
156 
157  int transient[2];
160 
161  int ave_sum[2];
162 
164 
165  int lpc_coefs[2][40];
169 
172 
173 
175 {
176  WmallDecodeCtx *s = avctx->priv_data;
177  uint8_t *edata_ptr = avctx->extradata;
178  unsigned int channel_mask;
179  int i, log2_max_num_subframes;
180 
181  s->avctx = avctx;
183 
184  if (avctx->extradata_size >= 18) {
185  s->decode_flags = AV_RL16(edata_ptr + 14);
186  channel_mask = AV_RL32(edata_ptr + 2);
187  s->bits_per_sample = AV_RL16(edata_ptr);
188  if (s->bits_per_sample == 16)
190  else if (s->bits_per_sample == 24) {
192  av_log_missing_feature(avctx, "Bit-depth higher than 16", 0);
193  return AVERROR_PATCHWELCOME;
194  } else {
195  av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %d\n",
196  s->bits_per_sample);
197  return AVERROR_INVALIDDATA;
198  }
199  /* dump the extradata */
200  for (i = 0; i < avctx->extradata_size; i++)
201  av_dlog(avctx, "[%x] ", avctx->extradata[i]);
202  av_dlog(avctx, "\n");
203 
204  } else {
205  av_log_ask_for_sample(avctx, "Unsupported extradata size\n");
206  return AVERROR_PATCHWELCOME;
207  }
208 
209  /* generic init */
210  s->log2_frame_size = av_log2(avctx->block_align) + 4;
211 
212  /* frame info */
213  s->skip_frame = 1; /* skip first frame */
214  s->packet_loss = 1;
215  s->len_prefix = s->decode_flags & 0x40;
216 
217  /* get frame len */
219  3, s->decode_flags);
221 
222  /* init previous block len */
223  for (i = 0; i < avctx->channels; i++)
225 
226  /* subframe info */
227  log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
228  s->max_num_subframes = 1 << log2_max_num_subframes;
229  s->max_subframe_len_bit = 0;
230  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
231 
234  s->bV3RTM = s->decode_flags & 0x100;
235 
236  if (s->max_num_subframes > MAX_SUBFRAMES) {
237  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
238  s->max_num_subframes);
239  return AVERROR_INVALIDDATA;
240  }
241 
242  s->num_channels = avctx->channels;
243 
244  /* extract lfe channel position */
245  s->lfe_channel = -1;
246 
247  if (channel_mask & 8) {
248  unsigned int mask;
249  for (mask = 1; mask < 16; mask <<= 1)
250  if (channel_mask & mask)
251  ++s->lfe_channel;
252  }
253 
254  if (s->num_channels < 0) {
255  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
256  s->num_channels);
257  return AVERROR_INVALIDDATA;
258  } else if (s->num_channels > WMALL_MAX_CHANNELS) {
259  av_log_ask_for_sample(avctx, "unsupported number of channels\n");
260  return AVERROR_PATCHWELCOME;
261  }
262 
264  avctx->coded_frame = &s->frame;
265  avctx->channel_layout = channel_mask;
266  return 0;
267 }
268 
275 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
276 {
277  int frame_len_ratio, subframe_len, len;
278 
279  /* no need to read from the bitstream when only one length is possible */
280  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
281  return s->min_samples_per_subframe;
282 
283  len = av_log2(s->max_num_subframes - 1) + 1;
284  frame_len_ratio = get_bits(&s->gb, len);
285  subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
286 
287  /* sanity check the length */
288  if (subframe_len < s->min_samples_per_subframe ||
289  subframe_len > s->samples_per_frame) {
290  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
291  subframe_len);
292  return AVERROR_INVALIDDATA;
293  }
294  return subframe_len;
295 }
296 
318 {
319  uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
320  uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
321  int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
322  int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
323  int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
324  int c, tile_aligned;
325 
326  /* reset tiling information */
327  for (c = 0; c < s->num_channels; c++)
328  s->channel[c].num_subframes = 0;
329 
330  tile_aligned = get_bits1(&s->gb);
331  if (s->max_num_subframes == 1 || tile_aligned)
332  fixed_channel_layout = 1;
333 
334  /* loop until the frame data is split between the subframes */
335  do {
336  int subframe_len, in_use = 0;
337 
338  /* check which channels contain the subframe */
339  for (c = 0; c < s->num_channels; c++) {
340  if (num_samples[c] == min_channel_len) {
341  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
342  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
343  contains_subframe[c] = in_use = 1;
344  } else {
345  if (get_bits1(&s->gb))
346  contains_subframe[c] = in_use = 1;
347  }
348  } else
349  contains_subframe[c] = 0;
350  }
351 
352  if (!in_use) {
354  "Found empty subframe\n");
355  return AVERROR_INVALIDDATA;
356  }
357 
358  /* get subframe length, subframe_len == 0 is not allowed */
359  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
360  return AVERROR_INVALIDDATA;
361  /* add subframes to the individual channels and find new min_channel_len */
362  min_channel_len += subframe_len;
363  for (c = 0; c < s->num_channels; c++) {
364  WmallChannelCtx *chan = &s->channel[c];
365 
366  if (contains_subframe[c]) {
367  if (chan->num_subframes >= MAX_SUBFRAMES) {
369  "broken frame: num subframes > 31\n");
370  return AVERROR_INVALIDDATA;
371  }
372  chan->subframe_len[chan->num_subframes] = subframe_len;
373  num_samples[c] += subframe_len;
374  ++chan->num_subframes;
375  if (num_samples[c] > s->samples_per_frame) {
376  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
377  "channel len(%d) > samples_per_frame(%d)\n",
378  num_samples[c], s->samples_per_frame);
379  return AVERROR_INVALIDDATA;
380  }
381  } else if (num_samples[c] <= min_channel_len) {
382  if (num_samples[c] < min_channel_len) {
383  channels_for_cur_subframe = 0;
384  min_channel_len = num_samples[c];
385  }
386  ++channels_for_cur_subframe;
387  }
388  }
389  } while (min_channel_len < s->samples_per_frame);
390 
391  for (c = 0; c < s->num_channels; c++) {
392  int i, offset = 0;
393  for (i = 0; i < s->channel[c].num_subframes; i++) {
394  s->channel[c].subframe_offsets[i] = offset;
395  offset += s->channel[c].subframe_len[i];
396  }
397  }
398 
399  return 0;
400 }
401 
403 {
404  int i;
405  s->acfilter_order = get_bits(&s->gb, 4) + 1;
406  s->acfilter_scaling = get_bits(&s->gb, 4);
407 
408  for (i = 0; i < s->acfilter_order; i++)
409  s->acfilter_coeffs[i] = (s->acfilter_scaling ?
410  get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
411 }
412 
414 {
415  s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
416  s->mclms_scaling = get_bits(&s->gb, 4);
417  if (get_bits1(&s->gb)) {
418  int i, send_coef_bits;
419  int cbits = av_log2(s->mclms_scaling + 1);
420  if (1 << cbits < s->mclms_scaling + 1)
421  cbits++;
422 
423  send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
424 
425  for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
426  s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
427 
428  for (i = 0; i < s->num_channels; i++) {
429  int c;
430  for (c = 0; c < i; c++)
431  s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
432  }
433  }
434 }
435 
437 {
438  int c, i;
439  int cdlms_send_coef = get_bits1(&s->gb);
440 
441  for (c = 0; c < s->num_channels; c++) {
442  s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
443  for (i = 0; i < s->cdlms_ttl[c]; i++) {
444  s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
445  if (s->cdlms[c][i].order > MAX_ORDER) {
447  "Order[%d][%d] %d > max (%d), not supported\n",
448  c, i, s->cdlms[c][i].order, MAX_ORDER);
449  s->cdlms[0][0].order = 0;
450  return AVERROR_INVALIDDATA;
451  }
452  }
453 
454  for (i = 0; i < s->cdlms_ttl[c]; i++)
455  s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
456 
457  if (cdlms_send_coef) {
458  for (i = 0; i < s->cdlms_ttl[c]; i++) {
459  int cbits, shift_l, shift_r, j;
460  cbits = av_log2(s->cdlms[c][i].order);
461  if ((1 << cbits) < s->cdlms[c][i].order)
462  cbits++;
463  s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
464 
465  cbits = av_log2(s->cdlms[c][i].scaling + 1);
466  if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
467  cbits++;
468 
469  s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
470  shift_l = 32 - s->cdlms[c][i].bitsend;
471  shift_r = 32 - s->cdlms[c][i].scaling - 2;
472  for (j = 0; j < s->cdlms[c][i].coefsend; j++)
473  s->cdlms[c][i].coefs[j] =
474  (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
475  }
476  }
477  }
478 
479  return 0;
480 }
481 
482 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
483 {
484  int i = 0;
485  unsigned int ave_mean;
486  s->transient[ch] = get_bits1(&s->gb);
487  if (s->transient[ch]) {
488  s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
489  if (s->transient_pos[ch])
490  s->transient[ch] = 0;
491  s->channel[ch].transient_counter =
493  } else if (s->channel[ch].transient_counter)
494  s->transient[ch] = 1;
495 
496  if (s->seekable_tile) {
497  ave_mean = get_bits(&s->gb, s->bits_per_sample);
498  s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
499  }
500 
501  if (s->seekable_tile) {
502  if (s->do_inter_ch_decorr)
503  s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
504  else
505  s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
506  i++;
507  }
508  for (; i < tile_size; i++) {
509  int quo = 0, rem, rem_bits, residue;
510  while(get_bits1(&s->gb)) {
511  quo++;
512  if (get_bits_left(&s->gb) <= 0)
513  return -1;
514  }
515  if (quo >= 32)
516  quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
517 
518  ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
519  if (ave_mean <= 1)
520  residue = quo;
521  else {
522  rem_bits = av_ceil_log2(ave_mean);
523  rem = rem_bits ? get_bits_long(&s->gb, rem_bits) : 0;
524  residue = (quo << rem_bits) + rem;
525  }
526 
527  s->ave_sum[ch] = residue + s->ave_sum[ch] -
528  (s->ave_sum[ch] >> s->movave_scaling);
529 
530  if (residue & 1)
531  residue = -(residue >> 1) - 1;
532  else
533  residue = residue >> 1;
534  s->channel_residues[ch][i] = residue;
535  }
536 
537  return 0;
538 
539 }
540 
541 static void decode_lpc(WmallDecodeCtx *s)
542 {
543  int ch, i, cbits;
544  s->lpc_order = get_bits(&s->gb, 5) + 1;
545  s->lpc_scaling = get_bits(&s->gb, 4);
546  s->lpc_intbits = get_bits(&s->gb, 3) + 1;
547  cbits = s->lpc_scaling + s->lpc_intbits;
548  for (ch = 0; ch < s->num_channels; ch++)
549  for (i = 0; i < s->lpc_order; i++)
550  s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
551 }
552 
554 {
555  int ich, ilms;
556 
557  memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
558  memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
559  memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
560 
561  memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
562  memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
563  memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
564  memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
565 
566  for (ich = 0; ich < s->num_channels; ich++) {
567  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
568  memset(s->cdlms[ich][ilms].coefs, 0,
569  sizeof(s->cdlms[ich][ilms].coefs));
570  memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
571  sizeof(s->cdlms[ich][ilms].lms_prevvalues));
572  memset(s->cdlms[ich][ilms].lms_updates, 0,
573  sizeof(s->cdlms[ich][ilms].lms_updates));
574  }
575  s->ave_sum[ich] = 0;
576  }
577 }
578 
583 {
584  int ich, ilms;
586  for (ich = 0; ich < s->num_channels; ich++) {
587  for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
588  s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
589  /* first sample of a seekable subframe is considered as the starting of
590  a transient area which is samples_per_frame samples long */
592  s->transient[ich] = 1;
593  s->transient_pos[ich] = 0;
594  }
595 }
596 
597 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
598 {
599  int i, j, ich, pred_error;
600  int order = s->mclms_order;
601  int num_channels = s->num_channels;
602  int range = 1 << (s->bits_per_sample - 1);
603 
604  for (ich = 0; ich < num_channels; ich++) {
605  pred_error = s->channel_residues[ich][icoef] - pred[ich];
606  if (pred_error > 0) {
607  for (i = 0; i < order * num_channels; i++)
608  s->mclms_coeffs[i + ich * order * num_channels] +=
609  s->mclms_updates[s->mclms_recent + i];
610  for (j = 0; j < ich; j++) {
611  if (s->channel_residues[j][icoef] > 0)
612  s->mclms_coeffs_cur[ich * num_channels + j] += 1;
613  else if (s->channel_residues[j][icoef] < 0)
614  s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
615  }
616  } else if (pred_error < 0) {
617  for (i = 0; i < order * num_channels; i++)
618  s->mclms_coeffs[i + ich * order * num_channels] -=
619  s->mclms_updates[s->mclms_recent + i];
620  for (j = 0; j < ich; j++) {
621  if (s->channel_residues[j][icoef] > 0)
622  s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
623  else if (s->channel_residues[j][icoef] < 0)
624  s->mclms_coeffs_cur[ich * num_channels + j] += 1;
625  }
626  }
627  }
628 
629  for (ich = num_channels - 1; ich >= 0; ich--) {
630  s->mclms_recent--;
631  s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
632  if (s->channel_residues[ich][icoef] > range - 1)
633  s->mclms_prevvalues[s->mclms_recent] = range - 1;
634  else if (s->channel_residues[ich][icoef] < -range)
635  s->mclms_prevvalues[s->mclms_recent] = -range;
636 
637  s->mclms_updates[s->mclms_recent] = 0;
638  if (s->channel_residues[ich][icoef] > 0)
639  s->mclms_updates[s->mclms_recent] = 1;
640  else if (s->channel_residues[ich][icoef] < 0)
641  s->mclms_updates[s->mclms_recent] = -1;
642  }
643 
644  if (s->mclms_recent == 0) {
645  memcpy(&s->mclms_prevvalues[order * num_channels],
646  s->mclms_prevvalues,
647  2 * order * num_channels);
648  memcpy(&s->mclms_updates[order * num_channels],
649  s->mclms_updates,
650  2 * order * num_channels);
651  s->mclms_recent = num_channels * order;
652  }
653 }
654 
655 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
656 {
657  int ich, i;
658  int order = s->mclms_order;
659  int num_channels = s->num_channels;
660 
661  for (ich = 0; ich < num_channels; ich++) {
662  pred[ich] = 0;
663  if (!s->is_channel_coded[ich])
664  continue;
665  for (i = 0; i < order * num_channels; i++)
666  pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
667  s->mclms_coeffs[i + order * num_channels * ich];
668  for (i = 0; i < ich; i++)
669  pred[ich] += s->channel_residues[i][icoef] *
670  s->mclms_coeffs_cur[i + num_channels * ich];
671  pred[ich] += 1 << s->mclms_scaling - 1;
672  pred[ich] >>= s->mclms_scaling;
673  s->channel_residues[ich][icoef] += pred[ich];
674  }
675 }
676 
677 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
678 {
679  int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
680  for (icoef = 0; icoef < tile_size; icoef++) {
681  mclms_predict(s, icoef, pred);
682  mclms_update(s, icoef, pred);
683  }
684 }
685 
686 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
687 {
688  int pred = 0, icoef;
689  int recent = s->cdlms[ich][ilms].recent;
690 
691  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
692  pred += s->cdlms[ich][ilms].coefs[icoef] *
693  s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
694 
695  return pred;
696 }
697 
698 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
699  int input, int residue)
700 {
701  int icoef;
702  int recent = s->cdlms[ich][ilms].recent;
703  int range = 1 << s->bits_per_sample - 1;
704 
705  if (residue < 0) {
706  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
707  s->cdlms[ich][ilms].coefs[icoef] -=
708  s->cdlms[ich][ilms].lms_updates[icoef + recent];
709  } else if (residue > 0) {
710  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
711  s->cdlms[ich][ilms].coefs[icoef] +=
712  s->cdlms[ich][ilms].lms_updates[icoef + recent];
713  }
714 
715  if (recent)
716  recent--;
717  else {
718  memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
719  s->cdlms[ich][ilms].lms_prevvalues,
720  2 * s->cdlms[ich][ilms].order);
721  memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
722  s->cdlms[ich][ilms].lms_updates,
723  2 * s->cdlms[ich][ilms].order);
724  recent = s->cdlms[ich][ilms].order - 1;
725  }
726 
727  s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
728  if (!input)
729  s->cdlms[ich][ilms].lms_updates[recent] = 0;
730  else if (input < 0)
731  s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
732  else
733  s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
734 
735  s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
736  s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
737  s->cdlms[ich][ilms].recent = recent;
738 }
739 
740 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
741 {
742  int ilms, recent, icoef;
743  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
744  recent = s->cdlms[ich][ilms].recent;
745  if (s->update_speed[ich] == 16)
746  continue;
747  if (s->bV3RTM) {
748  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
749  s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
750  } else {
751  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
752  s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
753  }
754  }
755  s->update_speed[ich] = 16;
756 }
757 
758 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
759 {
760  int ilms, recent, icoef;
761  for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
762  recent = s->cdlms[ich][ilms].recent;
763  if (s->update_speed[ich] == 8)
764  continue;
765  if (s->bV3RTM)
766  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
767  s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
768  else
769  for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
770  s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
771  }
772  s->update_speed[ich] = 8;
773 }
774 
775 static void revert_cdlms(WmallDecodeCtx *s, int ch,
776  int coef_begin, int coef_end)
777 {
778  int icoef, pred, ilms, num_lms, residue, input;
779 
780  num_lms = s->cdlms_ttl[ch];
781  for (ilms = num_lms - 1; ilms >= 0; ilms--) {
782  for (icoef = coef_begin; icoef < coef_end; icoef++) {
783  pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
784  residue = s->channel_residues[ch][icoef];
785  pred += lms_predict(s, ch, ilms);
786  input = residue + (pred >> s->cdlms[ch][ilms].scaling);
787  lms_update(s, ch, ilms, input, residue);
788  s->channel_residues[ch][icoef] = input;
789  }
790  }
791 }
792 
793 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
794 {
795  if (s->num_channels != 2)
796  return;
797  else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
798  int icoef;
799  for (icoef = 0; icoef < tile_size; icoef++) {
800  s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
801  s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
802  }
803  }
804 }
805 
806 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
807 {
808  int ich, pred, i, j;
809  int64_t *filter_coeffs = s->acfilter_coeffs;
810  int scaling = s->acfilter_scaling;
811  int order = s->acfilter_order;
812 
813  for (ich = 0; ich < s->num_channels; ich++) {
814  int *prevvalues = s->acfilter_prevvalues[ich];
815  for (i = 0; i < order; i++) {
816  pred = 0;
817  for (j = 0; j < order; j++) {
818  if (i <= j)
819  pred += filter_coeffs[j] * prevvalues[j - i];
820  else
821  pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
822  }
823  pred >>= scaling;
824  s->channel_residues[ich][i] += pred;
825  }
826  for (i = order; i < tile_size; i++) {
827  pred = 0;
828  for (j = 0; j < order; j++)
829  pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
830  pred >>= scaling;
831  s->channel_residues[ich][i] += pred;
832  }
833  for (j = 0; j < order; j++)
834  prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
835  }
836 }
837 
839 {
840  int offset = s->samples_per_frame;
841  int subframe_len = s->samples_per_frame;
842  int total_samples = s->samples_per_frame * s->num_channels;
843  int i, j, rawpcm_tile, padding_zeroes, res;
844 
846 
847  /* reset channel context and find the next block offset and size
848  == the next block of the channel with the smallest number of
849  decoded samples */
850  for (i = 0; i < s->num_channels; i++) {
851  if (offset > s->channel[i].decoded_samples) {
852  offset = s->channel[i].decoded_samples;
853  subframe_len =
855  }
856  }
857 
858  /* get a list of all channels that contain the estimated block */
860  for (i = 0; i < s->num_channels; i++) {
861  const int cur_subframe = s->channel[i].cur_subframe;
862  /* subtract already processed samples */
863  total_samples -= s->channel[i].decoded_samples;
864 
865  /* and count if there are multiple subframes that match our profile */
866  if (offset == s->channel[i].decoded_samples &&
867  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
868  total_samples -= s->channel[i].subframe_len[cur_subframe];
869  s->channel[i].decoded_samples +=
870  s->channel[i].subframe_len[cur_subframe];
873  }
874  }
875 
876  /* check if the frame will be complete after processing the
877  estimated block */
878  if (!total_samples)
879  s->parsed_all_subframes = 1;
880 
881 
882  s->seekable_tile = get_bits1(&s->gb);
883  if (s->seekable_tile) {
885 
886  s->do_arith_coding = get_bits1(&s->gb);
887  if (s->do_arith_coding) {
888  av_log_missing_feature(s->avctx, "Arithmetic coding", 1);
889  return AVERROR_PATCHWELCOME;
890  }
891  s->do_ac_filter = get_bits1(&s->gb);
892  s->do_inter_ch_decorr = get_bits1(&s->gb);
893  s->do_mclms = get_bits1(&s->gb);
894 
895  if (s->do_ac_filter)
896  decode_ac_filter(s);
897 
898  if (s->do_mclms)
899  decode_mclms(s);
900 
901  if ((res = decode_cdlms(s)) < 0)
902  return res;
903  s->movave_scaling = get_bits(&s->gb, 3);
904  s->quant_stepsize = get_bits(&s->gb, 8) + 1;
905 
906  reset_codec(s);
907  } else if (!s->cdlms[0][0].order) {
909  "Waiting for seekable tile\n");
910  s->frame.nb_samples = 0;
911  return -1;
912  }
913 
914  rawpcm_tile = get_bits1(&s->gb);
915 
916  for (i = 0; i < s->num_channels; i++)
917  s->is_channel_coded[i] = 1;
918 
919  if (!rawpcm_tile) {
920  for (i = 0; i < s->num_channels; i++)
921  s->is_channel_coded[i] = get_bits1(&s->gb);
922 
923  if (s->bV3RTM) {
924  // LPC
925  s->do_lpc = get_bits1(&s->gb);
926  if (s->do_lpc) {
927  decode_lpc(s);
928  av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
929  "implemented. Expect wrong output.\n");
930  }
931  } else
932  s->do_lpc = 0;
933  }
934 
935 
936  if (get_bits1(&s->gb))
937  padding_zeroes = get_bits(&s->gb, 5);
938  else
939  padding_zeroes = 0;
940 
941  if (rawpcm_tile) {
942  int bits = s->bits_per_sample - padding_zeroes;
943  if (bits <= 0) {
945  "Invalid number of padding bits in raw PCM tile\n");
946  return AVERROR_INVALIDDATA;
947  }
948  av_dlog(s->avctx, "RAWPCM %d bits per sample. "
949  "total %d bits, remain=%d\n", bits,
950  bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
951  for (i = 0; i < s->num_channels; i++)
952  for (j = 0; j < subframe_len; j++)
953  s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
954  } else {
955  for (i = 0; i < s->num_channels; i++)
956  if (s->is_channel_coded[i]) {
957  decode_channel_residues(s, i, subframe_len);
958  if (s->seekable_tile)
959  use_high_update_speed(s, i);
960  else
962  revert_cdlms(s, i, 0, subframe_len);
963  } else {
964  memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
965  }
966  }
967  if (s->do_mclms)
968  revert_mclms(s, subframe_len);
969  if (s->do_inter_ch_decorr)
970  revert_inter_ch_decorr(s, subframe_len);
971  if (s->do_ac_filter)
972  revert_acfilter(s, subframe_len);
973 
974  /* Dequantize */
975  if (s->quant_stepsize != 1)
976  for (i = 0; i < s->num_channels; i++)
977  for (j = 0; j < subframe_len; j++)
978  s->channel_residues[i][j] *= s->quant_stepsize;
979 
980  /* Write to proper output buffer depending on bit-depth */
981  for (i = 0; i < s->channels_for_cur_subframe; i++) {
982  int c = s->channel_indexes_for_cur_subframe[i];
983  int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
984 
985  for (j = 0; j < subframe_len; j++) {
986  if (s->bits_per_sample == 16) {
987  *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
988  } else {
989  *s->samples_32[c]++ = s->channel_residues[c][j] << padding_zeroes;
990  }
991  }
992  }
993 
994  /* handled one subframe */
995  for (i = 0; i < s->channels_for_cur_subframe; i++) {
996  int c = s->channel_indexes_for_cur_subframe[i];
997  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
998  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001  ++s->channel[c].cur_subframe;
1002  }
1003  return 0;
1004 }
1005 
1013 {
1014  GetBitContext* gb = &s->gb;
1015  int more_frames = 0, len = 0, i, ret;
1016 
1018  if ((ret = ff_get_buffer(s->avctx, &s->frame)) < 0) {
1019  /* return an error if no frame could be decoded at all */
1021  "not enough space for the output samples\n");
1022  s->packet_loss = 1;
1023  return ret;
1024  }
1025  for (i = 0; i < s->num_channels; i++) {
1026  s->samples_16[i] = (int16_t *)s->frame.extended_data[i];
1027  s->samples_32[i] = (int32_t *)s->frame.extended_data[i];
1028  }
1029 
1030  /* get frame length */
1031  if (s->len_prefix)
1032  len = get_bits(gb, s->log2_frame_size);
1033 
1034  /* decode tile information */
1035  if (decode_tilehdr(s)) {
1036  s->packet_loss = 1;
1037  return 0;
1038  }
1039 
1040  /* read drc info */
1042  s->drc_gain = get_bits(gb, 8);
1043 
1044  /* no idea what these are for, might be the number of samples
1045  that need to be skipped at the beginning or end of a stream */
1046  if (get_bits1(gb)) {
1047  int av_unused skip;
1048 
1049  /* usually true for the first frame */
1050  if (get_bits1(gb)) {
1051  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1052  av_dlog(s->avctx, "start skip: %i\n", skip);
1053  }
1054 
1055  /* sometimes true for the last frame */
1056  if (get_bits1(gb)) {
1057  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1058  av_dlog(s->avctx, "end skip: %i\n", skip);
1059  }
1060 
1061  }
1062 
1063  /* reset subframe states */
1064  s->parsed_all_subframes = 0;
1065  for (i = 0; i < s->num_channels; i++) {
1066  s->channel[i].decoded_samples = 0;
1067  s->channel[i].cur_subframe = 0;
1068  }
1069 
1070  /* decode all subframes */
1071  while (!s->parsed_all_subframes) {
1072  if (decode_subframe(s) < 0) {
1073  s->packet_loss = 1;
1074  return 0;
1075  }
1076  }
1077 
1078  av_dlog(s->avctx, "Frame done\n");
1079 
1080  if (s->skip_frame)
1081  s->skip_frame = 0;
1082 
1083  if (s->len_prefix) {
1084  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1085  /* FIXME: not sure if this is always an error */
1087  "frame[%i] would have to skip %i bits\n", s->frame_num,
1088  len - (get_bits_count(gb) - s->frame_offset) - 1);
1089  s->packet_loss = 1;
1090  return 0;
1091  }
1092 
1093  /* skip the rest of the frame data */
1094  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1095  }
1096 
1097  /* decode trailer bit */
1098  more_frames = get_bits1(gb);
1099  ++s->frame_num;
1100  return more_frames;
1101 }
1102 
1110 {
1111  return s->buf_bit_size - get_bits_count(gb);
1112 }
1113 
1121 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1122  int append)
1123 {
1124  int buflen;
1125  PutBitContext tmp;
1126 
1127  /* when the frame data does not need to be concatenated, the input buffer
1128  is reset and additional bits from the previous frame are copied
1129  and skipped later so that a fast byte copy is possible */
1130 
1131  if (!append) {
1132  s->frame_offset = get_bits_count(gb) & 7;
1133  s->num_saved_bits = s->frame_offset;
1135  }
1136 
1137  buflen = (s->num_saved_bits + len + 8) >> 3;
1138 
1139  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1140  av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1141  s->packet_loss = 1;
1142  return;
1143  }
1144 
1145  s->num_saved_bits += len;
1146  if (!append) {
1147  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1148  s->num_saved_bits);
1149  } else {
1150  int align = 8 - (get_bits_count(gb) & 7);
1151  align = FFMIN(align, len);
1152  put_bits(&s->pb, align, get_bits(gb, align));
1153  len -= align;
1154  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1155  }
1156  skip_bits_long(gb, len);
1157 
1158  tmp = s->pb;
1159  flush_put_bits(&tmp);
1160 
1162  skip_bits(&s->gb, s->frame_offset);
1163 }
1164 
1165 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1166  AVPacket* avpkt)
1167 {
1168  WmallDecodeCtx *s = avctx->priv_data;
1169  GetBitContext* gb = &s->pgb;
1170  const uint8_t* buf = avpkt->data;
1171  int buf_size = avpkt->size;
1172  int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1173 
1174  s->frame.nb_samples = 0;
1175 
1176  if (s->packet_done || s->packet_loss) {
1177  s->packet_done = 0;
1178 
1179  /* sanity check for the buffer length */
1180  if (buf_size < avctx->block_align)
1181  return 0;
1182 
1183  s->next_packet_start = buf_size - avctx->block_align;
1184  buf_size = avctx->block_align;
1185  s->buf_bit_size = buf_size << 3;
1186 
1187  /* parse packet header */
1188  init_get_bits(gb, buf, s->buf_bit_size);
1189  packet_sequence_number = get_bits(gb, 4);
1190  skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1191  spliced_packet = get_bits1(gb);
1192  if (spliced_packet)
1193  av_log_missing_feature(avctx, "Bitstream splicing", 1);
1194 
1195  /* get number of bits that need to be added to the previous frame */
1196  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1197 
1198  /* check for packet loss */
1199  if (!s->packet_loss &&
1200  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1201  s->packet_loss = 1;
1202  av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1203  s->packet_sequence_number, packet_sequence_number);
1204  }
1205  s->packet_sequence_number = packet_sequence_number;
1206 
1207  if (num_bits_prev_frame > 0) {
1208  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1209  if (num_bits_prev_frame >= remaining_packet_bits) {
1210  num_bits_prev_frame = remaining_packet_bits;
1211  s->packet_done = 1;
1212  }
1213 
1214  /* Append the previous frame data to the remaining data from the
1215  * previous packet to create a full frame. */
1216  save_bits(s, gb, num_bits_prev_frame, 1);
1217 
1218  /* decode the cross packet frame if it is valid */
1219  if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1220  decode_frame(s);
1221  } else if (s->num_saved_bits - s->frame_offset) {
1222  av_dlog(avctx, "ignoring %x previously saved bits\n",
1223  s->num_saved_bits - s->frame_offset);
1224  }
1225 
1226  if (s->packet_loss) {
1227  /* Reset number of saved bits so that the decoder does not start
1228  * to decode incomplete frames in the s->len_prefix == 0 case. */
1229  s->num_saved_bits = 0;
1230  s->packet_loss = 0;
1232  }
1233 
1234  } else {
1235  int frame_size;
1236 
1237  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1238  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1239  skip_bits(gb, s->packet_offset);
1240 
1241  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1242  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1243  frame_size <= remaining_bits(s, gb)) {
1244  save_bits(s, gb, frame_size, 0);
1245  s->packet_done = !decode_frame(s);
1246  } else if (!s->len_prefix
1247  && s->num_saved_bits > get_bits_count(&s->gb)) {
1248  /* when the frames do not have a length prefix, we don't know the
1249  * compressed length of the individual frames however, we know what
1250  * part of a new packet belongs to the previous frame therefore we
1251  * save the incoming packet first, then we append the "previous
1252  * frame" data from the next packet so that we get a buffer that
1253  * only contains full frames */
1254  s->packet_done = !decode_frame(s);
1255  } else {
1256  s->packet_done = 1;
1257  }
1258  }
1259 
1260  if (s->packet_done && !s->packet_loss &&
1261  remaining_bits(s, gb) > 0) {
1262  /* save the rest of the data so that it can be decoded
1263  * with the next packet */
1264  save_bits(s, gb, remaining_bits(s, gb), 0);
1265  }
1266 
1267  *(AVFrame *)data = s->frame;
1268  *got_frame_ptr = s->frame.nb_samples > 0;
1269  s->packet_offset = get_bits_count(gb) & 7;
1270 
1271  return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1272 }
1273 
1274 static void flush(AVCodecContext *avctx)
1275 {
1276  WmallDecodeCtx *s = avctx->priv_data;
1277  s->packet_loss = 1;
1278  s->packet_done = 0;
1279  s->num_saved_bits = 0;
1280  s->frame_offset = 0;
1281  s->next_packet_start = 0;
1282  s->cdlms[0][0].order = 0;
1283  s->frame.nb_samples = 0;
1285 }
1286 
1288  .name = "wmalossless",
1289  .type = AVMEDIA_TYPE_AUDIO,
1291  .priv_data_size = sizeof(WmallDecodeCtx),
1292  .init = decode_init,
1293  .decode = decode_packet,
1294  .flush = flush,
1296  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1297  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1300 };
static void decode_ac_filter(WmallDecodeCtx *s)
int16_t prev_block_len
length of the previous block
int16_t lms_prevvalues[MAX_ORDER *2]
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])
struct WmallDecodeCtx WmallDecodeCtx
main decoder context
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
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
uint16_t subframe_offsets[MAX_SUBFRAMES]
subframe positions in the current frame
int16_t mclms_updates[WMALL_MAX_CHANNELS *2 *32]
int32_t * samples_32[WMALL_MAX_CHANNELS]
current samplebuffer pointer (24-bit)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
int channel_coeffs[2][WMALL_BLOCK_MAX_SIZE]
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
uint8_t drc_gain
gain for the DRC tool
int size
Definition: avcodec.h:916
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:60
const uint8_t * buffer
Definition: get_bits.h:53
PutBitContext pb
context for filling the frame_data buffer
#define AV_RL16
Definition: intreadwrite.h:42
uint8_t cur_subframe
current subframe number
static void decode_mclms(WmallDecodeCtx *s)
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int lpc_coefs[2][40]
static int decode_subframe_length(WmallDecodeCtx *s, int offset)
Decode the subframe length.
static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
AVCodec.
Definition: avcodec.h:2960
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2141
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
#define MAX_ORDER
int8_t channels_for_cur_subframe
number of channels that contain the subframe
Macro definitions for various function/variable attributes.
uint8_t packet_sequence_number
current packet number
int16_t subframe_len
current subframe length
uint16_t decoded_samples
number of already processed samples
GetBitContext pgb
bitstream reader context for the packet
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
int quant_step
quantization step for the current subframe
uint8_t bits
Definition: crc.c:31
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
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:1454
int frame_offset
frame offset in the bit reservoir
const char data[16]
Definition: mxf.c:66
static uint8_t * append(uint8_t *buf, const uint8_t *src, int size)
uint16_t min_samples_per_subframe
struct WmallDecodeCtx::@66 cdlms[2][9]
uint8_t * data
Definition: avcodec.h:915
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
bitstream reader API header.
signed 32 bits, planar
Definition: samplefmt.h:59
frame-specific decoder context for a single channel
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
int8_t lfe_channel
lfe channel index
uint8_t do_arith_coding
static const uint8_t frame_size[4]
Definition: g723_1_data.h:47
int buf_bit_size
buffer size in bits
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:547
int16_t mclms_coeffs[WMALL_MAX_CHANNELS *WMALL_MAX_CHANNELS *32]
void av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
static const uint16_t mask[17]
Definition: lzw.c:38
int16_t coefs[MAX_ORDER]
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:88
static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
simple assert() macros that are a bit more flexible than ISO C assert().
int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS]
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
uint8_t frame_data[MAX_FRAMESIZE+FF_INPUT_BUFFER_PADDING_SIZE]
compressed frame data
static int decode_subframe(WmallDecodeCtx *s)
static int decode_cdlms(WmallDecodeCtx *s)
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:136
uint8_t transmit_coefs
static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
#define WMALL_BLOCK_MAX_SIZE
maximum block size
AVCodecContext * avctx
int8_t parsed_all_subframes
all subframes decoded?
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
static int decode_tilehdr(WmallDecodeCtx *s)
Decode how the data in the frame is split into subframes.
static void use_high_update_speed(WmallDecodeCtx *s, int ich)
#define MAX_SUBFRAMES
max number of subframes per channel
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)
uint16_t log2_frame_size
uint32_t decode_flags
used compression features
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
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
#define AV_RL32
Definition: intreadwrite.h:146
static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
int acfilter_prevvalues[2][16]
uint8_t packet_done
set when a packet is fully decoded
main decoder context
static void revert_cdlms(WmallDecodeCtx *s, int ch, int coef_begin, int coef_end)
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
int next_packet_start
start offset of the next WMA packet in the demuxer packet
external API header
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
#define WMALL_MAX_CHANNELS
current decoder limitations
main external API structure.
Definition: avcodec.h:1339
int16_t * samples_16[WMALL_MAX_CHANNELS]
current samplebuffer pointer (16-bit)
static void decode_lpc(WmallDecodeCtx *s)
int extradata_size
Definition: avcodec.h:1455
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:604
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2007
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
int16_t mclms_prevvalues[WMALL_MAX_CHANNELS *2 *32]
int64_t acfilter_coeffs[16]
int is_channel_coded[2]
uint8_t num_subframes
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:301
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)
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:31
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.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:86
int dynamic_range_compression
frame contains DRC data
int transient_counter
number of transient samples from the beginning of the transient zone
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:52
static void save_bits(WmallDecodeCtx *s, GetBitContext *gb, int len, int append)
Fill the bit reservoir with a (partial) frame.
void * priv_data
Definition: avcodec.h:1382
int len
int channels
number of audio channels
Definition: avcodec.h:2105
#define av_log2
Definition: intmath.h:85
AVCodec ff_wmalossless_decoder
signed 16 bits, planar
Definition: samplefmt.h:58
int16_t lms_updates[MAX_ORDER *2]
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.
int channel_residues[2][WMALL_BLOCK_MAX_SIZE]
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: avcodec.h:1028
int num_saved_bits
saved number of bits
int subframe_offset
subframe offset in the bit reservoir
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
for(j=16;j >0;--j)
static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input, int residue)
static void revert_mclms(WmallDecodeCtx *s, int tile_size)
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
bitstream writer API