ffmpeg / libavcodec / wmaprodec.c @ 9244370a
History  View  Annotate  Download (59.6 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 16384 ///< 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 scale_factors[MAX_BANDS]; ///< scale factor values for the current subframe 
141 
int saved_scale_factors[MAX_BANDS]; ///< scale factors from a previous subframe 
142 
uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block

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

148 
* @brief channel group for channel transformations

149 
*/

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

152 
int8_t transform; ///< transform on / off

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

154 
float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];

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

159 
* @brief main decoder context

160 
*/

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

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

164 
DSPContext dsp; ///< accelerated DSP functions

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

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

168 
MDCTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size

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

173 
uint32_t decode_flags; ///< used compression features

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

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

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

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

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

180 
int8_t lfe_channel; ///< lfe channel index

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

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

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

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

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

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

189  
190 
/* packet decode state */

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

192 
uint8_t packet_sequence_number; ///< current packet number

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

197 
uint8_t output_buffer_full; ///< flag indicating that the output buffer is full

198  
199 
/* frame decode state */

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

201 
GetBitContext gb; ///< bitstream reader context

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

207 
int8_t skip_frame; ///< skip output step

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

209  
210 
/* subframe/block decode state */

211 
int16_t subframe_len; ///< current subframe length

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

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

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

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

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

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

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

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

223 
} WMAProDecodeCtx; 
224  
225  
226 
/**

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

228 
*@param s context

229 
*/

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

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

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

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

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

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

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

242 
} 
243  
244 
/**

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

246 
*@param avctx codec context

247 
*@return 0 on success, < 0 otherwise

248 
*/

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

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

261 
*@brief Initialize the decoder.

262 
*@param avctx codec context

263 
*@return 0 on success, 1 otherwise

264 
*/

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

271 
int log2_max_num_subframes;

272 
int num_possible_block_sizes;

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

282 
channel_mask = AV_RL32(edata_ptr+2);

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

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

287 
dprintf(avctx, "\n");

288  
289 
} else {

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

291 
return AVERROR_INVALIDDATA;

292 
} 
293  
294 
/** generic init */

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

296  
297 
/** frame info */

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

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

301  
302 
if (!s>len_prefix) {

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

304 
return AVERROR_INVALIDDATA;

305 
} 
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) 
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  s>num_channels > WMAPRO_MAX_CHANNELS) { 
346 
av_log_ask_for_sample(avctx, "invalid number of channels\n");

347 
return AVERROR_NOTSUPP;

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

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

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

379 
for every possible block size */

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

382 
int x;

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

390 
offset &= ~3;

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

395 
s>num_sfb[i] = band  1;

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

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

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

402 
*/

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

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

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

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

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

426 
for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) { 
427 
const int n = 1 << (WMAPRO_BLOCK_MAX_BITS  i); 
428 
const int win_idx = WMAPRO_BLOCK_MAX_BITS  i  7; 
429 
ff_sine_window_init(ff_sine_windows[win_idx], n); 
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 
int vlctable;

765 
VLC* vlc; 
766 
WMAProChannelCtx* ci = &s>channel[c]; 
767 
int rl_mode = 0; 
768 
int cur_coeff = 0; 
769 
int num_zeros = 0; 
770 
const uint16_t* run;

771 
const uint16_t* level;

772  
773 
dprintf(s>avctx, "decode coefficients for channel %i\n", c);

774  
775 
vlctable = get_bits1(&s>gb); 
776 
vlc = &coef_vlc[vlctable]; 
777  
778 
if (vlctable) {

779 
run = coef1_run; 
780 
level = coef1_level; 
781 
} else {

782 
run = coef0_run; 
783 
level = coef0_level; 
784 
} 
785  
786 
/** decode vector coefficients (consumes up to 167 bits per iteration for

787 
4 vector coded large values) */

788 
while (!rl_mode && cur_coeff + 3 < s>subframe_len) { 
789 
int vals[4]; 
790 
int i;

791 
unsigned int idx; 
792  
793 
idx = get_vlc2(&s>gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); 
794  
795 
if (idx == HUFF_VEC4_SIZE  1) { 
796 
for (i = 0; i < 4; i += 2) { 
797 
idx = get_vlc2(&s>gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); 
798 
if (idx == HUFF_VEC2_SIZE  1) { 
799 
vals[i] = get_vlc2(&s>gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); 
800 
if (vals[i] == HUFF_VEC1_SIZE  1) 
801 
vals[i] += ff_wma_get_large_val(&s>gb); 
802 
vals[i+1] = get_vlc2(&s>gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);

803 
if (vals[i+1] == HUFF_VEC1_SIZE  1) 
804 
vals[i+1] += ff_wma_get_large_val(&s>gb);

805 
} else {

806 
vals[i] = symbol_to_vec2[idx] >> 4;

807 
vals[i+1] = symbol_to_vec2[idx] & 0xF; 
808 
} 
809 
} 
810 
} else {

811 
vals[0] = symbol_to_vec4[idx] >> 12; 
812 
vals[1] = (symbol_to_vec4[idx] >> 8) & 0xF; 
813 
vals[2] = (symbol_to_vec4[idx] >> 4) & 0xF; 
814 
vals[3] = symbol_to_vec4[idx] & 0xF; 
815 
} 
816  
817 
/** decode sign */

818 
for (i = 0; i < 4; i++) { 
819 
if (vals[i]) {

820 
int sign = get_bits1(&s>gb)  1; 
821 
ci>coeffs[cur_coeff] = (vals[i] ^ sign)  sign; 
822 
num_zeros = 0;

823 
} else {

824 
ci>coeffs[cur_coeff] = 0;

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

826 
were found in a row */

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

828 
} 
829 
++cur_coeff; 
830 
} 
831 
} 
832  
833 
/** decode run level coded coefficients */

834 
if (rl_mode) {

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

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

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

838 
level, run, 1, ci>coeffs,

839 
cur_coeff, s>subframe_len, 
840 
s>subframe_len, s>esc_len, 0))

841 
return AVERROR_INVALIDDATA;

842 
} 
843  
844 
return 0; 
845 
} 
846  
847 
/**

848 
*@brief Extract scale factors from the bitstream.

849 
*@param s codec context

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

851 
*/

852 
static int decode_scale_factors(WMAProDecodeCtx* s) 
853 
{ 
854 
int i;

855  
856 
/** should never consume more than 5344 bits

857 
* MAX_CHANNELS * (1 + MAX_BANDS * 23)

858 
*/

859  
860 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
861 
int c = s>channel_indexes_for_cur_subframe[i];

862 
int* sf;

863 
int* sf_end = s>channel[c].scale_factors + s>num_bands;

864  
865 
/** resample scale factors for the new block size

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

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

868 
* transmitted scale factors is kept in saved_scale_factors

869 
*/

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

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

872 
int b;

873 
for (b = 0; b < s>num_bands; b++) 
874 
s>channel[c].scale_factors[b] = 
875 
s>channel[c].saved_scale_factors[*sf_offsets++]; 
876 
} 
877  
878 
if (!s>channel[c].cur_subframe  get_bits1(&s>gb)) {

879  
880 
if (!s>channel[c].reuse_sf) {

881 
int val;

882 
/** decode DPCM coded scale factors */

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

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

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

887 
*sf = val; 
888 
} 
889 
} else {

890 
int i;

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

892 
for (i = 0; i < s>num_bands; i++) { 
893 
int idx;

894 
int skip;

895 
int val;

896 
int sign;

897  
898 
idx = get_vlc2(&s>gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); 
899  
900 
if (!idx) {

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

902 
val = code >> 6;

903 
sign = (code & 1)  1; 
904 
skip = (code & 0x3f) >> 1; 
905 
} else if (idx == 1) { 
906 
break;

907 
} else {

908 
skip = scale_rl_run[idx]; 
909 
val = scale_rl_level[idx]; 
910 
sign = get_bits1(&s>gb)1;

911 
} 
912  
913 
i += skip; 
914 
if (i >= s>num_bands) {

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

917 
return AVERROR_INVALIDDATA;

918 
} 
919 
s>channel[c].scale_factors[i] += (val ^ sign)  sign; 
920 
} 
921 
} 
922  
923 
/** save transmitted scale factors so that they can be reused for

924 
the next subframe */

925 
memcpy(s>channel[c].saved_scale_factors, 
926 
s>channel[c].scale_factors, s>num_bands * 
927 
sizeof(*s>channel[c].saved_scale_factors));

928 
s>channel[c].table_idx = s>table_idx; 
929 
s>channel[c].reuse_sf = 1;

930 
} 
931  
932 
/** calculate new scale factor maximum */

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

934 
for (sf = s>channel[c].scale_factors + 1; sf < sf_end; sf++) { 
935 
s>channel[c].max_scale_factor = 
936 
FFMAX(s>channel[c].max_scale_factor, *sf); 
937 
} 
938  
939 
} 
940 
return 0; 
941 
} 
942  
943 
/**

944 
*@brief Reconstruct the individual channel data.

945 
*@param s codec context

946 
*/

947 
static void inverse_channel_transform(WMAProDecodeCtx *s) 
948 
{ 
949 
int i;

950  
951 
for (i = 0; i < s>num_chgroups; i++) { 
952 
if (s>chgroup[i].transform) {

953 
float data[WMAPRO_MAX_CHANNELS];

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

956 
float** ch_end = ch_data + num_channels;

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

958 
int16_t* sfb; 
959  
960 
/** multichannel decorrelation */

961 
for (sfb = s>cur_sfb_offsets;

962 
sfb < s>cur_sfb_offsets + s>num_bands; sfb++) { 
963 
int y;

964 
if (*tb++ == 1) { 
965 
/** multiply values with the decorrelation_matrix */

966 
for (y = sfb[0]; y < FFMIN(sfb[1], s>subframe_len); y++) { 
967 
const float* mat = s>chgroup[i].decorrelation_matrix; 
968 
const float* data_end = data + num_channels; 
969 
float* data_ptr = data;

970 
float** ch;

971  
972 
for (ch = ch_data; ch < ch_end; ch++)

973 
*data_ptr++ = (*ch)[y]; 
974  
975 
for (ch = ch_data; ch < ch_end; ch++) {

976 
float sum = 0; 
977 
data_ptr = data; 
978 
while (data_ptr < data_end)

979 
sum += *data_ptr++ * *mat++; 
980  
981 
(*ch)[y] = sum; 
982 
} 
983 
} 
984 
} else if (s>num_channels == 2) { 
985 
for (y = sfb[0]; y < FFMIN(sfb[1], s>subframe_len); y++) { 
986 
ch_data[0][y] *= 181.0 / 128; 
987 
ch_data[1][y] *= 181.0 / 128; 
988 
} 
989 
} 
990 
} 
991 
} 
992 
} 
993 
} 
994  
995 
/**

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

997 
*@param s codec context

998 
*/

999 
static void wmapro_window(WMAProDecodeCtx *s) 
1000 
{ 
1001 
int i;

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

1004 
float* window;

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

1006 
float* start = s>channel[c].coeffs  (winlen >> 1); 
1007  
1008 
if (s>subframe_len < winlen) {

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

1010 
winlen = s>subframe_len; 
1011 
} 
1012  
1013 
window = s>windows[av_log2(winlen)  BLOCK_MIN_BITS]; 
1014  
1015 
winlen >>= 1;

1016  
1017 
s>dsp.vector_fmul_window(start, start, start + winlen, 
1018 
window, 0, winlen);

1019  
1020 
s>channel[c].prev_block_len = s>subframe_len; 
1021 
} 
1022 
} 
1023  
1024 
/**

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

1026 
*@param s codec context

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

1028 
*/

1029 
static int decode_subframe(WMAProDecodeCtx *s) 
1030 
{ 
1031 
int offset = s>samples_per_frame;

1032 
int subframe_len = s>samples_per_frame;

1033 
int i;

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

1035 
int transmit_coeffs = 0; 
1036 
int cur_subwoofer_cutoff;

1037  
1038 
s>subframe_offset = get_bits_count(&s>gb); 
1039  
1040 
/** reset channel context and find the next block offset and size

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

1042 
decoded samples

1043 
*/

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

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

1047 
offset = s>channel[i].decoded_samples; 
1048 
subframe_len = 
1049 
s>channel[i].subframe_len[s>channel[i].cur_subframe]; 
1050 
} 
1051 
} 
1052  
1053 
dprintf(s>avctx, 
1054 
"processing subframe with offset %i len %i\n", offset, subframe_len);

1055  
1056 
/** get a list of all channels that contain the estimated block */

1057 
s>channels_for_cur_subframe = 0;

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

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

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

1065 
subframe_len == s>channel[i].subframe_len[cur_subframe]) { 
1066 
total_samples = s>channel[i].subframe_len[cur_subframe]; 
1067 
s>channel[i].decoded_samples += 
1068 
s>channel[i].subframe_len[cur_subframe]; 
1069 
s>channel_indexes_for_cur_subframe[s>channels_for_cur_subframe] = i; 
1070 
++s>channels_for_cur_subframe; 
1071 
} 
1072 
} 
1073  
1074 
/** check if the frame will be complete after processing the

1075 
estimated block */

1076 
if (!total_samples)

1077 
s>parsed_all_subframes = 1;

1078  
1079  
1080 
dprintf(s>avctx, "subframe is part of %i channels\n",

1081 
s>channels_for_cur_subframe); 
1082  
1083 
/** calculate number of scale factor bands and their offsets */

1084 
s>table_idx = av_log2(s>samples_per_frame/subframe_len); 
1085 
s>num_bands = s>num_sfb[s>table_idx]; 
1086 
s>cur_sfb_offsets = s>sfb_offsets[s>table_idx]; 
1087 
cur_subwoofer_cutoff = s>subwoofer_cutoffs[s>table_idx]; 
1088  
1089 
/** configure the decoder for the current subframe */

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

1092  
1093 
s>channel[c].coeffs = &s>channel[c].out[(s>samples_per_frame >> 1)

1094 
+ offset]; 
1095 
} 
1096  
1097 
s>subframe_len = subframe_len; 
1098 
s>esc_len = av_log2(s>subframe_len  1) + 1; 
1099  
1100 
/** skip extended header if any */

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

1102 
int num_fill_bits;

1103 
if (!(num_fill_bits = get_bits(&s>gb, 2))) { 
1104 
int len = get_bits(&s>gb, 4); 
1105 
num_fill_bits = get_bits(&s>gb, len) + 1;

1106 
} 
1107  
1108 
if (num_fill_bits >= 0) { 
1109 
if (get_bits_count(&s>gb) + num_fill_bits > s>num_saved_bits) {

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

1111 
return AVERROR_INVALIDDATA;

1112 
} 
1113  
1114 
skip_bits_long(&s>gb, num_fill_bits); 
1115 
} 
1116 
} 
1117  
1118 
/** no idea for what the following bit is used */

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

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

1121 
return AVERROR_INVALIDDATA;

1122 
} 
1123  
1124  
1125 
if (decode_channel_transform(s) < 0) 
1126 
return AVERROR_INVALIDDATA;

1127  
1128  
1129 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1130 
int c = s>channel_indexes_for_cur_subframe[i];

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

1132 
transmit_coeffs = 1;

1133 
} 
1134  
1135 
if (transmit_coeffs) {

1136 
int step;

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

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

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

1141 
return AVERROR_INVALIDDATA;

1142 
} 
1143 
/** decode quantization step */

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

1145 
quant_step += step; 
1146 
if (step == 32  step == 31) { 
1147 
const int sign = (step == 31)  1; 
1148 
int quant = 0; 
1149 
while (get_bits_count(&s>gb) + 5 < s>num_saved_bits && 
1150 
(step = get_bits(&s>gb, 5)) == 31) { 
1151 
quant += 31;

1152 
} 
1153 
quant_step += ((quant + step) ^ sign)  sign; 
1154 
} 
1155 
if (quant_step < 0) { 
1156 
av_log(s>avctx, AV_LOG_DEBUG, "negative quant step\n");

1157 
} 
1158  
1159 
/** decode quantization step modifiers for every channel */

1160  
1161 
if (s>channels_for_cur_subframe == 1) { 
1162 
s>channel[s>channel_indexes_for_cur_subframe[0]].quant_step = quant_step;

1163 
} else {

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

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

1169 
if (modifier_len) {

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

1171 
} else

1172 
++s>channel[c].quant_step; 
1173 
} 
1174 
} 
1175 
} 
1176  
1177 
/** decode scale factors */

1178 
if (decode_scale_factors(s) < 0) 
1179 
return AVERROR_INVALIDDATA;

1180 
} 
1181  
1182 
dprintf(s>avctx, "BITSTREAM: subframe header length was %i\n",

1183 
get_bits_count(&s>gb)  s>subframe_offset); 
1184  
1185 
/** parse coefficients */

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

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

1189 
get_bits_count(&s>gb) < s>num_saved_bits) { 
1190 
decode_coeffs(s, c); 
1191 
} else

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

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

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

1197 
get_bits_count(&s>gb)  s>subframe_offset); 
1198  
1199 
if (transmit_coeffs) {

1200 
/** reconstruct the per channel data */

1201 
inverse_channel_transform(s); 
1202 
for (i = 0; i < s>channels_for_cur_subframe; i++) { 
1203 
int c = s>channel_indexes_for_cur_subframe[i];

1204 
const int* sf = s>channel[c].scale_factors; 
1205 
int b;

1206  
1207 
if (c == s>lfe_channel)

1208 
memset(&s>tmp[cur_subwoofer_cutoff], 0, sizeof(*s>tmp) * 
1209 
(subframe_len  cur_subwoofer_cutoff)); 
1210  
1211 
/** inverse quantization and rescaling */

1212 
for (b = 0; b < s>num_bands; b++) { 
1213 
const int end = FFMIN(s>cur_sfb_offsets[b+1], s>subframe_len); 
1214 
const int exp = s>channel[c].quant_step  
1215 
(s>channel[c].max_scale_factor  *sf++) * 
1216 
s>channel[c].scale_factor_step; 
1217 
const float quant = pow(10.0, exp / 20.0); 
1218 
int start;

1219  
1220 
for (start = s>cur_sfb_offsets[b]; start < end; start++)

1221 
s>tmp[start] = s>channel[c].coeffs[start] * quant; 
1222 
} 
1223  
1224 
/** apply imdct (ff_imdct_half == DCTIV with reverse) */

1225 
ff_imdct_half(&s>mdct_ctx[av_log2(subframe_len)  BLOCK_MIN_BITS], 
1226 
s>channel[c].coeffs, s>tmp); 
1227 
} 
1228 
} 
1229  
1230 
/** window and overlappadd */

1231 
wmapro_window(s); 
1232  
1233 
/** handled one subframe */

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

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

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

1238 
return AVERROR_INVALIDDATA;

1239 
} 
1240 
++s>channel[c].cur_subframe; 
1241 
} 
1242  
1243 
return 0; 
1244 
} 
1245  
1246 
/**

1247 
*@brief Decode one WMA frame.

1248 
*@param s codec context

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

1250 
* 1 if there are additional frames

1251 
*/

1252 
static int decode_frame(WMAProDecodeCtx *s) 
1253 
{ 
1254 
GetBitContext* gb = &s>gb; 
1255 
int more_frames = 0; 
1256 
int len = 0; 
1257 
int i;

1258  
1259 
/** check for potential output buffer overflow */

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

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

1262 
if (s>samples_start == s>samples) {

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

1265 
s>packet_loss = 1;

1266 
} else

1267 
s>output_buffer_full = 1;

1268 
return 0; 
1269 
} 
1270  
1271 
/** get frame length */

1272 
if (s>len_prefix)

1273 
len = get_bits(gb, s>log2_frame_size); 
1274  
1275 
dprintf(s>avctx, "decoding frame with length %x\n", len);

1276  
1277 
/** decode tile information */

1278 
if (decode_tilehdr(s)) {

1279 
s>packet_loss = 1;

1280 
return 0; 
1281 
} 
1282  
1283 
/** read postproc transform */

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

1286 
s>packet_loss = 1;

1287 
return 0; 
1288 
} 
1289  
1290 
/** read drc info */

1291 
if (s>dynamic_range_compression) {

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

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

1294 
} 
1295  
1296 
/** no idea what these are for, might be the number of samples

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

1298 
if (get_bits1(gb)) {

1299 
int skip;

1300  
1301 
/** usually true for the first frame */

1302 
if (get_bits1(gb)) {

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

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

1305 
} 
1306  
1307 
/** sometimes true for the last frame */

1308 
if (get_bits1(gb)) {

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

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

1311 
} 
1312  
1313 
} 
1314  
1315 
dprintf(s>avctx, "BITSTREAM: frame header length was %i\n",

1316 
get_bits_count(gb)  s>frame_offset); 
1317  
1318 
/** reset subframe states */

1319 
s>parsed_all_subframes = 0;

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

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

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

1324 
} 
1325  
1326 
/** decode all subframes */

1327 
while (!s>parsed_all_subframes) {

1328 
if (decode_subframe(s) < 0) { 
1329 
s>packet_loss = 1;

1330 
return 0; 
1331 
} 
1332 
} 
1333  
1334 
/** interleave samples and write them to the output buffer */

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

1337 
int incr = s>num_channels;

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

1339 
int x;

1340  
1341 
ptr = s>samples + i; 
1342  
1343 
for (x = 0; x < s>samples_per_frame; x++) { 
1344 
*ptr = av_clipf(*iptr++, 1.0, 32767.0 / 32768.0); 
1345 
ptr += incr; 
1346 
} 
1347  
1348 
/** reuse second half of the IMDCT output for the next frame */

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

1350 
&s>channel[i].out[s>samples_per_frame], 
1351 
s>samples_per_frame * sizeof(*s>channel[i].out) >> 1); 
1352 
} 
1353  
1354 
if (s>skip_frame) {

1355 
s>skip_frame = 0;

1356 
} else

1357 
s>samples += s>num_channels * s>samples_per_frame; 
1358  
1359 
if (len != (get_bits_count(gb)  s>frame_offset) + 2) { 
1360 
/** FIXME: not sure if this is always an error */

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

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

1363 
s>packet_loss = 1;

1364 
return 0; 
1365 
} 
1366  
1367 
/** skip the rest of the frame data */

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

1369  
1370 
/** decode trailer bit */

1371 
more_frames = get_bits1(gb); 
1372  
1373 
++s>frame_num; 
1374 
return more_frames;

1375 
} 
1376  
1377 
/**

1378 
*@brief Calculate remaining input buffer length.

1379 
*@param s codec context

1380 
*@param gb bitstream reader context

1381 
*@return remaining size in bits

1382 
*/

1383 
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) 
1384 
{ 
1385 
return s>buf_bit_size  get_bits_count(gb);

1386 
} 
1387  
1388 
/**

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

1390 
*@param s codec context

1391 
*@param gb bitstream reader context

1392 
*@param len length of the partial frame

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

1394 
*/

1395 
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, 
1396 
int append)

1397 
{ 
1398 
int buflen;

1399  
1400 
/** when the frame data does not need to be concatenated, the input buffer

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

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

1403  
1404 
if (!append) {

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

1406 
s>num_saved_bits = s>frame_offset; 
1407 
init_put_bits(&s>pb, s>frame_data, MAX_FRAMESIZE); 
1408 
} 
1409  
1410 
buflen = (s>num_saved_bits + len + 8) >> 3; 
1411  
1412 
if (len <= 0  buflen > MAX_FRAMESIZE) { 
1413 
av_log_ask_for_sample(s>avctx, "input buffer too small\n");

1414 
s>packet_loss = 1;

1415 
return;

1416 
} 
1417  
1418 
s>num_saved_bits += len; 
1419 
if (!append) {

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

1421 
s>num_saved_bits); 
1422 
} else {

1423 
int align = 8  (get_bits_count(gb) & 7); 
1424 
align = FFMIN(align, len); 
1425 
put_bits(&s>pb, align, get_bits(gb, align)); 
1426 
len = align; 
1427 
ff_copy_bits(&s>pb, gb>buffer + (get_bits_count(gb) >> 3), len);

1428 
} 
1429 
skip_bits_long(gb, len); 
1430  
1431 
{ 
1432 
PutBitContext tmp = s>pb; 
1433 
flush_put_bits(&tmp); 
1434 
} 
1435  
1436 
init_get_bits(&s>gb, s>frame_data, s>num_saved_bits); 
1437 
skip_bits(&s>gb, s>frame_offset); 
1438 
} 
1439  
1440 
/**

1441 
*@brief Decode a single WMA packet.

1442 
*@param avctx codec context

1443 
*@param data the output buffer

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

1445 
*@param avpkt input packet

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

1447 
*/

1448 
static int decode_packet(AVCodecContext *avctx, 
1449 
void *data, int *data_size, AVPacket* avpkt) 
1450 
{ 
1451 
WMAProDecodeCtx *s = avctx>priv_data; 
1452 
GetBitContext* gb = &s>pgb; 
1453 
const uint8_t* buf = avpkt>data;

1454 
int buf_size = avpkt>size;

1455 
int more_frames = 1; 
1456 
int num_bits_prev_frame;

1457 
int packet_sequence_number;

1458  
1459 
s>samples = data; 
1460 
s>samples_start = data; 
1461 
s>samples_end = (float*)((int8_t*)data + *data_size);

1462 
*data_size = 0;

1463  
1464 
if (!s>output_buffer_full) {

1465 
s>buf_bit_size = buf_size << 3;

1466  
1467 
/** sanity check for the buffer length */

1468 
if (buf_size < avctx>block_align)

1469 
return 0; 
1470  
1471 
buf_size = avctx>block_align; 
1472  
1473 
/** parse packet header */

1474 
init_get_bits(gb, buf, s>buf_bit_size); 
1475 
packet_sequence_number = get_bits(gb, 4);

1476 
skip_bits(gb, 2);

1477  
1478 
/** get number of bits that need to be added to the previous frame */

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

1481 
num_bits_prev_frame); 
1482  
1483 
/** check for packet loss */

1484 
if (!s>packet_loss &&

1485 
((s>packet_sequence_number + 1) & 0xF) != packet_sequence_number) { 
1486 
s>packet_loss = 1;

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

1488 
s>packet_sequence_number, packet_sequence_number); 
1489 
} 
1490 
s>packet_sequence_number = packet_sequence_number; 
1491  
1492 
if (num_bits_prev_frame > 0) { 
1493 
/** append the previous frame data to the remaining data from the

1494 
previous packet to create a full frame */

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

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

1497 
s>num_saved_bits  s>frame_offset); 
1498  
1499 
/** decode the cross packet frame if it is valid */

1500 
if (!s>packet_loss)

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

1504 
s>num_saved_bits  s>frame_offset); 
1505 
} 
1506  
1507 
s>packet_loss = 0;

1508  
1509 
} else {

1510 
/** continue decoding */

1511 
s>output_buffer_full = 0;

1512 
more_frames = decode_frame(s); 
1513 
} 
1514  
1515 
/** decode the rest of the packet */

1516 
while (!s>packet_loss && !s>output_buffer_full && more_frames &&

1517 
remaining_bits(s, gb) > s>log2_frame_size) { 
1518 
int frame_size = show_bits(gb, s>log2_frame_size);

1519  
1520 
/** there is enough data for a full frame */

1521 
if (remaining_bits(s, gb) >= frame_size && frame_size > 0) { 
1522 
save_bits(s, gb, frame_size, 0);

1523  
1524 
/** decode the frame */

1525 
more_frames = decode_frame(s); 
1526  
1527 
} else

1528 
more_frames = 0;

1529 
} 
1530  
1531 
if (!s>output_buffer_full && !s>packet_loss &&

1532 
remaining_bits(s, gb) > 0) {

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

1534 
with the next packet */

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

1536 
} 
1537  
1538 
*data_size = (int8_t *)s>samples  (int8_t *)data; 
1539  
1540 
return (s>output_buffer_full)?0: avctx>block_align; 
1541 
} 
1542  
1543 
/**

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

1545 
*@param avctx codec context

1546 
*/

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

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

1552 
new frame */

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

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

1556 
s>packet_loss = 1;

1557 
} 
1558  
1559  
1560 
/**

1561 
*@brief wmapro decoder

1562 
*/

1563 
AVCodec wmapro_decoder = { 
1564 
"wmapro",

1565 
CODEC_TYPE_AUDIO, 
1566 
CODEC_ID_WMAPRO, 
1567 
sizeof(WMAProDecodeCtx),

1568 
decode_init, 
1569 
NULL,

1570 
decode_end, 
1571 
decode_packet, 
1572 
.flush= flush, 
1573 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),

1574 
}; 