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