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]; ///< sine 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 sine 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  if (get_bits_left(&s->gb) < 1)
504  return AVERROR_INVALIDDATA;
505 
506  /** 1 bit indicates if the subframe is of maximum length */
507  if (s->max_subframe_len_bit) {
508  if (get_bits1(&s->gb))
509  frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
510  } else
511  frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
512 
513  subframe_len = s->samples_per_frame >> frame_len_shift;
514 
515  /** sanity check the length */
516  if (subframe_len < s->min_samples_per_subframe ||
517  subframe_len > s->samples_per_frame) {
518  av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
519  subframe_len);
520  return AVERROR_INVALIDDATA;
521  }
522  return subframe_len;
523 }
524 
525 /**
526  *@brief Decode how the data in the frame is split into subframes.
527  * Every WMA frame contains the encoded data for a fixed number of
528  * samples per channel. The data for every channel might be split
529  * into several subframes. This function will reconstruct the list of
530  * subframes for every channel.
531  *
532  * If the subframes are not evenly split, the algorithm estimates the
533  * channels with the lowest number of total samples.
534  * Afterwards, for each of these channels a bit is read from the
535  * bitstream that indicates if the channel contains a subframe with the
536  * next subframe size that is going to be read from the bitstream or not.
537  * If a channel contains such a subframe, the subframe size gets added to
538  * the channel's subframe list.
539  * The algorithm repeats these steps until the frame is properly divided
540  * between the individual channels.
541  *
542  *@param s context
543  *@return 0 on success, < 0 in case of an error
544  */
546 {
547  uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
548  uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
549  int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
550  int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
551  int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
552  int c;
553 
554  /* Should never consume more than 3073 bits (256 iterations for the
555  * while loop when always the minimum amount of 128 samples is subtracted
556  * from missing samples in the 8 channel case).
557  * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
558  */
559 
560  /** reset tiling information */
561  for (c = 0; c < s->avctx->channels; c++)
562  s->channel[c].num_subframes = 0;
563 
564  if (s->max_num_subframes == 1 || get_bits1(&s->gb))
565  fixed_channel_layout = 1;
566 
567  /** loop until the frame data is split between the subframes */
568  do {
569  int subframe_len;
570 
571  /** check which channels contain the subframe */
572  for (c = 0; c < s->avctx->channels; c++) {
573  if (num_samples[c] == min_channel_len) {
574  if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
575  (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
576  contains_subframe[c] = 1;
577  else
578  contains_subframe[c] = get_bits1(&s->gb);
579  } else
580  contains_subframe[c] = 0;
581  }
582 
583  /** get subframe length, subframe_len == 0 is not allowed */
584  if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
585  return AVERROR_INVALIDDATA;
586 
587  /** add subframes to the individual channels and find new min_channel_len */
588  min_channel_len += subframe_len;
589  for (c = 0; c < s->avctx->channels; c++) {
590  WMAProChannelCtx* chan = &s->channel[c];
591 
592  if (contains_subframe[c]) {
593  if (chan->num_subframes >= MAX_SUBFRAMES) {
595  "broken frame: num subframes > 31\n");
596  return AVERROR_INVALIDDATA;
597  }
598  chan->subframe_len[chan->num_subframes] = subframe_len;
599  num_samples[c] += subframe_len;
600  ++chan->num_subframes;
601  if (num_samples[c] > s->samples_per_frame) {
602  av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
603  "channel len > samples_per_frame\n");
604  return AVERROR_INVALIDDATA;
605  }
606  } else if (num_samples[c] <= min_channel_len) {
607  if (num_samples[c] < min_channel_len) {
608  channels_for_cur_subframe = 0;
609  min_channel_len = num_samples[c];
610  }
611  ++channels_for_cur_subframe;
612  }
613  }
614  } while (min_channel_len < s->samples_per_frame);
615 
616  for (c = 0; c < s->avctx->channels; c++) {
617  int i;
618  int offset = 0;
619  for (i = 0; i < s->channel[c].num_subframes; i++) {
620  av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
621  " len %i\n", s->frame_num, c, i,
622  s->channel[c].subframe_len[i]);
623  s->channel[c].subframe_offset[i] = offset;
624  offset += s->channel[c].subframe_len[i];
625  }
626  }
627 
628  return 0;
629 }
630 
631 /**
632  *@brief Calculate a decorrelation matrix from the bitstream parameters.
633  *@param s codec context
634  *@param chgroup channel group for which the matrix needs to be calculated
635  */
637  WMAProChannelGrp *chgroup)
638 {
639  int i;
640  int offset = 0;
641  int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
642  memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
643  s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
644 
645  for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
646  rotation_offset[i] = get_bits(&s->gb, 6);
647 
648  for (i = 0; i < chgroup->num_channels; i++)
649  chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
650  get_bits1(&s->gb) ? 1.0 : -1.0;
651 
652  for (i = 1; i < chgroup->num_channels; i++) {
653  int x;
654  for (x = 0; x < i; x++) {
655  int y;
656  for (y = 0; y < i + 1; y++) {
657  float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
658  float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
659  int n = rotation_offset[offset + x];
660  float sinv;
661  float cosv;
662 
663  if (n < 32) {
664  sinv = sin64[n];
665  cosv = sin64[32 - n];
666  } else {
667  sinv = sin64[64 - n];
668  cosv = -sin64[n - 32];
669  }
670 
671  chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
672  (v1 * sinv) - (v2 * cosv);
673  chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
674  (v1 * cosv) + (v2 * sinv);
675  }
676  }
677  offset += i;
678  }
679 }
680 
681 /**
682  *@brief Decode channel transformation parameters
683  *@param s codec context
684  *@return >= 0 in case of success, < 0 in case of bitstream errors
685  */
687 {
688  int i;
689  /* should never consume more than 1921 bits for the 8 channel case
690  * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
691  * + MAX_CHANNELS + MAX_BANDS + 1)
692  */
693 
694  /** in the one channel case channel transforms are pointless */
695  s->num_chgroups = 0;
696  if (s->avctx->channels > 1) {
697  int remaining_channels = s->channels_for_cur_subframe;
698 
699  if (get_bits1(&s->gb)) {
701  "Channel transform bit");
702  return AVERROR_PATCHWELCOME;
703  }
704 
705  for (s->num_chgroups = 0; remaining_channels &&
707  WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
708  float** channel_data = chgroup->channel_data;
709  chgroup->num_channels = 0;
710  chgroup->transform = 0;
711 
712  /** decode channel mask */
713  if (remaining_channels > 2) {
714  for (i = 0; i < s->channels_for_cur_subframe; i++) {
715  int channel_idx = s->channel_indexes_for_cur_subframe[i];
716  if (!s->channel[channel_idx].grouped
717  && get_bits1(&s->gb)) {
718  ++chgroup->num_channels;
719  s->channel[channel_idx].grouped = 1;
720  *channel_data++ = s->channel[channel_idx].coeffs;
721  }
722  }
723  } else {
724  chgroup->num_channels = remaining_channels;
725  for (i = 0; i < s->channels_for_cur_subframe; i++) {
726  int channel_idx = s->channel_indexes_for_cur_subframe[i];
727  if (!s->channel[channel_idx].grouped)
728  *channel_data++ = s->channel[channel_idx].coeffs;
729  s->channel[channel_idx].grouped = 1;
730  }
731  }
732 
733  /** decode transform type */
734  if (chgroup->num_channels == 2) {
735  if (get_bits1(&s->gb)) {
736  if (get_bits1(&s->gb)) {
738  "Unknown channel transform type");
739  return AVERROR_PATCHWELCOME;
740  }
741  } else {
742  chgroup->transform = 1;
743  if (s->avctx->channels == 2) {
744  chgroup->decorrelation_matrix[0] = 1.0;
745  chgroup->decorrelation_matrix[1] = -1.0;
746  chgroup->decorrelation_matrix[2] = 1.0;
747  chgroup->decorrelation_matrix[3] = 1.0;
748  } else {
749  /** cos(pi/4) */
750  chgroup->decorrelation_matrix[0] = 0.70703125;
751  chgroup->decorrelation_matrix[1] = -0.70703125;
752  chgroup->decorrelation_matrix[2] = 0.70703125;
753  chgroup->decorrelation_matrix[3] = 0.70703125;
754  }
755  }
756  } else if (chgroup->num_channels > 2) {
757  if (get_bits1(&s->gb)) {
758  chgroup->transform = 1;
759  if (get_bits1(&s->gb)) {
760  decode_decorrelation_matrix(s, chgroup);
761  } else {
762  /** FIXME: more than 6 coupled channels not supported */
763  if (chgroup->num_channels > 6) {
765  "Coupled channels > 6");
766  } else {
767  memcpy(chgroup->decorrelation_matrix,
769  chgroup->num_channels * chgroup->num_channels *
770  sizeof(*chgroup->decorrelation_matrix));
771  }
772  }
773  }
774  }
775 
776  /** decode transform on / off */
777  if (chgroup->transform) {
778  if (!get_bits1(&s->gb)) {
779  int i;
780  /** transform can be enabled for individual bands */
781  for (i = 0; i < s->num_bands; i++) {
782  chgroup->transform_band[i] = get_bits1(&s->gb);
783  }
784  } else {
785  memset(chgroup->transform_band, 1, s->num_bands);
786  }
787  }
788  remaining_channels -= chgroup->num_channels;
789  }
790  }
791  return 0;
792 }
793 
794 /**
795  *@brief Extract the coefficients from the bitstream.
796  *@param s codec context
797  *@param c current channel number
798  *@return 0 on success, < 0 in case of bitstream errors
799  */
800 static int decode_coeffs(WMAProDecodeCtx *s, int c)
801 {
802  /* Integers 0..15 as single-precision floats. The table saves a
803  costly int to float conversion, and storing the values as
804  integers allows fast sign-flipping. */
805  static const uint32_t fval_tab[16] = {
806  0x00000000, 0x3f800000, 0x40000000, 0x40400000,
807  0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
808  0x41000000, 0x41100000, 0x41200000, 0x41300000,
809  0x41400000, 0x41500000, 0x41600000, 0x41700000,
810  };
811  int vlctable;
812  VLC* vlc;
813  WMAProChannelCtx* ci = &s->channel[c];
814  int rl_mode = 0;
815  int cur_coeff = 0;
816  int num_zeros = 0;
817  const uint16_t* run;
818  const float* level;
819 
820  av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
821 
822  vlctable = get_bits1(&s->gb);
823  vlc = &coef_vlc[vlctable];
824 
825  if (vlctable) {
826  run = coef1_run;
827  level = coef1_level;
828  } else {
829  run = coef0_run;
830  level = coef0_level;
831  }
832 
833  /** decode vector coefficients (consumes up to 167 bits per iteration for
834  4 vector coded large values) */
835  while ((s->transmit_num_vec_coeffs || !rl_mode) &&
836  (cur_coeff + 3 < ci->num_vec_coeffs)) {
837  uint32_t vals[4];
838  int i;
839  unsigned int idx;
840 
841  idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
842 
843  if (idx == HUFF_VEC4_SIZE - 1) {
844  for (i = 0; i < 4; i += 2) {
845  idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
846  if (idx == HUFF_VEC2_SIZE - 1) {
847  uint32_t v0, v1;
848  v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
849  if (v0 == HUFF_VEC1_SIZE - 1)
850  v0 += ff_wma_get_large_val(&s->gb);
851  v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
852  if (v1 == HUFF_VEC1_SIZE - 1)
853  v1 += ff_wma_get_large_val(&s->gb);
854  vals[i ] = av_float2int(v0);
855  vals[i+1] = av_float2int(v1);
856  } else {
857  vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
858  vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
859  }
860  }
861  } else {
862  vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
863  vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
864  vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
865  vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
866  }
867 
868  /** decode sign */
869  for (i = 0; i < 4; i++) {
870  if (vals[i]) {
871  uint32_t sign = get_bits1(&s->gb) - 1;
872  AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
873  num_zeros = 0;
874  } else {
875  ci->coeffs[cur_coeff] = 0;
876  /** switch to run level mode when subframe_len / 128 zeros
877  were found in a row */
878  rl_mode |= (++num_zeros > s->subframe_len >> 8);
879  }
880  ++cur_coeff;
881  }
882  }
883 
884  /** decode run level coded coefficients */
885  if (cur_coeff < s->subframe_len) {
886  memset(&ci->coeffs[cur_coeff], 0,
887  sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
888  if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
889  level, run, 1, ci->coeffs,
890  cur_coeff, s->subframe_len,
891  s->subframe_len, s->esc_len, 0))
892  return AVERROR_INVALIDDATA;
893  }
894 
895  return 0;
896 }
897 
898 /**
899  *@brief Extract scale factors from the bitstream.
900  *@param s codec context
901  *@return 0 on success, < 0 in case of bitstream errors
902  */
904 {
905  int i;
906 
907  /** should never consume more than 5344 bits
908  * MAX_CHANNELS * (1 + MAX_BANDS * 23)
909  */
910 
911  for (i = 0; i < s->channels_for_cur_subframe; i++) {
913  int* sf;
914  int* sf_end;
916  sf_end = s->channel[c].scale_factors + s->num_bands;
917 
918  /** resample scale factors for the new block size
919  * as the scale factors might need to be resampled several times
920  * before some new values are transmitted, a backup of the last
921  * transmitted scale factors is kept in saved_scale_factors
922  */
923  if (s->channel[c].reuse_sf) {
924  const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
925  int b;
926  for (b = 0; b < s->num_bands; b++)
927  s->channel[c].scale_factors[b] =
928  s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
929  }
930 
931  if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
932 
933  if (!s->channel[c].reuse_sf) {
934  int val;
935  /** decode DPCM coded scale factors */
936  s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
937  val = 45 / s->channel[c].scale_factor_step;
938  for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
939  val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
940  *sf = val;
941  }
942  } else {
943  int i;
944  /** run level decode differences to the resampled factors */
945  for (i = 0; i < s->num_bands; i++) {
946  int idx;
947  int skip;
948  int val;
949  int sign;
950 
951  idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
952 
953  if (!idx) {
954  uint32_t code = get_bits(&s->gb, 14);
955  val = code >> 6;
956  sign = (code & 1) - 1;
957  skip = (code & 0x3f) >> 1;
958  } else if (idx == 1) {
959  break;
960  } else {
961  skip = scale_rl_run[idx];
962  val = scale_rl_level[idx];
963  sign = get_bits1(&s->gb)-1;
964  }
965 
966  i += skip;
967  if (i >= s->num_bands) {
969  "invalid scale factor coding\n");
970  return AVERROR_INVALIDDATA;
971  }
972  s->channel[c].scale_factors[i] += (val ^ sign) - sign;
973  }
974  }
975  /** swap buffers */
977  s->channel[c].table_idx = s->table_idx;
978  s->channel[c].reuse_sf = 1;
979  }
980 
981  /** calculate new scale factor maximum */
983  for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
985  FFMAX(s->channel[c].max_scale_factor, *sf);
986  }
987 
988  }
989  return 0;
990 }
991 
992 /**
993  *@brief Reconstruct the individual channel data.
994  *@param s codec context
995  */
997 {
998  int i;
999 
1000  for (i = 0; i < s->num_chgroups; i++) {
1001  if (s->chgroup[i].transform) {
1002  float data[WMAPRO_MAX_CHANNELS];
1003  const int num_channels = s->chgroup[i].num_channels;
1004  float** ch_data = s->chgroup[i].channel_data;
1005  float** ch_end = ch_data + num_channels;
1006  const int8_t* tb = s->chgroup[i].transform_band;
1007  int16_t* sfb;
1008 
1009  /** multichannel decorrelation */
1010  for (sfb = s->cur_sfb_offsets;
1011  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1012  int y;
1013  if (*tb++ == 1) {
1014  /** multiply values with the decorrelation_matrix */
1015  for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1016  const float* mat = s->chgroup[i].decorrelation_matrix;
1017  const float* data_end = data + num_channels;
1018  float* data_ptr = data;
1019  float** ch;
1020 
1021  for (ch = ch_data; ch < ch_end; ch++)
1022  *data_ptr++ = (*ch)[y];
1023 
1024  for (ch = ch_data; ch < ch_end; ch++) {
1025  float sum = 0;
1026  data_ptr = data;
1027  while (data_ptr < data_end)
1028  sum += *data_ptr++ * *mat++;
1029 
1030  (*ch)[y] = sum;
1031  }
1032  }
1033  } else if (s->avctx->channels == 2) {
1034  int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1035  s->fdsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1036  ch_data[0] + sfb[0],
1037  181.0 / 128, len);
1038  s->fdsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1039  ch_data[1] + sfb[0],
1040  181.0 / 128, len);
1041  }
1042  }
1043  }
1044  }
1045 }
1046 
1047 /**
1048  *@brief Apply sine window and reconstruct the output buffer.
1049  *@param s codec context
1050  */
1052 {
1053  int i;
1054  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1055  int c = s->channel_indexes_for_cur_subframe[i];
1056  float* window;
1057  int winlen = s->channel[c].prev_block_len;
1058  float* start = s->channel[c].coeffs - (winlen >> 1);
1059 
1060  if (s->subframe_len < winlen) {
1061  start += (winlen - s->subframe_len) >> 1;
1062  winlen = s->subframe_len;
1063  }
1064 
1065  window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1066 
1067  winlen >>= 1;
1068 
1069  s->fdsp.vector_fmul_window(start, start, start + winlen,
1070  window, winlen);
1071 
1073  }
1074 }
1075 
1076 /**
1077  *@brief Decode a single subframe (block).
1078  *@param s codec context
1079  *@return 0 on success, < 0 when decoding failed
1080  */
1082 {
1083  int offset = s->samples_per_frame;
1084  int subframe_len = s->samples_per_frame;
1085  int i;
1086  int total_samples = s->samples_per_frame * s->avctx->channels;
1087  int transmit_coeffs = 0;
1088  int cur_subwoofer_cutoff;
1089 
1090  s->subframe_offset = get_bits_count(&s->gb);
1091 
1092  /** reset channel context and find the next block offset and size
1093  == the next block of the channel with the smallest number of
1094  decoded samples
1095  */
1096  for (i = 0; i < s->avctx->channels; i++) {
1097  s->channel[i].grouped = 0;
1098  if (offset > s->channel[i].decoded_samples) {
1099  offset = s->channel[i].decoded_samples;
1100  subframe_len =
1102  }
1103  }
1104 
1105  av_dlog(s->avctx,
1106  "processing subframe with offset %i len %i\n", offset, subframe_len);
1107 
1108  /** get a list of all channels that contain the estimated block */
1110  for (i = 0; i < s->avctx->channels; i++) {
1111  const int cur_subframe = s->channel[i].cur_subframe;
1112  /** subtract already processed samples */
1113  total_samples -= s->channel[i].decoded_samples;
1114 
1115  /** and count if there are multiple subframes that match our profile */
1116  if (offset == s->channel[i].decoded_samples &&
1117  subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1118  total_samples -= s->channel[i].subframe_len[cur_subframe];
1119  s->channel[i].decoded_samples +=
1120  s->channel[i].subframe_len[cur_subframe];
1123  }
1124  }
1125 
1126  /** check if the frame will be complete after processing the
1127  estimated block */
1128  if (!total_samples)
1129  s->parsed_all_subframes = 1;
1130 
1131 
1132  av_dlog(s->avctx, "subframe is part of %i channels\n",
1134 
1135  /** calculate number of scale factor bands and their offsets */
1136  s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1137  s->num_bands = s->num_sfb[s->table_idx];
1139  cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1140 
1141  /** configure the decoder for the current subframe */
1142  offset += s->samples_per_frame >> 1;
1143 
1144  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1145  int c = s->channel_indexes_for_cur_subframe[i];
1146 
1147  s->channel[c].coeffs = &s->channel[c].out[offset];
1148  }
1149 
1150  s->subframe_len = subframe_len;
1151  s->esc_len = av_log2(s->subframe_len - 1) + 1;
1152 
1153  /** skip extended header if any */
1154  if (get_bits1(&s->gb)) {
1155  int num_fill_bits;
1156  if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1157  int len = get_bits(&s->gb, 4);
1158  num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
1159  }
1160 
1161  if (num_fill_bits >= 0) {
1162  if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1163  av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1164  return AVERROR_INVALIDDATA;
1165  }
1166 
1167  skip_bits_long(&s->gb, num_fill_bits);
1168  }
1169  }
1170 
1171  /** no idea for what the following bit is used */
1172  if (get_bits1(&s->gb)) {
1173  avpriv_request_sample(s->avctx, "Reserved bit");
1174  return AVERROR_PATCHWELCOME;
1175  }
1176 
1177 
1178  if (decode_channel_transform(s) < 0)
1179  return AVERROR_INVALIDDATA;
1180 
1181 
1182  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1183  int c = s->channel_indexes_for_cur_subframe[i];
1184  if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1185  transmit_coeffs = 1;
1186  }
1187 
1189  if (transmit_coeffs) {
1190  int step;
1191  int quant_step = 90 * s->bits_per_sample >> 4;
1192 
1193  /** decode number of vector coded coefficients */
1194  if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1195  int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1196  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1197  int c = s->channel_indexes_for_cur_subframe[i];
1198  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1199  if (num_vec_coeffs > s->subframe_len) {
1200  av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1201  return AVERROR_INVALIDDATA;
1202  }
1203  av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1204  s->channel[c].num_vec_coeffs = num_vec_coeffs;
1205  }
1206  } else {
1207  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1208  int c = s->channel_indexes_for_cur_subframe[i];
1210  }
1211  }
1212  /** decode quantization step */
1213  step = get_sbits(&s->gb, 6);
1214  quant_step += step;
1215  if (step == -32 || step == 31) {
1216  const int sign = (step == 31) - 1;
1217  int quant = 0;
1218  while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1219  (step = get_bits(&s->gb, 5)) == 31) {
1220  quant += 31;
1221  }
1222  quant_step += ((quant + step) ^ sign) - sign;
1223  }
1224  if (quant_step < 0) {
1225  av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1226  }
1227 
1228  /** decode quantization step modifiers for every channel */
1229 
1230  if (s->channels_for_cur_subframe == 1) {
1231  s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1232  } else {
1233  int modifier_len = get_bits(&s->gb, 3);
1234  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1235  int c = s->channel_indexes_for_cur_subframe[i];
1236  s->channel[c].quant_step = quant_step;
1237  if (get_bits1(&s->gb)) {
1238  if (modifier_len) {
1239  s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1240  } else
1241  ++s->channel[c].quant_step;
1242  }
1243  }
1244  }
1245 
1246  /** decode scale factors */
1247  if (decode_scale_factors(s) < 0)
1248  return AVERROR_INVALIDDATA;
1249  }
1250 
1251  av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1252  get_bits_count(&s->gb) - s->subframe_offset);
1253 
1254  /** parse coefficients */
1255  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1256  int c = s->channel_indexes_for_cur_subframe[i];
1257  if (s->channel[c].transmit_coefs &&
1258  get_bits_count(&s->gb) < s->num_saved_bits) {
1259  decode_coeffs(s, c);
1260  } else
1261  memset(s->channel[c].coeffs, 0,
1262  sizeof(*s->channel[c].coeffs) * subframe_len);
1263  }
1264 
1265  av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1266  get_bits_count(&s->gb) - s->subframe_offset);
1267 
1268  if (transmit_coeffs) {
1269  FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1270  /** reconstruct the per channel data */
1272  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1273  int c = s->channel_indexes_for_cur_subframe[i];
1274  const int* sf = s->channel[c].scale_factors;
1275  int b;
1276 
1277  if (c == s->lfe_channel)
1278  memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1279  (subframe_len - cur_subwoofer_cutoff));
1280 
1281  /** inverse quantization and rescaling */
1282  for (b = 0; b < s->num_bands; b++) {
1283  const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1284  const int exp = s->channel[c].quant_step -
1285  (s->channel[c].max_scale_factor - *sf++) *
1286  s->channel[c].scale_factor_step;
1287  const float quant = pow(10.0, exp / 20.0);
1288  int start = s->cur_sfb_offsets[b];
1289  s->fdsp.vector_fmul_scalar(s->tmp + start,
1290  s->channel[c].coeffs + start,
1291  quant, end - start);
1292  }
1293 
1294  /** apply imdct (imdct_half == DCTIV with reverse) */
1295  mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1296  }
1297  }
1298 
1299  /** window and overlapp-add */
1300  wmapro_window(s);
1301 
1302  /** handled one subframe */
1303  for (i = 0; i < s->channels_for_cur_subframe; i++) {
1304  int c = s->channel_indexes_for_cur_subframe[i];
1305  if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1306  av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1307  return AVERROR_INVALIDDATA;
1308  }
1309  ++s->channel[c].cur_subframe;
1310  }
1311 
1312  return 0;
1313 }
1314 
1315 /**
1316  *@brief Decode one WMA frame.
1317  *@param s codec context
1318  *@return 0 if the trailer bit indicates that this is the last frame,
1319  * 1 if there are additional frames
1320  */
1321 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1322 {
1323  AVCodecContext *avctx = s->avctx;
1324  GetBitContext* gb = &s->gb;
1325  int more_frames = 0;
1326  int len = 0;
1327  int i, ret;
1328 
1329  /** get frame length */
1330  if (s->len_prefix)
1331  len = get_bits(gb, s->log2_frame_size);
1332 
1333  av_dlog(s->avctx, "decoding frame with length %x\n", len);
1334 
1335  /** decode tile information */
1336  if (decode_tilehdr(s)) {
1337  s->packet_loss = 1;
1338  return 0;
1339  }
1340 
1341  /** read postproc transform */
1342  if (s->avctx->channels > 1 && get_bits1(gb)) {
1343  if (get_bits1(gb)) {
1344  for (i = 0; i < avctx->channels * avctx->channels; i++)
1345  skip_bits(gb, 4);
1346  }
1347  }
1348 
1349  /** read drc info */
1350  if (s->dynamic_range_compression) {
1351  s->drc_gain = get_bits(gb, 8);
1352  av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1353  }
1354 
1355  /** no idea what these are for, might be the number of samples
1356  that need to be skipped at the beginning or end of a stream */
1357  if (get_bits1(gb)) {
1358  int av_unused skip;
1359 
1360  /** usually true for the first frame */
1361  if (get_bits1(gb)) {
1362  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1363  av_dlog(s->avctx, "start skip: %i\n", skip);
1364  }
1365 
1366  /** sometimes true for the last frame */
1367  if (get_bits1(gb)) {
1368  skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1369  av_dlog(s->avctx, "end skip: %i\n", skip);
1370  }
1371 
1372  }
1373 
1374  av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1375  get_bits_count(gb) - s->frame_offset);
1376 
1377  /** reset subframe states */
1378  s->parsed_all_subframes = 0;
1379  for (i = 0; i < avctx->channels; i++) {
1380  s->channel[i].decoded_samples = 0;
1381  s->channel[i].cur_subframe = 0;
1382  s->channel[i].reuse_sf = 0;
1383  }
1384 
1385  /** decode all subframes */
1386  while (!s->parsed_all_subframes) {
1387  if (decode_subframe(s) < 0) {
1388  s->packet_loss = 1;
1389  return 0;
1390  }
1391  }
1392 
1393  /* get output buffer */
1394  frame->nb_samples = s->samples_per_frame;
1395  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1396  s->packet_loss = 1;
1397  return 0;
1398  }
1399 
1400  /** copy samples to the output buffer */
1401  for (i = 0; i < avctx->channels; i++)
1402  memcpy(frame->extended_data[i], s->channel[i].out,
1403  s->samples_per_frame * sizeof(*s->channel[i].out));
1404 
1405  for (i = 0; i < avctx->channels; i++) {
1406  /** reuse second half of the IMDCT output for the next frame */
1407  memcpy(&s->channel[i].out[0],
1408  &s->channel[i].out[s->samples_per_frame],
1409  s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1410  }
1411 
1412  if (s->skip_frame) {
1413  s->skip_frame = 0;
1414  *got_frame_ptr = 0;
1415  av_frame_unref(frame);
1416  } else {
1417  *got_frame_ptr = 1;
1418  }
1419 
1420  if (s->len_prefix) {
1421  if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1422  /** FIXME: not sure if this is always an error */
1424  "frame[%i] would have to skip %i bits\n", s->frame_num,
1425  len - (get_bits_count(gb) - s->frame_offset) - 1);
1426  s->packet_loss = 1;
1427  return 0;
1428  }
1429 
1430  /** skip the rest of the frame data */
1431  skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1432  } else {
1433  while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1434  }
1435  }
1436 
1437  /** decode trailer bit */
1438  more_frames = get_bits1(gb);
1439 
1440  ++s->frame_num;
1441  return more_frames;
1442 }
1443 
1444 /**
1445  *@brief Calculate remaining input buffer length.
1446  *@param s codec context
1447  *@param gb bitstream reader context
1448  *@return remaining size in bits
1449  */
1451 {
1452  return s->buf_bit_size - get_bits_count(gb);
1453 }
1454 
1455 /**
1456  *@brief Fill the bit reservoir with a (partial) frame.
1457  *@param s codec context
1458  *@param gb bitstream reader context
1459  *@param len length of the partial frame
1460  *@param append decides whether to reset the buffer or not
1461  */
1463  int append)
1464 {
1465  int buflen;
1466 
1467  /** when the frame data does not need to be concatenated, the input buffer
1468  is reset and additional bits from the previous frame are copied
1469  and skipped later so that a fast byte copy is possible */
1470 
1471  if (!append) {
1472  s->frame_offset = get_bits_count(gb) & 7;
1473  s->num_saved_bits = s->frame_offset;
1475  }
1476 
1477  buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
1478 
1479  if (len <= 0 || buflen > MAX_FRAMESIZE) {
1480  avpriv_request_sample(s->avctx, "Too small input buffer");
1481  s->packet_loss = 1;
1482  return;
1483  }
1484 
1485  av_assert0(len <= put_bits_left(&s->pb));
1486 
1487  s->num_saved_bits += len;
1488  if (!append) {
1489  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1490  s->num_saved_bits);
1491  } else {
1492  int align = 8 - (get_bits_count(gb) & 7);
1493  align = FFMIN(align, len);
1494  put_bits(&s->pb, align, get_bits(gb, align));
1495  len -= align;
1496  avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1497  }
1498  skip_bits_long(gb, len);
1499 
1500  {
1501  PutBitContext tmp = s->pb;
1502  flush_put_bits(&tmp);
1503  }
1504 
1506  skip_bits(&s->gb, s->frame_offset);
1507 }
1508 
1509 /**
1510  *@brief Decode a single WMA packet.
1511  *@param avctx codec context
1512  *@param data the output buffer
1513  *@param avpkt input packet
1514  *@return number of bytes that were read from the input buffer
1515  */
1516 static int decode_packet(AVCodecContext *avctx, void *data,
1517  int *got_frame_ptr, AVPacket* avpkt)
1518 {
1519  WMAProDecodeCtx *s = avctx->priv_data;
1520  GetBitContext* gb = &s->pgb;
1521  const uint8_t* buf = avpkt->data;
1522  int buf_size = avpkt->size;
1523  int num_bits_prev_frame;
1524  int packet_sequence_number;
1525 
1526  *got_frame_ptr = 0;
1527 
1528  if (s->packet_done || s->packet_loss) {
1529  s->packet_done = 0;
1530 
1531  /** sanity check for the buffer length */
1532  if (buf_size < avctx->block_align) {
1533  av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1534  buf_size, avctx->block_align);
1535  return AVERROR_INVALIDDATA;
1536  }
1537 
1538  s->next_packet_start = buf_size - avctx->block_align;
1539  buf_size = avctx->block_align;
1540  s->buf_bit_size = buf_size << 3;
1541 
1542  /** parse packet header */
1543  init_get_bits(gb, buf, s->buf_bit_size);
1544  packet_sequence_number = get_bits(gb, 4);
1545  skip_bits(gb, 2);
1546 
1547  /** get number of bits that need to be added to the previous frame */
1548  num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1549  av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1550  num_bits_prev_frame);
1551 
1552  /** check for packet loss */
1553  if (!s->packet_loss &&
1554  ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1555  s->packet_loss = 1;
1556  av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1557  s->packet_sequence_number, packet_sequence_number);
1558  }
1559  s->packet_sequence_number = packet_sequence_number;
1560 
1561  if (num_bits_prev_frame > 0) {
1562  int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1563  if (num_bits_prev_frame >= remaining_packet_bits) {
1564  num_bits_prev_frame = remaining_packet_bits;
1565  s->packet_done = 1;
1566  }
1567 
1568  /** append the previous frame data to the remaining data from the
1569  previous packet to create a full frame */
1570  save_bits(s, gb, num_bits_prev_frame, 1);
1571  av_dlog(avctx, "accumulated %x bits of frame data\n",
1572  s->num_saved_bits - s->frame_offset);
1573 
1574  /** decode the cross packet frame if it is valid */
1575  if (!s->packet_loss)
1576  decode_frame(s, data, got_frame_ptr);
1577  } else if (s->num_saved_bits - s->frame_offset) {
1578  av_dlog(avctx, "ignoring %x previously saved bits\n",
1579  s->num_saved_bits - s->frame_offset);
1580  }
1581 
1582  if (s->packet_loss) {
1583  /** reset number of saved bits so that the decoder
1584  does not start to decode incomplete frames in the
1585  s->len_prefix == 0 case */
1586  s->num_saved_bits = 0;
1587  s->packet_loss = 0;
1588  }
1589 
1590  } else {
1591  int frame_size;
1592  s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1593  init_get_bits(gb, avpkt->data, s->buf_bit_size);
1594  skip_bits(gb, s->packet_offset);
1595  if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1596  (frame_size = show_bits(gb, s->log2_frame_size)) &&
1597  frame_size <= remaining_bits(s, gb)) {
1598  save_bits(s, gb, frame_size, 0);
1599  if (!s->packet_loss)
1600  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1601  } else if (!s->len_prefix
1602  && s->num_saved_bits > get_bits_count(&s->gb)) {
1603  /** when the frames do not have a length prefix, we don't know
1604  the compressed length of the individual frames
1605  however, we know what part of a new packet belongs to the
1606  previous frame
1607  therefore we save the incoming packet first, then we append
1608  the "previous frame" data from the next packet so that
1609  we get a buffer that only contains full frames */
1610  s->packet_done = !decode_frame(s, data, got_frame_ptr);
1611  } else
1612  s->packet_done = 1;
1613  }
1614 
1615  if (s->packet_done && !s->packet_loss &&
1616  remaining_bits(s, gb) > 0) {
1617  /** save the rest of the data so that it can be decoded
1618  with the next packet */
1619  save_bits(s, gb, remaining_bits(s, gb), 0);
1620  }
1621 
1622  s->packet_offset = get_bits_count(gb) & 7;
1623  if (s->packet_loss)
1624  return AVERROR_INVALIDDATA;
1625 
1626  return get_bits_count(gb) >> 3;
1627 }
1628 
1629 /**
1630  *@brief Clear decoder buffers (for seeking).
1631  *@param avctx codec context
1632  */
1633 static void flush(AVCodecContext *avctx)
1634 {
1635  WMAProDecodeCtx *s = avctx->priv_data;
1636  int i;
1637  /** reset output buffer as a part of it is used during the windowing of a
1638  new frame */
1639  for (i = 0; i < avctx->channels; i++)
1640  memset(s->channel[i].out, 0, s->samples_per_frame *
1641  sizeof(*s->channel[i].out));
1642  s->packet_loss = 1;
1643 }
1644 
1645 
1646 /**
1647  *@brief wmapro decoder
1648  */
1650  .name = "wmapro",
1651  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1652  .type = AVMEDIA_TYPE_AUDIO,
1653  .id = AV_CODEC_ID_WMAPRO,
1654  .priv_data_size = sizeof(WMAProDecodeCtx),
1655  .init = decode_init,
1656  .close = decode_end,
1657  .decode = decode_packet,
1658  .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1659  .flush = flush,
1660  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1662 };