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