Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaprodec.c @ aac4b0a4

History | View | Annotate | Download (59.8 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  32768                                 ///< maximum compressed frame size
102

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

    
107

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

    
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      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
141
    int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
142
    int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
143
    uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
144
    float*   coeffs;                                  ///< pointer to the subframe decode buffer
145
    DECLARE_ALIGNED_16(float, out[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]); ///< output buffer
146
} WMAProChannelCtx;
147

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

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

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

    
191
    /* packet decode state */
192
    GetBitContext    pgb;                           ///< bitstream reader context for the packet
193
    uint8_t          packet_offset;                 ///< frame offset in the packet
194
    uint8_t          packet_sequence_number;        ///< current packet number
195
    int              num_saved_bits;                ///< saved number of bits
196
    int              frame_offset;                  ///< frame offset in the bit reservoir
197
    int              subframe_offset;               ///< subframe offset in the bit reservoir
198
    uint8_t          packet_loss;                   ///< set in case of bitstream error
199
    uint8_t          packet_done;                   ///< set when a packet is fully decoded
200

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

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

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

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

    
226

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

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

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

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

    
258
    return 0;
259
}
260

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

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

    
279
    avctx->sample_fmt = SAMPLE_FMT_FLT;
280

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
399

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
592
    return 0;
593
}
594

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
845
    return 0;
846
}
847

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

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

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

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

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

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

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

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

    
916
                    i += skip;
917
                    if (i >= s->num_bands) {
918
                        av_log(s->avctx, AV_LOG_ERROR,
919
                               "invalid scale factor coding\n");
920
                        return AVERROR_INVALIDDATA;
921
                    }
922
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
923
                }
924
            }
925
            /** swap buffers */
926
            s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
927
            s->channel[c].table_idx = s->table_idx;
928
            s->channel[c].reuse_sf  = 1;
929
        }
930

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

    
938
    }
939
    return 0;
940
}
941

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

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

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

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

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

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

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

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

    
1015
        window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1016

    
1017
        winlen >>= 1;
1018

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

    
1022
        s->channel[c].prev_block_len = s->subframe_len;
1023
    }
1024
}
1025

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

    
1040
    s->subframe_offset = get_bits_count(&s->gb);
1041

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

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

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

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

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

    
1081

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

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

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

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

    
1099
    s->subframe_len = subframe_len;
1100
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1101

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

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

    
1116
            skip_bits_long(&s->gb, num_fill_bits);
1117
        }
1118
    }
1119

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

    
1126

    
1127
    if (decode_channel_transform(s) < 0)
1128
        return AVERROR_INVALIDDATA;
1129

    
1130

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

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

    
1161
        /** decode quantization step modifiers for every channel */
1162

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

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

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

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

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

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

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

    
1213
            /** inverse quantization and rescaling */
1214
            for (b = 0; b < s->num_bands; b++) {
1215
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1216
                const int exp = s->channel[c].quant_step -
1217
                            (s->channel[c].max_scale_factor - *sf++) *
1218
                            s->channel[c].scale_factor_step;
1219
                const float quant = pow(10.0, exp / 20.0);
1220
                int start = s->cur_sfb_offsets[b];
1221
                s->dsp.vector_fmul_scalar(s->tmp + start,
1222
                                          s->channel[c].coeffs + start,
1223
                                          quant, end - start);
1224
            }
1225

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

    
1232
    /** window and overlapp-add */
1233
    wmapro_window(s);
1234

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

    
1245
    return 0;
1246
}
1247

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

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

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

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

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

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

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

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

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

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

    
1312
    }
1313

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

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

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

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

    
1340
        ptr = s->samples + i;
1341

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1457
    s->samples       = data;
1458
    s->samples_end   = (float*)((int8_t*)data + *data_size);
1459
    *data_size = 0;
1460

    
1461
    if (s->packet_done || s->packet_loss) {
1462
        s->packet_done = 0;
1463
        s->buf_bit_size = buf_size << 3;
1464

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

    
1469
        buf_size = avctx->block_align;
1470

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

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

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

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

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

    
1505
        s->packet_loss = 0;
1506

    
1507
    } else {
1508
        int frame_size;
1509
        s->buf_bit_size = avpkt->size << 3;
1510
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1511
        skip_bits(gb, s->packet_offset);
1512
        if (remaining_bits(s, gb) > s->log2_frame_size &&
1513
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1514
            frame_size <= remaining_bits(s, gb)) {
1515
            save_bits(s, gb, frame_size, 0);
1516
            s->packet_done = !decode_frame(s);
1517
        } else
1518
            s->packet_done = 1;
1519
    }
1520

    
1521
    if (s->packet_done && !s->packet_loss &&
1522
        remaining_bits(s, gb) > 0) {
1523
        /** save the rest of the data so that it can be decoded
1524
            with the next packet */
1525
        save_bits(s, gb, remaining_bits(s, gb), 0);
1526
    }
1527

    
1528
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1529
    s->packet_offset = get_bits_count(gb) & 7;
1530

    
1531
    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1532
}
1533

    
1534
/**
1535
 *@brief Clear decoder buffers (for seeking).
1536
 *@param avctx codec context
1537
 */
1538
static void flush(AVCodecContext *avctx)
1539
{
1540
    WMAProDecodeCtx *s = avctx->priv_data;
1541
    int i;
1542
    /** reset output buffer as a part of it is used during the windowing of a
1543
        new frame */
1544
    for (i = 0; i < s->num_channels; i++)
1545
        memset(s->channel[i].out, 0, s->samples_per_frame *
1546
               sizeof(*s->channel[i].out));
1547
    s->packet_loss = 1;
1548
}
1549

    
1550

    
1551
/**
1552
 *@brief wmapro decoder
1553
 */
1554
AVCodec wmapro_decoder = {
1555
    "wmapro",
1556
    CODEC_TYPE_AUDIO,
1557
    CODEC_ID_WMAPRO,
1558
    sizeof(WMAProDecodeCtx),
1559
    decode_init,
1560
    NULL,
1561
    decode_end,
1562
    decode_packet,
1563
    .capabilities = CODEC_CAP_SUBFRAMES,
1564
    .flush= flush,
1565
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1566
};