Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaprodec.c @ 9244370a

History | View | Annotate | Download (59.6 KB)

1
/*
2
 * Wmapro compatible decoder
3
 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4
 * Copyright (c) 2008 - 2009 Sascha Sommer, Benjamin Larsson
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file  libavcodec/wmaprodec.c
25
 * @brief wmapro decoder implementation
26
 * Wmapro is an MDCT based codec comparable to wma standard or AAC.
27
 * The decoding therefore consists of the following steps:
28
 * - bitstream decoding
29
 * - reconstruction of per-channel data
30
 * - rescaling and inverse quantization
31
 * - IMDCT
32
 * - windowing and overlapp-add
33
 *
34
 * The compressed wmapro bitstream is split into individual packets.
35
 * Every such packet contains one or more wma frames.
36
 * The compressed frames may have a variable length and frames may
37
 * cross packet boundaries.
38
 * Common to all wmapro frames is the number of samples that are stored in
39
 * a frame.
40
 * The number of samples and a few other decode flags are stored
41
 * as extradata that has to be passed to the decoder.
42
 *
43
 * The wmapro frames themselves are again split into a variable number of
44
 * subframes. Every subframe contains the data for 2^N time domain samples
45
 * where N varies between 7 and 12.
46
 *
47
 * Example wmapro bitstream (in samples):
48
 *
49
 * ||   packet 0           || packet 1 || packet 2      packets
50
 * ---------------------------------------------------
51
 * || frame 0      || frame 1       || frame 2    ||    frames
52
 * ---------------------------------------------------
53
 * ||   |      |   ||   |   |   |   ||            ||    subframes of channel 0
54
 * ---------------------------------------------------
55
 * ||      |   |   ||   |   |   |   ||            ||    subframes of channel 1
56
 * ---------------------------------------------------
57
 *
58
 * The frame layouts for the individual channels of a wma frame does not need
59
 * to be the same.
60
 *
61
 * However, if the offsets and lengths of several subframes of a frame are the
62
 * same, the subframes of the channels can be grouped.
63
 * Every group may then use special coding techniques like M/S stereo coding
64
 * to improve the compression ratio. These channel transformations do not
65
 * need to be applied to a whole subframe. Instead, they can also work on
66
 * individual scale factor bands (see below).
67
 * The coefficients that carry the audio signal in the frequency domain
68
 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements.
69
 * In addition to that, the encoder can switch to a runlevel coding scheme
70
 * by transmitting subframe_length / 128 zero coefficients.
71
 *
72
 * Before the audio signal can be converted to the time domain, the
73
 * coefficients have to be rescaled and inverse quantized.
74
 * A subframe is therefore split into several scale factor bands that get
75
 * scaled individually.
76
 * Scale factors are submitted for every frame but they might be shared
77
 * between the subframes of a channel. Scale factors are initially DPCM-coded.
78
 * Once scale factors are shared, the differences are transmitted as runlevel
79
 * codes.
80
 * Every subframe length and offset combination in the frame layout shares a
81
 * common quantization factor that can be adjusted for every channel by a
82
 * modifier.
83
 * After the inverse quantization, the coefficients get processed by an IMDCT.
84
 * The resulting values are then windowed with a sine window and the first half
85
 * of the values are added to the second half of the output from the previous
86
 * subframe in order to reconstruct the output samples.
87
 */
88

    
89
#include "avcodec.h"
90
#include "internal.h"
91
#include "get_bits.h"
92
#include "put_bits.h"
93
#include "wmaprodata.h"
94
#include "dsputil.h"
95
#include "wma.h"
96

    
97
/** current decoder limitations */
98
#define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
99
#define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
100
#define MAX_BANDS      29                                    ///< max number of scale factor bands
101
#define MAX_FRAMESIZE  16384                                 ///< maximum compressed frame size
102

    
103
#define WMAPRO_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
104
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
105
#define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1) ///< possible block sizes
106

    
107

    
108
#define VLCBITS            9
109
#define SCALEVLCBITS       8
110
#define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
111
#define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
112
#define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
113
#define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
114
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
115

    
116
static VLC              sf_vlc;           ///< scale factor DPCM vlc
117
static VLC              sf_rl_vlc;        ///< scale factor run length vlc
118
static VLC              vec4_vlc;         ///< 4 coefficients per symbol
119
static VLC              vec2_vlc;         ///< 2 coefficients per symbol
120
static VLC              vec1_vlc;         ///< 1 coefficient per symbol
121
static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
122
static float            sin64[33];        ///< sinus table for decorrelation
123

    
124
/**
125
 * @brief frame specific decoder context for a single channel
126
 */
127
typedef struct {
128
    int16_t  prev_block_len;                          ///< length of the previous block
129
    uint8_t  transmit_coefs;
130
    uint8_t  num_subframes;
131
    uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
132
    uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
133
    uint8_t  cur_subframe;                            ///< current subframe number
134
    uint16_t decoded_samples;                         ///< number of already processed samples
135
    uint8_t  grouped;                                 ///< channel is part of a group
136
    int      quant_step;                              ///< quantization step for the current subframe
137
    int8_t   reuse_sf;                                ///< share scale factors between subframes
138
    int8_t   scale_factor_step;                       ///< scaling step for the current subframe
139
    int      max_scale_factor;                        ///< maximum scale factor for the current subframe
140
    int      scale_factors[MAX_BANDS];                ///< scale factor values for the current subframe
141
    int      saved_scale_factors[MAX_BANDS];          ///< scale factors from a previous subframe
142
    uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
143
    float*   coeffs;                                  ///< pointer to the subframe decode buffer
144
    DECLARE_ALIGNED_16(float, out[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]); ///< output buffer
145
} WMAProChannelCtx;
146

    
147
/**
148
 * @brief channel group for channel transformations
149
 */
150
typedef struct {
151
    uint8_t num_channels;                                     ///< number of channels in the group
152
    int8_t  transform;                                        ///< transform on / off
153
    int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
154
    float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
155
    float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
156
} WMAProChannelGrp;
157

    
158
/**
159
 * @brief main decoder context
160
 */
161
typedef struct WMAProDecodeCtx {
162
    /* generic decoder variables */
163
    AVCodecContext*  avctx;                         ///< codec context for av_log
164
    DSPContext       dsp;                           ///< accelerated DSP functions
165
    uint8_t          frame_data[MAX_FRAMESIZE +
166
                      FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
167
    PutBitContext    pb;                            ///< context for filling the frame_data buffer
168
    MDCTContext      mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
169
    DECLARE_ALIGNED_16(float, tmp[WMAPRO_BLOCK_MAX_SIZE]); ///< IMDCT output buffer
170
    float*           windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
171

    
172
    /* frame size dependent frame information (set during initialization) */
173
    uint32_t         decode_flags;                  ///< used compression features
174
    uint8_t          len_prefix;                    ///< frame is prefixed with its length
175
    uint8_t          dynamic_range_compression;     ///< frame contains DRC data
176
    uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
177
    uint16_t         samples_per_frame;             ///< number of samples to output
178
    uint16_t         log2_frame_size;
179
    int8_t           num_channels;                  ///< number of channels in the stream (same as AVCodecContext.num_channels)
180
    int8_t           lfe_channel;                   ///< lfe channel index
181
    uint8_t          max_num_subframes;
182
    uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
183
    uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
184
    uint16_t         min_samples_per_subframe;
185
    int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
186
    int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
187
    int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
188
    int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
189

    
190
    /* packet decode state */
191
    GetBitContext    pgb;                           ///< bitstream reader context for the packet
192
    uint8_t          packet_sequence_number;        ///< current packet number
193
    int              num_saved_bits;                ///< saved number of bits
194
    int              frame_offset;                  ///< frame offset in the bit reservoir
195
    int              subframe_offset;               ///< subframe offset in the bit reservoir
196
    uint8_t          packet_loss;                   ///< set in case of bitstream error
197
    uint8_t          output_buffer_full;            ///< flag indicating that the output buffer is full
198

    
199
    /* frame decode state */
200
    uint32_t         frame_num;                     ///< current frame number (not used for decoding)
201
    GetBitContext    gb;                            ///< bitstream reader context
202
    int              buf_bit_size;                  ///< buffer size in bits
203
    float*           samples_start;                 ///< start samplebuffer pointer
204
    float*           samples;                       ///< current samplebuffer pointer
205
    float*           samples_end;                   ///< maximum samplebuffer pointer
206
    uint8_t          drc_gain;                      ///< gain for the DRC tool
207
    int8_t           skip_frame;                    ///< skip output step
208
    int8_t           parsed_all_subframes;          ///< all subframes decoded?
209

    
210
    /* subframe/block decode state */
211
    int16_t          subframe_len;                  ///< current subframe length
212
    int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
213
    int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
214
    int8_t           num_bands;                     ///< number of scale factor bands
215
    int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
216
    uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
217
    int8_t           esc_len;                       ///< length of escaped coefficients
218

    
219
    uint8_t          num_chgroups;                  ///< number of channel groups
220
    WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  ///< channel group information
221

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

    
225

    
226
/**
227
 *@brief helper function to print the most important members of the context
228
 *@param s context
229
 */
230
static void av_cold dump_context(WMAProDecodeCtx *s)
231
{
232
#define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
233
#define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
234

    
235
    PRINT("ed sample bit depth", s->bits_per_sample);
236
    PRINT_HEX("ed decode flags", s->decode_flags);
237
    PRINT("samples per frame",   s->samples_per_frame);
238
    PRINT("log2 frame size",     s->log2_frame_size);
239
    PRINT("max num subframes",   s->max_num_subframes);
240
    PRINT("len prefix",          s->len_prefix);
241
    PRINT("num channels",        s->num_channels);
242
}
243

    
244
/**
245
 *@brief Uninitialize the decoder and free all resources.
246
 *@param avctx codec context
247
 *@return 0 on success, < 0 otherwise
248
 */
249
static av_cold int decode_end(AVCodecContext *avctx)
250
{
251
    WMAProDecodeCtx *s = avctx->priv_data;
252
    int i;
253

    
254
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
255
        ff_mdct_end(&s->mdct_ctx[i]);
256

    
257
    return 0;
258
}
259

    
260
/**
261
 *@brief Initialize the decoder.
262
 *@param avctx codec context
263
 *@return 0 on success, -1 otherwise
264
 */
265
static av_cold int decode_init(AVCodecContext *avctx)
266
{
267
    WMAProDecodeCtx *s = avctx->priv_data;
268
    uint8_t *edata_ptr = avctx->extradata;
269
    unsigned int channel_mask;
270
    int i;
271
    int log2_max_num_subframes;
272
    int num_possible_block_sizes;
273

    
274
    s->avctx = avctx;
275
    dsputil_init(&s->dsp, avctx);
276
    init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
277

    
278
    avctx->sample_fmt = SAMPLE_FMT_FLT;
279

    
280
    if (avctx->extradata_size >= 18) {
281
        s->decode_flags    = AV_RL16(edata_ptr+14);
282
        channel_mask       = AV_RL32(edata_ptr+2);
283
        s->bits_per_sample = AV_RL16(edata_ptr);
284
        /** dump the extradata */
285
        for (i = 0; i < avctx->extradata_size; i++)
286
            dprintf(avctx, "[%x] ", avctx->extradata[i]);
287
        dprintf(avctx, "\n");
288

    
289
    } else {
290
        av_log_ask_for_sample(avctx, "Unknown extradata size\n");
291
        return AVERROR_INVALIDDATA;
292
    }
293

    
294
    /** generic init */
295
    s->log2_frame_size = av_log2(avctx->block_align) + 4;
296

    
297
    /** frame info */
298
    s->skip_frame  = 1; /** skip first frame */
299
    s->packet_loss = 1;
300
    s->len_prefix  = (s->decode_flags & 0x40);
301

    
302
    if (!s->len_prefix) {
303
        av_log_ask_for_sample(avctx, "no length prefix\n");
304
        return AVERROR_INVALIDDATA;
305
    }
306

    
307
    /** get frame len */
308
    s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
309
                                                          3, s->decode_flags);
310

    
311
    /** init previous block len */
312
    for (i = 0; i < avctx->channels; i++)
313
        s->channel[i].prev_block_len = s->samples_per_frame;
314

    
315
    /** subframe info */
316
    log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
317
    s->max_num_subframes         = 1 << log2_max_num_subframes;
318
    if (s->max_num_subframes == 16)
319
        s->max_subframe_len_bit = 1;
320
    s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
321

    
322
    num_possible_block_sizes     = log2_max_num_subframes + 1;
323
    s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
324
    s->dynamic_range_compression = (s->decode_flags & 0x80);
325

    
326
    if (s->max_num_subframes > MAX_SUBFRAMES) {
327
        av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
328
               s->max_num_subframes);
329
        return AVERROR_INVALIDDATA;
330
    }
331

    
332
    s->num_channels = avctx->channels;
333

    
334
    /** extract lfe channel position */
335
    s->lfe_channel = -1;
336

    
337
    if (channel_mask & 8) {
338
        unsigned int mask;
339
        for (mask = 1; mask < 16; mask <<= 1) {
340
            if (channel_mask & mask)
341
                ++s->lfe_channel;
342
        }
343
    }
344

    
345
    if (s->num_channels < 0 || s->num_channels > WMAPRO_MAX_CHANNELS) {
346
        av_log_ask_for_sample(avctx, "invalid number of channels\n");
347
        return AVERROR_NOTSUPP;
348
    }
349

    
350
    INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
351
                    scale_huffbits, 1, 1,
352
                    scale_huffcodes, 2, 2, 616);
353

    
354
    INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
355
                    scale_rl_huffbits, 1, 1,
356
                    scale_rl_huffcodes, 4, 4, 1406);
357

    
358
    INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
359
                    coef0_huffbits, 1, 1,
360
                    coef0_huffcodes, 4, 4, 2108);
361

    
362
    INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
363
                    coef1_huffbits, 1, 1,
364
                    coef1_huffcodes, 4, 4, 3912);
365

    
366
    INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
367
                    vec4_huffbits, 1, 1,
368
                    vec4_huffcodes, 2, 2, 604);
369

    
370
    INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
371
                    vec2_huffbits, 1, 1,
372
                    vec2_huffcodes, 2, 2, 562);
373

    
374
    INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
375
                    vec1_huffbits, 1, 1,
376
                    vec1_huffcodes, 2, 2, 562);
377

    
378
    /** calculate number of scale factor bands and their offsets
379
        for every possible block size */
380
    for (i = 0; i < num_possible_block_sizes; i++) {
381
        int subframe_len = s->samples_per_frame >> i;
382
        int x;
383
        int band = 1;
384

    
385
        s->sfb_offsets[i][0] = 0;
386

    
387
        for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
388
            int offset = (subframe_len * 2 * critical_freq[x])
389
                          / s->avctx->sample_rate + 2;
390
            offset &= ~3;
391
            if (offset > s->sfb_offsets[i][band - 1])
392
                s->sfb_offsets[i][band++] = offset;
393
        }
394
        s->sfb_offsets[i][band - 1] = subframe_len;
395
        s->num_sfb[i]               = band - 1;
396
    }
397

    
398

    
399
    /** Scale factors can be shared between blocks of different size
400
        as every block has a different scale factor band layout.
401
        The matrix sf_offsets is needed to find the correct scale factor.
402
     */
403

    
404
    for (i = 0; i < num_possible_block_sizes; i++) {
405
        int b;
406
        for (b = 0; b < s->num_sfb[i]; b++) {
407
            int x;
408
            int offset = ((s->sfb_offsets[i][b]
409
                           + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
410
            for (x = 0; x < num_possible_block_sizes; x++) {
411
                int v = 0;
412
                while (s->sfb_offsets[x][v + 1] << x < offset)
413
                    ++v;
414
                s->sf_offsets[i][x][b] = v;
415
            }
416
        }
417
    }
418

    
419
    /** init MDCT, FIXME: only init needed sizes */
420
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
421
        ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1,
422
                     1.0 / (1 << (BLOCK_MIN_BITS + i - 1))
423
                     / (1 << (s->bits_per_sample - 1)));
424

    
425
    /** init MDCT windows: simple sinus window */
426
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
427
        const int n       = 1 << (WMAPRO_BLOCK_MAX_BITS - i);
428
        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i - 7;
429
        ff_sine_window_init(ff_sine_windows[win_idx], n);
430
        s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
431
    }
432

    
433
    /** calculate subwoofer cutoff values */
434
    for (i = 0; i < num_possible_block_sizes; i++) {
435
        int block_size = s->samples_per_frame >> i;
436
        int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
437
                     / s->avctx->sample_rate;
438
        s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
439
    }
440

    
441
    /** calculate sine values for the decorrelation matrix */
442
    for (i = 0; i < 33; i++)
443
        sin64[i] = sin(i*M_PI / 64.0);
444

    
445
    if (avctx->debug & FF_DEBUG_BITSTREAM)
446
        dump_context(s);
447

    
448
    avctx->channel_layout = channel_mask;
449
    return 0;
450
}
451

    
452
/**
453
 *@brief Decode the subframe length.
454
 *@param s context
455
 *@param offset sample offset in the frame
456
 *@return decoded subframe length on success, < 0 in case of an error
457
 */
458
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
459
{
460
    int frame_len_shift = 0;
461
    int subframe_len;
462

    
463
    /** no need to read from the bitstream when only one length is possible */
464
    if (offset == s->samples_per_frame - s->min_samples_per_subframe)
465
        return s->min_samples_per_subframe;
466

    
467
    /** 1 bit indicates if the subframe is of maximum length */
468
    if (s->max_subframe_len_bit) {
469
        if (get_bits1(&s->gb))
470
            frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
471
    } else
472
        frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
473

    
474
    subframe_len = s->samples_per_frame >> frame_len_shift;
475

    
476
    /** sanity check the length */
477
    if (subframe_len < s->min_samples_per_subframe ||
478
        subframe_len > s->samples_per_frame) {
479
        av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
480
               subframe_len);
481
        return AVERROR_INVALIDDATA;
482
    }
483
    return subframe_len;
484
}
485

    
486
/**
487
 *@brief Decode how the data in the frame is split into subframes.
488
 *       Every WMA frame contains the encoded data for a fixed number of
489
 *       samples per channel. The data for every channel might be split
490
 *       into several subframes. This function will reconstruct the list of
491
 *       subframes for every channel.
492
 *
493
 *       If the subframes are not evenly split, the algorithm estimates the
494
 *       channels with the lowest number of total samples.
495
 *       Afterwards, for each of these channels a bit is read from the
496
 *       bitstream that indicates if the channel contains a subframe with the
497
 *       next subframe size that is going to be read from the bitstream or not.
498
 *       If a channel contains such a subframe, the subframe size gets added to
499
 *       the channel's subframe list.
500
 *       The algorithm repeats these steps until the frame is properly divided
501
 *       between the individual channels.
502
 *
503
 *@param s context
504
 *@return 0 on success, < 0 in case of an error
505
 */
506
static int decode_tilehdr(WMAProDecodeCtx *s)
507
{
508
    uint16_t num_samples[WMAPRO_MAX_CHANNELS];        /** sum of samples for all currently known subframes of a channel */
509
    uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /** flag indicating if a channel contains the current subframe */
510
    int channels_for_cur_subframe = s->num_channels;  /** number of channels that contain the current subframe */
511
    int fixed_channel_layout = 0;                     /** flag indicating that all channels use the same subframe offsets and sizes */
512
    int min_channel_len = 0;                          /** smallest sum of samples (channels with this length will be processed first) */
513
    int c;
514

    
515
    /* Should never consume more than 3073 bits (256 iterations for the
516
     * while loop when always the minimum amount of 128 samples is substracted
517
     * from missing samples in the 8 channel case).
518
     * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
519
     */
520

    
521
    /** reset tiling information */
522
    for (c = 0; c < s->num_channels; c++)
523
        s->channel[c].num_subframes = 0;
524

    
525
    memset(num_samples, 0, sizeof(num_samples));
526

    
527
    if (s->max_num_subframes == 1 || get_bits1(&s->gb))
528
        fixed_channel_layout = 1;
529

    
530
    /** loop until the frame data is split between the subframes */
531
    do {
532
        int subframe_len;
533

    
534
        /** check which channels contain the subframe */
535
        for (c = 0; c < s->num_channels; c++) {
536
            if (num_samples[c] == min_channel_len) {
537
                if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
538
                   (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
539
                    contains_subframe[c] = 1;
540
                else
541
                    contains_subframe[c] = get_bits1(&s->gb);
542
            } else
543
                contains_subframe[c] = 0;
544
        }
545

    
546
        /** get subframe length, subframe_len == 0 is not allowed */
547
        if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
548
            return AVERROR_INVALIDDATA;
549

    
550
        /** add subframes to the individual channels and find new min_channel_len */
551
        min_channel_len += subframe_len;
552
        for (c = 0; c < s->num_channels; c++) {
553
            WMAProChannelCtx* chan = &s->channel[c];
554

    
555
            if (contains_subframe[c]) {
556
                if (chan->num_subframes >= MAX_SUBFRAMES) {
557
                    av_log(s->avctx, AV_LOG_ERROR,
558
                           "broken frame: num subframes > 31\n");
559
                    return AVERROR_INVALIDDATA;
560
                }
561
                chan->subframe_len[chan->num_subframes] = subframe_len;
562
                num_samples[c] += subframe_len;
563
                ++chan->num_subframes;
564
                if (num_samples[c] > s->samples_per_frame) {
565
                    av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
566
                           "channel len > samples_per_frame\n");
567
                    return AVERROR_INVALIDDATA;
568
                }
569
            } else if (num_samples[c] <= min_channel_len) {
570
                if (num_samples[c] < min_channel_len) {
571
                    channels_for_cur_subframe = 0;
572
                    min_channel_len = num_samples[c];
573
                }
574
                ++channels_for_cur_subframe;
575
            }
576
        }
577
    } while (min_channel_len < s->samples_per_frame);
578

    
579
    for (c = 0; c < s->num_channels; c++) {
580
        int i;
581
        int offset = 0;
582
        for (i = 0; i < s->channel[c].num_subframes; i++) {
583
            dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
584
                    " len %i\n", s->frame_num, c, i,
585
                    s->channel[c].subframe_len[i]);
586
            s->channel[c].subframe_offset[i] = offset;
587
            offset += s->channel[c].subframe_len[i];
588
        }
589
    }
590

    
591
    return 0;
592
}
593

    
594
/**
595
 *@brief Calculate a decorrelation matrix from the bitstream parameters.
596
 *@param s codec context
597
 *@param chgroup channel group for which the matrix needs to be calculated
598
 */
599
static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
600
                                        WMAProChannelGrp *chgroup)
601
{
602
    int i;
603
    int offset = 0;
604
    int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
605
    memset(chgroup->decorrelation_matrix, 0, s->num_channels *
606
           s->num_channels * sizeof(*chgroup->decorrelation_matrix));
607

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

    
611
    for (i = 0; i < chgroup->num_channels; i++)
612
        chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
613
            get_bits1(&s->gb) ? 1.0 : -1.0;
614

    
615
    for (i = 1; i < chgroup->num_channels; i++) {
616
        int x;
617
        for (x = 0; x < i; x++) {
618
            int y;
619
            for (y = 0; y < i + 1; y++) {
620
                float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
621
                float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
622
                int n = rotation_offset[offset + x];
623
                float sinv;
624
                float cosv;
625

    
626
                if (n < 32) {
627
                    sinv = sin64[n];
628
                    cosv = sin64[32 - n];
629
                } else {
630
                    sinv =  sin64[64 -  n];
631
                    cosv = -sin64[n  - 32];
632
                }
633

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

    
644
/**
645
 *@brief Decode channel transformation parameters
646
 *@param s codec context
647
 *@return 0 in case of success, < 0 in case of bitstream errors
648
 */
649
static int decode_channel_transform(WMAProDecodeCtx* s)
650
{
651
    int i;
652
    /* should never consume more than 1921 bits for the 8 channel case
653
     * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
654
     * + MAX_CHANNELS + MAX_BANDS + 1)
655
     */
656

    
657
    /** in the one channel case channel transforms are pointless */
658
    s->num_chgroups = 0;
659
    if (s->num_channels > 1) {
660
        int remaining_channels = s->channels_for_cur_subframe;
661

    
662
        if (get_bits1(&s->gb)) {
663
            av_log_ask_for_sample(s->avctx,
664
                                  "unsupported channel transform bit\n");
665
            return AVERROR_INVALIDDATA;
666
        }
667

    
668
        for (s->num_chgroups = 0; remaining_channels &&
669
             s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
670
            WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
671
            float** channel_data = chgroup->channel_data;
672
            chgroup->num_channels = 0;
673
            chgroup->transform = 0;
674

    
675
            /** decode channel mask */
676
            if (remaining_channels > 2) {
677
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
678
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
679
                    if (!s->channel[channel_idx].grouped
680
                        && get_bits1(&s->gb)) {
681
                        ++chgroup->num_channels;
682
                        s->channel[channel_idx].grouped = 1;
683
                        *channel_data++ = s->channel[channel_idx].coeffs;
684
                    }
685
                }
686
            } else {
687
                chgroup->num_channels = remaining_channels;
688
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
689
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
690
                    if (!s->channel[channel_idx].grouped)
691
                        *channel_data++ = s->channel[channel_idx].coeffs;
692
                    s->channel[channel_idx].grouped = 1;
693
                }
694
            }
695

    
696
            /** decode transform type */
697
            if (chgroup->num_channels == 2) {
698
                if (get_bits1(&s->gb)) {
699
                    if (get_bits1(&s->gb)) {
700
                        av_log_ask_for_sample(s->avctx,
701
                                              "unsupported channel transform type\n");
702
                    }
703
                } else {
704
                    chgroup->transform = 1;
705
                    if (s->num_channels == 2) {
706
                        chgroup->decorrelation_matrix[0] =  1.0;
707
                        chgroup->decorrelation_matrix[1] = -1.0;
708
                        chgroup->decorrelation_matrix[2] =  1.0;
709
                        chgroup->decorrelation_matrix[3] =  1.0;
710
                    } else {
711
                        /** cos(pi/4) */
712
                        chgroup->decorrelation_matrix[0] =  0.70703125;
713
                        chgroup->decorrelation_matrix[1] = -0.70703125;
714
                        chgroup->decorrelation_matrix[2] =  0.70703125;
715
                        chgroup->decorrelation_matrix[3] =  0.70703125;
716
                    }
717
                }
718
            } else if (chgroup->num_channels > 2) {
719
                if (get_bits1(&s->gb)) {
720
                    chgroup->transform = 1;
721
                    if (get_bits1(&s->gb)) {
722
                        decode_decorrelation_matrix(s, chgroup);
723
                    } else {
724
                        /** FIXME: more than 6 coupled channels not supported */
725
                        if (chgroup->num_channels > 6) {
726
                            av_log_ask_for_sample(s->avctx,
727
                                                  "coupled channels > 6\n");
728
                        } else {
729
                            memcpy(chgroup->decorrelation_matrix,
730
                                   default_decorrelation[chgroup->num_channels],
731
                                   chgroup->num_channels * chgroup->num_channels *
732
                                   sizeof(*chgroup->decorrelation_matrix));
733
                        }
734
                    }
735
                }
736
            }
737

    
738
            /** decode transform on / off */
739
            if (chgroup->transform) {
740
                if (!get_bits1(&s->gb)) {
741
                    int i;
742
                    /** transform can be enabled for individual bands */
743
                    for (i = 0; i < s->num_bands; i++) {
744
                        chgroup->transform_band[i] = get_bits1(&s->gb);
745
                    }
746
                } else {
747
                    memset(chgroup->transform_band, 1, s->num_bands);
748
                }
749
            }
750
            remaining_channels -= chgroup->num_channels;
751
        }
752
    }
753
    return 0;
754
}
755

    
756
/**
757
 *@brief Extract the coefficients from the bitstream.
758
 *@param s codec context
759
 *@param c current channel number
760
 *@return 0 on success, < 0 in case of bitstream errors
761
 */
762
static int decode_coeffs(WMAProDecodeCtx *s, int c)
763
{
764
    int vlctable;
765
    VLC* vlc;
766
    WMAProChannelCtx* ci = &s->channel[c];
767
    int rl_mode = 0;
768
    int cur_coeff = 0;
769
    int num_zeros = 0;
770
    const uint16_t* run;
771
    const uint16_t* level;
772

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

    
775
    vlctable = get_bits1(&s->gb);
776
    vlc = &coef_vlc[vlctable];
777

    
778
    if (vlctable) {
779
        run = coef1_run;
780
        level = coef1_level;
781
    } else {
782
        run = coef0_run;
783
        level = coef0_level;
784
    }
785

    
786
    /** decode vector coefficients (consumes up to 167 bits per iteration for
787
      4 vector coded large values) */
788
    while (!rl_mode && cur_coeff + 3 < s->subframe_len) {
789
        int vals[4];
790
        int i;
791
        unsigned int idx;
792

    
793
        idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
794

    
795
        if (idx == HUFF_VEC4_SIZE - 1) {
796
            for (i = 0; i < 4; i += 2) {
797
                idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
798
                if (idx == HUFF_VEC2_SIZE - 1) {
799
                    vals[i] = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
800
                    if (vals[i] == HUFF_VEC1_SIZE - 1)
801
                        vals[i] += ff_wma_get_large_val(&s->gb);
802
                    vals[i+1] = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
803
                    if (vals[i+1] == HUFF_VEC1_SIZE - 1)
804
                        vals[i+1] += ff_wma_get_large_val(&s->gb);
805
                } else {
806
                    vals[i]   = symbol_to_vec2[idx] >> 4;
807
                    vals[i+1] = symbol_to_vec2[idx] & 0xF;
808
                }
809
            }
810
        } else {
811
            vals[0] =  symbol_to_vec4[idx] >> 12;
812
            vals[1] = (symbol_to_vec4[idx] >> 8) & 0xF;
813
            vals[2] = (symbol_to_vec4[idx] >> 4) & 0xF;
814
            vals[3] =  symbol_to_vec4[idx]       & 0xF;
815
        }
816

    
817
        /** decode sign */
818
        for (i = 0; i < 4; i++) {
819
            if (vals[i]) {
820
                int sign = get_bits1(&s->gb) - 1;
821
                ci->coeffs[cur_coeff] = (vals[i] ^ sign) - sign;
822
                num_zeros = 0;
823
            } else {
824
                ci->coeffs[cur_coeff] = 0;
825
                /** switch to run level mode when subframe_len / 128 zeros
826
                    were found in a row */
827
                rl_mode |= (++num_zeros > s->subframe_len >> 8);
828
            }
829
            ++cur_coeff;
830
        }
831
    }
832

    
833
    /** decode run level coded coefficients */
834
    if (rl_mode) {
835
        memset(&ci->coeffs[cur_coeff], 0,
836
               sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
837
        if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
838
                                    level, run, 1, ci->coeffs,
839
                                    cur_coeff, s->subframe_len,
840
                                    s->subframe_len, s->esc_len, 0))
841
            return AVERROR_INVALIDDATA;
842
    }
843

    
844
    return 0;
845
}
846

    
847
/**
848
 *@brief Extract scale factors from the bitstream.
849
 *@param s codec context
850
 *@return 0 on success, < 0 in case of bitstream errors
851
 */
852
static int decode_scale_factors(WMAProDecodeCtx* s)
853
{
854
    int i;
855

    
856
    /** should never consume more than 5344 bits
857
     *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
858
     */
859

    
860
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
861
        int c = s->channel_indexes_for_cur_subframe[i];
862
        int* sf;
863
        int* sf_end = s->channel[c].scale_factors + s->num_bands;
864

    
865
        /** resample scale factors for the new block size
866
         *  as the scale factors might need to be resampled several times
867
         *  before some  new values are transmitted, a backup of the last
868
         *  transmitted scale factors is kept in saved_scale_factors
869
         */
870
        if (s->channel[c].reuse_sf) {
871
            const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
872
            int b;
873
            for (b = 0; b < s->num_bands; b++)
874
                s->channel[c].scale_factors[b] =
875
                                   s->channel[c].saved_scale_factors[*sf_offsets++];
876
        }
877

    
878
        if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
879

    
880
            if (!s->channel[c].reuse_sf) {
881
                int val;
882
                /** decode DPCM coded scale factors */
883
                s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
884
                val = 45 / s->channel[c].scale_factor_step;
885
                for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
886
                    val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
887
                    *sf = val;
888
                }
889
            } else {
890
                int i;
891
                /** run level decode differences to the resampled factors */
892
                for (i = 0; i < s->num_bands; i++) {
893
                    int idx;
894
                    int skip;
895
                    int val;
896
                    int sign;
897

    
898
                    idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
899

    
900
                    if (!idx) {
901
                        uint32_t code = get_bits(&s->gb, 14);
902
                        val  =  code >> 6;
903
                        sign = (code & 1) - 1;
904
                        skip = (code & 0x3f) >> 1;
905
                    } else if (idx == 1) {
906
                        break;
907
                    } else {
908
                        skip = scale_rl_run[idx];
909
                        val  = scale_rl_level[idx];
910
                        sign = get_bits1(&s->gb)-1;
911
                    }
912

    
913
                    i += skip;
914
                    if (i >= s->num_bands) {
915
                        av_log(s->avctx, AV_LOG_ERROR,
916
                               "invalid scale factor coding\n");
917
                        return AVERROR_INVALIDDATA;
918
                    }
919
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
920
                }
921
            }
922

    
923
            /** save transmitted scale factors so that they can be reused for
924
                the next subframe */
925
            memcpy(s->channel[c].saved_scale_factors,
926
                   s->channel[c].scale_factors, s->num_bands *
927
                   sizeof(*s->channel[c].saved_scale_factors));
928
            s->channel[c].table_idx = s->table_idx;
929
            s->channel[c].reuse_sf  = 1;
930
        }
931

    
932
        /** calculate new scale factor maximum */
933
        s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
934
        for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
935
            s->channel[c].max_scale_factor =
936
                FFMAX(s->channel[c].max_scale_factor, *sf);
937
        }
938

    
939
    }
940
    return 0;
941
}
942

    
943
/**
944
 *@brief Reconstruct the individual channel data.
945
 *@param s codec context
946
 */
947
static void inverse_channel_transform(WMAProDecodeCtx *s)
948
{
949
    int i;
950

    
951
    for (i = 0; i < s->num_chgroups; i++) {
952
        if (s->chgroup[i].transform) {
953
            float data[WMAPRO_MAX_CHANNELS];
954
            const int num_channels = s->chgroup[i].num_channels;
955
            float** ch_data = s->chgroup[i].channel_data;
956
            float** ch_end = ch_data + num_channels;
957
            const int8_t* tb = s->chgroup[i].transform_band;
958
            int16_t* sfb;
959

    
960
            /** multichannel decorrelation */
961
            for (sfb = s->cur_sfb_offsets;
962
                 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
963
                int y;
964
                if (*tb++ == 1) {
965
                    /** multiply values with the decorrelation_matrix */
966
                    for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
967
                        const float* mat = s->chgroup[i].decorrelation_matrix;
968
                        const float* data_end = data + num_channels;
969
                        float* data_ptr = data;
970
                        float** ch;
971

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

    
975
                        for (ch = ch_data; ch < ch_end; ch++) {
976
                            float sum = 0;
977
                            data_ptr = data;
978
                            while (data_ptr < data_end)
979
                                sum += *data_ptr++ * *mat++;
980

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

    
995
/**
996
 *@brief Apply sine window and reconstruct the output buffer.
997
 *@param s codec context
998
 */
999
static void wmapro_window(WMAProDecodeCtx *s)
1000
{
1001
    int i;
1002
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1003
        int c = s->channel_indexes_for_cur_subframe[i];
1004
        float* window;
1005
        int winlen = s->channel[c].prev_block_len;
1006
        float* start = s->channel[c].coeffs - (winlen >> 1);
1007

    
1008
        if (s->subframe_len < winlen) {
1009
            start += (winlen - s->subframe_len) >> 1;
1010
            winlen = s->subframe_len;
1011
        }
1012

    
1013
        window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1014

    
1015
        winlen >>= 1;
1016

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

    
1020
        s->channel[c].prev_block_len = s->subframe_len;
1021
    }
1022
}
1023

    
1024
/**
1025
 *@brief Decode a single subframe (block).
1026
 *@param s codec context
1027
 *@return 0 on success, < 0 when decoding failed
1028
 */
1029
static int decode_subframe(WMAProDecodeCtx *s)
1030
{
1031
    int offset = s->samples_per_frame;
1032
    int subframe_len = s->samples_per_frame;
1033
    int i;
1034
    int total_samples   = s->samples_per_frame * s->num_channels;
1035
    int transmit_coeffs = 0;
1036
    int cur_subwoofer_cutoff;
1037

    
1038
    s->subframe_offset = get_bits_count(&s->gb);
1039

    
1040
    /** reset channel context and find the next block offset and size
1041
        == the next block of the channel with the smallest number of
1042
        decoded samples
1043
    */
1044
    for (i = 0; i < s->num_channels; i++) {
1045
        s->channel[i].grouped = 0;
1046
        if (offset > s->channel[i].decoded_samples) {
1047
            offset = s->channel[i].decoded_samples;
1048
            subframe_len =
1049
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
1050
        }
1051
    }
1052

    
1053
    dprintf(s->avctx,
1054
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1055

    
1056
    /** get a list of all channels that contain the estimated block */
1057
    s->channels_for_cur_subframe = 0;
1058
    for (i = 0; i < s->num_channels; i++) {
1059
        const int cur_subframe = s->channel[i].cur_subframe;
1060
        /** substract already processed samples */
1061
        total_samples -= s->channel[i].decoded_samples;
1062

    
1063
        /** and count if there are multiple subframes that match our profile */
1064
        if (offset == s->channel[i].decoded_samples &&
1065
            subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1066
            total_samples -= s->channel[i].subframe_len[cur_subframe];
1067
            s->channel[i].decoded_samples +=
1068
                s->channel[i].subframe_len[cur_subframe];
1069
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1070
            ++s->channels_for_cur_subframe;
1071
        }
1072
    }
1073

    
1074
    /** check if the frame will be complete after processing the
1075
        estimated block */
1076
    if (!total_samples)
1077
        s->parsed_all_subframes = 1;
1078

    
1079

    
1080
    dprintf(s->avctx, "subframe is part of %i channels\n",
1081
            s->channels_for_cur_subframe);
1082

    
1083
    /** calculate number of scale factor bands and their offsets */
1084
    s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1085
    s->num_bands         = s->num_sfb[s->table_idx];
1086
    s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1087
    cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1088

    
1089
    /** configure the decoder for the current subframe */
1090
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1091
        int c = s->channel_indexes_for_cur_subframe[i];
1092

    
1093
        s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1094
                                                  + offset];
1095
    }
1096

    
1097
    s->subframe_len = subframe_len;
1098
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1099

    
1100
    /** skip extended header if any */
1101
    if (get_bits1(&s->gb)) {
1102
        int num_fill_bits;
1103
        if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1104
            int len = get_bits(&s->gb, 4);
1105
            num_fill_bits = get_bits(&s->gb, len) + 1;
1106
        }
1107

    
1108
        if (num_fill_bits >= 0) {
1109
            if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1110
                av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1111
                return AVERROR_INVALIDDATA;
1112
            }
1113

    
1114
            skip_bits_long(&s->gb, num_fill_bits);
1115
        }
1116
    }
1117

    
1118
    /** no idea for what the following bit is used */
1119
    if (get_bits1(&s->gb)) {
1120
        av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1121
        return AVERROR_INVALIDDATA;
1122
    }
1123

    
1124

    
1125
    if (decode_channel_transform(s) < 0)
1126
        return AVERROR_INVALIDDATA;
1127

    
1128

    
1129
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1130
        int c = s->channel_indexes_for_cur_subframe[i];
1131
        if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1132
            transmit_coeffs = 1;
1133
    }
1134

    
1135
    if (transmit_coeffs) {
1136
        int step;
1137
        int quant_step = 90 * s->bits_per_sample >> 4;
1138
        if ((get_bits1(&s->gb))) {
1139
            /** FIXME: might change run level mode decision */
1140
            av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1141
            return AVERROR_INVALIDDATA;
1142
        }
1143
        /** decode quantization step */
1144
        step = get_sbits(&s->gb, 6);
1145
        quant_step += step;
1146
        if (step == -32 || step == 31) {
1147
            const int sign = (step == 31) - 1;
1148
            int quant = 0;
1149
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1150
                   (step = get_bits(&s->gb, 5)) == 31) {
1151
                quant += 31;
1152
            }
1153
            quant_step += ((quant + step) ^ sign) - sign;
1154
        }
1155
        if (quant_step < 0) {
1156
            av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1157
        }
1158

    
1159
        /** decode quantization step modifiers for every channel */
1160

    
1161
        if (s->channels_for_cur_subframe == 1) {
1162
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1163
        } else {
1164
            int modifier_len = get_bits(&s->gb, 3);
1165
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1166
                int c = s->channel_indexes_for_cur_subframe[i];
1167
                s->channel[c].quant_step = quant_step;
1168
                if (get_bits1(&s->gb)) {
1169
                    if (modifier_len) {
1170
                        s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1171
                    } else
1172
                        ++s->channel[c].quant_step;
1173
                }
1174
            }
1175
        }
1176

    
1177
        /** decode scale factors */
1178
        if (decode_scale_factors(s) < 0)
1179
            return AVERROR_INVALIDDATA;
1180
    }
1181

    
1182
    dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1183
            get_bits_count(&s->gb) - s->subframe_offset);
1184

    
1185
    /** parse coefficients */
1186
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1187
        int c = s->channel_indexes_for_cur_subframe[i];
1188
        if (s->channel[c].transmit_coefs &&
1189
            get_bits_count(&s->gb) < s->num_saved_bits) {
1190
            decode_coeffs(s, c);
1191
        } else
1192
            memset(s->channel[c].coeffs, 0,
1193
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1194
    }
1195

    
1196
    dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1197
            get_bits_count(&s->gb) - s->subframe_offset);
1198

    
1199
    if (transmit_coeffs) {
1200
        /** reconstruct the per channel data */
1201
        inverse_channel_transform(s);
1202
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
1203
            int c = s->channel_indexes_for_cur_subframe[i];
1204
            const int* sf = s->channel[c].scale_factors;
1205
            int b;
1206

    
1207
            if (c == s->lfe_channel)
1208
                memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1209
                       (subframe_len - cur_subwoofer_cutoff));
1210

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

    
1220
                for (start = s->cur_sfb_offsets[b]; start < end; start++)
1221
                    s->tmp[start] = s->channel[c].coeffs[start] * quant;
1222
            }
1223

    
1224
            /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1225
            ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS],
1226
                          s->channel[c].coeffs, s->tmp);
1227
        }
1228
    }
1229

    
1230
    /** window and overlapp-add */
1231
    wmapro_window(s);
1232

    
1233
    /** handled one subframe */
1234
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1235
        int c = s->channel_indexes_for_cur_subframe[i];
1236
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1237
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1238
            return AVERROR_INVALIDDATA;
1239
        }
1240
        ++s->channel[c].cur_subframe;
1241
    }
1242

    
1243
    return 0;
1244
}
1245

    
1246
/**
1247
 *@brief Decode one WMA frame.
1248
 *@param s codec context
1249
 *@return 0 if the trailer bit indicates that this is the last frame,
1250
 *        1 if there are additional frames
1251
 */
1252
static int decode_frame(WMAProDecodeCtx *s)
1253
{
1254
    GetBitContext* gb = &s->gb;
1255
    int more_frames = 0;
1256
    int len = 0;
1257
    int i;
1258

    
1259
    /** check for potential output buffer overflow */
1260
    if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1261
        /** return an error if no frame could be decoded at all */
1262
        if (s->samples_start == s->samples) {
1263
            av_log(s->avctx, AV_LOG_ERROR,
1264
                   "not enough space for the output samples\n");
1265
            s->packet_loss = 1;
1266
        } else
1267
            s->output_buffer_full = 1;
1268
        return 0;
1269
    }
1270

    
1271
    /** get frame length */
1272
    if (s->len_prefix)
1273
        len = get_bits(gb, s->log2_frame_size);
1274

    
1275
    dprintf(s->avctx, "decoding frame with length %x\n", len);
1276

    
1277
    /** decode tile information */
1278
    if (decode_tilehdr(s)) {
1279
        s->packet_loss = 1;
1280
        return 0;
1281
    }
1282

    
1283
    /** read postproc transform */
1284
    if (s->num_channels > 1 && get_bits1(gb)) {
1285
        av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1286
        s->packet_loss = 1;
1287
        return 0;
1288
    }
1289

    
1290
    /** read drc info */
1291
    if (s->dynamic_range_compression) {
1292
        s->drc_gain = get_bits(gb, 8);
1293
        dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1294
    }
1295

    
1296
    /** no idea what these are for, might be the number of samples
1297
        that need to be skipped at the beginning or end of a stream */
1298
    if (get_bits1(gb)) {
1299
        int skip;
1300

    
1301
        /** usually true for the first frame */
1302
        if (get_bits1(gb)) {
1303
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1304
            dprintf(s->avctx, "start skip: %i\n", skip);
1305
        }
1306

    
1307
        /** sometimes true for the last frame */
1308
        if (get_bits1(gb)) {
1309
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1310
            dprintf(s->avctx, "end skip: %i\n", skip);
1311
        }
1312

    
1313
    }
1314

    
1315
    dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1316
            get_bits_count(gb) - s->frame_offset);
1317

    
1318
    /** reset subframe states */
1319
    s->parsed_all_subframes = 0;
1320
    for (i = 0; i < s->num_channels; i++) {
1321
        s->channel[i].decoded_samples = 0;
1322
        s->channel[i].cur_subframe    = 0;
1323
        s->channel[i].reuse_sf        = 0;
1324
    }
1325

    
1326
    /** decode all subframes */
1327
    while (!s->parsed_all_subframes) {
1328
        if (decode_subframe(s) < 0) {
1329
            s->packet_loss = 1;
1330
            return 0;
1331
        }
1332
    }
1333

    
1334
    /** interleave samples and write them to the output buffer */
1335
    for (i = 0; i < s->num_channels; i++) {
1336
        float* ptr;
1337
        int incr = s->num_channels;
1338
        float* iptr = s->channel[i].out;
1339
        int x;
1340

    
1341
        ptr = s->samples + i;
1342

    
1343
        for (x = 0; x < s->samples_per_frame; x++) {
1344
            *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1345
            ptr += incr;
1346
        }
1347

    
1348
        /** reuse second half of the IMDCT output for the next frame */
1349
        memcpy(&s->channel[i].out[0],
1350
               &s->channel[i].out[s->samples_per_frame],
1351
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1352
    }
1353

    
1354
    if (s->skip_frame) {
1355
        s->skip_frame = 0;
1356
    } else
1357
        s->samples += s->num_channels * s->samples_per_frame;
1358

    
1359
    if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1360
        /** FIXME: not sure if this is always an error */
1361
        av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n",
1362
               s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1363
        s->packet_loss = 1;
1364
        return 0;
1365
    }
1366

    
1367
    /** skip the rest of the frame data */
1368
    skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1369

    
1370
    /** decode trailer bit */
1371
    more_frames = get_bits1(gb);
1372

    
1373
    ++s->frame_num;
1374
    return more_frames;
1375
}
1376

    
1377
/**
1378
 *@brief Calculate remaining input buffer length.
1379
 *@param s codec context
1380
 *@param gb bitstream reader context
1381
 *@return remaining size in bits
1382
 */
1383
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1384
{
1385
    return s->buf_bit_size - get_bits_count(gb);
1386
}
1387

    
1388
/**
1389
 *@brief Fill the bit reservoir with a (partial) frame.
1390
 *@param s codec context
1391
 *@param gb bitstream reader context
1392
 *@param len length of the partial frame
1393
 *@param append decides wether to reset the buffer or not
1394
 */
1395
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1396
                      int append)
1397
{
1398
    int buflen;
1399

    
1400
    /** when the frame data does not need to be concatenated, the input buffer
1401
        is resetted and additional bits from the previous frame are copyed
1402
        and skipped later so that a fast byte copy is possible */
1403

    
1404
    if (!append) {
1405
        s->frame_offset = get_bits_count(gb) & 7;
1406
        s->num_saved_bits = s->frame_offset;
1407
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1408
    }
1409

    
1410
    buflen = (s->num_saved_bits + len + 8) >> 3;
1411

    
1412
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1413
        av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1414
        s->packet_loss = 1;
1415
        return;
1416
    }
1417

    
1418
    s->num_saved_bits += len;
1419
    if (!append) {
1420
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1421
                     s->num_saved_bits);
1422
    } else {
1423
        int align = 8 - (get_bits_count(gb) & 7);
1424
        align = FFMIN(align, len);
1425
        put_bits(&s->pb, align, get_bits(gb, align));
1426
        len -= align;
1427
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1428
    }
1429
    skip_bits_long(gb, len);
1430

    
1431
    {
1432
        PutBitContext tmp = s->pb;
1433
        flush_put_bits(&tmp);
1434
    }
1435

    
1436
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1437
    skip_bits(&s->gb, s->frame_offset);
1438
}
1439

    
1440
/**
1441
 *@brief Decode a single WMA packet.
1442
 *@param avctx codec context
1443
 *@param data the output buffer
1444
 *@param data_size number of bytes that were written to the output buffer
1445
 *@param avpkt input packet
1446
 *@return number of bytes that were read from the input buffer
1447
 */
1448
static int decode_packet(AVCodecContext *avctx,
1449
                         void *data, int *data_size, AVPacket* avpkt)
1450
{
1451
    WMAProDecodeCtx *s = avctx->priv_data;
1452
    GetBitContext* gb  = &s->pgb;
1453
    const uint8_t* buf = avpkt->data;
1454
    int buf_size       = avpkt->size;
1455
    int more_frames    = 1;
1456
    int num_bits_prev_frame;
1457
    int packet_sequence_number;
1458

    
1459
    s->samples       = data;
1460
    s->samples_start = data;
1461
    s->samples_end   = (float*)((int8_t*)data + *data_size);
1462
    *data_size = 0;
1463

    
1464
    if (!s->output_buffer_full) {
1465
        s->buf_bit_size = buf_size << 3;
1466

    
1467
        /** sanity check for the buffer length */
1468
        if (buf_size < avctx->block_align)
1469
            return 0;
1470

    
1471
        buf_size = avctx->block_align;
1472

    
1473
        /** parse packet header */
1474
        init_get_bits(gb, buf, s->buf_bit_size);
1475
        packet_sequence_number = get_bits(gb, 4);
1476
        skip_bits(gb, 2);
1477

    
1478
        /** get number of bits that need to be added to the previous frame */
1479
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1480
        dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1481
                num_bits_prev_frame);
1482

    
1483
        /** check for packet loss */
1484
        if (!s->packet_loss &&
1485
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1486
            s->packet_loss = 1;
1487
            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1488
                   s->packet_sequence_number, packet_sequence_number);
1489
        }
1490
        s->packet_sequence_number = packet_sequence_number;
1491

    
1492
        if (num_bits_prev_frame > 0) {
1493
            /** append the previous frame data to the remaining data from the
1494
                previous packet to create a full frame */
1495
            save_bits(s, gb, num_bits_prev_frame, 1);
1496
            dprintf(avctx, "accumulated %x bits of frame data\n",
1497
                    s->num_saved_bits - s->frame_offset);
1498

    
1499
            /** decode the cross packet frame if it is valid */
1500
            if (!s->packet_loss)
1501
                decode_frame(s);
1502
        } else if (s->num_saved_bits - s->frame_offset) {
1503
            dprintf(avctx, "ignoring %x previously saved bits\n",
1504
                    s->num_saved_bits - s->frame_offset);
1505
        }
1506

    
1507
        s->packet_loss = 0;
1508

    
1509
    } else {
1510
        /** continue decoding */
1511
        s->output_buffer_full = 0;
1512
        more_frames = decode_frame(s);
1513
    }
1514

    
1515
    /** decode the rest of the packet */
1516
    while (!s->packet_loss && !s->output_buffer_full && more_frames &&
1517
           remaining_bits(s, gb) > s->log2_frame_size) {
1518
        int frame_size = show_bits(gb, s->log2_frame_size);
1519

    
1520
        /** there is enough data for a full frame */
1521
        if (remaining_bits(s, gb) >= frame_size && frame_size > 0) {
1522
            save_bits(s, gb, frame_size, 0);
1523

    
1524
            /** decode the frame */
1525
            more_frames = decode_frame(s);
1526

    
1527
        } else
1528
            more_frames = 0;
1529
    }
1530

    
1531
    if (!s->output_buffer_full && !s->packet_loss &&
1532
        remaining_bits(s, gb) > 0) {
1533
        /** save the rest of the data so that it can be decoded
1534
            with the next packet */
1535
        save_bits(s, gb, remaining_bits(s, gb), 0);
1536
    }
1537

    
1538
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1539

    
1540
    return (s->output_buffer_full)?0: avctx->block_align;
1541
}
1542

    
1543
/**
1544
 *@brief Clear decoder buffers (for seeking).
1545
 *@param avctx codec context
1546
 */
1547
static void flush(AVCodecContext *avctx)
1548
{
1549
    WMAProDecodeCtx *s = avctx->priv_data;
1550
    int i;
1551
    /** reset output buffer as a part of it is used during the windowing of a
1552
        new frame */
1553
    for (i = 0; i < s->num_channels; i++)
1554
        memset(s->channel[i].out, 0, s->samples_per_frame *
1555
               sizeof(*s->channel[i].out));
1556
    s->packet_loss = 1;
1557
}
1558

    
1559

    
1560
/**
1561
 *@brief wmapro decoder
1562
 */
1563
AVCodec wmapro_decoder = {
1564
    "wmapro",
1565
    CODEC_TYPE_AUDIO,
1566
    CODEC_ID_WMAPRO,
1567
    sizeof(WMAProDecodeCtx),
1568
    decode_init,
1569
    NULL,
1570
    decode_end,
1571
    decode_packet,
1572
    .flush= flush,
1573
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1574
};