Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaprodec.c @ f7346719

History | View | Annotate | Download (62 KB)

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

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

    
89
#include "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_MIN_BITS  6                                           ///< log2 of min block size
104
#define WMAPRO_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
105
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
106
#define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
107

    
108

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

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

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

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

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

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

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

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

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

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

    
225
    WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
226
} WMAProDecodeCtx;
227

    
228

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

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

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

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

    
260
    return 0;
261
}
262

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

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

    
281
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
282

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

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

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

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

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

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

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

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

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

    
330
    s->num_channels = avctx->channels;
331

    
332
    /** extract lfe channel position */
333
    s->lfe_channel = -1;
334

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

    
343
    if (s->num_channels < 0) {
344
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
345
        return AVERROR_INVALIDDATA;
346
    } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
347
        av_log_ask_for_sample(avctx, "unsupported number of channels\n");
348
        return AVERROR_PATCHWELCOME;
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], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
423
                     1.0 / (1 << (WMAPRO_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) - WMAPRO_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) - WMAPRO_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
        if (get_bits1(gb)) {
1296
            for (i = 0; i < s->num_channels * s->num_channels; i++)
1297
                skip_bits(gb, 4);
1298
        }
1299
    }
1300

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

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

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

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

    
1324
    }
1325

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

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

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

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

    
1352
        // FIXME should create/use a DSP function here
1353
        while (iptr < iend) {
1354
            *ptr = *iptr++;
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 (s->len_prefix) {
1370
        if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1371
            /** FIXME: not sure if this is always an error */
1372
            av_log(s->avctx, AV_LOG_ERROR,
1373
                   "frame[%i] would have to skip %i bits\n", s->frame_num,
1374
                   len - (get_bits_count(gb) - s->frame_offset) - 1);
1375
            s->packet_loss = 1;
1376
            return 0;
1377
        }
1378

    
1379
        /** skip the rest of the frame data */
1380
        skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1381
    } else {
1382
        while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1383
        }
1384
    }
1385

    
1386
    /** decode trailer bit */
1387
    more_frames = get_bits1(gb);
1388

    
1389
    ++s->frame_num;
1390
    return more_frames;
1391
}
1392

    
1393
/**
1394
 *@brief Calculate remaining input buffer length.
1395
 *@param s codec context
1396
 *@param gb bitstream reader context
1397
 *@return remaining size in bits
1398
 */
1399
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1400
{
1401
    return s->buf_bit_size - get_bits_count(gb);
1402
}
1403

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

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

    
1420
    if (!append) {
1421
        s->frame_offset = get_bits_count(gb) & 7;
1422
        s->num_saved_bits = s->frame_offset;
1423
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1424
    }
1425

    
1426
    buflen = (s->num_saved_bits + len + 8) >> 3;
1427

    
1428
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1429
        av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1430
        s->packet_loss = 1;
1431
        return;
1432
    }
1433

    
1434
    s->num_saved_bits += len;
1435
    if (!append) {
1436
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1437
                     s->num_saved_bits);
1438
    } else {
1439
        int align = 8 - (get_bits_count(gb) & 7);
1440
        align = FFMIN(align, len);
1441
        put_bits(&s->pb, align, get_bits(gb, align));
1442
        len -= align;
1443
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1444
    }
1445
    skip_bits_long(gb, len);
1446

    
1447
    {
1448
        PutBitContext tmp = s->pb;
1449
        flush_put_bits(&tmp);
1450
    }
1451

    
1452
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1453
    skip_bits(&s->gb, s->frame_offset);
1454
}
1455

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

    
1474
    s->samples       = data;
1475
    s->samples_end   = (float*)((int8_t*)data + *data_size);
1476
    *data_size = 0;
1477

    
1478
    if (s->packet_done || s->packet_loss) {
1479
        s->packet_done = 0;
1480

    
1481
        /** sanity check for the buffer length */
1482
        if (buf_size < avctx->block_align)
1483
            return 0;
1484

    
1485
        s->next_packet_start = buf_size - avctx->block_align;
1486
        buf_size = avctx->block_align;
1487
        s->buf_bit_size = buf_size << 3;
1488

    
1489
        /** parse packet header */
1490
        init_get_bits(gb, buf, s->buf_bit_size);
1491
        packet_sequence_number = get_bits(gb, 4);
1492
        skip_bits(gb, 2);
1493

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

    
1499
        /** check for packet loss */
1500
        if (!s->packet_loss &&
1501
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1502
            s->packet_loss = 1;
1503
            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1504
                   s->packet_sequence_number, packet_sequence_number);
1505
        }
1506
        s->packet_sequence_number = packet_sequence_number;
1507

    
1508
        if (num_bits_prev_frame > 0) {
1509
            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1510
            if (num_bits_prev_frame >= remaining_packet_bits) {
1511
                num_bits_prev_frame = remaining_packet_bits;
1512
                s->packet_done = 1;
1513
            }
1514

    
1515
            /** append the previous frame data to the remaining data from the
1516
                previous packet to create a full frame */
1517
            save_bits(s, gb, num_bits_prev_frame, 1);
1518
            dprintf(avctx, "accumulated %x bits of frame data\n",
1519
                    s->num_saved_bits - s->frame_offset);
1520

    
1521
            /** decode the cross packet frame if it is valid */
1522
            if (!s->packet_loss)
1523
                decode_frame(s);
1524
        } else if (s->num_saved_bits - s->frame_offset) {
1525
            dprintf(avctx, "ignoring %x previously saved bits\n",
1526
                    s->num_saved_bits - s->frame_offset);
1527
        }
1528

    
1529
        if (s->packet_loss) {
1530
            /** reset number of saved bits so that the decoder
1531
                does not start to decode incomplete frames in the
1532
                s->len_prefix == 0 case */
1533
            s->num_saved_bits = 0;
1534
            s->packet_loss = 0;
1535
        }
1536

    
1537
    } else {
1538
        int frame_size;
1539
        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1540
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1541
        skip_bits(gb, s->packet_offset);
1542
        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1543
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1544
            frame_size <= remaining_bits(s, gb)) {
1545
            save_bits(s, gb, frame_size, 0);
1546
            s->packet_done = !decode_frame(s);
1547
        } else if (!s->len_prefix
1548
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
1549
            /** when the frames do not have a length prefix, we don't know
1550
                the compressed length of the individual frames
1551
                however, we know what part of a new packet belongs to the
1552
                previous frame
1553
                therefore we save the incoming packet first, then we append
1554
                the "previous frame" data from the next packet so that
1555
                we get a buffer that only contains full frames */
1556
            s->packet_done = !decode_frame(s);
1557
        } else
1558
            s->packet_done = 1;
1559
    }
1560

    
1561
    if (s->packet_done && !s->packet_loss &&
1562
        remaining_bits(s, gb) > 0) {
1563
        /** save the rest of the data so that it can be decoded
1564
            with the next packet */
1565
        save_bits(s, gb, remaining_bits(s, gb), 0);
1566
    }
1567

    
1568
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1569
    s->packet_offset = get_bits_count(gb) & 7;
1570

    
1571
    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1572
}
1573

    
1574
/**
1575
 *@brief Clear decoder buffers (for seeking).
1576
 *@param avctx codec context
1577
 */
1578
static void flush(AVCodecContext *avctx)
1579
{
1580
    WMAProDecodeCtx *s = avctx->priv_data;
1581
    int i;
1582
    /** reset output buffer as a part of it is used during the windowing of a
1583
        new frame */
1584
    for (i = 0; i < s->num_channels; i++)
1585
        memset(s->channel[i].out, 0, s->samples_per_frame *
1586
               sizeof(*s->channel[i].out));
1587
    s->packet_loss = 1;
1588
}
1589

    
1590

    
1591
/**
1592
 *@brief wmapro decoder
1593
 */
1594
AVCodec wmapro_decoder = {
1595
    "wmapro",
1596
    AVMEDIA_TYPE_AUDIO,
1597
    CODEC_ID_WMAPRO,
1598
    sizeof(WMAProDecodeCtx),
1599
    decode_init,
1600
    NULL,
1601
    decode_end,
1602
    decode_packet,
1603
    .capabilities = CODEC_CAP_SUBFRAMES,
1604
    .flush= flush,
1605
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1606
};