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