summaryrefslogtreecommitdiff
path: root/apps/codecs/libwmapro/wmaprodec.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/codecs/libwmapro/wmaprodec.c')
-rw-r--r--apps/codecs/libwmapro/wmaprodec.c1578
1 files changed, 1578 insertions, 0 deletions
diff --git a/apps/codecs/libwmapro/wmaprodec.c b/apps/codecs/libwmapro/wmaprodec.c
new file mode 100644
index 0000000000..82f1b3623b
--- /dev/null
+++ b/apps/codecs/libwmapro/wmaprodec.c
@@ -0,0 +1,1578 @@
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 02110-1301 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 per-channel data
30 * - rescaling and inverse quantization
31 * - IMDCT
32 * - windowing and overlapp-add
33 *
34 * The compressed wmapro bitstream is split into individual packets.
35 * Every such packet contains one or more wma frames.
36 * The compressed frames may have a variable length and frames may
37 * cross packet boundaries.
38 * Common to all wmapro frames is the number of samples that are stored in
39 * a frame.
40 * The number of samples and a few other decode flags are stored
41 * as extradata that has to be passed to the decoder.
42 *
43 * The wmapro frames themselves are again split into a variable number of
44 * subframes. Every subframe contains the data for 2^N time domain samples
45 * where N varies between 7 and 12.
46 *
47 * Example wmapro bitstream (in samples):
48 *
49 * || packet 0 || packet 1 || packet 2 packets
50 * ---------------------------------------------------
51 * || frame 0 || frame 1 || frame 2 || frames
52 * ---------------------------------------------------
53 * || | | || | | | || || subframes of channel 0
54 * ---------------------------------------------------
55 * || | | || | | | || || subframes of channel 1
56 * ---------------------------------------------------
57 *
58 * The frame layouts for the individual channels of a wma frame does not need
59 * to be the same.
60 *
61 * However, if the offsets and lengths of several subframes of a frame are the
62 * same, the subframes of the channels can be grouped.
63 * Every group may then use special coding techniques like M/S stereo coding
64 * to improve the compression ratio. These channel transformations do not
65 * need to be applied to a whole subframe. Instead, they can also work on
66 * individual scale factor bands (see below).
67 * The coefficients that carry the audio signal in the frequency domain
68 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
69 * In addition to that, the encoder can switch to a runlevel coding scheme
70 * by transmitting subframe_length / 128 zero coefficients.
71 *
72 * Before the audio signal can be converted to the time domain, the
73 * coefficients have to be rescaled and inverse quantized.
74 * A subframe is therefore split into several scale factor bands that get
75 * scaled individually.
76 * Scale factors are submitted for every frame but they might be shared
77 * between the subframes of a channel. Scale factors are initially DPCM-coded.
78 * Once scale factors are shared, the differences are transmitted as runlevel
79 * codes.
80 * Every subframe length and offset combination in the frame layout shares a
81 * common quantization factor that can be adjusted for every channel by a
82 * modifier.
83 * After the inverse quantization, the coefficients get processed by an IMDCT.
84 * The resulting values are then windowed with a sine window and the first half
85 * of the values are added to the second half of the output from the previous
86 * subframe in order to reconstruct the output samples.
87 */
88
89#include "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+VLCBITS-1)/VLCBITS)
111#define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
112#define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
113#define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
114#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
115
116static VLC sf_vlc; ///< scale factor DPCM vlc
117static VLC sf_rl_vlc; ///< scale factor run length vlc
118static VLC vec4_vlc; ///< 4 coefficients per symbol
119static VLC vec2_vlc; ///< 2 coefficients per symbol
120static VLC vec1_vlc; ///< 1 coefficient per symbol
121static VLC coef_vlc[2]; ///< coefficient run length vlc codes
122static float sin64[33]; ///< sinus table for decorrelation
123
124/**
125 * @brief frame specific decoder context for a single channel
126 */
127typedef 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 */
151typedef 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 */
162typedef 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 */
231static 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 */
250static 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 */
266static 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) {
347 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
348 return AVERROR_INVALIDDATA;
349 } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
350 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
351 return AVERROR_PATCHWELCOME;
352 }
353
354 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
355 scale_huffbits, 1, 1,
356 scale_huffcodes, 2, 2, 616);
357
358 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
359 scale_rl_huffbits, 1, 1,
360 scale_rl_huffcodes, 4, 4, 1406);
361
362 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
363 coef0_huffbits, 1, 1,
364 coef0_huffcodes, 4, 4, 2108);
365
366 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
367 coef1_huffbits, 1, 1,
368 coef1_huffcodes, 4, 4, 3912);
369
370 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
371 vec4_huffbits, 1, 1,
372 vec4_huffcodes, 2, 2, 604);
373
374 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
375 vec2_huffbits, 1, 1,
376 vec2_huffcodes, 2, 2, 562);
377
378 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
379 vec1_huffbits, 1, 1,
380 vec1_huffcodes, 2, 2, 562);
381
382 /** calculate number of scale factor bands and their offsets
383 for every possible block size */
384 for (i = 0; i < num_possible_block_sizes; i++) {
385 int subframe_len = s->samples_per_frame >> i;
386 int x;
387 int band = 1;
388
389 s->sfb_offsets[i][0] = 0;
390
391 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
392 int offset = (subframe_len * 2 * critical_freq[x])
393 / s->avctx->sample_rate + 2;
394 offset &= ~3;
395 if (offset > s->sfb_offsets[i][band - 1])
396 s->sfb_offsets[i][band++] = offset;
397 }
398 s->sfb_offsets[i][band - 1] = subframe_len;
399 s->num_sfb[i] = band - 1;
400 }
401
402
403 /** Scale factors can be shared between blocks of different size
404 as every block has a different scale factor band layout.
405 The matrix sf_offsets is needed to find the correct scale factor.
406 */
407
408 for (i = 0; i < num_possible_block_sizes; i++) {
409 int b;
410 for (b = 0; b < s->num_sfb[i]; b++) {
411 int x;
412 int offset = ((s->sfb_offsets[i][b]
413 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
414 for (x = 0; x < num_possible_block_sizes; x++) {
415 int v = 0;
416 while (s->sfb_offsets[x][v + 1] << x < offset)
417 ++v;
418 s->sf_offsets[i][x][b] = v;
419 }
420 }
421 }
422
423 /** init MDCT, FIXME: only init needed sizes */
424 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
425 ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1,
426 1.0 / (1 << (BLOCK_MIN_BITS + i - 1))
427 / (1 << (s->bits_per_sample - 1)));
428
429 /** init MDCT windows: simple sinus window */
430 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
431 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
432 ff_init_ff_sine_windows(win_idx);
433 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
434 }
435
436 /** calculate subwoofer cutoff values */
437 for (i = 0; i < num_possible_block_sizes; i++) {
438 int block_size = s->samples_per_frame >> i;
439 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
440 / s->avctx->sample_rate;
441 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
442 }
443
444 /** calculate sine values for the decorrelation matrix */
445 for (i = 0; i < 33; i++)
446 sin64[i] = sin(i*M_PI / 64.0);
447
448 if (avctx->debug & FF_DEBUG_BITSTREAM)
449 dump_context(s);
450
451 avctx->channel_layout = channel_mask;
452 return 0;
453}
454
455/**
456 *@brief Decode the subframe length.
457 *@param s context
458 *@param offset sample offset in the frame
459 *@return decoded subframe length on success, < 0 in case of an error
460 */
461static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
462{
463 int frame_len_shift = 0;
464 int subframe_len;
465
466 /** no need to read from the bitstream when only one length is possible */
467 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
468 return s->min_samples_per_subframe;
469
470 /** 1 bit indicates if the subframe is of maximum length */
471 if (s->max_subframe_len_bit) {
472 if (get_bits1(&s->gb))
473 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
474 } else
475 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
476
477 subframe_len = s->samples_per_frame >> frame_len_shift;
478
479 /** sanity check the length */
480 if (subframe_len < s->min_samples_per_subframe ||
481 subframe_len > s->samples_per_frame) {
482 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
483 subframe_len);
484 return AVERROR_INVALIDDATA;
485 }
486 return subframe_len;
487}
488
489/**
490 *@brief Decode how the data in the frame is split into subframes.
491 * Every WMA frame contains the encoded data for a fixed number of
492 * samples per channel. The data for every channel might be split
493 * into several subframes. This function will reconstruct the list of
494 * subframes for every channel.
495 *
496 * If the subframes are not evenly split, the algorithm estimates the
497 * channels with the lowest number of total samples.
498 * Afterwards, for each of these channels a bit is read from the
499 * bitstream that indicates if the channel contains a subframe with the
500 * next subframe size that is going to be read from the bitstream or not.
501 * If a channel contains such a subframe, the subframe size gets added to
502 * the channel's subframe list.
503 * The algorithm repeats these steps until the frame is properly divided
504 * between the individual channels.
505 *
506 *@param s context
507 *@return 0 on success, < 0 in case of an error
508 */
509static int decode_tilehdr(WMAProDecodeCtx *s)
510{
511 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /** sum of samples for all currently known subframes of a channel */
512 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /** flag indicating if a channel contains the current subframe */
513 int channels_for_cur_subframe = s->num_channels; /** number of channels that contain the current subframe */
514 int fixed_channel_layout = 0; /** flag indicating that all channels use the same subframe offsets and sizes */
515 int min_channel_len = 0; /** smallest sum of samples (channels with this length will be processed first) */
516 int c;
517
518 /* Should never consume more than 3073 bits (256 iterations for the
519 * while loop when always the minimum amount of 128 samples is substracted
520 * from missing samples in the 8 channel case).
521 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
522 */
523
524 /** reset tiling information */
525 for (c = 0; c < s->num_channels; c++)
526 s->channel[c].num_subframes = 0;
527
528 memset(num_samples, 0, sizeof(num_samples));
529
530 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
531 fixed_channel_layout = 1;
532
533 /** loop until the frame data is split between the subframes */
534 do {
535 int subframe_len;
536
537 /** check which channels contain the subframe */
538 for (c = 0; c < s->num_channels; c++) {
539 if (num_samples[c] == min_channel_len) {
540 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
541 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
542 contains_subframe[c] = 1;
543 else
544 contains_subframe[c] = get_bits1(&s->gb);
545 } else
546 contains_subframe[c] = 0;
547 }
548
549 /** get subframe length, subframe_len == 0 is not allowed */
550 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
551 return AVERROR_INVALIDDATA;
552
553 /** add subframes to the individual channels and find new min_channel_len */
554 min_channel_len += subframe_len;
555 for (c = 0; c < s->num_channels; c++) {
556 WMAProChannelCtx* chan = &s->channel[c];
557
558 if (contains_subframe[c]) {
559 if (chan->num_subframes >= MAX_SUBFRAMES) {
560 av_log(s->avctx, AV_LOG_ERROR,
561 "broken frame: num subframes > 31\n");
562 return AVERROR_INVALIDDATA;
563 }
564 chan->subframe_len[chan->num_subframes] = subframe_len;
565 num_samples[c] += subframe_len;
566 ++chan->num_subframes;
567 if (num_samples[c] > s->samples_per_frame) {
568 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
569 "channel len > samples_per_frame\n");
570 return AVERROR_INVALIDDATA;
571 }
572 } else if (num_samples[c] <= min_channel_len) {
573 if (num_samples[c] < min_channel_len) {
574 channels_for_cur_subframe = 0;
575 min_channel_len = num_samples[c];
576 }
577 ++channels_for_cur_subframe;
578 }
579 }
580 } while (min_channel_len < s->samples_per_frame);
581
582 for (c = 0; c < s->num_channels; c++) {
583 int i;
584 int offset = 0;
585 for (i = 0; i < s->channel[c].num_subframes; i++) {
586 dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
587 " len %i\n", s->frame_num, c, i,
588 s->channel[c].subframe_len[i]);
589 s->channel[c].subframe_offset[i] = offset;
590 offset += s->channel[c].subframe_len[i];
591 }
592 }
593
594 return 0;
595}
596
597/**
598 *@brief Calculate a decorrelation matrix from the bitstream parameters.
599 *@param s codec context
600 *@param chgroup channel group for which the matrix needs to be calculated
601 */
602static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
603 WMAProChannelGrp *chgroup)
604{
605 int i;
606 int offset = 0;
607 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
608 memset(chgroup->decorrelation_matrix, 0, s->num_channels *
609 s->num_channels * sizeof(*chgroup->decorrelation_matrix));
610
611 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
612 rotation_offset[i] = get_bits(&s->gb, 6);
613
614 for (i = 0; i < chgroup->num_channels; i++)
615 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
616 get_bits1(&s->gb) ? 1.0 : -1.0;
617
618 for (i = 1; i < chgroup->num_channels; i++) {
619 int x;
620 for (x = 0; x < i; x++) {
621 int y;
622 for (y = 0; y < i + 1; y++) {
623 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
624 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
625 int n = rotation_offset[offset + x];
626 float sinv;
627 float cosv;
628
629 if (n < 32) {
630 sinv = sin64[n];
631 cosv = sin64[32 - n];
632 } else {
633 sinv = sin64[64 - n];
634 cosv = -sin64[n - 32];
635 }
636
637 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
638 (v1 * sinv) - (v2 * cosv);
639 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
640 (v1 * cosv) + (v2 * sinv);
641 }
642 }
643 offset += i;
644 }
645}
646
647/**
648 *@brief Decode channel transformation parameters
649 *@param s codec context
650 *@return 0 in case of success, < 0 in case of bitstream errors
651 */
652static int decode_channel_transform(WMAProDecodeCtx* s)
653{
654 int i;
655 /* should never consume more than 1921 bits for the 8 channel case
656 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
657 * + MAX_CHANNELS + MAX_BANDS + 1)
658 */
659
660 /** in the one channel case channel transforms are pointless */
661 s->num_chgroups = 0;
662 if (s->num_channels > 1) {
663 int remaining_channels = s->channels_for_cur_subframe;
664
665 if (get_bits1(&s->gb)) {
666 av_log_ask_for_sample(s->avctx,
667 "unsupported channel transform bit\n");
668 return AVERROR_INVALIDDATA;
669 }
670
671 for (s->num_chgroups = 0; remaining_channels &&
672 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
673 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
674 float** channel_data = chgroup->channel_data;
675 chgroup->num_channels = 0;
676 chgroup->transform = 0;
677
678 /** decode channel mask */
679 if (remaining_channels > 2) {
680 for (i = 0; i < s->channels_for_cur_subframe; i++) {
681 int channel_idx = s->channel_indexes_for_cur_subframe[i];
682 if (!s->channel[channel_idx].grouped
683 && get_bits1(&s->gb)) {
684 ++chgroup->num_channels;
685 s->channel[channel_idx].grouped = 1;
686 *channel_data++ = s->channel[channel_idx].coeffs;
687 }
688 }
689 } else {
690 chgroup->num_channels = remaining_channels;
691 for (i = 0; i < s->channels_for_cur_subframe; i++) {
692 int channel_idx = s->channel_indexes_for_cur_subframe[i];
693 if (!s->channel[channel_idx].grouped)
694 *channel_data++ = s->channel[channel_idx].coeffs;
695 s->channel[channel_idx].grouped = 1;
696 }
697 }
698
699 /** decode transform type */
700 if (chgroup->num_channels == 2) {
701 if (get_bits1(&s->gb)) {
702 if (get_bits1(&s->gb)) {
703 av_log_ask_for_sample(s->avctx,
704 "unsupported channel transform type\n");
705 }
706 } else {
707 chgroup->transform = 1;
708 if (s->num_channels == 2) {
709 chgroup->decorrelation_matrix[0] = 1.0;
710 chgroup->decorrelation_matrix[1] = -1.0;
711 chgroup->decorrelation_matrix[2] = 1.0;
712 chgroup->decorrelation_matrix[3] = 1.0;
713 } else {
714 /** cos(pi/4) */
715 chgroup->decorrelation_matrix[0] = 0.70703125;
716 chgroup->decorrelation_matrix[1] = -0.70703125;
717 chgroup->decorrelation_matrix[2] = 0.70703125;
718 chgroup->decorrelation_matrix[3] = 0.70703125;
719 }
720 }
721 } else if (chgroup->num_channels > 2) {
722 if (get_bits1(&s->gb)) {
723 chgroup->transform = 1;
724 if (get_bits1(&s->gb)) {
725 decode_decorrelation_matrix(s, chgroup);
726 } else {
727 /** FIXME: more than 6 coupled channels not supported */
728 if (chgroup->num_channels > 6) {
729 av_log_ask_for_sample(s->avctx,
730 "coupled channels > 6\n");
731 } else {
732 memcpy(chgroup->decorrelation_matrix,
733 default_decorrelation[chgroup->num_channels],
734 chgroup->num_channels * chgroup->num_channels *
735 sizeof(*chgroup->decorrelation_matrix));
736 }
737 }
738 }
739 }
740
741 /** decode transform on / off */
742 if (chgroup->transform) {
743 if (!get_bits1(&s->gb)) {
744 int i;
745 /** transform can be enabled for individual bands */
746 for (i = 0; i < s->num_bands; i++) {
747 chgroup->transform_band[i] = get_bits1(&s->gb);
748 }
749 } else {
750 memset(chgroup->transform_band, 1, s->num_bands);
751 }
752 }
753 remaining_channels -= chgroup->num_channels;
754 }
755 }
756 return 0;
757}
758
759/**
760 *@brief Extract the coefficients from the bitstream.
761 *@param s codec context
762 *@param c current channel number
763 *@return 0 on success, < 0 in case of bitstream errors
764 */
765static int decode_coeffs(WMAProDecodeCtx *s, int c)
766{
767 /* Integers 0..15 as single-precision floats. The table saves a
768 costly int to float conversion, and storing the values as
769 integers allows fast sign-flipping. */
770 static const int fval_tab[16] = {
771 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
772 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
773 0x41000000, 0x41100000, 0x41200000, 0x41300000,
774 0x41400000, 0x41500000, 0x41600000, 0x41700000,
775 };
776 int vlctable;
777 VLC* vlc;
778 WMAProChannelCtx* ci = &s->channel[c];
779 int rl_mode = 0;
780 int cur_coeff = 0;
781 int num_zeros = 0;
782 const uint16_t* run;
783 const float* level;
784
785 dprintf(s->avctx, "decode coefficients for channel %i\n", c);
786
787 vlctable = get_bits1(&s->gb);
788 vlc = &coef_vlc[vlctable];
789
790 if (vlctable) {
791 run = coef1_run;
792 level = coef1_level;
793 } else {
794 run = coef0_run;
795 level = coef0_level;
796 }
797
798 /** decode vector coefficients (consumes up to 167 bits per iteration for
799 4 vector coded large values) */
800 while (!rl_mode && cur_coeff + 3 < s->subframe_len) {
801 int vals[4];
802 int i;
803 unsigned int idx;
804
805 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
806
807 if (idx == HUFF_VEC4_SIZE - 1) {
808 for (i = 0; i < 4; i += 2) {
809 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
810 if (idx == HUFF_VEC2_SIZE - 1) {
811 int v0, v1;
812 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
813 if (v0 == HUFF_VEC1_SIZE - 1)
814 v0 += ff_wma_get_large_val(&s->gb);
815 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
816 if (v1 == HUFF_VEC1_SIZE - 1)
817 v1 += ff_wma_get_large_val(&s->gb);
818 ((float*)vals)[i ] = v0;
819 ((float*)vals)[i+1] = v1;
820 } else {
821 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
822 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
823 }
824 }
825 } else {
826 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
827 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
828 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
829 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
830 }
831
832 /** decode sign */
833 for (i = 0; i < 4; i++) {
834 if (vals[i]) {
835 int sign = get_bits1(&s->gb) - 1;
836 *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31;
837 num_zeros = 0;
838 } else {
839 ci->coeffs[cur_coeff] = 0;
840 /** switch to run level mode when subframe_len / 128 zeros
841 were found in a row */
842 rl_mode |= (++num_zeros > s->subframe_len >> 8);
843 }
844 ++cur_coeff;
845 }
846 }
847
848 /** decode run level coded coefficients */
849 if (rl_mode) {
850 memset(&ci->coeffs[cur_coeff], 0,
851 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
852 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
853 level, run, 1, ci->coeffs,
854 cur_coeff, s->subframe_len,
855 s->subframe_len, s->esc_len, 0))
856 return AVERROR_INVALIDDATA;
857 }
858
859 return 0;
860}
861
862/**
863 *@brief Extract scale factors from the bitstream.
864 *@param s codec context
865 *@return 0 on success, < 0 in case of bitstream errors
866 */
867static int decode_scale_factors(WMAProDecodeCtx* s)
868{
869 int i;
870
871 /** should never consume more than 5344 bits
872 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
873 */
874
875 for (i = 0; i < s->channels_for_cur_subframe; i++) {
876 int c = s->channel_indexes_for_cur_subframe[i];
877 int* sf;
878 int* sf_end;
879 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
880 sf_end = s->channel[c].scale_factors + s->num_bands;
881
882 /** resample scale factors for the new block size
883 * as the scale factors might need to be resampled several times
884 * before some new values are transmitted, a backup of the last
885 * transmitted scale factors is kept in saved_scale_factors
886 */
887 if (s->channel[c].reuse_sf) {
888 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
889 int b;
890 for (b = 0; b < s->num_bands; b++)
891 s->channel[c].scale_factors[b] =
892 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
893 }
894
895 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
896
897 if (!s->channel[c].reuse_sf) {
898 int val;
899 /** decode DPCM coded scale factors */
900 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
901 val = 45 / s->channel[c].scale_factor_step;
902 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
903 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
904 *sf = val;
905 }
906 } else {
907 int i;
908 /** run level decode differences to the resampled factors */
909 for (i = 0; i < s->num_bands; i++) {
910 int idx;
911 int skip;
912 int val;
913 int sign;
914
915 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
916
917 if (!idx) {
918 uint32_t code = get_bits(&s->gb, 14);
919 val = code >> 6;
920 sign = (code & 1) - 1;
921 skip = (code & 0x3f) >> 1;
922 } else if (idx == 1) {
923 break;
924 } else {
925 skip = scale_rl_run[idx];
926 val = scale_rl_level[idx];
927 sign = get_bits1(&s->gb)-1;
928 }
929
930 i += skip;
931 if (i >= s->num_bands) {
932 av_log(s->avctx, AV_LOG_ERROR,
933 "invalid scale factor coding\n");
934 return AVERROR_INVALIDDATA;
935 }
936 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
937 }
938 }
939 /** swap buffers */
940 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
941 s->channel[c].table_idx = s->table_idx;
942 s->channel[c].reuse_sf = 1;
943 }
944
945 /** calculate new scale factor maximum */
946 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
947 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
948 s->channel[c].max_scale_factor =
949 FFMAX(s->channel[c].max_scale_factor, *sf);
950 }
951
952 }
953 return 0;
954}
955
956/**
957 *@brief Reconstruct the individual channel data.
958 *@param s codec context
959 */
960static void inverse_channel_transform(WMAProDecodeCtx *s)
961{
962 int i;
963
964 for (i = 0; i < s->num_chgroups; i++) {
965 if (s->chgroup[i].transform) {
966 float data[WMAPRO_MAX_CHANNELS];
967 const int num_channels = s->chgroup[i].num_channels;
968 float** ch_data = s->chgroup[i].channel_data;
969 float** ch_end = ch_data + num_channels;
970 const int8_t* tb = s->chgroup[i].transform_band;
971 int16_t* sfb;
972
973 /** multichannel decorrelation */
974 for (sfb = s->cur_sfb_offsets;
975 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
976 int y;
977 if (*tb++ == 1) {
978 /** multiply values with the decorrelation_matrix */
979 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
980 const float* mat = s->chgroup[i].decorrelation_matrix;
981 const float* data_end = data + num_channels;
982 float* data_ptr = data;
983 float** ch;
984
985 for (ch = ch_data; ch < ch_end; ch++)
986 *data_ptr++ = (*ch)[y];
987
988 for (ch = ch_data; ch < ch_end; ch++) {
989 float sum = 0;
990 data_ptr = data;
991 while (data_ptr < data_end)
992 sum += *data_ptr++ * *mat++;
993
994 (*ch)[y] = sum;
995 }
996 }
997 } else if (s->num_channels == 2) {
998 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
999 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
1000 ch_data[0] + sfb[0],
1001 181.0 / 128, len);
1002 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1003 ch_data[1] + sfb[0],
1004 181.0 / 128, len);
1005 }
1006 }
1007 }
1008 }
1009}
1010
1011/**
1012 *@brief Apply sine window and reconstruct the output buffer.
1013 *@param s codec context
1014 */
1015static void wmapro_window(WMAProDecodeCtx *s)
1016{
1017 int i;
1018 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1019 int c = s->channel_indexes_for_cur_subframe[i];
1020 float* window;
1021 int winlen = s->channel[c].prev_block_len;
1022 float* start = s->channel[c].coeffs - (winlen >> 1);
1023
1024 if (s->subframe_len < winlen) {
1025 start += (winlen - s->subframe_len) >> 1;
1026 winlen = s->subframe_len;
1027 }
1028
1029 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1030
1031 winlen >>= 1;
1032
1033 s->dsp.vector_fmul_window(start, start, start + winlen,
1034 window, 0, winlen);
1035
1036 s->channel[c].prev_block_len = s->subframe_len;
1037 }
1038}
1039
1040/**
1041 *@brief Decode a single subframe (block).
1042 *@param s codec context
1043 *@return 0 on success, < 0 when decoding failed
1044 */
1045static int decode_subframe(WMAProDecodeCtx *s)
1046{
1047 int offset = s->samples_per_frame;
1048 int subframe_len = s->samples_per_frame;
1049 int i;
1050 int total_samples = s->samples_per_frame * s->num_channels;
1051 int transmit_coeffs = 0;
1052 int cur_subwoofer_cutoff;
1053
1054 s->subframe_offset = get_bits_count(&s->gb);
1055
1056 /** reset channel context and find the next block offset and size
1057 == the next block of the channel with the smallest number of
1058 decoded samples
1059 */
1060 for (i = 0; i < s->num_channels; i++) {
1061 s->channel[i].grouped = 0;
1062 if (offset > s->channel[i].decoded_samples) {
1063 offset = s->channel[i].decoded_samples;
1064 subframe_len =
1065 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1066 }
1067 }
1068
1069 dprintf(s->avctx,
1070 "processing subframe with offset %i len %i\n", offset, subframe_len);
1071
1072 /** get a list of all channels that contain the estimated block */
1073 s->channels_for_cur_subframe = 0;
1074 for (i = 0; i < s->num_channels; i++) {
1075 const int cur_subframe = s->channel[i].cur_subframe;
1076 /** substract already processed samples */
1077 total_samples -= s->channel[i].decoded_samples;
1078
1079 /** and count if there are multiple subframes that match our profile */
1080 if (offset == s->channel[i].decoded_samples &&
1081 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1082 total_samples -= s->channel[i].subframe_len[cur_subframe];
1083 s->channel[i].decoded_samples +=
1084 s->channel[i].subframe_len[cur_subframe];
1085 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1086 ++s->channels_for_cur_subframe;
1087 }
1088 }
1089
1090 /** check if the frame will be complete after processing the
1091 estimated block */
1092 if (!total_samples)
1093 s->parsed_all_subframes = 1;
1094
1095
1096 dprintf(s->avctx, "subframe is part of %i channels\n",
1097 s->channels_for_cur_subframe);
1098
1099 /** calculate number of scale factor bands and their offsets */
1100 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1101 s->num_bands = s->num_sfb[s->table_idx];
1102 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1103 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1104
1105 /** configure the decoder for the current subframe */
1106 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1107 int c = s->channel_indexes_for_cur_subframe[i];
1108
1109 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1110 + offset];
1111 }
1112
1113 s->subframe_len = subframe_len;
1114 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1115
1116 /** skip extended header if any */
1117 if (get_bits1(&s->gb)) {
1118 int num_fill_bits;
1119 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1120 int len = get_bits(&s->gb, 4);
1121 num_fill_bits = get_bits(&s->gb, len) + 1;
1122 }
1123
1124 if (num_fill_bits >= 0) {
1125 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1126 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1127 return AVERROR_INVALIDDATA;
1128 }
1129
1130 skip_bits_long(&s->gb, num_fill_bits);
1131 }
1132 }
1133
1134 /** no idea for what the following bit is used */
1135 if (get_bits1(&s->gb)) {
1136 av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1137 return AVERROR_INVALIDDATA;
1138 }
1139
1140
1141 if (decode_channel_transform(s) < 0)
1142 return AVERROR_INVALIDDATA;
1143
1144
1145 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1146 int c = s->channel_indexes_for_cur_subframe[i];
1147 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1148 transmit_coeffs = 1;
1149 }
1150
1151 if (transmit_coeffs) {
1152 int step;
1153 int quant_step = 90 * s->bits_per_sample >> 4;
1154 if ((get_bits1(&s->gb))) {
1155 /** FIXME: might change run level mode decision */
1156 av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1157 return AVERROR_INVALIDDATA;
1158 }
1159 /** decode quantization step */
1160 step = get_sbits(&s->gb, 6);
1161 quant_step += step;
1162 if (step == -32 || step == 31) {
1163 const int sign = (step == 31) - 1;
1164 int quant = 0;
1165 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1166 (step = get_bits(&s->gb, 5)) == 31) {
1167 quant += 31;
1168 }
1169 quant_step += ((quant + step) ^ sign) - sign;
1170 }
1171 if (quant_step < 0) {
1172 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1173 }
1174
1175 /** decode quantization step modifiers for every channel */
1176
1177 if (s->channels_for_cur_subframe == 1) {
1178 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1179 } else {
1180 int modifier_len = get_bits(&s->gb, 3);
1181 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1182 int c = s->channel_indexes_for_cur_subframe[i];
1183 s->channel[c].quant_step = quant_step;
1184 if (get_bits1(&s->gb)) {
1185 if (modifier_len) {
1186 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1187 } else
1188 ++s->channel[c].quant_step;
1189 }
1190 }
1191 }
1192
1193 /** decode scale factors */
1194 if (decode_scale_factors(s) < 0)
1195 return AVERROR_INVALIDDATA;
1196 }
1197
1198 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1199 get_bits_count(&s->gb) - s->subframe_offset);
1200
1201 /** parse coefficients */
1202 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1203 int c = s->channel_indexes_for_cur_subframe[i];
1204 if (s->channel[c].transmit_coefs &&
1205 get_bits_count(&s->gb) < s->num_saved_bits) {
1206 decode_coeffs(s, c);
1207 } else
1208 memset(s->channel[c].coeffs, 0,
1209 sizeof(*s->channel[c].coeffs) * subframe_len);
1210 }
1211
1212 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1213 get_bits_count(&s->gb) - s->subframe_offset);
1214
1215 if (transmit_coeffs) {
1216 /** reconstruct the per channel data */
1217 inverse_channel_transform(s);
1218 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1219 int c = s->channel_indexes_for_cur_subframe[i];
1220 const int* sf = s->channel[c].scale_factors;
1221 int b;
1222
1223 if (c == s->lfe_channel)
1224 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1225 (subframe_len - cur_subwoofer_cutoff));
1226
1227 /** inverse quantization and rescaling */
1228 for (b = 0; b < s->num_bands; b++) {
1229 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1230 const int exp = s->channel[c].quant_step -
1231 (s->channel[c].max_scale_factor - *sf++) *
1232 s->channel[c].scale_factor_step;
1233 const float quant = pow(10.0, exp / 20.0);
1234 int start = s->cur_sfb_offsets[b];
1235 s->dsp.vector_fmul_scalar(s->tmp + start,
1236 s->channel[c].coeffs + start,
1237 quant, end - start);
1238 }
1239
1240 /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1241 ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS],
1242 s->channel[c].coeffs, s->tmp);
1243 }
1244 }
1245
1246 /** window and overlapp-add */
1247 wmapro_window(s);
1248
1249 /** handled one subframe */
1250 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1251 int c = s->channel_indexes_for_cur_subframe[i];
1252 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1253 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1254 return AVERROR_INVALIDDATA;
1255 }
1256 ++s->channel[c].cur_subframe;
1257 }
1258
1259 return 0;
1260}
1261
1262/**
1263 *@brief Decode one WMA frame.
1264 *@param s codec context
1265 *@return 0 if the trailer bit indicates that this is the last frame,
1266 * 1 if there are additional frames
1267 */
1268static int decode_frame(WMAProDecodeCtx *s)
1269{
1270 GetBitContext* gb = &s->gb;
1271 int more_frames = 0;
1272 int len = 0;
1273 int i;
1274
1275 /** check for potential output buffer overflow */
1276 if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1277 /** return an error if no frame could be decoded at all */
1278 av_log(s->avctx, AV_LOG_ERROR,
1279 "not enough space for the output samples\n");
1280 s->packet_loss = 1;
1281 return 0;
1282 }
1283
1284 /** get frame length */
1285 if (s->len_prefix)
1286 len = get_bits(gb, s->log2_frame_size);
1287
1288 dprintf(s->avctx, "decoding frame with length %x\n", len);
1289
1290 /** decode tile information */
1291 if (decode_tilehdr(s)) {
1292 s->packet_loss = 1;
1293 return 0;
1294 }
1295
1296 /** read postproc transform */
1297 if (s->num_channels > 1 && get_bits1(gb)) {
1298 av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1299 s->packet_loss = 1;
1300 return 0;
1301 }
1302
1303 /** read drc info */
1304 if (s->dynamic_range_compression) {
1305 s->drc_gain = get_bits(gb, 8);
1306 dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1307 }
1308
1309 /** no idea what these are for, might be the number of samples
1310 that need to be skipped at the beginning or end of a stream */
1311 if (get_bits1(gb)) {
1312 int skip;
1313
1314 /** usually true for the first frame */
1315 if (get_bits1(gb)) {
1316 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1317 dprintf(s->avctx, "start skip: %i\n", skip);
1318 }
1319
1320 /** sometimes true for the last frame */
1321 if (get_bits1(gb)) {
1322 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1323 dprintf(s->avctx, "end skip: %i\n", skip);
1324 }
1325
1326 }
1327
1328 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1329 get_bits_count(gb) - s->frame_offset);
1330
1331 /** reset subframe states */
1332 s->parsed_all_subframes = 0;
1333 for (i = 0; i < s->num_channels; i++) {
1334 s->channel[i].decoded_samples = 0;
1335 s->channel[i].cur_subframe = 0;
1336 s->channel[i].reuse_sf = 0;
1337 }
1338
1339 /** decode all subframes */
1340 while (!s->parsed_all_subframes) {
1341 if (decode_subframe(s) < 0) {
1342 s->packet_loss = 1;
1343 return 0;
1344 }
1345 }
1346
1347 /** interleave samples and write them to the output buffer */
1348 for (i = 0; i < s->num_channels; i++) {
1349 float* ptr = s->samples + i;
1350 int incr = s->num_channels;
1351 float* iptr = s->channel[i].out;
1352 float* iend = iptr + s->samples_per_frame;
1353
1354 while (iptr < iend) {
1355 *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1356 ptr += incr;
1357 }
1358
1359 /** reuse second half of the IMDCT output for the next frame */
1360 memcpy(&s->channel[i].out[0],
1361 &s->channel[i].out[s->samples_per_frame],
1362 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1363 }
1364
1365 if (s->skip_frame) {
1366 s->skip_frame = 0;
1367 } else
1368 s->samples += s->num_channels * s->samples_per_frame;
1369
1370 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1371 /** FIXME: not sure if this is always an error */
1372 av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n",
1373 s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1374 s->packet_loss = 1;
1375 return 0;
1376 }
1377
1378 /** skip the rest of the frame data */
1379 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1380
1381 /** decode trailer bit */
1382 more_frames = get_bits1(gb);
1383
1384 ++s->frame_num;
1385 return more_frames;
1386}
1387
1388/**
1389 *@brief Calculate remaining input buffer length.
1390 *@param s codec context
1391 *@param gb bitstream reader context
1392 *@return remaining size in bits
1393 */
1394static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1395{
1396 return s->buf_bit_size - get_bits_count(gb);
1397}
1398
1399/**
1400 *@brief Fill the bit reservoir with a (partial) frame.
1401 *@param s codec context
1402 *@param gb bitstream reader context
1403 *@param len length of the partial frame
1404 *@param append decides wether to reset the buffer or not
1405 */
1406static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1407 int append)
1408{
1409 int buflen;
1410
1411 /** when the frame data does not need to be concatenated, the input buffer
1412 is resetted and additional bits from the previous frame are copyed
1413 and skipped later so that a fast byte copy is possible */
1414
1415 if (!append) {
1416 s->frame_offset = get_bits_count(gb) & 7;
1417 s->num_saved_bits = s->frame_offset;
1418 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1419 }
1420
1421 buflen = (s->num_saved_bits + len + 8) >> 3;
1422
1423 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1424 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1425 s->packet_loss = 1;
1426 return;
1427 }
1428
1429 s->num_saved_bits += len;
1430 if (!append) {
1431 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1432 s->num_saved_bits);
1433 } else {
1434 int align = 8 - (get_bits_count(gb) & 7);
1435 align = FFMIN(align, len);
1436 put_bits(&s->pb, align, get_bits(gb, align));
1437 len -= align;
1438 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1439 }
1440 skip_bits_long(gb, len);
1441
1442 {
1443 PutBitContext tmp = s->pb;
1444 flush_put_bits(&tmp);
1445 }
1446
1447 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1448 skip_bits(&s->gb, s->frame_offset);
1449}
1450
1451/**
1452 *@brief Decode a single WMA packet.
1453 *@param avctx codec context
1454 *@param data the output buffer
1455 *@param data_size number of bytes that were written to the output buffer
1456 *@param avpkt input packet
1457 *@return number of bytes that were read from the input buffer
1458 */
1459static int decode_packet(AVCodecContext *avctx,
1460 void *data, int *data_size, AVPacket* avpkt)
1461{
1462 WMAProDecodeCtx *s = avctx->priv_data;
1463 GetBitContext* gb = &s->pgb;
1464 const uint8_t* buf = avpkt->data;
1465 int buf_size = avpkt->size;
1466 int num_bits_prev_frame;
1467 int packet_sequence_number;
1468
1469 s->samples = data;
1470 s->samples_end = (float*)((int8_t*)data + *data_size);
1471 *data_size = 0;
1472
1473 if (s->packet_done || s->packet_loss) {
1474 s->packet_done = 0;
1475 s->buf_bit_size = buf_size << 3;
1476
1477 /** sanity check for the buffer length */
1478 if (buf_size < avctx->block_align)
1479 return 0;
1480
1481 buf_size = avctx->block_align;
1482
1483 /** parse packet header */
1484 init_get_bits(gb, buf, s->buf_bit_size);
1485 packet_sequence_number = get_bits(gb, 4);
1486 skip_bits(gb, 2);
1487
1488 /** get number of bits that need to be added to the previous frame */
1489 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1490 dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1491 num_bits_prev_frame);
1492
1493 /** check for packet loss */
1494 if (!s->packet_loss &&
1495 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1496 s->packet_loss = 1;
1497 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1498 s->packet_sequence_number, packet_sequence_number);
1499 }
1500 s->packet_sequence_number = packet_sequence_number;
1501
1502 if (num_bits_prev_frame > 0) {
1503 /** append the previous frame data to the remaining data from the
1504 previous packet to create a full frame */
1505 save_bits(s, gb, num_bits_prev_frame, 1);
1506 dprintf(avctx, "accumulated %x bits of frame data\n",
1507 s->num_saved_bits - s->frame_offset);
1508
1509 /** decode the cross packet frame if it is valid */
1510 if (!s->packet_loss)
1511 decode_frame(s);
1512 } else if (s->num_saved_bits - s->frame_offset) {
1513 dprintf(avctx, "ignoring %x previously saved bits\n",
1514 s->num_saved_bits - s->frame_offset);
1515 }
1516
1517 s->packet_loss = 0;
1518
1519 } else {
1520 int frame_size;
1521 s->buf_bit_size = avpkt->size << 3;
1522 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1523 skip_bits(gb, s->packet_offset);
1524 if (remaining_bits(s, gb) > s->log2_frame_size &&
1525 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1526 frame_size <= remaining_bits(s, gb)) {
1527 save_bits(s, gb, frame_size, 0);
1528 s->packet_done = !decode_frame(s);
1529 } else
1530 s->packet_done = 1;
1531 }
1532
1533 if (s->packet_done && !s->packet_loss &&
1534 remaining_bits(s, gb) > 0) {
1535 /** save the rest of the data so that it can be decoded
1536 with the next packet */
1537 save_bits(s, gb, remaining_bits(s, gb), 0);
1538 }
1539
1540 *data_size = (int8_t *)s->samples - (int8_t *)data;
1541 s->packet_offset = get_bits_count(gb) & 7;
1542
1543 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1544}
1545
1546/**
1547 *@brief Clear decoder buffers (for seeking).
1548 *@param avctx codec context
1549 */
1550static void flush(AVCodecContext *avctx)
1551{
1552 WMAProDecodeCtx *s = avctx->priv_data;
1553 int i;
1554 /** reset output buffer as a part of it is used during the windowing of a
1555 new frame */
1556 for (i = 0; i < s->num_channels; i++)
1557 memset(s->channel[i].out, 0, s->samples_per_frame *
1558 sizeof(*s->channel[i].out));
1559 s->packet_loss = 1;
1560}
1561
1562
1563/**
1564 *@brief wmapro decoder
1565 */
1566AVCodec wmapro_decoder = {
1567 "wmapro",
1568 AVMEDIA_TYPE_AUDIO,
1569 CODEC_ID_WMAPRO,
1570 sizeof(WMAProDecodeCtx),
1571 decode_init,
1572 NULL,
1573 decode_end,
1574 decode_packet,
1575 .capabilities = CODEC_CAP_SUBFRAMES,
1576 .flush= flush,
1577 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1578};
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-01 13:34:52 +0000