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