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 "libavutil/float_dsp.h"
90 #include "libavutil/intfloat.h"
91 #include "libavutil/intreadwrite.h"
92 #include "avcodec.h"
93 #include "internal.h"
94 #include "get_bits.h"
95 #include "put_bits.h"
96 #include "wmaprodata.h"
97 #include "sinewin.h"
98 #include "wma.h"
99 #include "wma_common.h"
100 
101 /** current decoder limitations */
102 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels
103 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
104 #define MAX_BANDS 29 ///< max number of scale factor bands
105 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
106 
107 #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size
108 #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size
109 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS) ///< minimum block size
110 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size
111 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
112 
113 
114 #define VLCBITS 9
115 #define SCALEVLCBITS 8
116 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
117 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
118 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
119 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
120 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
121 
122 static VLC sf_vlc; ///< scale factor DPCM vlc
123 static VLC sf_rl_vlc; ///< scale factor run length vlc
124 static VLC vec4_vlc; ///< 4 coefficients per symbol
125 static VLC vec2_vlc; ///< 2 coefficients per symbol
126 static VLC vec1_vlc; ///< 1 coefficient per symbol
127 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
128 static float sin64[33]; ///< sinus table for decorrelation
129 
130 /**
131  * @brief frame specific decoder context for a single channel
132  */
133 typedef struct {
134  int16_t prev_block_len; ///< length of the previous block
137  uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
138  uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
139  uint8_t cur_subframe; ///< current subframe number
140  uint16_t decoded_samples; ///< number of already processed samples
141  uint8_t grouped; ///< channel is part of a group
142  int quant_step; ///< quantization step for the current subframe
143  int8_t reuse_sf; ///< share scale factors between subframes
144  int8_t scale_factor_step; ///< scaling step for the current subframe
145  int max_scale_factor; ///< maximum scale factor for the current subframe
146  int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
147  int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
148  int* scale_factors; ///< pointer to the scale factor values used for decoding
149  uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
150  float* coeffs; ///< pointer to the subframe decode buffer
151  uint16_t num_vec_coeffs; ///< number of vector coded coefficients
152  DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
154 
155 /**
156  * @brief channel group for channel transformations
157  */
158 typedef struct {
159  uint8_t num_channels; ///< number of channels in the group
160  int8_t transform; ///< transform on / off
161  int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
162  float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
163  float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
165 
166 /**
167  * @brief main decoder context
168  */
169 typedef struct WMAProDecodeCtx {
170  /* generic decoder variables */
171  AVCodecContext* avctx; ///< codec context for av_log
174  FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
175  PutBitContext pb; ///< context for filling the frame_data buffer
176  FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
177  DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
178  float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
179 
180  /* frame size dependent frame information (set during initialization) */
181  uint32_t decode_flags; ///< used compression features
182  uint8_t len_prefix; ///< frame is prefixed with its length
183  uint8_t dynamic_range_compression; ///< frame contains DRC data
184  uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
185  uint16_t samples_per_frame; ///< number of samples to output
186  uint16_t log2_frame_size;
187  int8_t lfe_channel; ///< lfe channel index
189  uint8_t subframe_len_bits; ///< number of bits used for the subframe length
190  uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
192  int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
193  int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
194  int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
195  int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
196 
197  /* packet decode state */
198  GetBitContext pgb; ///< bitstream reader context for the packet
199  int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
200  uint8_t packet_offset; ///< frame offset in the packet
201  uint8_t packet_sequence_number; ///< current packet number
202  int num_saved_bits; ///< saved number of bits
203  int frame_offset; ///< frame offset in the bit reservoir
204  int subframe_offset; ///< subframe offset in the bit reservoir
205  uint8_t packet_loss; ///< set in case of bitstream error
206  uint8_t packet_done; ///< set when a packet is fully decoded
207 
208  /* frame decode state */
209  uint32_t frame_num; ///< current frame number (not used for decoding)
210  GetBitContext gb; ///< bitstream reader context
211  int buf_bit_size; ///< buffer size in bits
212  uint8_t drc_gain; ///< gain for the DRC tool
213  int8_t skip_frame; ///< skip output step
214  int8_t parsed_all_subframes; ///< all subframes decoded?
215 
216  /* subframe/block decode state */
217  int16_t subframe_len; ///< current subframe length
218  int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
220  int8_t num_bands; ///< number of scale factor bands
221  int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
222  int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
223  uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
224  int8_t esc_len; ///< length of escaped coefficients
225 
226  uint8_t num_chgroups; ///< number of channel groups
227  WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
228 
231 
232 
233 /**
234  *@brief helper function to print the most important members of the context
235  *@param s context
236  */
238 {
239 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
240 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
241 
242  PRINT("ed sample bit depth", s->bits_per_sample);
243  PRINT_HEX("ed decode flags", s->decode_flags);
244  PRINT("samples per frame", s->samples_per_frame);
245  PRINT("log2 frame size", s->log2_frame_size);
246  PRINT("max num subframes", s->max_num_subframes);
247  PRINT("len prefix", s->len_prefix);
248  PRINT("num channels", s->avctx->channels);
249 }
250 
251 /**
252  *@brief Uninitialize the decoder and free all resources.
253  *@param avctx codec context
254  *@return 0 on success, < 0 otherwise
255  */
257 {
258  WMAProDecodeCtx *s = avctx->priv_data;
259  int i;
260 
261  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
262  ff_mdct_end(&s->mdct_ctx[i]);
263 
264  return 0;
265 }
266 
267 /**
268  *@brief Initialize the decoder.
269  *@param avctx codec context
270  *@return 0 on success, -1 otherwise
271  */
273 {
274  WMAProDecodeCtx *s = avctx->priv_data;
275  uint8_t *edata_ptr = avctx->extradata;
276  unsigned int channel_mask;
277  int i, bits;
278  int log2_max_num_subframes;
279  int num_possible_block_sizes;
280 
281  if (!avctx->block_align) {
282  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
283  return AVERROR(EINVAL);
284  }
285 
286  s->avctx = avctx;
288 
290 
292 
293  if (avctx->extradata_size >= 18) {
294  s->decode_flags = AV_RL16(edata_ptr+14);
295  channel_mask = AV_RL32(edata_ptr+2);
296  s->bits_per_sample = AV_RL16(edata_ptr);
297  /** dump the extradata */
298  for (i = 0; i < avctx->extradata_size; i++)
299  av_dlog(avctx, "[%x] ", avctx->extradata[i]);
300  av_dlog(avctx, "\n");
301 
302  } else {
303  avpriv_request_sample(avctx, "Unknown extradata size");
304  return AVERROR_PATCHWELCOME;
305  }
306 
307  /** generic init */
308  s->log2_frame_size = av_log2(avctx->block_align) + 4;
309  if (s->log2_frame_size > 25) {
310  avpriv_request_sample(avctx, "Large block align");
311  return AVERROR_PATCHWELCOME;
312  }
313 
314  /** frame info */
315  s->skip_frame = 1; /* skip first frame */
316  s->packet_loss = 1;
317  s->len_prefix = (s->decode_flags & 0x40);
318 
319  /** get frame len */
320  bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
321  if (bits > WMAPRO_BLOCK_MAX_BITS) {
322  avpriv_request_sample(avctx, "14-bit block sizes");
323  return AVERROR_PATCHWELCOME;
324  }
325  s->samples_per_frame = 1 << bits;
326 
327  /** subframe info */
328  log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
329  s->max_num_subframes = 1 << log2_max_num_subframes;
330  if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
331  s->max_subframe_len_bit = 1;
332  s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
333 
334  num_possible_block_sizes = log2_max_num_subframes + 1;
336  s->dynamic_range_compression = (s->decode_flags & 0x80);
337 
338  if (s->max_num_subframes > MAX_SUBFRAMES) {
339  av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
340  s->max_num_subframes);
341  return AVERROR_INVALIDDATA;
342  }
343 
345  av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
347  return AVERROR_INVALIDDATA;
348  }
349 
350  if (s->avctx->sample_rate <= 0) {
351  av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
352  return AVERROR_INVALIDDATA;
353  }
354 
355  if (avctx->channels < 0) {
356  av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
357  avctx->channels);
358  return AVERROR_INVALIDDATA;
359  } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
360  avpriv_request_sample(avctx,
361  "More than %d channels", WMAPRO_MAX_CHANNELS);
362  return AVERROR_PATCHWELCOME;
363  }
364 
365  /** init previous block len */
366  for (i = 0; i < avctx->channels; i++)
368 
369  /** extract lfe channel position */
370  s->lfe_channel = -1;
371 
372  if (channel_mask & 8) {
373  unsigned int mask;
374  for (mask = 1; mask < 16; mask <<= 1) {
375  if (channel_mask & mask)
376  ++s->lfe_channel;
377  }
378  }
379 
381  scale_huffbits, 1, 1,
382  scale_huffcodes, 2, 2, 616);
383 
385  scale_rl_huffbits, 1, 1,
386  scale_rl_huffcodes, 4, 4, 1406);
387 
388  INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
389  coef0_huffbits, 1, 1,
390  coef0_huffcodes, 4, 4, 2108);
391 
392  INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
393  coef1_huffbits, 1, 1,
394  coef1_huffcodes, 4, 4, 3912);
395 
397  vec4_huffbits, 1, 1,
398  vec4_huffcodes, 2, 2, 604);
399 
401  vec2_huffbits, 1, 1,
402  vec2_huffcodes, 2, 2, 562);
403 
405  vec1_huffbits, 1, 1,
406  vec1_huffcodes, 2, 2, 562);
407 
408  /** calculate number of scale factor bands and their offsets
409  for every possible block size */
410  for (i = 0; i < num_possible_block_sizes; i++) {
411  int subframe_len = s->samples_per_frame >> i;
412  int x;
413  int band = 1;
414 
415  s->sfb_offsets[i][0] = 0;
416 
417  for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
418  int offset = (subframe_len * 2 * critical_freq[x])
419  / s->avctx->sample_rate + 2;
420  offset &= ~3;
421  if (offset > s->sfb_offsets[i][band - 1])
422  s->sfb_offsets[i][band++] = offset;
423  }
424  s->sfb_offsets[i][band - 1] = subframe_len;
425  s->num_sfb[i] = band - 1;
426  if (s->num_sfb[i] <= 0) {
427  av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
428  return AVERROR_INVALIDDATA;
429  }
430  }
431 
432 
433  /** Scale factors can be shared between blocks of different size
434  as every block has a different scale factor band layout.
435  The matrix sf_offsets is needed to find the correct scale factor.
436  */
437 
438  for (i = 0; i < num_possible_block_sizes; i++) {
439  int b;
440  for (b = 0; b < s->num_sfb[i]; b++) {
441  int x;
442  int offset = ((s->sfb_offsets[i][b]
443  + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
444  for (x = 0; x < num_possible_block_sizes; x++) {
445  int v = 0;
446  while (s->sfb_offsets[x][v + 1] << x < offset) {
447  v++;
448  av_assert0(v < MAX_BANDS);
449  }
450  s->sf_offsets[i][x][b] = v;
451  }
452  }
453  }
454 
455  /** init MDCT, FIXME: only init needed sizes */
456  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
458  1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
459  / (1 << (s->bits_per_sample - 1)));
460 
461  /** init MDCT windows: simple sinus window */
462  for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
463  const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
464  ff_init_ff_sine_windows(win_idx);
465  s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
466  }
467 
468  /** calculate subwoofer cutoff values */
469  for (i = 0; i < num_possible_block_sizes; i++) {
470  int block_size = s->samples_per_frame >> i;
471  int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
472  / s->avctx->sample_rate;
473  s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
474  }
475 
476  /** calculate sine values for the decorrelation matrix */
477  for (i = 0; i < 33; i++)
478  sin64[i] = sin(i*M_PI / 64.0);
479 
480  if (avctx->debug & FF_DEBUG_BITSTREAM)
481  dump_context(s);
482 
483  avctx->channel_layout = channel_mask;
484 
485  return 0;
486 }
487 
488 /**
489  *@brief Decode the subframe length.
490  *@param s context
491  *@param offset sample offset in the frame
492  *@return decoded subframe length on success, < 0 in case of an error
493  */
495 {
496  int frame_len_shift = 0;
497  int subframe_len;
498 
499  /** no need to read from the bitstream when only one length is possible */
500  if (offset == s->samples_per_frame - s->min_samples_per_subframe)
501  return s->min_samples_per_subframe;
502 
503  /** 1 bit indicates if the subframe is of maximum length */
504  if (s->max_subframe_len_bit) {
505  if (get_bits1(&s->gb))
506  frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
507  } else
508  frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
509 
510  subframe_len = s->samples_per_frame >> frame_len_shift;
511 
512  /** sanity check the length */
513  if (subframe_len < s->min_samples_per_subframe ||
514  subframe_len > s->samples_per_frame) {
515  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
516  subframe_len);
517  return AVERROR_INVALIDDATA;
518  }
519  return subframe_len;
520 }
521 
522 /**
523  *@brief Decode how the data in the frame is split into subframes.
524  * Every WMA frame contains the encoded data for a fixed number of
525  * samples per channel. The data for every channel might be split
526  * into several subframes. This function will reconstruct the list of
527  * subframes for every channel.
528  *
529  * If the subframes are not evenly split, the algorithm estimates the
530  * channels with the lowest number of total samples.
531  * Afterwards, for each of these channels a bit is read from the
532  * bitstream that indicates if the channel contains a subframe with the
533  * next subframe size that is going to be read from the bitstream or not.
534  * If a channel contains such a subframe, the subframe size gets added to
535  * the channel's subframe list.
536  * The algorithm repeats these steps until the frame is properly divided
537  * between the individual channels.
538  *
539  *@param s context
540  *@return 0 on success, < 0 in case of an error
541  */
543 {
544  uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
545  uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
546  int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
547  int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
548  int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
549  int c;
550 
551  /* Should never consume more than 3073 bits (256 iterations for the
552  * while loop when always the minimum amount of 128 samples is subtracted
553  * from missing samples in the 8 channel case).
554  * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
555  */
556 
557  /** reset tiling information */
558  for (c = 0; c < s->avctx->channels; c++)
559  s->channel[c].num_subframes = 0;
560 
561  if (s->max_num_subframes == 1 || get_bits1(&s->gb))
562  fixed_channel_layout = 1;
563 
564  /** loop until the frame data is split between the subframes */
565  do {
566  int subframe_len;
567 
568  /** check which channels contain the subframe */
569  for (c = 0; c < s->avctx->channels; c++) {
570  if (num_samples[c] == min_channel_len) {
571  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
572  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
573  contains_subframe[c] = 1;
574  else
575  contains_subframe[c] = get_bits1(&s->gb);
576  } else
577  contains_subframe[c] = 0;
578  }
579 
580  /** get subframe length, subframe_len == 0 is not allowed */
581  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
582  return AVERROR_INVALIDDATA;
583 
584  /** add subframes to the individual channels and find new min_channel_len */
585  min_channel_len += subframe_len;
586  for (c = 0; c < s->avctx->channels; c++) {
587  WMAProChannelCtx* chan = &s->channel[c];
588 
589  if (contains_subframe[c]) {
590  if (chan->num_subframes >= MAX_SUBFRAMES) {
592  "broken frame: num subframes > 31\n");
593  return AVERROR_INVALIDDATA;
594  }
595  chan->subframe_len[chan->num_subframes] = subframe_len;
596  num_samples[c] += subframe_len;
597  ++chan->num_subframes;
598  if (num_samples[c] > s->samples_per_frame) {
599  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
600  "channel len > samples_per_frame\n");
601  return AVERROR_INVALIDDATA;
602  }
603  } else if (num_samples[c] <= min_channel_len) {
604  if (num_samples[c] < min_channel_len) {
605  channels_for_cur_subframe = 0;
606  min_channel_len = num_samples[c];
607  }
608  ++channels_for_cur_subframe;
609  }
610  }
611  } while (min_channel_len < s->samples_per_frame);
612 
613  for (c = 0; c < s->avctx->channels; c++) {
614  int i;
615  int offset = 0;
616  for (i = 0; i < s->channel[c].num_subframes; i++) {
617  av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
618  " len %i\n", s->frame_num, c, i,
619  s->channel[c].subframe_len[i]);
620  s->channel[c].subframe_offset[i] = offset;
621  offset += s->channel[c].subframe_len[i];
622  }
623  }
624 
625  return 0;
626 }
627 
628 /**
629  *@brief Calculate a decorrelation matrix from the bitstream parameters.
630  *@param s codec context
631  *@param chgroup channel group for which the matrix needs to be calculated
632  */
634  WMAProChannelGrp *chgroup)
635 {
636  int i;
637  int offset = 0;
638  int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
639  memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
640  s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
641 
642  for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
643  rotation_offset[i] = get_bits(&s->gb, 6);
644 
645  for (i = 0; i < chgroup->num_channels; i++)
646  chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
647  get_bits1(&s->gb) ? 1.0 : -1.0;
648 
649  for (i = 1; i < chgroup->num_channels; i++) {
650  int x;
651  for (x = 0; x < i; x++) {
652  int y;
653  for (y = 0; y < i + 1; y++) {
654  float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
655  float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
656  int n = rotation_offset[offset + x];
657  float sinv;
658  float cosv;
659 
660  if (n < 32) {
661  sinv = sin64[n];
662  cosv = sin64[32 - n];
663  } else {
664  sinv = sin64[64 - n];
665  cosv = -sin64[n - 32];
666  }
667 
668  chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
669  (v1 * sinv) - (v2 * cosv);
670  chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
671  (v1 * cosv) + (v2 * sinv);
672  }
673  }
674  offset += i;
675  }
676 }
677 
678 /**
679  *@brief Decode channel transformation parameters
680  *@param s codec context
681  *@return 0 in case of success, < 0 in case of bitstream errors
682  */
684 {
685  int i;
686  /* should never consume more than 1921 bits for the 8 channel case
687  * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
688  * + MAX_CHANNELS + MAX_BANDS + 1)
689  */
690 
691  /** in the one channel case channel transforms are pointless */
692  s->num_chgroups = 0;
693  if (s->avctx->channels > 1) {
694  int remaining_channels = s->channels_for_cur_subframe;
695 
696  if (get_bits1(&s->gb)) {
698  "Channel transform bit");
699  return AVERROR_PATCHWELCOME;
700  }
701 
702  for (s->num_chgroups = 0; remaining_channels &&
704  WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
705  float** channel_data = chgroup->channel_data;
706  chgroup->num_channels = 0;
707  chgroup->transform = 0;
708 
709  /** decode channel mask */
710  if (remaining_channels > 2) {
711  for (i = 0; i < s->channels_for_cur_subframe; i++) {
712  int channel_idx = s->channel_indexes_for_cur_subframe[i];
713  if (!s->channel[channel_idx].grouped
714  && get_bits1(&s->gb)) {
715  ++chgroup->num_channels;
716  s->channel[channel_idx].grouped = 1;
717  *channel_data++ = s->channel[channel_idx].coeffs;
718  }
719  }
720  } else {
721  chgroup->num_channels = remaining_channels;
722  for (i = 0; i < s->channels_for_cur_subframe; i++) {
723  int channel_idx = s->channel_indexes_for_cur_subframe[i];
724  if (!s->channel[channel_idx].grouped)
725  *channel_data++ = s->channel[channel_idx].coeffs;
726  s->channel[channel_idx].grouped = 1;
727  }
728  }
729 
730  /** decode transform type */
731  if (chgroup->num_channels == 2) {
732  if (get_bits1(&s->gb)) {
733  if (get_bits1(&s->gb)) {
735  "Unknown channel transform type");
736  return AVERROR_PATCHWELCOME;
737  }
738  } else {
739  chgroup->transform = 1;
740  if (s->avctx->channels == 2) {
741  chgroup->decorrelation_matrix[0] = 1.0;
742  chgroup->decorrelation_matrix[1] = -1.0;
743  chgroup->decorrelation_matrix[2] = 1.0;
744  chgroup->decorrelation_matrix[3] = 1.0;
745  } else {
746  /** cos(pi/4) */
747  chgroup->decorrelation_matrix[0] = 0.70703125;
748  chgroup->decorrelation_matrix[1] = -0.70703125;
749  chgroup->decorrelation_matrix[2] = 0.70703125;
750  chgroup->decorrelation_matrix[3] = 0.70703125;
751  }
752  }
753  } else if (chgroup->num_channels > 2) {
754  if (get_bits1(&s->gb)) {
755  chgroup->transform = 1;
756  if (get_bits1(&s->gb)) {
757  decode_decorrelation_matrix(s, chgroup);
758  } else {
759  /** FIXME: more than 6 coupled channels not supported */
760  if (chgroup->num_channels > 6) {
762  "Coupled channels > 6");
763  } else {
764  memcpy(chgroup->decorrelation_matrix,
766  chgroup->num_channels * chgroup->num_channels *
767  sizeof(*chgroup->decorrelation_matrix));
768  }
769  }
770  }
771  }
772 
773  /** decode transform on / off */
774  if (chgroup->transform) {
775  if (!get_bits1(&s->gb)) {
776  int i;
777  /** transform can be enabled for individual bands */
778  for (i = 0; i < s->num_bands; i++) {
779  chgroup->transform_band[i] = get_bits1(&s->gb);
780  }
781  } else {
782  memset(chgroup->transform_band, 1, s->num_bands);
783  }
784  }
785  remaining_channels -= chgroup->num_channels;
786  }
787  }
788  return 0;
789 }
790 
791 /**
792  *@brief Extract the coefficients from the bitstream.
793  *@param s codec context
794  *@param c current channel number
795  *@return 0 on success, < 0 in case of bitstream errors
796  */
797 static int decode_coeffs(WMAProDecodeCtx *s, int c)
798 {
799  /* Integers 0..15 as single-precision floats. The table saves a
800  costly int to float conversion, and storing the values as
801  integers allows fast sign-flipping. */
802  static const uint32_t fval_tab[16] = {
803  0x00000000, 0x3f800000, 0x40000000, 0x40400000,
804  0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
805  0x41000000, 0x41100000, 0x41200000, 0x41300000,
806  0x41400000, 0x41500000, 0x41600000, 0x41700000,
807  };
808  int vlctable;
809  VLC* vlc;
810  WMAProChannelCtx* ci = &s->channel[c];
811  int rl_mode = 0;
812  int cur_coeff = 0;
813  int num_zeros = 0;
814  const uint16_t* run;
815  const float* level;
816 
817  av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
818 
819  vlctable = get_bits1(&s->gb);
820  vlc = &coef_vlc[vlctable];
821 
822  if (vlctable) {
823  run = coef1_run;
824  level = coef1_level;
825  } else {
826  run = coef0_run;
827  level = coef0_level;
828  }
829 
830  /** decode vector coefficients (consumes up to 167 bits per iteration for
831  4 vector coded large values) */
832  while ((s->transmit_num_vec_coeffs || !rl_mode) &&
833  (cur_coeff + 3 < ci->num_vec_coeffs)) {
834  uint32_t vals[4];
835  int i;
836  unsigned int idx;
837 
838  idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
839 
840  if (idx == HUFF_VEC4_SIZE - 1) {
841  for (i = 0; i < 4; i += 2) {
842  idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
843  if (idx == HUFF_VEC2_SIZE - 1) {
844  uint32_t v0, v1;
845  v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
846  if (v0 == HUFF_VEC1_SIZE - 1)
847  v0 += ff_wma_get_large_val(&s->gb);
848  v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
849  if (v1 == HUFF_VEC1_SIZE - 1)
850  v1 += ff_wma_get_large_val(&s->gb);
851  vals[i ] = av_float2int(v0);
852  vals[i+1] = av_float2int(v1);
853  } else {
854  vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
855  vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
856  }
857  }
858  } else {
859  vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
860  vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
861  vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
862  vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
863  }
864 
865  /** decode sign */
866  for (i = 0; i < 4; i++) {
867  if (vals[i]) {
868  uint32_t sign = get_bits1(&s->gb) - 1;
869  AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
870  num_zeros = 0;
871  } else {
872  ci->coeffs[cur_coeff] = 0;
873  /** switch to run level mode when subframe_len / 128 zeros
874  were found in a row */
875  rl_mode |= (++num_zeros > s->subframe_len >> 8);
876  }
877  ++cur_coeff;
878  }
879  }
880 
881  /** decode run level coded coefficients */
882  if (cur_coeff < s->subframe_len) {
883  memset(&ci->coeffs[cur_coeff], 0,
884  sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
885  if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
886  level, run, 1, ci->coeffs,
887  cur_coeff, s->subframe_len,
888  s->subframe_len, s->esc_len, 0))
889  return AVERROR_INVALIDDATA;
890  }
891 
892  return 0;
893 }
894 
895 /**
896  *@brief Extract scale factors from the bitstream.
897  *@param s codec context
898  *@return 0 on success, < 0 in case of bitstream errors
899  */
901 {
902  int i;
903 
904  /** should never consume more than 5344 bits
905  * MAX_CHANNELS * (1 + MAX_BANDS * 23)
906  */
907 
908  for (i = 0; i < s->channels_for_cur_subframe; i++) {
910  int* sf;
911  int* sf_end;
913  sf_end = s->channel[c].scale_factors + s->num_bands;
914 
915  /** resample scale factors for the new block size
916  * as the scale factors might need to be resampled several times
917  * before some new values are transmitted, a backup of the last
918  * transmitted scale factors is kept in saved_scale_factors
919  */
920  if (s->channel[c].reuse_sf) {
921  const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
922  int b;
923  for (b = 0; b < s->num_bands; b++)
924  s->channel[c].scale_factors[b] =
925  s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
926  }
927 
928  if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
929 
930  if (!s->channel[c].reuse_sf) {
931  int val;
932  /** decode DPCM coded scale factors */
933  s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
934  val = 45 / s->channel[c].scale_factor_step;
935  for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
936  val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
937  *sf = val;
938  }
939  } else {
940  int i;
941  /** run level decode differences to the resampled factors */
942  for (i = 0; i < s->num_bands; i++) {
943  int idx;
944  int skip;
945  int val;
946  int sign;
947 
948  idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
949 
950  if (!idx) {
951  uint32_t code = get_bits(&s->gb, 14);
952  val = code >> 6;
953  sign = (code & 1) - 1;
954  skip = (code & 0x3f) >> 1;
955  } else if (idx == 1) {
956  break;
957  } else {
958  skip = scale_rl_run[idx];
959  val = scale_rl_level[idx];
960  sign = get_bits1(&s->gb)-1;
961  }
962 
963  i += skip;
964  if (i >= s->num_bands) {
966  "invalid scale factor coding\n");
967  return AVERROR_INVALIDDATA;
968  }
969  s->channel[c].scale_factors[i] += (val ^ sign) - sign;
970  }
971  }
972  /** swap buffers */
974  s->channel[c].table_idx = s->table_idx;
975  s->channel[c].reuse_sf = 1;
976  }
977 
978  /** calculate new scale factor maximum */
980  for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
982  FFMAX(s->channel[c].max_scale_factor, *sf);
983  }
984 
985  }
986  return 0;
987 }
988 
989 /**
990  *@brief Reconstruct the individual channel data.
991  *@param s codec context
992  */
994 {
995  int i;
996 
997  for (i = 0; i < s->num_chgroups; i++) {
998  if (s->chgroup[i].transform) {
999  float data[WMAPRO_MAX_CHANNELS];
1000  const int num_channels = s->chgroup[i].num_channels;
1001  float** ch_data = s->chgroup[i].channel_data;
1002  float** ch_end = ch_data + num_channels;
1003  const int8_t* tb = s->chgroup[i].transform_band;
1004  int16_t* sfb;
1005 
1006  /** multichannel decorrelation */
1007  for (sfb = s->cur_sfb_offsets;
1008  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1009  int y;
1010  if (*tb++ == 1) {
1011  /** multiply values with the decorrelation_matrix */
1012  for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1013  const float* mat = s->chgroup[i].decorrelation_matrix;
1014  const float* data_end = data + num_channels;
1015  float* data_ptr = data;
1016  float** ch;
1017 
1018  for (ch = ch_data; ch < ch_end; ch++)
1019  *data_ptr++ = (*ch)[y];
1020 
1021  for (ch = ch_data; ch < ch_end; ch++) {
1022  float sum = 0;
1023  data_ptr = data;
1024  while (data_ptr < data_end)
1025  sum += *data_ptr++ * *mat++;
1026 
1027  (*ch)[y] = sum;
1028  }
1029  }
1030  } else if (s->avctx->channels == 2) {
1031  int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1032  s->fdsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1033  ch_data[0] + sfb[0],
1034  181.0 / 128, len);
1035  s->fdsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1036  ch_data[1] + sfb[0],
1037  181.0 / 128, len);
1038  }
1039  }
1040  }
1041  }
1042 }
1043 
1044 /**
1045  *@brief Apply sine window and reconstruct the output buffer.
1046  *@param s codec context
1047  */
1049 {
1050  int i;
1051  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1052  int c = s->channel_indexes_for_cur_subframe[i];
1053  float* window;
1054  int winlen = s->channel[c].prev_block_len;
1055  float* start = s->channel[c].coeffs - (winlen >> 1);
1056 
1057  if (s->subframe_len < winlen) {
1058  start += (winlen - s->subframe_len) >> 1;
1059  winlen = s->subframe_len;
1060  }
1061 
1062  window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1063 
1064  winlen >>= 1;
1065 
1066  s->fdsp.vector_fmul_window(start, start, start + winlen,
1067  window, winlen);
1068 
1070  }
1071 }
1072 
1073 /**
1074  *@brief Decode a single subframe (block).
1075  *@param s codec context
1076  *@return 0 on success, < 0 when decoding failed
1077  */
1079 {
1080  int offset = s->samples_per_frame;
1081  int subframe_len = s->samples_per_frame;
1082  int i;
1083  int total_samples = s->samples_per_frame * s->avctx->channels;
1084  int transmit_coeffs = 0;
1085  int cur_subwoofer_cutoff;
1086 
1087  s->subframe_offset = get_bits_count(&s->gb);
1088 
1089  /** reset channel context and find the next block offset and size
1090  == the next block of the channel with the smallest number of
1091  decoded samples
1092  */
1093  for (i = 0; i < s->avctx->channels; i++) {
1094  s->channel[i].grouped = 0;
1095  if (offset > s->channel[i].decoded_samples) {
1096  offset = s->channel[i].decoded_samples;
1097  subframe_len =
1099  }
1100  }
1101 
1102  av_dlog(s->avctx,
1103  "processing subframe with offset %i len %i\n", offset, subframe_len);
1104 
1105  /** get a list of all channels that contain the estimated block */
1107  for (i = 0; i < s->avctx->channels; i++) {
1108  const int cur_subframe = s->channel[i].cur_subframe;
1109  /** subtract already processed samples */
1110  total_samples -= s->channel[i].decoded_samples;
1111 
1112  /** and count if there are multiple subframes that match our profile */
1113  if (offset == s->channel[i].decoded_samples &&
1114  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1115  total_samples -= s->channel[i].subframe_len[cur_subframe];
1116  s->channel[i].decoded_samples +=
1117  s->channel[i].subframe_len[cur_subframe];
1120  }
1121  }
1122 
1123  /** check if the frame will be complete after processing the
1124  estimated block */
1125  if (!total_samples)
1126  s->parsed_all_subframes = 1;
1127 
1128 
1129  av_dlog(s->avctx, "subframe is part of %i channels\n",
1131 
1132  /** calculate number of scale factor bands and their offsets */
1133  s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1134  s->num_bands = s->num_sfb[s->table_idx];
1136  cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1137 
1138  /** configure the decoder for the current subframe */
1139  offset += s->samples_per_frame >> 1;
1140 
1141  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1142  int c = s->channel_indexes_for_cur_subframe[i];
1143 
1144  s->channel[c].coeffs = &s->channel[c].out[offset];
1145  }
1146 
1147  s->subframe_len = subframe_len;
1148  s->esc_len = av_log2(s->subframe_len - 1) + 1;
1149 
1150  /** skip extended header if any */
1151  if (get_bits1(&s->gb)) {
1152  int num_fill_bits;
1153  if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1154  int len = get_bits(&s->gb, 4);
1155  num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
1156  }
1157 
1158  if (num_fill_bits >= 0) {
1159  if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1160  av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1161  return AVERROR_INVALIDDATA;
1162  }
1163 
1164  skip_bits_long(&s->gb, num_fill_bits);
1165  }
1166  }
1167 
1168  /** no idea for what the following bit is used */
1169  if (get_bits1(&s->gb)) {
1170  avpriv_request_sample(s->avctx, "Reserved bit");
1171  return AVERROR_PATCHWELCOME;
1172  }
1173 
1174 
1175  if (decode_channel_transform(s) < 0)
1176  return AVERROR_INVALIDDATA;
1177 
1178 
1179  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1180  int c = s->channel_indexes_for_cur_subframe[i];
1181  if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1182  transmit_coeffs = 1;
1183  }
1184 
1186  if (transmit_coeffs) {
1187  int step;
1188  int quant_step = 90 * s->bits_per_sample >> 4;
1189 
1190  /** decode number of vector coded coefficients */
1191  if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1192  int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1193  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1194  int c = s->channel_indexes_for_cur_subframe[i];
1195  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1196  if (num_vec_coeffs > s->subframe_len) {
1197  av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1198  return AVERROR_INVALIDDATA;
1199  }
1200  av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1201  s->channel[c].num_vec_coeffs = num_vec_coeffs;
1202  }
1203  } else {
1204  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1205  int c = s->channel_indexes_for_cur_subframe[i];
1207  }
1208  }
1209  /** decode quantization step */
1210  step = get_sbits(&s->gb, 6);
1211  quant_step += step;
1212  if (step == -32 || step == 31) {
1213  const int sign = (step == 31) - 1;
1214  int quant = 0;
1215  while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1216  (step = get_bits(&s->gb, 5)) == 31) {
1217  quant += 31;
1218  }
1219  quant_step += ((quant + step) ^ sign) - sign;
1220  }
1221  if (quant_step < 0) {
1222  av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1223  }
1224 
1225  /** decode quantization step modifiers for every channel */
1226 
1227  if (s->channels_for_cur_subframe == 1) {
1228  s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1229  } else {
1230  int modifier_len = get_bits(&s->gb, 3);
1231  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1232  int c = s->channel_indexes_for_cur_subframe[i];
1233  s->channel[c].quant_step = quant_step;
1234  if (get_bits1(&s->gb)) {
1235  if (modifier_len) {
1236  s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1237  } else
1238  ++s->channel[c].quant_step;
1239  }
1240  }
1241  }
1242 
1243  /** decode scale factors */
1244  if (decode_scale_factors(s) < 0)
1245  return AVERROR_INVALIDDATA;
1246  }
1247 
1248  av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1249  get_bits_count(&s->gb) - s->subframe_offset);
1250 
1251  /** parse coefficients */
1252  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1253  int c = s->channel_indexes_for_cur_subframe[i];
1254  if (s->channel[c].transmit_coefs &&
1255  get_bits_count(&s->gb) < s->num_saved_bits) {
1256  decode_coeffs(s, c);
1257  } else
1258  memset(s->channel[c].coeffs, 0,
1259  sizeof(*s->channel[c].coeffs) * subframe_len);
1260  }
1261 
1262  av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1263  get_bits_count(&s->gb) - s->subframe_offset);
1264 
1265  if (transmit_coeffs) {
1266  FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1267  /** reconstruct the per channel data */
1269  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1270  int c = s->channel_indexes_for_cur_subframe[i];
1271  const int* sf = s->channel[c].scale_factors;
1272  int b;
1273 
1274  if (c == s->lfe_channel)
1275  memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1276  (subframe_len - cur_subwoofer_cutoff));
1277 
1278  /** inverse quantization and rescaling */
1279  for (b = 0; b < s->num_bands; b++) {
1280  const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1281  const int exp = s->channel[c].quant_step -
1282  (s->channel[c].max_scale_factor - *sf++) *
1283  s->channel[c].scale_factor_step;
1284  const float quant = pow(10.0, exp / 20.0);
1285  int start = s->cur_sfb_offsets[b];
1286  s->fdsp.vector_fmul_scalar(s->tmp + start,
1287  s->channel[c].coeffs + start,
1288  quant, end - start);
1289  }
1290 
1291  /** apply imdct (imdct_half == DCTIV with reverse) */
1292  mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1293  }
1294  }
1295 
1296  /** window and overlapp-add */
1297  wmapro_window(s);
1298 
1299  /** handled one subframe */
1300  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1301  int c = s->channel_indexes_for_cur_subframe[i];
1302  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1303  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1304  return AVERROR_INVALIDDATA;
1305  }
1306  ++s->channel[c].cur_subframe;
1307  }
1308 
1309  return 0;
1310 }
1311 
1312 /**
1313  *@brief Decode one WMA frame.
1314  *@param s codec context
1315  *@return 0 if the trailer bit indicates that this is the last frame,
1316  * 1 if there are additional frames
1317  */
1318 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1319 {
1320  AVCodecContext *avctx = s->avctx;
1321  GetBitContext* gb = &s->gb;
1322  int more_frames = 0;
1323  int len = 0;
1324  int i, ret;
1325 
1326  /** get frame length */
1327  if (s->len_prefix)
1328  len = get_bits(gb, s->log2_frame_size);
1329 
1330  av_dlog(s->avctx, "decoding frame with length %x\n", len);
1331 
1332  /** decode tile information */
1333  if (decode_tilehdr(s)) {
1334  s->packet_loss = 1;
1335  return 0;
1336  }
1337 
1338  /** read postproc transform */
1339  if (s->avctx->channels > 1 && get_bits1(gb)) {
1340  if (get_bits1(gb)) {
1341  for (i = 0; i < avctx->channels * avctx->channels; i++)
1342  skip_bits(gb, 4);
1343  }
1344  }
1345 
1346  /** read drc info */
1347  if (s->dynamic_range_compression) {
1348  s->drc_gain = get_bits(gb, 8);
1349  av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1350  }
1351 
1352  /** no idea what these are for, might be the number of samples
1353  that need to be skipped at the beginning or end of a stream */
1354  if (get_bits1(gb)) {
1355  int av_unused skip;
1356 
1357  /** usually true for the first frame */
1358  if (get_bits1(gb)) {
1359  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1360  av_dlog(s->avctx, "start skip: %i\n", skip);
1361  }
1362 
1363  /** sometimes true for the last frame */
1364  if (get_bits1(gb)) {
1365  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1366  av_dlog(s->avctx, "end skip: %i\n", skip);
1367  }
1368 
1369  }
1370 
1371  av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1372  get_bits_count(gb) - s->frame_offset);
1373 
1374  /** reset subframe states */
1375  s->parsed_all_subframes = 0;
1376  for (i = 0; i < avctx->channels; i++) {
1377  s->channel[i].decoded_samples = 0;
1378  s->channel[i].cur_subframe = 0;
1379  s->channel[i].reuse_sf = 0;
1380  }
1381 
1382  /** decode all subframes */
1383  while (!s->parsed_all_subframes) {
1384  if (decode_subframe(s) < 0) {
1385  s->packet_loss = 1;
1386  return 0;
1387  }
1388  }
1389 
1390  /* get output buffer */
1391  frame->nb_samples = s->samples_per_frame;
1392  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1393  s->packet_loss = 1;
1394  return 0;
1395  }
1396 
1397  /** copy samples to the output buffer */
1398  for (i = 0; i < avctx->channels; i++)
1399  memcpy(frame->extended_data[i], s->channel[i].out,
1400  s->samples_per_frame * sizeof(*s->channel[i].out));
1401 
1402  for (i = 0; i < avctx->channels; i++) {
1403  /** reuse second half of the IMDCT output for the next frame */
1404  memcpy(&s->channel[i].out[0],
1405  &s->channel[i].out[s->samples_per_frame],
1406  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1407  }
1408 
1409  if (s->skip_frame) {
1410  s->skip_frame = 0;
1411  *got_frame_ptr = 0;
1412  av_frame_unref(frame);
1413  } else {
1414  *got_frame_ptr = 1;
1415  }
1416 
1417  if (s->len_prefix) {
1418  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1419  /** FIXME: not sure if this is always an error */
1421  "frame[%i] would have to skip %i bits\n", s->frame_num,
1422  len - (get_bits_count(gb) - s->frame_offset) - 1);
1423  s->packet_loss = 1;
1424  return 0;
1425  }
1426 
1427  /** skip the rest of the frame data */
1428  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1429  } else {
1430  while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1431  }
1432  }
1433 
1434  /** decode trailer bit */
1435  more_frames = get_bits1(gb);
1436 
1437  ++s->frame_num;
1438  return more_frames;
1439 }
1440 
1441 /**
1442  *@brief Calculate remaining input buffer length.
1443  *@param s codec context
1444  *@param gb bitstream reader context
1445  *@return remaining size in bits
1446  */
1448 {
1449  return s->buf_bit_size - get_bits_count(gb);
1450 }
1451 
1452 /**
1453  *@brief Fill the bit reservoir with a (partial) frame.
1454  *@param s codec context
1455  *@param gb bitstream reader context
1456  *@param len length of the partial frame
1457  *@param append decides whether to reset the buffer or not
1458  */
1460  int append)
1461 {
1462  int buflen;
1463 
1464  /** when the frame data does not need to be concatenated, the input buffer
1465  is reset and additional bits from the previous frame are copied
1466  and skipped later so that a fast byte copy is possible */
1467 
1468  if (!append) {
1469  s->frame_offset = get_bits_count(gb) & 7;
1470  s->num_saved_bits = s->frame_offset;
1472  }
1473 
1474  buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1475 
1476  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1477  avpriv_request_sample(s->avctx, "Too small input buffer");
1478  s->packet_loss = 1;
1479  return;
1480  }
1481 
1482  av_assert0(len <= put_bits_left(&s->pb));
1483 
1484  s->num_saved_bits += len;
1485  if (!append) {
1486  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1487  s->num_saved_bits);
1488  } else {
1489  int align = 8 - (get_bits_count(gb) & 7);
1490  align = FFMIN(align, len);
1491  put_bits(&s->pb, align, get_bits(gb, align));
1492  len -= align;
1493  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1494  }
1495  skip_bits_long(gb, len);
1496 
1497  {
1498  PutBitContext tmp = s->pb;
1499  flush_put_bits(&tmp);
1500  }
1501 
1503  skip_bits(&s->gb, s->frame_offset);
1504 }
1505 
1506 /**
1507  *@brief Decode a single WMA packet.
1508  *@param avctx codec context
1509  *@param data the output buffer
1510  *@param avpkt input packet
1511  *@return number of bytes that were read from the input buffer
1512  */
1513 static int decode_packet(AVCodecContext *avctx, void *data,
1514  int *got_frame_ptr, AVPacket* avpkt)
1515 {
1516  WMAProDecodeCtx *s = avctx->priv_data;
1517  GetBitContext* gb = &s->pgb;
1518  const uint8_t* buf = avpkt->data;
1519  int buf_size = avpkt->size;
1520  int num_bits_prev_frame;
1521  int packet_sequence_number;
1522 
1523  *got_frame_ptr = 0;
1524 
1525  if (s->packet_done || s->packet_loss) {
1526  s->packet_done = 0;
1527 
1528  /** sanity check for the buffer length */
1529  if (buf_size < avctx->block_align) {
1530  av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1531  buf_size, avctx->block_align);
1532  return AVERROR_INVALIDDATA;
1533  }
1534 
1535  s->next_packet_start = buf_size - avctx->block_align;
1536  buf_size = avctx->block_align;
1537  s->buf_bit_size = buf_size << 3;
1538 
1539  /** parse packet header */
1540  init_get_bits(gb, buf, s->buf_bit_size);
1541  packet_sequence_number = get_bits(gb, 4);
1542  skip_bits(gb, 2);
1543 
1544  /** get number of bits that need to be added to the previous frame */
1545  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1546  av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1547  num_bits_prev_frame);
1548 
1549  /** check for packet loss */
1550  if (!s->packet_loss &&
1551  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1552  s->packet_loss = 1;
1553  av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1554  s->packet_sequence_number, packet_sequence_number);
1555  }
1556  s->packet_sequence_number = packet_sequence_number;
1557 
1558  if (num_bits_prev_frame > 0) {
1559  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1560  if (num_bits_prev_frame >= remaining_packet_bits) {
1561  num_bits_prev_frame = remaining_packet_bits;
1562  s->packet_done = 1;
1563  }
1564 
1565  /** append the previous frame data to the remaining data from the
1566  previous packet to create a full frame */
1567  save_bits(s, gb, num_bits_prev_frame, 1);
1568  av_dlog(avctx, "accumulated %x bits of frame data\n",
1569  s->num_saved_bits - s->frame_offset);
1570 
1571  /** decode the cross packet frame if it is valid */
1572  if (!s->packet_loss)
1573  decode_frame(s, data, got_frame_ptr);
1574  } else if (s->num_saved_bits - s->frame_offset) {
1575  av_dlog(avctx, "ignoring %x previously saved bits\n",
1576  s->num_saved_bits - s->frame_offset);
1577  }
1578 
1579  if (s->packet_loss) {
1580  /** reset number of saved bits so that the decoder
1581  does not start to decode incomplete frames in the
1582  s->len_prefix == 0 case */
1583  s->num_saved_bits = 0;
1584  s->packet_loss = 0;
1585  }
1586 
1587  } else {
1588  int frame_size;
1589  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1590  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1591  skip_bits(gb, s->packet_offset);
1592  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1593  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1594  frame_size <= remaining_bits(s, gb)) {
1595  save_bits(s, gb, frame_size, 0);
1596  if (!s->packet_loss)
1597  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1598  } else if (!s->len_prefix
1599  && s->num_saved_bits > get_bits_count(&s->gb)) {
1600  /** when the frames do not have a length prefix, we don't know
1601  the compressed length of the individual frames
1602  however, we know what part of a new packet belongs to the
1603  previous frame
1604  therefore we save the incoming packet first, then we append
1605  the "previous frame" data from the next packet so that
1606  we get a buffer that only contains full frames */
1607  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1608  } else
1609  s->packet_done = 1;
1610  }
1611 
1612  if (s->packet_done && !s->packet_loss &&
1613  remaining_bits(s, gb) > 0) {
1614  /** save the rest of the data so that it can be decoded
1615  with the next packet */
1616  save_bits(s, gb, remaining_bits(s, gb), 0);
1617  }
1618 
1619  s->packet_offset = get_bits_count(gb) & 7;
1620  if (s->packet_loss)
1621  return AVERROR_INVALIDDATA;
1622 
1623  return get_bits_count(gb) >> 3;
1624 }
1625 
1626 /**
1627  *@brief Clear decoder buffers (for seeking).
1628  *@param avctx codec context
1629  */
1630 static void flush(AVCodecContext *avctx)
1631 {
1632  WMAProDecodeCtx *s = avctx->priv_data;
1633  int i;
1634  /** reset output buffer as a part of it is used during the windowing of a
1635  new frame */
1636  for (i = 0; i < avctx->channels; i++)
1637  memset(s->channel[i].out, 0, s->samples_per_frame *
1638  sizeof(*s->channel[i].out));
1639  s->packet_loss = 1;
1640 }
1641 
1642 
1643 /**
1644  *@brief wmapro decoder
1645  */
1647  .name = "wmapro",
1648  .type = AVMEDIA_TYPE_AUDIO,
1649  .id = AV_CODEC_ID_WMAPRO,
1650  .priv_data_size = sizeof(WMAProDecodeCtx),
1651  .init = decode_init,
1652  .close = decode_end,
1653  .decode = decode_packet,
1654  .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1655  .flush = flush,
1656  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1657  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1659 };