GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wmaprodec.c Lines: 594 870 68.3 %
Date: 2021-01-26 11:44:58 Branches: 338 564 59.9 %

Line Branch Exec Source
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 <inttypes.h>
90
91
#include "libavutil/ffmath.h"
92
#include "libavutil/float_dsp.h"
93
#include "libavutil/intfloat.h"
94
#include "libavutil/intreadwrite.h"
95
#include "libavutil/mem_internal.h"
96
97
#include "avcodec.h"
98
#include "internal.h"
99
#include "get_bits.h"
100
#include "put_bits.h"
101
#include "wmaprodata.h"
102
#include "sinewin.h"
103
#include "wma.h"
104
#include "wma_common.h"
105
106
/** current decoder limitations */
107
#define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
108
#define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
109
#define MAX_BANDS      29                                    ///< max number of scale factor bands
110
#define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
111
#define XMA_MAX_STREAMS         8
112
#define XMA_MAX_CHANNELS_STREAM 2
113
#define XMA_MAX_CHANNELS        (XMA_MAX_STREAMS * XMA_MAX_CHANNELS_STREAM)
114
115
#define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
116
#define WMAPRO_BLOCK_MAX_BITS 13                                           ///< log2 of max block size
117
#define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)                 ///< minimum block size
118
#define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
119
#define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
120
121
122
#define VLCBITS            9
123
#define SCALEVLCBITS       8
124
#define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
125
#define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
126
#define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
127
#define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
128
#define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
129
130
static VLC              sf_vlc;           ///< scale factor DPCM vlc
131
static VLC              sf_rl_vlc;        ///< scale factor run length vlc
132
static VLC              vec4_vlc;         ///< 4 coefficients per symbol
133
static VLC              vec2_vlc;         ///< 2 coefficients per symbol
134
static VLC              vec1_vlc;         ///< 1 coefficient per symbol
135
static VLC              coef_vlc[2];      ///< coefficient run length vlc codes
136
static float            sin64[33];        ///< sine table for decorrelation
137
138
/**
139
 * @brief frame specific decoder context for a single channel
140
 */
141
typedef struct WMAProChannelCtx {
142
    int16_t  prev_block_len;                          ///< length of the previous block
143
    uint8_t  transmit_coefs;
144
    uint8_t  num_subframes;
145
    uint16_t subframe_len[MAX_SUBFRAMES];             ///< subframe length in samples
146
    uint16_t subframe_offset[MAX_SUBFRAMES];          ///< subframe positions in the current frame
147
    uint8_t  cur_subframe;                            ///< current subframe number
148
    uint16_t decoded_samples;                         ///< number of already processed samples
149
    uint8_t  grouped;                                 ///< channel is part of a group
150
    int      quant_step;                              ///< quantization step for the current subframe
151
    int8_t   reuse_sf;                                ///< share scale factors between subframes
152
    int8_t   scale_factor_step;                       ///< scaling step for the current subframe
153
    int      max_scale_factor;                        ///< maximum scale factor for the current subframe
154
    int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
155
    int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
156
    int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
157
    uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
158
    float*   coeffs;                                  ///< pointer to the subframe decode buffer
159
    uint16_t num_vec_coeffs;                          ///< number of vector coded coefficients
160
    DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
161
} WMAProChannelCtx;
162
163
/**
164
 * @brief channel group for channel transformations
165
 */
166
typedef struct WMAProChannelGrp {
167
    uint8_t num_channels;                                     ///< number of channels in the group
168
    int8_t  transform;                                        ///< transform on / off
169
    int8_t  transform_band[MAX_BANDS];                        ///< controls if the transform is enabled for a certain band
170
    float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
171
    float*  channel_data[WMAPRO_MAX_CHANNELS];                ///< transformation coefficients
172
} WMAProChannelGrp;
173
174
/**
175
 * @brief main decoder context
176
 */
177
typedef struct WMAProDecodeCtx {
178
    /* generic decoder variables */
179
    AVCodecContext*  avctx;                         ///< codec context for av_log
180
    AVFloatDSPContext *fdsp;
181
    uint8_t          frame_data[MAX_FRAMESIZE +
182
                      AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
183
    PutBitContext    pb;                            ///< context for filling the frame_data buffer
184
    FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
185
    DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
186
    const float*     windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
187
188
    /* frame size dependent frame information (set during initialization) */
189
    uint32_t         decode_flags;                  ///< used compression features
190
    uint8_t          len_prefix;                    ///< frame is prefixed with its length
191
    uint8_t          dynamic_range_compression;     ///< frame contains DRC data
192
    uint8_t          bits_per_sample;               ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
193
    uint16_t         samples_per_frame;             ///< number of samples to output
194
    uint16_t         log2_frame_size;
195
    int8_t           lfe_channel;                   ///< lfe channel index
196
    uint8_t          max_num_subframes;
197
    uint8_t          subframe_len_bits;             ///< number of bits used for the subframe length
198
    uint8_t          max_subframe_len_bit;          ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
199
    uint16_t         min_samples_per_subframe;
200
    int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   ///< scale factor bands per block size
201
    int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    ///< scale factor band offsets (multiples of 4)
202
    int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
203
    int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
204
205
    /* packet decode state */
206
    GetBitContext    pgb;                           ///< bitstream reader context for the packet
207
    int              next_packet_start;             ///< start offset of the next wma packet in the demuxer packet
208
    uint8_t          packet_offset;                 ///< frame offset in the packet
209
    uint8_t          packet_sequence_number;        ///< current packet number
210
    int              num_saved_bits;                ///< saved number of bits
211
    int              frame_offset;                  ///< frame offset in the bit reservoir
212
    int              subframe_offset;               ///< subframe offset in the bit reservoir
213
    uint8_t          packet_loss;                   ///< set in case of bitstream error
214
    uint8_t          packet_done;                   ///< set when a packet is fully decoded
215
    uint8_t          eof_done;                      ///< set when EOF reached and extra subframe is written (XMA1/2)
216
217
    /* frame decode state */
218
    uint32_t         frame_num;                     ///< current frame number (not used for decoding)
219
    GetBitContext    gb;                            ///< bitstream reader context
220
    int              buf_bit_size;                  ///< buffer size in bits
221
    uint8_t          drc_gain;                      ///< gain for the DRC tool
222
    int8_t           skip_frame;                    ///< skip output step
223
    int8_t           parsed_all_subframes;          ///< all subframes decoded?
224
    uint8_t          skip_packets;                  ///< packets to skip to find next packet in a stream (XMA1/2)
225
226
    /* subframe/block decode state */
227
    int16_t          subframe_len;                  ///< current subframe length
228
    int8_t           nb_channels;                   ///< number of channels in stream (XMA1/2)
229
    int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
230
    int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
231
    int8_t           num_bands;                     ///< number of scale factor bands
232
    int8_t           transmit_num_vec_coeffs;       ///< number of vector coded coefficients is part of the bitstream
233
    int16_t*         cur_sfb_offsets;               ///< sfb offsets for the current block
234
    uint8_t          table_idx;                     ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
235
    int8_t           esc_len;                       ///< length of escaped coefficients
236
237
    uint8_t          num_chgroups;                  ///< number of channel groups
238
    WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  ///< channel group information
239
240
    WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
241
} WMAProDecodeCtx;
242
243
typedef struct XMADecodeCtx {
244
    WMAProDecodeCtx xma[XMA_MAX_STREAMS];
245
    AVFrame *frames[XMA_MAX_STREAMS];
246
    int current_stream;
247
    int num_streams;
248
    float samples[XMA_MAX_CHANNELS][512 * 64];
249
    int offset[XMA_MAX_STREAMS];
250
    int start_channel[XMA_MAX_STREAMS];
251
} XMADecodeCtx;
252
253
/**
254
 *@brief helper function to print the most important members of the context
255
 *@param s context
256
 */
257
static av_cold void dump_context(WMAProDecodeCtx *s)
258
{
259
#define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
260
#define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
261
262
    PRINT("ed sample bit depth", s->bits_per_sample);
263
    PRINT_HEX("ed decode flags", s->decode_flags);
264
    PRINT("samples per frame",   s->samples_per_frame);
265
    PRINT("log2 frame size",     s->log2_frame_size);
266
    PRINT("max num subframes",   s->max_num_subframes);
267
    PRINT("len prefix",          s->len_prefix);
268
    PRINT("num channels",        s->nb_channels);
269
}
270
271
/**
272
 *@brief Uninitialize the decoder and free all resources.
273
 *@param avctx codec context
274
 *@return 0 on success, < 0 otherwise
275
 */
276
8
static av_cold int decode_end(WMAProDecodeCtx *s)
277
{
278
    int i;
279
280
8
    av_freep(&s->fdsp);
281
282
72
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
283
64
        ff_mdct_end(&s->mdct_ctx[i]);
284
285
8
    return 0;
286
}
287
288
8
static av_cold int wmapro_decode_end(AVCodecContext *avctx)
289
{
290
8
    WMAProDecodeCtx *s = avctx->priv_data;
291
292
8
    decode_end(s);
293
294
8
    return 0;
295
}
296
297
40
static av_cold int get_rate(AVCodecContext *avctx)
298
{
299
40
    if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
300
        if (avctx->sample_rate > 44100)
301
            return 48000;
302
        else if (avctx->sample_rate > 32000)
303
            return 44100;
304
        else if (avctx->sample_rate > 24000)
305
            return 32000;
306
        return 24000;
307
    }
308
309
40
    return avctx->sample_rate;
310
}
311
312
/**
313
 *@brief Initialize the decoder.
314
 *@param avctx codec context
315
 *@return 0 on success, -1 otherwise
316
 */
317
8
static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
318
{
319
8
    uint8_t *edata_ptr = avctx->extradata;
320
    unsigned int channel_mask;
321
    int i, bits;
322
    int log2_max_num_subframes;
323
    int num_possible_block_sizes;
324
325

8
    if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
326
        avctx->block_align = 2048;
327
328
8
    if (!avctx->block_align) {
329
        av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
330
        return AVERROR(EINVAL);
331
    }
332
333
8
    s->avctx = avctx;
334
335
8
    init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
336
337
8
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
338
339
    /** dump the extradata */
340
8
    av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
341
152
    for (i = 0; i < avctx->extradata_size; i++)
342
144
        av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
343
8
    av_log(avctx, AV_LOG_DEBUG, "\n");
344
345

8
    if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
346
        s->decode_flags    = 0x10d6;
347
        s->bits_per_sample = 16;
348
        channel_mask       = 0; //AV_RL32(edata_ptr+2); /* not always in expected order */
349
        if ((num_stream+1) * XMA_MAX_CHANNELS_STREAM > avctx->channels) /* stream config is 2ch + 2ch + ... + 1/2ch */
350
            s->nb_channels = 1;
351
        else
352
            s->nb_channels = 2;
353
8
    } else if (avctx->codec_id == AV_CODEC_ID_XMA2) { /* XMA2WAVEFORMAT */
354
        s->decode_flags    = 0x10d6;
355
        s->bits_per_sample = 16;
356
        channel_mask       = 0; /* would need to aggregate from all streams */
357
        s->nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0]; /* nth stream config */
358
8
    } else if (avctx->codec_id == AV_CODEC_ID_XMA1) { /* XMAWAVEFORMAT */
359
        s->decode_flags    = 0x10d6;
360
        s->bits_per_sample = 16;
361
        channel_mask       = 0; /* would need to aggregate from all streams */
362
        s->nb_channels     = edata_ptr[8 + 20*num_stream + 17]; /* nth stream config */
363

8
    } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
364
8
        s->decode_flags    = AV_RL16(edata_ptr+14);
365
8
        channel_mask       = AV_RL32(edata_ptr+2);
366
8
        s->bits_per_sample = AV_RL16(edata_ptr);
367
8
        s->nb_channels     = avctx->channels;
368
369

8
        if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
370
            avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
371
            return AVERROR_PATCHWELCOME;
372
        }
373
    } else {
374
        avpriv_request_sample(avctx, "Unknown extradata size");
375
        return AVERROR_PATCHWELCOME;
376
    }
377
378
    /** generic init */
379
8
    s->log2_frame_size = av_log2(avctx->block_align) + 4;
380
8
    if (s->log2_frame_size > 25) {
381
        avpriv_request_sample(avctx, "Large block align");
382
        return AVERROR_PATCHWELCOME;
383
    }
384
385
    /** frame info */
386
8
    if (avctx->codec_id != AV_CODEC_ID_WMAPRO)
387
        s->skip_frame = 0;
388
    else
389
8
        s->skip_frame = 1; /* skip first frame */
390
391
8
    s->packet_loss = 1;
392
8
    s->len_prefix  = (s->decode_flags & 0x40);
393
394
    /** get frame len */
395
8
    if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
396
8
        bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
397
8
        if (bits > WMAPRO_BLOCK_MAX_BITS) {
398
            avpriv_request_sample(avctx, "14-bit block sizes");
399
            return AVERROR_PATCHWELCOME;
400
        }
401
8
        s->samples_per_frame = 1 << bits;
402
    } else {
403
        s->samples_per_frame = 512;
404
    }
405
406
    /** subframe info */
407
8
    log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
408
8
    s->max_num_subframes         = 1 << log2_max_num_subframes;
409

8
    if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
410
8
        s->max_subframe_len_bit = 1;
411
8
    s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
412
413
8
    num_possible_block_sizes     = log2_max_num_subframes + 1;
414
8
    s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
415
8
    s->dynamic_range_compression = (s->decode_flags & 0x80);
416
417
8
    if (s->max_num_subframes > MAX_SUBFRAMES) {
418
        av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
419
               s->max_num_subframes);
420
        return AVERROR_INVALIDDATA;
421
    }
422
423
8
    if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
424
        av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
425
               s->min_samples_per_subframe);
426
        return AVERROR_INVALIDDATA;
427
    }
428
429
8
    if (s->avctx->sample_rate <= 0) {
430
        av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
431
        return AVERROR_INVALIDDATA;
432
    }
433
434
8
    if (s->nb_channels <= 0) {
435
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
436
               s->nb_channels);
437
        return AVERROR_INVALIDDATA;
438

8
    } else if (avctx->codec_id != AV_CODEC_ID_WMAPRO && s->nb_channels > XMA_MAX_CHANNELS_STREAM) {
439
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels per XMA stream %d\n",
440
               s->nb_channels);
441
        return AVERROR_INVALIDDATA;
442

8
    } else if (s->nb_channels > WMAPRO_MAX_CHANNELS || s->nb_channels > avctx->channels) {
443
        avpriv_request_sample(avctx,
444
                              "More than %d channels", WMAPRO_MAX_CHANNELS);
445
        return AVERROR_PATCHWELCOME;
446
    }
447
448
    /** init previous block len */
449
32
    for (i = 0; i < s->nb_channels; i++)
450
24
        s->channel[i].prev_block_len = s->samples_per_frame;
451
452
    /** extract lfe channel position */
453
8
    s->lfe_channel = -1;
454
455
8
    if (channel_mask & 8) {
456
        unsigned int mask;
457
10
        for (mask = 1; mask < 16; mask <<= 1) {
458
8
            if (channel_mask & mask)
459
8
                ++s->lfe_channel;
460
        }
461
    }
462
463
8
    INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
464
                    scale_huffbits, 1, 1,
465
                    scale_huffcodes, 2, 2, 616);
466
467
8
    INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
468
                    scale_rl_huffbits, 1, 1,
469
                    scale_rl_huffcodes, 4, 4, 1406);
470
471
8
    INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
472
                    coef0_huffbits, 1, 1,
473
                    coef0_huffcodes, 4, 4, 2108);
474
475
8
    INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
476
                    coef1_huffbits, 1, 1,
477
                    coef1_huffcodes, 4, 4, 3912);
478
479
8
    INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
480
                    vec4_huffbits, 1, 1,
481
                    vec4_huffcodes, 2, 2, 604);
482
483
8
    INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
484
                    vec2_huffbits, 1, 1,
485
                    vec2_huffcodes, 2, 2, 562);
486
487
8
    INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
488
                    vec1_huffbits, 1, 1,
489
                    vec1_huffcodes, 2, 2, 562);
490
491
    /** calculate number of scale factor bands and their offsets
492
        for every possible block size */
493
48
    for (i = 0; i < num_possible_block_sizes; i++) {
494
40
        int subframe_len = s->samples_per_frame >> i;
495
        int x;
496
40
        int band = 1;
497
40
        int rate = get_rate(avctx);
498
499
40
        s->sfb_offsets[i][0] = 0;
500
501

1040
        for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
502
1040
            int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
503
1040
            offset &= ~3;
504
1040
            if (offset > s->sfb_offsets[i][band - 1])
505
860
                s->sfb_offsets[i][band++] = offset;
506
507
1040
            if (offset >= subframe_len)
508
40
                break;
509
        }
510
40
        s->sfb_offsets[i][band - 1] = subframe_len;
511
40
        s->num_sfb[i]               = band - 1;
512
40
        if (s->num_sfb[i] <= 0) {
513
            av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
514
            return AVERROR_INVALIDDATA;
515
        }
516
    }
517
518
519
    /** Scale factors can be shared between blocks of different size
520
        as every block has a different scale factor band layout.
521
        The matrix sf_offsets is needed to find the correct scale factor.
522
     */
523
524
48
    for (i = 0; i < num_possible_block_sizes; i++) {
525
        int b;
526
900
        for (b = 0; b < s->num_sfb[i]; b++) {
527
            int x;
528
860
            int offset = ((s->sfb_offsets[i][b]
529
860
                           + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
530
5160
            for (x = 0; x < num_possible_block_sizes; x++) {
531
4300
                int v = 0;
532
48176
                while (s->sfb_offsets[x][v + 1] << x < offset) {
533
43876
                    v++;
534
43876
                    av_assert0(v < MAX_BANDS);
535
                }
536
4300
                s->sf_offsets[i][x][b] = v;
537
            }
538
        }
539
    }
540
541
8
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
542
8
    if (!s->fdsp)
543
        return AVERROR(ENOMEM);
544
545
    /** init MDCT, FIXME: only init needed sizes */
546
72
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
547
64
        ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
548
64
                     1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
549
64
                     / (1ll << (s->bits_per_sample - 1)));
550
551
    /** init MDCT windows: simple sine window */
552
72
    for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
553
64
        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
554
64
        ff_init_ff_sine_windows(win_idx);
555
64
        s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
556
    }
557
558
    /** calculate subwoofer cutoff values */
559
48
    for (i = 0; i < num_possible_block_sizes; i++) {
560
40
        int block_size = s->samples_per_frame >> i;
561
40
        int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
562
40
                     / s->avctx->sample_rate;
563
40
        s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
564
    }
565
566
    /** calculate sine values for the decorrelation matrix */
567
272
    for (i = 0; i < 33; i++)
568
264
        sin64[i] = sin(i*M_PI / 64.0);
569
570
8
    if (avctx->debug & FF_DEBUG_BITSTREAM)
571
        dump_context(s);
572
573
8
    avctx->channel_layout = channel_mask;
574
575
8
    return 0;
576
}
577
578
/**
579
 *@brief Initialize the decoder.
580
 *@param avctx codec context
581
 *@return 0 on success, -1 otherwise
582
 */
583
8
static av_cold int wmapro_decode_init(AVCodecContext *avctx)
584
{
585
8
    WMAProDecodeCtx *s = avctx->priv_data;
586
587
8
    return decode_init(s, avctx, 0);
588
}
589
590
/**
591
 *@brief Decode the subframe length.
592
 *@param s context
593
 *@param offset sample offset in the frame
594
 *@return decoded subframe length on success, < 0 in case of an error
595
 */
596
527
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
597
{
598
527
    int frame_len_shift = 0;
599
    int subframe_len;
600
601
    /** no need to read from the bitstream when only one length is possible */
602
527
    if (offset == s->samples_per_frame - s->min_samples_per_subframe)
603
9
        return s->min_samples_per_subframe;
604
605
518
    if (get_bits_left(&s->gb) < 1)
606
        return AVERROR_INVALIDDATA;
607
608
    /** 1 bit indicates if the subframe is of maximum length */
609
518
    if (s->max_subframe_len_bit) {
610
518
        if (get_bits1(&s->gb))
611
279
            frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
612
    } else
613
        frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
614
615
518
    subframe_len = s->samples_per_frame >> frame_len_shift;
616
617
    /** sanity check the length */
618
518
    if (subframe_len < s->min_samples_per_subframe ||
619
518
        subframe_len > s->samples_per_frame) {
620
        av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
621
               subframe_len);
622
        return AVERROR_INVALIDDATA;
623
    }
624
518
    return subframe_len;
625
}
626
627
/**
628
 *@brief Decode how the data in the frame is split into subframes.
629
 *       Every WMA frame contains the encoded data for a fixed number of
630
 *       samples per channel. The data for every channel might be split
631
 *       into several subframes. This function will reconstruct the list of
632
 *       subframes for every channel.
633
 *
634
 *       If the subframes are not evenly split, the algorithm estimates the
635
 *       channels with the lowest number of total samples.
636
 *       Afterwards, for each of these channels a bit is read from the
637
 *       bitstream that indicates if the channel contains a subframe with the
638
 *       next subframe size that is going to be read from the bitstream or not.
639
 *       If a channel contains such a subframe, the subframe size gets added to
640
 *       the channel's subframe list.
641
 *       The algorithm repeats these steps until the frame is properly divided
642
 *       between the individual channels.
643
 *
644
 *@param s context
645
 *@return 0 on success, < 0 in case of an error
646
 */
647
257
static int decode_tilehdr(WMAProDecodeCtx *s)
648
{
649
257
    uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
650
    uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
651
257
    int channels_for_cur_subframe = s->nb_channels;   /**< number of channels that contain the current subframe */
652
257
    int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subframe offsets and sizes */
653
257
    int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
654
    int c;
655
656
    /* Should never consume more than 3073 bits (256 iterations for the
657
     * while loop when always the minimum amount of 128 samples is subtracted
658
     * from missing samples in the 8 channel case).
659
     * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
660
     */
661
662
    /** reset tiling information */
663
1183
    for (c = 0; c < s->nb_channels; c++)
664
926
        s->channel[c].num_subframes = 0;
665
666

257
    if (s->max_num_subframes == 1 || get_bits1(&s->gb))
667
225
        fixed_channel_layout = 1;
668
669
    /** loop until the frame data is split between the subframes */
670
    do {
671
        int subframe_len;
672
673
        /** check which channels contain the subframe */
674
2813
        for (c = 0; c < s->nb_channels; c++) {
675
2286
            if (num_samples[c] == min_channel_len) {
676

1277
                if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
677
224
                   (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
678
1053
                    contains_subframe[c] = 1;
679
                else
680
224
                    contains_subframe[c] = get_bits1(&s->gb);
681
            } else
682
1009
                contains_subframe[c] = 0;
683
        }
684
685
        /** get subframe length, subframe_len == 0 is not allowed */
686
527
        if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
687
            return AVERROR_INVALIDDATA;
688
689
        /** add subframes to the individual channels and find new min_channel_len */
690
527
        min_channel_len += subframe_len;
691
2813
        for (c = 0; c < s->nb_channels; c++) {
692
2286
            WMAProChannelCtx* chan = &s->channel[c];
693
694
2286
            if (contains_subframe[c]) {
695
1234
                if (chan->num_subframes >= MAX_SUBFRAMES) {
696
                    av_log(s->avctx, AV_LOG_ERROR,
697
                           "broken frame: num subframes > 31\n");
698
                    return AVERROR_INVALIDDATA;
699
                }
700
1234
                chan->subframe_len[chan->num_subframes] = subframe_len;
701
1234
                num_samples[c] += subframe_len;
702
1234
                ++chan->num_subframes;
703
1234
                if (num_samples[c] > s->samples_per_frame) {
704
                    av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
705
                           "channel len > samples_per_frame\n");
706
                    return AVERROR_INVALIDDATA;
707
                }
708
1052
            } else if (num_samples[c] <= min_channel_len) {
709
211
                if (num_samples[c] < min_channel_len) {
710
43
                    channels_for_cur_subframe = 0;
711
43
                    min_channel_len = num_samples[c];
712
                }
713
211
                ++channels_for_cur_subframe;
714
            }
715
        }
716
527
    } while (min_channel_len < s->samples_per_frame);
717
718
1183
    for (c = 0; c < s->nb_channels; c++) {
719
        int i;
720
926
        int offset = 0;
721
2160
        for (i = 0; i < s->channel[c].num_subframes; i++) {
722
            ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]"
723
                    " len %i\n", s->frame_num, c, i,
724
                    s->channel[c].subframe_len[i]);
725
1234
            s->channel[c].subframe_offset[i] = offset;
726
1234
            offset += s->channel[c].subframe_len[i];
727
        }
728
    }
729
730
257
    return 0;
731
}
732
733
/**
734
 *@brief Calculate a decorrelation matrix from the bitstream parameters.
735
 *@param s codec context
736
 *@param chgroup channel group for which the matrix needs to be calculated
737
 */
738
79
static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
739
                                        WMAProChannelGrp *chgroup)
740
{
741
    int i;
742
79
    int offset = 0;
743
    int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
744
79
    memset(chgroup->decorrelation_matrix, 0, s->nb_channels *
745
79
           s->nb_channels * sizeof(*chgroup->decorrelation_matrix));
746
747
316
    for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
748
237
        rotation_offset[i] = get_bits(&s->gb, 6);
749
750
316
    for (i = 0; i < chgroup->num_channels; i++)
751
237
        chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
752
237
            get_bits1(&s->gb) ? 1.0 : -1.0;
753
754
237
    for (i = 1; i < chgroup->num_channels; i++) {
755
        int x;
756
395
        for (x = 0; x < i; x++) {
757
            int y;
758
869
            for (y = 0; y < i + 1; y++) {
759
632
                float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
760
632
                float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
761
632
                int n = rotation_offset[offset + x];
762
                float sinv;
763
                float cosv;
764
765
632
                if (n < 32) {
766
442
                    sinv = sin64[n];
767
442
                    cosv = sin64[32 - n];
768
                } else {
769
190
                    sinv =  sin64[64 -  n];
770
190
                    cosv = -sin64[n  - 32];
771
                }
772
773
632
                chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
774
632
                                               (v1 * sinv) - (v2 * cosv);
775
632
                chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
776
632
                                               (v1 * cosv) + (v2 * sinv);
777
            }
778
        }
779
158
        offset += i;
780
    }
781
79
}
782
783
/**
784
 *@brief Decode channel transformation parameters
785
 *@param s codec context
786
 *@return >= 0 in case of success, < 0 in case of bitstream errors
787
 */
788
527
static int decode_channel_transform(WMAProDecodeCtx* s)
789
{
790
    int i;
791
    /* should never consume more than 1921 bits for the 8 channel case
792
     * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
793
     * + MAX_CHANNELS + MAX_BANDS + 1)
794
     */
795
796
    /** in the one channel case channel transforms are pointless */
797
527
    s->num_chgroups = 0;
798
527
    if (s->nb_channels > 1) {
799
527
        int remaining_channels = s->channels_for_cur_subframe;
800
801
527
        if (get_bits1(&s->gb)) {
802
            avpriv_request_sample(s->avctx,
803
                                  "Channel transform bit");
804
            return AVERROR_PATCHWELCOME;
805
        }
806
807
1156
        for (s->num_chgroups = 0; remaining_channels &&
808
629
             s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
809
629
            WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
810
629
            float** channel_data = chgroup->channel_data;
811
629
            chgroup->num_channels = 0;
812
629
            chgroup->transform = 0;
813
814
            /** decode channel mask */
815
629
            if (remaining_channels > 2) {
816
1217
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
817
1035
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
818
1035
                    if (!s->channel[channel_idx].grouped
819
819
                        && get_bits1(&s->gb)) {
820
536
                        ++chgroup->num_channels;
821
536
                        s->channel[channel_idx].grouped = 1;
822
536
                        *channel_data++ = s->channel[channel_idx].coeffs;
823
                    }
824
                }
825
            } else {
826
447
                chgroup->num_channels = remaining_channels;
827
1222
                for (i = 0; i < s->channels_for_cur_subframe; i++) {
828
775
                    int channel_idx = s->channel_indexes_for_cur_subframe[i];
829
775
                    if (!s->channel[channel_idx].grouped)
830
698
                        *channel_data++ = s->channel[channel_idx].coeffs;
831
775
                    s->channel[channel_idx].grouped = 1;
832
                }
833
            }
834
835
            /** decode transform type */
836
629
            if (chgroup->num_channels == 2) {
837
276
                if (get_bits1(&s->gb)) {
838
38
                    if (get_bits1(&s->gb)) {
839
                        avpriv_request_sample(s->avctx,
840
                                              "Unknown channel transform type");
841
                        return AVERROR_PATCHWELCOME;
842
                    }
843
                } else {
844
238
                    chgroup->transform = 1;
845
238
                    if (s->nb_channels == 2) {
846
215
                        chgroup->decorrelation_matrix[0] =  1.0;
847
215
                        chgroup->decorrelation_matrix[1] = -1.0;
848
215
                        chgroup->decorrelation_matrix[2] =  1.0;
849
215
                        chgroup->decorrelation_matrix[3] =  1.0;
850
                    } else {
851
                        /** cos(pi/4) */
852
23
                        chgroup->decorrelation_matrix[0] =  0.70703125;
853
23
                        chgroup->decorrelation_matrix[1] = -0.70703125;
854
23
                        chgroup->decorrelation_matrix[2] =  0.70703125;
855
23
                        chgroup->decorrelation_matrix[3] =  0.70703125;
856
                    }
857
                }
858
353
            } else if (chgroup->num_channels > 2) {
859
157
                if (get_bits1(&s->gb)) {
860
79
                    chgroup->transform = 1;
861
79
                    if (get_bits1(&s->gb)) {
862
79
                        decode_decorrelation_matrix(s, chgroup);
863
                    } else {
864
                        /** FIXME: more than 6 coupled channels not supported */
865
                        if (chgroup->num_channels > 6) {
866
                            avpriv_request_sample(s->avctx,
867
                                                  "Coupled channels > 6");
868
                        } else {
869
                            memcpy(chgroup->decorrelation_matrix,
870
                                   default_decorrelation[chgroup->num_channels],
871
                                   chgroup->num_channels * chgroup->num_channels *
872
                                   sizeof(*chgroup->decorrelation_matrix));
873
                        }
874
                    }
875
                }
876
            }
877
878
            /** decode transform on / off */
879
629
            if (chgroup->transform) {
880
317
                if (!get_bits1(&s->gb)) {
881
                    int i;
882
                    /** transform can be enabled for individual bands */
883
                    for (i = 0; i < s->num_bands; i++) {
884
                        chgroup->transform_band[i] = get_bits1(&s->gb);
885
                    }
886
                } else {
887
317
                    memset(chgroup->transform_band, 1, s->num_bands);
888
                }
889
            }
890
629
            remaining_channels -= chgroup->num_channels;
891
        }
892
    }
893
527
    return 0;
894
}
895
896
/**
897
 *@brief Extract the coefficients from the bitstream.
898
 *@param s codec context
899
 *@param c current channel number
900
 *@return 0 on success, < 0 in case of bitstream errors
901
 */
902
1038
static int decode_coeffs(WMAProDecodeCtx *s, int c)
903
{
904
    /* Integers 0..15 as single-precision floats.  The table saves a
905
       costly int to float conversion, and storing the values as
906
       integers allows fast sign-flipping. */
907
    static const uint32_t fval_tab[16] = {
908
        0x00000000, 0x3f800000, 0x40000000, 0x40400000,
909
        0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
910
        0x41000000, 0x41100000, 0x41200000, 0x41300000,
911
        0x41400000, 0x41500000, 0x41600000, 0x41700000,
912
    };
913
    int vlctable;
914
    VLC* vlc;
915
1038
    WMAProChannelCtx* ci = &s->channel[c];
916
1038
    int rl_mode = 0;
917
1038
    int cur_coeff = 0;
918
1038
    int num_zeros = 0;
919
    const uint16_t* run;
920
    const float* level;
921
922
    ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
923
924
1038
    vlctable = get_bits1(&s->gb);
925
1038
    vlc = &coef_vlc[vlctable];
926
927
1038
    if (vlctable) {
928
321
        run = coef1_run;
929
321
        level = coef1_level;
930
    } else {
931
717
        run = coef0_run;
932
717
        level = coef0_level;
933
    }
934
935
    /** decode vector coefficients (consumes up to 167 bits per iteration for
936
      4 vector coded large values) */
937

39251
    while ((s->transmit_num_vec_coeffs || !rl_mode) &&
938
38213
           (cur_coeff + 3 < ci->num_vec_coeffs)) {
939
        uint32_t vals[4];
940
        int i;
941
        unsigned int idx;
942
943
38213
        idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
944
945
38213
        if (idx == HUFF_VEC4_SIZE - 1) {
946
65430
            for (i = 0; i < 4; i += 2) {
947
43620
                idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
948
43620
                if (idx == HUFF_VEC2_SIZE - 1) {
949
                    uint32_t v0, v1;
950
20544
                    v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
951
20544
                    if (v0 == HUFF_VEC1_SIZE - 1)
952
1608
                        v0 += ff_wma_get_large_val(&s->gb);
953
20544
                    v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
954
20544
                    if (v1 == HUFF_VEC1_SIZE - 1)
955
1665
                        v1 += ff_wma_get_large_val(&s->gb);
956
20544
                    vals[i  ] = av_float2int(v0);
957
20544
                    vals[i+1] = av_float2int(v1);
958
                } else {
959
23076
                    vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
960
23076
                    vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
961
                }
962
            }
963
        } else {
964
16403
            vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
965
16403
            vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
966
16403
            vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
967
16403
            vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
968
        }
969
970
        /** decode sign */
971
191065
        for (i = 0; i < 4; i++) {
972
152852
            if (vals[i]) {
973
111800
                uint32_t sign = get_bits1(&s->gb) - 1;
974
111800
                AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
975
111800
                num_zeros = 0;
976
            } else {
977
41052
                ci->coeffs[cur_coeff] = 0;
978
                /** switch to run level mode when subframe_len / 128 zeros
979
                    were found in a row */
980
41052
                rl_mode |= (++num_zeros > s->subframe_len >> 8);
981
            }
982
152852
            ++cur_coeff;
983
        }
984
    }
985
986
    /** decode run level coded coefficients */
987
1038
    if (cur_coeff < s->subframe_len) {
988
1038
        memset(&ci->coeffs[cur_coeff], 0,
989
1038
               sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
990
1038
        if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
991
1038
                                    level, run, 1, ci->coeffs,
992
1038
                                    cur_coeff, s->subframe_len,
993
1038
                                    s->subframe_len, s->esc_len, 0))
994
            return AVERROR_INVALIDDATA;
995
    }
996
997
1038
    return 0;
998
}
999
1000
/**
1001
 *@brief Extract scale factors from the bitstream.
1002
 *@param s codec context
1003
 *@return 0 on success, < 0 in case of bitstream errors
1004
 */
1005
521
static int decode_scale_factors(WMAProDecodeCtx* s)
1006
{
1007
    int i;
1008
1009
    /** should never consume more than 5344 bits
1010
     *  MAX_CHANNELS * (1 +  MAX_BANDS * 23)
1011
     */
1012
1013
1745
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1014
1224
        int c = s->channel_indexes_for_cur_subframe[i];
1015
        int* sf;
1016
        int* sf_end;
1017
1224
        s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
1018
1224
        sf_end = s->channel[c].scale_factors + s->num_bands;
1019
1020
        /** resample scale factors for the new block size
1021
         *  as the scale factors might need to be resampled several times
1022
         *  before some  new values are transmitted, a backup of the last
1023
         *  transmitted scale factors is kept in saved_scale_factors
1024
         */
1025
1224
        if (s->channel[c].reuse_sf) {
1026
298
            const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
1027
            int b;
1028
5471
            for (b = 0; b < s->num_bands; b++)
1029
5173
                s->channel[c].scale_factors[b] =
1030
5173
                    s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
1031
        }
1032
1033

1224
        if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
1034
1035
1206
            if (!s->channel[c].reuse_sf) {
1036
                int val;
1037
                /** decode DPCM coded scale factors */
1038
926
                s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1039
926
                val = 45 / s->channel[c].scale_factor_step;
1040
24757
                for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1041
23831
                    val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1042
23831
                    *sf = val;
1043
                }
1044
            } else {
1045
                int i;
1046
                /** run level decode differences to the resampled factors */
1047
1904
                for (i = 0; i < s->num_bands; i++) {
1048
                    int idx;
1049
                    int skip;
1050
                    int val;
1051
                    int sign;
1052
1053
1904
                    idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1054
1055
1904
                    if (!idx) {
1056
41
                        uint32_t code = get_bits(&s->gb, 14);
1057
41
                        val  =  code >> 6;
1058
41
                        sign = (code & 1) - 1;
1059
41
                        skip = (code & 0x3f) >> 1;
1060
1863
                    } else if (idx == 1) {
1061
280
                        break;
1062
                    } else {
1063
1583
                        skip = scale_rl_run[idx];
1064
1583
                        val  = scale_rl_level[idx];
1065
1583
                        sign = get_bits1(&s->gb)-1;
1066
                    }
1067
1068
1624
                    i += skip;
1069
1624
                    if (i >= s->num_bands) {
1070
                        av_log(s->avctx, AV_LOG_ERROR,
1071
                               "invalid scale factor coding\n");
1072
                        return AVERROR_INVALIDDATA;
1073
                    }
1074
1624
                    s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1075
                }
1076
            }
1077
            /** swap buffers */
1078
1206
            s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1079
1206
            s->channel[c].table_idx = s->table_idx;
1080
1206
            s->channel[c].reuse_sf  = 1;
1081
        }
1082
1083
        /** calculate new scale factor maximum */
1084
1224
        s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1085
29004
        for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1086
27780
            s->channel[c].max_scale_factor =
1087
27780
                FFMAX(s->channel[c].max_scale_factor, *sf);
1088
        }
1089
1090
    }
1091
521
    return 0;
1092
}
1093
1094
/**
1095
 *@brief Reconstruct the individual channel data.
1096
 *@param s codec context
1097
 */
1098
521
static void inverse_channel_transform(WMAProDecodeCtx *s)
1099
{
1100
    int i;
1101
1102
1144
    for (i = 0; i < s->num_chgroups; i++) {
1103
623
        if (s->chgroup[i].transform) {
1104
            float data[WMAPRO_MAX_CHANNELS];
1105
317
            const int num_channels = s->chgroup[i].num_channels;
1106
317
            float** ch_data = s->chgroup[i].channel_data;
1107
317
            float** ch_end = ch_data + num_channels;
1108
317
            const int8_t* tb = s->chgroup[i].transform_band;
1109
            int16_t* sfb;
1110
1111
            /** multichannel decorrelation */
1112
317
            for (sfb = s->cur_sfb_offsets;
1113
8013
                 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1114
                int y;
1115
7696
                if (*tb++ == 1) {
1116
                    /** multiply values with the decorrelation_matrix */
1117
530064
                    for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1118
522368
                        const float* mat = s->chgroup[i].decorrelation_matrix;
1119
522368
                        const float* data_end = data + num_channels;
1120
522368
                        float* data_ptr = data;
1121
                        float** ch;
1122
1123
1728896
                        for (ch = ch_data; ch < ch_end; ch++)
1124
1206528
                            *data_ptr++ = (*ch)[y];
1125
1126
1728896
                        for (ch = ch_data; ch < ch_end; ch++) {
1127
1206528
                            float sum = 0;
1128
1206528
                            data_ptr = data;
1129
4104960
                            while (data_ptr < data_end)
1130
2898432
                                sum += *data_ptr++ * *mat++;
1131
1132
1206528
                            (*ch)[y] = sum;
1133
                        }
1134
                    }
1135
                } else if (s->nb_channels == 2) {
1136
                    int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1137
                    s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1138
                                               ch_data[0] + sfb[0],
1139
                                               181.0 / 128, len);
1140
                    s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1141
                                               ch_data[1] + sfb[0],
1142
                                               181.0 / 128, len);
1143
                }
1144
            }
1145
        }
1146
    }
1147
521
}
1148
1149
/**
1150
 *@brief Apply sine window and reconstruct the output buffer.
1151
 *@param s codec context
1152
 */
1153
527
static void wmapro_window(WMAProDecodeCtx *s)
1154
{
1155
    int i;
1156
1761
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1157
1234
        int c = s->channel_indexes_for_cur_subframe[i];
1158
        const float* window;
1159
1234
        int winlen = s->channel[c].prev_block_len;
1160
1234
        float* start = s->channel[c].coeffs - (winlen >> 1);
1161
1162
1234
        if (s->subframe_len < winlen) {
1163
142
            start += (winlen - s->subframe_len) >> 1;
1164
142
            winlen = s->subframe_len;
1165
        }
1166
1167
1234
        window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1168
1169
1234
        winlen >>= 1;
1170
1171
1234
        s->fdsp->vector_fmul_window(start, start, start + winlen,
1172
                                   window, winlen);
1173
1174
1234
        s->channel[c].prev_block_len = s->subframe_len;
1175
    }
1176
527
}
1177
1178
/**
1179
 *@brief Decode a single subframe (block).
1180
 *@param s codec context
1181
 *@return 0 on success, < 0 when decoding failed
1182
 */
1183
527
static int decode_subframe(WMAProDecodeCtx *s)
1184
{
1185
527
    int offset = s->samples_per_frame;
1186
527
    int subframe_len = s->samples_per_frame;
1187
    int i;
1188
527
    int total_samples   = s->samples_per_frame * s->nb_channels;
1189
527
    int transmit_coeffs = 0;
1190
    int cur_subwoofer_cutoff;
1191
1192
527
    s->subframe_offset = get_bits_count(&s->gb);
1193
1194
    /** reset channel context and find the next block offset and size
1195
        == the next block of the channel with the smallest number of
1196
        decoded samples
1197
    */
1198
2813
    for (i = 0; i < s->nb_channels; i++) {
1199
2286
        s->channel[i].grouped = 0;
1200
2286
        if (offset > s->channel[i].decoded_samples) {
1201
539
            offset = s->channel[i].decoded_samples;
1202
539
            subframe_len =
1203
539
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
1204
        }
1205
    }
1206
1207
    ff_dlog(s->avctx,
1208
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1209
1210
    /** get a list of all channels that contain the estimated block */
1211
527
    s->channels_for_cur_subframe = 0;
1212
2813
    for (i = 0; i < s->nb_channels; i++) {
1213
2286
        const int cur_subframe = s->channel[i].cur_subframe;
1214
        /** subtract already processed samples */
1215
2286
        total_samples -= s->channel[i].decoded_samples;
1216
1217
        /** and count if there are multiple subframes that match our profile */
1218
2286
        if (offset == s->channel[i].decoded_samples &&
1219
1277
            subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1220
1234
            total_samples -= s->channel[i].subframe_len[cur_subframe];
1221
1234
            s->channel[i].decoded_samples +=
1222
1234
                s->channel[i].subframe_len[cur_subframe];
1223
1234
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1224
1234
            ++s->channels_for_cur_subframe;
1225
        }
1226
    }
1227
1228
    /** check if the frame will be complete after processing the
1229
        estimated block */
1230
527
    if (!total_samples)
1231
257
        s->parsed_all_subframes = 1;
1232
1233
1234
    ff_dlog(s->avctx, "subframe is part of %i channels\n",
1235
            s->channels_for_cur_subframe);
1236
1237
    /** calculate number of scale factor bands and their offsets */
1238
527
    s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
1239
527
    s->num_bands         = s->num_sfb[s->table_idx];
1240
527
    s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
1241
527
    cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1242
1243
    /** configure the decoder for the current subframe */
1244
527
    offset += s->samples_per_frame >> 1;
1245
1246
1761
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1247
1234
        int c = s->channel_indexes_for_cur_subframe[i];
1248
1249
1234
        s->channel[c].coeffs = &s->channel[c].out[offset];
1250
    }
1251
1252
527
    s->subframe_len = subframe_len;
1253
527
    s->esc_len = av_log2(s->subframe_len - 1) + 1;
1254
1255
    /** skip extended header if any */
1256
527
    if (get_bits1(&s->gb)) {
1257
        int num_fill_bits;
1258
158
        if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1259
158
            int len = get_bits(&s->gb, 4);
1260
158
            num_fill_bits = get_bitsz(&s->gb, len) + 1;
1261
        }
1262
1263
158
        if (num_fill_bits >= 0) {
1264
158
            if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1265
                av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1266
                return AVERROR_INVALIDDATA;
1267
            }
1268
1269
158
            skip_bits_long(&s->gb, num_fill_bits);
1270
        }
1271
    }
1272
1273
    /** no idea for what the following bit is used */
1274
527
    if (get_bits1(&s->gb)) {
1275
        avpriv_request_sample(s->avctx, "Reserved bit");
1276
        return AVERROR_PATCHWELCOME;
1277
    }
1278
1279
1280
527
    if (decode_channel_transform(s) < 0)
1281
        return AVERROR_INVALIDDATA;
1282
1283
1284
1761
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1285
1234
        int c = s->channel_indexes_for_cur_subframe[i];
1286
1234
        if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1287
1038
            transmit_coeffs = 1;
1288
    }
1289
1290
527
    av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1291
527
    if (transmit_coeffs) {
1292
        int step;
1293
521
        int quant_step = 90 * s->bits_per_sample >> 4;
1294
1295
        /** decode number of vector coded coefficients */
1296
521
        if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1297
            int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1298
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1299
                int c = s->channel_indexes_for_cur_subframe[i];
1300
                int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1301
                if (num_vec_coeffs > s->subframe_len) {
1302
                    av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1303
                    return AVERROR_INVALIDDATA;
1304
                }
1305
                av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1306
                s->channel[c].num_vec_coeffs = num_vec_coeffs;
1307
            }
1308
        } else {
1309
1745
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1310
1224
                int c = s->channel_indexes_for_cur_subframe[i];
1311
1224
                s->channel[c].num_vec_coeffs = s->subframe_len;
1312
            }
1313
        }
1314
        /** decode quantization step */
1315
521
        step = get_sbits(&s->gb, 6);
1316
521
        quant_step += step;
1317

521
        if (step == -32 || step == 31) {
1318
23
            const int sign = (step == 31) - 1;
1319
23
            int quant = 0;
1320
23
            while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1321
23
                   (step = get_bits(&s->gb, 5)) == 31) {
1322
                quant += 31;
1323
            }
1324
23
            quant_step += ((quant + step) ^ sign) - sign;
1325
        }
1326
521
        if (quant_step < 0) {
1327
            av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1328
        }
1329
1330
        /** decode quantization step modifiers for every channel */
1331
1332
521
        if (s->channels_for_cur_subframe == 1) {
1333
194
            s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1334
        } else {
1335
327
            int modifier_len = get_bits(&s->gb, 3);
1336
1357
            for (i = 0; i < s->channels_for_cur_subframe; i++) {
1337
1030
                int c = s->channel_indexes_for_cur_subframe[i];
1338
1030
                s->channel[c].quant_step = quant_step;
1339
1030
                if (get_bits1(&s->gb)) {
1340
511
                    if (modifier_len) {
1341
458
                        s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1342
                    } else
1343
53
                        ++s->channel[c].quant_step;
1344
                }
1345
            }
1346
        }
1347
1348
        /** decode scale factors */
1349
521
        if (decode_scale_factors(s) < 0)
1350
            return AVERROR_INVALIDDATA;
1351
    }
1352
1353
    ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1354
            get_bits_count(&s->gb) - s->subframe_offset);
1355
1356
    /** parse coefficients */
1357
1761
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1358
1234
        int c = s->channel_indexes_for_cur_subframe[i];
1359
1234
        if (s->channel[c].transmit_coefs &&
1360
1038
            get_bits_count(&s->gb) < s->num_saved_bits) {
1361
1038
            decode_coeffs(s, c);
1362
        } else
1363
196
            memset(s->channel[c].coeffs, 0,
1364
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1365
    }
1366
1367
    ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1368
            get_bits_count(&s->gb) - s->subframe_offset);
1369
1370
527
    if (transmit_coeffs) {
1371
521
        FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1372
        /** reconstruct the per channel data */
1373
521
        inverse_channel_transform(s);
1374
1745
        for (i = 0; i < s->channels_for_cur_subframe; i++) {
1375
1224
            int c = s->channel_indexes_for_cur_subframe[i];
1376
1224
            const int* sf = s->channel[c].scale_factors;
1377
            int b;
1378
1379
1224
            if (c == s->lfe_channel)
1380
103
                memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1381
103
                       (subframe_len - cur_subwoofer_cutoff));
1382
1383
            /** inverse quantization and rescaling */
1384
30228
            for (b = 0; b < s->num_bands; b++) {
1385
29004
                const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1386
29004
                const int exp = s->channel[c].quant_step -
1387
29004
                            (s->channel[c].max_scale_factor - *sf++) *
1388
29004
                            s->channel[c].scale_factor_step;
1389
29004
                const float quant = ff_exp10(exp / 20.0);
1390
29004
                int start = s->cur_sfb_offsets[b];
1391
29004
                s->fdsp->vector_fmul_scalar(s->tmp + start,
1392
29004
                                           s->channel[c].coeffs + start,
1393
                                           quant, end - start);
1394
            }
1395
1396
            /** apply imdct (imdct_half == DCTIV with reverse) */
1397
1224
            mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1398
        }
1399
    }
1400
1401
    /** window and overlapp-add */
1402
527
    wmapro_window(s);
1403
1404
    /** handled one subframe */
1405
1761
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1406
1234
        int c = s->channel_indexes_for_cur_subframe[i];
1407
1234
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1408
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1409
            return AVERROR_INVALIDDATA;
1410
        }
1411
1234
        ++s->channel[c].cur_subframe;
1412
    }
1413
1414
527
    return 0;
1415
}
1416
1417
/**
1418
 *@brief Decode one WMA frame.
1419
 *@param s codec context
1420
 *@return 0 if the trailer bit indicates that this is the last frame,
1421
 *        1 if there are additional frames
1422
 */
1423
257
static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1424
{
1425
257
    GetBitContext* gb = &s->gb;
1426
257
    int more_frames = 0;
1427
257
    int len = 0;
1428
    int i;
1429
1430
    /** get frame length */
1431
257
    if (s->len_prefix)
1432
257
        len = get_bits(gb, s->log2_frame_size);
1433
1434
    ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1435
1436
    /** decode tile information */
1437
257
    if (decode_tilehdr(s)) {
1438
        s->packet_loss = 1;
1439
        return 0;
1440
    }
1441
1442
    /** read postproc transform */
1443

257
    if (s->nb_channels > 1 && get_bits1(gb)) {
1444
        if (get_bits1(gb)) {
1445
            for (i = 0; i < s->nb_channels * s->nb_channels; i++)
1446
                skip_bits(gb, 4);
1447
        }
1448
    }
1449
1450
    /** read drc info */
1451
257
    if (s->dynamic_range_compression) {
1452
257
        s->drc_gain = get_bits(gb, 8);
1453
        ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1454
    }
1455
1456
    /** no idea what these are for, might be the number of samples
1457
        that need to be skipped at the beginning or end of a stream */
1458
257
    if (get_bits1(gb)) {
1459
        int av_unused skip;
1460
1461
        /** usually true for the first frame */
1462
4
        if (get_bits1(gb)) {
1463
3
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1464
            ff_dlog(s->avctx, "start skip: %i\n", skip);
1465
        }
1466
1467
        /** sometimes true for the last frame */
1468
4
        if (get_bits1(gb)) {
1469
1
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1470
            ff_dlog(s->avctx, "end skip: %i\n", skip);
1471
        }
1472
1473
    }
1474
1475
    ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1476
            get_bits_count(gb) - s->frame_offset);
1477
1478
    /** reset subframe states */
1479
257
    s->parsed_all_subframes = 0;
1480
1183
    for (i = 0; i < s->nb_channels; i++) {
1481
926
        s->channel[i].decoded_samples = 0;
1482
926
        s->channel[i].cur_subframe    = 0;
1483
926
        s->channel[i].reuse_sf        = 0;
1484
    }
1485
1486
    /** decode all subframes */
1487
784
    while (!s->parsed_all_subframes) {
1488
527
        if (decode_subframe(s) < 0) {
1489
            s->packet_loss = 1;
1490
            return 0;
1491
        }
1492
    }
1493
1494
    /** copy samples to the output buffer */
1495
1183
    for (i = 0; i < s->nb_channels; i++)
1496
926
        memcpy(frame->extended_data[i], s->channel[i].out,
1497
926
               s->samples_per_frame * sizeof(*s->channel[i].out));
1498
1499
1183
    for (i = 0; i < s->nb_channels; i++) {
1500
        /** reuse second half of the IMDCT output for the next frame */
1501
926
        memcpy(&s->channel[i].out[0],
1502
926
               &s->channel[i].out[s->samples_per_frame],
1503
926
               s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1504
    }
1505
1506
257
    if (s->skip_frame) {
1507
3
        s->skip_frame = 0;
1508
3
        *got_frame_ptr = 0;
1509
3
        av_frame_unref(frame);
1510
    } else {
1511
254
        *got_frame_ptr = 1;
1512
    }
1513
1514
257
    if (s->len_prefix) {
1515
257
        if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1516
            /** FIXME: not sure if this is always an error */
1517
            av_log(s->avctx, AV_LOG_ERROR,
1518
                   "frame[%"PRIu32"] would have to skip %i bits\n",
1519
                   s->frame_num,
1520
                   len - (get_bits_count(gb) - s->frame_offset) - 1);
1521
            s->packet_loss = 1;
1522
            return 0;
1523
        }
1524
1525
        /** skip the rest of the frame data */
1526
257
        skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1527
    } else {
1528
        while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1529
        }
1530
    }
1531
1532
    /** decode trailer bit */
1533
257
    more_frames = get_bits1(gb);
1534
1535
257
    ++s->frame_num;
1536
257
    return more_frames;
1537
}
1538
1539
/**
1540
 *@brief Calculate remaining input buffer length.
1541
 *@param s codec context
1542
 *@param gb bitstream reader context
1543
 *@return remaining size in bits
1544
 */
1545
849
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1546
{
1547
849
    return s->buf_bit_size - get_bits_count(gb);
1548
}
1549
1550
/**
1551
 *@brief Fill the bit reservoir with a (partial) frame.
1552
 *@param s codec context
1553
 *@param gb bitstream reader context
1554
 *@param len length of the partial frame
1555
 *@param append decides whether to reset the buffer or not
1556
 */
1557
281
static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1558
                      int append)
1559
{
1560
    int buflen;
1561
1562
    /** when the frame data does not need to be concatenated, the input buffer
1563
        is reset and additional bits from the previous frame are copied
1564
        and skipped later so that a fast byte copy is possible */
1565
1566
281
    if (!append) {
1567
260
        s->frame_offset = get_bits_count(gb) & 7;
1568
260
        s->num_saved_bits = s->frame_offset;
1569
260
        init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1570
260
        buflen = (s->num_saved_bits      + len + 7) >> 3;
1571
    } else
1572
21
        buflen = (put_bits_count(&s->pb) + len + 7) >> 3;
1573
1574

281
    if (len <= 0 || buflen > MAX_FRAMESIZE) {
1575
        avpriv_request_sample(s->avctx, "Too small input buffer");
1576
        s->packet_loss = 1;
1577
        return;
1578
    }
1579
1580
281
    av_assert0(len <= put_bits_left(&s->pb));
1581
1582
281
    s->num_saved_bits += len;
1583
281
    if (!append) {
1584
260
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1585
                     s->num_saved_bits);
1586
    } else {
1587
21
        int align = 8 - (get_bits_count(gb) & 7);
1588
21
        align = FFMIN(align, len);
1589
21
        put_bits(&s->pb, align, get_bits(gb, align));
1590
21
        len -= align;
1591
21
        ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1592
    }
1593
281
    skip_bits_long(gb, len);
1594
1595
    {
1596
281
        PutBitContext tmp = s->pb;
1597
281
        flush_put_bits(&tmp);
1598
    }
1599
1600
281
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1601
281
    skip_bits(&s->gb, s->frame_offset);
1602
}
1603
1604
283
static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s,
1605
                         void *data, int *got_frame_ptr, AVPacket *avpkt)
1606
{
1607
283
    GetBitContext* gb  = &s->pgb;
1608
283
    const uint8_t* buf = avpkt->data;
1609
283
    int buf_size       = avpkt->size;
1610
    int num_bits_prev_frame;
1611
    int packet_sequence_number;
1612
1613
283
    *got_frame_ptr = 0;
1614
1615
283
    if (!buf_size) {
1616
        AVFrame *frame = data;
1617
        int i;
1618
1619
        /** Must output remaining samples after stream end. WMAPRO 5.1 created
1620
         * by XWMA encoder don't though (maybe only 1/2ch streams need it). */
1621
        s->packet_done = 0;
1622
        if (s->eof_done)
1623
            return 0;
1624
1625
        /** clean output buffer and copy last IMDCT samples */
1626
        for (i = 0; i < s->nb_channels; i++) {
1627
            memset(frame->extended_data[i], 0,
1628
            s->samples_per_frame * sizeof(*s->channel[i].out));
1629
1630
            memcpy(frame->extended_data[i], s->channel[i].out,
1631
                   s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1632
        }
1633
1634
        /* TODO: XMA should output 128 samples only (instead of 512) and WMAPRO
1635
         * maybe 768 (with 2048), XMA needs changes in multi-stream handling though. */
1636
1637
        s->eof_done = 1;
1638
        s->packet_done = 1;
1639
        *got_frame_ptr = 1;
1640
        return 0;
1641
    }
1642

283
    else if (s->packet_done || s->packet_loss) {
1643
24
        s->packet_done = 0;
1644
1645
        /** sanity check for the buffer length */
1646

24
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1647
            av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1648
                   buf_size, avctx->block_align);
1649
            s->packet_loss = 1;
1650
            return AVERROR_INVALIDDATA;
1651
        }
1652
1653
24
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1654
24
            s->next_packet_start = buf_size - avctx->block_align;
1655
24
            buf_size = avctx->block_align;
1656
        } else {
1657
            s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1658
            buf_size = FFMIN(buf_size, avctx->block_align);
1659
        }
1660
24
        s->buf_bit_size = buf_size << 3;
1661
1662
        /** parse packet header */
1663
24
        init_get_bits(gb, buf, s->buf_bit_size);
1664
24
        if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1665
24
            packet_sequence_number = get_bits(gb, 4);
1666
24
            skip_bits(gb, 2);
1667
        } else {
1668
            int num_frames = get_bits(gb, 6);
1669
            ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames);
1670
            packet_sequence_number = 0;
1671
        }
1672
1673
        /** get number of bits that need to be added to the previous frame */
1674
24
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1675
24
        if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1676
            skip_bits(gb, 3);
1677
            s->skip_packets = get_bits(gb, 8);
1678
            ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets);
1679
        }
1680
1681
        ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1682
                num_bits_prev_frame);
1683
1684
        /** check for packet loss */
1685

24
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss &&
1686
21
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1687
            s->packet_loss = 1;
1688
            av_log(avctx, AV_LOG_ERROR,
1689
                   "Packet loss detected! seq %"PRIx8" vs %x\n",
1690
                   s->packet_sequence_number, packet_sequence_number);
1691
        }
1692
24
        s->packet_sequence_number = packet_sequence_number;
1693
1694
24
        if (num_bits_prev_frame > 0) {
1695
21
            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1696
21
            if (num_bits_prev_frame >= remaining_packet_bits) {
1697
                num_bits_prev_frame = remaining_packet_bits;
1698
                s->packet_done = 1;
1699
            }
1700
1701
            /** append the previous frame data to the remaining data from the
1702
                previous packet to create a full frame */
1703
21
            save_bits(s, gb, num_bits_prev_frame, 1);
1704
            ff_dlog(avctx, "accumulated %x bits of frame data\n",
1705
                    s->num_saved_bits - s->frame_offset);
1706
1707
            /** decode the cross packet frame if it is valid */
1708
21
            if (!s->packet_loss)
1709
21
                decode_frame(s, data, got_frame_ptr);
1710
3
        } else if (s->num_saved_bits - s->frame_offset) {
1711
            ff_dlog(avctx, "ignoring %x previously saved bits\n",
1712
                    s->num_saved_bits - s->frame_offset);
1713
        }
1714
1715
24
        if (s->packet_loss) {
1716
            /** reset number of saved bits so that the decoder
1717
                does not start to decode incomplete frames in the
1718
                s->len_prefix == 0 case */
1719
3
            s->num_saved_bits = 0;
1720
3
            s->packet_loss = 0;
1721
        }
1722
    } else {
1723
        int frame_size;
1724
1725
259
        if (avpkt->size < s->next_packet_start) {
1726
            s->packet_loss = 1;
1727
            return AVERROR_INVALIDDATA;
1728
        }
1729
1730
259
        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1731
259
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1732
259
        skip_bits(gb, s->packet_offset);
1733

259
        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1734

518
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1735
259
            frame_size <= remaining_bits(s, gb)) {
1736
236
            save_bits(s, gb, frame_size, 0);
1737
236
            if (!s->packet_loss)
1738
236
                s->packet_done = !decode_frame(s, data, got_frame_ptr);
1739
23
        } else if (!s->len_prefix
1740
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
1741
            /** when the frames do not have a length prefix, we don't know
1742
                the compressed length of the individual frames
1743
                however, we know what part of a new packet belongs to the
1744
                previous frame
1745
                therefore we save the incoming packet first, then we append
1746
                the "previous frame" data from the next packet so that
1747
                we get a buffer that only contains full frames */
1748
            s->packet_done = !decode_frame(s, data, got_frame_ptr);
1749
        } else {
1750
23
            s->packet_done = 1;
1751
        }
1752
    }
1753
1754
283
    if (remaining_bits(s, gb) < 0) {
1755
        av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1756
        s->packet_loss = 1;
1757
    }
1758
1759

307
    if (s->packet_done && !s->packet_loss &&
1760
24
        remaining_bits(s, gb) > 0) {
1761
        /** save the rest of the data so that it can be decoded
1762
            with the next packet */
1763
24
        save_bits(s, gb, remaining_bits(s, gb), 0);
1764
    }
1765
1766
283
    s->packet_offset = get_bits_count(gb) & 7;
1767
283
    if (s->packet_loss)
1768
        return AVERROR_INVALIDDATA;
1769
1770
283
    return get_bits_count(gb) >> 3;
1771
}
1772
1773
/**
1774
 *@brief Decode a single WMA packet.
1775
 *@param avctx codec context
1776
 *@param data the output buffer
1777
 *@param avpkt input packet
1778
 *@return number of bytes that were read from the input buffer
1779
 */
1780
283
static int wmapro_decode_packet(AVCodecContext *avctx, void *data,
1781
                                int *got_frame_ptr, AVPacket *avpkt)
1782
{
1783
283
    WMAProDecodeCtx *s = avctx->priv_data;
1784
283
    AVFrame *frame = data;
1785
    int ret;
1786
1787
    /* get output buffer */
1788
283
    frame->nb_samples = s->samples_per_frame;
1789
283
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1790
        s->packet_loss = 1;
1791
        return 0;
1792
    }
1793
1794
283
    return decode_packet(avctx, s, data, got_frame_ptr, avpkt);
1795
}
1796
1797
static int xma_decode_packet(AVCodecContext *avctx, void *data,
1798
                             int *got_frame_ptr, AVPacket *avpkt)
1799
{
1800
    XMADecodeCtx *s = avctx->priv_data;
1801
    int got_stream_frame_ptr = 0;
1802
    AVFrame *frame = data;
1803
    int i, ret, offset = INT_MAX;
1804
1805
    if (!s->frames[s->current_stream]->data[0]) {
1806
        s->frames[s->current_stream]->nb_samples = 512;
1807
        if ((ret = ff_get_buffer(avctx, s->frames[s->current_stream], 0)) < 0) {
1808
            return ret;
1809
        }
1810
    }
1811
    /* decode current stream packet */
1812
    ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream],
1813
                        &got_stream_frame_ptr, avpkt);
1814
1815
    if (got_stream_frame_ptr && s->offset[s->current_stream] >= 64) {
1816
        got_stream_frame_ptr = 0;
1817
        ret = AVERROR_INVALIDDATA;
1818
    }
1819
1820
    /* copy stream samples (1/2ch) to sample buffer (Nch) */
1821
    if (got_stream_frame_ptr) {
1822
        int start_ch = s->start_channel[s->current_stream];
1823
        memcpy(&s->samples[start_ch + 0][s->offset[s->current_stream] * 512],
1824
               s->frames[s->current_stream]->extended_data[0], 512 * 4);
1825
        if (s->xma[s->current_stream].nb_channels > 1)
1826
            memcpy(&s->samples[start_ch + 1][s->offset[s->current_stream] * 512],
1827
                   s->frames[s->current_stream]->extended_data[1], 512 * 4);
1828
        s->offset[s->current_stream]++;
1829
    } else if (ret < 0) {
1830
        memset(s->offset, 0, sizeof(s->offset));
1831
        s->current_stream = 0;
1832
        return ret;
1833
    }
1834
1835
    /* find next XMA packet's owner stream, and update.
1836
     * XMA streams find their packets following packet_skips
1837
     * (at start there is one packet per stream, then interleave non-linearly). */
1838
    if (s->xma[s->current_stream].packet_done ||
1839
        s->xma[s->current_stream].packet_loss) {
1840
1841
        /* select stream with 0 skip_packets (= uses next packet) */
1842
        if (s->xma[s->current_stream].skip_packets != 0) {
1843
            int min[2];
1844
1845
            min[0] = s->xma[0].skip_packets;
1846
            min[1] = i = 0;
1847
1848
            for (i = 1; i < s->num_streams; i++) {
1849
                if (s->xma[i].skip_packets < min[0]) {
1850
                    min[0] = s->xma[i].skip_packets;
1851
                    min[1] = i;
1852
                }
1853
            }
1854
1855
            s->current_stream = min[1];
1856
        }
1857
1858
        /* all other streams skip next packet */
1859
        for (i = 0; i < s->num_streams; i++) {
1860
            s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1);
1861
        }
1862
1863
        /* copy samples from buffer to output if possible */
1864
        for (i = 0; i < s->num_streams; i++) {
1865
            offset = FFMIN(offset, s->offset[i]);
1866
        }
1867
        if (offset > 0) {
1868
            int bret;
1869
1870
            frame->nb_samples = 512 * offset;
1871
            if ((bret = ff_get_buffer(avctx, frame, 0)) < 0)
1872
                return bret;
1873
1874
            /* copy samples buffer (Nch) to frame samples (Nch), move unconsumed samples */
1875
            for (i = 0; i < s->num_streams; i++) {
1876
                int start_ch = s->start_channel[i];
1877
                memcpy(frame->extended_data[start_ch + 0], s->samples[start_ch + 0], frame->nb_samples * 4);
1878
                if (s->xma[i].nb_channels > 1)
1879
                    memcpy(frame->extended_data[start_ch + 1], s->samples[start_ch + 1], frame->nb_samples * 4);
1880
1881
                s->offset[i] -= offset;
1882
                if (s->offset[i]) {
1883
                    memmove(s->samples[start_ch + 0], s->samples[start_ch + 0] + frame->nb_samples, s->offset[i] * 4 * 512);
1884
                    if (s->xma[i].nb_channels > 1)
1885
                        memmove(s->samples[start_ch + 1], s->samples[start_ch + 1] + frame->nb_samples, s->offset[i] * 4 * 512);
1886
                }
1887
            }
1888
1889
            *got_frame_ptr = 1;
1890
        }
1891
    }
1892
1893
    return ret;
1894
}
1895
1896
static av_cold int xma_decode_init(AVCodecContext *avctx)
1897
{
1898
    XMADecodeCtx *s = avctx->priv_data;
1899
    int i, ret, start_channels = 0;
1900
1901
    if (avctx->channels <= 0 || avctx->extradata_size == 0)
1902
        return AVERROR_INVALIDDATA;
1903
1904
    /* get stream config */
1905
    if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
1906
        s->num_streams = (avctx->channels + 1) / 2;
1907
    } else if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 2) { /* XMA2WAVEFORMAT */
1908
        s->num_streams = avctx->extradata[1];
1909
        if (avctx->extradata_size != (32 + ((avctx->extradata[0]==3)?0:8) + 4*s->num_streams)) {
1910
            av_log(avctx, AV_LOG_ERROR, "Incorrect XMA2 extradata size\n");
1911
            s->num_streams = 0;
1912
            return AVERROR(EINVAL);
1913
        }
1914
    } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 4) { /* XMAWAVEFORMAT */
1915
        s->num_streams = avctx->extradata[4];
1916
        if (avctx->extradata_size != (8 + 20*s->num_streams)) {
1917
            av_log(avctx, AV_LOG_ERROR, "Incorrect XMA1 extradata size\n");
1918
            s->num_streams = 0;
1919
            return AVERROR(EINVAL);
1920
        }
1921
    } else {
1922
        av_log(avctx, AV_LOG_ERROR, "Incorrect XMA config\n");
1923
        return AVERROR(EINVAL);
1924
    }
1925
1926
    /* encoder supports up to 64 streams / 64*2 channels (would have to alloc arrays) */
1927
    if (avctx->channels > XMA_MAX_CHANNELS || s->num_streams > XMA_MAX_STREAMS ||
1928
        s->num_streams <= 0
1929
    ) {
1930
        avpriv_request_sample(avctx, "More than %d channels in %d streams", XMA_MAX_CHANNELS, s->num_streams);
1931
        s->num_streams = 0;
1932
        return AVERROR_PATCHWELCOME;
1933
    }
1934
1935
    /* init all streams (several streams of 1/2ch make Nch files) */
1936
    for (i = 0; i < s->num_streams; i++) {
1937
        ret = decode_init(&s->xma[i], avctx, i);
1938
        if (ret < 0)
1939
            return ret;
1940
        s->frames[i] = av_frame_alloc();
1941
        if (!s->frames[i])
1942
            return AVERROR(ENOMEM);
1943
1944
        s->start_channel[i] = start_channels;
1945
        start_channels += s->xma[i].nb_channels;
1946
    }
1947
    if (start_channels != avctx->channels)
1948
        return AVERROR_INVALIDDATA;
1949
1950
    return ret;
1951
}
1952
1953
static av_cold int xma_decode_end(AVCodecContext *avctx)
1954
{
1955
    XMADecodeCtx *s = avctx->priv_data;
1956
    int i;
1957
1958
    for (i = 0; i < s->num_streams; i++) {
1959
        decode_end(&s->xma[i]);
1960
        av_frame_free(&s->frames[i]);
1961
    }
1962
    s->num_streams = 0;
1963
1964
    return 0;
1965
}
1966
1967
static void flush(WMAProDecodeCtx *s)
1968
{
1969
    int i;
1970
    /** reset output buffer as a part of it is used during the windowing of a
1971
        new frame */
1972
    for (i = 0; i < s->nb_channels; i++)
1973
        memset(s->channel[i].out, 0, s->samples_per_frame *
1974
               sizeof(*s->channel[i].out));
1975
    s->packet_loss = 1;
1976
    s->skip_packets = 0;
1977
    s->eof_done = 0;
1978
}
1979
1980
1981
/**
1982
 *@brief Clear decoder buffers (for seeking).
1983
 *@param avctx codec context
1984
 */
1985
static void wmapro_flush(AVCodecContext *avctx)
1986
{
1987
    WMAProDecodeCtx *s = avctx->priv_data;
1988
1989
    flush(s);
1990
}
1991
1992
static void xma_flush(AVCodecContext *avctx)
1993
{
1994
    XMADecodeCtx *s = avctx->priv_data;
1995
    int i;
1996
1997
    for (i = 0; i < s->num_streams; i++)
1998
        flush(&s->xma[i]);
1999
2000
    memset(s->offset, 0, sizeof(s->offset));
2001
    s->current_stream = 0;
2002
}
2003
2004
2005
/**
2006
 *@brief wmapro decoder
2007
 */
2008
AVCodec ff_wmapro_decoder = {
2009
    .name           = "wmapro",
2010
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
2011
    .type           = AVMEDIA_TYPE_AUDIO,
2012
    .id             = AV_CODEC_ID_WMAPRO,
2013
    .priv_data_size = sizeof(WMAProDecodeCtx),
2014
    .init           = wmapro_decode_init,
2015
    .close          = wmapro_decode_end,
2016
    .decode         = wmapro_decode_packet,
2017
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
2018
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
2019
    .flush          = wmapro_flush,
2020
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2021
                                                      AV_SAMPLE_FMT_NONE },
2022
};
2023
2024
AVCodec ff_xma1_decoder = {
2025
    .name           = "xma1",
2026
    .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
2027
    .type           = AVMEDIA_TYPE_AUDIO,
2028
    .id             = AV_CODEC_ID_XMA1,
2029
    .priv_data_size = sizeof(XMADecodeCtx),
2030
    .init           = xma_decode_init,
2031
    .close          = xma_decode_end,
2032
    .decode         = xma_decode_packet,
2033
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
2034
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
2035
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2036
                                                      AV_SAMPLE_FMT_NONE },
2037
};
2038
2039
AVCodec ff_xma2_decoder = {
2040
    .name           = "xma2",
2041
    .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
2042
    .type           = AVMEDIA_TYPE_AUDIO,
2043
    .id             = AV_CODEC_ID_XMA2,
2044
    .priv_data_size = sizeof(XMADecodeCtx),
2045
    .init           = xma_decode_init,
2046
    .close          = xma_decode_end,
2047
    .decode         = xma_decode_packet,
2048
    .flush          = xma_flush,
2049
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
2050
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
2051
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2052
                                                      AV_SAMPLE_FMT_NONE },
2053
};