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