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