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