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