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
211 
212  /* frame decode state */
213  uint32_t frame_num; ///< current frame number (not used for decoding)
215  GetBitContext gb; ///< bitstream reader context
216  int buf_bit_size; ///< buffer size in bits
217  uint8_t drc_gain; ///< gain for the DRC tool
218  int8_t skip_frame; ///< skip output step
219  int8_t parsed_all_subframes; ///< all subframes decoded?
220 
221  /* subframe/block decode state */
222  int16_t subframe_len; ///< current subframe length
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 
238 /**
239  *@brief helper function to print the most important members of the context
240  *@param s context
241  */
243 {
244 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
245 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
246 
247  PRINT("ed sample bit depth", s->bits_per_sample);
248  PRINT_HEX("ed decode flags", s->decode_flags);
249  PRINT("samples per frame", s->samples_per_frame);
250  PRINT("log2 frame size", s->log2_frame_size);
251  PRINT("max num subframes", s->max_num_subframes);
252  PRINT("len prefix", s->len_prefix);
253  PRINT("num channels", s->avctx->channels);
254 }
255 
256 /**
257  *@brief Uninitialize the decoder and free all resources.
258  *@param avctx codec context
259  *@return 0 on success, < 0 otherwise
260  */
262 {
263  WMAProDecodeCtx *s = avctx->priv_data;
264  int i;
265 
266  av_freep(&s->fdsp);
267 
268  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
269  ff_mdct_end(&s->mdct_ctx[i]);
270 
271  return 0;
272 }
273 
274 static av_cold int get_rate(AVCodecContext *avctx)
275 {
276  if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
277  if (avctx->sample_rate > 44100)
278  return 48000;
279  else if (avctx->sample_rate > 32000)
280  return 44100;
281  else if (avctx->sample_rate > 24000)
282  return 32000;
283  return 24000;
284  }
285 
286  return avctx->sample_rate;
287 }
288 
289 /**
290  *@brief Initialize the decoder.
291  *@param avctx codec context
292  *@return 0 on success, -1 otherwise
293  */
295 {
296  WMAProDecodeCtx *s = avctx->priv_data;
297  uint8_t *edata_ptr = avctx->extradata;
298  unsigned int channel_mask;
299  int i, bits;
300  int log2_max_num_subframes;
301  int num_possible_block_sizes;
302 
303  if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
304  avctx->block_align = 2048;
305 
306  if (!avctx->block_align) {
307  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
308  return AVERROR(EINVAL);
309  }
310 
311  s->avctx = avctx;
313  if (!s->fdsp)
314  return AVERROR(ENOMEM);
315 
317 
319 
320  if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 34) {
321  s->decode_flags = 0x10d6;
322  channel_mask = AV_RL32(edata_ptr+2);
323  s->bits_per_sample = 16;
324  /** dump the extradata */
325  for (i = 0; i < avctx->extradata_size; i++)
326  ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
327  ff_dlog(avctx, "\n");
328 
329  } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 28) {
330  s->decode_flags = 0x10d6;
331  s->bits_per_sample = 16;
332  channel_mask = 0;
333  /** dump the extradata */
334  for (i = 0; i < avctx->extradata_size; i++)
335  ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
336  ff_dlog(avctx, "\n");
337 
338  } else if (avctx->extradata_size >= 18) {
339  s->decode_flags = AV_RL16(edata_ptr+14);
340  channel_mask = AV_RL32(edata_ptr+2);
341  s->bits_per_sample = AV_RL16(edata_ptr);
342 
343  if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
344  avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
345  return AVERROR_PATCHWELCOME;
346  }
347 
348  /** dump the extradata */
349  for (i = 0; i < avctx->extradata_size; i++)
350  ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
351  ff_dlog(avctx, "\n");
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  avpriv_report_missing_feature(avctx, ">2 channels support");
360  return AVERROR_PATCHWELCOME;
361  }
362 
363  /** generic init */
364  s->log2_frame_size = av_log2(avctx->block_align) + 4;
365  if (s->log2_frame_size > 25) {
366  avpriv_request_sample(avctx, "Large block align");
367  return AVERROR_PATCHWELCOME;
368  }
369 
370  /** frame info */
371  if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
372  s->skip_frame = 0;
373  else
374  s->skip_frame = 1; /* skip first frame */
375 
376  s->packet_loss = 1;
377  s->len_prefix = (s->decode_flags & 0x40);
378 
379  /** get frame len */
380  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
381  bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
382  if (bits > WMAPRO_BLOCK_MAX_BITS) {
383  avpriv_request_sample(avctx, "14-bit block sizes");
384  return AVERROR_PATCHWELCOME;
385  }
386  s->samples_per_frame = 1 << bits;
387  } else {
388  s->samples_per_frame = 512;
389  }
390 
391  /** subframe info */
392  log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
393  s->max_num_subframes = 1 << log2_max_num_subframes;
394  if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
395  s->max_subframe_len_bit = 1;
396  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
397 
398  num_possible_block_sizes = log2_max_num_subframes + 1;
400  s->dynamic_range_compression = (s->decode_flags & 0x80);
401 
402  if (s->max_num_subframes > MAX_SUBFRAMES) {
403  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
404  s->max_num_subframes);
405  return AVERROR_INVALIDDATA;
406  }
407 
409  av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
411  return AVERROR_INVALIDDATA;
412  }
413 
414  if (s->avctx->sample_rate <= 0) {
415  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
416  return AVERROR_INVALIDDATA;
417  }
418 
419  if (avctx->channels < 0) {
420  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
421  avctx->channels);
422  return AVERROR_INVALIDDATA;
423  } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
424  avpriv_request_sample(avctx,
425  "More than %d channels", WMAPRO_MAX_CHANNELS);
426  return AVERROR_PATCHWELCOME;
427  }
428 
429  /** init previous block len */
430  for (i = 0; i < avctx->channels; i++)
432 
433  /** extract lfe channel position */
434  s->lfe_channel = -1;
435 
436  if (channel_mask & 8) {
437  unsigned int mask;
438  for (mask = 1; mask < 16; mask <<= 1) {
439  if (channel_mask & mask)
440  ++s->lfe_channel;
441  }
442  }
443 
445  scale_huffbits, 1, 1,
446  scale_huffcodes, 2, 2, 616);
447 
449  scale_rl_huffbits, 1, 1,
450  scale_rl_huffcodes, 4, 4, 1406);
451 
452  INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
453  coef0_huffbits, 1, 1,
454  coef0_huffcodes, 4, 4, 2108);
455 
456  INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
457  coef1_huffbits, 1, 1,
458  coef1_huffcodes, 4, 4, 3912);
459 
461  vec4_huffbits, 1, 1,
462  vec4_huffcodes, 2, 2, 604);
463 
465  vec2_huffbits, 1, 1,
466  vec2_huffcodes, 2, 2, 562);
467 
469  vec1_huffbits, 1, 1,
470  vec1_huffcodes, 2, 2, 562);
471 
472  /** calculate number of scale factor bands and their offsets
473  for every possible block size */
474  for (i = 0; i < num_possible_block_sizes; i++) {
475  int subframe_len = s->samples_per_frame >> i;
476  int x;
477  int band = 1;
478  int rate = get_rate(avctx);
479 
480  s->sfb_offsets[i][0] = 0;
481 
482  for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
483  int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
484  offset &= ~3;
485  if (offset > s->sfb_offsets[i][band - 1])
486  s->sfb_offsets[i][band++] = offset;
487 
488  if (offset >= subframe_len)
489  break;
490  }
491  s->sfb_offsets[i][band - 1] = subframe_len;
492  s->num_sfb[i] = band - 1;
493  if (s->num_sfb[i] <= 0) {
494  av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
495  return AVERROR_INVALIDDATA;
496  }
497  }
498 
499 
500  /** Scale factors can be shared between blocks of different size
501  as every block has a different scale factor band layout.
502  The matrix sf_offsets is needed to find the correct scale factor.
503  */
504 
505  for (i = 0; i < num_possible_block_sizes; i++) {
506  int b;
507  for (b = 0; b < s->num_sfb[i]; b++) {
508  int x;
509  int offset = ((s->sfb_offsets[i][b]
510  + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
511  for (x = 0; x < num_possible_block_sizes; x++) {
512  int v = 0;
513  while (s->sfb_offsets[x][v + 1] << x < offset) {
514  v++;
515  av_assert0(v < MAX_BANDS);
516  }
517  s->sf_offsets[i][x][b] = v;
518  }
519  }
520  }
521 
522  /** init MDCT, FIXME: only init needed sizes */
523  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
525  1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
526  / (1 << (s->bits_per_sample - 1)));
527 
528  /** init MDCT windows: simple sine window */
529  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
530  const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
531  ff_init_ff_sine_windows(win_idx);
532  s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
533  }
534 
535  /** calculate subwoofer cutoff values */
536  for (i = 0; i < num_possible_block_sizes; i++) {
537  int block_size = s->samples_per_frame >> i;
538  int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
539  / s->avctx->sample_rate;
540  s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
541  }
542 
543  /** calculate sine values for the decorrelation matrix */
544  for (i = 0; i < 33; i++)
545  sin64[i] = sin(i*M_PI / 64.0);
546 
547  if (avctx->debug & FF_DEBUG_BITSTREAM)
548  dump_context(s);
549 
550  avctx->channel_layout = channel_mask;
551 
552  return 0;
553 }
554 
555 /**
556  *@brief Decode the subframe length.
557  *@param s context
558  *@param offset sample offset in the frame
559  *@return decoded subframe length on success, < 0 in case of an error
560  */
562 {
563  int frame_len_shift = 0;
564  int subframe_len;
565 
566  /** no need to read from the bitstream when only one length is possible */
567  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
568  return s->min_samples_per_subframe;
569 
570  if (get_bits_left(&s->gb) < 1)
571  return AVERROR_INVALIDDATA;
572 
573  /** 1 bit indicates if the subframe is of maximum length */
574  if (s->max_subframe_len_bit) {
575  if (get_bits1(&s->gb))
576  frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
577  } else
578  frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
579 
580  subframe_len = s->samples_per_frame >> frame_len_shift;
581 
582  /** sanity check the length */
583  if (subframe_len < s->min_samples_per_subframe ||
584  subframe_len > s->samples_per_frame) {
585  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
586  subframe_len);
587  return AVERROR_INVALIDDATA;
588  }
589  return subframe_len;
590 }
591 
592 /**
593  *@brief Decode how the data in the frame is split into subframes.
594  * Every WMA frame contains the encoded data for a fixed number of
595  * samples per channel. The data for every channel might be split
596  * into several subframes. This function will reconstruct the list of
597  * subframes for every channel.
598  *
599  * If the subframes are not evenly split, the algorithm estimates the
600  * channels with the lowest number of total samples.
601  * Afterwards, for each of these channels a bit is read from the
602  * bitstream that indicates if the channel contains a subframe with the
603  * next subframe size that is going to be read from the bitstream or not.
604  * If a channel contains such a subframe, the subframe size gets added to
605  * the channel's subframe list.
606  * The algorithm repeats these steps until the frame is properly divided
607  * between the individual channels.
608  *
609  *@param s context
610  *@return 0 on success, < 0 in case of an error
611  */
613 {
614  uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
615  uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
616  int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
617  int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
618  int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
619  int c;
620 
621  /* Should never consume more than 3073 bits (256 iterations for the
622  * while loop when always the minimum amount of 128 samples is subtracted
623  * from missing samples in the 8 channel case).
624  * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
625  */
626 
627  /** reset tiling information */
628  for (c = 0; c < s->avctx->channels; c++)
629  s->channel[c].num_subframes = 0;
630 
631  if (s->max_num_subframes == 1 || get_bits1(&s->gb))
632  fixed_channel_layout = 1;
633 
634  /** loop until the frame data is split between the subframes */
635  do {
636  int subframe_len;
637 
638  /** check which channels contain the subframe */
639  for (c = 0; c < s->avctx->channels; c++) {
640  if (num_samples[c] == min_channel_len) {
641  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
642  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
643  contains_subframe[c] = 1;
644  else
645  contains_subframe[c] = get_bits1(&s->gb);
646  } else
647  contains_subframe[c] = 0;
648  }
649 
650  /** get subframe length, subframe_len == 0 is not allowed */
651  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
652  return AVERROR_INVALIDDATA;
653 
654  /** add subframes to the individual channels and find new min_channel_len */
655  min_channel_len += subframe_len;
656  for (c = 0; c < s->avctx->channels; c++) {
657  WMAProChannelCtx* chan = &s->channel[c];
658 
659  if (contains_subframe[c]) {
660  if (chan->num_subframes >= MAX_SUBFRAMES) {
662  "broken frame: num subframes > 31\n");
663  return AVERROR_INVALIDDATA;
664  }
665  chan->subframe_len[chan->num_subframes] = subframe_len;
666  num_samples[c] += subframe_len;
667  ++chan->num_subframes;
668  if (num_samples[c] > s->samples_per_frame) {
669  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
670  "channel len > samples_per_frame\n");
671  return AVERROR_INVALIDDATA;
672  }
673  } else if (num_samples[c] <= min_channel_len) {
674  if (num_samples[c] < min_channel_len) {
675  channels_for_cur_subframe = 0;
676  min_channel_len = num_samples[c];
677  }
678  ++channels_for_cur_subframe;
679  }
680  }
681  } while (min_channel_len < s->samples_per_frame);
682 
683  for (c = 0; c < s->avctx->channels; c++) {
684  int i;
685  int offset = 0;
686  for (i = 0; i < s->channel[c].num_subframes; i++) {
687  ff_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
688  " len %i\n", s->frame_num, c, i,
689  s->channel[c].subframe_len[i]);
690  s->channel[c].subframe_offset[i] = offset;
691  offset += s->channel[c].subframe_len[i];
692  }
693  }
694 
695  return 0;
696 }
697 
698 /**
699  *@brief Calculate a decorrelation matrix from the bitstream parameters.
700  *@param s codec context
701  *@param chgroup channel group for which the matrix needs to be calculated
702  */
704  WMAProChannelGrp *chgroup)
705 {
706  int i;
707  int offset = 0;
708  int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
709  memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
710  s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
711 
712  for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
713  rotation_offset[i] = get_bits(&s->gb, 6);
714 
715  for (i = 0; i < chgroup->num_channels; i++)
716  chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
717  get_bits1(&s->gb) ? 1.0 : -1.0;
718 
719  for (i = 1; i < chgroup->num_channels; i++) {
720  int x;
721  for (x = 0; x < i; x++) {
722  int y;
723  for (y = 0; y < i + 1; y++) {
724  float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
725  float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
726  int n = rotation_offset[offset + x];
727  float sinv;
728  float cosv;
729 
730  if (n < 32) {
731  sinv = sin64[n];
732  cosv = sin64[32 - n];
733  } else {
734  sinv = sin64[64 - n];
735  cosv = -sin64[n - 32];
736  }
737 
738  chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
739  (v1 * sinv) - (v2 * cosv);
740  chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
741  (v1 * cosv) + (v2 * sinv);
742  }
743  }
744  offset += i;
745  }
746 }
747 
748 /**
749  *@brief Decode channel transformation parameters
750  *@param s codec context
751  *@return >= 0 in case of success, < 0 in case of bitstream errors
752  */
754 {
755  int i;
756  /* should never consume more than 1921 bits for the 8 channel case
757  * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
758  * + MAX_CHANNELS + MAX_BANDS + 1)
759  */
760 
761  /** in the one channel case channel transforms are pointless */
762  s->num_chgroups = 0;
763  if (s->avctx->channels > 1) {
764  int remaining_channels = s->channels_for_cur_subframe;
765 
766  if (get_bits1(&s->gb)) {
768  "Channel transform bit");
769  return AVERROR_PATCHWELCOME;
770  }
771 
772  for (s->num_chgroups = 0; remaining_channels &&
774  WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
775  float** channel_data = chgroup->channel_data;
776  chgroup->num_channels = 0;
777  chgroup->transform = 0;
778 
779  /** decode channel mask */
780  if (remaining_channels > 2) {
781  for (i = 0; i < s->channels_for_cur_subframe; i++) {
782  int channel_idx = s->channel_indexes_for_cur_subframe[i];
783  if (!s->channel[channel_idx].grouped
784  && get_bits1(&s->gb)) {
785  ++chgroup->num_channels;
786  s->channel[channel_idx].grouped = 1;
787  *channel_data++ = s->channel[channel_idx].coeffs;
788  }
789  }
790  } else {
791  chgroup->num_channels = remaining_channels;
792  for (i = 0; i < s->channels_for_cur_subframe; i++) {
793  int channel_idx = s->channel_indexes_for_cur_subframe[i];
794  if (!s->channel[channel_idx].grouped)
795  *channel_data++ = s->channel[channel_idx].coeffs;
796  s->channel[channel_idx].grouped = 1;
797  }
798  }
799 
800  /** decode transform type */
801  if (chgroup->num_channels == 2) {
802  if (get_bits1(&s->gb)) {
803  if (get_bits1(&s->gb)) {
805  "Unknown channel transform type");
806  return AVERROR_PATCHWELCOME;
807  }
808  } else {
809  chgroup->transform = 1;
810  if (s->avctx->channels == 2) {
811  chgroup->decorrelation_matrix[0] = 1.0;
812  chgroup->decorrelation_matrix[1] = -1.0;
813  chgroup->decorrelation_matrix[2] = 1.0;
814  chgroup->decorrelation_matrix[3] = 1.0;
815  } else {
816  /** cos(pi/4) */
817  chgroup->decorrelation_matrix[0] = 0.70703125;
818  chgroup->decorrelation_matrix[1] = -0.70703125;
819  chgroup->decorrelation_matrix[2] = 0.70703125;
820  chgroup->decorrelation_matrix[3] = 0.70703125;
821  }
822  }
823  } else if (chgroup->num_channels > 2) {
824  if (get_bits1(&s->gb)) {
825  chgroup->transform = 1;
826  if (get_bits1(&s->gb)) {
827  decode_decorrelation_matrix(s, chgroup);
828  } else {
829  /** FIXME: more than 6 coupled channels not supported */
830  if (chgroup->num_channels > 6) {
832  "Coupled channels > 6");
833  } else {
834  memcpy(chgroup->decorrelation_matrix,
836  chgroup->num_channels * chgroup->num_channels *
837  sizeof(*chgroup->decorrelation_matrix));
838  }
839  }
840  }
841  }
842 
843  /** decode transform on / off */
844  if (chgroup->transform) {
845  if (!get_bits1(&s->gb)) {
846  int i;
847  /** transform can be enabled for individual bands */
848  for (i = 0; i < s->num_bands; i++) {
849  chgroup->transform_band[i] = get_bits1(&s->gb);
850  }
851  } else {
852  memset(chgroup->transform_band, 1, s->num_bands);
853  }
854  }
855  remaining_channels -= chgroup->num_channels;
856  }
857  }
858  return 0;
859 }
860 
861 /**
862  *@brief Extract the coefficients from the bitstream.
863  *@param s codec context
864  *@param c current channel number
865  *@return 0 on success, < 0 in case of bitstream errors
866  */
867 static int decode_coeffs(WMAProDecodeCtx *s, int c)
868 {
869  /* Integers 0..15 as single-precision floats. The table saves a
870  costly int to float conversion, and storing the values as
871  integers allows fast sign-flipping. */
872  static const uint32_t fval_tab[16] = {
873  0x00000000, 0x3f800000, 0x40000000, 0x40400000,
874  0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
875  0x41000000, 0x41100000, 0x41200000, 0x41300000,
876  0x41400000, 0x41500000, 0x41600000, 0x41700000,
877  };
878  int vlctable;
879  VLC* vlc;
880  WMAProChannelCtx* ci = &s->channel[c];
881  int rl_mode = 0;
882  int cur_coeff = 0;
883  int num_zeros = 0;
884  const uint16_t* run;
885  const float* level;
886 
887  ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
888 
889  vlctable = get_bits1(&s->gb);
890  vlc = &coef_vlc[vlctable];
891 
892  if (vlctable) {
893  run = coef1_run;
894  level = coef1_level;
895  } else {
896  run = coef0_run;
897  level = coef0_level;
898  }
899 
900  /** decode vector coefficients (consumes up to 167 bits per iteration for
901  4 vector coded large values) */
902  while ((s->transmit_num_vec_coeffs || !rl_mode) &&
903  (cur_coeff + 3 < ci->num_vec_coeffs)) {
904  uint32_t vals[4];
905  int i;
906  unsigned int idx;
907 
908  idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
909 
910  if (idx == HUFF_VEC4_SIZE - 1) {
911  for (i = 0; i < 4; i += 2) {
912  idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
913  if (idx == HUFF_VEC2_SIZE - 1) {
914  uint32_t v0, v1;
915  v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
916  if (v0 == HUFF_VEC1_SIZE - 1)
917  v0 += ff_wma_get_large_val(&s->gb);
918  v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
919  if (v1 == HUFF_VEC1_SIZE - 1)
920  v1 += ff_wma_get_large_val(&s->gb);
921  vals[i ] = av_float2int(v0);
922  vals[i+1] = av_float2int(v1);
923  } else {
924  vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
925  vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
926  }
927  }
928  } else {
929  vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
930  vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
931  vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
932  vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
933  }
934 
935  /** decode sign */
936  for (i = 0; i < 4; i++) {
937  if (vals[i]) {
938  uint32_t sign = get_bits1(&s->gb) - 1;
939  AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
940  num_zeros = 0;
941  } else {
942  ci->coeffs[cur_coeff] = 0;
943  /** switch to run level mode when subframe_len / 128 zeros
944  were found in a row */
945  rl_mode |= (++num_zeros > s->subframe_len >> 8);
946  }
947  ++cur_coeff;
948  }
949  }
950 
951  /** decode run level coded coefficients */
952  if (cur_coeff < s->subframe_len) {
953  memset(&ci->coeffs[cur_coeff], 0,
954  sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
955  if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
956  level, run, 1, ci->coeffs,
957  cur_coeff, s->subframe_len,
958  s->subframe_len, s->esc_len, 0))
959  return AVERROR_INVALIDDATA;
960  }
961 
962  return 0;
963 }
964 
965 /**
966  *@brief Extract scale factors from the bitstream.
967  *@param s codec context
968  *@return 0 on success, < 0 in case of bitstream errors
969  */
971 {
972  int i;
973 
974  /** should never consume more than 5344 bits
975  * MAX_CHANNELS * (1 + MAX_BANDS * 23)
976  */
977 
978  for (i = 0; i < s->channels_for_cur_subframe; i++) {
980  int* sf;
981  int* sf_end;
983  sf_end = s->channel[c].scale_factors + s->num_bands;
984 
985  /** resample scale factors for the new block size
986  * as the scale factors might need to be resampled several times
987  * before some new values are transmitted, a backup of the last
988  * transmitted scale factors is kept in saved_scale_factors
989  */
990  if (s->channel[c].reuse_sf) {
991  const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
992  int b;
993  for (b = 0; b < s->num_bands; b++)
994  s->channel[c].scale_factors[b] =
995  s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
996  }
997 
998  if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
999 
1000  if (!s->channel[c].reuse_sf) {
1001  int val;
1002  /** decode DPCM coded scale factors */
1003  s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1004  val = 45 / s->channel[c].scale_factor_step;
1005  for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1006  val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1007  *sf = val;
1008  }
1009  } else {
1010  int i;
1011  /** run level decode differences to the resampled factors */
1012  for (i = 0; i < s->num_bands; i++) {
1013  int idx;
1014  int skip;
1015  int val;
1016  int sign;
1017 
1018  idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1019 
1020  if (!idx) {
1021  uint32_t code = get_bits(&s->gb, 14);
1022  val = code >> 6;
1023  sign = (code & 1) - 1;
1024  skip = (code & 0x3f) >> 1;
1025  } else if (idx == 1) {
1026  break;
1027  } else {
1028  skip = scale_rl_run[idx];
1029  val = scale_rl_level[idx];
1030  sign = get_bits1(&s->gb)-1;
1031  }
1032 
1033  i += skip;
1034  if (i >= s->num_bands) {
1036  "invalid scale factor coding\n");
1037  return AVERROR_INVALIDDATA;
1038  }
1039  s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1040  }
1041  }
1042  /** swap buffers */
1044  s->channel[c].table_idx = s->table_idx;
1045  s->channel[c].reuse_sf = 1;
1046  }
1047 
1048  /** calculate new scale factor maximum */
1050  for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1051  s->channel[c].max_scale_factor =
1052  FFMAX(s->channel[c].max_scale_factor, *sf);
1053  }
1054 
1055  }
1056  return 0;
1057 }
1058 
1059 /**
1060  *@brief Reconstruct the individual channel data.
1061  *@param s codec context
1062  */
1064 {
1065  int i;
1066 
1067  for (i = 0; i < s->num_chgroups; i++) {
1068  if (s->chgroup[i].transform) {
1069  float data[WMAPRO_MAX_CHANNELS];
1070  const int num_channels = s->chgroup[i].num_channels;
1071  float** ch_data = s->chgroup[i].channel_data;
1072  float** ch_end = ch_data + num_channels;
1073  const int8_t* tb = s->chgroup[i].transform_band;
1074  int16_t* sfb;
1075 
1076  /** multichannel decorrelation */
1077  for (sfb = s->cur_sfb_offsets;
1078  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1079  int y;
1080  if (*tb++ == 1) {
1081  /** multiply values with the decorrelation_matrix */
1082  for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1083  const float* mat = s->chgroup[i].decorrelation_matrix;
1084  const float* data_end = data + num_channels;
1085  float* data_ptr = data;
1086  float** ch;
1087 
1088  for (ch = ch_data; ch < ch_end; ch++)
1089  *data_ptr++ = (*ch)[y];
1090 
1091  for (ch = ch_data; ch < ch_end; ch++) {
1092  float sum = 0;
1093  data_ptr = data;
1094  while (data_ptr < data_end)
1095  sum += *data_ptr++ * *mat++;
1096 
1097  (*ch)[y] = sum;
1098  }
1099  }
1100  } else if (s->avctx->channels == 2) {
1101  int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1102  s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1103  ch_data[0] + sfb[0],
1104  181.0 / 128, len);
1105  s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1106  ch_data[1] + sfb[0],
1107  181.0 / 128, len);
1108  }
1109  }
1110  }
1111  }
1112 }
1113 
1114 /**
1115  *@brief Apply sine window and reconstruct the output buffer.
1116  *@param s codec context
1117  */
1119 {
1120  int i;
1121  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1122  int c = s->channel_indexes_for_cur_subframe[i];
1123  const float* window;
1124  int winlen = s->channel[c].prev_block_len;
1125  float* start = s->channel[c].coeffs - (winlen >> 1);
1126 
1127  if (s->subframe_len < winlen) {
1128  start += (winlen - s->subframe_len) >> 1;
1129  winlen = s->subframe_len;
1130  }
1131 
1132  window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1133 
1134  winlen >>= 1;
1135 
1136  s->fdsp->vector_fmul_window(start, start, start + winlen,
1137  window, winlen);
1138 
1140  }
1141 }
1142 
1143 /**
1144  *@brief Decode a single subframe (block).
1145  *@param s codec context
1146  *@return 0 on success, < 0 when decoding failed
1147  */
1149 {
1150  int offset = s->samples_per_frame;
1151  int subframe_len = s->samples_per_frame;
1152  int i;
1153  int total_samples = s->samples_per_frame * s->avctx->channels;
1154  int transmit_coeffs = 0;
1155  int cur_subwoofer_cutoff;
1156 
1157  s->subframe_offset = get_bits_count(&s->gb);
1158 
1159  /** reset channel context and find the next block offset and size
1160  == the next block of the channel with the smallest number of
1161  decoded samples
1162  */
1163  for (i = 0; i < s->avctx->channels; i++) {
1164  s->channel[i].grouped = 0;
1165  if (offset > s->channel[i].decoded_samples) {
1166  offset = s->channel[i].decoded_samples;
1167  subframe_len =
1169  }
1170  }
1171 
1172  ff_dlog(s->avctx,
1173  "processing subframe with offset %i len %i\n", offset, subframe_len);
1174 
1175  /** get a list of all channels that contain the estimated block */
1177  for (i = 0; i < s->avctx->channels; i++) {
1178  const int cur_subframe = s->channel[i].cur_subframe;
1179  /** subtract already processed samples */
1180  total_samples -= s->channel[i].decoded_samples;
1181 
1182  /** and count if there are multiple subframes that match our profile */
1183  if (offset == s->channel[i].decoded_samples &&
1184  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1185  total_samples -= s->channel[i].subframe_len[cur_subframe];
1186  s->channel[i].decoded_samples +=
1187  s->channel[i].subframe_len[cur_subframe];
1190  }
1191  }
1192 
1193  /** check if the frame will be complete after processing the
1194  estimated block */
1195  if (!total_samples)
1196  s->parsed_all_subframes = 1;
1197 
1198 
1199  ff_dlog(s->avctx, "subframe is part of %i channels\n",
1201 
1202  /** calculate number of scale factor bands and their offsets */
1203  s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1204  s->num_bands = s->num_sfb[s->table_idx];
1206  cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1207 
1208  /** configure the decoder for the current subframe */
1209  offset += s->samples_per_frame >> 1;
1210 
1211  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1212  int c = s->channel_indexes_for_cur_subframe[i];
1213 
1214  s->channel[c].coeffs = &s->channel[c].out[offset];
1215  }
1216 
1217  s->subframe_len = subframe_len;
1218  s->esc_len = av_log2(s->subframe_len - 1) + 1;
1219 
1220  /** skip extended header if any */
1221  if (get_bits1(&s->gb)) {
1222  int num_fill_bits;
1223  if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1224  int len = get_bits(&s->gb, 4);
1225  num_fill_bits = get_bitsz(&s->gb, len) + 1;
1226  }
1227 
1228  if (num_fill_bits >= 0) {
1229  if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1230  av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1231  return AVERROR_INVALIDDATA;
1232  }
1233 
1234  skip_bits_long(&s->gb, num_fill_bits);
1235  }
1236  }
1237 
1238  /** no idea for what the following bit is used */
1239  if (get_bits1(&s->gb)) {
1240  avpriv_request_sample(s->avctx, "Reserved bit");
1241  return AVERROR_PATCHWELCOME;
1242  }
1243 
1244 
1245  if (decode_channel_transform(s) < 0)
1246  return AVERROR_INVALIDDATA;
1247 
1248 
1249  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1250  int c = s->channel_indexes_for_cur_subframe[i];
1251  if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1252  transmit_coeffs = 1;
1253  }
1254 
1256  if (transmit_coeffs) {
1257  int step;
1258  int quant_step = 90 * s->bits_per_sample >> 4;
1259 
1260  /** decode number of vector coded coefficients */
1261  if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1262  int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1263  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1264  int c = s->channel_indexes_for_cur_subframe[i];
1265  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1266  if (num_vec_coeffs > s->subframe_len) {
1267  av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1268  return AVERROR_INVALIDDATA;
1269  }
1270  av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1271  s->channel[c].num_vec_coeffs = num_vec_coeffs;
1272  }
1273  } else {
1274  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1275  int c = s->channel_indexes_for_cur_subframe[i];
1277  }
1278  }
1279  /** decode quantization step */
1280  step = get_sbits(&s->gb, 6);
1281  quant_step += step;
1282  if (step == -32 || step == 31) {
1283  const int sign = (step == 31) - 1;
1284  int quant = 0;
1285  while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1286  (step = get_bits(&s->gb, 5)) == 31) {
1287  quant += 31;
1288  }
1289  quant_step += ((quant + step) ^ sign) - sign;
1290  }
1291  if (quant_step < 0) {
1292  av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1293  }
1294 
1295  /** decode quantization step modifiers for every channel */
1296 
1297  if (s->channels_for_cur_subframe == 1) {
1298  s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1299  } else {
1300  int modifier_len = get_bits(&s->gb, 3);
1301  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1302  int c = s->channel_indexes_for_cur_subframe[i];
1303  s->channel[c].quant_step = quant_step;
1304  if (get_bits1(&s->gb)) {
1305  if (modifier_len) {
1306  s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1307  } else
1308  ++s->channel[c].quant_step;
1309  }
1310  }
1311  }
1312 
1313  /** decode scale factors */
1314  if (decode_scale_factors(s) < 0)
1315  return AVERROR_INVALIDDATA;
1316  }
1317 
1318  ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1319  get_bits_count(&s->gb) - s->subframe_offset);
1320 
1321  /** parse coefficients */
1322  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1323  int c = s->channel_indexes_for_cur_subframe[i];
1324  if (s->channel[c].transmit_coefs &&
1325  get_bits_count(&s->gb) < s->num_saved_bits) {
1326  decode_coeffs(s, c);
1327  } else
1328  memset(s->channel[c].coeffs, 0,
1329  sizeof(*s->channel[c].coeffs) * subframe_len);
1330  }
1331 
1332  ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1333  get_bits_count(&s->gb) - s->subframe_offset);
1334 
1335  if (transmit_coeffs) {
1336  FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1337  /** reconstruct the per channel data */
1339  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1340  int c = s->channel_indexes_for_cur_subframe[i];
1341  const int* sf = s->channel[c].scale_factors;
1342  int b;
1343 
1344  if (c == s->lfe_channel)
1345  memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1346  (subframe_len - cur_subwoofer_cutoff));
1347 
1348  /** inverse quantization and rescaling */
1349  for (b = 0; b < s->num_bands; b++) {
1350  const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1351  const int exp = s->channel[c].quant_step -
1352  (s->channel[c].max_scale_factor - *sf++) *
1353  s->channel[c].scale_factor_step;
1354  const float quant = ff_exp10(exp / 20.0);
1355  int start = s->cur_sfb_offsets[b];
1356  s->fdsp->vector_fmul_scalar(s->tmp + start,
1357  s->channel[c].coeffs + start,
1358  quant, end - start);
1359  }
1360 
1361  /** apply imdct (imdct_half == DCTIV with reverse) */
1362  mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1363  }
1364  }
1365 
1366  /** window and overlapp-add */
1367  wmapro_window(s);
1368 
1369  /** handled one subframe */
1370  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1371  int c = s->channel_indexes_for_cur_subframe[i];
1372  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1373  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1374  return AVERROR_INVALIDDATA;
1375  }
1376  ++s->channel[c].cur_subframe;
1377  }
1378 
1379  return 0;
1380 }
1381 
1382 /**
1383  *@brief Decode one WMA frame.
1384  *@param s codec context
1385  *@return 0 if the trailer bit indicates that this is the last frame,
1386  * 1 if there are additional frames
1387  */
1388 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1389 {
1390  AVCodecContext *avctx = s->avctx;
1391  GetBitContext* gb = &s->gb;
1392  int more_frames = 0;
1393  int len = 0;
1394  int i, ret;
1395 
1396  /** get frame length */
1397  if (s->len_prefix)
1398  len = get_bits(gb, s->log2_frame_size);
1399 
1400  ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1401 
1402  /** decode tile information */
1403  if (decode_tilehdr(s)) {
1404  s->packet_loss = 1;
1405  return 0;
1406  }
1407 
1408  /** read postproc transform */
1409  if (s->avctx->channels > 1 && get_bits1(gb)) {
1410  if (get_bits1(gb)) {
1411  for (i = 0; i < avctx->channels * avctx->channels; i++)
1412  skip_bits(gb, 4);
1413  }
1414  }
1415 
1416  /** read drc info */
1417  if (s->dynamic_range_compression) {
1418  s->drc_gain = get_bits(gb, 8);
1419  ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1420  }
1421 
1422  /** no idea what these are for, might be the number of samples
1423  that need to be skipped at the beginning or end of a stream */
1424  if (get_bits1(gb)) {
1425  int av_unused skip;
1426 
1427  /** usually true for the first frame */
1428  if (get_bits1(gb)) {
1429  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1430  ff_dlog(s->avctx, "start skip: %i\n", skip);
1431  }
1432 
1433  /** sometimes true for the last frame */
1434  if (get_bits1(gb)) {
1435  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1436  ff_dlog(s->avctx, "end skip: %i\n", skip);
1437  }
1438 
1439  }
1440 
1441  ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1442  get_bits_count(gb) - s->frame_offset);
1443 
1444  /** reset subframe states */
1445  s->parsed_all_subframes = 0;
1446  for (i = 0; i < avctx->channels; i++) {
1447  s->channel[i].decoded_samples = 0;
1448  s->channel[i].cur_subframe = 0;
1449  s->channel[i].reuse_sf = 0;
1450  }
1451 
1452  /** decode all subframes */
1453  while (!s->parsed_all_subframes) {
1454  if (decode_subframe(s) < 0) {
1455  s->packet_loss = 1;
1456  return 0;
1457  }
1458  }
1459 
1460  /* get output buffer */
1461  frame->nb_samples = s->samples_per_frame;
1462  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1463  s->packet_loss = 1;
1464  return 0;
1465  }
1466 
1467  /** copy samples to the output buffer */
1468  for (i = 0; i < avctx->channels; i++)
1469  memcpy(frame->extended_data[i], s->channel[i].out,
1470  s->samples_per_frame * sizeof(*s->channel[i].out));
1471 
1472  for (i = 0; i < avctx->channels; i++) {
1473  /** reuse second half of the IMDCT output for the next frame */
1474  memcpy(&s->channel[i].out[0],
1475  &s->channel[i].out[s->samples_per_frame],
1476  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1477  }
1478 
1479  if (s->skip_frame) {
1480  s->skip_frame = 0;
1481  *got_frame_ptr = 0;
1482  av_frame_unref(frame);
1483  } else {
1484  *got_frame_ptr = 1;
1485  }
1486 
1487  if (s->len_prefix) {
1488  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1489  /** FIXME: not sure if this is always an error */
1491  "frame[%"PRIu32"] would have to skip %i bits\n",
1492  s->frame_num,
1493  len - (get_bits_count(gb) - s->frame_offset) - 1);
1494  s->packet_loss = 1;
1495  return 0;
1496  }
1497 
1498  /** skip the rest of the frame data */
1499  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1500  } else {
1501  while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1502  }
1503  }
1504 
1505  /** decode trailer bit */
1506  more_frames = get_bits1(gb);
1507 
1508  ++s->frame_num;
1509  return more_frames;
1510 }
1511 
1512 /**
1513  *@brief Calculate remaining input buffer length.
1514  *@param s codec context
1515  *@param gb bitstream reader context
1516  *@return remaining size in bits
1517  */
1519 {
1520  return s->buf_bit_size - get_bits_count(gb);
1521 }
1522 
1523 /**
1524  *@brief Fill the bit reservoir with a (partial) frame.
1525  *@param s codec context
1526  *@param gb bitstream reader context
1527  *@param len length of the partial frame
1528  *@param append decides whether to reset the buffer or not
1529  */
1531  int append)
1532 {
1533  int buflen;
1534 
1535  /** when the frame data does not need to be concatenated, the input buffer
1536  is reset and additional bits from the previous frame are copied
1537  and skipped later so that a fast byte copy is possible */
1538 
1539  if (!append) {
1540  s->frame_offset = get_bits_count(gb) & 7;
1541  s->num_saved_bits = s->frame_offset;
1543  }
1544 
1545  buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1546 
1547  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1548  avpriv_request_sample(s->avctx, "Too small input buffer");
1549  s->packet_loss = 1;
1550  return;
1551  }
1552 
1553  av_assert0(len <= put_bits_left(&s->pb));
1554 
1555  s->num_saved_bits += len;
1556  if (!append) {
1557  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1558  s->num_saved_bits);
1559  } else {
1560  int align = 8 - (get_bits_count(gb) & 7);
1561  align = FFMIN(align, len);
1562  put_bits(&s->pb, align, get_bits(gb, align));
1563  len -= align;
1564  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1565  }
1566  skip_bits_long(gb, len);
1567 
1568  {
1569  PutBitContext tmp = s->pb;
1570  flush_put_bits(&tmp);
1571  }
1572 
1574  skip_bits(&s->gb, s->frame_offset);
1575 }
1576 
1577 /**
1578  *@brief Decode a single WMA packet.
1579  *@param avctx codec context
1580  *@param data the output buffer
1581  *@param avpkt input packet
1582  *@return number of bytes that were read from the input buffer
1583  */
1584 static int decode_packet(AVCodecContext *avctx, void *data,
1585  int *got_frame_ptr, AVPacket* avpkt)
1586 {
1587  WMAProDecodeCtx *s = avctx->priv_data;
1588  GetBitContext* gb = &s->pgb;
1589  const uint8_t* buf = avpkt->data;
1590  int buf_size = avpkt->size;
1591  int num_bits_prev_frame;
1592  int packet_sequence_number;
1593 
1594  *got_frame_ptr = 0;
1595 
1596  if (s->skip_packets > 0) {
1597  s->skip_packets--;
1598  return FFMIN(avpkt->size, avctx->block_align);
1599  }
1600 
1601  if (s->packet_done || s->packet_loss) {
1602  s->packet_done = 0;
1603 
1604  /** sanity check for the buffer length */
1605  if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1606  av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1607  buf_size, avctx->block_align);
1608  return AVERROR_INVALIDDATA;
1609  }
1610 
1611  if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1612  s->next_packet_start = buf_size - avctx->block_align;
1613  buf_size = avctx->block_align;
1614  } else {
1615  s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1616  buf_size = FFMIN(buf_size, avctx->block_align);
1617  }
1618  s->buf_bit_size = buf_size << 3;
1619 
1620  /** parse packet header */
1621  init_get_bits(gb, buf, s->buf_bit_size);
1622  if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1623  packet_sequence_number = get_bits(gb, 4);
1624  skip_bits(gb, 2);
1625  } else {
1626  s->num_frames = get_bits(gb, 6);
1627  packet_sequence_number = 0;
1628  }
1629 
1630  /** get number of bits that need to be added to the previous frame */
1631  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1632  if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1633  skip_bits(gb, 3);
1634  s->skip_packets = get_bits(gb, 8);
1635  }
1636 
1637  ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1638  num_bits_prev_frame);
1639 
1640  /** check for packet loss */
1641  if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
1642  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1643  s->packet_loss = 1;
1644  av_log(avctx, AV_LOG_ERROR,
1645  "Packet loss detected! seq %"PRIx8" vs %x\n",
1646  s->packet_sequence_number, packet_sequence_number);
1647  }
1648  s->packet_sequence_number = packet_sequence_number;
1649 
1650  if (num_bits_prev_frame > 0) {
1651  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1652  if (num_bits_prev_frame >= remaining_packet_bits) {
1653  num_bits_prev_frame = remaining_packet_bits;
1654  s->packet_done = 1;
1655  }
1656 
1657  /** append the previous frame data to the remaining data from the
1658  previous packet to create a full frame */
1659  save_bits(s, gb, num_bits_prev_frame, 1);
1660  ff_dlog(avctx, "accumulated %x bits of frame data\n",
1661  s->num_saved_bits - s->frame_offset);
1662 
1663  /** decode the cross packet frame if it is valid */
1664  if (!s->packet_loss)
1665  decode_frame(s, data, got_frame_ptr);
1666  } else if (s->num_saved_bits - s->frame_offset) {
1667  ff_dlog(avctx, "ignoring %x previously saved bits\n",
1668  s->num_saved_bits - s->frame_offset);
1669  }
1670 
1671  if (s->packet_loss) {
1672  /** reset number of saved bits so that the decoder
1673  does not start to decode incomplete frames in the
1674  s->len_prefix == 0 case */
1675  s->num_saved_bits = 0;
1676  s->packet_loss = 0;
1677  }
1678 
1679  } else {
1680  int frame_size;
1681  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1682  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1683  skip_bits(gb, s->packet_offset);
1684  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1685  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1686  frame_size <= remaining_bits(s, gb)) {
1687  save_bits(s, gb, frame_size, 0);
1688  if (!s->packet_loss)
1689  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1690  } else if (!s->len_prefix
1691  && s->num_saved_bits > get_bits_count(&s->gb)) {
1692  /** when the frames do not have a length prefix, we don't know
1693  the compressed length of the individual frames
1694  however, we know what part of a new packet belongs to the
1695  previous frame
1696  therefore we save the incoming packet first, then we append
1697  the "previous frame" data from the next packet so that
1698  we get a buffer that only contains full frames */
1699  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1700  } else
1701  s->packet_done = 1;
1702  }
1703 
1704  if (remaining_bits(s, gb) < 0) {
1705  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1706  s->packet_loss = 1;
1707  }
1708 
1709  if (s->packet_done && !s->packet_loss &&
1710  remaining_bits(s, gb) > 0) {
1711  /** save the rest of the data so that it can be decoded
1712  with the next packet */
1713  save_bits(s, gb, remaining_bits(s, gb), 0);
1714  }
1715 
1716  s->packet_offset = get_bits_count(gb) & 7;
1717  if (s->packet_loss)
1718  return AVERROR_INVALIDDATA;
1719 
1720  return get_bits_count(gb) >> 3;
1721 }
1722 
1723 /**
1724  *@brief Clear decoder buffers (for seeking).
1725  *@param avctx codec context
1726  */
1727 static void flush(AVCodecContext *avctx)
1728 {
1729  WMAProDecodeCtx *s = avctx->priv_data;
1730  int i;
1731  /** reset output buffer as a part of it is used during the windowing of a
1732  new frame */
1733  for (i = 0; i < avctx->channels; i++)
1734  memset(s->channel[i].out, 0, s->samples_per_frame *
1735  sizeof(*s->channel[i].out));
1736  s->packet_loss = 1;
1737 }
1738 
1739 
1740 /**
1741  *@brief wmapro decoder
1742  */
1744  .name = "wmapro",
1745  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1746  .type = AVMEDIA_TYPE_AUDIO,
1747  .id = AV_CODEC_ID_WMAPRO,
1748  .priv_data_size = sizeof(WMAProDecodeCtx),
1749  .init = decode_init,
1750  .close = decode_end,
1751  .decode = decode_packet,
1752  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1753  .flush = flush,
1754  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1756 };
1757 
1759  .name = "xma1",
1760  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
1761  .type = AVMEDIA_TYPE_AUDIO,
1762  .id = AV_CODEC_ID_XMA1,
1763  .priv_data_size = sizeof(WMAProDecodeCtx),
1764  .init = decode_init,
1765  .close = decode_end,
1766  .decode = decode_packet,
1767  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1768  .flush = flush,
1769  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1771 };
1772 
1774  .name = "xma2",
1775  .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
1776  .type = AVMEDIA_TYPE_AUDIO,
1777  .id = AV_CODEC_ID_XMA2,
1778  .priv_data_size = sizeof(WMAProDecodeCtx),
1779  .init = decode_init,
1780  .close = decode_end,
1781  .decode = decode_packet,
1782  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1783  .flush = flush,
1784  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1786 };
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:612
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
#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:247
#define WMAPRO_BLOCK_MIN_SIZE
minimum block size
Definition: wmaprodec.c:112
uint16_t min_samples_per_subframe
Definition: wmaprodec.c:194
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:204
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVCodecContext * avctx
codec context for av_log
Definition: wmaprodec.c:174
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:57
uint32_t decode_flags
used compression features
Definition: wmaprodec.c:184
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2918
int size
Definition: avcodec.h:1601
const char * b
Definition: vf_curves.c:113
static const uint16_t vec4_huffcodes[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:421
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:65
int8_t scale_factor_step
scaling step for the current subframe
Definition: wmaprodec.c:147
const uint8_t * buffer
Definition: get_bits.h:56
int av_log2(unsigned v)
Definition: intmath.c:26
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)
Decode run level compressed coefficients.
Definition: wma.c:438
uint16_t log2_frame_size
Definition: wmaprodec.c:189
static const uint8_t scale_huffbits[HUFF_SCALE_SIZE]
Definition: wmaprodata.h:70
uint8_t table_idx
index in sf_offsets for the scale factor reference block
Definition: wmaprodec.c:152
int16_t * cur_sfb_offsets
sfb offsets for the current block
Definition: wmaprodec.c:227
GLfloat v0
Definition: opengl_enc.c:107
#define VLCBITS
Definition: wmaprodec.c:117
uint8_t run
Definition: svq3.c:206
WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]
channel group information
Definition: wmaprodec.c:232
PutBitContext pb
context for filling the frame_data buffer
Definition: wmaprodec.c:178
#define SCALEVLCBITS
Definition: wmaprodec.c:118
AVCodec.
Definition: avcodec.h:3589
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:2474
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:232
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:242
static const uint8_t scale_rl_run[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:140
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single WMA packet.
Definition: wmaprodec.c:1584
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int frame_offset
frame offset in the bit reservoir
Definition: wmaprodec.c:206
AVFloatDSPContext * fdsp
Definition: wmaprodec.c:175
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:103
static const float coef1_level[HUFF_COEF1_SIZE]
Definition: wmaprodata.h:396
uint16_t subframe_offset[MAX_SUBFRAMES]
subframe positions in the current frame
Definition: wmaprodec.c:141
uint8_t bits
Definition: crc.c:296
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2445
static void inverse_channel_transform(WMAProDecodeCtx *s)
Reconstruct the individual channel data.
Definition: wmaprodec.c:1063
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
#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 * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1790
uint8_t packet_sequence_number
current packet number
Definition: wmaprodec.c:204
uint8_t drc_gain
gain for the DRC tool
Definition: wmaprodec.c:217
uint8_t dynamic_range_compression
frame contains DRC data
Definition: wmaprodec.c:186
static AVFrame * frame
static uint8_t * append(uint8_t *buf, const uint8_t *src, int size)
#define MAX_FRAMESIZE
maximum compressed frame size
Definition: wmaprodec.c:108
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
int16_t prev_block_len
length of the previous block
Definition: wmaprodec.c:137
WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]
per channel data
Definition: wmaprodec.c:234
GetBitContext gb
bitstream reader context
Definition: wmaprodec.c:215
uint8_t * data
Definition: avcodec.h:1600
uint8_t grouped
channel is part of a group
Definition: wmaprodec.c:144
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
#define WMAPRO_BLOCK_MAX_BITS
log2 of max block size
Definition: wmaprodec.c:111
#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:216
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:568
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:1148
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
#define HUFF_VEC4_SIZE
Definition: wmaprodata.h:419
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]
Definition: wmaprodec.c:224
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1770
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:1758
#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:3596
#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:1743
#define FFMAX(a, b)
Definition: common.h:94
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
Decode the subframe length.
Definition: wmaprodec.c:561
static const uint8_t coef1_huffbits[555]
Definition: wmadata.h:335
int8_t exp
Definition: eval.c:64
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:2488
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 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 void flush(AVCodecContext *avctx)
Clear decoder buffers (for seeking).
Definition: wmaprodec.c:1727
static const uint16_t symbol_to_vec4[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:540
static SDL_Window * window
Definition: ffplay.c:364
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Extract the coefficients from the bitstream.
Definition: wmaprodec.c:867
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:885
uint8_t skip_packets
Definition: wmaprodec.c:210
#define FFMIN(a, b)
Definition: common.h:96
uint32_t frame_num
current frame number (not used for decoding)
Definition: wmaprodec.c:213
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:1773
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:282
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:1530
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:535
int8_t transmit_num_vec_coeffs
number of vector coded coefficients is part of the bitstream
Definition: wmaprodec.c:226
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:69
int n
Definition: avisynth_c.h:684
#define MAX_BANDS
max number of scale factor bands
Definition: wmaprodec.c:107
const float * windows[WMAPRO_BLOCK_SIZES]
windows for the different block sizes
Definition: wmaprodec.c:181
uint8_t subframe_len_bits
number of bits used for the subframe length
Definition: wmaprodec.c:192
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:1822
static VLC vec2_vlc
2 coefficients per symbol
Definition: wmaprodec.c:128
int8_t parsed_all_subframes
all subframes decoded?
Definition: wmaprodec.c:219
Libavcodec external API header.
channel group for channel transformations
Definition: wmaprodec.c:161
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define VEC1MAXDEPTH
Definition: wmaprodec.c:121
enum AVCodecID codec_id
Definition: avcodec.h:1692
int16_t subframe_len
current subframe length
Definition: wmaprodec.c:222
int sample_rate
samples per second
Definition: avcodec.h:2437
#define WMAPRO_BLOCK_SIZES
possible block sizes
Definition: wmaprodec.c:114
int debug
debug
Definition: avcodec.h:2915
static const uint8_t vec4_huffbits[HUFF_VEC4_SIZE]
Definition: wmaprodata.h:440
main external API structure.
Definition: avcodec.h:1675
static const uint8_t symbol_to_vec2[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:557
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:934
tables for wmapro decoding
void * buf
Definition: avisynth_c.h:690
#define VEC4MAXDEPTH
Definition: wmaprodec.c:119
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
int extradata_size
Definition: avcodec.h:1791
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:299
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
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:1008
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:406
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:970
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:274
uint8_t transmit_coefs
Definition: wmaprodec.c:138
static VLC sf_rl_vlc
scale factor run length vlc
Definition: wmaprodec.c:126
float * coeffs
pointer to the subframe decode buffer
Definition: wmaprodec.c:153
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:119
uint8_t cur_subframe
current subframe number
Definition: wmaprodec.c:142
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
Calculate remaining input buffer length.
Definition: wmaprodec.c:1518
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:485
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static int decode_channel_transform(WMAProDecodeCtx *s)
Decode channel transformation parameters.
Definition: wmaprodec.c:753
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
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the decoder.
Definition: wmaprodec.c:294
#define PRINT_HEX(a, b)
uint16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
Definition: wmaprodec.c:140
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:750
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:703
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]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static void wmapro_window(WMAProDecodeCtx *s)
Apply sine window and reconstruct the output buffer.
Definition: wmaprodec.c:1118
#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:733
static const uint8_t scale_rl_level[HUFF_SCALE_RL_SIZE]
Definition: wmaprodata.h:150
void * priv_data
Definition: avcodec.h:1717
int len
GetBitContext pgb
bitstream reader context for the packet
Definition: wmaprodec.c:201
int channels
number of audio channels
Definition: avcodec.h:2438
static uint8_t tmp[8]
Definition: des.c:38
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:406
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:1388
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2468
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:231
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the decoder and free all resources.
Definition: wmaprodec.c:261
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1577
#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:241
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:958
int8_t skip_frame
skip output step
Definition: wmaprodec.c:218
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:262
#define av_unused
Definition: attributes.h:126
void AAC_RENAME() ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
#define tb
Definition: regdef.h:68
static const uint8_t vec2_huffbits[HUFF_VEC2_SIZE]
Definition: wmaprodata.h:483
uint8_t num_chgroups
number of channel groups
Definition: wmaprodec.c:231
uint8_t packet_done
set when a packet is fully decoded
Definition: wmaprodec.c:209
bitstream writer API