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