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