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