GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wmalosslessdec.c Lines: 480 622 77.2 %
Date: 2020-10-23 17:01:47 Branches: 282 404 69.8 %

Line Branch Exec Source
1
/*
2
 * Windows Media Audio Lossless decoder
3
 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4
 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5
 * Copyright (c) 2011 Andreas Ă–man
6
 * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24
25
#include <inttypes.h>
26
27
#include "libavutil/attributes.h"
28
#include "libavutil/avassert.h"
29
30
#include "avcodec.h"
31
#include "internal.h"
32
#include "get_bits.h"
33
#include "put_bits.h"
34
#include "lossless_audiodsp.h"
35
#include "wma.h"
36
#include "wma_common.h"
37
38
/** current decoder limitations */
39
#define WMALL_MAX_CHANNELS      8                       ///< max number of handled channels
40
#define MAX_SUBFRAMES          32                       ///< max number of subframes per channel
41
#define MAX_BANDS              29                       ///< max number of scale factor bands
42
#define MAX_FRAMESIZE       32768                       ///< maximum compressed frame size
43
#define MAX_ORDER             256
44
45
#define WMALL_BLOCK_MIN_BITS    6                       ///< log2 of min block size
46
#define WMALL_BLOCK_MAX_BITS   14                       ///< log2 of max block size
47
#define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)    ///< maximum block size
48
#define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
49
50
#define WMALL_COEFF_PAD_SIZE   16                       ///< pad coef buffers with 0 for use with SIMD
51
52
/**
53
 * @brief frame-specific decoder context for a single channel
54
 */
55
typedef struct WmallChannelCtx {
56
    int16_t     prev_block_len;                         ///< length of the previous block
57
    uint8_t     transmit_coefs;
58
    uint8_t     num_subframes;
59
    uint16_t    subframe_len[MAX_SUBFRAMES];            ///< subframe length in samples
60
    uint16_t    subframe_offsets[MAX_SUBFRAMES];        ///< subframe positions in the current frame
61
    uint8_t     cur_subframe;                           ///< current subframe number
62
    uint16_t    decoded_samples;                        ///< number of already processed samples
63
    int         quant_step;                             ///< quantization step for the current subframe
64
    int         transient_counter;                      ///< number of transient samples from the beginning of the transient zone
65
} WmallChannelCtx;
66
67
/**
68
 * @brief main decoder context
69
 */
70
typedef struct WmallDecodeCtx {
71
    /* generic decoder variables */
72
    AVCodecContext  *avctx;
73
    AVFrame         *frame;
74
    LLAudDSPContext dsp;                           ///< accelerated DSP functions
75
    uint8_t         *frame_data;                    ///< compressed frame data
76
    int             max_frame_size;                 ///< max bitstream size
77
    PutBitContext   pb;                             ///< context for filling the frame_data buffer
78
79
    /* frame size dependent frame information (set during initialization) */
80
    uint32_t        decode_flags;                   ///< used compression features
81
    int             len_prefix;                     ///< frame is prefixed with its length
82
    int             dynamic_range_compression;      ///< frame contains DRC data
83
    uint8_t         bits_per_sample;                ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
84
    uint16_t        samples_per_frame;              ///< number of samples to output
85
    uint16_t        log2_frame_size;
86
    int8_t          num_channels;                   ///< number of channels in the stream (same as AVCodecContext.num_channels)
87
    int8_t          lfe_channel;                    ///< lfe channel index
88
    uint8_t         max_num_subframes;
89
    uint8_t         subframe_len_bits;              ///< number of bits used for the subframe length
90
    uint8_t         max_subframe_len_bit;           ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
91
    uint16_t        min_samples_per_subframe;
92
93
    /* packet decode state */
94
    GetBitContext   pgb;                            ///< bitstream reader context for the packet
95
    int             next_packet_start;              ///< start offset of the next WMA packet in the demuxer packet
96
    uint8_t         packet_offset;                  ///< offset to the frame in the packet
97
    uint8_t         packet_sequence_number;         ///< current packet number
98
    int             num_saved_bits;                 ///< saved number of bits
99
    int             frame_offset;                   ///< frame offset in the bit reservoir
100
    int             subframe_offset;                ///< subframe offset in the bit reservoir
101
    uint8_t         packet_loss;                    ///< set in case of bitstream error
102
    uint8_t         packet_done;                    ///< set when a packet is fully decoded
103
104
    /* frame decode state */
105
    uint32_t        frame_num;                      ///< current frame number (not used for decoding)
106
    GetBitContext   gb;                             ///< bitstream reader context
107
    int             buf_bit_size;                   ///< buffer size in bits
108
    int16_t         *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
109
    int32_t         *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
110
    uint8_t         drc_gain;                       ///< gain for the DRC tool
111
    int8_t          skip_frame;                     ///< skip output step
112
    int8_t          parsed_all_subframes;           ///< all subframes decoded?
113
114
    /* subframe/block decode state */
115
    int16_t         subframe_len;                   ///< current subframe length
116
    int8_t          channels_for_cur_subframe;      ///< number of channels that contain the subframe
117
    int8_t          channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
118
119
    WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
120
121
    // WMA Lossless-specific
122
123
    uint8_t do_arith_coding;
124
    uint8_t do_ac_filter;
125
    uint8_t do_inter_ch_decorr;
126
    uint8_t do_mclms;
127
    uint8_t do_lpc;
128
129
    int8_t  acfilter_order;
130
    int8_t  acfilter_scaling;
131
    int16_t acfilter_coeffs[16];
132
    int     acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
133
134
    int8_t  mclms_order;
135
    int8_t  mclms_scaling;
136
    int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
137
    int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
138
    int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
139
    int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
140
    int     mclms_recent;
141
142
    int     movave_scaling;
143
    int     quant_stepsize;
144
145
    struct {
146
        int order;
147
        int scaling;
148
        int coefsend;
149
        int bitsend;
150
        DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
151
        DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
152
        DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153
        int recent;
154
    } cdlms[WMALL_MAX_CHANNELS][9];
155
156
    int cdlms_ttl[WMALL_MAX_CHANNELS];
157
158
    int bV3RTM;
159
160
    int is_channel_coded[WMALL_MAX_CHANNELS];
161
    int update_speed[WMALL_MAX_CHANNELS];
162
163
    int transient[WMALL_MAX_CHANNELS];
164
    int transient_pos[WMALL_MAX_CHANNELS];
165
    int seekable_tile;
166
167
    unsigned ave_sum[WMALL_MAX_CHANNELS];
168
169
    int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
170
171
    int lpc_coefs[WMALL_MAX_CHANNELS][40];
172
    int lpc_order;
173
    int lpc_scaling;
174
    int lpc_intbits;
175
} WmallDecodeCtx;
176
177
/** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
178
#define WMASIGN(x) (((x) > 0) - ((x) < 0))
179
180
8
static av_cold int decode_init(AVCodecContext *avctx)
181
{
182
8
    WmallDecodeCtx *s  = avctx->priv_data;
183
8
    uint8_t *edata_ptr = avctx->extradata;
184
    unsigned int channel_mask;
185
    int i, log2_max_num_subframes;
186
187

8
    if (avctx->block_align <= 0 || avctx->block_align > (1<<21)) {
188
        av_log(avctx, AV_LOG_ERROR, "block_align is not set or invalid\n");
189
        return AVERROR(EINVAL);
190
    }
191
192
8
    av_assert0(avctx->channels >= 0);
193
8
    if (avctx->channels > WMALL_MAX_CHANNELS) {
194
        avpriv_request_sample(avctx,
195
                              "More than " AV_STRINGIFY(WMALL_MAX_CHANNELS) " channels");
196
        return AVERROR_PATCHWELCOME;
197
    }
198
199
8
    s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
200
8
    s->frame_data = av_mallocz(s->max_frame_size + AV_INPUT_BUFFER_PADDING_SIZE);
201
8
    if (!s->frame_data)
202
        return AVERROR(ENOMEM);
203
204
8
    s->avctx = avctx;
205
8
    ff_llauddsp_init(&s->dsp);
206
8
    init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
207
208
8
    if (avctx->extradata_size >= 18) {
209
8
        s->decode_flags    = AV_RL16(edata_ptr + 14);
210
8
        channel_mask       = AV_RL32(edata_ptr +  2);
211
8
        s->bits_per_sample = AV_RL16(edata_ptr);
212
8
        if (s->bits_per_sample == 16)
213
2
            avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
214
6
        else if (s->bits_per_sample == 24) {
215
6
            avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
216
6
            avctx->bits_per_raw_sample = 24;
217
        } else {
218
            av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
219
                   s->bits_per_sample);
220
            return AVERROR_INVALIDDATA;
221
        }
222
        /* dump the extradata */
223
152
        for (i = 0; i < avctx->extradata_size; i++)
224
            ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
225
        ff_dlog(avctx, "\n");
226
227
    } else {
228
        avpriv_request_sample(avctx, "Unsupported extradata size");
229
        return AVERROR_PATCHWELCOME;
230
    }
231
232
    /* generic init */
233
8
    s->log2_frame_size = av_log2(avctx->block_align) + 4;
234
235
    /* frame info */
236
8
    s->skip_frame  = 1; /* skip first frame */
237
8
    s->packet_loss = 1;
238
8
    s->len_prefix  = s->decode_flags & 0x40;
239
240
    /* get frame len */
241
8
    s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
242
                                                          3, s->decode_flags);
243
8
    av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
244
245
    /* init previous block len */
246
24
    for (i = 0; i < avctx->channels; i++)
247
16
        s->channel[i].prev_block_len = s->samples_per_frame;
248
249
    /* subframe info */
250
8
    log2_max_num_subframes  = (s->decode_flags & 0x38) >> 3;
251
8
    s->max_num_subframes    = 1 << log2_max_num_subframes;
252
8
    s->max_subframe_len_bit = 0;
253
8
    s->subframe_len_bits    = av_log2(log2_max_num_subframes) + 1;
254
255
8
    s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
256
8
    s->dynamic_range_compression = s->decode_flags & 0x80;
257
8
    s->bV3RTM                    = s->decode_flags & 0x100;
258
259
8
    if (s->max_num_subframes > MAX_SUBFRAMES) {
260
        av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
261
               s->max_num_subframes);
262
        return AVERROR_INVALIDDATA;
263
    }
264
265
8
    s->num_channels = avctx->channels;
266
267
    /* extract lfe channel position */
268
8
    s->lfe_channel = -1;
269
270
8
    if (channel_mask & 8) {
271
        unsigned int mask;
272
        for (mask = 1; mask < 16; mask <<= 1)
273
            if (channel_mask & mask)
274
                ++s->lfe_channel;
275
    }
276
277
8
    s->frame = av_frame_alloc();
278
8
    if (!s->frame)
279
        return AVERROR(ENOMEM);
280
281
8
    avctx->channel_layout = channel_mask;
282
8
    return 0;
283
}
284
285
/**
286
 * @brief Decode the subframe length.
287
 * @param s      context
288
 * @param offset sample offset in the frame
289
 * @return decoded subframe length on success, < 0 in case of an error
290
 */
291
269
static int decode_subframe_length(WmallDecodeCtx *s, int offset)
292
{
293
    int frame_len_ratio, subframe_len, len;
294
295
    /* no need to read from the bitstream when only one length is possible */
296
269
    if (offset == s->samples_per_frame - s->min_samples_per_subframe)
297
        return s->min_samples_per_subframe;
298
299
269
    len             = av_log2(s->max_num_subframes - 1) + 1;
300
269
    frame_len_ratio = get_bits(&s->gb, len);
301
269
    subframe_len    = s->min_samples_per_subframe * (frame_len_ratio + 1);
302
303
    /* sanity check the length */
304
269
    if (subframe_len < s->min_samples_per_subframe ||
305
269
        subframe_len > s->samples_per_frame) {
306
        av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
307
               subframe_len);
308
        return AVERROR_INVALIDDATA;
309
    }
310
269
    return subframe_len;
311
}
312
313
/**
314
 * @brief Decode how the data in the frame is split into subframes.
315
 *       Every WMA frame contains the encoded data for a fixed number of
316
 *       samples per channel. The data for every channel might be split
317
 *       into several subframes. This function will reconstruct the list of
318
 *       subframes for every channel.
319
 *
320
 *       If the subframes are not evenly split, the algorithm estimates the
321
 *       channels with the lowest number of total samples.
322
 *       Afterwards, for each of these channels a bit is read from the
323
 *       bitstream that indicates if the channel contains a subframe with the
324
 *       next subframe size that is going to be read from the bitstream or not.
325
 *       If a channel contains such a subframe, the subframe size gets added to
326
 *       the channel's subframe list.
327
 *       The algorithm repeats these steps until the frame is properly divided
328
 *       between the individual channels.
329
 *
330
 * @param s context
331
 * @return 0 on success, < 0 in case of an error
332
 */
333
269
static int decode_tilehdr(WmallDecodeCtx *s)
334
{
335
269
    uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
336
    uint8_t  contains_subframe[WMALL_MAX_CHANNELS];   /* flag indicating if a channel contains the current subframe */
337
269
    int channels_for_cur_subframe = s->num_channels;  /* number of channels that contain the current subframe */
338
269
    int fixed_channel_layout = 0;                     /* flag indicating that all channels use the same subfra2me offsets and sizes */
339
269
    int min_channel_len = 0;                          /* smallest sum of samples (channels with this length will be processed first) */
340
    int c, tile_aligned;
341
342
    /* reset tiling information */
343
807
    for (c = 0; c < s->num_channels; c++)
344
538
        s->channel[c].num_subframes = 0;
345
346
269
    tile_aligned = get_bits1(&s->gb);
347

269
    if (s->max_num_subframes == 1 || tile_aligned)
348
        fixed_channel_layout = 1;
349
350
    /* loop until the frame data is split between the subframes */
351
    do {
352
269
        int subframe_len, in_use = 0;
353
354
        /* check which channels contain the subframe */
355
807
        for (c = 0; c < s->num_channels; c++) {
356
538
            if (num_samples[c] == min_channel_len) {
357

538
                if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
358
538
                   (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
359
                    contains_subframe[c] = 1;
360
                } else {
361
538
                    contains_subframe[c] = get_bits1(&s->gb);
362
                }
363
538
                in_use |= contains_subframe[c];
364
            } else
365
                contains_subframe[c] = 0;
366
        }
367
368
269
        if (!in_use) {
369
            av_log(s->avctx, AV_LOG_ERROR,
370
                   "Found empty subframe\n");
371
            return AVERROR_INVALIDDATA;
372
        }
373
374
        /* get subframe length, subframe_len == 0 is not allowed */
375
269
        if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
376
            return AVERROR_INVALIDDATA;
377
        /* add subframes to the individual channels and find new min_channel_len */
378
269
        min_channel_len += subframe_len;
379
807
        for (c = 0; c < s->num_channels; c++) {
380
538
            WmallChannelCtx *chan = &s->channel[c];
381
382
538
            if (contains_subframe[c]) {
383
538
                if (chan->num_subframes >= MAX_SUBFRAMES) {
384
                    av_log(s->avctx, AV_LOG_ERROR,
385
                           "broken frame: num subframes > 31\n");
386
                    return AVERROR_INVALIDDATA;
387
                }
388
538
                chan->subframe_len[chan->num_subframes] = subframe_len;
389
538
                num_samples[c] += subframe_len;
390
538
                ++chan->num_subframes;
391
538
                if (num_samples[c] > s->samples_per_frame) {
392
                    av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
393
                           "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
394
                           num_samples[c], s->samples_per_frame);
395
                    return AVERROR_INVALIDDATA;
396
                }
397
            } else if (num_samples[c] <= min_channel_len) {
398
                if (num_samples[c] < min_channel_len) {
399
                    channels_for_cur_subframe = 0;
400
                    min_channel_len = num_samples[c];
401
                }
402
                ++channels_for_cur_subframe;
403
            }
404
        }
405
269
    } while (min_channel_len < s->samples_per_frame);
406
407
807
    for (c = 0; c < s->num_channels; c++) {
408
538
        int i, offset = 0;
409
1076
        for (i = 0; i < s->channel[c].num_subframes; i++) {
410
538
            s->channel[c].subframe_offsets[i] = offset;
411
538
            offset += s->channel[c].subframe_len[i];
412
        }
413
    }
414
415
269
    return 0;
416
}
417
418
26
static void decode_ac_filter(WmallDecodeCtx *s)
419
{
420
    int i;
421
26
    s->acfilter_order   = get_bits(&s->gb, 4) + 1;
422
26
    s->acfilter_scaling = get_bits(&s->gb, 4);
423
424
52
    for (i = 0; i < s->acfilter_order; i++)
425
26
        s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
426
26
}
427
428
23
static void decode_mclms(WmallDecodeCtx *s)
429
{
430
23
    s->mclms_order   = (get_bits(&s->gb, 4) + 1) * 2;
431
23
    s->mclms_scaling = get_bits(&s->gb, 4);
432
23
    if (get_bits1(&s->gb)) {
433
        int i, send_coef_bits;
434
        int cbits = av_log2(s->mclms_scaling + 1);
435
        if (1 << cbits < s->mclms_scaling + 1)
436
            cbits++;
437
438
        send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
439
440
        for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
441
            s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
442
443
        for (i = 0; i < s->num_channels; i++) {
444
            int c;
445
            for (c = 0; c < i; c++)
446
                s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
447
        }
448
    }
449
23
}
450
451
26
static int decode_cdlms(WmallDecodeCtx *s)
452
{
453
    int c, i;
454
26
    int cdlms_send_coef = get_bits1(&s->gb);
455
456
78
    for (c = 0; c < s->num_channels; c++) {
457
52
        s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
458
150
        for (i = 0; i < s->cdlms_ttl[c]; i++) {
459
98
            s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
460
98
            if (s->cdlms[c][i].order > MAX_ORDER) {
461
                av_log(s->avctx, AV_LOG_ERROR,
462
                       "Order[%d][%d] %d > max (%d), not supported\n",
463
                       c, i, s->cdlms[c][i].order, MAX_ORDER);
464
                s->cdlms[0][0].order = 0;
465
                return AVERROR_INVALIDDATA;
466
            }
467

98
            if(s->cdlms[c][i].order & 8 && s->bits_per_sample == 16) {
468
                static int warned;
469
                if(!warned)
470
                    avpriv_request_sample(s->avctx, "CDLMS of order %d",
471
                                          s->cdlms[c][i].order);
472
                warned = 1;
473
            }
474
        }
475
476
150
        for (i = 0; i < s->cdlms_ttl[c]; i++)
477
98
            s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
478
479
52
        if (cdlms_send_coef) {
480
            for (i = 0; i < s->cdlms_ttl[c]; i++) {
481
                int cbits, shift_l, shift_r, j;
482
                cbits = av_log2(s->cdlms[c][i].order);
483
                if ((1 << cbits) < s->cdlms[c][i].order)
484
                    cbits++;
485
                s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
486
487
                cbits = av_log2(s->cdlms[c][i].scaling + 1);
488
                if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
489
                    cbits++;
490
491
                s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
492
                shift_l = 32 - s->cdlms[c][i].bitsend;
493
                shift_r = 32 - s->cdlms[c][i].scaling - 2;
494
                for (j = 0; j < s->cdlms[c][i].coefsend; j++)
495
                    s->cdlms[c][i].coefs[j] =
496
                        (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
497
            }
498
        }
499
500
150
        for (i = 0; i < s->cdlms_ttl[c]; i++)
501
98
            memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
502
                   0, WMALL_COEFF_PAD_SIZE);
503
    }
504
505
26
    return 0;
506
}
507
508
504
static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
509
{
510
504
    int i = 0;
511
    unsigned int ave_mean;
512
504
    s->transient[ch] = get_bits1(&s->gb);
513
504
    if (s->transient[ch]) {
514
1
        s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
515
1
        if (s->transient_pos[ch])
516
1
            s->transient[ch] = 0;
517
1
        s->channel[ch].transient_counter =
518
1
            FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
519
503
    } else if (s->channel[ch].transient_counter)
520
503
        s->transient[ch] = 1;
521
522
504
    if (s->seekable_tile) {
523
51
        ave_mean = get_bits(&s->gb, s->bits_per_sample);
524
51
        s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
525
    }
526
527
504
    if (s->seekable_tile) {
528
51
        if (s->do_inter_ch_decorr)
529
51
            s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
530
        else
531
            s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
532
51
        i++;
533
    }
534
1032067
    for (; i < tile_size; i++) {
535
        int rem, rem_bits;
536
1031564
        unsigned quo = 0, residue;
537
2032470
        while(get_bits1(&s->gb)) {
538
1000907
            quo++;
539
1000907
            if (get_bits_left(&s->gb) <= 0)
540
1
                return -1;
541
        }
542
1031563
        if (quo >= 32)
543
            quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
544
545
1031563
        ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
546
1031563
        if (ave_mean <= 1)
547
52125
            residue = quo;
548
        else {
549
979438
            rem_bits = av_ceil_log2(ave_mean);
550
979438
            rem      = get_bits_long(&s->gb, rem_bits);
551
979438
            residue  = (quo << rem_bits) + rem;
552
        }
553
554
1031563
        s->ave_sum[ch] = residue + s->ave_sum[ch] -
555
1031563
                         (s->ave_sum[ch] >> s->movave_scaling);
556
557
1031563
        residue = (residue >> 1) ^ -(residue & 1);
558
1031563
        s->channel_residues[ch][i] = residue;
559
    }
560
561
503
    return 0;
562
563
}
564
565
static void decode_lpc(WmallDecodeCtx *s)
566
{
567
    int ch, i, cbits;
568
    s->lpc_order   = get_bits(&s->gb, 5) + 1;
569
    s->lpc_scaling = get_bits(&s->gb, 4);
570
    s->lpc_intbits = get_bits(&s->gb, 3) + 1;
571
    cbits = s->lpc_scaling + s->lpc_intbits;
572
    for (ch = 0; ch < s->num_channels; ch++)
573
        for (i = 0; i < s->lpc_order; i++)
574
            s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
575
}
576
577
26
static void clear_codec_buffers(WmallDecodeCtx *s)
578
{
579
    int ich, ilms;
580
581
26
    memset(s->acfilter_coeffs,     0, sizeof(s->acfilter_coeffs));
582
26
    memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
583
26
    memset(s->lpc_coefs,           0, sizeof(s->lpc_coefs));
584
585
26
    memset(s->mclms_coeffs,     0, sizeof(s->mclms_coeffs));
586
26
    memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
587
26
    memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
588
26
    memset(s->mclms_updates,    0, sizeof(s->mclms_updates));
589
590
78
    for (ich = 0; ich < s->num_channels; ich++) {
591
140
        for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
592
88
            memset(s->cdlms[ich][ilms].coefs, 0,
593
                   sizeof(s->cdlms[ich][ilms].coefs));
594
88
            memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
595
                   sizeof(s->cdlms[ich][ilms].lms_prevvalues));
596
88
            memset(s->cdlms[ich][ilms].lms_updates, 0,
597
                   sizeof(s->cdlms[ich][ilms].lms_updates));
598
        }
599
52
        s->ave_sum[ich] = 0;
600
    }
601
26
}
602
603
/**
604
 * @brief Reset filter parameters and transient area at new seekable tile.
605
 */
606
26
static void reset_codec(WmallDecodeCtx *s)
607
{
608
    int ich, ilms;
609
26
    s->mclms_recent = s->mclms_order * s->num_channels;
610
78
    for (ich = 0; ich < s->num_channels; ich++) {
611
150
        for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
612
98
            s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
613
        /* first sample of a seekable subframe is considered as the starting of
614
            a transient area which is samples_per_frame samples long */
615
52
        s->channel[ich].transient_counter = s->samples_per_frame;
616
52
        s->transient[ich]     = 1;
617
52
        s->transient_pos[ich] = 0;
618
    }
619
26
}
620
621
448512
static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
622
{
623
    int i, j, ich, pred_error;
624
448512
    int order        = s->mclms_order;
625
448512
    int num_channels = s->num_channels;
626
448512
    int range        = 1 << (s->bits_per_sample - 1);
627
628
1345536
    for (ich = 0; ich < num_channels; ich++) {
629
897024
        pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
630
897024
        if (pred_error > 0) {
631
2248105
            for (i = 0; i < order * num_channels; i++)
632
1798484
                s->mclms_coeffs[i + ich * order * num_channels] +=
633
1798484
                    s->mclms_updates[s->mclms_recent + i];
634
672836
            for (j = 0; j < ich; j++)
635
223215
                s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
636
447403
        } else if (pred_error < 0) {
637
2219705
            for (i = 0; i < order * num_channels; i++)
638
1775764
                s->mclms_coeffs[i + ich * order * num_channels] -=
639
1775764
                    s->mclms_updates[s->mclms_recent + i];
640
667249
            for (j = 0; j < ich; j++)
641
223308
                s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
642
        }
643
    }
644
645
1345536
    for (ich = num_channels - 1; ich >= 0; ich--) {
646
897024
        s->mclms_recent--;
647
897024
        s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
648
            -range, range - 1);
649
897024
        s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
650
    }
651
652
448512
    if (s->mclms_recent == 0) {
653
224256
        memcpy(&s->mclms_prevvalues[order * num_channels],
654
224256
               s->mclms_prevvalues,
655
224256
               sizeof(int32_t) * order * num_channels);
656
224256
        memcpy(&s->mclms_updates[order * num_channels],
657
224256
               s->mclms_updates,
658
224256
               sizeof(int32_t) * order * num_channels);
659
224256
        s->mclms_recent = num_channels * order;
660
    }
661
448512
}
662
663
448512
static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
664
{
665
    int ich, i;
666
448512
    int order        = s->mclms_order;
667
448512
    int num_channels = s->num_channels;
668
669
1345536
    for (ich = 0; ich < num_channels; ich++) {
670
897024
        pred[ich] = 0;
671
897024
        if (!s->is_channel_coded[ich])
672
            continue;
673
4485120
        for (i = 0; i < order * num_channels; i++)
674
3588096
            pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
675
3588096
                         s->mclms_coeffs[i + order * num_channels * ich];
676
1345536
        for (i = 0; i < ich; i++)
677
448512
            pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
678
448512
                         s->mclms_coeffs_cur[i + num_channels * ich];
679
897024
        pred[ich] += (1U << s->mclms_scaling) >> 1;
680
897024
        pred[ich] >>= s->mclms_scaling;
681
897024
        s->channel_residues[ich][icoef] += (unsigned)pred[ich];
682
    }
683
448512
}
684
685
219
static void revert_mclms(WmallDecodeCtx *s, int tile_size)
686
{
687
219
    int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
688
448731
    for (icoef = 0; icoef < tile_size; icoef++) {
689
448512
        mclms_predict(s, icoef, pred);
690
448512
        mclms_update(s, icoef, pred);
691
    }
692
219
}
693
694
51
static void use_high_update_speed(WmallDecodeCtx *s, int ich)
695
{
696
    int ilms, recent, icoef;
697
148
    for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
698
97
        recent = s->cdlms[ich][ilms].recent;
699
97
        if (s->update_speed[ich] == 16)
700
            continue;
701
97
        if (s->bV3RTM) {
702
97
            for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
703
88
                s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
704
        } else {
705
3608
            for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
706
3520
                s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
707
        }
708
    }
709
51
    s->update_speed[ich] = 16;
710
51
}
711
712
453
static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
713
{
714
    int ilms, recent, icoef;
715
1298
    for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
716
845
        recent = s->cdlms[ich][ilms].recent;
717
845
        if (s->update_speed[ich] == 8)
718
747
            continue;
719
98
        if (s->bV3RTM)
720
106
            for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
721
96
                s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
722
        else
723
3608
            for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
724
3520
                s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
725
    }
726
453
    s->update_speed[ich] = 8;
727
453
}
728
729
#define CD_LMS(bits, ROUND) \
730
static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
731
{ \
732
    int recent = s->cdlms[ich][ilms].recent; \
733
    int range  = 1 << s->bits_per_sample - 1; \
734
    int order  = s->cdlms[ich][ilms].order; \
735
    int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
736
 \
737
    if (recent) \
738
        recent--; \
739
    else { \
740
        memcpy(prev + order, prev, (bits/8) * order); \
741
        memcpy(s->cdlms[ich][ilms].lms_updates + order, \
742
               s->cdlms[ich][ilms].lms_updates, \
743
               sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
744
        recent = order - 1; \
745
    } \
746
 \
747
    prev[recent] = av_clip(input, -range, range - 1); \
748
    s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
749
 \
750
    s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
751
    s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
752
    s->cdlms[ich][ilms].recent = recent; \
753
    memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
754
           sizeof(s->cdlms[ich][ilms].lms_updates) - \
755
           sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
756
} \
757
 \
758
static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
759
                                  int coef_begin, int coef_end) \
760
{ \
761
    int icoef, ilms, num_lms, residue, input; \
762
    unsigned pred;\
763
 \
764
    num_lms = s->cdlms_ttl[ch]; \
765
    for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
766
        for (icoef = coef_begin; icoef < coef_end; icoef++) { \
767
            int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
768
            pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
769
            residue = s->channel_residues[ch][icoef]; \
770
            pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
771
                                                        prevvalues + s->cdlms[ch][ilms].recent, \
772
                                                        s->cdlms[ch][ilms].lms_updates + \
773
                                                        s->cdlms[ch][ilms].recent, \
774
                                                        FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
775
                                                        WMASIGN(residue)); \
776
            input = residue + (unsigned)((int)pred >> s->cdlms[ch][ilms].scaling); \
777
            lms_update ## bits(s, ch, ilms, input); \
778
            s->channel_residues[ch][icoef] = input; \
779
        } \
780
    } \
781
    if (bits <= 16) emms_c(); \
782
}
783
784

6883800
CD_LMS(16, WMALL_COEFF_PAD_SIZE)
785

417978
CD_LMS(32, 8)
786
787
264
static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
788
{
789
264
    if (s->num_channels != 2)
790
        return;
791

264
    else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
792
        int icoef;
793
540936
        for (icoef = 0; icoef < tile_size; icoef++) {
794
540672
            s->channel_residues[0][icoef] -= (unsigned)(s->channel_residues[1][icoef] >> 1);
795
540672
            s->channel_residues[1][icoef] += (unsigned) s->channel_residues[0][icoef];
796
        }
797
    }
798
}
799
800
264
static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
801
{
802
    int ich, pred, i, j;
803
264
    int16_t *filter_coeffs = s->acfilter_coeffs;
804
264
    int scaling            = s->acfilter_scaling;
805
264
    int order              = s->acfilter_order;
806
807
792
    for (ich = 0; ich < s->num_channels; ich++) {
808
528
        int *prevvalues = s->acfilter_prevvalues[ich];
809
1056
        for (i = 0; i < order; i++) {
810
528
            pred = 0;
811
1056
            for (j = 0; j < order; j++) {
812
528
                if (i <= j)
813
528
                    pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
814
                else
815
                    pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
816
            }
817
528
            pred >>= scaling;
818
528
            s->channel_residues[ich][i] += (unsigned)pred;
819
        }
820
1081344
        for (i = order; i < tile_size; i++) {
821
1080816
            pred = 0;
822
2161632
            for (j = 0; j < order; j++)
823
1080816
                pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
824
1080816
            pred >>= scaling;
825
1080816
            s->channel_residues[ich][i] += (unsigned)pred;
826
        }
827
1056
        for (j = order - 1; j >= 0; j--)
828
528
            if (tile_size <= j) {
829
                prevvalues[j] = prevvalues[j - tile_size];
830
            }else
831
528
                prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
832
    }
833
264
}
834
835
269
static int decode_subframe(WmallDecodeCtx *s)
836
{
837
269
    int offset        = s->samples_per_frame;
838
269
    int subframe_len  = s->samples_per_frame;
839
269
    int total_samples = s->samples_per_frame * s->num_channels;
840
    int i, j, rawpcm_tile, padding_zeroes, res;
841
842
269
    s->subframe_offset = get_bits_count(&s->gb);
843
844
    /* reset channel context and find the next block offset and size
845
        == the next block of the channel with the smallest number of
846
        decoded samples */
847
807
    for (i = 0; i < s->num_channels; i++) {
848
538
        if (offset > s->channel[i].decoded_samples) {
849
269
            offset = s->channel[i].decoded_samples;
850
269
            subframe_len =
851
269
                s->channel[i].subframe_len[s->channel[i].cur_subframe];
852
        }
853
    }
854
855
    /* get a list of all channels that contain the estimated block */
856
269
    s->channels_for_cur_subframe = 0;
857
807
    for (i = 0; i < s->num_channels; i++) {
858
538
        const int cur_subframe = s->channel[i].cur_subframe;
859
        /* subtract already processed samples */
860
538
        total_samples -= s->channel[i].decoded_samples;
861
862
        /* and count if there are multiple subframes that match our profile */
863
538
        if (offset == s->channel[i].decoded_samples &&
864
538
            subframe_len == s->channel[i].subframe_len[cur_subframe]) {
865
538
            total_samples -= s->channel[i].subframe_len[cur_subframe];
866
538
            s->channel[i].decoded_samples +=
867
538
                s->channel[i].subframe_len[cur_subframe];
868
538
            s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
869
538
            ++s->channels_for_cur_subframe;
870
        }
871
    }
872
873
    /* check if the frame will be complete after processing the
874
        estimated block */
875
269
    if (!total_samples)
876
269
        s->parsed_all_subframes = 1;
877
878
879
269
    s->seekable_tile = get_bits1(&s->gb);
880
269
    if (s->seekable_tile) {
881
26
        clear_codec_buffers(s);
882
883
26
        s->do_arith_coding    = get_bits1(&s->gb);
884
26
        if (s->do_arith_coding) {
885
            avpriv_request_sample(s->avctx, "Arithmetic coding");
886
            return AVERROR_PATCHWELCOME;
887
        }
888
26
        s->do_ac_filter       = get_bits1(&s->gb);
889
26
        s->do_inter_ch_decorr = get_bits1(&s->gb);
890
26
        s->do_mclms           = get_bits1(&s->gb);
891
892
26
        if (s->do_ac_filter)
893
26
            decode_ac_filter(s);
894
895
26
        if (s->do_mclms)
896
23
            decode_mclms(s);
897
898
26
        if ((res = decode_cdlms(s)) < 0)
899
            return res;
900
26
        s->movave_scaling = get_bits(&s->gb, 3);
901
26
        s->quant_stepsize = get_bits(&s->gb, 8) + 1;
902
903
26
        reset_codec(s);
904
    }
905
906
269
    rawpcm_tile = get_bits1(&s->gb);
907
908

269
    if (!rawpcm_tile && !s->cdlms[0][0].order) {
909
        av_log(s->avctx, AV_LOG_DEBUG,
910
               "Waiting for seekable tile\n");
911
        av_frame_unref(s->frame);
912
        return -1;
913
    }
914
915
916
807
    for (i = 0; i < s->num_channels; i++)
917
538
        s->is_channel_coded[i] = 1;
918
919
269
    if (!rawpcm_tile) {
920
792
        for (i = 0; i < s->num_channels; i++)
921
528
            s->is_channel_coded[i] = get_bits1(&s->gb);
922
923
264
        if (s->bV3RTM) {
924
            // LPC
925
54
            s->do_lpc = get_bits1(&s->gb);
926
54
            if (s->do_lpc) {
927
                decode_lpc(s);
928
                avpriv_request_sample(s->avctx, "Expect wrong output since "
929
                                      "inverse LPC filter");
930
            }
931
        } else
932
210
            s->do_lpc = 0;
933
    }
934
935
269
    if (get_bits_left(&s->gb) < 1)
936
        return AVERROR_INVALIDDATA;
937
938
269
    if (get_bits1(&s->gb))
939
9
        padding_zeroes = get_bits(&s->gb, 5);
940
    else
941
260
        padding_zeroes = 0;
942
943
269
    if (rawpcm_tile) {
944
5
        int bits = s->bits_per_sample - padding_zeroes;
945
5
        if (bits <= 0) {
946
            av_log(s->avctx, AV_LOG_ERROR,
947
                   "Invalid number of padding bits in raw PCM tile\n");
948
            return AVERROR_INVALIDDATA;
949
        }
950
        ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
951
                "total %d bits, remain=%d\n", bits,
952
                bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
953
15
        for (i = 0; i < s->num_channels; i++)
954
20490
            for (j = 0; j < subframe_len; j++)
955
20480
                s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
956
    } else {
957
264
        if (s->bits_per_sample < padding_zeroes)
958
            return AVERROR_INVALIDDATA;
959
792
        for (i = 0; i < s->num_channels; i++) {
960
528
            if (s->is_channel_coded[i]) {
961
504
                decode_channel_residues(s, i, subframe_len);
962
504
                if (s->seekable_tile)
963
51
                    use_high_update_speed(s, i);
964
                else
965
453
                    use_normal_update_speed(s, i);
966
504
                if (s->bits_per_sample > 16)
967
84
                    revert_cdlms32(s, i, 0, subframe_len);
968
                else
969
420
                    revert_cdlms16(s, i, 0, subframe_len);
970
            } else {
971
24
                memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
972
            }
973
        }
974
975
264
        if (s->do_mclms)
976
219
            revert_mclms(s, subframe_len);
977
264
        if (s->do_inter_ch_decorr)
978
264
            revert_inter_ch_decorr(s, subframe_len);
979
264
        if (s->do_ac_filter)
980
264
            revert_acfilter(s, subframe_len);
981
982
        /* Dequantize */
983
264
        if (s->quant_stepsize != 1)
984
            for (i = 0; i < s->num_channels; i++)
985
                for (j = 0; j < subframe_len; j++)
986
                    s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
987
    }
988
989
    /* Write to proper output buffer depending on bit-depth */
990
807
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
991
538
        int c = s->channel_indexes_for_cur_subframe[i];
992
538
        int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
993
994
1102362
        for (j = 0; j < subframe_len; j++) {
995
1101824
            if (s->bits_per_sample == 16) {
996
860160
                *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
997
            } else {
998
241664
                *s->samples_32[c]++ = s->channel_residues[c][j] * (256U << padding_zeroes);
999
            }
1000
        }
1001
    }
1002
1003
    /* handled one subframe */
1004
807
    for (i = 0; i < s->channels_for_cur_subframe; i++) {
1005
538
        int c = s->channel_indexes_for_cur_subframe[i];
1006
538
        if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1007
            av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1008
            return AVERROR_INVALIDDATA;
1009
        }
1010
538
        ++s->channel[c].cur_subframe;
1011
    }
1012
269
    return 0;
1013
}
1014
1015
/**
1016
 * @brief Decode one WMA frame.
1017
 * @param s codec context
1018
 * @return 0 if the trailer bit indicates that this is the last frame,
1019
 *         1 if there are additional frames
1020
 */
1021
269
static int decode_frame(WmallDecodeCtx *s)
1022
{
1023
269
    GetBitContext* gb = &s->gb;
1024
269
    int more_frames = 0, len = 0, i, ret;
1025
1026
269
    s->frame->nb_samples = s->samples_per_frame;
1027
269
    if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1028
        /* return an error if no frame could be decoded at all */
1029
        s->packet_loss = 1;
1030
        s->frame->nb_samples = 0;
1031
        return ret;
1032
    }
1033
807
    for (i = 0; i < s->num_channels; i++) {
1034
538
        s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1035
538
        s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1036
    }
1037
1038
    /* get frame length */
1039
269
    if (s->len_prefix)
1040
        len = get_bits(gb, s->log2_frame_size);
1041
1042
    /* decode tile information */
1043
269
    if ((ret = decode_tilehdr(s))) {
1044
        s->packet_loss = 1;
1045
        av_frame_unref(s->frame);
1046
        return ret;
1047
    }
1048
1049
    /* read drc info */
1050
269
    if (s->dynamic_range_compression)
1051
50
        s->drc_gain = get_bits(gb, 8);
1052
1053
    /* no idea what these are for, might be the number of samples
1054
       that need to be skipped at the beginning or end of a stream */
1055
269
    if (get_bits1(gb)) {
1056
        int av_unused skip;
1057
1058
        /* usually true for the first frame */
1059
1
        if (get_bits1(gb)) {
1060
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1061
            ff_dlog(s->avctx, "start skip: %i\n", skip);
1062
        }
1063
1064
        /* sometimes true for the last frame */
1065
1
        if (get_bits1(gb)) {
1066
1
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1067
            ff_dlog(s->avctx, "end skip: %i\n", skip);
1068
1
            s->frame->nb_samples -= skip;
1069
1
            if (s->frame->nb_samples <= 0)
1070
                return AVERROR_INVALIDDATA;
1071
        }
1072
1073
    }
1074
1075
    /* reset subframe states */
1076
269
    s->parsed_all_subframes = 0;
1077
807
    for (i = 0; i < s->num_channels; i++) {
1078
538
        s->channel[i].decoded_samples = 0;
1079
538
        s->channel[i].cur_subframe    = 0;
1080
    }
1081
1082
    /* decode all subframes */
1083
538
    while (!s->parsed_all_subframes) {
1084
269
        int decoded_samples = s->channel[0].decoded_samples;
1085
269
        if (decode_subframe(s) < 0) {
1086
            s->packet_loss = 1;
1087
            if (s->frame->nb_samples)
1088
                s->frame->nb_samples = decoded_samples;
1089
            return 0;
1090
        }
1091
    }
1092
1093
    ff_dlog(s->avctx, "Frame done\n");
1094
1095
269
    s->skip_frame = 0;
1096
1097
269
    if (s->len_prefix) {
1098
        if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1099
            /* FIXME: not sure if this is always an error */
1100
            av_log(s->avctx, AV_LOG_ERROR,
1101
                   "frame[%"PRIu32"] would have to skip %i bits\n",
1102
                   s->frame_num,
1103
                   len - (get_bits_count(gb) - s->frame_offset) - 1);
1104
            s->packet_loss = 1;
1105
            return 0;
1106
        }
1107
1108
        /* skip the rest of the frame data */
1109
        skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1110
    }
1111
1112
    /* decode trailer bit */
1113
269
    more_frames = get_bits1(gb);
1114
269
    ++s->frame_num;
1115
269
    return more_frames;
1116
}
1117
1118
/**
1119
 * @brief Calculate remaining input buffer length.
1120
 * @param s  codec context
1121
 * @param gb bitstream reader context
1122
 * @return remaining size in bits
1123
 */
1124
469
static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1125
{
1126
469
    return s->buf_bit_size - get_bits_count(gb);
1127
}
1128
1129
/**
1130
 * @brief Fill the bit reservoir with a (partial) frame.
1131
 * @param s      codec context
1132
 * @param gb     bitstream reader context
1133
 * @param len    length of the partial frame
1134
 * @param append decides whether to reset the buffer or not
1135
 */
1136
177
static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1137
                      int append)
1138
{
1139
    int buflen;
1140
    PutBitContext tmp;
1141
1142
    /* when the frame data does not need to be concatenated, the input buffer
1143
        is reset and additional bits from the previous frame are copied
1144
        and skipped later so that a fast byte copy is possible */
1145
1146
177
    if (!append) {
1147
89
        s->frame_offset   = get_bits_count(gb) & 7;
1148
89
        s->num_saved_bits = s->frame_offset;
1149
89
        init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1150
    }
1151
1152
177
    buflen = (s->num_saved_bits + len + 8) >> 3;
1153
1154

177
    if (len <= 0 || buflen > s->max_frame_size) {
1155
        avpriv_request_sample(s->avctx, "Too small input buffer");
1156
        s->packet_loss = 1;
1157
        s->num_saved_bits = 0;
1158
        return;
1159
    }
1160
1161
177
    s->num_saved_bits += len;
1162
177
    if (!append) {
1163
89
        avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1164
                         s->num_saved_bits);
1165
    } else {
1166
88
        int align = 8 - (get_bits_count(gb) & 7);
1167
88
        align = FFMIN(align, len);
1168
88
        put_bits(&s->pb, align, get_bits(gb, align));
1169
88
        len -= align;
1170
88
        avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1171
    }
1172
177
    skip_bits_long(gb, len);
1173
1174
177
    tmp = s->pb;
1175
177
    flush_put_bits(&tmp);
1176
1177
177
    init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1178
177
    skip_bits(&s->gb, s->frame_offset);
1179
}
1180
1181
285
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1182
                         AVPacket* avpkt)
1183
{
1184
285
    WmallDecodeCtx *s = avctx->priv_data;
1185
285
    GetBitContext* gb  = &s->pgb;
1186
285
    const uint8_t* buf = avpkt->data;
1187
285
    int buf_size       = avpkt->size;
1188
    int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1189
1190
285
    s->frame->nb_samples = 0;
1191
1192

285
    if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1193
11
        s->packet_done = 0;
1194
11
        if (!decode_frame(s))
1195
4
            s->num_saved_bits = 0;
1196

274
    } else if (s->packet_done || s->packet_loss) {
1197
92
        s->packet_done = 0;
1198
1199
92
        if (!buf_size)
1200
            return 0;
1201
1202
92
        s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1203
92
        buf_size             = FFMIN(avctx->block_align, buf_size);
1204
92
        s->buf_bit_size      = buf_size << 3;
1205
1206
        /* parse packet header */
1207
92
        init_get_bits(gb, buf, s->buf_bit_size);
1208
92
        packet_sequence_number = get_bits(gb, 4);
1209
92
        skip_bits(gb, 1);   // Skip seekable_frame_in_packet, currently unused
1210
92
        spliced_packet = get_bits1(gb);
1211
92
        if (spliced_packet)
1212
            avpriv_request_sample(avctx, "Bitstream splicing");
1213
1214
        /* get number of bits that need to be added to the previous frame */
1215
92
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1216
1217
        /* check for packet loss */
1218
92
        if (!s->packet_loss &&
1219
88
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1220
            s->packet_loss = 1;
1221
            av_log(avctx, AV_LOG_ERROR,
1222
                   "Packet loss detected! seq %"PRIx8" vs %x\n",
1223
                   s->packet_sequence_number, packet_sequence_number);
1224
        }
1225
92
        s->packet_sequence_number = packet_sequence_number;
1226
1227
92
        if (num_bits_prev_frame > 0) {
1228
88
            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1229
88
            if (num_bits_prev_frame >= remaining_packet_bits) {
1230
3
                num_bits_prev_frame = remaining_packet_bits;
1231
3
                s->packet_done = 1;
1232
            }
1233
1234
            /* Append the previous frame data to the remaining data from the
1235
             * previous packet to create a full frame. */
1236
88
            save_bits(s, gb, num_bits_prev_frame, 1);
1237
1238
            /* decode the cross packet frame if it is valid */
1239

88
            if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1240
85
                decode_frame(s);
1241
4
        } else if (s->num_saved_bits - s->frame_offset) {
1242
            ff_dlog(avctx, "ignoring %x previously saved bits\n",
1243
                    s->num_saved_bits - s->frame_offset);
1244
        }
1245
1246
92
        if (s->packet_loss) {
1247
            /* Reset number of saved bits so that the decoder does not start
1248
             * to decode incomplete frames in the s->len_prefix == 0 case. */
1249
4
            s->num_saved_bits = 0;
1250
4
            s->packet_loss    = 0;
1251
4
            init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1252
        }
1253
1254
    } else {
1255
        int frame_size;
1256
1257
182
        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1258
182
        init_get_bits(gb, avpkt->data, s->buf_bit_size);
1259
182
        skip_bits(gb, s->packet_offset);
1260
1261

182
        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1262
            (frame_size = show_bits(gb, s->log2_frame_size)) &&
1263
            frame_size <= remaining_bits(s, gb)) {
1264
            save_bits(s, gb, frame_size, 0);
1265
1266
            if (!s->packet_loss)
1267
                s->packet_done = !decode_frame(s);
1268
182
        } else if (!s->len_prefix
1269
182
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
1270
            /* when the frames do not have a length prefix, we don't know the
1271
             * compressed length of the individual frames however, we know what
1272
             * part of a new packet belongs to the previous frame therefore we
1273
             * save the incoming packet first, then we append the "previous
1274
             * frame" data from the next packet so that we get a buffer that
1275
             * only contains full frames */
1276
173
            s->packet_done = !decode_frame(s);
1277
        } else {
1278
9
            s->packet_done = 1;
1279
        }
1280
    }
1281
1282
285
    if (remaining_bits(s, gb) < 0) {
1283
        av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1284
        s->packet_loss = 1;
1285
    }
1286
1287

380
    if (s->packet_done && !s->packet_loss &&
1288
95
        remaining_bits(s, gb) > 0) {
1289
        /* save the rest of the data so that it can be decoded
1290
         * with the next packet */
1291
89
        save_bits(s, gb, remaining_bits(s, gb), 0);
1292
    }
1293
1294
285
    *got_frame_ptr   = s->frame->nb_samples > 0;
1295
285
    av_frame_move_ref(data, s->frame);
1296
1297
285
    s->packet_offset = get_bits_count(gb) & 7;
1298
1299

285
    return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1300
}
1301
1302
static void flush(AVCodecContext *avctx)
1303
{
1304
    WmallDecodeCtx *s    = avctx->priv_data;
1305
    s->packet_loss       = 1;
1306
    s->packet_done       = 0;
1307
    s->num_saved_bits    = 0;
1308
    s->frame_offset      = 0;
1309
    s->next_packet_start = 0;
1310
    s->cdlms[0][0].order = 0;
1311
    s->frame->nb_samples = 0;
1312
    init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1313
}
1314
1315
8
static av_cold int decode_close(AVCodecContext *avctx)
1316
{
1317
8
    WmallDecodeCtx *s = avctx->priv_data;
1318
1319
8
    av_frame_free(&s->frame);
1320
8
    av_freep(&s->frame_data);
1321
1322
8
    return 0;
1323
}
1324
1325
AVCodec ff_wmalossless_decoder = {
1326
    .name           = "wmalossless",
1327
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1328
    .type           = AVMEDIA_TYPE_AUDIO,
1329
    .id             = AV_CODEC_ID_WMALOSSLESS,
1330
    .priv_data_size = sizeof(WmallDecodeCtx),
1331
    .init           = decode_init,
1332
    .close          = decode_close,
1333
    .decode         = decode_packet,
1334
    .flush          = flush,
1335
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1336
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1337
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1338
                                                      AV_SAMPLE_FMT_S32P,
1339
                                                      AV_SAMPLE_FMT_NONE },
1340
};