ffmpeg / libavcodec / wmaprodec.c @ 26f548bb
History  View  Annotate  Download (62.7 KB)
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 Libav.

7 
*

8 
* Libav 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 
* Libav 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 Libav; if not, write to the Free Software

20 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 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 perchannel data

30 
*  rescaling and inverse quantization

31 
*  IMDCT

32 
*  windowing and overlappadd

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 huffmancoded 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 DPCMcoded.

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 "avcodec.h" 
90 
#include "internal.h" 
91 
#include "get_bits.h" 
92 
#include "put_bits.h" 
93 
#include "wmaprodata.h" 
94 
#include "dsputil.h" 
95 
#include "wma.h" 
96  
97 
/** current decoder limitations */

98 
#define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels 
99 
#define MAX_SUBFRAMES 32 ///< max number of subframes per channel 
100 
#define MAX_BANDS 29 ///< max number of scale factor bands 
101 
#define MAX_FRAMESIZE 32768 ///< maximum compressed frame size 
102  
103 
#define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size 
104 
#define WMAPRO_BLOCK_MAX_BITS 12 ///< log2 of max block size 
105 
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size 
106 
#define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS  WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes 
107  
108  
109 
#define VLCBITS 9 
110 
#define SCALEVLCBITS 8 
111 
#define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS1)/VLCBITS) 
112 
#define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS1)/VLCBITS) 
113 
#define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS1)/VLCBITS) 
114 
#define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS1)/SCALEVLCBITS) 
115 
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS1)/VLCBITS) 
116  
117 
static VLC sf_vlc; ///< scale factor DPCM vlc 
118 
static VLC sf_rl_vlc; ///< scale factor run length vlc 
119 
static VLC vec4_vlc; ///< 4 coefficients per symbol 
120 
static VLC vec2_vlc; ///< 2 coefficients per symbol 
121 
static VLC vec1_vlc; ///< 1 coefficient per symbol 
122 
static VLC coef_vlc[2]; ///< coefficient run length vlc codes 
123 
static float sin64[33]; ///< sinus table for decorrelation 
124  
125 
/**

126 
* @brief frame specific decoder context for a single channel

127 
*/

128 
typedef struct { 
129 
int16_t prev_block_len; ///< length of the previous block

130 
uint8_t transmit_coefs; 
131 
uint8_t num_subframes; 
132 
uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples

133 
uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame

134 
uint8_t cur_subframe; ///< current subframe number

135 
uint16_t decoded_samples; ///< number of already processed samples

136 
uint8_t grouped; ///< channel is part of a group

137 
int quant_step; ///< quantization step for the current subframe 
138 
int8_t reuse_sf; ///< share scale factors between subframes

139 
int8_t scale_factor_step; ///< scaling step for the current subframe

140 
int max_scale_factor; ///< maximum scale factor for the current subframe 
141 
int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values 
142 
int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)

143 
int* scale_factors; ///< pointer to the scale factor values used for decoding 
144 
uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block

145 
float* coeffs; ///< pointer to the subframe decode buffer 
146 
uint16_t num_vec_coeffs; ///< number of vector coded coefficients

147 
DECLARE_ALIGNED(16, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer 
148 
} WMAProChannelCtx; 
149  
150 
/**

151 
* @brief channel group for channel transformations

152 
*/

153 
typedef struct { 
154 
uint8_t num_channels; ///< number of channels in the group

155 
int8_t transform; ///< transform on / off

156 
int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band

157 
float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];

158 
float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients 
159 
} WMAProChannelGrp; 
160  
161 
/**

162 
* @brief main decoder context

163 
*/

164 
typedef struct WMAProDecodeCtx { 
165 
/* generic decoder variables */

166 
AVCodecContext* avctx; ///< codec context for av_log

167 
DSPContext dsp; ///< accelerated DSP functions

168 
uint8_t frame_data[MAX_FRAMESIZE + 
169 
FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data

170 
PutBitContext pb; ///< context for filling the frame_data buffer

171 
FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size

172 
DECLARE_ALIGNED(16, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer 
173 
float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes 
174  
175 
/* frame size dependent frame information (set during initialization) */

176 
uint32_t decode_flags; ///< used compression features

177 
uint8_t len_prefix; ///< frame is prefixed with its length

178 
uint8_t dynamic_range_compression; ///< frame contains DRC data

179 
uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [1.0, 1.0])

180 
uint16_t samples_per_frame; ///< number of samples to output

181 
uint16_t log2_frame_size; 
182 
int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)

183 
int8_t lfe_channel; ///< lfe channel index

184 
uint8_t max_num_subframes; 
185 
uint8_t subframe_len_bits; ///< number of bits used for the subframe length

186 
uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1

187 
uint16_t min_samples_per_subframe; 
188 
int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size

189 
int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)

190 
int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix

191 
int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values

192  
193 
/* packet decode state */

194 
GetBitContext pgb; ///< bitstream reader context for the packet

195 
int next_packet_start; ///< start offset of the next wma packet in the demuxer packet 
196 
uint8_t packet_offset; ///< frame offset in the packet

197 
uint8_t packet_sequence_number; ///< current packet number

198 
int num_saved_bits; ///< saved number of bits 
199 
int frame_offset; ///< frame offset in the bit reservoir 
200 
int subframe_offset; ///< subframe offset in the bit reservoir 
201 
uint8_t packet_loss; ///< set in case of bitstream error

202 
uint8_t packet_done; ///< set when a packet is fully decoded

203  
204 
/* frame decode state */

205 
uint32_t frame_num; ///< current frame number (not used for decoding)

206 
GetBitContext gb; ///< bitstream reader context

207 
int buf_bit_size; ///< buffer size in bits 
208 
float* samples; ///< current samplebuffer pointer 
209 
float* samples_end; ///< maximum samplebuffer pointer 
210 
uint8_t drc_gain; ///< gain for the DRC tool

211 
int8_t skip_frame; ///< skip output step

212 
int8_t parsed_all_subframes; ///< all subframes decoded?

213  
214 
/* subframe/block decode state */

215 
int16_t subframe_len; ///< current subframe length

216 
int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe

217 
int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]; 
218 
int8_t num_bands; ///< number of scale factor bands

219 
int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream

220 
int16_t* cur_sfb_offsets; ///< sfb offsets for the current block

221 
uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables

222 
int8_t esc_len; ///< length of escaped coefficients

223  
224 
uint8_t num_chgroups; ///< number of channel groups

225 
WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information

226  
227 
WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data

228 
} WMAProDecodeCtx; 
229  
230  
231 
/**

232 
*@brief helper function to print the most important members of the context

233 
*@param s context

234 
*/

235 
static void av_cold dump_context(WMAProDecodeCtx *s) 
236 
{ 
237 
#define PRINT(a, b) av_log(s>avctx, AV_LOG_DEBUG, " %s = %d\n", a, b); 
238 
#define PRINT_HEX(a, b) av_log(s>avctx, AV_LOG_DEBUG, " %s = %x\n", a, b); 
239  
240 
PRINT("ed sample bit depth", s>bits_per_sample);

241 
PRINT_HEX("ed decode flags", s>decode_flags);

242 
PRINT("samples per frame", s>samples_per_frame);

243 
PRINT("log2 frame size", s>log2_frame_size);

244 
PRINT("max num subframes", s>max_num_subframes);

245 
PRINT("len prefix", s>len_prefix);

246 
PRINT("num channels", s>num_channels);

247 
} 
248  
249 
/**

250 
*@brief Uninitialize the decoder and free all resources.

251 
*@param avctx codec context

252 
*@return 0 on success, < 0 otherwise

253 
*/

254 
static av_cold int decode_end(AVCodecContext *avctx) 
255 
{ 
256 
WMAProDecodeCtx *s = avctx>priv_data; 
257 
int i;

258  
259 
for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) 
260 
ff_mdct_end(&s>mdct_ctx[i]); 
261  
262 
return 0; 
263 
} 
264  
265 
/**

266 
*@brief Initialize the decoder.

267 
*@param avctx codec context

268 
*@return 0 on success, 1 otherwise

269 
*/

270 
static av_cold int decode_init(AVCodecContext *avctx) 
271 
{ 
272 
WMAProDecodeCtx *s = avctx>priv_data; 
273 
uint8_t *edata_ptr = avctx>extradata; 
274 
unsigned int channel_mask; 
275 
int i;

276 
int log2_max_num_subframes;

277 
int num_possible_block_sizes;

278  
279 
s>avctx = avctx; 
280 
dsputil_init(&s>dsp, avctx); 
281 
init_put_bits(&s>pb, s>frame_data, MAX_FRAMESIZE); 
282  
283 
avctx>sample_fmt = AV_SAMPLE_FMT_FLT; 
284  
285 
if (avctx>extradata_size >= 18) { 
286 
s>decode_flags = AV_RL16(edata_ptr+14);

287 
channel_mask = AV_RL32(edata_ptr+2);

288 
s>bits_per_sample = AV_RL16(edata_ptr); 
289 
/** dump the extradata */

290 
for (i = 0; i < avctx>extradata_size; i++) 
291 
av_dlog(avctx, "[%x] ", avctx>extradata[i]);

292 
av_dlog(avctx, "\n");

293  
294 
} else {

295 
av_log_ask_for_sample(avctx, "Unknown extradata size\n");

296 
return AVERROR_INVALIDDATA;

297 
} 
298  
299 
/** generic init */

300 
s>log2_frame_size = av_log2(avctx>block_align) + 4;

301  
302 
/** frame info */

303 
s>skip_frame = 1; /* skip first frame */ 
304 
s>packet_loss = 1;

305 
s>len_prefix = (s>decode_flags & 0x40);

306  
307 
/** get frame len */

308 
s>samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx>sample_rate,

309 
3, s>decode_flags);

310  
311 
/** init previous block len */

312 
for (i = 0; i < avctx>channels; i++) 
313 
s>channel[i].prev_block_len = s>samples_per_frame; 
314  
315 
/** subframe info */

316 
log2_max_num_subframes = ((s>decode_flags & 0x38) >> 3); 
317 
s>max_num_subframes = 1 << log2_max_num_subframes;

318 
if (s>max_num_subframes == 16  s>max_num_subframes == 4) 
319 
s>max_subframe_len_bit = 1;

320 
s>subframe_len_bits = av_log2(log2_max_num_subframes) + 1;

321  
322 
num_possible_block_sizes = log2_max_num_subframes + 1;

323 
s>min_samples_per_subframe = s>samples_per_frame / s>max_num_subframes; 
324 
s>dynamic_range_compression = (s>decode_flags & 0x80);

325  
326 
if (s>max_num_subframes > MAX_SUBFRAMES) {

327 
av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",

328 
s>max_num_subframes); 
329 
return AVERROR_INVALIDDATA;

330 
} 
331  
332 
s>num_channels = avctx>channels; 
333  
334 
/** extract lfe channel position */

335 
s>lfe_channel = 1;

336  
337 
if (channel_mask & 8) { 
338 
unsigned int mask; 
339 
for (mask = 1; mask < 16; mask <<= 1) { 
340 
if (channel_mask & mask)

341 
++s>lfe_channel; 
342 
} 
343 
} 
344  
345 
if (s>num_channels < 0) { 
346 
av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s>num_channels);

347 
return AVERROR_INVALIDDATA;

348 
} else if (s>num_channels > WMAPRO_MAX_CHANNELS) { 
349 
av_log_ask_for_sample(avctx, "unsupported number of channels\n");

350 
return AVERROR_PATCHWELCOME;

351 
} 
352  
353 
INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE, 
354 
scale_huffbits, 1, 1, 
355 
scale_huffcodes, 2, 2, 616); 
356  
357 
INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE, 
358 
scale_rl_huffbits, 1, 1, 
359 
scale_rl_huffcodes, 4, 4, 1406); 
360  
361 
INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,

362 
coef0_huffbits, 1, 1, 
363 
coef0_huffcodes, 4, 4, 2108); 
364  
365 
INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,

366 
coef1_huffbits, 1, 1, 
367 
coef1_huffcodes, 4, 4, 3912); 
368  
369 
INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE, 
370 
vec4_huffbits, 1, 1, 
371 
vec4_huffcodes, 2, 2, 604); 
372  
373 
INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE, 
374 
vec2_huffbits, 1, 1, 
375 
vec2_huffcodes, 2, 2, 562); 
376  
377 
INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE, 
378 
vec1_huffbits, 1, 1, 
379 
vec1_huffcodes, 2, 2, 562); 
380  
381 
/** calculate number of scale factor bands and their offsets

382 
for every possible block size */

383 
for (i = 0; i < num_possible_block_sizes; i++) { 
384 
int subframe_len = s>samples_per_frame >> i;

385 
int x;

386 
int band = 1; 
387  
388 
s>sfb_offsets[i][0] = 0; 
389  
390 
for (x = 0; x < MAX_BANDS1 && s>sfb_offsets[i][band  1] < subframe_len; x++) { 
391 
int offset = (subframe_len * 2 * critical_freq[x]) 
392 
/ s>avctx>sample_rate + 2;

393 
offset &= ~3;

394 
if (offset > s>sfb_offsets[i][band  1]) 
395 
s>sfb_offsets[i][band++] = offset; 
396 
} 
397 
s>sfb_offsets[i][band  1] = subframe_len;

398 
s>num_sfb[i] = band  1;

399 
} 
400  
401  
402 
/** Scale factors can be shared between blocks of different size

403 
as every block has a different scale factor band layout.

404 
The matrix sf_offsets is needed to find the correct scale factor.

405 
*/

406  
407 
for (i = 0; i < num_possible_block_sizes; i++) { 
408 
int b;

409 
for (b = 0; b < s>num_sfb[i]; b++) { 
410 
int x;

411 
int offset = ((s>sfb_offsets[i][b]

412 
+ s>sfb_offsets[i][b + 1]  1) << i) >> 1; 
413 
for (x = 0; x < num_possible_block_sizes; x++) { 
414 
int v = 0; 
415 
while (s>sfb_offsets[x][v + 1] << x < offset) 
416 
++v; 
417 
s>sf_offsets[i][x][b] = v; 
418 
} 
419 
} 
420 
} 
421  
422 
/** init MDCT, FIXME: only init needed sizes */

423 
for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) 
424 
ff_mdct_init(&s>mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1, 
425 
1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i  1)) 
426 
/ (1 << (s>bits_per_sample  1))); 
427  
428 
/** init MDCT windows: simple sinus window */

429 
for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) { 
430 
const int win_idx = WMAPRO_BLOCK_MAX_BITS  i; 
431 
ff_init_ff_sine_windows(win_idx); 
432 
s>windows[WMAPRO_BLOCK_SIZES  i  1] = ff_sine_windows[win_idx];

433 
} 
434  
435 
/** calculate subwoofer cutoff values */

436 
for (i = 0; i < num_possible_block_sizes; i++) { 
437 
int block_size = s>samples_per_frame >> i;

438 
int cutoff = (440*block_size + 3 * (s>avctx>sample_rate >> 1)  1) 
439 
/ s>avctx>sample_rate; 
440 
s>subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);

441 
} 
442  
443 
/** calculate sine values for the decorrelation matrix */

444 
for (i = 0; i < 33; i++) 
445 
sin64[i] = sin(i*M_PI / 64.0); 
446  
447 
if (avctx>debug & FF_DEBUG_BITSTREAM)

448 
dump_context(s); 
449  
450 
avctx>channel_layout = channel_mask; 
451 
return 0; 
452 
} 
453  
454 
/**

455 
*@brief Decode the subframe length.

456 
*@param s context

457 
*@param offset sample offset in the frame

458 
*@return decoded subframe length on success, < 0 in case of an error

459 
*/

460 
static int decode_subframe_length(WMAProDecodeCtx *s, int offset) 
461 
{ 
462 
int frame_len_shift = 0; 
463 
int subframe_len;

464  
465 
/** no need to read from the bitstream when only one length is possible */

466 
if (offset == s>samples_per_frame  s>min_samples_per_subframe)

467 
return s>min_samples_per_subframe;

468  
469 
/** 1 bit indicates if the subframe is of maximum length */

470 
if (s>max_subframe_len_bit) {

471 
if (get_bits1(&s>gb))

472 
frame_len_shift = 1 + get_bits(&s>gb, s>subframe_len_bits1); 
473 
} else

474 
frame_len_shift = get_bits(&s>gb, s>subframe_len_bits); 
475  
476 
subframe_len = s>samples_per_frame >> frame_len_shift; 
477  
478 
/** sanity check the length */

479 
if (subframe_len < s>min_samples_per_subframe 

480 
subframe_len > s>samples_per_frame) { 
481 
av_log(s>avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",

482 
subframe_len); 
483 
return AVERROR_INVALIDDATA;

484 
} 
485 
return subframe_len;

486 
} 
487  
488 
/**

489 
*@brief Decode how the data in the frame is split into subframes.

490 
* Every WMA frame contains the encoded data for a fixed number of

491 
* samples per channel. The data for every channel might be split

492 
* into several subframes. This function will reconstruct the list of

493 
* subframes for every channel.

494 
*

495 
* If the subframes are not evenly split, the algorithm estimates the

496 
* channels with the lowest number of total samples.

497 
* Afterwards, for each of these channels a bit is read from the

498 
* bitstream that indicates if the channel contains a subframe with the

499 
* next subframe size that is going to be read from the bitstream or not.

500 
* If a channel contains such a subframe, the subframe size gets added to

501 
* the channel's subframe list.

502 
* The algorithm repeats these steps until the frame is properly divided

503 
* between the individual channels.

504 
*

505 
*@param s context

506 
*@return 0 on success, < 0 in case of an error

507 
*/

508 
static int decode_tilehdr(WMAProDecodeCtx *s) 
509 
{ 
510 
uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /**< sum of samples for all currently known subframes of a channel */

511 
uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */

512 
int channels_for_cur_subframe = s>num_channels; /**< number of channels that contain the current subframe */ 
513 
int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */ 
514 
int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */ 
515 
int c;

516  
517 
/* Should never consume more than 3073 bits (256 iterations for the

518 
* while loop when always the minimum amount of 128 samples is substracted

519 
* from missing samples in the 8 channel case).

520 
* 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)

521 
*/

522  
523 
/** reset tiling information */

524 
for (c = 0; c < s>num_channels; c++) 
525 
s>channel[c].num_subframes = 0;

526  
527 
memset(num_samples, 0, sizeof(num_samples)); 
528  
529 
if (s>max_num_subframes == 1  get_bits1(&s>gb)) 
530 
fixed_channel_layout = 1;

531  
532 
/** loop until the frame data is split between the subframes */

533 
do {

534 
int subframe_len;

535  
536 
/** check which channels contain the subframe */

537 
for (c = 0; c < s>num_channels; c++) { 
538 
if (num_samples[c] == min_channel_len) {

539 
if (fixed_channel_layout  channels_for_cur_subframe == 1  
540 
(min_channel_len == s>samples_per_frame  s>min_samples_per_subframe)) 
541 
contains_subframe[c] = 1;

542 
else

543 
contains_subframe[c] = get_bits1(&s>gb); 
544 
} else

545 
contains_subframe[c] = 0;

546 
} 
547  
548 
/** get subframe length, subframe_len == 0 is not allowed */

549 
if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0) 
550 
return AVERROR_INVALIDDATA;

551  
552 
/** add subframes to the individual channels and find new min_channel_len */

553 
min_channel_len += subframe_len; 
554 
for (c = 0; c < s>num_channels; c++) { 
555 
WMAProChannelCtx* chan = &s>channel[c]; 
556  
557 
if (contains_subframe[c]) {

558 
if (chan>num_subframes >= MAX_SUBFRAMES) {

559 
av_log(s>avctx, AV_LOG_ERROR, 
560 
"broken frame: num subframes > 31\n");

561 
return AVERROR_INVALIDDATA;

562 
} 
563 
chan>subframe_len[chan>num_subframes] = subframe_len; 
564 
num_samples[c] += subframe_len; 
565 
++chan>num_subframes; 
566 
if (num_samples[c] > s>samples_per_frame) {

567 
av_log(s>avctx, AV_LOG_ERROR, "broken frame: "

568 
"channel len > samples_per_frame\n");

569 
return AVERROR_INVALIDDATA;

570 
} 
571 
} else if (num_samples[c] <= min_channel_len) { 
572 
if (num_samples[c] < min_channel_len) {

573 
channels_for_cur_subframe = 0;

574 
min_channel_len = num_samples[c]; 
575 
} 
576 
++channels_for_cur_subframe; 
577 
} 
578 
} 
579 
} while (min_channel_len < s>samples_per_frame);

580  
581 
for (c = 0; c < s>num_channels; c++) { 
582 
int i;

583 
int offset = 0; 
584 
for (i = 0; i < s>channel[c].num_subframes; i++) { 
585 
av_dlog(s>avctx, "frame[%i] channel[%i] subframe[%i]"

586 
" len %i\n", s>frame_num, c, i,

587 
s>channel[c].subframe_len[i]); 
588 
s>channel[c].subframe_offset[i] = offset; 
589 
offset += s>channel[c].subframe_len[i]; 
590 
} 
591 
} 
592  
593 
return 0; 
594 
} 
595  
596 
/**

597 
*@brief Calculate a decorrelation matrix from the bitstream parameters.

598 
*@param s codec context

599 
*@param chgroup channel group for which the matrix needs to be calculated

600 
*/

601 
static void decode_decorrelation_matrix(WMAProDecodeCtx *s, 
602 
WMAProChannelGrp *chgroup) 
603 
{ 
604 
int i;

605 
int offset = 0; 
606 
int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS]; 
607 
memset(chgroup>decorrelation_matrix, 0, s>num_channels *

608 
s>num_channels * sizeof(*chgroup>decorrelation_matrix));

609  
610 
for (i = 0; i < chgroup>num_channels * (chgroup>num_channels  1) >> 1; i++) 
611 
rotation_offset[i] = get_bits(&s>gb, 6);

612  
613 
for (i = 0; i < chgroup>num_channels; i++) 
614 
chgroup>decorrelation_matrix[chgroup>num_channels * i + i] = 
615 
get_bits1(&s>gb) ? 1.0 : 1.0; 
616  
617 
for (i = 1; i < chgroup>num_channels; i++) { 
618 
int x;

619 
for (x = 0; x < i; x++) { 
620 
int y;

621 
for (y = 0; y < i + 1; y++) { 
622 
float v1 = chgroup>decorrelation_matrix[x * chgroup>num_channels + y];

623 
float v2 = chgroup>decorrelation_matrix[i * chgroup>num_channels + y];

624 
int n = rotation_offset[offset + x];

625 
float sinv;

626 
float cosv;

627  
628 
if (n < 32) { 
629 
sinv = sin64[n]; 
630 
cosv = sin64[32  n];

631 
} else {

632 
sinv = sin64[64  n];

633 
cosv = sin64[n  32];

634 
} 
635  
636 
chgroup>decorrelation_matrix[y + x * chgroup>num_channels] = 
637 
(v1 * sinv)  (v2 * cosv); 
638 
chgroup>decorrelation_matrix[y + i * chgroup>num_channels] = 
639 
(v1 * cosv) + (v2 * sinv); 
640 
} 
641 
} 
642 
offset += i; 
643 
} 
644 
} 
645  
646 
/**

647 
*@brief Decode channel transformation parameters

648 
*@param s codec context

649 
*@return 0 in case of success, < 0 in case of bitstream errors

650 
*/

651 
static int decode_channel_transform(WMAProDecodeCtx* s) 
652 
{ 
653 
int i;

654 
/* should never consume more than 1921 bits for the 8 channel case

655 
* 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS

656 
* + MAX_CHANNELS + MAX_BANDS + 1)

657 
*/

658  
659 
/** in the one channel case channel transforms are pointless */

660 
s>num_chgroups = 0;

661 
if (s>num_channels > 1) { 
662 
int remaining_channels = s>channels_for_cur_subframe;

663  
664 
if (get_bits1(&s>gb)) {

665 
av_log_ask_for_sample(s>avctx, 
666 
"unsupported channel transform bit\n");

667 
return AVERROR_INVALIDDATA;

668 
} 
669  
670 
for (s>num_chgroups = 0; remaining_channels && 
671 
s>num_chgroups < s>channels_for_cur_subframe; s>num_chgroups++) { 
672 
WMAProChannelGrp* chgroup = &s>chgroup[s>num_chgroups]; 
673 
float** channel_data = chgroup>channel_data;

674 
chgroup>num_channels = 0;

675 
chgroup>transform = 0;

676  
677 
/** decode channel mask */

678 
if (remaining_channels > 2) { 
679 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
680 
int channel_idx = s>channel_indexes_for_cur_subframe[i];

681 
if (!s>channel[channel_idx].grouped

682 
&& get_bits1(&s>gb)) { 
683 
++chgroup>num_channels; 
684 
s>channel[channel_idx].grouped = 1;

685 
*channel_data++ = s>channel[channel_idx].coeffs; 
686 
} 
687 
} 
688 
} else {

689 
chgroup>num_channels = remaining_channels; 
690 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
691 
int channel_idx = s>channel_indexes_for_cur_subframe[i];

692 
if (!s>channel[channel_idx].grouped)

693 
*channel_data++ = s>channel[channel_idx].coeffs; 
694 
s>channel[channel_idx].grouped = 1;

695 
} 
696 
} 
697  
698 
/** decode transform type */

699 
if (chgroup>num_channels == 2) { 
700 
if (get_bits1(&s>gb)) {

701 
if (get_bits1(&s>gb)) {

702 
av_log_ask_for_sample(s>avctx, 
703 
"unsupported channel transform type\n");

704 
} 
705 
} else {

706 
chgroup>transform = 1;

707 
if (s>num_channels == 2) { 
708 
chgroup>decorrelation_matrix[0] = 1.0; 
709 
chgroup>decorrelation_matrix[1] = 1.0; 
710 
chgroup>decorrelation_matrix[2] = 1.0; 
711 
chgroup>decorrelation_matrix[3] = 1.0; 
712 
} else {

713 
/** cos(pi/4) */

714 
chgroup>decorrelation_matrix[0] = 0.70703125; 
715 
chgroup>decorrelation_matrix[1] = 0.70703125; 
716 
chgroup>decorrelation_matrix[2] = 0.70703125; 
717 
chgroup>decorrelation_matrix[3] = 0.70703125; 
718 
} 
719 
} 
720 
} else if (chgroup>num_channels > 2) { 
721 
if (get_bits1(&s>gb)) {

722 
chgroup>transform = 1;

723 
if (get_bits1(&s>gb)) {

724 
decode_decorrelation_matrix(s, chgroup); 
725 
} else {

726 
/** FIXME: more than 6 coupled channels not supported */

727 
if (chgroup>num_channels > 6) { 
728 
av_log_ask_for_sample(s>avctx, 
729 
"coupled channels > 6\n");

730 
} else {

731 
memcpy(chgroup>decorrelation_matrix, 
732 
default_decorrelation[chgroup>num_channels], 
733 
chgroup>num_channels * chgroup>num_channels * 
734 
sizeof(*chgroup>decorrelation_matrix));

735 
} 
736 
} 
737 
} 
738 
} 
739  
740 
/** decode transform on / off */

741 
if (chgroup>transform) {

742 
if (!get_bits1(&s>gb)) {

743 
int i;

744 
/** transform can be enabled for individual bands */

745 
for (i = 0; i < s>num_bands; i++) { 
746 
chgroup>transform_band[i] = get_bits1(&s>gb); 
747 
} 
748 
} else {

749 
memset(chgroup>transform_band, 1, s>num_bands);

750 
} 
751 
} 
752 
remaining_channels = chgroup>num_channels; 
753 
} 
754 
} 
755 
return 0; 
756 
} 
757  
758 
/**

759 
*@brief Extract the coefficients from the bitstream.

760 
*@param s codec context

761 
*@param c current channel number

762 
*@return 0 on success, < 0 in case of bitstream errors

763 
*/

764 
static int decode_coeffs(WMAProDecodeCtx *s, int c) 
765 
{ 
766 
/* Integers 0..15 as singleprecision floats. The table saves a

767 
costly int to float conversion, and storing the values as

768 
integers allows fast signflipping. */

769 
static const int fval_tab[16] = { 
770 
0x00000000, 0x3f800000, 0x40000000, 0x40400000, 
771 
0x40800000, 0x40a00000, 0x40c00000, 0x40e00000, 
772 
0x41000000, 0x41100000, 0x41200000, 0x41300000, 
773 
0x41400000, 0x41500000, 0x41600000, 0x41700000, 
774 
}; 
775 
int vlctable;

776 
VLC* vlc; 
777 
WMAProChannelCtx* ci = &s>channel[c]; 
778 
int rl_mode = 0; 
779 
int cur_coeff = 0; 
780 
int num_zeros = 0; 
781 
const uint16_t* run;

782 
const float* level; 
783  
784 
av_dlog(s>avctx, "decode coefficients for channel %i\n", c);

785  
786 
vlctable = get_bits1(&s>gb); 
787 
vlc = &coef_vlc[vlctable]; 
788  
789 
if (vlctable) {

790 
run = coef1_run; 
791 
level = coef1_level; 
792 
} else {

793 
run = coef0_run; 
794 
level = coef0_level; 
795 
} 
796  
797 
/** decode vector coefficients (consumes up to 167 bits per iteration for

798 
4 vector coded large values) */

799 
while ((s>transmit_num_vec_coeffs  !rl_mode) &&

800 
(cur_coeff + 3 < ci>num_vec_coeffs)) {

801 
int vals[4]; 
802 
int i;

803 
unsigned int idx; 
804  
805 
idx = get_vlc2(&s>gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); 
806  
807 
if (idx == HUFF_VEC4_SIZE  1) { 
808 
for (i = 0; i < 4; i += 2) { 
809 
idx = get_vlc2(&s>gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); 
810 
if (idx == HUFF_VEC2_SIZE  1) { 
811 
int v0, v1;

812 
v0 = get_vlc2(&s>gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); 
813 
if (v0 == HUFF_VEC1_SIZE  1) 
814 
v0 += ff_wma_get_large_val(&s>gb); 
815 
v1 = get_vlc2(&s>gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); 
816 
if (v1 == HUFF_VEC1_SIZE  1) 
817 
v1 += ff_wma_get_large_val(&s>gb); 
818 
((float*)vals)[i ] = v0;

819 
((float*)vals)[i+1] = v1; 
820 
} else {

821 
vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];

822 
vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF]; 
823 
} 
824 
} 
825 
} else {

826 
vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ]; 
827 
vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF]; 
828 
vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF]; 
829 
vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF]; 
830 
} 
831  
832 
/** decode sign */

833 
for (i = 0; i < 4; i++) { 
834 
if (vals[i]) {

835 
int sign = get_bits1(&s>gb)  1; 
836 
*(uint32_t*)&ci>coeffs[cur_coeff] = vals[i] ^ sign<<31;

837 
num_zeros = 0;

838 
} else {

839 
ci>coeffs[cur_coeff] = 0;

840 
/** switch to run level mode when subframe_len / 128 zeros

841 
were found in a row */

842 
rl_mode = (++num_zeros > s>subframe_len >> 8);

843 
} 
844 
++cur_coeff; 
845 
} 
846 
} 
847  
848 
/** decode run level coded coefficients */

849 
if (cur_coeff < s>subframe_len) {

850 
memset(&ci>coeffs[cur_coeff], 0,

851 
sizeof(*ci>coeffs) * (s>subframe_len  cur_coeff));

852 
if (ff_wma_run_level_decode(s>avctx, &s>gb, vlc,

853 
level, run, 1, ci>coeffs,

854 
cur_coeff, s>subframe_len, 
855 
s>subframe_len, s>esc_len, 0))

856 
return AVERROR_INVALIDDATA;

857 
} 
858  
859 
return 0; 
860 
} 
861  
862 
/**

863 
*@brief Extract scale factors from the bitstream.

864 
*@param s codec context

865 
*@return 0 on success, < 0 in case of bitstream errors

866 
*/

867 
static int decode_scale_factors(WMAProDecodeCtx* s) 
868 
{ 
869 
int i;

870  
871 
/** should never consume more than 5344 bits

872 
* MAX_CHANNELS * (1 + MAX_BANDS * 23)

873 
*/

874  
875 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
876 
int c = s>channel_indexes_for_cur_subframe[i];

877 
int* sf;

878 
int* sf_end;

879 
s>channel[c].scale_factors = s>channel[c].saved_scale_factors[!s>channel[c].scale_factor_idx]; 
880 
sf_end = s>channel[c].scale_factors + s>num_bands; 
881  
882 
/** resample scale factors for the new block size

883 
* as the scale factors might need to be resampled several times

884 
* before some new values are transmitted, a backup of the last

885 
* transmitted scale factors is kept in saved_scale_factors

886 
*/

887 
if (s>channel[c].reuse_sf) {

888 
const int8_t* sf_offsets = s>sf_offsets[s>table_idx][s>channel[c].table_idx];

889 
int b;

890 
for (b = 0; b < s>num_bands; b++) 
891 
s>channel[c].scale_factors[b] = 
892 
s>channel[c].saved_scale_factors[s>channel[c].scale_factor_idx][*sf_offsets++]; 
893 
} 
894  
895 
if (!s>channel[c].cur_subframe  get_bits1(&s>gb)) {

896  
897 
if (!s>channel[c].reuse_sf) {

898 
int val;

899 
/** decode DPCM coded scale factors */

900 
s>channel[c].scale_factor_step = get_bits(&s>gb, 2) + 1; 
901 
val = 45 / s>channel[c].scale_factor_step;

902 
for (sf = s>channel[c].scale_factors; sf < sf_end; sf++) {

903 
val += get_vlc2(&s>gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH)  60;

904 
*sf = val; 
905 
} 
906 
} else {

907 
int i;

908 
/** run level decode differences to the resampled factors */

909 
for (i = 0; i < s>num_bands; i++) { 
910 
int idx;

911 
int skip;

912 
int val;

913 
int sign;

914  
915 
idx = get_vlc2(&s>gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); 
916  
917 
if (!idx) {

918 
uint32_t code = get_bits(&s>gb, 14);

919 
val = code >> 6;

920 
sign = (code & 1)  1; 
921 
skip = (code & 0x3f) >> 1; 
922 
} else if (idx == 1) { 
923 
break;

924 
} else {

925 
skip = scale_rl_run[idx]; 
926 
val = scale_rl_level[idx]; 
927 
sign = get_bits1(&s>gb)1;

928 
} 
929  
930 
i += skip; 
931 
if (i >= s>num_bands) {

932 
av_log(s>avctx, AV_LOG_ERROR, 
933 
"invalid scale factor coding\n");

934 
return AVERROR_INVALIDDATA;

935 
} 
936 
s>channel[c].scale_factors[i] += (val ^ sign)  sign; 
937 
} 
938 
} 
939 
/** swap buffers */

940 
s>channel[c].scale_factor_idx = !s>channel[c].scale_factor_idx; 
941 
s>channel[c].table_idx = s>table_idx; 
942 
s>channel[c].reuse_sf = 1;

943 
} 
944  
945 
/** calculate new scale factor maximum */

946 
s>channel[c].max_scale_factor = s>channel[c].scale_factors[0];

947 
for (sf = s>channel[c].scale_factors + 1; sf < sf_end; sf++) { 
948 
s>channel[c].max_scale_factor = 
949 
FFMAX(s>channel[c].max_scale_factor, *sf); 
950 
} 
951  
952 
} 
953 
return 0; 
954 
} 
955  
956 
/**

957 
*@brief Reconstruct the individual channel data.

958 
*@param s codec context

959 
*/

960 
static void inverse_channel_transform(WMAProDecodeCtx *s) 
961 
{ 
962 
int i;

963  
964 
for (i = 0; i < s>num_chgroups; i++) { 
965 
if (s>chgroup[i].transform) {

966 
float data[WMAPRO_MAX_CHANNELS];

967 
const int num_channels = s>chgroup[i].num_channels; 
968 
float** ch_data = s>chgroup[i].channel_data;

969 
float** ch_end = ch_data + num_channels;

970 
const int8_t* tb = s>chgroup[i].transform_band;

971 
int16_t* sfb; 
972  
973 
/** multichannel decorrelation */

974 
for (sfb = s>cur_sfb_offsets;

975 
sfb < s>cur_sfb_offsets + s>num_bands; sfb++) { 
976 
int y;

977 
if (*tb++ == 1) { 
978 
/** multiply values with the decorrelation_matrix */

979 
for (y = sfb[0]; y < FFMIN(sfb[1], s>subframe_len); y++) { 
980 
const float* mat = s>chgroup[i].decorrelation_matrix; 
981 
const float* data_end = data + num_channels; 
982 
float* data_ptr = data;

983 
float** ch;

984  
985 
for (ch = ch_data; ch < ch_end; ch++)

986 
*data_ptr++ = (*ch)[y]; 
987  
988 
for (ch = ch_data; ch < ch_end; ch++) {

989 
float sum = 0; 
990 
data_ptr = data; 
991 
while (data_ptr < data_end)

992 
sum += *data_ptr++ * *mat++; 
993  
994 
(*ch)[y] = sum; 
995 
} 
996 
} 
997 
} else if (s>num_channels == 2) { 
998 
int len = FFMIN(sfb[1], s>subframe_len)  sfb[0]; 
999 
s>dsp.vector_fmul_scalar(ch_data[0] + sfb[0], 
1000 
ch_data[0] + sfb[0], 
1001 
181.0 / 128, len); 
1002 
s>dsp.vector_fmul_scalar(ch_data[1] + sfb[0], 
1003 
ch_data[1] + sfb[0], 
1004 
181.0 / 128, len); 
1005 
} 
1006 
} 
1007 
} 
1008 
} 
1009 
} 
1010  
1011 
/**

1012 
*@brief Apply sine window and reconstruct the output buffer.

1013 
*@param s codec context

1014 
*/

1015 
static void wmapro_window(WMAProDecodeCtx *s) 
1016 
{ 
1017 
int i;

1018 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1019 
int c = s>channel_indexes_for_cur_subframe[i];

1020 
float* window;

1021 
int winlen = s>channel[c].prev_block_len;

1022 
float* start = s>channel[c].coeffs  (winlen >> 1); 
1023  
1024 
if (s>subframe_len < winlen) {

1025 
start += (winlen  s>subframe_len) >> 1;

1026 
winlen = s>subframe_len; 
1027 
} 
1028  
1029 
window = s>windows[av_log2(winlen)  WMAPRO_BLOCK_MIN_BITS]; 
1030  
1031 
winlen >>= 1;

1032  
1033 
s>dsp.vector_fmul_window(start, start, start + winlen, 
1034 
window, winlen); 
1035  
1036 
s>channel[c].prev_block_len = s>subframe_len; 
1037 
} 
1038 
} 
1039  
1040 
/**

1041 
*@brief Decode a single subframe (block).

1042 
*@param s codec context

1043 
*@return 0 on success, < 0 when decoding failed

1044 
*/

1045 
static int decode_subframe(WMAProDecodeCtx *s) 
1046 
{ 
1047 
int offset = s>samples_per_frame;

1048 
int subframe_len = s>samples_per_frame;

1049 
int i;

1050 
int total_samples = s>samples_per_frame * s>num_channels;

1051 
int transmit_coeffs = 0; 
1052 
int cur_subwoofer_cutoff;

1053  
1054 
s>subframe_offset = get_bits_count(&s>gb); 
1055  
1056 
/** reset channel context and find the next block offset and size

1057 
== the next block of the channel with the smallest number of

1058 
decoded samples

1059 
*/

1060 
for (i = 0; i < s>num_channels; i++) { 
1061 
s>channel[i].grouped = 0;

1062 
if (offset > s>channel[i].decoded_samples) {

1063 
offset = s>channel[i].decoded_samples; 
1064 
subframe_len = 
1065 
s>channel[i].subframe_len[s>channel[i].cur_subframe]; 
1066 
} 
1067 
} 
1068  
1069 
av_dlog(s>avctx, 
1070 
"processing subframe with offset %i len %i\n", offset, subframe_len);

1071  
1072 
/** get a list of all channels that contain the estimated block */

1073 
s>channels_for_cur_subframe = 0;

1074 
for (i = 0; i < s>num_channels; i++) { 
1075 
const int cur_subframe = s>channel[i].cur_subframe; 
1076 
/** substract already processed samples */

1077 
total_samples = s>channel[i].decoded_samples; 
1078  
1079 
/** and count if there are multiple subframes that match our profile */

1080 
if (offset == s>channel[i].decoded_samples &&

1081 
subframe_len == s>channel[i].subframe_len[cur_subframe]) { 
1082 
total_samples = s>channel[i].subframe_len[cur_subframe]; 
1083 
s>channel[i].decoded_samples += 
1084 
s>channel[i].subframe_len[cur_subframe]; 
1085 
s>channel_indexes_for_cur_subframe[s>channels_for_cur_subframe] = i; 
1086 
++s>channels_for_cur_subframe; 
1087 
} 
1088 
} 
1089  
1090 
/** check if the frame will be complete after processing the

1091 
estimated block */

1092 
if (!total_samples)

1093 
s>parsed_all_subframes = 1;

1094  
1095  
1096 
av_dlog(s>avctx, "subframe is part of %i channels\n",

1097 
s>channels_for_cur_subframe); 
1098  
1099 
/** calculate number of scale factor bands and their offsets */

1100 
s>table_idx = av_log2(s>samples_per_frame/subframe_len); 
1101 
s>num_bands = s>num_sfb[s>table_idx]; 
1102 
s>cur_sfb_offsets = s>sfb_offsets[s>table_idx]; 
1103 
cur_subwoofer_cutoff = s>subwoofer_cutoffs[s>table_idx]; 
1104  
1105 
/** configure the decoder for the current subframe */

1106 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1107 
int c = s>channel_indexes_for_cur_subframe[i];

1108  
1109 
s>channel[c].coeffs = &s>channel[c].out[(s>samples_per_frame >> 1)

1110 
+ offset]; 
1111 
} 
1112  
1113 
s>subframe_len = subframe_len; 
1114 
s>esc_len = av_log2(s>subframe_len  1) + 1; 
1115  
1116 
/** skip extended header if any */

1117 
if (get_bits1(&s>gb)) {

1118 
int num_fill_bits;

1119 
if (!(num_fill_bits = get_bits(&s>gb, 2))) { 
1120 
int len = get_bits(&s>gb, 4); 
1121 
num_fill_bits = get_bits(&s>gb, len) + 1;

1122 
} 
1123  
1124 
if (num_fill_bits >= 0) { 
1125 
if (get_bits_count(&s>gb) + num_fill_bits > s>num_saved_bits) {

1126 
av_log(s>avctx, AV_LOG_ERROR, "invalid number of fill bits\n");

1127 
return AVERROR_INVALIDDATA;

1128 
} 
1129  
1130 
skip_bits_long(&s>gb, num_fill_bits); 
1131 
} 
1132 
} 
1133  
1134 
/** no idea for what the following bit is used */

1135 
if (get_bits1(&s>gb)) {

1136 
av_log_ask_for_sample(s>avctx, "reserved bit set\n");

1137 
return AVERROR_INVALIDDATA;

1138 
} 
1139  
1140  
1141 
if (decode_channel_transform(s) < 0) 
1142 
return AVERROR_INVALIDDATA;

1143  
1144  
1145 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1146 
int c = s>channel_indexes_for_cur_subframe[i];

1147 
if ((s>channel[c].transmit_coefs = get_bits1(&s>gb)))

1148 
transmit_coeffs = 1;

1149 
} 
1150  
1151 
if (transmit_coeffs) {

1152 
int step;

1153 
int quant_step = 90 * s>bits_per_sample >> 4; 
1154  
1155 
/** decode number of vector coded coefficients */

1156 
if ((s>transmit_num_vec_coeffs = get_bits1(&s>gb))) {

1157 
int num_bits = av_log2((s>subframe_len + 3)/4) + 1; 
1158 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1159 
int c = s>channel_indexes_for_cur_subframe[i];

1160 
s>channel[c].num_vec_coeffs = get_bits(&s>gb, num_bits) << 2;

1161 
} 
1162 
} else {

1163 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1164 
int c = s>channel_indexes_for_cur_subframe[i];

1165 
s>channel[c].num_vec_coeffs = s>subframe_len; 
1166 
} 
1167 
} 
1168 
/** decode quantization step */

1169 
step = get_sbits(&s>gb, 6);

1170 
quant_step += step; 
1171 
if (step == 32  step == 31) { 
1172 
const int sign = (step == 31)  1; 
1173 
int quant = 0; 
1174 
while (get_bits_count(&s>gb) + 5 < s>num_saved_bits && 
1175 
(step = get_bits(&s>gb, 5)) == 31) { 
1176 
quant += 31;

1177 
} 
1178 
quant_step += ((quant + step) ^ sign)  sign; 
1179 
} 
1180 
if (quant_step < 0) { 
1181 
av_log(s>avctx, AV_LOG_DEBUG, "negative quant step\n");

1182 
} 
1183  
1184 
/** decode quantization step modifiers for every channel */

1185  
1186 
if (s>channels_for_cur_subframe == 1) { 
1187 
s>channel[s>channel_indexes_for_cur_subframe[0]].quant_step = quant_step;

1188 
} else {

1189 
int modifier_len = get_bits(&s>gb, 3); 
1190 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1191 
int c = s>channel_indexes_for_cur_subframe[i];

1192 
s>channel[c].quant_step = quant_step; 
1193 
if (get_bits1(&s>gb)) {

1194 
if (modifier_len) {

1195 
s>channel[c].quant_step += get_bits(&s>gb, modifier_len) + 1;

1196 
} else

1197 
++s>channel[c].quant_step; 
1198 
} 
1199 
} 
1200 
} 
1201  
1202 
/** decode scale factors */

1203 
if (decode_scale_factors(s) < 0) 
1204 
return AVERROR_INVALIDDATA;

1205 
} 
1206  
1207 
av_dlog(s>avctx, "BITSTREAM: subframe header length was %i\n",

1208 
get_bits_count(&s>gb)  s>subframe_offset); 
1209  
1210 
/** parse coefficients */

1211 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1212 
int c = s>channel_indexes_for_cur_subframe[i];

1213 
if (s>channel[c].transmit_coefs &&

1214 
get_bits_count(&s>gb) < s>num_saved_bits) { 
1215 
decode_coeffs(s, c); 
1216 
} else

1217 
memset(s>channel[c].coeffs, 0,

1218 
sizeof(*s>channel[c].coeffs) * subframe_len);

1219 
} 
1220  
1221 
av_dlog(s>avctx, "BITSTREAM: subframe length was %i\n",

1222 
get_bits_count(&s>gb)  s>subframe_offset); 
1223  
1224 
if (transmit_coeffs) {

1225 
FFTContext *mdct = &s>mdct_ctx[av_log2(subframe_len)  WMAPRO_BLOCK_MIN_BITS]; 
1226 
/** reconstruct the per channel data */

1227 
inverse_channel_transform(s); 
1228 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1229 
int c = s>channel_indexes_for_cur_subframe[i];

1230 
const int* sf = s>channel[c].scale_factors; 
1231 
int b;

1232  
1233 
if (c == s>lfe_channel)

1234 
memset(&s>tmp[cur_subwoofer_cutoff], 0, sizeof(*s>tmp) * 
1235 
(subframe_len  cur_subwoofer_cutoff)); 
1236  
1237 
/** inverse quantization and rescaling */

1238 
for (b = 0; b < s>num_bands; b++) { 
1239 
const int end = FFMIN(s>cur_sfb_offsets[b+1], s>subframe_len); 
1240 
const int exp = s>channel[c].quant_step  
1241 
(s>channel[c].max_scale_factor  *sf++) * 
1242 
s>channel[c].scale_factor_step; 
1243 
const float quant = pow(10.0, exp / 20.0); 
1244 
int start = s>cur_sfb_offsets[b];

1245 
s>dsp.vector_fmul_scalar(s>tmp + start, 
1246 
s>channel[c].coeffs + start, 
1247 
quant, end  start); 
1248 
} 
1249  
1250 
/** apply imdct (imdct_half == DCTIV with reverse) */

1251 
mdct>imdct_half(mdct, s>channel[c].coeffs, s>tmp); 
1252 
} 
1253 
} 
1254  
1255 
/** window and overlappadd */

1256 
wmapro_window(s); 
1257  
1258 
/** handled one subframe */

1259 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1260 
int c = s>channel_indexes_for_cur_subframe[i];

1261 
if (s>channel[c].cur_subframe >= s>channel[c].num_subframes) {

1262 
av_log(s>avctx, AV_LOG_ERROR, "broken subframe\n");

1263 
return AVERROR_INVALIDDATA;

1264 
} 
1265 
++s>channel[c].cur_subframe; 
1266 
} 
1267  
1268 
return 0; 
1269 
} 
1270  
1271 
/**

1272 
*@brief Decode one WMA frame.

1273 
*@param s codec context

1274 
*@return 0 if the trailer bit indicates that this is the last frame,

1275 
* 1 if there are additional frames

1276 
*/

1277 
static int decode_frame(WMAProDecodeCtx *s) 
1278 
{ 
1279 
GetBitContext* gb = &s>gb; 
1280 
int more_frames = 0; 
1281 
int len = 0; 
1282 
int i;

1283  
1284 
/** check for potential output buffer overflow */

1285 
if (s>num_channels * s>samples_per_frame > s>samples_end  s>samples) {

1286 
/** return an error if no frame could be decoded at all */

1287 
av_log(s>avctx, AV_LOG_ERROR, 
1288 
"not enough space for the output samples\n");

1289 
s>packet_loss = 1;

1290 
return 0; 
1291 
} 
1292  
1293 
/** get frame length */

1294 
if (s>len_prefix)

1295 
len = get_bits(gb, s>log2_frame_size); 
1296  
1297 
av_dlog(s>avctx, "decoding frame with length %x\n", len);

1298  
1299 
/** decode tile information */

1300 
if (decode_tilehdr(s)) {

1301 
s>packet_loss = 1;

1302 
return 0; 
1303 
} 
1304  
1305 
/** read postproc transform */

1306 
if (s>num_channels > 1 && get_bits1(gb)) { 
1307 
if (get_bits1(gb)) {

1308 
for (i = 0; i < s>num_channels * s>num_channels; i++) 
1309 
skip_bits(gb, 4);

1310 
} 
1311 
} 
1312  
1313 
/** read drc info */

1314 
if (s>dynamic_range_compression) {

1315 
s>drc_gain = get_bits(gb, 8);

1316 
av_dlog(s>avctx, "drc_gain %i\n", s>drc_gain);

1317 
} 
1318  
1319 
/** no idea what these are for, might be the number of samples

1320 
that need to be skipped at the beginning or end of a stream */

1321 
if (get_bits1(gb)) {

1322 
int skip;

1323  
1324 
/** usually true for the first frame */

1325 
if (get_bits1(gb)) {

1326 
skip = get_bits(gb, av_log2(s>samples_per_frame * 2));

1327 
av_dlog(s>avctx, "start skip: %i\n", skip);

1328 
} 
1329  
1330 
/** sometimes true for the last frame */

1331 
if (get_bits1(gb)) {

1332 
skip = get_bits(gb, av_log2(s>samples_per_frame * 2));

1333 
av_dlog(s>avctx, "end skip: %i\n", skip);

1334 
} 
1335  
1336 
} 
1337  
1338 
av_dlog(s>avctx, "BITSTREAM: frame header length was %i\n",

1339 
get_bits_count(gb)  s>frame_offset); 
1340  
1341 
/** reset subframe states */

1342 
s>parsed_all_subframes = 0;

1343 
for (i = 0; i < s>num_channels; i++) { 
1344 
s>channel[i].decoded_samples = 0;

1345 
s>channel[i].cur_subframe = 0;

1346 
s>channel[i].reuse_sf = 0;

1347 
} 
1348  
1349 
/** decode all subframes */

1350 
while (!s>parsed_all_subframes) {

1351 
if (decode_subframe(s) < 0) { 
1352 
s>packet_loss = 1;

1353 
return 0; 
1354 
} 
1355 
} 
1356  
1357 
/** interleave samples and write them to the output buffer */

1358 
for (i = 0; i < s>num_channels; i++) { 
1359 
float* ptr = s>samples + i;

1360 
int incr = s>num_channels;

1361 
float* iptr = s>channel[i].out;

1362 
float* iend = iptr + s>samples_per_frame;

1363  
1364 
// FIXME should create/use a DSP function here

1365 
while (iptr < iend) {

1366 
*ptr = *iptr++; 
1367 
ptr += incr; 
1368 
} 
1369  
1370 
/** reuse second half of the IMDCT output for the next frame */

1371 
memcpy(&s>channel[i].out[0],

1372 
&s>channel[i].out[s>samples_per_frame], 
1373 
s>samples_per_frame * sizeof(*s>channel[i].out) >> 1); 
1374 
} 
1375  
1376 
if (s>skip_frame) {

1377 
s>skip_frame = 0;

1378 
} else

1379 
s>samples += s>num_channels * s>samples_per_frame; 
1380  
1381 
if (s>len_prefix) {

1382 
if (len != (get_bits_count(gb)  s>frame_offset) + 2) { 
1383 
/** FIXME: not sure if this is always an error */

1384 
av_log(s>avctx, AV_LOG_ERROR, 
1385 
"frame[%i] would have to skip %i bits\n", s>frame_num,

1386 
len  (get_bits_count(gb)  s>frame_offset)  1);

1387 
s>packet_loss = 1;

1388 
return 0; 
1389 
} 
1390  
1391 
/** skip the rest of the frame data */

1392 
skip_bits_long(gb, len  (get_bits_count(gb)  s>frame_offset)  1);

1393 
} else {

1394 
while (get_bits_count(gb) < s>num_saved_bits && get_bits1(gb) == 0) { 
1395 
} 
1396 
} 
1397  
1398 
/** decode trailer bit */

1399 
more_frames = get_bits1(gb); 
1400  
1401 
++s>frame_num; 
1402 
return more_frames;

1403 
} 
1404  
1405 
/**

1406 
*@brief Calculate remaining input buffer length.

1407 
*@param s codec context

1408 
*@param gb bitstream reader context

1409 
*@return remaining size in bits

1410 
*/

1411 
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) 
1412 
{ 
1413 
return s>buf_bit_size  get_bits_count(gb);

1414 
} 
1415  
1416 
/**

1417 
*@brief Fill the bit reservoir with a (partial) frame.

1418 
*@param s codec context

1419 
*@param gb bitstream reader context

1420 
*@param len length of the partial frame

1421 
*@param append decides wether to reset the buffer or not

1422 
*/

1423 
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, 
1424 
int append)

1425 
{ 
1426 
int buflen;

1427  
1428 
/** when the frame data does not need to be concatenated, the input buffer

1429 
is resetted and additional bits from the previous frame are copyed

1430 
and skipped later so that a fast byte copy is possible */

1431  
1432 
if (!append) {

1433 
s>frame_offset = get_bits_count(gb) & 7;

1434 
s>num_saved_bits = s>frame_offset; 
1435 
init_put_bits(&s>pb, s>frame_data, MAX_FRAMESIZE); 
1436 
} 
1437  
1438 
buflen = (s>num_saved_bits + len + 8) >> 3; 
1439  
1440 
if (len <= 0  buflen > MAX_FRAMESIZE) { 
1441 
av_log_ask_for_sample(s>avctx, "input buffer too small\n");

1442 
s>packet_loss = 1;

1443 
return;

1444 
} 
1445  
1446 
s>num_saved_bits += len; 
1447 
if (!append) {

1448 
ff_copy_bits(&s>pb, gb>buffer + (get_bits_count(gb) >> 3),

1449 
s>num_saved_bits); 
1450 
} else {

1451 
int align = 8  (get_bits_count(gb) & 7); 
1452 
align = FFMIN(align, len); 
1453 
put_bits(&s>pb, align, get_bits(gb, align)); 
1454 
len = align; 
1455 
ff_copy_bits(&s>pb, gb>buffer + (get_bits_count(gb) >> 3), len);

1456 
} 
1457 
skip_bits_long(gb, len); 
1458  
1459 
{ 
1460 
PutBitContext tmp = s>pb; 
1461 
flush_put_bits(&tmp); 
1462 
} 
1463  
1464 
init_get_bits(&s>gb, s>frame_data, s>num_saved_bits); 
1465 
skip_bits(&s>gb, s>frame_offset); 
1466 
} 
1467  
1468 
/**

1469 
*@brief Decode a single WMA packet.

1470 
*@param avctx codec context

1471 
*@param data the output buffer

1472 
*@param data_size number of bytes that were written to the output buffer

1473 
*@param avpkt input packet

1474 
*@return number of bytes that were read from the input buffer

1475 
*/

1476 
static int decode_packet(AVCodecContext *avctx, 
1477 
void *data, int *data_size, AVPacket* avpkt) 
1478 
{ 
1479 
WMAProDecodeCtx *s = avctx>priv_data; 
1480 
GetBitContext* gb = &s>pgb; 
1481 
const uint8_t* buf = avpkt>data;

1482 
int buf_size = avpkt>size;

1483 
int num_bits_prev_frame;

1484 
int packet_sequence_number;

1485  
1486 
s>samples = data; 
1487 
s>samples_end = (float*)((int8_t*)data + *data_size);

1488 
*data_size = 0;

1489  
1490 
if (s>packet_done  s>packet_loss) {

1491 
s>packet_done = 0;

1492  
1493 
/** sanity check for the buffer length */

1494 
if (buf_size < avctx>block_align)

1495 
return 0; 
1496  
1497 
s>next_packet_start = buf_size  avctx>block_align; 
1498 
buf_size = avctx>block_align; 
1499 
s>buf_bit_size = buf_size << 3;

1500  
1501 
/** parse packet header */

1502 
init_get_bits(gb, buf, s>buf_bit_size); 
1503 
packet_sequence_number = get_bits(gb, 4);

1504 
skip_bits(gb, 2);

1505  
1506 
/** get number of bits that need to be added to the previous frame */

1507 
num_bits_prev_frame = get_bits(gb, s>log2_frame_size); 
1508 
av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx>frame_number,

1509 
num_bits_prev_frame); 
1510  
1511 
/** check for packet loss */

1512 
if (!s>packet_loss &&

1513 
((s>packet_sequence_number + 1) & 0xF) != packet_sequence_number) { 
1514 
s>packet_loss = 1;

1515 
av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",

1516 
s>packet_sequence_number, packet_sequence_number); 
1517 
} 
1518 
s>packet_sequence_number = packet_sequence_number; 
1519  
1520 
if (num_bits_prev_frame > 0) { 
1521 
int remaining_packet_bits = s>buf_bit_size  get_bits_count(gb);

1522 
if (num_bits_prev_frame >= remaining_packet_bits) {

1523 
num_bits_prev_frame = remaining_packet_bits; 
1524 
s>packet_done = 1;

1525 
} 
1526  
1527 
/** append the previous frame data to the remaining data from the

1528 
previous packet to create a full frame */

1529 
save_bits(s, gb, num_bits_prev_frame, 1);

1530 
av_dlog(avctx, "accumulated %x bits of frame data\n",

1531 
s>num_saved_bits  s>frame_offset); 
1532  
1533 
/** decode the cross packet frame if it is valid */

1534 
if (!s>packet_loss)

1535 
decode_frame(s); 
1536 
} else if (s>num_saved_bits  s>frame_offset) { 
1537 
av_dlog(avctx, "ignoring %x previously saved bits\n",

1538 
s>num_saved_bits  s>frame_offset); 
1539 
} 
1540  
1541 
if (s>packet_loss) {

1542 
/** reset number of saved bits so that the decoder

1543 
does not start to decode incomplete frames in the

1544 
s>len_prefix == 0 case */

1545 
s>num_saved_bits = 0;

1546 
s>packet_loss = 0;

1547 
} 
1548  
1549 
} else {

1550 
int frame_size;

1551 
s>buf_bit_size = (avpkt>size  s>next_packet_start) << 3;

1552 
init_get_bits(gb, avpkt>data, s>buf_bit_size); 
1553 
skip_bits(gb, s>packet_offset); 
1554 
if (s>len_prefix && remaining_bits(s, gb) > s>log2_frame_size &&

1555 
(frame_size = show_bits(gb, s>log2_frame_size)) && 
1556 
frame_size <= remaining_bits(s, gb)) { 
1557 
save_bits(s, gb, frame_size, 0);

1558 
s>packet_done = !decode_frame(s); 
1559 
} else if (!s>len_prefix 
1560 
&& s>num_saved_bits > get_bits_count(&s>gb)) { 
1561 
/** when the frames do not have a length prefix, we don't know

1562 
the compressed length of the individual frames

1563 
however, we know what part of a new packet belongs to the

1564 
previous frame

1565 
therefore we save the incoming packet first, then we append

1566 
the "previous frame" data from the next packet so that

1567 
we get a buffer that only contains full frames */

1568 
s>packet_done = !decode_frame(s); 
1569 
} else

1570 
s>packet_done = 1;

1571 
} 
1572  
1573 
if (s>packet_done && !s>packet_loss &&

1574 
remaining_bits(s, gb) > 0) {

1575 
/** save the rest of the data so that it can be decoded

1576 
with the next packet */

1577 
save_bits(s, gb, remaining_bits(s, gb), 0);

1578 
} 
1579  
1580 
*data_size = (int8_t *)s>samples  (int8_t *)data; 
1581 
s>packet_offset = get_bits_count(gb) & 7;

1582  
1583 
return (s>packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3; 
1584 
} 
1585  
1586 
/**

1587 
*@brief Clear decoder buffers (for seeking).

1588 
*@param avctx codec context

1589 
*/

1590 
static void flush(AVCodecContext *avctx) 
1591 
{ 
1592 
WMAProDecodeCtx *s = avctx>priv_data; 
1593 
int i;

1594 
/** reset output buffer as a part of it is used during the windowing of a

1595 
new frame */

1596 
for (i = 0; i < s>num_channels; i++) 
1597 
memset(s>channel[i].out, 0, s>samples_per_frame *

1598 
sizeof(*s>channel[i].out));

1599 
s>packet_loss = 1;

1600 
} 
1601  
1602  
1603 
/**

1604 
*@brief wmapro decoder

1605 
*/

1606 
AVCodec ff_wmapro_decoder = { 
1607 
"wmapro",

1608 
AVMEDIA_TYPE_AUDIO, 
1609 
CODEC_ID_WMAPRO, 
1610 
sizeof(WMAProDecodeCtx),

1611 
decode_init, 
1612 
NULL,

1613 
decode_end, 
1614 
decode_packet, 
1615 
.capabilities = CODEC_CAP_SUBFRAMES, 
1616 
.flush= flush, 
1617 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),

1618 
}; 