ffmpeg / libavcodec / wmaprodec.c @ 84dc2d8a
History  View  Annotate  Download (60.3 KB)
1 
/*


2 
* Wmapro compatible decoder

3 
* Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion

4 
* Copyright (c) 2008  2009 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 021101301 USA

21 
*/

22  
23 
/**

24 
* @file libavcodec/wmaprodec.c

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_MAX_BITS 12 ///< log2 of max block size 
104 
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size 
105 
#define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS  BLOCK_MIN_BITS + 1) ///< possible block sizes 
106  
107  
108 
#define VLCBITS 9 
109 
#define SCALEVLCBITS 8 
110 
#define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS1)/VLCBITS) 
111 
#define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS1)/VLCBITS) 
112 
#define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS1)/VLCBITS) 
113 
#define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS1)/SCALEVLCBITS) 
114 
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS1)/VLCBITS) 
115  
116 
static VLC sf_vlc; ///< scale factor DPCM vlc 
117 
static VLC sf_rl_vlc; ///< scale factor run length vlc 
118 
static VLC vec4_vlc; ///< 4 coefficients per symbol 
119 
static VLC vec2_vlc; ///< 2 coefficients per symbol 
120 
static VLC vec1_vlc; ///< 1 coefficient per symbol 
121 
static VLC coef_vlc[2]; ///< coefficient run length vlc codes 
122 
static float sin64[33]; ///< sinus table for decorrelation 
123  
124 
/**

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

126 
*/

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

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

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

133 
uint8_t cur_subframe; ///< current subframe number

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

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

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

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

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

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

144 
float* coeffs; ///< pointer to the subframe decode buffer 
145 
DECLARE_ALIGNED(16, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer 
146 
} WMAProChannelCtx; 
147  
148 
/**

149 
* @brief channel group for channel transformations

150 
*/

151 
typedef struct { 
152 
uint8_t num_channels; ///< number of channels in the group

153 
int8_t transform; ///< transform on / off

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

155 
float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];

156 
float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients 
157 
} WMAProChannelGrp; 
158  
159 
/**

160 
* @brief main decoder context

161 
*/

162 
typedef struct WMAProDecodeCtx { 
163 
/* generic decoder variables */

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

165 
DSPContext dsp; ///< accelerated DSP functions

166 
uint8_t frame_data[MAX_FRAMESIZE + 
167 
FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data

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

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

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

174 
uint32_t decode_flags; ///< used compression features

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

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

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

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

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

181 
int8_t lfe_channel; ///< lfe channel index

182 
uint8_t max_num_subframes; 
183 
uint8_t subframe_len_bits; ///< number of bits used for the subframe length

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

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

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

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

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

190  
191 
/* packet decode state */

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

193 
uint8_t packet_offset; ///< frame offset in the packet

194 
uint8_t packet_sequence_number; ///< current packet number

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

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

200  
201 
/* frame decode state */

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

203 
GetBitContext gb; ///< bitstream reader context

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

208 
int8_t skip_frame; ///< skip output step

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

210  
211 
/* subframe/block decode state */

212 
int16_t subframe_len; ///< current subframe length

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

214 
int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]; 
215 
int8_t num_bands; ///< number of scale factor bands

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

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

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

219  
220 
uint8_t num_chgroups; ///< number of channel groups

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

222  
223 
WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data

224 
} WMAProDecodeCtx; 
225  
226  
227 
/**

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

229 
*@param s context

230 
*/

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

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

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

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

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

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

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

243 
} 
244  
245 
/**

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

247 
*@param avctx codec context

248 
*@return 0 on success, < 0 otherwise

249 
*/

250 
static av_cold int decode_end(AVCodecContext *avctx) 
251 
{ 
252 
WMAProDecodeCtx *s = avctx>priv_data; 
253 
int i;

254  
255 
for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) 
256 
ff_mdct_end(&s>mdct_ctx[i]); 
257  
258 
return 0; 
259 
} 
260  
261 
/**

262 
*@brief Initialize the decoder.

263 
*@param avctx codec context

264 
*@return 0 on success, 1 otherwise

265 
*/

266 
static av_cold int decode_init(AVCodecContext *avctx) 
267 
{ 
268 
WMAProDecodeCtx *s = avctx>priv_data; 
269 
uint8_t *edata_ptr = avctx>extradata; 
270 
unsigned int channel_mask; 
271 
int i;

272 
int log2_max_num_subframes;

273 
int num_possible_block_sizes;

274  
275 
s>avctx = avctx; 
276 
dsputil_init(&s>dsp, avctx); 
277 
init_put_bits(&s>pb, s>frame_data, MAX_FRAMESIZE); 
278  
279 
avctx>sample_fmt = SAMPLE_FMT_FLT; 
280  
281 
if (avctx>extradata_size >= 18) { 
282 
s>decode_flags = AV_RL16(edata_ptr+14);

283 
channel_mask = AV_RL32(edata_ptr+2);

284 
s>bits_per_sample = AV_RL16(edata_ptr); 
285 
/** dump the extradata */

286 
for (i = 0; i < avctx>extradata_size; i++) 
287 
dprintf(avctx, "[%x] ", avctx>extradata[i]);

288 
dprintf(avctx, "\n");

289  
290 
} else {

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

292 
return AVERROR_INVALIDDATA;

293 
} 
294  
295 
/** generic init */

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

297  
298 
/** frame info */

299 
s>skip_frame = 1; /** skip first frame */ 
300 
s>packet_loss = 1;

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

302  
303 
if (!s>len_prefix) {

304 
av_log_ask_for_sample(avctx, "no length prefix\n");

305 
return AVERROR_INVALIDDATA;

306 
} 
307  
308 
/** get frame len */

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

310 
3, s>decode_flags);

311  
312 
/** init previous block len */

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

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

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

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

322  
323 
num_possible_block_sizes = log2_max_num_subframes + 1;

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

326  
327 
if (s>max_num_subframes > MAX_SUBFRAMES) {

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

329 
s>max_num_subframes); 
330 
return AVERROR_INVALIDDATA;

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

336 
s>lfe_channel = 1;

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

342 
++s>lfe_channel; 
343 
} 
344 
} 
345  
346 
if (s>num_channels < 0  s>num_channels > WMAPRO_MAX_CHANNELS) { 
347 
av_log_ask_for_sample(avctx, "invalid number of channels\n");

348 
return AVERROR_NOTSUPP;

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

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

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

380 
for every possible block size */

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

383 
int x;

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

391 
offset &= ~3;

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

396 
s>num_sfb[i] = band  1;

397 
} 
398  
399  
400 
/** Scale factors can be shared between blocks of different size

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

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

403 
*/

404  
405 
for (i = 0; i < num_possible_block_sizes; i++) { 
406 
int b;

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

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

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

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

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

431 
} 
432  
433 
/** calculate subwoofer cutoff values */

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

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

439 
} 
440  
441 
/** calculate sine values for the decorrelation matrix */

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

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

453 
*@brief Decode the subframe length.

454 
*@param s context

455 
*@param offset sample offset in the frame

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

457 
*/

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

462  
463 
/** no need to read from the bitstream when only one length is possible */

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

465 
return s>min_samples_per_subframe;

466  
467 
/** 1 bit indicates if the subframe is of maximum length */

468 
if (s>max_subframe_len_bit) {

469 
if (get_bits1(&s>gb))

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

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

477 
if (subframe_len < s>min_samples_per_subframe 

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

480 
subframe_len); 
481 
return AVERROR_INVALIDDATA;

482 
} 
483 
return subframe_len;

484 
} 
485  
486 
/**

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

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

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

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

491 
* subframes for every channel.

492 
*

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

494 
* channels with the lowest number of total samples.

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

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

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

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

499 
* the channel's subframe list.

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

501 
* between the individual channels.

502 
*

503 
*@param s context

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

505 
*/

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

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

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

514  
515 
/* Should never consume more than 3073 bits (256 iterations for the

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

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

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

519 
*/

520  
521 
/** reset tiling information */

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

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

529  
530 
/** loop until the frame data is split between the subframes */

531 
do {

532 
int subframe_len;

533  
534 
/** check which channels contain the subframe */

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

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

540 
else

541 
contains_subframe[c] = get_bits1(&s>gb); 
542 
} else

543 
contains_subframe[c] = 0;

544 
} 
545  
546 
/** get subframe length, subframe_len == 0 is not allowed */

547 
if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0) 
548 
return AVERROR_INVALIDDATA;

549  
550 
/** add subframes to the individual channels and find new min_channel_len */

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

556 
if (chan>num_subframes >= MAX_SUBFRAMES) {

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

559 
return AVERROR_INVALIDDATA;

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

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

566 
"channel len > samples_per_frame\n");

567 
return AVERROR_INVALIDDATA;

568 
} 
569 
} else if (num_samples[c] <= min_channel_len) { 
570 
if (num_samples[c] < min_channel_len) {

571 
channels_for_cur_subframe = 0;

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

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

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

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

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

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

596 
*@param s codec context

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

598 
*/

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

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

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

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

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

617 
for (x = 0; x < i; x++) { 
618 
int y;

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

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

622 
int n = rotation_offset[offset + x];

623 
float sinv;

624 
float cosv;

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

629 
} else {

630 
sinv = sin64[64  n];

631 
cosv = sin64[n  32];

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

645 
*@brief Decode channel transformation parameters

646 
*@param s codec context

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

648 
*/

649 
static int decode_channel_transform(WMAProDecodeCtx* s) 
650 
{ 
651 
int i;

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

653 
* 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS

654 
* + MAX_CHANNELS + MAX_BANDS + 1)

655 
*/

656  
657 
/** in the one channel case channel transforms are pointless */

658 
s>num_chgroups = 0;

659 
if (s>num_channels > 1) { 
660 
int remaining_channels = s>channels_for_cur_subframe;

661  
662 
if (get_bits1(&s>gb)) {

663 
av_log_ask_for_sample(s>avctx, 
664 
"unsupported channel transform bit\n");

665 
return AVERROR_INVALIDDATA;

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

672 
chgroup>num_channels = 0;

673 
chgroup>transform = 0;

674  
675 
/** decode channel mask */

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

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

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

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

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

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

691 
*channel_data++ = s>channel[channel_idx].coeffs; 
692 
s>channel[channel_idx].grouped = 1;

693 
} 
694 
} 
695  
696 
/** decode transform type */

697 
if (chgroup>num_channels == 2) { 
698 
if (get_bits1(&s>gb)) {

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

700 
av_log_ask_for_sample(s>avctx, 
701 
"unsupported channel transform type\n");

702 
} 
703 
} else {

704 
chgroup>transform = 1;

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

711 
/** cos(pi/4) */

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

720 
chgroup>transform = 1;

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

722 
decode_decorrelation_matrix(s, chgroup); 
723 
} else {

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

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

728 
} else {

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

733 
} 
734 
} 
735 
} 
736 
} 
737  
738 
/** decode transform on / off */

739 
if (chgroup>transform) {

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

741 
int i;

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

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

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

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

757 
*@brief Extract the coefficients from the bitstream.

758 
*@param s codec context

759 
*@param c current channel number

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

761 
*/

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

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

766 
integers allows fast signflipping. */

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

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

780 
const float* level; 
781  
782 
dprintf(s>avctx, "decode coefficients for channel %i\n", c);

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

788 
run = coef1_run; 
789 
level = coef1_level; 
790 
} else {

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

796 
4 vector coded large values) */

797 
while (!rl_mode && cur_coeff + 3 < s>subframe_len) { 
798 
int vals[4]; 
799 
int i;

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

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

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

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

819 
vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF]; 
820 
} 
821 
} 
822 
} else {

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

830 
for (i = 0; i < 4; i++) { 
831 
if (vals[i]) {

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

834 
num_zeros = 0;

835 
} else {

836 
ci>coeffs[cur_coeff] = 0;

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

838 
were found in a row */

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

840 
} 
841 
++cur_coeff; 
842 
} 
843 
} 
844  
845 
/** decode run level coded coefficients */

846 
if (rl_mode) {

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

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

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

850 
level, run, 1, ci>coeffs,

851 
cur_coeff, s>subframe_len, 
852 
s>subframe_len, s>esc_len, 0))

853 
return AVERROR_INVALIDDATA;

854 
} 
855  
856 
return 0; 
857 
} 
858  
859 
/**

860 
*@brief Extract scale factors from the bitstream.

861 
*@param s codec context

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

863 
*/

864 
static int decode_scale_factors(WMAProDecodeCtx* s) 
865 
{ 
866 
int i;

867  
868 
/** should never consume more than 5344 bits

869 
* MAX_CHANNELS * (1 + MAX_BANDS * 23)

870 
*/

871  
872 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
873 
int c = s>channel_indexes_for_cur_subframe[i];

874 
int* sf;

875 
int* sf_end;

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

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

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

882 
* transmitted scale factors is kept in saved_scale_factors

883 
*/

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

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

886 
int b;

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

893  
894 
if (!s>channel[c].reuse_sf) {

895 
int val;

896 
/** decode DPCM coded scale factors */

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

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

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

901 
*sf = val; 
902 
} 
903 
} else {

904 
int i;

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

906 
for (i = 0; i < s>num_bands; i++) { 
907 
int idx;

908 
int skip;

909 
int val;

910 
int sign;

911  
912 
idx = get_vlc2(&s>gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); 
913  
914 
if (!idx) {

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

916 
val = code >> 6;

917 
sign = (code & 1)  1; 
918 
skip = (code & 0x3f) >> 1; 
919 
} else if (idx == 1) { 
920 
break;

921 
} else {

922 
skip = scale_rl_run[idx]; 
923 
val = scale_rl_level[idx]; 
924 
sign = get_bits1(&s>gb)1;

925 
} 
926  
927 
i += skip; 
928 
if (i >= s>num_bands) {

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

931 
return AVERROR_INVALIDDATA;

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

937 
s>channel[c].scale_factor_idx = !s>channel[c].scale_factor_idx; 
938 
s>channel[c].table_idx = s>table_idx; 
939 
s>channel[c].reuse_sf = 1;

940 
} 
941  
942 
/** calculate new scale factor maximum */

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

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

954 
*@brief Reconstruct the individual channel data.

955 
*@param s codec context

956 
*/

957 
static void inverse_channel_transform(WMAProDecodeCtx *s) 
958 
{ 
959 
int i;

960  
961 
for (i = 0; i < s>num_chgroups; i++) { 
962 
if (s>chgroup[i].transform) {

963 
float data[WMAPRO_MAX_CHANNELS];

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

966 
float** ch_end = ch_data + num_channels;

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

968 
int16_t* sfb; 
969  
970 
/** multichannel decorrelation */

971 
for (sfb = s>cur_sfb_offsets;

972 
sfb < s>cur_sfb_offsets + s>num_bands; sfb++) { 
973 
int y;

974 
if (*tb++ == 1) { 
975 
/** multiply values with the decorrelation_matrix */

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

980 
float** ch;

981  
982 
for (ch = ch_data; ch < ch_end; ch++)

983 
*data_ptr++ = (*ch)[y]; 
984  
985 
for (ch = ch_data; ch < ch_end; ch++) {

986 
float sum = 0; 
987 
data_ptr = data; 
988 
while (data_ptr < data_end)

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

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

1010 
*@param s codec context

1011 
*/

1012 
static void wmapro_window(WMAProDecodeCtx *s) 
1013 
{ 
1014 
int i;

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

1017 
float* window;

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

1019 
float* start = s>channel[c].coeffs  (winlen >> 1); 
1020  
1021 
if (s>subframe_len < winlen) {

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

1023 
winlen = s>subframe_len; 
1024 
} 
1025  
1026 
window = s>windows[av_log2(winlen)  BLOCK_MIN_BITS]; 
1027  
1028 
winlen >>= 1;

1029  
1030 
s>dsp.vector_fmul_window(start, start, start + winlen, 
1031 
window, 0, winlen);

1032  
1033 
s>channel[c].prev_block_len = s>subframe_len; 
1034 
} 
1035 
} 
1036  
1037 
/**

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

1039 
*@param s codec context

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

1041 
*/

1042 
static int decode_subframe(WMAProDecodeCtx *s) 
1043 
{ 
1044 
int offset = s>samples_per_frame;

1045 
int subframe_len = s>samples_per_frame;

1046 
int i;

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

1048 
int transmit_coeffs = 0; 
1049 
int cur_subwoofer_cutoff;

1050  
1051 
s>subframe_offset = get_bits_count(&s>gb); 
1052  
1053 
/** reset channel context and find the next block offset and size

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

1055 
decoded samples

1056 
*/

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

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

1060 
offset = s>channel[i].decoded_samples; 
1061 
subframe_len = 
1062 
s>channel[i].subframe_len[s>channel[i].cur_subframe]; 
1063 
} 
1064 
} 
1065  
1066 
dprintf(s>avctx, 
1067 
"processing subframe with offset %i len %i\n", offset, subframe_len);

1068  
1069 
/** get a list of all channels that contain the estimated block */

1070 
s>channels_for_cur_subframe = 0;

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

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

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

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

1088 
estimated block */

1089 
if (!total_samples)

1090 
s>parsed_all_subframes = 1;

1091  
1092  
1093 
dprintf(s>avctx, "subframe is part of %i channels\n",

1094 
s>channels_for_cur_subframe); 
1095  
1096 
/** calculate number of scale factor bands and their offsets */

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

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

1105  
1106 
s>channel[c].coeffs = &s>channel[c].out[(s>samples_per_frame >> 1)

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

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

1115 
int num_fill_bits;

1116 
if (!(num_fill_bits = get_bits(&s>gb, 2))) { 
1117 
int len = get_bits(&s>gb, 4); 
1118 
num_fill_bits = get_bits(&s>gb, len) + 1;

1119 
} 
1120  
1121 
if (num_fill_bits >= 0) { 
1122 
if (get_bits_count(&s>gb) + num_fill_bits > s>num_saved_bits) {

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

1124 
return AVERROR_INVALIDDATA;

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

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

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

1134 
return AVERROR_INVALIDDATA;

1135 
} 
1136  
1137  
1138 
if (decode_channel_transform(s) < 0) 
1139 
return AVERROR_INVALIDDATA;

1140  
1141  
1142 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1143 
int c = s>channel_indexes_for_cur_subframe[i];

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

1145 
transmit_coeffs = 1;

1146 
} 
1147  
1148 
if (transmit_coeffs) {

1149 
int step;

1150 
int quant_step = 90 * s>bits_per_sample >> 4; 
1151 
if ((get_bits1(&s>gb))) {

1152 
/** FIXME: might change run level mode decision */

1153 
av_log_ask_for_sample(s>avctx, "unsupported quant step coding\n");

1154 
return AVERROR_INVALIDDATA;

1155 
} 
1156 
/** decode quantization step */

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

1158 
quant_step += step; 
1159 
if (step == 32  step == 31) { 
1160 
const int sign = (step == 31)  1; 
1161 
int quant = 0; 
1162 
while (get_bits_count(&s>gb) + 5 < s>num_saved_bits && 
1163 
(step = get_bits(&s>gb, 5)) == 31) { 
1164 
quant += 31;

1165 
} 
1166 
quant_step += ((quant + step) ^ sign)  sign; 
1167 
} 
1168 
if (quant_step < 0) { 
1169 
av_log(s>avctx, AV_LOG_DEBUG, "negative quant step\n");

1170 
} 
1171  
1172 
/** decode quantization step modifiers for every channel */

1173  
1174 
if (s>channels_for_cur_subframe == 1) { 
1175 
s>channel[s>channel_indexes_for_cur_subframe[0]].quant_step = quant_step;

1176 
} else {

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

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

1182 
if (modifier_len) {

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

1184 
} else

1185 
++s>channel[c].quant_step; 
1186 
} 
1187 
} 
1188 
} 
1189  
1190 
/** decode scale factors */

1191 
if (decode_scale_factors(s) < 0) 
1192 
return AVERROR_INVALIDDATA;

1193 
} 
1194  
1195 
dprintf(s>avctx, "BITSTREAM: subframe header length was %i\n",

1196 
get_bits_count(&s>gb)  s>subframe_offset); 
1197  
1198 
/** parse coefficients */

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

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

1202 
get_bits_count(&s>gb) < s>num_saved_bits) { 
1203 
decode_coeffs(s, c); 
1204 
} else

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

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

1207 
} 
1208  
1209 
dprintf(s>avctx, "BITSTREAM: subframe length was %i\n",

1210 
get_bits_count(&s>gb)  s>subframe_offset); 
1211  
1212 
if (transmit_coeffs) {

1213 
/** reconstruct the per channel data */

1214 
inverse_channel_transform(s); 
1215 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1216 
int c = s>channel_indexes_for_cur_subframe[i];

1217 
const int* sf = s>channel[c].scale_factors; 
1218 
int b;

1219  
1220 
if (c == s>lfe_channel)

1221 
memset(&s>tmp[cur_subwoofer_cutoff], 0, sizeof(*s>tmp) * 
1222 
(subframe_len  cur_subwoofer_cutoff)); 
1223  
1224 
/** inverse quantization and rescaling */

1225 
for (b = 0; b < s>num_bands; b++) { 
1226 
const int end = FFMIN(s>cur_sfb_offsets[b+1], s>subframe_len); 
1227 
const int exp = s>channel[c].quant_step  
1228 
(s>channel[c].max_scale_factor  *sf++) * 
1229 
s>channel[c].scale_factor_step; 
1230 
const float quant = pow(10.0, exp / 20.0); 
1231 
int start = s>cur_sfb_offsets[b];

1232 
s>dsp.vector_fmul_scalar(s>tmp + start, 
1233 
s>channel[c].coeffs + start, 
1234 
quant, end  start); 
1235 
} 
1236  
1237 
/** apply imdct (ff_imdct_half == DCTIV with reverse) */

1238 
ff_imdct_half(&s>mdct_ctx[av_log2(subframe_len)  BLOCK_MIN_BITS], 
1239 
s>channel[c].coeffs, s>tmp); 
1240 
} 
1241 
} 
1242  
1243 
/** window and overlappadd */

1244 
wmapro_window(s); 
1245  
1246 
/** handled one subframe */

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

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

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

1251 
return AVERROR_INVALIDDATA;

1252 
} 
1253 
++s>channel[c].cur_subframe; 
1254 
} 
1255  
1256 
return 0; 
1257 
} 
1258  
1259 
/**

1260 
*@brief Decode one WMA frame.

1261 
*@param s codec context

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

1263 
* 1 if there are additional frames

1264 
*/

1265 
static int decode_frame(WMAProDecodeCtx *s) 
1266 
{ 
1267 
GetBitContext* gb = &s>gb; 
1268 
int more_frames = 0; 
1269 
int len = 0; 
1270 
int i;

1271  
1272 
/** check for potential output buffer overflow */

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

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

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

1277 
s>packet_loss = 1;

1278 
return 0; 
1279 
} 
1280  
1281 
/** get frame length */

1282 
if (s>len_prefix)

1283 
len = get_bits(gb, s>log2_frame_size); 
1284  
1285 
dprintf(s>avctx, "decoding frame with length %x\n", len);

1286  
1287 
/** decode tile information */

1288 
if (decode_tilehdr(s)) {

1289 
s>packet_loss = 1;

1290 
return 0; 
1291 
} 
1292  
1293 
/** read postproc transform */

1294 
if (s>num_channels > 1 && get_bits1(gb)) { 
1295 
av_log_ask_for_sample(s>avctx, "Unsupported postproc transform found\n");

1296 
s>packet_loss = 1;

1297 
return 0; 
1298 
} 
1299  
1300 
/** read drc info */

1301 
if (s>dynamic_range_compression) {

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

1303 
dprintf(s>avctx, "drc_gain %i\n", s>drc_gain);

1304 
} 
1305  
1306 
/** no idea what these are for, might be the number of samples

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

1308 
if (get_bits1(gb)) {

1309 
int skip;

1310  
1311 
/** usually true for the first frame */

1312 
if (get_bits1(gb)) {

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

1314 
dprintf(s>avctx, "start skip: %i\n", skip);

1315 
} 
1316  
1317 
/** sometimes true for the last frame */

1318 
if (get_bits1(gb)) {

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

1320 
dprintf(s>avctx, "end skip: %i\n", skip);

1321 
} 
1322  
1323 
} 
1324  
1325 
dprintf(s>avctx, "BITSTREAM: frame header length was %i\n",

1326 
get_bits_count(gb)  s>frame_offset); 
1327  
1328 
/** reset subframe states */

1329 
s>parsed_all_subframes = 0;

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

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

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

1334 
} 
1335  
1336 
/** decode all subframes */

1337 
while (!s>parsed_all_subframes) {

1338 
if (decode_subframe(s) < 0) { 
1339 
s>packet_loss = 1;

1340 
return 0; 
1341 
} 
1342 
} 
1343  
1344 
/** interleave samples and write them to the output buffer */

1345 
for (i = 0; i < s>num_channels; i++) { 
1346 
float* ptr;

1347 
int incr = s>num_channels;

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

1349 
int x;

1350  
1351 
ptr = s>samples + i; 
1352  
1353 
for (x = 0; x < s>samples_per_frame; x++) { 
1354 
*ptr = av_clipf(*iptr++, 1.0, 32767.0 / 32768.0); 
1355 
ptr += incr; 
1356 
} 
1357  
1358 
/** reuse second half of the IMDCT output for the next frame */

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

1360 
&s>channel[i].out[s>samples_per_frame], 
1361 
s>samples_per_frame * sizeof(*s>channel[i].out) >> 1); 
1362 
} 
1363  
1364 
if (s>skip_frame) {

1365 
s>skip_frame = 0;

1366 
} else

1367 
s>samples += s>num_channels * s>samples_per_frame; 
1368  
1369 
if (len != (get_bits_count(gb)  s>frame_offset) + 2) { 
1370 
/** FIXME: not sure if this is always an error */

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

1372 
s>frame_num, len  (get_bits_count(gb)  s>frame_offset)  1);

1373 
s>packet_loss = 1;

1374 
return 0; 
1375 
} 
1376  
1377 
/** skip the rest of the frame data */

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

1379  
1380 
/** decode trailer bit */

1381 
more_frames = get_bits1(gb); 
1382  
1383 
++s>frame_num; 
1384 
return more_frames;

1385 
} 
1386  
1387 
/**

1388 
*@brief Calculate remaining input buffer length.

1389 
*@param s codec context

1390 
*@param gb bitstream reader context

1391 
*@return remaining size in bits

1392 
*/

1393 
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) 
1394 
{ 
1395 
return s>buf_bit_size  get_bits_count(gb);

1396 
} 
1397  
1398 
/**

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

1400 
*@param s codec context

1401 
*@param gb bitstream reader context

1402 
*@param len length of the partial frame

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

1404 
*/

1405 
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, 
1406 
int append)

1407 
{ 
1408 
int buflen;

1409  
1410 
/** when the frame data does not need to be concatenated, the input buffer

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

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

1413  
1414 
if (!append) {

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

1416 
s>num_saved_bits = s>frame_offset; 
1417 
init_put_bits(&s>pb, s>frame_data, MAX_FRAMESIZE); 
1418 
} 
1419  
1420 
buflen = (s>num_saved_bits + len + 8) >> 3; 
1421  
1422 
if (len <= 0  buflen > MAX_FRAMESIZE) { 
1423 
av_log_ask_for_sample(s>avctx, "input buffer too small\n");

1424 
s>packet_loss = 1;

1425 
return;

1426 
} 
1427  
1428 
s>num_saved_bits += len; 
1429 
if (!append) {

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

1431 
s>num_saved_bits); 
1432 
} else {

1433 
int align = 8  (get_bits_count(gb) & 7); 
1434 
align = FFMIN(align, len); 
1435 
put_bits(&s>pb, align, get_bits(gb, align)); 
1436 
len = align; 
1437 
ff_copy_bits(&s>pb, gb>buffer + (get_bits_count(gb) >> 3), len);

1438 
} 
1439 
skip_bits_long(gb, len); 
1440  
1441 
{ 
1442 
PutBitContext tmp = s>pb; 
1443 
flush_put_bits(&tmp); 
1444 
} 
1445  
1446 
init_get_bits(&s>gb, s>frame_data, s>num_saved_bits); 
1447 
skip_bits(&s>gb, s>frame_offset); 
1448 
} 
1449  
1450 
/**

1451 
*@brief Decode a single WMA packet.

1452 
*@param avctx codec context

1453 
*@param data the output buffer

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

1455 
*@param avpkt input packet

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

1457 
*/

1458 
static int decode_packet(AVCodecContext *avctx, 
1459 
void *data, int *data_size, AVPacket* avpkt) 
1460 
{ 
1461 
WMAProDecodeCtx *s = avctx>priv_data; 
1462 
GetBitContext* gb = &s>pgb; 
1463 
const uint8_t* buf = avpkt>data;

1464 
int buf_size = avpkt>size;

1465 
int num_bits_prev_frame;

1466 
int packet_sequence_number;

1467  
1468 
s>samples = data; 
1469 
s>samples_end = (float*)((int8_t*)data + *data_size);

1470 
*data_size = 0;

1471  
1472 
if (s>packet_done  s>packet_loss) {

1473 
s>packet_done = 0;

1474 
s>buf_bit_size = buf_size << 3;

1475  
1476 
/** sanity check for the buffer length */

1477 
if (buf_size < avctx>block_align)

1478 
return 0; 
1479  
1480 
buf_size = avctx>block_align; 
1481  
1482 
/** parse packet header */

1483 
init_get_bits(gb, buf, s>buf_bit_size); 
1484 
packet_sequence_number = get_bits(gb, 4);

1485 
skip_bits(gb, 2);

1486  
1487 
/** get number of bits that need to be added to the previous frame */

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

1490 
num_bits_prev_frame); 
1491  
1492 
/** check for packet loss */

1493 
if (!s>packet_loss &&

1494 
((s>packet_sequence_number + 1) & 0xF) != packet_sequence_number) { 
1495 
s>packet_loss = 1;

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

1497 
s>packet_sequence_number, packet_sequence_number); 
1498 
} 
1499 
s>packet_sequence_number = packet_sequence_number; 
1500  
1501 
if (num_bits_prev_frame > 0) { 
1502 
/** append the previous frame data to the remaining data from the

1503 
previous packet to create a full frame */

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

1505 
dprintf(avctx, "accumulated %x bits of frame data\n",

1506 
s>num_saved_bits  s>frame_offset); 
1507  
1508 
/** decode the cross packet frame if it is valid */

1509 
if (!s>packet_loss)

1510 
decode_frame(s); 
1511 
} else if (s>num_saved_bits  s>frame_offset) { 
1512 
dprintf(avctx, "ignoring %x previously saved bits\n",

1513 
s>num_saved_bits  s>frame_offset); 
1514 
} 
1515  
1516 
s>packet_loss = 0;

1517  
1518 
} else {

1519 
int frame_size;

1520 
s>buf_bit_size = avpkt>size << 3;

1521 
init_get_bits(gb, avpkt>data, s>buf_bit_size); 
1522 
skip_bits(gb, s>packet_offset); 
1523 
if (remaining_bits(s, gb) > s>log2_frame_size &&

1524 
(frame_size = show_bits(gb, s>log2_frame_size)) && 
1525 
frame_size <= remaining_bits(s, gb)) { 
1526 
save_bits(s, gb, frame_size, 0);

1527 
s>packet_done = !decode_frame(s); 
1528 
} else

1529 
s>packet_done = 1;

1530 
} 
1531  
1532 
if (s>packet_done && !s>packet_loss &&

1533 
remaining_bits(s, gb) > 0) {

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

1535 
with the next packet */

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

1537 
} 
1538  
1539 
*data_size = (int8_t *)s>samples  (int8_t *)data; 
1540 
s>packet_offset = get_bits_count(gb) & 7;

1541  
1542 
return (s>packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3; 
1543 
} 
1544  
1545 
/**

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

1547 
*@param avctx codec context

1548 
*/

1549 
static void flush(AVCodecContext *avctx) 
1550 
{ 
1551 
WMAProDecodeCtx *s = avctx>priv_data; 
1552 
int i;

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

1554 
new frame */

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

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

1558 
s>packet_loss = 1;

1559 
} 
1560  
1561  
1562 
/**

1563 
*@brief wmapro decoder

1564 
*/

1565 
AVCodec wmapro_decoder = { 
1566 
"wmapro",

1567 
CODEC_TYPE_AUDIO, 
1568 
CODEC_ID_WMAPRO, 
1569 
sizeof(WMAProDecodeCtx),

1570 
decode_init, 
1571 
NULL,

1572 
decode_end, 
1573 
decode_packet, 
1574 
.capabilities = CODEC_CAP_SUBFRAMES, 
1575 
.flush= flush, 
1576 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),

1577 
}; 