FFmpeg
wmaprodec.c
Go to the documentation of this file.
1 /*
2  * Wmapro compatible decoder
3  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * @brief wmapro decoder implementation
26  * Wmapro is an MDCT based codec comparable to wma standard or AAC.
27  * The decoding therefore consists of the following steps:
28  * - bitstream decoding
29  * - reconstruction of per-channel data
30  * - rescaling and inverse quantization
31  * - IMDCT
32  * - windowing and overlapp-add
33  *
34  * The compressed wmapro bitstream is split into individual packets.
35  * Every such packet contains one or more wma frames.
36  * The compressed frames may have a variable length and frames may
37  * cross packet boundaries.
38  * Common to all wmapro frames is the number of samples that are stored in
39  * a frame.
40  * The number of samples and a few other decode flags are stored
41  * as extradata that has to be passed to the decoder.
42  *
43  * The wmapro frames themselves are again split into a variable number of
44  * subframes. Every subframe contains the data for 2^N time domain samples
45  * where N varies between 7 and 12.
46  *
47  * Example wmapro bitstream (in samples):
48  *
49  * || packet 0 || packet 1 || packet 2 packets
50  * ---------------------------------------------------
51  * || frame 0 || frame 1 || frame 2 || frames
52  * ---------------------------------------------------
53  * || | | || | | | || || subframes of channel 0
54  * ---------------------------------------------------
55  * || | | || | | | || || subframes of channel 1
56  * ---------------------------------------------------
57  *
58  * The frame layouts for the individual channels of a wma frame does not need
59  * to be the same.
60  *
61  * However, if the offsets and lengths of several subframes of a frame are the
62  * same, the subframes of the channels can be grouped.
63  * Every group may then use special coding techniques like M/S stereo coding
64  * to improve the compression ratio. These channel transformations do not
65  * need to be applied to a whole subframe. Instead, they can also work on
66  * individual scale factor bands (see below).
67  * The coefficients that carry the audio signal in the frequency domain
68  * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
69  * In addition to that, the encoder can switch to a runlevel coding scheme
70  * by transmitting subframe_length / 128 zero coefficients.
71  *
72  * Before the audio signal can be converted to the time domain, the
73  * coefficients have to be rescaled and inverse quantized.
74  * A subframe is therefore split into several scale factor bands that get
75  * scaled individually.
76  * Scale factors are submitted for every frame but they might be shared
77  * between the subframes of a channel. Scale factors are initially DPCM-coded.
78  * Once scale factors are shared, the differences are transmitted as runlevel
79  * codes.
80  * Every subframe length and offset combination in the frame layout shares a
81  * common quantization factor that can be adjusted for every channel by a
82  * modifier.
83  * After the inverse quantization, the coefficients get processed by an IMDCT.
84  * The resulting values are then windowed with a sine window and the first half
85  * of the values are added to the second half of the output from the previous
86  * subframe in order to reconstruct the output samples.
87  */
88 
89 #include <inttypes.h>
90 
91 #include "libavutil/audio_fifo.h"
92 #include "libavutil/ffmath.h"
93 #include "libavutil/float_dsp.h"
94 #include "libavutil/intfloat.h"
95 #include "libavutil/intreadwrite.h"
96 #include "libavutil/mem_internal.h"
97 #include "libavutil/thread.h"
98 
99 #include "avcodec.h"
100 #include "internal.h"
101 #include "get_bits.h"
102 #include "put_bits.h"
103 #include "wmaprodata.h"
104 #include "sinewin.h"
105 #include "wma.h"
106 #include "wma_common.h"
107 
108 /** current decoder limitations */
109 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels
110 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
111 #define MAX_BANDS 29 ///< max number of scale factor bands
112 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
113 #define XMA_MAX_STREAMS 8
114 #define XMA_MAX_CHANNELS_STREAM 2
115 #define XMA_MAX_CHANNELS (XMA_MAX_STREAMS * XMA_MAX_CHANNELS_STREAM)
116 
117 #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size
118 #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size
119 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS) ///< minimum block size
120 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size
121 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
122 
123 
124 #define VLCBITS 9
125 #define SCALEVLCBITS 8
126 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
127 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
128 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
129 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
130 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
131 
132 static VLC sf_vlc; ///< scale factor DPCM vlc
133 static VLC sf_rl_vlc; ///< scale factor run length vlc
134 static VLC vec4_vlc; ///< 4 coefficients per symbol
135 static VLC vec2_vlc; ///< 2 coefficients per symbol
136 static VLC vec1_vlc; ///< 1 coefficient per symbol
137 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
138 static float sin64[33]; ///< sine table for decorrelation
139 
140 /**
141  * @brief frame specific decoder context for a single channel
142  */
143 typedef struct WMAProChannelCtx {
144  int16_t prev_block_len; ///< length of the previous block
145  uint8_t transmit_coefs;
146  uint8_t num_subframes;
147  uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
148  uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
149  uint8_t cur_subframe; ///< current subframe number
150  uint16_t decoded_samples; ///< number of already processed samples
151  uint8_t grouped; ///< channel is part of a group
152  int quant_step; ///< quantization step for the current subframe
153  int8_t reuse_sf; ///< share scale factors between subframes
154  int8_t scale_factor_step; ///< scaling step for the current subframe
155  int max_scale_factor; ///< maximum scale factor for the current subframe
156  int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
157  int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
158  int* scale_factors; ///< pointer to the scale factor values used for decoding
159  uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
160  float* coeffs; ///< pointer to the subframe decode buffer
161  uint16_t num_vec_coeffs; ///< number of vector coded coefficients
162  DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
164 
165 /**
166  * @brief channel group for channel transformations
167  */
168 typedef struct WMAProChannelGrp {
169  uint8_t num_channels; ///< number of channels in the group
170  int8_t transform; ///< transform on / off
171  int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
173  float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
175 
176 /**
177  * @brief main decoder context
178  */
179 typedef struct WMAProDecodeCtx {
180  /* generic decoder variables */
181  AVCodecContext* avctx; ///< codec context for av_log
183  uint8_t frame_data[MAX_FRAMESIZE +
184  AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
185  PutBitContext pb; ///< context for filling the frame_data buffer
186  FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
187  DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
188  const float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
189 
190  /* frame size dependent frame information (set during initialization) */
191  uint32_t decode_flags; ///< used compression features
192  uint8_t len_prefix; ///< frame is prefixed with its length
193  uint8_t dynamic_range_compression; ///< frame contains DRC data
194  uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
195  uint16_t samples_per_frame; ///< number of samples to output
196  uint16_t trim_start; ///< number of samples to skip at start
197  uint16_t trim_end; ///< number of samples to skip at end
198  uint16_t log2_frame_size;
199  int8_t lfe_channel; ///< lfe channel index
201  uint8_t subframe_len_bits; ///< number of bits used for the subframe length
202  uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
204  int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
205  int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
206  int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
207  int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
208 
209  /* packet decode state */
210  GetBitContext pgb; ///< bitstream reader context for the packet
211  int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
212  uint8_t packet_offset; ///< frame offset in the packet
213  uint8_t packet_sequence_number; ///< current packet number
214  int num_saved_bits; ///< saved number of bits
215  int frame_offset; ///< frame offset in the bit reservoir
216  int subframe_offset; ///< subframe offset in the bit reservoir
217  uint8_t packet_loss; ///< set in case of bitstream error
218  uint8_t packet_done; ///< set when a packet is fully decoded
219  uint8_t eof_done; ///< set when EOF reached and extra subframe is written (XMA1/2)
220 
221  /* frame decode state */
222  uint32_t frame_num; ///< current frame number (not used for decoding)
223  GetBitContext gb; ///< bitstream reader context
224  int buf_bit_size; ///< buffer size in bits
225  uint8_t drc_gain; ///< gain for the DRC tool
226  int8_t skip_frame; ///< skip output step
227  int8_t parsed_all_subframes; ///< all subframes decoded?
228  uint8_t skip_packets; ///< packets to skip to find next packet in a stream (XMA1/2)
229 
230  /* subframe/block decode state */
231  int16_t subframe_len; ///< current subframe length
232  int8_t nb_channels; ///< number of channels in stream (XMA1/2)
233  int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
235  int8_t num_bands; ///< number of scale factor bands
236  int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
237  int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
238  uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
239  int8_t esc_len; ///< length of escaped coefficients
240 
241  uint8_t num_chgroups; ///< number of channel groups
242  WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
243 
246 
247 typedef struct XMADecodeCtx {
255  int flushed;
256 } XMADecodeCtx;
257 
258 /**
259  *@brief helper function to print the most important members of the context
260  *@param s context
261  */
263 {
264 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
265 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
266 
267  PRINT("ed sample bit depth", s->bits_per_sample);
268  PRINT_HEX("ed decode flags", s->decode_flags);
269  PRINT("samples per frame", s->samples_per_frame);
270  PRINT("log2 frame size", s->log2_frame_size);
271  PRINT("max num subframes", s->max_num_subframes);
272  PRINT("len prefix", s->len_prefix);
273  PRINT("num channels", s->nb_channels);
274 }
275 
276 /**
277  *@brief Uninitialize the decoder and free all resources.
278  *@param avctx codec context
279  *@return 0 on success, < 0 otherwise
280  */
282 {
283  int i;
284 
285  av_freep(&s->fdsp);
286 
287  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
288  ff_mdct_end(&s->mdct_ctx[i]);
289 
290  return 0;
291 }
292 
294 {
295  WMAProDecodeCtx *s = avctx->priv_data;
296 
297  decode_end(s);
298 
299  return 0;
300 }
301 
302 static av_cold int get_rate(AVCodecContext *avctx)
303 {
304  if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
305  if (avctx->sample_rate > 44100)
306  return 48000;
307  else if (avctx->sample_rate > 32000)
308  return 44100;
309  else if (avctx->sample_rate > 24000)
310  return 32000;
311  return 24000;
312  }
313 
314  return avctx->sample_rate;
315 }
316 
317 static av_cold void decode_init_static(void)
318 {
320  scale_huffbits, 1, 1,
321  scale_huffcodes, 2, 2, 616);
323  scale_rl_huffbits, 1, 1,
324  scale_rl_huffcodes, 4, 4, 1406);
326  coef0_huffbits, 1, 1,
327  coef0_huffcodes, 4, 4, 2108);
329  coef1_huffbits, 1, 1,
330  coef1_huffcodes, 4, 4, 3912);
332  vec4_huffbits, 1, 1,
333  vec4_huffcodes, 2, 2, 604);
335  vec2_huffbits, 1, 1,
336  vec2_huffcodes, 2, 2, 562);
338  vec1_huffbits, 1, 1,
339  vec1_huffcodes, 2, 2, 562);
340 
341  /** calculate sine values for the decorrelation matrix */
342  for (int i = 0; i < 33; i++)
343  sin64[i] = sin(i * M_PI / 64.0);
344 
345  for (int i = WMAPRO_BLOCK_MIN_BITS; i <= WMAPRO_BLOCK_MAX_BITS; i++)
347 }
348 
349 /**
350  *@brief Initialize the decoder.
351  *@param avctx codec context
352  *@return 0 on success, -1 otherwise
353  */
354 static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
355 {
356  static AVOnce init_static_once = AV_ONCE_INIT;
357  uint8_t *edata_ptr = avctx->extradata;
358  unsigned int channel_mask;
359  int i, bits, ret;
360  int log2_max_num_subframes;
361  int num_possible_block_sizes;
362 
363  if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
364  avctx->block_align = 2048;
365 
366  if (!avctx->block_align) {
367  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
368  return AVERROR(EINVAL);
369  }
370 
371  s->avctx = avctx;
372 
373  init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
374 
376 
377  /** dump the extradata */
378  av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
379  for (i = 0; i < avctx->extradata_size; i++)
380  av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
381  av_log(avctx, AV_LOG_DEBUG, "\n");
382 
383  if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
384  s->decode_flags = 0x10d6;
385  s->bits_per_sample = 16;
386  channel_mask = 0; //AV_RL32(edata_ptr+2); /* not always in expected order */
387  if ((num_stream+1) * XMA_MAX_CHANNELS_STREAM > avctx->channels) /* stream config is 2ch + 2ch + ... + 1/2ch */
388  s->nb_channels = 1;
389  else
390  s->nb_channels = 2;
391  } else if (avctx->codec_id == AV_CODEC_ID_XMA2) { /* XMA2WAVEFORMAT */
392  s->decode_flags = 0x10d6;
393  s->bits_per_sample = 16;
394  channel_mask = 0; /* would need to aggregate from all streams */
395  s->nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0]; /* nth stream config */
396  } else if (avctx->codec_id == AV_CODEC_ID_XMA1) { /* XMAWAVEFORMAT */
397  s->decode_flags = 0x10d6;
398  s->bits_per_sample = 16;
399  channel_mask = 0; /* would need to aggregate from all streams */
400  s->nb_channels = edata_ptr[8 + 20*num_stream + 17]; /* nth stream config */
401  } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
402  s->decode_flags = AV_RL16(edata_ptr+14);
403  channel_mask = AV_RL32(edata_ptr+2);
404  s->bits_per_sample = AV_RL16(edata_ptr);
405  s->nb_channels = avctx->channels;
406 
407  if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
408  avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
409  return AVERROR_PATCHWELCOME;
410  }
411  } else {
412  avpriv_request_sample(avctx, "Unknown extradata size");
413  return AVERROR_PATCHWELCOME;
414  }
415 
416  /** generic init */
417  s->log2_frame_size = av_log2(avctx->block_align) + 4;
418  if (s->log2_frame_size > 25) {
419  avpriv_request_sample(avctx, "Large block align");
420  return AVERROR_PATCHWELCOME;
421  }
422 
423  /** frame info */
424  s->skip_frame = 1; /* skip first frame */
425 
426  s->packet_loss = 1;
427  s->len_prefix = (s->decode_flags & 0x40);
428 
429  /** get frame len */
430  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
431  bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
432  if (bits > WMAPRO_BLOCK_MAX_BITS) {
433  avpriv_request_sample(avctx, "14-bit block sizes");
434  return AVERROR_PATCHWELCOME;
435  }
436  s->samples_per_frame = 1 << bits;
437  } else {
438  s->samples_per_frame = 512;
439  }
440 
441  /** subframe info */
442  log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
443  s->max_num_subframes = 1 << log2_max_num_subframes;
444  if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
445  s->max_subframe_len_bit = 1;
446  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
447 
448  num_possible_block_sizes = log2_max_num_subframes + 1;
449  s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
450  s->dynamic_range_compression = (s->decode_flags & 0x80);
451 
452  if (s->max_num_subframes > MAX_SUBFRAMES) {
453  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
454  s->max_num_subframes);
455  return AVERROR_INVALIDDATA;
456  }
457 
458  if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
459  av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
460  s->min_samples_per_subframe);
461  return AVERROR_INVALIDDATA;
462  }
463 
464  if (s->avctx->sample_rate <= 0) {
465  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
466  return AVERROR_INVALIDDATA;
467  }
468 
469  if (s->nb_channels <= 0) {
470  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
471  s->nb_channels);
472  return AVERROR_INVALIDDATA;
473  } else if (avctx->codec_id != AV_CODEC_ID_WMAPRO && s->nb_channels > XMA_MAX_CHANNELS_STREAM) {
474  av_log(avctx, AV_LOG_ERROR, "invalid number of channels per XMA stream %d\n",
475  s->nb_channels);
476  return AVERROR_INVALIDDATA;
477  } else if (s->nb_channels > WMAPRO_MAX_CHANNELS || s->nb_channels > avctx->channels) {
478  avpriv_request_sample(avctx,
479  "More than %d channels", WMAPRO_MAX_CHANNELS);
480  return AVERROR_PATCHWELCOME;
481  }
482 
483  /** init previous block len */
484  for (i = 0; i < s->nb_channels; i++)
485  s->channel[i].prev_block_len = s->samples_per_frame;
486 
487  /** extract lfe channel position */
488  s->lfe_channel = -1;
489 
490  if (channel_mask & 8) {
491  unsigned int mask;
492  for (mask = 1; mask < 16; mask <<= 1) {
493  if (channel_mask & mask)
494  ++s->lfe_channel;
495  }
496  }
497 
498  /** calculate number of scale factor bands and their offsets
499  for every possible block size */
500  for (i = 0; i < num_possible_block_sizes; i++) {
501  int subframe_len = s->samples_per_frame >> i;
502  int x;
503  int band = 1;
504  int rate = get_rate(avctx);
505 
506  s->sfb_offsets[i][0] = 0;
507 
508  for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
509  int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
510  offset &= ~3;
511  if (offset > s->sfb_offsets[i][band - 1])
512  s->sfb_offsets[i][band++] = offset;
513 
514  if (offset >= subframe_len)
515  break;
516  }
517  s->sfb_offsets[i][band - 1] = subframe_len;
518  s->num_sfb[i] = band - 1;
519  if (s->num_sfb[i] <= 0) {
520  av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
521  return AVERROR_INVALIDDATA;
522  }
523  }
524 
525 
526  /** Scale factors can be shared between blocks of different size
527  as every block has a different scale factor band layout.
528  The matrix sf_offsets is needed to find the correct scale factor.
529  */
530 
531  for (i = 0; i < num_possible_block_sizes; i++) {
532  int b;
533  for (b = 0; b < s->num_sfb[i]; b++) {
534  int x;
535  int offset = ((s->sfb_offsets[i][b]
536  + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
537  for (x = 0; x < num_possible_block_sizes; x++) {
538  int v = 0;
539  while (s->sfb_offsets[x][v + 1] << x < offset) {
540  v++;
541  av_assert0(v < MAX_BANDS);
542  }
543  s->sf_offsets[i][x][b] = v;
544  }
545  }
546  }
547 
549  if (!s->fdsp)
550  return AVERROR(ENOMEM);
551 
552  /** init MDCT, FIXME: only init needed sizes */
553  for (int i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
554  ret = ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS + 1 + i, 1,
555  1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
556  / (1ll << (s->bits_per_sample - 1)));
557  if (ret < 0)
558  return ret;
559  }
560 
561  /** init MDCT windows: simple sine window */
562  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
563  const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
564  s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
565  }
566 
567  /** calculate subwoofer cutoff values */
568  for (i = 0; i < num_possible_block_sizes; i++) {
569  int block_size = s->samples_per_frame >> i;
570  int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
571  / s->avctx->sample_rate;
572  s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
573  }
574 
575  if (avctx->debug & FF_DEBUG_BITSTREAM)
576  dump_context(s);
577 
578  if (avctx->codec_id == AV_CODEC_ID_WMAPRO)
579  avctx->channel_layout = channel_mask;
580 
581  ff_thread_once(&init_static_once, decode_init_static);
582 
583  return 0;
584 }
585 
586 /**
587  *@brief Initialize the decoder.
588  *@param avctx codec context
589  *@return 0 on success, -1 otherwise
590  */
592 {
593  WMAProDecodeCtx *s = avctx->priv_data;
594 
595  return decode_init(s, avctx, 0);
596 }
597 
598 /**
599  *@brief Decode the subframe length.
600  *@param s context
601  *@param offset sample offset in the frame
602  *@return decoded subframe length on success, < 0 in case of an error
603  */
605 {
606  int frame_len_shift = 0;
607  int subframe_len;
608 
609  /** no need to read from the bitstream when only one length is possible */
610  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
611  return s->min_samples_per_subframe;
612 
613  if (get_bits_left(&s->gb) < 1)
614  return AVERROR_INVALIDDATA;
615 
616  /** 1 bit indicates if the subframe is of maximum length */
617  if (s->max_subframe_len_bit) {
618  if (get_bits1(&s->gb))
619  frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
620  } else
621  frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
622 
623  subframe_len = s->samples_per_frame >> frame_len_shift;
624 
625  /** sanity check the length */
626  if (subframe_len < s->min_samples_per_subframe ||
627  subframe_len > s->samples_per_frame) {
628  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
629  subframe_len);
630  return AVERROR_INVALIDDATA;
631  }
632  return subframe_len;
633 }
634 
635 /**
636  *@brief Decode how the data in the frame is split into subframes.
637  * Every WMA frame contains the encoded data for a fixed number of
638  * samples per channel. The data for every channel might be split
639  * into several subframes. This function will reconstruct the list of
640  * subframes for every channel.
641  *
642  * If the subframes are not evenly split, the algorithm estimates the
643  * channels with the lowest number of total samples.
644  * Afterwards, for each of these channels a bit is read from the
645  * bitstream that indicates if the channel contains a subframe with the
646  * next subframe size that is going to be read from the bitstream or not.
647  * If a channel contains such a subframe, the subframe size gets added to
648  * the channel's subframe list.
649  * The algorithm repeats these steps until the frame is properly divided
650  * between the individual channels.
651  *
652  *@param s context
653  *@return 0 on success, < 0 in case of an error
654  */
656 {
657  uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
658  uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
659  int channels_for_cur_subframe = s->nb_channels; /**< number of channels that contain the current subframe */
660  int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
661  int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
662  int c;
663 
664  /* Should never consume more than 3073 bits (256 iterations for the
665  * while loop when always the minimum amount of 128 samples is subtracted
666  * from missing samples in the 8 channel case).
667  * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
668  */
669 
670  /** reset tiling information */
671  for (c = 0; c < s->nb_channels; c++)
672  s->channel[c].num_subframes = 0;
673 
674  if (s->max_num_subframes == 1 || get_bits1(&s->gb))
675  fixed_channel_layout = 1;
676 
677  /** loop until the frame data is split between the subframes */
678  do {
679  int subframe_len;
680 
681  /** check which channels contain the subframe */
682  for (c = 0; c < s->nb_channels; c++) {
683  if (num_samples[c] == min_channel_len) {
684  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
685  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
686  contains_subframe[c] = 1;
687  else
688  contains_subframe[c] = get_bits1(&s->gb);
689  } else
690  contains_subframe[c] = 0;
691  }
692 
693  /** get subframe length, subframe_len == 0 is not allowed */
694  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
695  return AVERROR_INVALIDDATA;
696 
697  /** add subframes to the individual channels and find new min_channel_len */
698  min_channel_len += subframe_len;
699  for (c = 0; c < s->nb_channels; c++) {
700  WMAProChannelCtx* chan = &s->channel[c];
701 
702  if (contains_subframe[c]) {
703  if (chan->num_subframes >= MAX_SUBFRAMES) {
704  av_log(s->avctx, AV_LOG_ERROR,
705  "broken frame: num subframes > 31\n");
706  return AVERROR_INVALIDDATA;
707  }
708  chan->subframe_len[chan->num_subframes] = subframe_len;
709  num_samples[c] += subframe_len;
710  ++chan->num_subframes;
711  if (num_samples[c] > s->samples_per_frame) {
712  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
713  "channel len > samples_per_frame\n");
714  return AVERROR_INVALIDDATA;
715  }
716  } else if (num_samples[c] <= min_channel_len) {
717  if (num_samples[c] < min_channel_len) {
718  channels_for_cur_subframe = 0;
719  min_channel_len = num_samples[c];
720  }
721  ++channels_for_cur_subframe;
722  }
723  }
724  } while (min_channel_len < s->samples_per_frame);
725 
726  for (c = 0; c < s->nb_channels; c++) {
727  int i;
728  int offset = 0;
729  for (i = 0; i < s->channel[c].num_subframes; i++) {
730  ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]"
731  " len %i\n", s->frame_num, c, i,
732  s->channel[c].subframe_len[i]);
733  s->channel[c].subframe_offset[i] = offset;
734  offset += s->channel[c].subframe_len[i];
735  }
736  }
737 
738  return 0;
739 }
740 
741 /**
742  *@brief Calculate a decorrelation matrix from the bitstream parameters.
743  *@param s codec context
744  *@param chgroup channel group for which the matrix needs to be calculated
745  */
747  WMAProChannelGrp *chgroup)
748 {
749  int i;
750  int offset = 0;
751  int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
752  memset(chgroup->decorrelation_matrix, 0, s->nb_channels *
753  s->nb_channels * sizeof(*chgroup->decorrelation_matrix));
754 
755  for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
756  rotation_offset[i] = get_bits(&s->gb, 6);
757 
758  for (i = 0; i < chgroup->num_channels; i++)
759  chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
760  get_bits1(&s->gb) ? 1.0 : -1.0;
761 
762  for (i = 1; i < chgroup->num_channels; i++) {
763  int x;
764  for (x = 0; x < i; x++) {
765  int y;
766  for (y = 0; y < i + 1; y++) {
767  float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
768  float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
769  int n = rotation_offset[offset + x];
770  float sinv;
771  float cosv;
772 
773  if (n < 32) {
774  sinv = sin64[n];
775  cosv = sin64[32 - n];
776  } else {
777  sinv = sin64[64 - n];
778  cosv = -sin64[n - 32];
779  }
780 
781  chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
782  (v1 * sinv) - (v2 * cosv);
783  chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
784  (v1 * cosv) + (v2 * sinv);
785  }
786  }
787  offset += i;
788  }
789 }
790 
791 /**
792  *@brief Decode channel transformation parameters
793  *@param s codec context
794  *@return >= 0 in case of success, < 0 in case of bitstream errors
795  */
797 {
798  int i;
799  /* should never consume more than 1921 bits for the 8 channel case
800  * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
801  * + MAX_CHANNELS + MAX_BANDS + 1)
802  */
803 
804  /** in the one channel case channel transforms are pointless */
805  s->num_chgroups = 0;
806  if (s->nb_channels > 1) {
807  int remaining_channels = s->channels_for_cur_subframe;
808 
809  if (get_bits1(&s->gb)) {
810  avpriv_request_sample(s->avctx,
811  "Channel transform bit");
812  return AVERROR_PATCHWELCOME;
813  }
814 
815  for (s->num_chgroups = 0; remaining_channels &&
816  s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
817  WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
818  float** channel_data = chgroup->channel_data;
819  chgroup->num_channels = 0;
820  chgroup->transform = 0;
821 
822  /** decode channel mask */
823  if (remaining_channels > 2) {
824  for (i = 0; i < s->channels_for_cur_subframe; i++) {
825  int channel_idx = s->channel_indexes_for_cur_subframe[i];
826  if (!s->channel[channel_idx].grouped
827  && get_bits1(&s->gb)) {
828  ++chgroup->num_channels;
829  s->channel[channel_idx].grouped = 1;
830  *channel_data++ = s->channel[channel_idx].coeffs;
831  }
832  }
833  } else {
834  chgroup->num_channels = remaining_channels;
835  for (i = 0; i < s->channels_for_cur_subframe; i++) {
836  int channel_idx = s->channel_indexes_for_cur_subframe[i];
837  if (!s->channel[channel_idx].grouped)
838  *channel_data++ = s->channel[channel_idx].coeffs;
839  s->channel[channel_idx].grouped = 1;
840  }
841  }
842 
843  /** decode transform type */
844  if (chgroup->num_channels == 2) {
845  if (get_bits1(&s->gb)) {
846  if (get_bits1(&s->gb)) {
847  avpriv_request_sample(s->avctx,
848  "Unknown channel transform type");
849  return AVERROR_PATCHWELCOME;
850  }
851  } else {
852  chgroup->transform = 1;
853  if (s->nb_channels == 2) {
854  chgroup->decorrelation_matrix[0] = 1.0;
855  chgroup->decorrelation_matrix[1] = -1.0;
856  chgroup->decorrelation_matrix[2] = 1.0;
857  chgroup->decorrelation_matrix[3] = 1.0;
858  } else {
859  /** cos(pi/4) */
860  chgroup->decorrelation_matrix[0] = 0.70703125;
861  chgroup->decorrelation_matrix[1] = -0.70703125;
862  chgroup->decorrelation_matrix[2] = 0.70703125;
863  chgroup->decorrelation_matrix[3] = 0.70703125;
864  }
865  }
866  } else if (chgroup->num_channels > 2) {
867  if (get_bits1(&s->gb)) {
868  chgroup->transform = 1;
869  if (get_bits1(&s->gb)) {
870  decode_decorrelation_matrix(s, chgroup);
871  } else {
872  /** FIXME: more than 6 coupled channels not supported */
873  if (chgroup->num_channels > 6) {
874  avpriv_request_sample(s->avctx,
875  "Coupled channels > 6");
876  } else {
877  memcpy(chgroup->decorrelation_matrix,
879  chgroup->num_channels * chgroup->num_channels *
880  sizeof(*chgroup->decorrelation_matrix));
881  }
882  }
883  }
884  }
885 
886  /** decode transform on / off */
887  if (chgroup->transform) {
888  if (!get_bits1(&s->gb)) {
889  int i;
890  /** transform can be enabled for individual bands */
891  for (i = 0; i < s->num_bands; i++) {
892  chgroup->transform_band[i] = get_bits1(&s->gb);
893  }
894  } else {
895  memset(chgroup->transform_band, 1, s->num_bands);
896  }
897  }
898  remaining_channels -= chgroup->num_channels;
899  }
900  }
901  return 0;
902 }
903 
904 /**
905  *@brief Extract the coefficients from the bitstream.
906  *@param s codec context
907  *@param c current channel number
908  *@return 0 on success, < 0 in case of bitstream errors
909  */
910 static int decode_coeffs(WMAProDecodeCtx *s, int c)
911 {
912  /* Integers 0..15 as single-precision floats. The table saves a
913  costly int to float conversion, and storing the values as
914  integers allows fast sign-flipping. */
915  static const uint32_t fval_tab[16] = {
916  0x00000000, 0x3f800000, 0x40000000, 0x40400000,
917  0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
918  0x41000000, 0x41100000, 0x41200000, 0x41300000,
919  0x41400000, 0x41500000, 0x41600000, 0x41700000,
920  };
921  int vlctable;
922  VLC* vlc;
923  WMAProChannelCtx* ci = &s->channel[c];
924  int rl_mode = 0;
925  int cur_coeff = 0;
926  int num_zeros = 0;
927  const uint16_t* run;
928  const float* level;
929 
930  ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
931 
932  vlctable = get_bits1(&s->gb);
933  vlc = &coef_vlc[vlctable];
934 
935  if (vlctable) {
936  run = coef1_run;
937  level = coef1_level;
938  } else {
939  run = coef0_run;
940  level = coef0_level;
941  }
942 
943  /** decode vector coefficients (consumes up to 167 bits per iteration for
944  4 vector coded large values) */
945  while ((s->transmit_num_vec_coeffs || !rl_mode) &&
946  (cur_coeff + 3 < ci->num_vec_coeffs)) {
947  uint32_t vals[4];
948  int i;
949  unsigned int idx;
950 
951  idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
952 
953  if (idx == HUFF_VEC4_SIZE - 1) {
954  for (i = 0; i < 4; i += 2) {
955  idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
956  if (idx == HUFF_VEC2_SIZE - 1) {
957  uint32_t v0, v1;
959  if (v0 == HUFF_VEC1_SIZE - 1)
960  v0 += ff_wma_get_large_val(&s->gb);
962  if (v1 == HUFF_VEC1_SIZE - 1)
963  v1 += ff_wma_get_large_val(&s->gb);
964  vals[i ] = av_float2int(v0);
965  vals[i+1] = av_float2int(v1);
966  } else {
967  vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
968  vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
969  }
970  }
971  } else {
972  vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
973  vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
974  vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
975  vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
976  }
977 
978  /** decode sign */
979  for (i = 0; i < 4; i++) {
980  if (vals[i]) {
981  uint32_t sign = get_bits1(&s->gb) - 1;
982  AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
983  num_zeros = 0;
984  } else {
985  ci->coeffs[cur_coeff] = 0;
986  /** switch to run level mode when subframe_len / 128 zeros
987  were found in a row */
988  rl_mode |= (++num_zeros > s->subframe_len >> 8);
989  }
990  ++cur_coeff;
991  }
992  }
993 
994  /** decode run level coded coefficients */
995  if (cur_coeff < s->subframe_len) {
996  int ret;
997 
998  memset(&ci->coeffs[cur_coeff], 0,
999  sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
1000  ret = ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
1001  level, run, 1, ci->coeffs,
1002  cur_coeff, s->subframe_len,
1003  s->subframe_len, s->esc_len, 0);
1004  if (ret < 0)
1005  return ret;
1006  }
1007 
1008  return 0;
1009 }
1010 
1011 /**
1012  *@brief Extract scale factors from the bitstream.
1013  *@param s codec context
1014  *@return 0 on success, < 0 in case of bitstream errors
1015  */
1017 {
1018  int i;
1019 
1020  /** should never consume more than 5344 bits
1021  * MAX_CHANNELS * (1 + MAX_BANDS * 23)
1022  */
1023 
1024  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1025  int c = s->channel_indexes_for_cur_subframe[i];
1026  int* sf;
1027  int* sf_end;
1028  s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
1029  sf_end = s->channel[c].scale_factors + s->num_bands;
1030 
1031  /** resample scale factors for the new block size
1032  * as the scale factors might need to be resampled several times
1033  * before some new values are transmitted, a backup of the last
1034  * transmitted scale factors is kept in saved_scale_factors
1035  */
1036  if (s->channel[c].reuse_sf) {
1037  const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
1038  int b;
1039  for (b = 0; b < s->num_bands; b++)
1040  s->channel[c].scale_factors[b] =
1041  s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
1042  }
1043 
1044  if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
1045 
1046  if (!s->channel[c].reuse_sf) {
1047  int val;
1048  /** decode DPCM coded scale factors */
1049  s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1050  val = 45 / s->channel[c].scale_factor_step;
1051  for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1052  val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1053  *sf = val;
1054  }
1055  } else {
1056  int i;
1057  /** run level decode differences to the resampled factors */
1058  for (i = 0; i < s->num_bands; i++) {
1059  int idx;
1060  int skip;
1061  int val;
1062  int sign;
1063 
1065 
1066  if (!idx) {
1067  uint32_t code = get_bits(&s->gb, 14);
1068  val = code >> 6;
1069  sign = (code & 1) - 1;
1070  skip = (code & 0x3f) >> 1;
1071  } else if (idx == 1) {
1072  break;
1073  } else {
1074  skip = scale_rl_run[idx];
1075  val = scale_rl_level[idx];
1076  sign = get_bits1(&s->gb)-1;
1077  }
1078 
1079  i += skip;
1080  if (i >= s->num_bands) {
1081  av_log(s->avctx, AV_LOG_ERROR,
1082  "invalid scale factor coding\n");
1083  return AVERROR_INVALIDDATA;
1084  }
1085  s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1086  }
1087  }
1088  /** swap buffers */
1089  s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1090  s->channel[c].table_idx = s->table_idx;
1091  s->channel[c].reuse_sf = 1;
1092  }
1093 
1094  /** calculate new scale factor maximum */
1095  s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1096  for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1097  s->channel[c].max_scale_factor =
1098  FFMAX(s->channel[c].max_scale_factor, *sf);
1099  }
1100 
1101  }
1102  return 0;
1103 }
1104 
1105 /**
1106  *@brief Reconstruct the individual channel data.
1107  *@param s codec context
1108  */
1110 {
1111  int i;
1112 
1113  for (i = 0; i < s->num_chgroups; i++) {
1114  if (s->chgroup[i].transform) {
1115  float data[WMAPRO_MAX_CHANNELS];
1116  const int num_channels = s->chgroup[i].num_channels;
1117  float** ch_data = s->chgroup[i].channel_data;
1118  float** ch_end = ch_data + num_channels;
1119  const int8_t* tb = s->chgroup[i].transform_band;
1120  int16_t* sfb;
1121 
1122  /** multichannel decorrelation */
1123  for (sfb = s->cur_sfb_offsets;
1124  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1125  int y;
1126  if (*tb++ == 1) {
1127  /** multiply values with the decorrelation_matrix */
1128  for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1129  const float* mat = s->chgroup[i].decorrelation_matrix;
1130  const float* data_end = data + num_channels;
1131  float* data_ptr = data;
1132  float** ch;
1133 
1134  for (ch = ch_data; ch < ch_end; ch++)
1135  *data_ptr++ = (*ch)[y];
1136 
1137  for (ch = ch_data; ch < ch_end; ch++) {
1138  float sum = 0;
1139  data_ptr = data;
1140  while (data_ptr < data_end)
1141  sum += *data_ptr++ * *mat++;
1142 
1143  (*ch)[y] = sum;
1144  }
1145  }
1146  } else if (s->nb_channels == 2) {
1147  int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1148  s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1149  ch_data[0] + sfb[0],
1150  181.0 / 128, len);
1151  s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1152  ch_data[1] + sfb[0],
1153  181.0 / 128, len);
1154  }
1155  }
1156  }
1157  }
1158 }
1159 
1160 /**
1161  *@brief Apply sine window and reconstruct the output buffer.
1162  *@param s codec context
1163  */
1165 {
1166  int i;
1167  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1168  int c = s->channel_indexes_for_cur_subframe[i];
1169  const float* window;
1170  int winlen = s->channel[c].prev_block_len;
1171  float* start = s->channel[c].coeffs - (winlen >> 1);
1172 
1173  if (s->subframe_len < winlen) {
1174  start += (winlen - s->subframe_len) >> 1;
1175  winlen = s->subframe_len;
1176  }
1177 
1178  window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1179 
1180  winlen >>= 1;
1181 
1182  s->fdsp->vector_fmul_window(start, start, start + winlen,
1183  window, winlen);
1184 
1185  s->channel[c].prev_block_len = s->subframe_len;
1186  }
1187 }
1188 
1189 /**
1190  *@brief Decode a single subframe (block).
1191  *@param s codec context
1192  *@return 0 on success, < 0 when decoding failed
1193  */
1195 {
1196  int offset = s->samples_per_frame;
1197  int subframe_len = s->samples_per_frame;
1198  int i;
1199  int total_samples = s->samples_per_frame * s->nb_channels;
1200  int transmit_coeffs = 0;
1201  int cur_subwoofer_cutoff;
1202 
1203  s->subframe_offset = get_bits_count(&s->gb);
1204 
1205  /** reset channel context and find the next block offset and size
1206  == the next block of the channel with the smallest number of
1207  decoded samples
1208  */
1209  for (i = 0; i < s->nb_channels; i++) {
1210  s->channel[i].grouped = 0;
1211  if (offset > s->channel[i].decoded_samples) {
1212  offset = s->channel[i].decoded_samples;
1213  subframe_len =
1214  s->channel[i].subframe_len[s->channel[i].cur_subframe];
1215  }
1216  }
1217 
1218  ff_dlog(s->avctx,
1219  "processing subframe with offset %i len %i\n", offset, subframe_len);
1220 
1221  /** get a list of all channels that contain the estimated block */
1222  s->channels_for_cur_subframe = 0;
1223  for (i = 0; i < s->nb_channels; i++) {
1224  const int cur_subframe = s->channel[i].cur_subframe;
1225  /** subtract already processed samples */
1226  total_samples -= s->channel[i].decoded_samples;
1227 
1228  /** and count if there are multiple subframes that match our profile */
1229  if (offset == s->channel[i].decoded_samples &&
1230  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1231  total_samples -= s->channel[i].subframe_len[cur_subframe];
1232  s->channel[i].decoded_samples +=
1233  s->channel[i].subframe_len[cur_subframe];
1234  s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1235  ++s->channels_for_cur_subframe;
1236  }
1237  }
1238 
1239  /** check if the frame will be complete after processing the
1240  estimated block */
1241  if (!total_samples)
1242  s->parsed_all_subframes = 1;
1243 
1244 
1245  ff_dlog(s->avctx, "subframe is part of %i channels\n",
1246  s->channels_for_cur_subframe);
1247 
1248  /** calculate number of scale factor bands and their offsets */
1249  s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1250  s->num_bands = s->num_sfb[s->table_idx];
1251  s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1252  cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1253 
1254  /** configure the decoder for the current subframe */
1255  offset += s->samples_per_frame >> 1;
1256 
1257  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1258  int c = s->channel_indexes_for_cur_subframe[i];
1259 
1260  s->channel[c].coeffs = &s->channel[c].out[offset];
1261  }
1262 
1263  s->subframe_len = subframe_len;
1264  s->esc_len = av_log2(s->subframe_len - 1) + 1;
1265 
1266  /** skip extended header if any */
1267  if (get_bits1(&s->gb)) {
1268  int num_fill_bits;
1269  if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1270  int len = get_bits(&s->gb, 4);
1271  num_fill_bits = get_bitsz(&s->gb, len) + 1;
1272  }
1273 
1274  if (num_fill_bits >= 0) {
1275  if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1276  av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1277  return AVERROR_INVALIDDATA;
1278  }
1279 
1280  skip_bits_long(&s->gb, num_fill_bits);
1281  }
1282  }
1283 
1284  /** no idea for what the following bit is used */
1285  if (get_bits1(&s->gb)) {
1286  avpriv_request_sample(s->avctx, "Reserved bit");
1287  return AVERROR_PATCHWELCOME;
1288  }
1289 
1290 
1291  if (decode_channel_transform(s) < 0)
1292  return AVERROR_INVALIDDATA;
1293 
1294 
1295  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1296  int c = s->channel_indexes_for_cur_subframe[i];
1297  if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1298  transmit_coeffs = 1;
1299  }
1300 
1301  av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1302  if (transmit_coeffs) {
1303  int step;
1304  int quant_step = 90 * s->bits_per_sample >> 4;
1305 
1306  /** decode number of vector coded coefficients */
1307  if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1308  int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1309  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1310  int c = s->channel_indexes_for_cur_subframe[i];
1311  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1312  if (num_vec_coeffs > s->subframe_len) {
1313  av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1314  return AVERROR_INVALIDDATA;
1315  }
1316  av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1317  s->channel[c].num_vec_coeffs = num_vec_coeffs;
1318  }
1319  } else {
1320  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1321  int c = s->channel_indexes_for_cur_subframe[i];
1322  s->channel[c].num_vec_coeffs = s->subframe_len;
1323  }
1324  }
1325  /** decode quantization step */
1326  step = get_sbits(&s->gb, 6);
1327  quant_step += step;
1328  if (step == -32 || step == 31) {
1329  const int sign = (step == 31) - 1;
1330  int quant = 0;
1331  while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1332  (step = get_bits(&s->gb, 5)) == 31) {
1333  quant += 31;
1334  }
1335  quant_step += ((quant + step) ^ sign) - sign;
1336  }
1337  if (quant_step < 0) {
1338  av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1339  }
1340 
1341  /** decode quantization step modifiers for every channel */
1342 
1343  if (s->channels_for_cur_subframe == 1) {
1344  s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1345  } else {
1346  int modifier_len = get_bits(&s->gb, 3);
1347  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1348  int c = s->channel_indexes_for_cur_subframe[i];
1349  s->channel[c].quant_step = quant_step;
1350  if (get_bits1(&s->gb)) {
1351  if (modifier_len) {
1352  s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1353  } else
1354  ++s->channel[c].quant_step;
1355  }
1356  }
1357  }
1358 
1359  /** decode scale factors */
1360  if (decode_scale_factors(s) < 0)
1361  return AVERROR_INVALIDDATA;
1362  }
1363 
1364  ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1365  get_bits_count(&s->gb) - s->subframe_offset);
1366 
1367  /** parse coefficients */
1368  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1369  int c = s->channel_indexes_for_cur_subframe[i];
1370  if (s->channel[c].transmit_coefs &&
1371  get_bits_count(&s->gb) < s->num_saved_bits) {
1372  decode_coeffs(s, c);
1373  } else
1374  memset(s->channel[c].coeffs, 0,
1375  sizeof(*s->channel[c].coeffs) * subframe_len);
1376  }
1377 
1378  ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1379  get_bits_count(&s->gb) - s->subframe_offset);
1380 
1381  if (transmit_coeffs) {
1382  FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1383  /** reconstruct the per channel data */
1385  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1386  int c = s->channel_indexes_for_cur_subframe[i];
1387  const int* sf = s->channel[c].scale_factors;
1388  int b;
1389 
1390  if (c == s->lfe_channel)
1391  memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1392  (subframe_len - cur_subwoofer_cutoff));
1393 
1394  /** inverse quantization and rescaling */
1395  for (b = 0; b < s->num_bands; b++) {
1396  const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1397  const int exp = s->channel[c].quant_step -
1398  (s->channel[c].max_scale_factor - *sf++) *
1399  s->channel[c].scale_factor_step;
1400  const float quant = ff_exp10(exp / 20.0);
1401  int start = s->cur_sfb_offsets[b];
1402  s->fdsp->vector_fmul_scalar(s->tmp + start,
1403  s->channel[c].coeffs + start,
1404  quant, end - start);
1405  }
1406 
1407  /** apply imdct (imdct_half == DCTIV with reverse) */
1408  mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1409  }
1410  }
1411 
1412  /** window and overlapp-add */
1413  wmapro_window(s);
1414 
1415  /** handled one subframe */
1416  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1417  int c = s->channel_indexes_for_cur_subframe[i];
1418  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1419  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1420  return AVERROR_INVALIDDATA;
1421  }
1422  ++s->channel[c].cur_subframe;
1423  }
1424 
1425  return 0;
1426 }
1427 
1428 /**
1429  *@brief Decode one WMA frame.
1430  *@param s codec context
1431  *@return 0 if the trailer bit indicates that this is the last frame,
1432  * 1 if there are additional frames
1433  */
1434 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1435 {
1436  GetBitContext* gb = &s->gb;
1437  int more_frames = 0;
1438  int len = 0;
1439  int i;
1440 
1441  /** get frame length */
1442  if (s->len_prefix)
1443  len = get_bits(gb, s->log2_frame_size);
1444 
1445  ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1446 
1447  /** decode tile information */
1448  if (decode_tilehdr(s)) {
1449  s->packet_loss = 1;
1450  return 0;
1451  }
1452 
1453  /** read postproc transform */
1454  if (s->nb_channels > 1 && get_bits1(gb)) {
1455  if (get_bits1(gb)) {
1456  for (i = 0; i < s->nb_channels * s->nb_channels; i++)
1457  skip_bits(gb, 4);
1458  }
1459  }
1460 
1461  /** read drc info */
1462  if (s->dynamic_range_compression) {
1463  s->drc_gain = get_bits(gb, 8);
1464  ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1465  }
1466 
1467  if (get_bits1(gb)) {
1468  if (get_bits1(gb))
1469  s->trim_start = get_bits(gb, av_log2(s->samples_per_frame * 2));
1470 
1471  if (get_bits1(gb))
1472  s->trim_end = get_bits(gb, av_log2(s->samples_per_frame * 2));
1473  } else {
1474  s->trim_start = s->trim_end = 0;
1475  }
1476 
1477  ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1478  get_bits_count(gb) - s->frame_offset);
1479 
1480  /** reset subframe states */
1481  s->parsed_all_subframes = 0;
1482  for (i = 0; i < s->nb_channels; i++) {
1483  s->channel[i].decoded_samples = 0;
1484  s->channel[i].cur_subframe = 0;
1485  s->channel[i].reuse_sf = 0;
1486  }
1487 
1488  /** decode all subframes */
1489  while (!s->parsed_all_subframes) {
1490  if (decode_subframe(s) < 0) {
1491  s->packet_loss = 1;
1492  return 0;
1493  }
1494  }
1495 
1496  /** copy samples to the output buffer */
1497  for (i = 0; i < s->nb_channels; i++)
1498  memcpy(frame->extended_data[i], s->channel[i].out,
1499  s->samples_per_frame * sizeof(*s->channel[i].out));
1500 
1501  for (i = 0; i < s->nb_channels; i++) {
1502  /** reuse second half of the IMDCT output for the next frame */
1503  memcpy(&s->channel[i].out[0],
1504  &s->channel[i].out[s->samples_per_frame],
1505  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1506  }
1507 
1508  if (s->skip_frame) {
1509  s->skip_frame = 0;
1510  *got_frame_ptr = 0;
1512  } else {
1513  *got_frame_ptr = 1;
1514  }
1515 
1516  if (s->len_prefix) {
1517  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1518  /** FIXME: not sure if this is always an error */
1519  av_log(s->avctx, AV_LOG_ERROR,
1520  "frame[%"PRIu32"] would have to skip %i bits\n",
1521  s->frame_num,
1522  len - (get_bits_count(gb) - s->frame_offset) - 1);
1523  s->packet_loss = 1;
1524  return 0;
1525  }
1526 
1527  /** skip the rest of the frame data */
1528  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1529  } else {
1530  while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1531  }
1532  }
1533 
1534  /** decode trailer bit */
1535  more_frames = get_bits1(gb);
1536 
1537  ++s->frame_num;
1538  return more_frames;
1539 }
1540 
1541 /**
1542  *@brief Calculate remaining input buffer length.
1543  *@param s codec context
1544  *@param gb bitstream reader context
1545  *@return remaining size in bits
1546  */
1548 {
1549  return s->buf_bit_size - get_bits_count(gb);
1550 }
1551 
1552 /**
1553  *@brief Fill the bit reservoir with a (partial) frame.
1554  *@param s codec context
1555  *@param gb bitstream reader context
1556  *@param len length of the partial frame
1557  *@param append decides whether to reset the buffer or not
1558  */
1560  int append)
1561 {
1562  int buflen;
1563 
1564  /** when the frame data does not need to be concatenated, the input buffer
1565  is reset and additional bits from the previous frame are copied
1566  and skipped later so that a fast byte copy is possible */
1567 
1568  if (!append) {
1569  s->frame_offset = get_bits_count(gb) & 7;
1570  s->num_saved_bits = s->frame_offset;
1571  init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1572  buflen = (s->num_saved_bits + len + 7) >> 3;
1573  } else
1574  buflen = (put_bits_count(&s->pb) + len + 7) >> 3;
1575 
1576  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1577  avpriv_request_sample(s->avctx, "Too small input buffer");
1578  s->packet_loss = 1;
1579  return;
1580  }
1581 
1582  av_assert0(len <= put_bits_left(&s->pb));
1583 
1584  s->num_saved_bits += len;
1585  if (!append) {
1586  ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1587  s->num_saved_bits);
1588  } else {
1589  int align = 8 - (get_bits_count(gb) & 7);
1590  align = FFMIN(align, len);
1591  put_bits(&s->pb, align, get_bits(gb, align));
1592  len -= align;
1593  ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1594  }
1595  skip_bits_long(gb, len);
1596 
1597  {
1598  PutBitContext tmp = s->pb;
1599  flush_put_bits(&tmp);
1600  }
1601 
1602  init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1603  skip_bits(&s->gb, s->frame_offset);
1604 }
1605 
1607  void *data, int *got_frame_ptr, AVPacket *avpkt)
1608 {
1609  GetBitContext* gb = &s->pgb;
1610  const uint8_t* buf = avpkt->data;
1611  int buf_size = avpkt->size;
1612  int num_bits_prev_frame;
1613  int packet_sequence_number;
1614  int ret;
1615 
1616  *got_frame_ptr = 0;
1617 
1618  if (!buf_size) {
1619  AVFrame *frame = data;
1620  int i;
1621 
1622  /** Must output remaining samples after stream end. WMAPRO 5.1 created
1623  * by XWMA encoder don't though (maybe only 1/2ch streams need it). */
1624  s->packet_done = 0;
1625  if (s->eof_done)
1626  return 0;
1627 
1628  /** clean output buffer and copy last IMDCT samples */
1629  for (i = 0; i < s->nb_channels; i++) {
1630  memset(frame->extended_data[i], 0,
1631  s->samples_per_frame * sizeof(*s->channel[i].out));
1632 
1633  memcpy(frame->extended_data[i], s->channel[i].out,
1634  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1635  }
1636 
1637  s->eof_done = 1;
1638  s->packet_done = 1;
1639  *got_frame_ptr = 1;
1640  return 0;
1641  }
1642  else if (s->packet_done || s->packet_loss) {
1643  s->packet_done = 0;
1644 
1645  /** sanity check for the buffer length */
1646  if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1647  av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1648  buf_size, avctx->block_align);
1649  s->packet_loss = 1;
1650  return AVERROR_INVALIDDATA;
1651  }
1652 
1653  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1654  s->next_packet_start = buf_size - avctx->block_align;
1655  buf_size = avctx->block_align;
1656  } else {
1657  s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1658  buf_size = FFMIN(buf_size, avctx->block_align);
1659  }
1660  s->buf_bit_size = buf_size << 3;
1661 
1662  /** parse packet header */
1663  ret = init_get_bits8(gb, buf, buf_size);
1664  if (ret < 0)
1665  return ret;
1666  if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1667  packet_sequence_number = get_bits(gb, 4);
1668  skip_bits(gb, 2);
1669  } else {
1670  int num_frames = get_bits(gb, 6);
1671  ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames);
1672  packet_sequence_number = 0;
1673  }
1674 
1675  /** get number of bits that need to be added to the previous frame */
1676  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1677  if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1678  skip_bits(gb, 3);
1679  s->skip_packets = get_bits(gb, 8);
1680  ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets);
1681  }
1682 
1683  ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1684  num_bits_prev_frame);
1685 
1686  /** check for packet loss */
1687  if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss &&
1688  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1689  s->packet_loss = 1;
1690  av_log(avctx, AV_LOG_ERROR,
1691  "Packet loss detected! seq %"PRIx8" vs %x\n",
1692  s->packet_sequence_number, packet_sequence_number);
1693  }
1694  s->packet_sequence_number = packet_sequence_number;
1695 
1696  if (num_bits_prev_frame > 0) {
1697  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1698  if (num_bits_prev_frame >= remaining_packet_bits) {
1699  num_bits_prev_frame = remaining_packet_bits;
1700  s->packet_done = 1;
1701  }
1702 
1703  /** append the previous frame data to the remaining data from the
1704  previous packet to create a full frame */
1705  save_bits(s, gb, num_bits_prev_frame, 1);
1706  ff_dlog(avctx, "accumulated %x bits of frame data\n",
1707  s->num_saved_bits - s->frame_offset);
1708 
1709  /** decode the cross packet frame if it is valid */
1710  if (!s->packet_loss)
1711  decode_frame(s, data, got_frame_ptr);
1712  } else if (s->num_saved_bits - s->frame_offset) {
1713  ff_dlog(avctx, "ignoring %x previously saved bits\n",
1714  s->num_saved_bits - s->frame_offset);
1715  }
1716 
1717  if (s->packet_loss) {
1718  /** reset number of saved bits so that the decoder
1719  does not start to decode incomplete frames in the
1720  s->len_prefix == 0 case */
1721  s->num_saved_bits = 0;
1722  s->packet_loss = 0;
1723  }
1724  } else {
1725  int frame_size;
1726 
1727  if (avpkt->size < s->next_packet_start) {
1728  s->packet_loss = 1;
1729  return AVERROR_INVALIDDATA;
1730  }
1731 
1732  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1733  ret = init_get_bits8(gb, avpkt->data, avpkt->size - s->next_packet_start);
1734  if (ret < 0)
1735  return ret;
1736  skip_bits(gb, s->packet_offset);
1737  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1738  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1739  frame_size <= remaining_bits(s, gb)) {
1740  save_bits(s, gb, frame_size, 0);
1741  if (!s->packet_loss)
1742  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1743  } else if (!s->len_prefix
1744  && s->num_saved_bits > get_bits_count(&s->gb)) {
1745  /** when the frames do not have a length prefix, we don't know
1746  the compressed length of the individual frames
1747  however, we know what part of a new packet belongs to the
1748  previous frame
1749  therefore we save the incoming packet first, then we append
1750  the "previous frame" data from the next packet so that
1751  we get a buffer that only contains full frames */
1752  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1753  } else {
1754  s->packet_done = 1;
1755  }
1756  }
1757 
1758  if (remaining_bits(s, gb) < 0) {
1759  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1760  s->packet_loss = 1;
1761  }
1762 
1763  if (s->packet_done && !s->packet_loss &&
1764  remaining_bits(s, gb) > 0) {
1765  /** save the rest of the data so that it can be decoded
1766  with the next packet */
1767  save_bits(s, gb, remaining_bits(s, gb), 0);
1768  }
1769 
1770  s->packet_offset = get_bits_count(gb) & 7;
1771  if (s->packet_loss)
1772  return AVERROR_INVALIDDATA;
1773 
1774  if (s->trim_start && avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1775  AVFrame *frame = data;
1776 
1777  if (s->trim_start < frame->nb_samples) {
1778  for (int ch = 0; ch < frame->channels; ch++)
1779  frame->extended_data[ch] += s->trim_start * 4;
1780 
1781  frame->nb_samples -= s->trim_start;
1782  } else {
1783  *got_frame_ptr = 0;
1784  }
1785 
1786  s->trim_start = 0;
1787  }
1788 
1789  if (s->trim_end && avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1790  AVFrame *frame = data;
1791 
1792  if (s->trim_end < frame->nb_samples) {
1793  frame->nb_samples -= s->trim_end;
1794  } else {
1795  *got_frame_ptr = 0;
1796  }
1797 
1798  s->trim_end = 0;
1799  }
1800 
1801  return get_bits_count(gb) >> 3;
1802 }
1803 
1804 /**
1805  *@brief Decode a single WMA packet.
1806  *@param avctx codec context
1807  *@param data the output buffer
1808  *@param avpkt input packet
1809  *@return number of bytes that were read from the input buffer
1810  */
1811 static int wmapro_decode_packet(AVCodecContext *avctx, void *data,
1812  int *got_frame_ptr, AVPacket *avpkt)
1813 {
1814  WMAProDecodeCtx *s = avctx->priv_data;
1815  AVFrame *frame = data;
1816  int ret;
1817 
1818  /* get output buffer */
1819  frame->nb_samples = s->samples_per_frame;
1820  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1821  s->packet_loss = 1;
1822  return 0;
1823  }
1824 
1825  return decode_packet(avctx, s, data, got_frame_ptr, avpkt);
1826 }
1827 
1828 static int xma_decode_packet(AVCodecContext *avctx, void *data,
1829  int *got_frame_ptr, AVPacket *avpkt)
1830 {
1831  XMADecodeCtx *s = avctx->priv_data;
1832  int got_stream_frame_ptr = 0;
1833  AVFrame *frame = data;
1834  int i, ret = 0, eof = 0;
1835 
1836  if (!s->frames[s->current_stream]->data[0]) {
1837  avctx->internal->skip_samples = 64;
1838  s->frames[s->current_stream]->nb_samples = 512;
1839  if ((ret = ff_get_buffer(avctx, s->frames[s->current_stream], 0)) < 0)
1840  return ret;
1841  } else if (s->frames[s->current_stream]->nb_samples != 512) {
1842  avctx->internal->skip_samples = 64;
1843  av_frame_unref(s->frames[s->current_stream]);
1844  s->frames[s->current_stream]->nb_samples = 512;
1845  if ((ret = ff_get_buffer(avctx, s->frames[s->current_stream], 0)) < 0)
1846  return ret;
1847  }
1848  /* decode current stream packet */
1849  if (!s->xma[s->current_stream].eof_done) {
1850  ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream],
1851  &got_stream_frame_ptr, avpkt);
1852  }
1853 
1854  if (!avpkt->size) {
1855  eof = 1;
1856 
1857  for (i = 0; i < s->num_streams; i++) {
1858  if (!s->xma[i].eof_done && s->frames[i]->data[0]) {
1859  ret = decode_packet(avctx, &s->xma[i], s->frames[i],
1860  &got_stream_frame_ptr, avpkt);
1861  }
1862 
1863  eof &= s->xma[i].eof_done;
1864  }
1865  }
1866 
1867  if (s->xma[0].trim_start)
1868  s->trim_start = s->xma[0].trim_start;
1869  if (s->xma[0].trim_end)
1870  s->trim_end = s->xma[0].trim_end;
1871 
1872  /* copy stream samples (1/2ch) to sample buffer (Nch) */
1873  if (got_stream_frame_ptr) {
1874  const int nb_samples = s->frames[s->current_stream]->nb_samples;
1875  void *left[1] = { s->frames[s->current_stream]->extended_data[0] };
1876  void *right[1] = { s->frames[s->current_stream]->extended_data[1] };
1877 
1878  av_audio_fifo_write(s->samples[0][s->current_stream], left, nb_samples);
1879  if (s->xma[s->current_stream].nb_channels > 1)
1880  av_audio_fifo_write(s->samples[1][s->current_stream], right, nb_samples);
1881  } else if (ret < 0) {
1882  s->current_stream = 0;
1883  return ret;
1884  }
1885 
1886  /* find next XMA packet's owner stream, and update.
1887  * XMA streams find their packets following packet_skips
1888  * (at start there is one packet per stream, then interleave non-linearly). */
1889  if (s->xma[s->current_stream].packet_done ||
1890  s->xma[s->current_stream].packet_loss) {
1891  int nb_samples = INT_MAX;
1892 
1893  /* select stream with 0 skip_packets (= uses next packet) */
1894  if (s->xma[s->current_stream].skip_packets != 0) {
1895  int min[2];
1896 
1897  min[0] = s->xma[0].skip_packets;
1898  min[1] = i = 0;
1899 
1900  for (i = 1; i < s->num_streams; i++) {
1901  if (s->xma[i].skip_packets < min[0]) {
1902  min[0] = s->xma[i].skip_packets;
1903  min[1] = i;
1904  }
1905  }
1906 
1907  s->current_stream = min[1];
1908  }
1909 
1910  /* all other streams skip next packet */
1911  for (i = 0; i < s->num_streams; i++) {
1912  s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1);
1913  nb_samples = FFMIN(nb_samples, av_audio_fifo_size(s->samples[0][i]));
1914  }
1915 
1916  if (!eof && avpkt->size)
1917  nb_samples -= FFMIN(nb_samples, 4096);
1918 
1919  /* copy samples from buffer to output if possible */
1920  if ((nb_samples > 0 || eof || !avpkt->size) && !s->flushed) {
1921  int bret;
1922 
1923  if (eof) {
1924  nb_samples -= av_clip(s->trim_end + s->trim_start - 128 - 64, 0, nb_samples);
1925  s->flushed = 1;
1926  }
1927 
1928  frame->nb_samples = nb_samples;
1929  if ((bret = ff_get_buffer(avctx, frame, 0)) < 0)
1930  return bret;
1931 
1932  for (i = 0; i < s->num_streams; i++) {
1933  const int start_ch = s->start_channel[i];
1934  void *left[1] = { frame->extended_data[start_ch + 0] };
1935 
1936  av_audio_fifo_read(s->samples[0][i], left, nb_samples);
1937  if (s->xma[i].nb_channels > 1) {
1938  void *right[1] = { frame->extended_data[start_ch + 1] };
1939  av_audio_fifo_read(s->samples[1][i], right, nb_samples);
1940  }
1941  }
1942 
1943  *got_frame_ptr = nb_samples > 0;
1944  }
1945  }
1946 
1947  return ret;
1948 }
1949 
1951 {
1952  XMADecodeCtx *s = avctx->priv_data;
1953  int i, ret, start_channels = 0;
1954 
1955  if (avctx->channels <= 0 || avctx->extradata_size == 0)
1956  return AVERROR_INVALIDDATA;
1957 
1958  /* get stream config */
1959  if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
1960  s->num_streams = AV_RL16(avctx->extradata);
1961  avctx->channel_layout = AV_RL32(avctx->extradata + 2);
1962  } else if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 2) { /* XMA2WAVEFORMAT */
1963  s->num_streams = avctx->extradata[1];
1964  if (avctx->extradata_size != (32 + ((avctx->extradata[0]==3)?0:8) + 4*s->num_streams)) {
1965  av_log(avctx, AV_LOG_ERROR, "Incorrect XMA2 extradata size\n");
1966  s->num_streams = 0;
1967  return AVERROR(EINVAL);
1968  }
1969  } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 4) { /* XMAWAVEFORMAT */
1970  s->num_streams = avctx->extradata[4];
1971  if (avctx->extradata_size != (8 + 20*s->num_streams)) {
1972  av_log(avctx, AV_LOG_ERROR, "Incorrect XMA1 extradata size\n");
1973  s->num_streams = 0;
1974  return AVERROR(EINVAL);
1975  }
1976  } else {
1977  av_log(avctx, AV_LOG_ERROR, "Incorrect XMA config\n");
1978  return AVERROR(EINVAL);
1979  }
1980 
1981  /* encoder supports up to 64 streams / 64*2 channels (would have to alloc arrays) */
1982  if (avctx->channels > XMA_MAX_CHANNELS || s->num_streams > XMA_MAX_STREAMS ||
1983  s->num_streams <= 0
1984  ) {
1985  avpriv_request_sample(avctx, "More than %d channels in %d streams", XMA_MAX_CHANNELS, s->num_streams);
1986  s->num_streams = 0;
1987  return AVERROR_PATCHWELCOME;
1988  }
1989 
1990  /* init all streams (several streams of 1/2ch make Nch files) */
1991  for (i = 0; i < s->num_streams; i++) {
1992  ret = decode_init(&s->xma[i], avctx, i);
1993  if (ret < 0)
1994  return ret;
1995  s->frames[i] = av_frame_alloc();
1996  if (!s->frames[i])
1997  return AVERROR(ENOMEM);
1998 
1999  s->start_channel[i] = start_channels;
2000  start_channels += s->xma[i].nb_channels;
2001  }
2002  if (start_channels != avctx->channels)
2003  return AVERROR_INVALIDDATA;
2004 
2005  for (int i = 0; i < XMA_MAX_STREAMS; i++) {
2006  s->samples[0][i] = av_audio_fifo_alloc(avctx->sample_fmt, 1, 64 * 512);
2007  s->samples[1][i] = av_audio_fifo_alloc(avctx->sample_fmt, 1, 64 * 512);
2008  if (!s->samples[0][i] || !s->samples[1][i])
2009  return AVERROR(ENOMEM);
2010  }
2011 
2012  return ret;
2013 }
2014 
2016 {
2017  XMADecodeCtx *s = avctx->priv_data;
2018  int i;
2019 
2020  for (i = 0; i < s->num_streams; i++) {
2021  decode_end(&s->xma[i]);
2022  av_frame_free(&s->frames[i]);
2023  }
2024  s->num_streams = 0;
2025 
2026  for (i = 0; i < XMA_MAX_STREAMS; i++) {
2027  av_audio_fifo_free(s->samples[0][i]);
2028  av_audio_fifo_free(s->samples[1][i]);
2029  }
2030 
2031  return 0;
2032 }
2033 
2034 static void flush(WMAProDecodeCtx *s)
2035 {
2036  int i;
2037  /** reset output buffer as a part of it is used during the windowing of a
2038  new frame */
2039  for (i = 0; i < s->nb_channels; i++)
2040  memset(s->channel[i].out, 0, s->samples_per_frame *
2041  sizeof(*s->channel[i].out));
2042  s->packet_loss = 1;
2043  s->skip_packets = 0;
2044  s->eof_done = 0;
2045  s->skip_frame = 1;
2046 }
2047 
2048 /**
2049  *@brief Clear decoder buffers (for seeking).
2050  *@param avctx codec context
2051  */
2052 static void wmapro_flush(AVCodecContext *avctx)
2053 {
2054  WMAProDecodeCtx *s = avctx->priv_data;
2055 
2056  flush(s);
2057 }
2058 
2059 static void xma_flush(AVCodecContext *avctx)
2060 {
2061  XMADecodeCtx *s = avctx->priv_data;
2062  int i;
2063 
2064  for (i = 0; i < XMA_MAX_STREAMS; i++) {
2065  av_audio_fifo_reset(s->samples[0][i]);
2066  av_audio_fifo_reset(s->samples[1][i]);
2067  }
2068 
2069  for (i = 0; i < s->num_streams; i++)
2070  flush(&s->xma[i]);
2071 
2072  s->current_stream = 0;
2073  s->flushed = 0;
2074 }
2075 
2076 /**
2077  *@brief wmapro decoder
2078  */
2080  .name = "wmapro",
2081  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
2082  .type = AVMEDIA_TYPE_AUDIO,
2083  .id = AV_CODEC_ID_WMAPRO,
2084  .priv_data_size = sizeof(WMAProDecodeCtx),
2086  .close = wmapro_decode_end,
2088  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
2089  .flush = wmapro_flush,
2090  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2093 };
2094 
2096  .name = "xma1",
2097  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
2098  .type = AVMEDIA_TYPE_AUDIO,
2099  .id = AV_CODEC_ID_XMA1,
2100  .priv_data_size = sizeof(XMADecodeCtx),
2101  .init = xma_decode_init,
2102  .close = xma_decode_end,
2105  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2108 };
2109 
2111  .name = "xma2",
2112  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
2113  .type = AVMEDIA_TYPE_AUDIO,
2114  .id = AV_CODEC_ID_XMA2,
2115  .priv_data_size = sizeof(XMADecodeCtx),
2116  .init = xma_decode_init,
2117  .close = xma_decode_end,
2119  .flush = xma_flush,
2121  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2124 };
WMAProChannelCtx::num_vec_coeffs
uint16_t num_vec_coeffs
number of vector coded coefficients
Definition: wmaprodec.c:161
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
default_decorrelation
static const float *const default_decorrelation[]
default decorrelation matrix offsets
Definition: wmaprodata.h:594
xma_decode_init
static av_cold int xma_decode_init(AVCodecContext *avctx)
Definition: wmaprodec.c:1950
WMAProDecodeCtx::subframe_offset
int subframe_offset
subframe offset in the bit reservoir
Definition: wmaprodec.c:216
AVCodec
AVCodec.
Definition: codec.h:202
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
XMA_MAX_CHANNELS
#define XMA_MAX_CHANNELS
Definition: wmaprodec.c:115
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
SCALEMAXDEPTH
#define SCALEMAXDEPTH
Definition: wmaprodec.c:129
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
decode_subframe
static int decode_subframe(WMAProDecodeCtx *s)
Decode a single subframe (block).
Definition: wmaprodec.c:1194
AVERROR
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
append
static uint8_t * append(uint8_t *buf, const uint8_t *src, int size)
Definition: mjpeg2jpeg_bsf.c:59
WMAProDecodeCtx::gb
GetBitContext gb
bitstream reader context
Definition: wmaprodec.c:223
WMAProDecodeCtx::samples_per_frame
uint16_t samples_per_frame
number of samples to output
Definition: wmaprodec.c:195
ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
Definition: sinewin_tablegen.h:51
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
mem_internal.h
WMAProChannelCtx::scale_factor_step
int8_t scale_factor_step
scaling step for the current subframe
Definition: wmaprodec.c:154
ff_xma1_decoder
const AVCodec ff_xma1_decoder
Definition: wmaprodec.c:2095
scale_huffbits
static const uint8_t scale_huffbits[HUFF_SCALE_SIZE]
Definition: wmaprodata.h:70
wmapro_window
static void wmapro_window(WMAProDecodeCtx *s)
Apply sine window and reconstruct the output buffer.
Definition: wmaprodec.c:1164
WMAPRO_BLOCK_MAX_BITS
#define WMAPRO_BLOCK_MAX_BITS
log2 of max block size
Definition: wmaprodec.c:118
WMAProDecodeCtx::min_samples_per_subframe
uint16_t min_samples_per_subframe
Definition: wmaprodec.c:203
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
WMAProChannelCtx::subframe_offset
uint16_t subframe_offset[MAX_SUBFRAMES]
subframe positions in the current frame
Definition: wmaprodec.c:148
thread.h
HUFF_SCALE_SIZE
#define HUFF_SCALE_SIZE
Definition: wmaprodata.h:49
decode_tilehdr
static int decode_tilehdr(WMAProDecodeCtx *s)
Decode how the data in the frame is split into subframes.
Definition: wmaprodec.c:655
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:180
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
coef0_run
static const uint16_t coef0_run[HUFF_COEF0_SIZE]
Definition: wmaprodata.h:332
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
WMAProDecodeCtx::avctx
AVCodecContext * avctx
codec context for av_log
Definition: wmaprodec.c:181
sf_rl_vlc
static VLC sf_rl_vlc
scale factor run length vlc
Definition: wmaprodec.c:133
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
wmapro_decode_init
static av_cold int wmapro_decode_init(AVCodecContext *avctx)
Initialize the decoder.
Definition: wmaprodec.c:591
flush
static void flush(WMAProDecodeCtx *s)
Definition: wmaprodec.c:2034
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
decode_packet
static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmaprodec.c:1606
get_rate
static av_cold int get_rate(AVCodecContext *avctx)
Definition: wmaprodec.c:302
VLCBITS
#define VLCBITS
Definition: wmaprodec.c:124
WMAPRO_BLOCK_MIN_SIZE
#define WMAPRO_BLOCK_MIN_SIZE
minimum block size
Definition: wmaprodec.c:119
b
#define b
Definition: input.c:40
decode_scale_factors
static int decode_scale_factors(WMAProDecodeCtx *s)
Extract scale factors from the bitstream.
Definition: wmaprodec.c:1016
data
const char data[16]
Definition: mxf.c:143
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
XMADecodeCtx::trim_start
int trim_start
Definition: wmaprodec.c:254
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:798
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
ff_xma2_decoder
const AVCodec ff_xma2_decoder
Definition: wmaprodec.c:2110
scale_rl_huffbits
static const uint8_t scale_rl_huffbits[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:118
WMAPRO_BLOCK_MAX_SIZE
#define WMAPRO_BLOCK_MAX_SIZE
maximum block size
Definition: wmaprodec.c:120
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
intfloat.h
PRINT_HEX
#define PRINT_HEX(a, b)
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
PRINT
#define PRINT(a, b)
WMAProDecodeCtx::pb
PutBitContext pb
context for filling the frame_data buffer
Definition: wmaprodec.c:185
decode_init
static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
Initialize the decoder.
Definition: wmaprodec.c:354
decode_end
static av_cold int decode_end(WMAProDecodeCtx *s)
Uninitialize the decoder and free all resources.
Definition: wmaprodec.c:281
WMAProDecodeCtx::fdsp
AVFloatDSPContext * fdsp
Definition: wmaprodec.c:182
WMAProDecodeCtx::sfb_offsets
int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]
scale factor band offsets (multiples of 4)
Definition: wmaprodec.c:205
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
sin64
static float sin64[33]
sine table for decorrelation
Definition: wmaprodec.c:138
HUFF_SCALE_RL_SIZE
#define HUFF_SCALE_RL_SIZE
Definition: wmaprodata.h:95
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
ff_copy_bits
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:69
window
static SDL_Window * window
Definition: ffplay.c:364
vec2_vlc
static VLC vec2_vlc
2 coefficients per symbol
Definition: wmaprodec.c:135
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:34
v0
#define v0
Definition: regdef.h:26
wmapro_decode_end
static av_cold int wmapro_decode_end(AVCodecContext *avctx)
Definition: wmaprodec.c:293
GetBitContext
Definition: get_bits.h:62
WMAProDecodeCtx::num_chgroups
uint8_t num_chgroups
number of channel groups
Definition: wmaprodec.c:241
WMAProDecodeCtx::drc_gain
uint8_t drc_gain
gain for the DRC tool
Definition: wmaprodec.c:225
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:124
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
val
static double val(void *priv, double ch)
Definition: aeval.c:76
WMAProDecodeCtx::num_bands
int8_t num_bands
number of scale factor bands
Definition: wmaprodec.c:235
WMAProDecodeCtx::tmp
float tmp[WMAPRO_BLOCK_MAX_SIZE]
IMDCT output buffer.
Definition: wmaprodec.c:187
SCALERLMAXDEPTH
#define SCALERLMAXDEPTH
Definition: wmaprodec.c:130
coef1_huffbits
static const uint8_t coef1_huffbits[555]
Definition: wmadata.h:331
WMAProDecodeCtx::sf_offsets
int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]
scale factor resample matrix
Definition: wmaprodec.c:206
WMAProDecodeCtx::chgroup
WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]
channel group information
Definition: wmaprodec.c:242
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
coef1_huffcodes
static const uint32_t coef1_huffcodes[555]
Definition: wmadata.h:258
WMAProChannelCtx::max_scale_factor
int max_scale_factor
maximum scale factor for the current subframe
Definition: wmaprodec.c:155
WMAProChannelCtx::quant_step
int quant_step
quantization step for the current subframe
Definition: wmaprodec.c:152
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
WMAProChannelCtx::table_idx
uint8_t table_idx
index in sf_offsets for the scale factor reference block
Definition: wmaprodec.c:159
decode_subframe_length
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
Decode the subframe length.
Definition: wmaprodec.c:604
WMAProChannelCtx::out
float out[WMAPRO_BLOCK_MAX_SIZE+WMAPRO_BLOCK_MAX_SIZE/2]
output buffer
Definition: wmaprodec.c:162
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
WMAProDecodeCtx::buf_bit_size
int buf_bit_size
buffer size in bits
Definition: wmaprodec.c:224
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
HUFF_COEF1_SIZE
#define HUFF_COEF1_SIZE
Definition: wmaprodata.h:253
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
symbol_to_vec4
static const uint16_t symbol_to_vec4[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:540
WMAProDecodeCtx::subframe_len_bits
uint8_t subframe_len_bits
number of bits used for the subframe length
Definition: wmaprodec.c:201
mask
static const uint16_t mask[17]
Definition: lzw.c:38
decode_decorrelation_matrix
static void decode_decorrelation_matrix(WMAProDecodeCtx *s, WMAProChannelGrp *chgroup)
Calculate a decorrelation matrix from the bitstream parameters.
Definition: wmaprodec.c:746
WMAProChannelCtx
frame specific decoder context for a single channel
Definition: wmaprodec.c:143
wma_common.h
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
WMAProChannelCtx::scale_factors
int * scale_factors
pointer to the scale factor values used for decoding
Definition: wmaprodec.c:158
WMAProDecodeCtx::skip_frame
int8_t skip_frame
skip output step
Definition: wmaprodec.c:226
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_CODEC_ID_WMAPRO
@ AV_CODEC_ID_WMAPRO
Definition: codec_id.h:460
WMAProDecodeCtx::subwoofer_cutoffs
int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]
subwoofer cutoff values
Definition: wmaprodec.c:207
WMAProDecodeCtx::decode_flags
uint32_t decode_flags
used compression features
Definition: wmaprodec.c:191
AV_CODEC_ID_XMA1
@ AV_CODEC_ID_XMA1
Definition: codec_id.h:502
vec2_huffcodes
static const uint16_t vec2_huffcodes[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:462
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:112
frame_size
int frame_size
Definition: mxfenc.c:2198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
WMAProDecodeCtx::packet_loss
uint8_t packet_loss
set in case of bitstream error
Definition: wmaprodec.c:217
bits
uint8_t bits
Definition: vp3data.h:141
symbol_to_vec2
static const uint8_t symbol_to_vec2[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:557
vec4_huffcodes
static const uint16_t vec4_huffcodes[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:421
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
WMAProDecodeCtx::log2_frame_size
uint16_t log2_frame_size
Definition: wmaprodec.c:198
inverse_channel_transform
static void inverse_channel_transform(WMAProDecodeCtx *s)
Reconstruct the individual channel data.
Definition: wmaprodec.c:1109
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:360
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
XMADecodeCtx::flushed
int flushed
Definition: wmaprodec.c:255
wma.h
XMADecodeCtx::xma
WMAProDecodeCtx xma[XMA_MAX_STREAMS]
Definition: wmaprodec.c:248
PutBitContext
Definition: put_bits.h:49
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
decode_coeffs
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Extract the coefficients from the bitstream.
Definition: wmaprodec.c:910
if
if(ret)
Definition: filter_design.txt:179
XMA_MAX_CHANNELS_STREAM
#define XMA_MAX_CHANNELS_STREAM
Definition: wmaprodec.c:114
WMAProChannelCtx::prev_block_len
int16_t prev_block_len
length of the previous block
Definition: wmaprodec.c:144
WMAProDecodeCtx::transmit_num_vec_coeffs
int8_t transmit_num_vec_coeffs
number of vector coded coefficients is part of the bitstream
Definition: wmaprodec.c:236
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:63
WMAProDecodeCtx::channel_indexes_for_cur_subframe
int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]
Definition: wmaprodec.c:234
WMAProChannelCtx::grouped
uint8_t grouped
channel is part of a group
Definition: wmaprodec.c:151
XMADecodeCtx::start_channel
int start_channel[XMA_MAX_STREAMS]
Definition: wmaprodec.c:253
vec4_huffbits
static const uint8_t vec4_huffbits[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:440
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
wmapro_flush
static void wmapro_flush(AVCodecContext *avctx)
Clear decoder buffers (for seeking).
Definition: wmaprodec.c:2052
run
uint8_t run
Definition: svq3.c:203
WMAProDecodeCtx::windows
const float * windows[WMAPRO_BLOCK_SIZES]
windows for the different block sizes
Definition: wmaprodec.c:188
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:59
WMAProChannelGrp::transform
int8_t transform
transform on / off
Definition: wmaprodec.c:170
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:418
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
WMAProDecodeCtx::nb_channels
int8_t nb_channels
number of channels in stream (XMA1/2)
Definition: wmaprodec.c:232
HUFF_VEC1_SIZE
#define HUFF_VEC1_SIZE
Definition: wmaprodata.h:505
xma_flush
static void xma_flush(AVCodecContext *avctx)
Definition: wmaprodec.c:2059
WMAPRO_MAX_CHANNELS
#define WMAPRO_MAX_CHANNELS
current decoder limitations
Definition: wmaprodec.c:109
WMAProChannelGrp
channel group for channel transformations
Definition: wmaprodec.c:168
exp
int8_t exp
Definition: eval.c:72
AVOnce
#define AVOnce
Definition: thread.h:172
c
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
scale_rl_level
static const uint8_t scale_rl_level[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:150
float_dsp.h
WMAProDecodeCtx::eof_done
uint8_t eof_done
set when EOF reached and extra subframe is written (XMA1/2)
Definition: wmaprodec.c:219
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:95
WMAProDecodeCtx::frame_num
uint32_t frame_num
current frame number (not used for decoding)
Definition: wmaprodec.c:222
sf_vlc
static VLC sf_vlc
scale factor DPCM vlc
Definition: wmaprodec.c:132
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1651
WMAProChannelCtx::num_subframes
uint8_t num_subframes
Definition: wmaprodec.c:146
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
HUFF_COEF0_SIZE
#define HUFF_COEF0_SIZE
Definition: wmaprodata.h:166
WMAProChannelCtx::coeffs
float * coeffs
pointer to the subframe decode buffer
Definition: wmaprodec.c:160
WMAProDecodeCtx::len_prefix
uint8_t len_prefix
frame is prefixed with its length
Definition: wmaprodec.c:192
critical_freq
static const uint16_t critical_freq[]
frequencies to divide the frequency spectrum into scale factor bands
Definition: wmaprodata.h:37
WMAProChannelCtx::transmit_coefs
uint8_t transmit_coefs
Definition: wmaprodec.c:145
WMAPRO_BLOCK_SIZES
#define WMAPRO_BLOCK_SIZES
possible block sizes
Definition: wmaprodec.c:121
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
WMAProDecodeCtx::frame_data
uint8_t frame_data[MAX_FRAMESIZE+AV_INPUT_BUFFER_PADDING_SIZE]
compressed frame data
Definition: wmaprodec.c:184
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
coef0_huffbits
static const uint8_t coef0_huffbits[666]
Definition: wmadata.h:171
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:154
decode_init_static
static av_cold void decode_init_static(void)
Definition: wmaprodec.c:317
WMAProChannelCtx::scale_factor_idx
int8_t scale_factor_idx
index for the transmitted scale factor values (used for resampling)
Definition: wmaprodec.c:157
MAX_SUBFRAMES
#define MAX_SUBFRAMES
max number of subframes per channel
Definition: wmaprodec.c:110
AVFloatDSPContext
Definition: float_dsp.h:24
XMADecodeCtx::samples
AVAudioFifo * samples[2][XMA_MAX_STREAMS]
Definition: wmaprodec.c:252
vec1_huffbits
static const uint8_t vec1_huffbits[HUFF_VEC1_SIZE]
Definition: wmaprodata.h:523
sinewin.h
offset
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
Definition: writing_filters.txt:86
WMAProDecodeCtx::mdct_ctx
FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]
MDCT context per block size.
Definition: wmaprodec.c:186
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:228
WMAProChannelGrp::transform_band
int8_t transform_band[MAX_BANDS]
controls if the transform is enabled for a certain band
Definition: wmaprodec.c:171
M_PI
#define M_PI
Definition: mathematics.h:52
XMA_MAX_STREAMS
#define XMA_MAX_STREAMS
Definition: wmaprodec.c:113
WMAProDecodeCtx::max_num_subframes
uint8_t max_num_subframes
Definition: wmaprodec.c:200
WMAProChannelCtx::reuse_sf
int8_t reuse_sf
share scale factors between subframes
Definition: wmaprodec.c:153
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
WMAProDecodeCtx::next_packet_start
int next_packet_start
start offset of the next wma packet in the demuxer packet
Definition: wmaprodec.c:211
av_audio_fifo_read
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:181
FFTContext
Definition: fft.h:75
scale_rl_huffcodes
static const uint32_t scale_rl_huffcodes[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:97
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
WMAProChannelCtx::cur_subframe
uint8_t cur_subframe
current subframe number
Definition: wmaprodec.c:149
scale_rl_run
static const uint8_t scale_rl_run[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:140
WMAProChannelCtx::decoded_samples
uint16_t decoded_samples
number of already processed samples
Definition: wmaprodec.c:150
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
FF_CODEC_CAP_INIT_CLEANUP
#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:50
HUFF_VEC2_SIZE
#define HUFF_VEC2_SIZE
Definition: wmaprodata.h:460
coef1_level
static const float coef1_level[HUFF_COEF1_SIZE]
Definition: wmaprodata.h:396
vec1_vlc
static VLC vec1_vlc
1 coefficient per symbol
Definition: wmaprodec.c:136
VEC1MAXDEPTH
#define VEC1MAXDEPTH
Definition: wmaprodec.c:128
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
MAX_BANDS
#define MAX_BANDS
max number of scale factor bands
Definition: wmaprodec.c:111
coef1_run
static const uint16_t coef1_run[HUFF_COEF1_SIZE]
Definition: wmaprodata.h:379
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
tb
#define tb
Definition: regdef.h:68
audio_fifo.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
len
int len
Definition: vorbis_enc_data.h:426
HUFF_VEC4_SIZE
#define HUFF_VEC4_SIZE
Definition: wmaprodata.h:419
WMAProDecodeCtx::trim_start
uint16_t trim_start
number of samples to skip at start
Definition: wmaprodec.c:196
coef_vlc
static VLC coef_vlc[2]
coefficient run length vlc codes
Definition: wmaprodec.c:137
XMADecodeCtx::trim_end
int trim_end
Definition: wmaprodec.c:254
wmaprodata.h
tables for wmapro decoding
avcodec.h
xma_decode_packet
static int xma_decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmaprodec.c:1828
WMAProDecodeCtx
main decoder context
Definition: wmaprodec.c:179
WMAProDecodeCtx::pgb
GetBitContext pgb
bitstream reader context for the packet
Definition: wmaprodec.c:210
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1029
save_bits
static void save_bits(WMAProDecodeCtx *s, GetBitContext *gb, int len, int append)
Fill the bit reservoir with a (partial) frame.
Definition: wmaprodec.c:1559
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
WMAProChannelGrp::num_channels
uint8_t num_channels
number of channels in the group
Definition: wmaprodec.c:169
coef0_huffcodes
static const uint32_t coef0_huffcodes[666]
Definition: wmadata.h:84
dump_context
static av_cold void dump_context(WMAProDecodeCtx *s)
helper function to print the most important members of the context
Definition: wmaprodec.c:262
ff_wmapro_decoder
const AVCodec ff_wmapro_decoder
wmapro decoder
Definition: wmaprodec.c:2079
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
decode_frame
static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
Decode one WMA frame.
Definition: wmaprodec.c:1434
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
scale_huffcodes
static const uint16_t scale_huffcodes[HUFF_SCALE_SIZE]
Definition: wmaprodata.h:51
WMAProDecodeCtx::channels_for_cur_subframe
int8_t channels_for_cur_subframe
number of channels that contain the subframe
Definition: wmaprodec.c:233
AVCodecContext
main external API structure.
Definition: avcodec.h:383
ff_wma_get_frame_len_bits
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
VEC4MAXDEPTH
#define VEC4MAXDEPTH
Definition: wmaprodec.c:126
WMAProDecodeCtx::esc_len
int8_t esc_len
length of escaped coefficients
Definition: wmaprodec.c:239
WMAProDecodeCtx::table_idx
uint8_t table_idx
index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
Definition: wmaprodec.c:238
WMAProDecodeCtx::num_sfb
int8_t num_sfb[WMAPRO_BLOCK_SIZES]
scale factor bands per block size
Definition: wmaprodec.c:204
vec2_huffbits
static const uint8_t vec2_huffbits[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:483
XMADecodeCtx::num_streams
int num_streams
Definition: wmaprodec.c:251
WMAProChannelCtx::subframe_len
uint16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
Definition: wmaprodec.c:147
VLC
Definition: vlc.h:26
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
WMAProDecodeCtx::bits_per_sample
uint8_t bits_per_sample
integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1....
Definition: wmaprodec.c:194
SCALEVLCBITS
#define SCALEVLCBITS
Definition: wmaprodec.c:125
WMAProDecodeCtx::max_subframe_len_bit
uint8_t max_subframe_len_bit
flag indicating that the subframe is of maximum size when the first subframe length bit is 1
Definition: wmaprodec.c:202
AV_CODEC_CAP_DELAY
#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:82
ffmath.h
WMAProDecodeCtx::packet_offset
uint8_t packet_offset
frame offset in the packet
Definition: wmaprodec.c:212
WMAProDecodeCtx::skip_packets
uint8_t skip_packets
packets to skip to find next packet in a stream (XMA1/2)
Definition: wmaprodec.c:228
WMAProChannelGrp::channel_data
float * channel_data[WMAPRO_MAX_CHANNELS]
transformation coefficients
Definition: wmaprodec.c:173
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
WMAProChannelCtx::saved_scale_factors
int saved_scale_factors[2][MAX_BANDS]
resampled and (previously) transmitted scale factor values
Definition: wmaprodec.c:156
WMAProDecodeCtx::frame_offset
int frame_offset
frame offset in the bit reservoir
Definition: wmaprodec.c:215
XMADecodeCtx::frames
AVFrame * frames[XMA_MAX_STREAMS]
Definition: wmaprodec.c:249
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:416
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:100
WMAProDecodeCtx::packet_done
uint8_t packet_done
set when a packet is fully decoded
Definition: wmaprodec.c:218
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1023
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
xma_decode_end
static av_cold int xma_decode_end(AVCodecContext *avctx)
Definition: wmaprodec.c:2015
wmapro_decode_packet
static int wmapro_decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single WMA packet.
Definition: wmaprodec.c:1811
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
WMAProDecodeCtx::lfe_channel
int8_t lfe_channel
lfe channel index
Definition: wmaprodec.c:199
AV_CODEC_ID_XMA2
@ AV_CODEC_ID_XMA2
Definition: codec_id.h:503
WMAProDecodeCtx::trim_end
uint16_t trim_end
number of samples to skip at end
Definition: wmaprodec.c:197
ff_wma_run_level_decode
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)
Decode run level compressed coefficients.
Definition: wma.c:426
WMAProDecodeCtx::cur_sfb_offsets
int16_t * cur_sfb_offsets
sfb offsets for the current block
Definition: wmaprodec.c:237
decode_channel_transform
static int decode_channel_transform(WMAProDecodeCtx *s)
Decode channel transformation parameters.
Definition: wmaprodec.c:796
WMAProDecodeCtx::subframe_len
int16_t subframe_len
current subframe length
Definition: wmaprodec.c:231
WMAProDecodeCtx::parsed_all_subframes
int8_t parsed_all_subframes
all subframes decoded?
Definition: wmaprodec.c:227
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
XMADecodeCtx
Definition: wmaprodec.c:247
coef0_level
static const float coef0_level[HUFF_COEF0_SIZE]
Definition: wmaprodata.h:355
MAX_FRAMESIZE
#define MAX_FRAMESIZE
maximum compressed frame size
Definition: wmaprodec.c:112
WMAProDecodeCtx::packet_sequence_number
uint8_t packet_sequence_number
current packet number
Definition: wmaprodec.c:213
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
WMAProDecodeCtx::dynamic_range_compression
uint8_t dynamic_range_compression
frame contains DRC data
Definition: wmaprodec.c:193
XMADecodeCtx::current_stream
int current_stream
Definition: wmaprodec.c:250
remaining_bits
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
Calculate remaining input buffer length.
Definition: wmaprodec.c:1547
av_audio_fifo_reset
void av_audio_fifo_reset(AVAudioFifo *af)
Reset the AVAudioFifo buffer.
Definition: audio_fifo.c:218
ff_wma_get_large_val
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
Definition: wma.c:394
put_bits.h
FF_DEBUG_BITSTREAM
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:1305
WMAProDecodeCtx::num_saved_bits
int num_saved_bits
saved number of bits
Definition: wmaprodec.c:214
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
WMAProChannelGrp::decorrelation_matrix
float decorrelation_matrix[WMAPRO_MAX_CHANNELS *WMAPRO_MAX_CHANNELS]
Definition: wmaprodec.c:172
vec4_vlc
static VLC vec4_vlc
4 coefficients per symbol
Definition: wmaprodec.c:134
channel
channel
Definition: ebur128.h:39
vec1_huffcodes
static const uint16_t vec1_huffcodes[HUFF_VEC1_SIZE]
Definition: wmaprodata.h:507
VEC2MAXDEPTH
#define VEC2MAXDEPTH
Definition: wmaprodec.c:127
min
float min
Definition: vorbis_enc_data.h:429
WMAPRO_BLOCK_MIN_BITS
#define WMAPRO_BLOCK_MIN_BITS
log2 of min block size
Definition: wmaprodec.c:117