Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmaprodec.c @ 26f548bb

History | View | Annotate | Download (62.7 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 Libav.
7
 *
8
 * Libav 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
 * Libav 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 Libav; 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
    uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
147
    DECLARE_ALIGNED(16, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
148
} WMAProChannelCtx;
149

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

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

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

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

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

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

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

    
227
    WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
228
} WMAProDecodeCtx;
229

    
230

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

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

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

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

    
262
    return 0;
263
}
264

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

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

    
283
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
284

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

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

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

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

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

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

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

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

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

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

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

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

    
345
    if (s->num_channels < 0) {
346
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
347
        return AVERROR_INVALIDDATA;
348
    } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
349
        av_log_ask_for_sample(avctx, "unsupported number of channels\n");
350
        return AVERROR_PATCHWELCOME;
351
    }
352

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

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

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

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

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

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

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

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

    
388
        s->sfb_offsets[i][0] = 0;
389

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

    
401

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
593
    return 0;
594
}
595

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

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

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

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

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

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

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

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

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

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

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

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

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

    
758
/**
759
 *@brief Extract the coefficients from the bitstream.
760
 *@param s codec context
761
 *@param c current channel number
762
 *@return 0 on success, < 0 in case of bitstream errors
763
 */
764
static int decode_coeffs(WMAProDecodeCtx *s, int c)
765
{
766
    /* Integers 0..15 as single-precision floats.  The table saves a
767
       costly int to float conversion, and storing the values as
768
       integers allows fast sign-flipping. */
769
    static const int fval_tab[16] = {
770
        0x00000000, 0x3f800000, 0x40000000, 0x40400000,
771
        0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
772
        0x41000000, 0x41100000, 0x41200000, 0x41300000,
773
        0x41400000, 0x41500000, 0x41600000, 0x41700000,
774
    };
775
    int vlctable;
776
    VLC* vlc;
777
    WMAProChannelCtx* ci = &s->channel[c];
778
    int rl_mode = 0;
779
    int cur_coeff = 0;
780
    int num_zeros = 0;
781
    const uint16_t* run;
782
    const float* level;
783

    
784
    av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
785

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

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

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

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

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

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

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

    
859
    return 0;
860
}
861

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

    
871
    /** should never consume more than 5344 bits
872
     *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
873
     */
874

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

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

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

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

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

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

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

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

    
952
    }
953
    return 0;
954
}
955

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

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

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

    
985
                        for (ch = ch_data; ch < ch_end; ch++)
986
                            *data_ptr++ = (*ch)[y];
987

    
988
                        for (ch = ch_data; ch < ch_end; ch++) {
989
                            float sum = 0;
990
                            data_ptr = data;
991
                            while (data_ptr < data_end)
992
                                sum += *data_ptr++ * *mat++;
993

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

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

    
1024
        if (s->subframe_len < winlen) {
1025
            start += (winlen - s->subframe_len) >> 1;
1026
            winlen = s->subframe_len;
1027
        }
1028

    
1029
        window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1030

    
1031
        winlen >>= 1;
1032

    
1033
        s->dsp.vector_fmul_window(start, start, start + winlen,
1034
                                  window, winlen);
1035

    
1036
        s->channel[c].prev_block_len = s->subframe_len;
1037
    }
1038
}
1039

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

    
1054
    s->subframe_offset = get_bits_count(&s->gb);
1055

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

    
1069
    av_dlog(s->avctx,
1070
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1071

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

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

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

    
1095

    
1096
    av_dlog(s->avctx, "subframe is part of %i channels\n",
1097
            s->channels_for_cur_subframe);
1098

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

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

    
1109
        s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
1110
                                                  + offset];
1111
    }
1112

    
1113
    s->subframe_len = subframe_len;
1114
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1115

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

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

    
1130
            skip_bits_long(&s->gb, num_fill_bits);
1131
        }
1132
    }
1133

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

    
1140

    
1141
    if (decode_channel_transform(s) < 0)
1142
        return AVERROR_INVALIDDATA;
1143

    
1144

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

    
1151
    if (transmit_coeffs) {
1152
        int step;
1153
        int quant_step = 90 * s->bits_per_sample >> 4;
1154

    
1155
        /** decode number of vector coded coefficients */
1156
        if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1157
            int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1158
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1159
                int c = s->channel_indexes_for_cur_subframe[i];
1160
                s->channel[c].num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1161
            }
1162
        } else {
1163
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1164
                int c = s->channel_indexes_for_cur_subframe[i];
1165
                s->channel[c].num_vec_coeffs = s->subframe_len;
1166
            }
1167
        }
1168
        /** decode quantization step */
1169
        step = get_sbits(&s->gb, 6);
1170
        quant_step += step;
1171
        if (step == -32 || step == 31) {
1172
            const int sign = (step == 31) - 1;
1173
            int quant = 0;
1174
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1175
                   (step = get_bits(&s->gb, 5)) == 31) {
1176
                quant += 31;
1177
            }
1178
            quant_step += ((quant + step) ^ sign) - sign;
1179
        }
1180
        if (quant_step < 0) {
1181
            av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1182
        }
1183

    
1184
        /** decode quantization step modifiers for every channel */
1185

    
1186
        if (s->channels_for_cur_subframe == 1) {
1187
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1188
        } else {
1189
            int modifier_len = get_bits(&s->gb, 3);
1190
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1191
                int c = s->channel_indexes_for_cur_subframe[i];
1192
                s->channel[c].quant_step = quant_step;
1193
                if (get_bits1(&s->gb)) {
1194
                    if (modifier_len) {
1195
                        s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1196
                    } else
1197
                        ++s->channel[c].quant_step;
1198
                }
1199
            }
1200
        }
1201

    
1202
        /** decode scale factors */
1203
        if (decode_scale_factors(s) < 0)
1204
            return AVERROR_INVALIDDATA;
1205
    }
1206

    
1207
    av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1208
            get_bits_count(&s->gb) - s->subframe_offset);
1209

    
1210
    /** parse coefficients */
1211
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1212
        int c = s->channel_indexes_for_cur_subframe[i];
1213
        if (s->channel[c].transmit_coefs &&
1214
            get_bits_count(&s->gb) < s->num_saved_bits) {
1215
            decode_coeffs(s, c);
1216
        } else
1217
            memset(s->channel[c].coeffs, 0,
1218
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1219
    }
1220

    
1221
    av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1222
            get_bits_count(&s->gb) - s->subframe_offset);
1223

    
1224
    if (transmit_coeffs) {
1225
        FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1226
        /** reconstruct the per channel data */
1227
        inverse_channel_transform(s);
1228
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
1229
            int c = s->channel_indexes_for_cur_subframe[i];
1230
            const int* sf = s->channel[c].scale_factors;
1231
            int b;
1232

    
1233
            if (c == s->lfe_channel)
1234
                memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1235
                       (subframe_len - cur_subwoofer_cutoff));
1236

    
1237
            /** inverse quantization and rescaling */
1238
            for (b = 0; b < s->num_bands; b++) {
1239
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1240
                const int exp = s->channel[c].quant_step -
1241
                            (s->channel[c].max_scale_factor - *sf++) *
1242
                            s->channel[c].scale_factor_step;
1243
                const float quant = pow(10.0, exp / 20.0);
1244
                int start = s->cur_sfb_offsets[b];
1245
                s->dsp.vector_fmul_scalar(s->tmp + start,
1246
                                          s->channel[c].coeffs + start,
1247
                                          quant, end - start);
1248
            }
1249

    
1250
            /** apply imdct (imdct_half == DCTIV with reverse) */
1251
            mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1252
        }
1253
    }
1254

    
1255
    /** window and overlapp-add */
1256
    wmapro_window(s);
1257

    
1258
    /** handled one subframe */
1259
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1260
        int c = s->channel_indexes_for_cur_subframe[i];
1261
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1262
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1263
            return AVERROR_INVALIDDATA;
1264
        }
1265
        ++s->channel[c].cur_subframe;
1266
    }
1267

    
1268
    return 0;
1269
}
1270

    
1271
/**
1272
 *@brief Decode one WMA frame.
1273
 *@param s codec context
1274
 *@return 0 if the trailer bit indicates that this is the last frame,
1275
 *        1 if there are additional frames
1276
 */
1277
static int decode_frame(WMAProDecodeCtx *s)
1278
{
1279
    GetBitContext* gb = &s->gb;
1280
    int more_frames = 0;
1281
    int len = 0;
1282
    int i;
1283

    
1284
    /** check for potential output buffer overflow */
1285
    if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1286
        /** return an error if no frame could be decoded at all */
1287
        av_log(s->avctx, AV_LOG_ERROR,
1288
               "not enough space for the output samples\n");
1289
        s->packet_loss = 1;
1290
        return 0;
1291
    }
1292

    
1293
    /** get frame length */
1294
    if (s->len_prefix)
1295
        len = get_bits(gb, s->log2_frame_size);
1296

    
1297
    av_dlog(s->avctx, "decoding frame with length %x\n", len);
1298

    
1299
    /** decode tile information */
1300
    if (decode_tilehdr(s)) {
1301
        s->packet_loss = 1;
1302
        return 0;
1303
    }
1304

    
1305
    /** read postproc transform */
1306
    if (s->num_channels > 1 && get_bits1(gb)) {
1307
        if (get_bits1(gb)) {
1308
            for (i = 0; i < s->num_channels * s->num_channels; i++)
1309
                skip_bits(gb, 4);
1310
        }
1311
    }
1312

    
1313
    /** read drc info */
1314
    if (s->dynamic_range_compression) {
1315
        s->drc_gain = get_bits(gb, 8);
1316
        av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1317
    }
1318

    
1319
    /** no idea what these are for, might be the number of samples
1320
        that need to be skipped at the beginning or end of a stream */
1321
    if (get_bits1(gb)) {
1322
        int skip;
1323

    
1324
        /** usually true for the first frame */
1325
        if (get_bits1(gb)) {
1326
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1327
            av_dlog(s->avctx, "start skip: %i\n", skip);
1328
        }
1329

    
1330
        /** sometimes true for the last frame */
1331
        if (get_bits1(gb)) {
1332
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1333
            av_dlog(s->avctx, "end skip: %i\n", skip);
1334
        }
1335

    
1336
    }
1337

    
1338
    av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1339
            get_bits_count(gb) - s->frame_offset);
1340

    
1341
    /** reset subframe states */
1342
    s->parsed_all_subframes = 0;
1343
    for (i = 0; i < s->num_channels; i++) {
1344
        s->channel[i].decoded_samples = 0;
1345
        s->channel[i].cur_subframe    = 0;
1346
        s->channel[i].reuse_sf        = 0;
1347
    }
1348

    
1349
    /** decode all subframes */
1350
    while (!s->parsed_all_subframes) {
1351
        if (decode_subframe(s) < 0) {
1352
            s->packet_loss = 1;
1353
            return 0;
1354
        }
1355
    }
1356

    
1357
    /** interleave samples and write them to the output buffer */
1358
    for (i = 0; i < s->num_channels; i++) {
1359
        float* ptr  = s->samples + i;
1360
        int incr = s->num_channels;
1361
        float* iptr = s->channel[i].out;
1362
        float* iend = iptr + s->samples_per_frame;
1363

    
1364
        // FIXME should create/use a DSP function here
1365
        while (iptr < iend) {
1366
            *ptr = *iptr++;
1367
            ptr += incr;
1368
        }
1369

    
1370
        /** reuse second half of the IMDCT output for the next frame */
1371
        memcpy(&s->channel[i].out[0],
1372
               &s->channel[i].out[s->samples_per_frame],
1373
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1374
    }
1375

    
1376
    if (s->skip_frame) {
1377
        s->skip_frame = 0;
1378
    } else
1379
        s->samples += s->num_channels * s->samples_per_frame;
1380

    
1381
    if (s->len_prefix) {
1382
        if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1383
            /** FIXME: not sure if this is always an error */
1384
            av_log(s->avctx, AV_LOG_ERROR,
1385
                   "frame[%i] would have to skip %i bits\n", s->frame_num,
1386
                   len - (get_bits_count(gb) - s->frame_offset) - 1);
1387
            s->packet_loss = 1;
1388
            return 0;
1389
        }
1390

    
1391
        /** skip the rest of the frame data */
1392
        skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1393
    } else {
1394
        while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1395
        }
1396
    }
1397

    
1398
    /** decode trailer bit */
1399
    more_frames = get_bits1(gb);
1400

    
1401
    ++s->frame_num;
1402
    return more_frames;
1403
}
1404

    
1405
/**
1406
 *@brief Calculate remaining input buffer length.
1407
 *@param s codec context
1408
 *@param gb bitstream reader context
1409
 *@return remaining size in bits
1410
 */
1411
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1412
{
1413
    return s->buf_bit_size - get_bits_count(gb);
1414
}
1415

    
1416
/**
1417
 *@brief Fill the bit reservoir with a (partial) frame.
1418
 *@param s codec context
1419
 *@param gb bitstream reader context
1420
 *@param len length of the partial frame
1421
 *@param append decides wether to reset the buffer or not
1422
 */
1423
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1424
                      int append)
1425
{
1426
    int buflen;
1427

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

    
1432
    if (!append) {
1433
        s->frame_offset = get_bits_count(gb) & 7;
1434
        s->num_saved_bits = s->frame_offset;
1435
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1436
    }
1437

    
1438
    buflen = (s->num_saved_bits + len + 8) >> 3;
1439

    
1440
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1441
        av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1442
        s->packet_loss = 1;
1443
        return;
1444
    }
1445

    
1446
    s->num_saved_bits += len;
1447
    if (!append) {
1448
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1449
                     s->num_saved_bits);
1450
    } else {
1451
        int align = 8 - (get_bits_count(gb) & 7);
1452
        align = FFMIN(align, len);
1453
        put_bits(&s->pb, align, get_bits(gb, align));
1454
        len -= align;
1455
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1456
    }
1457
    skip_bits_long(gb, len);
1458

    
1459
    {
1460
        PutBitContext tmp = s->pb;
1461
        flush_put_bits(&tmp);
1462
    }
1463

    
1464
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1465
    skip_bits(&s->gb, s->frame_offset);
1466
}
1467

    
1468
/**
1469
 *@brief Decode a single WMA packet.
1470
 *@param avctx codec context
1471
 *@param data the output buffer
1472
 *@param data_size number of bytes that were written to the output buffer
1473
 *@param avpkt input packet
1474
 *@return number of bytes that were read from the input buffer
1475
 */
1476
static int decode_packet(AVCodecContext *avctx,
1477
                         void *data, int *data_size, AVPacket* avpkt)
1478
{
1479
    WMAProDecodeCtx *s = avctx->priv_data;
1480
    GetBitContext* gb  = &s->pgb;
1481
    const uint8_t* buf = avpkt->data;
1482
    int buf_size       = avpkt->size;
1483
    int num_bits_prev_frame;
1484
    int packet_sequence_number;
1485

    
1486
    s->samples       = data;
1487
    s->samples_end   = (float*)((int8_t*)data + *data_size);
1488
    *data_size = 0;
1489

    
1490
    if (s->packet_done || s->packet_loss) {
1491
        s->packet_done = 0;
1492

    
1493
        /** sanity check for the buffer length */
1494
        if (buf_size < avctx->block_align)
1495
            return 0;
1496

    
1497
        s->next_packet_start = buf_size - avctx->block_align;
1498
        buf_size = avctx->block_align;
1499
        s->buf_bit_size = buf_size << 3;
1500

    
1501
        /** parse packet header */
1502
        init_get_bits(gb, buf, s->buf_bit_size);
1503
        packet_sequence_number = get_bits(gb, 4);
1504
        skip_bits(gb, 2);
1505

    
1506
        /** get number of bits that need to be added to the previous frame */
1507
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1508
        av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1509
                num_bits_prev_frame);
1510

    
1511
        /** check for packet loss */
1512
        if (!s->packet_loss &&
1513
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1514
            s->packet_loss = 1;
1515
            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1516
                   s->packet_sequence_number, packet_sequence_number);
1517
        }
1518
        s->packet_sequence_number = packet_sequence_number;
1519

    
1520
        if (num_bits_prev_frame > 0) {
1521
            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1522
            if (num_bits_prev_frame >= remaining_packet_bits) {
1523
                num_bits_prev_frame = remaining_packet_bits;
1524
                s->packet_done = 1;
1525
            }
1526

    
1527
            /** append the previous frame data to the remaining data from the
1528
                previous packet to create a full frame */
1529
            save_bits(s, gb, num_bits_prev_frame, 1);
1530
            av_dlog(avctx, "accumulated %x bits of frame data\n",
1531
                    s->num_saved_bits - s->frame_offset);
1532

    
1533
            /** decode the cross packet frame if it is valid */
1534
            if (!s->packet_loss)
1535
                decode_frame(s);
1536
        } else if (s->num_saved_bits - s->frame_offset) {
1537
            av_dlog(avctx, "ignoring %x previously saved bits\n",
1538
                    s->num_saved_bits - s->frame_offset);
1539
        }
1540

    
1541
        if (s->packet_loss) {
1542
            /** reset number of saved bits so that the decoder
1543
                does not start to decode incomplete frames in the
1544
                s->len_prefix == 0 case */
1545
            s->num_saved_bits = 0;
1546
            s->packet_loss = 0;
1547
        }
1548

    
1549
    } else {
1550
        int frame_size;
1551
        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1552
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1553
        skip_bits(gb, s->packet_offset);
1554
        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1555
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1556
            frame_size <= remaining_bits(s, gb)) {
1557
            save_bits(s, gb, frame_size, 0);
1558
            s->packet_done = !decode_frame(s);
1559
        } else if (!s->len_prefix
1560
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
1561
            /** when the frames do not have a length prefix, we don't know
1562
                the compressed length of the individual frames
1563
                however, we know what part of a new packet belongs to the
1564
                previous frame
1565
                therefore we save the incoming packet first, then we append
1566
                the "previous frame" data from the next packet so that
1567
                we get a buffer that only contains full frames */
1568
            s->packet_done = !decode_frame(s);
1569
        } else
1570
            s->packet_done = 1;
1571
    }
1572

    
1573
    if (s->packet_done && !s->packet_loss &&
1574
        remaining_bits(s, gb) > 0) {
1575
        /** save the rest of the data so that it can be decoded
1576
            with the next packet */
1577
        save_bits(s, gb, remaining_bits(s, gb), 0);
1578
    }
1579

    
1580
    *data_size = (int8_t *)s->samples - (int8_t *)data;
1581
    s->packet_offset = get_bits_count(gb) & 7;
1582

    
1583
    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1584
}
1585

    
1586
/**
1587
 *@brief Clear decoder buffers (for seeking).
1588
 *@param avctx codec context
1589
 */
1590
static void flush(AVCodecContext *avctx)
1591
{
1592
    WMAProDecodeCtx *s = avctx->priv_data;
1593
    int i;
1594
    /** reset output buffer as a part of it is used during the windowing of a
1595
        new frame */
1596
    for (i = 0; i < s->num_channels; i++)
1597
        memset(s->channel[i].out, 0, s->samples_per_frame *
1598
               sizeof(*s->channel[i].out));
1599
    s->packet_loss = 1;
1600
}
1601

    
1602

    
1603
/**
1604
 *@brief wmapro decoder
1605
 */
1606
AVCodec ff_wmapro_decoder = {
1607
    "wmapro",
1608
    AVMEDIA_TYPE_AUDIO,
1609
    CODEC_ID_WMAPRO,
1610
    sizeof(WMAProDecodeCtx),
1611
    decode_init,
1612
    NULL,
1613
    decode_end,
1614
    decode_packet,
1615
    .capabilities = CODEC_CAP_SUBFRAMES,
1616
    .flush= flush,
1617
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1618
};