Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaprodec.c @ 84dc2d8a

History | View | Annotate | Download (60.3 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 win_idx = WMAPRO_BLOCK_MAX_BITS - i;
429
        ff_init_ff_sine_windows(win_idx);
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
    /* Integers 0..15 as single-precision floats.  The table saves a
765
       costly int to float conversion, and storing the values as
766
       integers allows fast sign-flipping. */
767
    static const int fval_tab[16] = {
768
        0x00000000, 0x3f800000, 0x40000000, 0x40400000,
769
        0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
770
        0x41000000, 0x41100000, 0x41200000, 0x41300000,
771
        0x41400000, 0x41500000, 0x41600000, 0x41700000,
772
    };
773
    int vlctable;
774
    VLC* vlc;
775
    WMAProChannelCtx* ci = &s->channel[c];
776
    int rl_mode = 0;
777
    int cur_coeff = 0;
778
    int num_zeros = 0;
779
    const uint16_t* run;
780
    const float* level;
781

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

    
784
    vlctable = get_bits1(&s->gb);
785
    vlc = &coef_vlc[vlctable];
786

    
787
    if (vlctable) {
788
        run = coef1_run;
789
        level = coef1_level;
790
    } else {
791
        run = coef0_run;
792
        level = coef0_level;
793
    }
794

    
795
    /** decode vector coefficients (consumes up to 167 bits per iteration for
796
      4 vector coded large values) */
797
    while (!rl_mode && cur_coeff + 3 < s->subframe_len) {
798
        int vals[4];
799
        int i;
800
        unsigned int idx;
801

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

    
804
        if (idx == HUFF_VEC4_SIZE - 1) {
805
            for (i = 0; i < 4; i += 2) {
806
                idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
807
                if (idx == HUFF_VEC2_SIZE - 1) {
808
                    int v0, v1;
809
                    v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
810
                    if (v0 == HUFF_VEC1_SIZE - 1)
811
                        v0 += ff_wma_get_large_val(&s->gb);
812
                    v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
813
                    if (v1 == HUFF_VEC1_SIZE - 1)
814
                        v1 += ff_wma_get_large_val(&s->gb);
815
                    ((float*)vals)[i  ] = v0;
816
                    ((float*)vals)[i+1] = v1;
817
                } else {
818
                    vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
819
                    vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
820
                }
821
            }
822
        } else {
823
            vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
824
            vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
825
            vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
826
            vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
827
        }
828

    
829
        /** decode sign */
830
        for (i = 0; i < 4; i++) {
831
            if (vals[i]) {
832
                int sign = get_bits1(&s->gb) - 1;
833
                *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31;
834
                num_zeros = 0;
835
            } else {
836
                ci->coeffs[cur_coeff] = 0;
837
                /** switch to run level mode when subframe_len / 128 zeros
838
                    were found in a row */
839
                rl_mode |= (++num_zeros > s->subframe_len >> 8);
840
            }
841
            ++cur_coeff;
842
        }
843
    }
844

    
845
    /** decode run level coded coefficients */
846
    if (rl_mode) {
847
        memset(&ci->coeffs[cur_coeff], 0,
848
               sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
849
        if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
850
                                    level, run, 1, ci->coeffs,
851
                                    cur_coeff, s->subframe_len,
852
                                    s->subframe_len, s->esc_len, 0))
853
            return AVERROR_INVALIDDATA;
854
    }
855

    
856
    return 0;
857
}
858

    
859
/**
860
 *@brief Extract scale factors from the bitstream.
861
 *@param s codec context
862
 *@return 0 on success, < 0 in case of bitstream errors
863
 */
864
static int decode_scale_factors(WMAProDecodeCtx* s)
865
{
866
    int i;
867

    
868
    /** should never consume more than 5344 bits
869
     *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
870
     */
871

    
872
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
873
        int c = s->channel_indexes_for_cur_subframe[i];
874
        int* sf;
875
        int* sf_end;
876
        s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
877
        sf_end = s->channel[c].scale_factors + s->num_bands;
878

    
879
        /** resample scale factors for the new block size
880
         *  as the scale factors might need to be resampled several times
881
         *  before some  new values are transmitted, a backup of the last
882
         *  transmitted scale factors is kept in saved_scale_factors
883
         */
884
        if (s->channel[c].reuse_sf) {
885
            const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
886
            int b;
887
            for (b = 0; b < s->num_bands; b++)
888
                s->channel[c].scale_factors[b] =
889
                    s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
890
        }
891

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

    
894
            if (!s->channel[c].reuse_sf) {
895
                int val;
896
                /** decode DPCM coded scale factors */
897
                s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
898
                val = 45 / s->channel[c].scale_factor_step;
899
                for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
900
                    val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
901
                    *sf = val;
902
                }
903
            } else {
904
                int i;
905
                /** run level decode differences to the resampled factors */
906
                for (i = 0; i < s->num_bands; i++) {
907
                    int idx;
908
                    int skip;
909
                    int val;
910
                    int sign;
911

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

    
914
                    if (!idx) {
915
                        uint32_t code = get_bits(&s->gb, 14);
916
                        val  =  code >> 6;
917
                        sign = (code & 1) - 1;
918
                        skip = (code & 0x3f) >> 1;
919
                    } else if (idx == 1) {
920
                        break;
921
                    } else {
922
                        skip = scale_rl_run[idx];
923
                        val  = scale_rl_level[idx];
924
                        sign = get_bits1(&s->gb)-1;
925
                    }
926

    
927
                    i += skip;
928
                    if (i >= s->num_bands) {
929
                        av_log(s->avctx, AV_LOG_ERROR,
930
                               "invalid scale factor coding\n");
931
                        return AVERROR_INVALIDDATA;
932
                    }
933
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
934
                }
935
            }
936
            /** swap buffers */
937
            s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
938
            s->channel[c].table_idx = s->table_idx;
939
            s->channel[c].reuse_sf  = 1;
940
        }
941

    
942
        /** calculate new scale factor maximum */
943
        s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
944
        for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
945
            s->channel[c].max_scale_factor =
946
                FFMAX(s->channel[c].max_scale_factor, *sf);
947
        }
948

    
949
    }
950
    return 0;
951
}
952

    
953
/**
954
 *@brief Reconstruct the individual channel data.
955
 *@param s codec context
956
 */
957
static void inverse_channel_transform(WMAProDecodeCtx *s)
958
{
959
    int i;
960

    
961
    for (i = 0; i < s->num_chgroups; i++) {
962
        if (s->chgroup[i].transform) {
963
            float data[WMAPRO_MAX_CHANNELS];
964
            const int num_channels = s->chgroup[i].num_channels;
965
            float** ch_data = s->chgroup[i].channel_data;
966
            float** ch_end = ch_data + num_channels;
967
            const int8_t* tb = s->chgroup[i].transform_band;
968
            int16_t* sfb;
969

    
970
            /** multichannel decorrelation */
971
            for (sfb = s->cur_sfb_offsets;
972
                 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
973
                int y;
974
                if (*tb++ == 1) {
975
                    /** multiply values with the decorrelation_matrix */
976
                    for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
977
                        const float* mat = s->chgroup[i].decorrelation_matrix;
978
                        const float* data_end = data + num_channels;
979
                        float* data_ptr = data;
980
                        float** ch;
981

    
982
                        for (ch = ch_data; ch < ch_end; ch++)
983
                            *data_ptr++ = (*ch)[y];
984

    
985
                        for (ch = ch_data; ch < ch_end; ch++) {
986
                            float sum = 0;
987
                            data_ptr = data;
988
                            while (data_ptr < data_end)
989
                                sum += *data_ptr++ * *mat++;
990

    
991
                            (*ch)[y] = sum;
992
                        }
993
                    }
994
                } else if (s->num_channels == 2) {
995
                    int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
996
                    s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
997
                                              ch_data[0] + sfb[0],
998
                                              181.0 / 128, len);
999
                    s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
1000
                                              ch_data[1] + sfb[0],
1001
                                              181.0 / 128, len);
1002
                }
1003
            }
1004
        }
1005
    }
1006
}
1007

    
1008
/**
1009
 *@brief Apply sine window and reconstruct the output buffer.
1010
 *@param s codec context
1011
 */
1012
static void wmapro_window(WMAProDecodeCtx *s)
1013
{
1014
    int i;
1015
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1016
        int c = s->channel_indexes_for_cur_subframe[i];
1017
        float* window;
1018
        int winlen = s->channel[c].prev_block_len;
1019
        float* start = s->channel[c].coeffs - (winlen >> 1);
1020

    
1021
        if (s->subframe_len < winlen) {
1022
            start += (winlen - s->subframe_len) >> 1;
1023
            winlen = s->subframe_len;
1024
        }
1025

    
1026
        window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS];
1027

    
1028
        winlen >>= 1;
1029

    
1030
        s->dsp.vector_fmul_window(start, start, start + winlen,
1031
                                  window, 0, winlen);
1032

    
1033
        s->channel[c].prev_block_len = s->subframe_len;
1034
    }
1035
}
1036

    
1037
/**
1038
 *@brief Decode a single subframe (block).
1039
 *@param s codec context
1040
 *@return 0 on success, < 0 when decoding failed
1041
 */
1042
static int decode_subframe(WMAProDecodeCtx *s)
1043
{
1044
    int offset = s->samples_per_frame;
1045
    int subframe_len = s->samples_per_frame;
1046
    int i;
1047
    int total_samples   = s->samples_per_frame * s->num_channels;
1048
    int transmit_coeffs = 0;
1049
    int cur_subwoofer_cutoff;
1050

    
1051
    s->subframe_offset = get_bits_count(&s->gb);
1052

    
1053
    /** reset channel context and find the next block offset and size
1054
        == the next block of the channel with the smallest number of
1055
        decoded samples
1056
    */
1057
    for (i = 0; i < s->num_channels; i++) {
1058
        s->channel[i].grouped = 0;
1059
        if (offset > s->channel[i].decoded_samples) {
1060
            offset = s->channel[i].decoded_samples;
1061
            subframe_len =
1062
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
1063
        }
1064
    }
1065

    
1066
    dprintf(s->avctx,
1067
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1068

    
1069
    /** get a list of all channels that contain the estimated block */
1070
    s->channels_for_cur_subframe = 0;
1071
    for (i = 0; i < s->num_channels; i++) {
1072
        const int cur_subframe = s->channel[i].cur_subframe;
1073
        /** substract already processed samples */
1074
        total_samples -= s->channel[i].decoded_samples;
1075

    
1076
        /** and count if there are multiple subframes that match our profile */
1077
        if (offset == s->channel[i].decoded_samples &&
1078
            subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1079
            total_samples -= s->channel[i].subframe_len[cur_subframe];
1080
            s->channel[i].decoded_samples +=
1081
                s->channel[i].subframe_len[cur_subframe];
1082
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1083
            ++s->channels_for_cur_subframe;
1084
        }
1085
    }
1086

    
1087
    /** check if the frame will be complete after processing the
1088
        estimated block */
1089
    if (!total_samples)
1090
        s->parsed_all_subframes = 1;
1091

    
1092

    
1093
    dprintf(s->avctx, "subframe is part of %i channels\n",
1094
            s->channels_for_cur_subframe);
1095

    
1096
    /** calculate number of scale factor bands and their offsets */
1097
    s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1098
    s->num_bands         = s->num_sfb[s->table_idx];
1099
    s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1100
    cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1101

    
1102
    /** configure the decoder for the current subframe */
1103
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1104
        int c = s->channel_indexes_for_cur_subframe[i];
1105

    
1106
        s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1107
                                                  + offset];
1108
    }
1109

    
1110
    s->subframe_len = subframe_len;
1111
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1112

    
1113
    /** skip extended header if any */
1114
    if (get_bits1(&s->gb)) {
1115
        int num_fill_bits;
1116
        if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1117
            int len = get_bits(&s->gb, 4);
1118
            num_fill_bits = get_bits(&s->gb, len) + 1;
1119
        }
1120

    
1121
        if (num_fill_bits >= 0) {
1122
            if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1123
                av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1124
                return AVERROR_INVALIDDATA;
1125
            }
1126

    
1127
            skip_bits_long(&s->gb, num_fill_bits);
1128
        }
1129
    }
1130

    
1131
    /** no idea for what the following bit is used */
1132
    if (get_bits1(&s->gb)) {
1133
        av_log_ask_for_sample(s->avctx, "reserved bit set\n");
1134
        return AVERROR_INVALIDDATA;
1135
    }
1136

    
1137

    
1138
    if (decode_channel_transform(s) < 0)
1139
        return AVERROR_INVALIDDATA;
1140

    
1141

    
1142
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1143
        int c = s->channel_indexes_for_cur_subframe[i];
1144
        if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1145
            transmit_coeffs = 1;
1146
    }
1147

    
1148
    if (transmit_coeffs) {
1149
        int step;
1150
        int quant_step = 90 * s->bits_per_sample >> 4;
1151
        if ((get_bits1(&s->gb))) {
1152
            /** FIXME: might change run level mode decision */
1153
            av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n");
1154
            return AVERROR_INVALIDDATA;
1155
        }
1156
        /** decode quantization step */
1157
        step = get_sbits(&s->gb, 6);
1158
        quant_step += step;
1159
        if (step == -32 || step == 31) {
1160
            const int sign = (step == 31) - 1;
1161
            int quant = 0;
1162
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1163
                   (step = get_bits(&s->gb, 5)) == 31) {
1164
                quant += 31;
1165
            }
1166
            quant_step += ((quant + step) ^ sign) - sign;
1167
        }
1168
        if (quant_step < 0) {
1169
            av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1170
        }
1171

    
1172
        /** decode quantization step modifiers for every channel */
1173

    
1174
        if (s->channels_for_cur_subframe == 1) {
1175
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1176
        } else {
1177
            int modifier_len = get_bits(&s->gb, 3);
1178
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1179
                int c = s->channel_indexes_for_cur_subframe[i];
1180
                s->channel[c].quant_step = quant_step;
1181
                if (get_bits1(&s->gb)) {
1182
                    if (modifier_len) {
1183
                        s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1184
                    } else
1185
                        ++s->channel[c].quant_step;
1186
                }
1187
            }
1188
        }
1189

    
1190
        /** decode scale factors */
1191
        if (decode_scale_factors(s) < 0)
1192
            return AVERROR_INVALIDDATA;
1193
    }
1194

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

    
1198
    /** parse coefficients */
1199
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1200
        int c = s->channel_indexes_for_cur_subframe[i];
1201
        if (s->channel[c].transmit_coefs &&
1202
            get_bits_count(&s->gb) < s->num_saved_bits) {
1203
            decode_coeffs(s, c);
1204
        } else
1205
            memset(s->channel[c].coeffs, 0,
1206
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1207
    }
1208

    
1209
    dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1210
            get_bits_count(&s->gb) - s->subframe_offset);
1211

    
1212
    if (transmit_coeffs) {
1213
        /** reconstruct the per channel data */
1214
        inverse_channel_transform(s);
1215
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
1216
            int c = s->channel_indexes_for_cur_subframe[i];
1217
            const int* sf = s->channel[c].scale_factors;
1218
            int b;
1219

    
1220
            if (c == s->lfe_channel)
1221
                memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1222
                       (subframe_len - cur_subwoofer_cutoff));
1223

    
1224
            /** inverse quantization and rescaling */
1225
            for (b = 0; b < s->num_bands; b++) {
1226
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1227
                const int exp = s->channel[c].quant_step -
1228
                            (s->channel[c].max_scale_factor - *sf++) *
1229
                            s->channel[c].scale_factor_step;
1230
                const float quant = pow(10.0, exp / 20.0);
1231
                int start = s->cur_sfb_offsets[b];
1232
                s->dsp.vector_fmul_scalar(s->tmp + start,
1233
                                          s->channel[c].coeffs + start,
1234
                                          quant, end - start);
1235
            }
1236

    
1237
            /** apply imdct (ff_imdct_half == DCTIV with reverse) */
1238
            ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS],
1239
                          s->channel[c].coeffs, s->tmp);
1240
        }
1241
    }
1242

    
1243
    /** window and overlapp-add */
1244
    wmapro_window(s);
1245

    
1246
    /** handled one subframe */
1247
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1248
        int c = s->channel_indexes_for_cur_subframe[i];
1249
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1250
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1251
            return AVERROR_INVALIDDATA;
1252
        }
1253
        ++s->channel[c].cur_subframe;
1254
    }
1255

    
1256
    return 0;
1257
}
1258

    
1259
/**
1260
 *@brief Decode one WMA frame.
1261
 *@param s codec context
1262
 *@return 0 if the trailer bit indicates that this is the last frame,
1263
 *        1 if there are additional frames
1264
 */
1265
static int decode_frame(WMAProDecodeCtx *s)
1266
{
1267
    GetBitContext* gb = &s->gb;
1268
    int more_frames = 0;
1269
    int len = 0;
1270
    int i;
1271

    
1272
    /** check for potential output buffer overflow */
1273
    if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1274
        /** return an error if no frame could be decoded at all */
1275
        av_log(s->avctx, AV_LOG_ERROR,
1276
               "not enough space for the output samples\n");
1277
        s->packet_loss = 1;
1278
        return 0;
1279
    }
1280

    
1281
    /** get frame length */
1282
    if (s->len_prefix)
1283
        len = get_bits(gb, s->log2_frame_size);
1284

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

    
1287
    /** decode tile information */
1288
    if (decode_tilehdr(s)) {
1289
        s->packet_loss = 1;
1290
        return 0;
1291
    }
1292

    
1293
    /** read postproc transform */
1294
    if (s->num_channels > 1 && get_bits1(gb)) {
1295
        av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n");
1296
        s->packet_loss = 1;
1297
        return 0;
1298
    }
1299

    
1300
    /** read drc info */
1301
    if (s->dynamic_range_compression) {
1302
        s->drc_gain = get_bits(gb, 8);
1303
        dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1304
    }
1305

    
1306
    /** no idea what these are for, might be the number of samples
1307
        that need to be skipped at the beginning or end of a stream */
1308
    if (get_bits1(gb)) {
1309
        int skip;
1310

    
1311
        /** usually true for the first frame */
1312
        if (get_bits1(gb)) {
1313
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1314
            dprintf(s->avctx, "start skip: %i\n", skip);
1315
        }
1316

    
1317
        /** sometimes true for the last frame */
1318
        if (get_bits1(gb)) {
1319
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1320
            dprintf(s->avctx, "end skip: %i\n", skip);
1321
        }
1322

    
1323
    }
1324

    
1325
    dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1326
            get_bits_count(gb) - s->frame_offset);
1327

    
1328
    /** reset subframe states */
1329
    s->parsed_all_subframes = 0;
1330
    for (i = 0; i < s->num_channels; i++) {
1331
        s->channel[i].decoded_samples = 0;
1332
        s->channel[i].cur_subframe    = 0;
1333
        s->channel[i].reuse_sf        = 0;
1334
    }
1335

    
1336
    /** decode all subframes */
1337
    while (!s->parsed_all_subframes) {
1338
        if (decode_subframe(s) < 0) {
1339
            s->packet_loss = 1;
1340
            return 0;
1341
        }
1342
    }
1343

    
1344
    /** interleave samples and write them to the output buffer */
1345
    for (i = 0; i < s->num_channels; i++) {
1346
        float* ptr;
1347
        int incr = s->num_channels;
1348
        float* iptr = s->channel[i].out;
1349
        int x;
1350

    
1351
        ptr = s->samples + i;
1352

    
1353
        for (x = 0; x < s->samples_per_frame; x++) {
1354
            *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0);
1355
            ptr += incr;
1356
        }
1357

    
1358
        /** reuse second half of the IMDCT output for the next frame */
1359
        memcpy(&s->channel[i].out[0],
1360
               &s->channel[i].out[s->samples_per_frame],
1361
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1362
    }
1363

    
1364
    if (s->skip_frame) {
1365
        s->skip_frame = 0;
1366
    } else
1367
        s->samples += s->num_channels * s->samples_per_frame;
1368

    
1369
    if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1370
        /** FIXME: not sure if this is always an error */
1371
        av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n",
1372
               s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1);
1373
        s->packet_loss = 1;
1374
        return 0;
1375
    }
1376

    
1377
    /** skip the rest of the frame data */
1378
    skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1379

    
1380
    /** decode trailer bit */
1381
    more_frames = get_bits1(gb);
1382

    
1383
    ++s->frame_num;
1384
    return more_frames;
1385
}
1386

    
1387
/**
1388
 *@brief Calculate remaining input buffer length.
1389
 *@param s codec context
1390
 *@param gb bitstream reader context
1391
 *@return remaining size in bits
1392
 */
1393
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1394
{
1395
    return s->buf_bit_size - get_bits_count(gb);
1396
}
1397

    
1398
/**
1399
 *@brief Fill the bit reservoir with a (partial) frame.
1400
 *@param s codec context
1401
 *@param gb bitstream reader context
1402
 *@param len length of the partial frame
1403
 *@param append decides wether to reset the buffer or not
1404
 */
1405
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1406
                      int append)
1407
{
1408
    int buflen;
1409

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

    
1414
    if (!append) {
1415
        s->frame_offset = get_bits_count(gb) & 7;
1416
        s->num_saved_bits = s->frame_offset;
1417
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1418
    }
1419

    
1420
    buflen = (s->num_saved_bits + len + 8) >> 3;
1421

    
1422
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1423
        av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1424
        s->packet_loss = 1;
1425
        return;
1426
    }
1427

    
1428
    s->num_saved_bits += len;
1429
    if (!append) {
1430
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1431
                     s->num_saved_bits);
1432
    } else {
1433
        int align = 8 - (get_bits_count(gb) & 7);
1434
        align = FFMIN(align, len);
1435
        put_bits(&s->pb, align, get_bits(gb, align));
1436
        len -= align;
1437
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1438
    }
1439
    skip_bits_long(gb, len);
1440

    
1441
    {
1442
        PutBitContext tmp = s->pb;
1443
        flush_put_bits(&tmp);
1444
    }
1445

    
1446
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1447
    skip_bits(&s->gb, s->frame_offset);
1448
}
1449

    
1450
/**
1451
 *@brief Decode a single WMA packet.
1452
 *@param avctx codec context
1453
 *@param data the output buffer
1454
 *@param data_size number of bytes that were written to the output buffer
1455
 *@param avpkt input packet
1456
 *@return number of bytes that were read from the input buffer
1457
 */
1458
static int decode_packet(AVCodecContext *avctx,
1459
                         void *data, int *data_size, AVPacket* avpkt)
1460
{
1461
    WMAProDecodeCtx *s = avctx->priv_data;
1462
    GetBitContext* gb  = &s->pgb;
1463
    const uint8_t* buf = avpkt->data;
1464
    int buf_size       = avpkt->size;
1465
    int num_bits_prev_frame;
1466
    int packet_sequence_number;
1467

    
1468
    s->samples       = data;
1469
    s->samples_end   = (float*)((int8_t*)data + *data_size);
1470
    *data_size = 0;
1471

    
1472
    if (s->packet_done || s->packet_loss) {
1473
        s->packet_done = 0;
1474
        s->buf_bit_size = buf_size << 3;
1475

    
1476
        /** sanity check for the buffer length */
1477
        if (buf_size < avctx->block_align)
1478
            return 0;
1479

    
1480
        buf_size = avctx->block_align;
1481

    
1482
        /** parse packet header */
1483
        init_get_bits(gb, buf, s->buf_bit_size);
1484
        packet_sequence_number = get_bits(gb, 4);
1485
        skip_bits(gb, 2);
1486

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

    
1492
        /** check for packet loss */
1493
        if (!s->packet_loss &&
1494
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1495
            s->packet_loss = 1;
1496
            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1497
                   s->packet_sequence_number, packet_sequence_number);
1498
        }
1499
        s->packet_sequence_number = packet_sequence_number;
1500

    
1501
        if (num_bits_prev_frame > 0) {
1502
            /** append the previous frame data to the remaining data from the
1503
                previous packet to create a full frame */
1504
            save_bits(s, gb, num_bits_prev_frame, 1);
1505
            dprintf(avctx, "accumulated %x bits of frame data\n",
1506
                    s->num_saved_bits - s->frame_offset);
1507

    
1508
            /** decode the cross packet frame if it is valid */
1509
            if (!s->packet_loss)
1510
                decode_frame(s);
1511
        } else if (s->num_saved_bits - s->frame_offset) {
1512
            dprintf(avctx, "ignoring %x previously saved bits\n",
1513
                    s->num_saved_bits - s->frame_offset);
1514
        }
1515

    
1516
        s->packet_loss = 0;
1517

    
1518
    } else {
1519
        int frame_size;
1520
        s->buf_bit_size = avpkt->size << 3;
1521
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1522
        skip_bits(gb, s->packet_offset);
1523
        if (remaining_bits(s, gb) > s->log2_frame_size &&
1524
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1525
            frame_size <= remaining_bits(s, gb)) {
1526
            save_bits(s, gb, frame_size, 0);
1527
            s->packet_done = !decode_frame(s);
1528
        } else
1529
            s->packet_done = 1;
1530
    }
1531

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

    
1539
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1540
    s->packet_offset = get_bits_count(gb) & 7;
1541

    
1542
    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1543
}
1544

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

    
1561

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