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