GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wmaprodec.c Lines: 593 867 68.4 %
Date: 2020-10-23 17:01:47 Branches: 337 562 60.0 %

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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