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;
326 
328 
330 
331  /** dump the extradata */
332  av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
333  for (i = 0; i < avctx->extradata_size; i++)
334  av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
335  av_log(avctx, AV_LOG_DEBUG, "\n");
336  if (avctx->codec_id == AV_CODEC_ID_XMA2 && (!avctx->extradata || avctx->extradata_size >= 6)) {
337  s->decode_flags = 0x10d6;
338  channel_mask = avctx->extradata ? AV_RL32(edata_ptr+2) : 0;
339  s->bits_per_sample = 16;
340  } else if (avctx->codec_id == AV_CODEC_ID_XMA1) {
341  s->decode_flags = 0x10d6;
342  s->bits_per_sample = 16;
343  channel_mask = 0;
344  } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
345  s->decode_flags = AV_RL16(edata_ptr+14);
346  channel_mask = AV_RL32(edata_ptr+2);
347  s->bits_per_sample = AV_RL16(edata_ptr);
348 
349  if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
350  avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
351  return AVERROR_PATCHWELCOME;
352  }
353  } else {
354  avpriv_request_sample(avctx, "Unknown extradata size");
355  return AVERROR_PATCHWELCOME;
356  }
357 
358  if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {
359  s->nb_channels = 2;
360  } else {
361  s->nb_channels = avctx->channels;
362  }
363 
364  /** generic init */
365  s->log2_frame_size = av_log2(avctx->block_align) + 4;
366  if (s->log2_frame_size > 25) {
367  avpriv_request_sample(avctx, "Large block align");
368  return AVERROR_PATCHWELCOME;
369  }
370 
371  /** frame info */
372  if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
373  s->skip_frame = 0;
374  else
375  s->skip_frame = 1; /* skip first frame */
376 
377  s->packet_loss = 1;
378  s->len_prefix = (s->decode_flags & 0x40);
379 
380  /** get frame len */
381  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
382  bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
383  if (bits > WMAPRO_BLOCK_MAX_BITS) {
384  avpriv_request_sample(avctx, "14-bit block sizes");
385  return AVERROR_PATCHWELCOME;
386  }
387  s->samples_per_frame = 1 << bits;
388  } else {
389  s->samples_per_frame = 512;
390  }
391 
392  /** subframe info */
393  log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
394  s->max_num_subframes = 1 << log2_max_num_subframes;
395  if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
396  s->max_subframe_len_bit = 1;
397  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
398 
399  num_possible_block_sizes = log2_max_num_subframes + 1;
401  s->dynamic_range_compression = (s->decode_flags & 0x80);
402 
403  if (s->max_num_subframes > MAX_SUBFRAMES) {
404  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
405  s->max_num_subframes);
406  return AVERROR_INVALIDDATA;
407  }
408 
410  av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
412  return AVERROR_INVALIDDATA;
413  }
414 
415  if (s->avctx->sample_rate <= 0) {
416  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
417  return AVERROR_INVALIDDATA;
418  }
419 
420  if (s->nb_channels <= 0) {
421  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
422  s->nb_channels);
423  return AVERROR_INVALIDDATA;
424  } else if (s->nb_channels > WMAPRO_MAX_CHANNELS) {
425  avpriv_request_sample(avctx,
426  "More than %d channels", WMAPRO_MAX_CHANNELS);
427  return AVERROR_PATCHWELCOME;
428  }
429 
430  /** init previous block len */
431  for (i = 0; i < s->nb_channels; i++)
433 
434  /** extract lfe channel position */
435  s->lfe_channel = -1;
436 
437  if (channel_mask & 8) {
438  unsigned int mask;
439  for (mask = 1; mask < 16; mask <<= 1) {
440  if (channel_mask & mask)
441  ++s->lfe_channel;
442  }
443  }
444 
446  scale_huffbits, 1, 1,
447  scale_huffcodes, 2, 2, 616);
448 
450  scale_rl_huffbits, 1, 1,
451  scale_rl_huffcodes, 4, 4, 1406);
452 
453  INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
454  coef0_huffbits, 1, 1,
455  coef0_huffcodes, 4, 4, 2108);
456 
457  INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
458  coef1_huffbits, 1, 1,
459  coef1_huffcodes, 4, 4, 3912);
460 
462  vec4_huffbits, 1, 1,
463  vec4_huffcodes, 2, 2, 604);
464 
466  vec2_huffbits, 1, 1,
467  vec2_huffcodes, 2, 2, 562);
468 
470  vec1_huffbits, 1, 1,
471  vec1_huffcodes, 2, 2, 562);
472 
473  /** calculate number of scale factor bands and their offsets
474  for every possible block size */
475  for (i = 0; i < num_possible_block_sizes; i++) {
476  int subframe_len = s->samples_per_frame >> i;
477  int x;
478  int band = 1;
479  int rate = get_rate(avctx);
480 
481  s->sfb_offsets[i][0] = 0;
482 
483  for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
484  int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
485  offset &= ~3;
486  if (offset > s->sfb_offsets[i][band - 1])
487  s->sfb_offsets[i][band++] = offset;
488 
489  if (offset >= subframe_len)
490  break;
491  }
492  s->sfb_offsets[i][band - 1] = subframe_len;
493  s->num_sfb[i] = band - 1;
494  if (s->num_sfb[i] <= 0) {
495  av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
496  return AVERROR_INVALIDDATA;
497  }
498  }
499 
500 
501  /** Scale factors can be shared between blocks of different size
502  as every block has a different scale factor band layout.
503  The matrix sf_offsets is needed to find the correct scale factor.
504  */
505 
506  for (i = 0; i < num_possible_block_sizes; i++) {
507  int b;
508  for (b = 0; b < s->num_sfb[i]; b++) {
509  int x;
510  int offset = ((s->sfb_offsets[i][b]
511  + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
512  for (x = 0; x < num_possible_block_sizes; x++) {
513  int v = 0;
514  while (s->sfb_offsets[x][v + 1] << x < offset) {
515  v++;
516  av_assert0(v < MAX_BANDS);
517  }
518  s->sf_offsets[i][x][b] = v;
519  }
520  }
521  }
522 
524  if (!s->fdsp)
525  return AVERROR(ENOMEM);
526 
527  /** init MDCT, FIXME: only init needed sizes */
528  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
530  1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
531  / (1 << (s->bits_per_sample - 1)));
532 
533  /** init MDCT windows: simple sine window */
534  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
535  const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
536  ff_init_ff_sine_windows(win_idx);
537  s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
538  }
539 
540  /** calculate subwoofer cutoff values */
541  for (i = 0; i < num_possible_block_sizes; i++) {
542  int block_size = s->samples_per_frame >> i;
543  int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
544  / s->avctx->sample_rate;
545  s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
546  }
547 
548  /** calculate sine values for the decorrelation matrix */
549  for (i = 0; i < 33; i++)
550  sin64[i] = sin(i*M_PI / 64.0);
551 
552  if (avctx->debug & FF_DEBUG_BITSTREAM)
553  dump_context(s);
554 
555  avctx->channel_layout = channel_mask;
556 
557  return 0;
558 }
559 
560 /**
561  *@brief Initialize the decoder.
562  *@param avctx codec context
563  *@return 0 on success, -1 otherwise
564  */
566 {
567  WMAProDecodeCtx *s = avctx->priv_data;
568 
569  return decode_init(s, avctx);
570 }
571 
572 /**
573  *@brief Decode the subframe length.
574  *@param s context
575  *@param offset sample offset in the frame
576  *@return decoded subframe length on success, < 0 in case of an error
577  */
579 {
580  int frame_len_shift = 0;
581  int subframe_len;
582 
583  /** no need to read from the bitstream when only one length is possible */
584  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
585  return s->min_samples_per_subframe;
586 
587  if (get_bits_left(&s->gb) < 1)
588  return AVERROR_INVALIDDATA;
589 
590  /** 1 bit indicates if the subframe is of maximum length */
591  if (s->max_subframe_len_bit) {
592  if (get_bits1(&s->gb))
593  frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
594  } else
595  frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
596 
597  subframe_len = s->samples_per_frame >> frame_len_shift;
598 
599  /** sanity check the length */
600  if (subframe_len < s->min_samples_per_subframe ||
601  subframe_len > s->samples_per_frame) {
602  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
603  subframe_len);
604  return AVERROR_INVALIDDATA;
605  }
606  return subframe_len;
607 }
608 
609 /**
610  *@brief Decode how the data in the frame is split into subframes.
611  * Every WMA frame contains the encoded data for a fixed number of
612  * samples per channel. The data for every channel might be split
613  * into several subframes. This function will reconstruct the list of
614  * subframes for every channel.
615  *
616  * If the subframes are not evenly split, the algorithm estimates the
617  * channels with the lowest number of total samples.
618  * Afterwards, for each of these channels a bit is read from the
619  * bitstream that indicates if the channel contains a subframe with the
620  * next subframe size that is going to be read from the bitstream or not.
621  * If a channel contains such a subframe, the subframe size gets added to
622  * the channel's subframe list.
623  * The algorithm repeats these steps until the frame is properly divided
624  * between the individual channels.
625  *
626  *@param s context
627  *@return 0 on success, < 0 in case of an error
628  */
630 {
631  uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
632  uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
633  int channels_for_cur_subframe = s->nb_channels; /**< number of channels that contain the current subframe */
634  int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
635  int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
636  int c;
637 
638  /* Should never consume more than 3073 bits (256 iterations for the
639  * while loop when always the minimum amount of 128 samples is subtracted
640  * from missing samples in the 8 channel case).
641  * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
642  */
643 
644  /** reset tiling information */
645  for (c = 0; c < s->nb_channels; c++)
646  s->channel[c].num_subframes = 0;
647 
648  if (s->max_num_subframes == 1 || get_bits1(&s->gb))
649  fixed_channel_layout = 1;
650 
651  /** loop until the frame data is split between the subframes */
652  do {
653  int subframe_len;
654 
655  /** check which channels contain the subframe */
656  for (c = 0; c < s->nb_channels; c++) {
657  if (num_samples[c] == min_channel_len) {
658  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
659  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
660  contains_subframe[c] = 1;
661  else
662  contains_subframe[c] = get_bits1(&s->gb);
663  } else
664  contains_subframe[c] = 0;
665  }
666 
667  /** get subframe length, subframe_len == 0 is not allowed */
668  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
669  return AVERROR_INVALIDDATA;
670 
671  /** add subframes to the individual channels and find new min_channel_len */
672  min_channel_len += subframe_len;
673  for (c = 0; c < s->nb_channels; c++) {
674  WMAProChannelCtx* chan = &s->channel[c];
675 
676  if (contains_subframe[c]) {
677  if (chan->num_subframes >= MAX_SUBFRAMES) {
679  "broken frame: num subframes > 31\n");
680  return AVERROR_INVALIDDATA;
681  }
682  chan->subframe_len[chan->num_subframes] = subframe_len;
683  num_samples[c] += subframe_len;
684  ++chan->num_subframes;
685  if (num_samples[c] > s->samples_per_frame) {
686  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
687  "channel len > samples_per_frame\n");
688  return AVERROR_INVALIDDATA;
689  }
690  } else if (num_samples[c] <= min_channel_len) {
691  if (num_samples[c] < min_channel_len) {
692  channels_for_cur_subframe = 0;
693  min_channel_len = num_samples[c];
694  }
695  ++channels_for_cur_subframe;
696  }
697  }
698  } while (min_channel_len < s->samples_per_frame);
699 
700  for (c = 0; c < s->nb_channels; c++) {
701  int i;
702  int offset = 0;
703  for (i = 0; i < s->channel[c].num_subframes; i++) {
704  ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]"
705  " len %i\n", s->frame_num, c, i,
706  s->channel[c].subframe_len[i]);
707  s->channel[c].subframe_offset[i] = offset;
708  offset += s->channel[c].subframe_len[i];
709  }
710  }
711 
712  return 0;
713 }
714 
715 /**
716  *@brief Calculate a decorrelation matrix from the bitstream parameters.
717  *@param s codec context
718  *@param chgroup channel group for which the matrix needs to be calculated
719  */
721  WMAProChannelGrp *chgroup)
722 {
723  int i;
724  int offset = 0;
725  int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
726  memset(chgroup->decorrelation_matrix, 0, s->nb_channels *
727  s->nb_channels * sizeof(*chgroup->decorrelation_matrix));
728 
729  for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
730  rotation_offset[i] = get_bits(&s->gb, 6);
731 
732  for (i = 0; i < chgroup->num_channels; i++)
733  chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
734  get_bits1(&s->gb) ? 1.0 : -1.0;
735 
736  for (i = 1; i < chgroup->num_channels; i++) {
737  int x;
738  for (x = 0; x < i; x++) {
739  int y;
740  for (y = 0; y < i + 1; y++) {
741  float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
742  float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
743  int n = rotation_offset[offset + x];
744  float sinv;
745  float cosv;
746 
747  if (n < 32) {
748  sinv = sin64[n];
749  cosv = sin64[32 - n];
750  } else {
751  sinv = sin64[64 - n];
752  cosv = -sin64[n - 32];
753  }
754 
755  chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
756  (v1 * sinv) - (v2 * cosv);
757  chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
758  (v1 * cosv) + (v2 * sinv);
759  }
760  }
761  offset += i;
762  }
763 }
764 
765 /**
766  *@brief Decode channel transformation parameters
767  *@param s codec context
768  *@return >= 0 in case of success, < 0 in case of bitstream errors
769  */
771 {
772  int i;
773  /* should never consume more than 1921 bits for the 8 channel case
774  * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
775  * + MAX_CHANNELS + MAX_BANDS + 1)
776  */
777 
778  /** in the one channel case channel transforms are pointless */
779  s->num_chgroups = 0;
780  if (s->nb_channels > 1) {
781  int remaining_channels = s->channels_for_cur_subframe;
782 
783  if (get_bits1(&s->gb)) {
785  "Channel transform bit");
786  return AVERROR_PATCHWELCOME;
787  }
788 
789  for (s->num_chgroups = 0; remaining_channels &&
791  WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
792  float** channel_data = chgroup->channel_data;
793  chgroup->num_channels = 0;
794  chgroup->transform = 0;
795 
796  /** decode channel mask */
797  if (remaining_channels > 2) {
798  for (i = 0; i < s->channels_for_cur_subframe; i++) {
799  int channel_idx = s->channel_indexes_for_cur_subframe[i];
800  if (!s->channel[channel_idx].grouped
801  && get_bits1(&s->gb)) {
802  ++chgroup->num_channels;
803  s->channel[channel_idx].grouped = 1;
804  *channel_data++ = s->channel[channel_idx].coeffs;
805  }
806  }
807  } else {
808  chgroup->num_channels = remaining_channels;
809  for (i = 0; i < s->channels_for_cur_subframe; i++) {
810  int channel_idx = s->channel_indexes_for_cur_subframe[i];
811  if (!s->channel[channel_idx].grouped)
812  *channel_data++ = s->channel[channel_idx].coeffs;
813  s->channel[channel_idx].grouped = 1;
814  }
815  }
816 
817  /** decode transform type */
818  if (chgroup->num_channels == 2) {
819  if (get_bits1(&s->gb)) {
820  if (get_bits1(&s->gb)) {
822  "Unknown channel transform type");
823  return AVERROR_PATCHWELCOME;
824  }
825  } else {
826  chgroup->transform = 1;
827  if (s->nb_channels == 2) {
828  chgroup->decorrelation_matrix[0] = 1.0;
829  chgroup->decorrelation_matrix[1] = -1.0;
830  chgroup->decorrelation_matrix[2] = 1.0;
831  chgroup->decorrelation_matrix[3] = 1.0;
832  } else {
833  /** cos(pi/4) */
834  chgroup->decorrelation_matrix[0] = 0.70703125;
835  chgroup->decorrelation_matrix[1] = -0.70703125;
836  chgroup->decorrelation_matrix[2] = 0.70703125;
837  chgroup->decorrelation_matrix[3] = 0.70703125;
838  }
839  }
840  } else if (chgroup->num_channels > 2) {
841  if (get_bits1(&s->gb)) {
842  chgroup->transform = 1;
843  if (get_bits1(&s->gb)) {
844  decode_decorrelation_matrix(s, chgroup);
845  } else {
846  /** FIXME: more than 6 coupled channels not supported */
847  if (chgroup->num_channels > 6) {
849  "Coupled channels > 6");
850  } else {
851  memcpy(chgroup->decorrelation_matrix,
853  chgroup->num_channels * chgroup->num_channels *
854  sizeof(*chgroup->decorrelation_matrix));
855  }
856  }
857  }
858  }
859 
860  /** decode transform on / off */
861  if (chgroup->transform) {
862  if (!get_bits1(&s->gb)) {
863  int i;
864  /** transform can be enabled for individual bands */
865  for (i = 0; i < s->num_bands; i++) {
866  chgroup->transform_band[i] = get_bits1(&s->gb);
867  }
868  } else {
869  memset(chgroup->transform_band, 1, s->num_bands);
870  }
871  }
872  remaining_channels -= chgroup->num_channels;
873  }
874  }
875  return 0;
876 }
877 
878 /**
879  *@brief Extract the coefficients from the bitstream.
880  *@param s codec context
881  *@param c current channel number
882  *@return 0 on success, < 0 in case of bitstream errors
883  */
884 static int decode_coeffs(WMAProDecodeCtx *s, int c)
885 {
886  /* Integers 0..15 as single-precision floats. The table saves a
887  costly int to float conversion, and storing the values as
888  integers allows fast sign-flipping. */
889  static const uint32_t fval_tab[16] = {
890  0x00000000, 0x3f800000, 0x40000000, 0x40400000,
891  0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
892  0x41000000, 0x41100000, 0x41200000, 0x41300000,
893  0x41400000, 0x41500000, 0x41600000, 0x41700000,
894  };
895  int vlctable;
896  VLC* vlc;
897  WMAProChannelCtx* ci = &s->channel[c];
898  int rl_mode = 0;
899  int cur_coeff = 0;
900  int num_zeros = 0;
901  const uint16_t* run;
902  const float* level;
903 
904  ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
905 
906  vlctable = get_bits1(&s->gb);
907  vlc = &coef_vlc[vlctable];
908 
909  if (vlctable) {
910  run = coef1_run;
911  level = coef1_level;
912  } else {
913  run = coef0_run;
914  level = coef0_level;
915  }
916 
917  /** decode vector coefficients (consumes up to 167 bits per iteration for
918  4 vector coded large values) */
919  while ((s->transmit_num_vec_coeffs || !rl_mode) &&
920  (cur_coeff + 3 < ci->num_vec_coeffs)) {
921  uint32_t vals[4];
922  int i;
923  unsigned int idx;
924 
925  idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
926 
927  if (idx == HUFF_VEC4_SIZE - 1) {
928  for (i = 0; i < 4; i += 2) {
929  idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
930  if (idx == HUFF_VEC2_SIZE - 1) {
931  uint32_t v0, v1;
932  v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
933  if (v0 == HUFF_VEC1_SIZE - 1)
934  v0 += ff_wma_get_large_val(&s->gb);
935  v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
936  if (v1 == HUFF_VEC1_SIZE - 1)
937  v1 += ff_wma_get_large_val(&s->gb);
938  vals[i ] = av_float2int(v0);
939  vals[i+1] = av_float2int(v1);
940  } else {
941  vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
942  vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
943  }
944  }
945  } else {
946  vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
947  vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
948  vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
949  vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
950  }
951 
952  /** decode sign */
953  for (i = 0; i < 4; i++) {
954  if (vals[i]) {
955  uint32_t sign = get_bits1(&s->gb) - 1;
956  AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
957  num_zeros = 0;
958  } else {
959  ci->coeffs[cur_coeff] = 0;
960  /** switch to run level mode when subframe_len / 128 zeros
961  were found in a row */
962  rl_mode |= (++num_zeros > s->subframe_len >> 8);
963  }
964  ++cur_coeff;
965  }
966  }
967 
968  /** decode run level coded coefficients */
969  if (cur_coeff < s->subframe_len) {
970  memset(&ci->coeffs[cur_coeff], 0,
971  sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
972  if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
973  level, run, 1, ci->coeffs,
974  cur_coeff, s->subframe_len,
975  s->subframe_len, s->esc_len, 0))
976  return AVERROR_INVALIDDATA;
977  }
978 
979  return 0;
980 }
981 
982 /**
983  *@brief Extract scale factors from the bitstream.
984  *@param s codec context
985  *@return 0 on success, < 0 in case of bitstream errors
986  */
988 {
989  int i;
990 
991  /** should never consume more than 5344 bits
992  * MAX_CHANNELS * (1 + MAX_BANDS * 23)
993  */
994 
995  for (i = 0; i < s->channels_for_cur_subframe; i++) {
997  int* sf;
998  int* sf_end;
1000  sf_end = s->channel[c].scale_factors + s->num_bands;
1001 
1002  /** resample scale factors for the new block size
1003  * as the scale factors might need to be resampled several times
1004  * before some new values are transmitted, a backup of the last
1005  * transmitted scale factors is kept in saved_scale_factors
1006  */
1007  if (s->channel[c].reuse_sf) {
1008  const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
1009  int b;
1010  for (b = 0; b < s->num_bands; b++)
1011  s->channel[c].scale_factors[b] =
1012  s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
1013  }
1014 
1015  if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
1016 
1017  if (!s->channel[c].reuse_sf) {
1018  int val;
1019  /** decode DPCM coded scale factors */
1020  s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1021  val = 45 / s->channel[c].scale_factor_step;
1022  for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1023  val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1024  *sf = val;
1025  }
1026  } else {
1027  int i;
1028  /** run level decode differences to the resampled factors */
1029  for (i = 0; i < s->num_bands; i++) {
1030  int idx;
1031  int skip;
1032  int val;
1033  int sign;
1034 
1035  idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1036 
1037  if (!idx) {
1038  uint32_t code = get_bits(&s->gb, 14);
1039  val = code >> 6;
1040  sign = (code & 1) - 1;
1041  skip = (code & 0x3f) >> 1;
1042  } else if (idx == 1) {
1043  break;
1044  } else {
1045  skip = scale_rl_run[idx];
1046  val = scale_rl_level[idx];
1047  sign = get_bits1(&s->gb)-1;
1048  }
1049 
1050  i += skip;
1051  if (i >= s->num_bands) {
1053  "invalid scale factor coding\n");
1054  return AVERROR_INVALIDDATA;
1055  }
1056  s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1057  }
1058  }
1059  /** swap buffers */
1061  s->channel[c].table_idx = s->table_idx;
1062  s->channel[c].reuse_sf = 1;
1063  }
1064 
1065  /** calculate new scale factor maximum */
1067  for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1068  s->channel[c].max_scale_factor =
1069  FFMAX(s->channel[c].max_scale_factor, *sf);
1070  }
1071 
1072  }
1073  return 0;
1074 }
1075 
1076 /**
1077  *@brief Reconstruct the individual channel data.
1078  *@param s codec context
1079  */
1081 {
1082  int i;
1083 
1084  for (i = 0; i < s->num_chgroups; i++) {
1085  if (s->chgroup[i].transform) {
1086  float data[WMAPRO_MAX_CHANNELS];
1087  const int num_channels = s->chgroup[i].num_channels;
1088  float** ch_data = s->chgroup[i].channel_data;
1089  float** ch_end = ch_data + num_channels;
1090  const int8_t* tb = s->chgroup[i].transform_band;
1091  int16_t* sfb;
1092 
1093  /** multichannel decorrelation */
1094  for (sfb = s->cur_sfb_offsets;
1095  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1096  int y;
1097  if (*tb++ == 1) {
1098  /** multiply values with the decorrelation_matrix */
1099  for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1100  const float* mat = s->chgroup[i].decorrelation_matrix;
1101  const float* data_end = data + num_channels;
1102  float* data_ptr = data;
1103  float** ch;
1104 
1105  for (ch = ch_data; ch < ch_end; ch++)
1106  *data_ptr++ = (*ch)[y];
1107 
1108  for (ch = ch_data; ch < ch_end; ch++) {
1109  float sum = 0;
1110  data_ptr = data;
1111  while (data_ptr < data_end)
1112  sum += *data_ptr++ * *mat++;
1113 
1114  (*ch)[y] = sum;
1115  }
1116  }
1117  } else if (s->nb_channels == 2) {
1118  int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1119  s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1120  ch_data[0] + sfb[0],
1121  181.0 / 128, len);
1122  s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1123  ch_data[1] + sfb[0],
1124  181.0 / 128, len);
1125  }
1126  }
1127  }
1128  }
1129 }
1130 
1131 /**
1132  *@brief Apply sine window and reconstruct the output buffer.
1133  *@param s codec context
1134  */
1136 {
1137  int i;
1138  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1139  int c = s->channel_indexes_for_cur_subframe[i];
1140  const float* window;
1141  int winlen = s->channel[c].prev_block_len;
1142  float* start = s->channel[c].coeffs - (winlen >> 1);
1143 
1144  if (s->subframe_len < winlen) {
1145  start += (winlen - s->subframe_len) >> 1;
1146  winlen = s->subframe_len;
1147  }
1148 
1149  window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1150 
1151  winlen >>= 1;
1152 
1153  s->fdsp->vector_fmul_window(start, start, start + winlen,
1154  window, winlen);
1155 
1157  }
1158 }
1159 
1160 /**
1161  *@brief Decode a single subframe (block).
1162  *@param s codec context
1163  *@return 0 on success, < 0 when decoding failed
1164  */
1166 {
1167  int offset = s->samples_per_frame;
1168  int subframe_len = s->samples_per_frame;
1169  int i;
1170  int total_samples = s->samples_per_frame * s->nb_channels;
1171  int transmit_coeffs = 0;
1172  int cur_subwoofer_cutoff;
1173 
1174  s->subframe_offset = get_bits_count(&s->gb);
1175 
1176  /** reset channel context and find the next block offset and size
1177  == the next block of the channel with the smallest number of
1178  decoded samples
1179  */
1180  for (i = 0; i < s->nb_channels; i++) {
1181  s->channel[i].grouped = 0;
1182  if (offset > s->channel[i].decoded_samples) {
1183  offset = s->channel[i].decoded_samples;
1184  subframe_len =
1186  }
1187  }
1188 
1189  ff_dlog(s->avctx,
1190  "processing subframe with offset %i len %i\n", offset, subframe_len);
1191 
1192  /** get a list of all channels that contain the estimated block */
1194  for (i = 0; i < s->nb_channels; i++) {
1195  const int cur_subframe = s->channel[i].cur_subframe;
1196  /** subtract already processed samples */
1197  total_samples -= s->channel[i].decoded_samples;
1198 
1199  /** and count if there are multiple subframes that match our profile */
1200  if (offset == s->channel[i].decoded_samples &&
1201  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1202  total_samples -= s->channel[i].subframe_len[cur_subframe];
1203  s->channel[i].decoded_samples +=
1204  s->channel[i].subframe_len[cur_subframe];
1207  }
1208  }
1209 
1210  /** check if the frame will be complete after processing the
1211  estimated block */
1212  if (!total_samples)
1213  s->parsed_all_subframes = 1;
1214 
1215 
1216  ff_dlog(s->avctx, "subframe is part of %i channels\n",
1218 
1219  /** calculate number of scale factor bands and their offsets */
1220  s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1221  s->num_bands = s->num_sfb[s->table_idx];
1223  cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1224 
1225  /** configure the decoder for the current subframe */
1226  offset += s->samples_per_frame >> 1;
1227 
1228  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1229  int c = s->channel_indexes_for_cur_subframe[i];
1230 
1231  s->channel[c].coeffs = &s->channel[c].out[offset];
1232  }
1233 
1234  s->subframe_len = subframe_len;
1235  s->esc_len = av_log2(s->subframe_len - 1) + 1;
1236 
1237  /** skip extended header if any */
1238  if (get_bits1(&s->gb)) {
1239  int num_fill_bits;
1240  if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1241  int len = get_bits(&s->gb, 4);
1242  num_fill_bits = get_bitsz(&s->gb, len) + 1;
1243  }
1244 
1245  if (num_fill_bits >= 0) {
1246  if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1247  av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1248  return AVERROR_INVALIDDATA;
1249  }
1250 
1251  skip_bits_long(&s->gb, num_fill_bits);
1252  }
1253  }
1254 
1255  /** no idea for what the following bit is used */
1256  if (get_bits1(&s->gb)) {
1257  avpriv_request_sample(s->avctx, "Reserved bit");
1258  return AVERROR_PATCHWELCOME;
1259  }
1260 
1261 
1262  if (decode_channel_transform(s) < 0)
1263  return AVERROR_INVALIDDATA;
1264 
1265 
1266  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1267  int c = s->channel_indexes_for_cur_subframe[i];
1268  if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1269  transmit_coeffs = 1;
1270  }
1271 
1273  if (transmit_coeffs) {
1274  int step;
1275  int quant_step = 90 * s->bits_per_sample >> 4;
1276 
1277  /** decode number of vector coded coefficients */
1278  if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1279  int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1280  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1281  int c = s->channel_indexes_for_cur_subframe[i];
1282  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1283  if (num_vec_coeffs > s->subframe_len) {
1284  av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1285  return AVERROR_INVALIDDATA;
1286  }
1287  av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1288  s->channel[c].num_vec_coeffs = num_vec_coeffs;
1289  }
1290  } else {
1291  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1292  int c = s->channel_indexes_for_cur_subframe[i];
1294  }
1295  }
1296  /** decode quantization step */
1297  step = get_sbits(&s->gb, 6);
1298  quant_step += step;
1299  if (step == -32 || step == 31) {
1300  const int sign = (step == 31) - 1;
1301  int quant = 0;
1302  while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1303  (step = get_bits(&s->gb, 5)) == 31) {
1304  quant += 31;
1305  }
1306  quant_step += ((quant + step) ^ sign) - sign;
1307  }
1308  if (quant_step < 0) {
1309  av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1310  }
1311 
1312  /** decode quantization step modifiers for every channel */
1313 
1314  if (s->channels_for_cur_subframe == 1) {
1315  s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1316  } else {
1317  int modifier_len = get_bits(&s->gb, 3);
1318  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1319  int c = s->channel_indexes_for_cur_subframe[i];
1320  s->channel[c].quant_step = quant_step;
1321  if (get_bits1(&s->gb)) {
1322  if (modifier_len) {
1323  s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1324  } else
1325  ++s->channel[c].quant_step;
1326  }
1327  }
1328  }
1329 
1330  /** decode scale factors */
1331  if (decode_scale_factors(s) < 0)
1332  return AVERROR_INVALIDDATA;
1333  }
1334 
1335  ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1336  get_bits_count(&s->gb) - s->subframe_offset);
1337 
1338  /** parse coefficients */
1339  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1340  int c = s->channel_indexes_for_cur_subframe[i];
1341  if (s->channel[c].transmit_coefs &&
1342  get_bits_count(&s->gb) < s->num_saved_bits) {
1343  decode_coeffs(s, c);
1344  } else
1345  memset(s->channel[c].coeffs, 0,
1346  sizeof(*s->channel[c].coeffs) * subframe_len);
1347  }
1348 
1349  ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1350  get_bits_count(&s->gb) - s->subframe_offset);
1351 
1352  if (transmit_coeffs) {
1353  FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1354  /** reconstruct the per channel data */
1356  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1357  int c = s->channel_indexes_for_cur_subframe[i];
1358  const int* sf = s->channel[c].scale_factors;
1359  int b;
1360 
1361  if (c == s->lfe_channel)
1362  memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1363  (subframe_len - cur_subwoofer_cutoff));
1364 
1365  /** inverse quantization and rescaling */
1366  for (b = 0; b < s->num_bands; b++) {
1367  const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1368  const int exp = s->channel[c].quant_step -
1369  (s->channel[c].max_scale_factor - *sf++) *
1370  s->channel[c].scale_factor_step;
1371  const float quant = ff_exp10(exp / 20.0);
1372  int start = s->cur_sfb_offsets[b];
1373  s->fdsp->vector_fmul_scalar(s->tmp + start,
1374  s->channel[c].coeffs + start,
1375  quant, end - start);
1376  }
1377 
1378  /** apply imdct (imdct_half == DCTIV with reverse) */
1379  mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1380  }
1381  }
1382 
1383  /** window and overlapp-add */
1384  wmapro_window(s);
1385 
1386  /** handled one subframe */
1387  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1388  int c = s->channel_indexes_for_cur_subframe[i];
1389  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1390  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1391  return AVERROR_INVALIDDATA;
1392  }
1393  ++s->channel[c].cur_subframe;
1394  }
1395 
1396  return 0;
1397 }
1398 
1399 /**
1400  *@brief Decode one WMA frame.
1401  *@param s codec context
1402  *@return 0 if the trailer bit indicates that this is the last frame,
1403  * 1 if there are additional frames
1404  */
1405 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1406 {
1407  GetBitContext* gb = &s->gb;
1408  int more_frames = 0;
1409  int len = 0;
1410  int i;
1411 
1412  /** get frame length */
1413  if (s->len_prefix)
1414  len = get_bits(gb, s->log2_frame_size);
1415 
1416  ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1417 
1418  /** decode tile information */
1419  if (decode_tilehdr(s)) {
1420  s->packet_loss = 1;
1421  return 0;
1422  }
1423 
1424  /** read postproc transform */
1425  if (s->nb_channels > 1 && get_bits1(gb)) {
1426  if (get_bits1(gb)) {
1427  for (i = 0; i < s->nb_channels * s->nb_channels; i++)
1428  skip_bits(gb, 4);
1429  }
1430  }
1431 
1432  /** read drc info */
1433  if (s->dynamic_range_compression) {
1434  s->drc_gain = get_bits(gb, 8);
1435  ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1436  }
1437 
1438  /** no idea what these are for, might be the number of samples
1439  that need to be skipped at the beginning or end of a stream */
1440  if (get_bits1(gb)) {
1441  int av_unused skip;
1442 
1443  /** usually true for the first frame */
1444  if (get_bits1(gb)) {
1445  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1446  ff_dlog(s->avctx, "start skip: %i\n", skip);
1447  }
1448 
1449  /** sometimes true for the last frame */
1450  if (get_bits1(gb)) {
1451  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1452  ff_dlog(s->avctx, "end skip: %i\n", skip);
1453  }
1454 
1455  }
1456 
1457  ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1458  get_bits_count(gb) - s->frame_offset);
1459 
1460  /** reset subframe states */
1461  s->parsed_all_subframes = 0;
1462  for (i = 0; i < s->nb_channels; i++) {
1463  s->channel[i].decoded_samples = 0;
1464  s->channel[i].cur_subframe = 0;
1465  s->channel[i].reuse_sf = 0;
1466  }
1467 
1468  /** decode all subframes */
1469  while (!s->parsed_all_subframes) {
1470  if (decode_subframe(s) < 0) {
1471  s->packet_loss = 1;
1472  return 0;
1473  }
1474  }
1475 
1476  /** copy samples to the output buffer */
1477  for (i = 0; i < s->nb_channels; i++)
1478  memcpy(frame->extended_data[i], s->channel[i].out,
1479  s->samples_per_frame * sizeof(*s->channel[i].out));
1480 
1481  for (i = 0; i < s->nb_channels; i++) {
1482  /** reuse second half of the IMDCT output for the next frame */
1483  memcpy(&s->channel[i].out[0],
1484  &s->channel[i].out[s->samples_per_frame],
1485  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1486  }
1487 
1488  if (s->skip_frame) {
1489  s->skip_frame = 0;
1490  *got_frame_ptr = 0;
1491  av_frame_unref(frame);
1492  } else {
1493  *got_frame_ptr = 1;
1494  }
1495 
1496  if (s->len_prefix) {
1497  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1498  /** FIXME: not sure if this is always an error */
1500  "frame[%"PRIu32"] would have to skip %i bits\n",
1501  s->frame_num,
1502  len - (get_bits_count(gb) - s->frame_offset) - 1);
1503  s->packet_loss = 1;
1504  return 0;
1505  }
1506 
1507  /** skip the rest of the frame data */
1508  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1509  } else {
1510  while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1511  }
1512  }
1513 
1514  /** decode trailer bit */
1515  more_frames = get_bits1(gb);
1516 
1517  ++s->frame_num;
1518  return more_frames;
1519 }
1520 
1521 /**
1522  *@brief Calculate remaining input buffer length.
1523  *@param s codec context
1524  *@param gb bitstream reader context
1525  *@return remaining size in bits
1526  */
1528 {
1529  return s->buf_bit_size - get_bits_count(gb);
1530 }
1531 
1532 /**
1533  *@brief Fill the bit reservoir with a (partial) frame.
1534  *@param s codec context
1535  *@param gb bitstream reader context
1536  *@param len length of the partial frame
1537  *@param append decides whether to reset the buffer or not
1538  */
1540  int append)
1541 {
1542  int buflen;
1543 
1544  /** when the frame data does not need to be concatenated, the input buffer
1545  is reset and additional bits from the previous frame are copied
1546  and skipped later so that a fast byte copy is possible */
1547 
1548  if (!append) {
1549  s->frame_offset = get_bits_count(gb) & 7;
1550  s->num_saved_bits = s->frame_offset;
1552  }
1553 
1554  buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1555 
1556  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1557  avpriv_request_sample(s->avctx, "Too small input buffer");
1558  s->packet_loss = 1;
1559  return;
1560  }
1561 
1562  av_assert0(len <= put_bits_left(&s->pb));
1563 
1564  s->num_saved_bits += len;
1565  if (!append) {
1566  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1567  s->num_saved_bits);
1568  } else {
1569  int align = 8 - (get_bits_count(gb) & 7);
1570  align = FFMIN(align, len);
1571  put_bits(&s->pb, align, get_bits(gb, align));
1572  len -= align;
1573  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1574  }
1575  skip_bits_long(gb, len);
1576 
1577  {
1578  PutBitContext tmp = s->pb;
1579  flush_put_bits(&tmp);
1580  }
1581 
1583  skip_bits(&s->gb, s->frame_offset);
1584 }
1585 
1587  void *data, int *got_frame_ptr, AVPacket *avpkt)
1588 {
1589  GetBitContext* gb = &s->pgb;
1590  const uint8_t* buf = avpkt->data;
1591  int buf_size = avpkt->size;
1592  int num_bits_prev_frame;
1593  int packet_sequence_number;
1594 
1595  *got_frame_ptr = 0;
1596 
1597  if (s->packet_done || s->packet_loss) {
1598  s->packet_done = 0;
1599 
1600  /** sanity check for the buffer length */
1601  if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1602  av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1603  buf_size, avctx->block_align);
1604  return AVERROR_INVALIDDATA;
1605  }
1606 
1607  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1608  s->next_packet_start = buf_size - avctx->block_align;
1609  buf_size = avctx->block_align;
1610  } else {
1611  s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1612  buf_size = FFMIN(buf_size, avctx->block_align);
1613  }
1614  s->buf_bit_size = buf_size << 3;
1615 
1616  /** parse packet header */
1617  init_get_bits(gb, buf, s->buf_bit_size);
1618  if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1619  packet_sequence_number = get_bits(gb, 4);
1620  skip_bits(gb, 2);
1621  } else {
1622  int num_frames = get_bits(gb, 6);
1623  ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames);
1624  packet_sequence_number = 0;
1625  }
1626 
1627  /** get number of bits that need to be added to the previous frame */
1628  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1629  if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1630  skip_bits(gb, 3);
1631  s->skip_packets = get_bits(gb, 8);
1632  ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets);
1633  }
1634 
1635  ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1636  num_bits_prev_frame);
1637 
1638  /** check for packet loss */
1639  if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss &&
1640  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1641  s->packet_loss = 1;
1642  av_log(avctx, AV_LOG_ERROR,
1643  "Packet loss detected! seq %"PRIx8" vs %x\n",
1644  s->packet_sequence_number, packet_sequence_number);
1645  }
1646  s->packet_sequence_number = packet_sequence_number;
1647 
1648  if (num_bits_prev_frame > 0) {
1649  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1650  if (num_bits_prev_frame >= remaining_packet_bits) {
1651  num_bits_prev_frame = remaining_packet_bits;
1652  s->packet_done = 1;
1653  }
1654 
1655  /** append the previous frame data to the remaining data from the
1656  previous packet to create a full frame */
1657  save_bits(s, gb, num_bits_prev_frame, 1);
1658  ff_dlog(avctx, "accumulated %x bits of frame data\n",
1659  s->num_saved_bits - s->frame_offset);
1660 
1661  /** decode the cross packet frame if it is valid */
1662  if (!s->packet_loss)
1663  decode_frame(s, data, got_frame_ptr);
1664  } else if (s->num_saved_bits - s->frame_offset) {
1665  ff_dlog(avctx, "ignoring %x previously saved bits\n",
1666  s->num_saved_bits - s->frame_offset);
1667  }
1668 
1669  if (s->packet_loss) {
1670  /** reset number of saved bits so that the decoder
1671  does not start to decode incomplete frames in the
1672  s->len_prefix == 0 case */
1673  s->num_saved_bits = 0;
1674  s->packet_loss = 0;
1675  }
1676  } else {
1677  int frame_size;
1678  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1679  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1680  skip_bits(gb, s->packet_offset);
1681  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1682  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1683  frame_size <= remaining_bits(s, gb)) {
1684  save_bits(s, gb, frame_size, 0);
1685  if (!s->packet_loss)
1686  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1687  } else if (!s->len_prefix
1688  && s->num_saved_bits > get_bits_count(&s->gb)) {
1689  /** when the frames do not have a length prefix, we don't know
1690  the compressed length of the individual frames
1691  however, we know what part of a new packet belongs to the
1692  previous frame
1693  therefore we save the incoming packet first, then we append
1694  the "previous frame" data from the next packet so that
1695  we get a buffer that only contains full frames */
1696  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1697  } else {
1698  s->packet_done = 1;
1699  }
1700  }
1701 
1702  if (remaining_bits(s, gb) < 0) {
1703  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1704  s->packet_loss = 1;
1705  }
1706 
1707  if (s->packet_done && !s->packet_loss &&
1708  remaining_bits(s, gb) > 0) {
1709  /** save the rest of the data so that it can be decoded
1710  with the next packet */
1711  save_bits(s, gb, remaining_bits(s, gb), 0);
1712  }
1713 
1714  s->packet_offset = get_bits_count(gb) & 7;
1715  if (s->packet_loss)
1716  return AVERROR_INVALIDDATA;
1717 
1718  return get_bits_count(gb) >> 3;
1719 }
1720 
1721 /**
1722  *@brief Decode a single WMA packet.
1723  *@param avctx codec context
1724  *@param data the output buffer
1725  *@param avpkt input packet
1726  *@return number of bytes that were read from the input buffer
1727  */
1728 static int wmapro_decode_packet(AVCodecContext *avctx, void *data,
1729  int *got_frame_ptr, AVPacket *avpkt)
1730 {
1731  WMAProDecodeCtx *s = avctx->priv_data;
1732  AVFrame *frame = data;
1733  int ret;
1734 
1735  /* get output buffer */
1736  frame->nb_samples = s->samples_per_frame;
1737  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1738  s->packet_loss = 1;
1739  return 0;
1740  }
1741 
1742  return decode_packet(avctx, s, data, got_frame_ptr, avpkt);
1743 }
1744 
1745 static int xma_decode_packet(AVCodecContext *avctx, void *data,
1746  int *got_frame_ptr, AVPacket *avpkt)
1747 {
1748  XMADecodeCtx *s = avctx->priv_data;
1749  int got_stream_frame_ptr = 0;
1750  AVFrame *frame = data;
1751  int i, ret, offset = INT_MAX;
1752 
1753  ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream],
1754  &got_stream_frame_ptr, avpkt);
1755 
1756  if (got_stream_frame_ptr) {
1757  memcpy(&s->samples[s->current_stream * 2 + 0][s->offset[s->current_stream] * 512],
1758  s->frames[s->current_stream]->extended_data[0], 512 * 4);
1759  if (avctx->channels > 1)
1760  memcpy(&s->samples[s->current_stream * 2 + 1][s->offset[s->current_stream] * 512],
1761  s->frames[s->current_stream]->extended_data[1], 512 * 4);
1762  s->offset[s->current_stream]++;
1763  } else if (ret < 0) {
1764  memset(s->offset, 0, sizeof(s->offset));
1765  s->current_stream = 0;
1766  return ret;
1767  }
1768 
1769  if (s->xma[s->current_stream].packet_done ||
1770  s->xma[s->current_stream].packet_loss) {
1771  int bret;
1772 
1773  if (s->xma[s->current_stream].skip_packets == 0) {
1774  ;
1775  } else if (s->xma[0].skip_packets == 0 && avctx->channels >= 2) {
1776  s->current_stream = 0;
1777  } else if (s->xma[1].skip_packets == 0 && avctx->channels >= 4) {
1778  s->current_stream = 1;
1779  } else if (s->xma[2].skip_packets == 0 && avctx->channels >= 6) {
1780  s->current_stream = 2;
1781  } else if (s->xma[3].skip_packets == 0 && avctx->channels == 8) {
1782  s->current_stream = 3;
1783  } else {
1784  int min[2];
1785 
1786  min[0] = s->xma[0].skip_packets;
1787  min[1] = i = 0;
1788 
1789  for (i = 1; i < avctx->channels / 2; i++) {
1790  if (s->xma[i].skip_packets < min[0]) {
1791  min[1] = i;
1792  min[0] = s->xma[i].skip_packets;
1793  }
1794  }
1795 
1796  s->current_stream = min[1];
1797  }
1798 
1799  for (i = 0; i < avctx->channels / 2; i++) {
1800  s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1);
1801  }
1802 
1803  for (i = 0; i < (avctx->channels + 1) / 2; i++) {
1804  offset = FFMIN(offset, s->offset[i]);
1805  }
1806 
1807  if (offset > 0) {
1808  frame->nb_samples = 512 * offset;
1809  if ((bret = ff_get_buffer(avctx, frame, 0)) < 0)
1810  return bret;
1811 
1812  for (i = 0; i < (avctx->channels + 1) / 2; i++) {
1813  memcpy(frame->extended_data[i * 2 + 0], s->samples[i * 2 + 0], frame->nb_samples * 4);
1814  if (avctx->channels > 1)
1815  memcpy(frame->extended_data[i * 2 + 1], s->samples[i * 2 + 1], frame->nb_samples * 4);
1816  s->offset[i] -= offset;
1817  if (s->offset[i]) {
1818  memmove(s->samples[i * 2 + 0], s->samples[i * 2 + 0] + frame->nb_samples, s->offset[i] * 4 * 512);
1819  if (avctx->channels > 1)
1820  memmove(s->samples[i * 2 + 1], s->samples[i * 2 + 1] + frame->nb_samples, s->offset[i] * 4 * 512);
1821  }
1822  }
1823 
1824  *got_frame_ptr = 1;
1825  }
1826  }
1827 
1828  return ret;
1829 }
1830 
1832 {
1833  XMADecodeCtx *s = avctx->priv_data;
1834  int i, ret;
1835 
1836  if (avctx->channels <= 0 || avctx->channels > 8)
1837  return AVERROR_INVALIDDATA;
1838 
1839  for (i = 0; i < (avctx->channels + 1) / 2; i++) {
1840  ret = decode_init(&s->xma[i], avctx);
1841  if (ret < 0)
1842  return ret;
1843  s->frames[i] = av_frame_alloc();
1844  if (!s->frames[i])
1845  return AVERROR(ENOMEM);
1846  s->frames[i]->nb_samples = 512;
1847  if ((ret = ff_get_buffer(avctx, s->frames[i], 0)) < 0) {
1848  return AVERROR(ENOMEM);
1849  }
1850 
1851  }
1852 
1853  return ret;
1854 }
1855 
1857 {
1858  XMADecodeCtx *s = avctx->priv_data;
1859  int i;
1860 
1861  for (i = 0; i < avctx->channels / 2; i++) {
1862  decode_end(&s->xma[i]);
1863  av_frame_free(&s->frames[i]);
1864  }
1865 
1866  return 0;
1867 }
1868 
1869 static void flush(WMAProDecodeCtx *s)
1870 {
1871  int i;
1872  /** reset output buffer as a part of it is used during the windowing of a
1873  new frame */
1874  for (i = 0; i < s->nb_channels; i++)
1875  memset(s->channel[i].out, 0, s->samples_per_frame *
1876  sizeof(*s->channel[i].out));
1877  s->packet_loss = 1;
1878  s->skip_packets = 0;
1879 }
1880 
1881 
1882 /**
1883  *@brief Clear decoder buffers (for seeking).
1884  *@param avctx codec context
1885  */
1886 static void wmapro_flush(AVCodecContext *avctx)
1887 {
1888  WMAProDecodeCtx *s = avctx->priv_data;
1889 
1890  flush(s);
1891 }
1892 
1893 static void xma_flush(AVCodecContext *avctx)
1894 {
1895  XMADecodeCtx *s = avctx->priv_data;
1896  int i;
1897  for (i = 0; i < (avctx->channels + 1) / 2; i++)
1898  flush(&s->xma[i]);
1899 
1900  memset(s->offset, 0, sizeof(s->offset));
1901  s->current_stream = 0;
1902 }
1903 
1904 
1905 /**
1906  *@brief wmapro decoder
1907  */
1909  .name = "wmapro",
1910  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1911  .type = AVMEDIA_TYPE_AUDIO,
1912  .id = AV_CODEC_ID_WMAPRO,
1913  .priv_data_size = sizeof(WMAProDecodeCtx),
1915  .close = wmapro_decode_end,
1917  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1918  .flush = wmapro_flush,
1919  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1921 };
1922 
1924  .name = "xma1",
1925  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
1926  .type = AVMEDIA_TYPE_AUDIO,
1927  .id = AV_CODEC_ID_XMA1,
1928  .priv_data_size = sizeof(XMADecodeCtx),
1929  .init = xma_decode_init,
1930  .close = xma_decode_end,
1932  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1933  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1935 };
1936 
1938  .name = "xma2",
1939  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
1940  .type = AVMEDIA_TYPE_AUDIO,
1941  .id = AV_CODEC_ID_XMA2,
1942  .priv_data_size = sizeof(XMADecodeCtx),
1943  .init = xma_decode_init,
1944  .close = xma_decode_end,
1946  .flush = xma_flush,
1947  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1948  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1950 };
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:629
This structure describes decoded (raw) audio or video data.
Definition: frame.h:194
#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:75
uint32_t decode_flags
used compression features
Definition: wmaprodec.c:184
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2990
int size
Definition: avcodec.h:1672
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:64
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:1886
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:428
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:3722
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:2545
#define AV_WN32A(p, v)
Definition: intreadwrite.h:543
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:246
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
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:1831
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:119
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:2516
static void inverse_channel_transform(WMAProDecodeCtx *s)
Reconstruct the individual channel data.
Definition: wmaprodec.c:1080
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:150
#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
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_X86ASM &&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 av_cold int xma_decode_end(AVCodecContext *avctx)
Definition: wmaprodec.c:1856
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1861
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:104
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:1671
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:1165
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:127
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:163
#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:179
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:1841
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:1923
#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:3729
#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:1908
#define FFMAX(a, b)
Definition: common.h:94
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
Decode the subframe length.
Definition: wmaprodec.c:578
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:2559
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:1586
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:362
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Extract the coefficients from the bitstream.
Definition: wmaprodec.c:884
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:928
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:1893
static void flush(WMAProDecodeCtx *s)
Definition: wmaprodec.c:1869
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:1937
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:1539
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:85
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:565
#define VEC1MAXDEPTH
Definition: wmaprodec.c:121
enum AVCodecID codec_id
Definition: avcodec.h:1763
int16_t subframe_len
current subframe length
Definition: wmaprodec.c:221
int sample_rate
samples per second
Definition: avcodec.h:2508
#define WMAPRO_BLOCK_SIZES
possible block sizes
Definition: wmaprodec.c:114
int debug
debug
Definition: avcodec.h:2987
static const uint8_t vec4_huffbits[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:440
main external API structure.
Definition: avcodec.h:1746
static const uint8_t symbol_to_vec2[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:557
tables for wmapro decoding
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1748
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:1862
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:1051
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:987
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
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:1527
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:502
static int decode_channel_transform(WMAProDecodeCtx *s)
Decode channel transformation parameters.
Definition: wmaprodec.c:770
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:720
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
static double c[64]
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
static void wmapro_window(WMAProDecodeCtx *s)
Apply sine window and reconstruct the output buffer.
Definition: wmaprodec.c:1135
#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:776
static const uint8_t scale_rl_level[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:150
void * priv_data
Definition: avcodec.h:1788
int len
GetBitContext pgb
bitstream reader context for the packet
Definition: wmaprodec.c:201
int channels
number of audio channels
Definition: avcodec.h:2509
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
Definition: wma.c:396
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:1405
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2539
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
#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:1728
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:241
float min
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1648
#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:260
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:1001
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:125
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:1745
static uint8_t tmp[11]
Definition: aes_ctr.c:26
bitstream writer API