GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/wmalosslessdec.c Lines: 480 622 77.2 %
Date: 2021-01-27 23:23:17 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
#include "libavutil/mem_internal.h"
30
31
#include "avcodec.h"
32
#include "internal.h"
33
#include "get_bits.h"
34
#include "put_bits.h"
35
#include "lossless_audiodsp.h"
36
#include "wma.h"
37
#include "wma_common.h"
38
39
/** current decoder limitations */
40
#define WMALL_MAX_CHANNELS      8                       ///< max number of handled channels
41
#define MAX_SUBFRAMES          32                       ///< max number of subframes per channel
42
#define MAX_BANDS              29                       ///< max number of scale factor bands
43
#define MAX_FRAMESIZE       32768                       ///< maximum compressed frame size
44
#define MAX_ORDER             256
45
46
#define WMALL_BLOCK_MIN_BITS    6                       ///< log2 of min block size
47
#define WMALL_BLOCK_MAX_BITS   14                       ///< log2 of max block size
48
#define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS)    ///< maximum block size
49
#define WMALL_BLOCK_SIZES    (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
50
51
#define WMALL_COEFF_PAD_SIZE   16                       ///< pad coef buffers with 0 for use with SIMD
52
53
/**
54
 * @brief frame-specific decoder context for a single channel
55
 */
56
typedef struct WmallChannelCtx {
57
    int16_t     prev_block_len;                         ///< length of the previous block
58
    uint8_t     transmit_coefs;
59
    uint8_t     num_subframes;
60
    uint16_t    subframe_len[MAX_SUBFRAMES];            ///< subframe length in samples
61
    uint16_t    subframe_offsets[MAX_SUBFRAMES];        ///< subframe positions in the current frame
62
    uint8_t     cur_subframe;                           ///< current subframe number
63
    uint16_t    decoded_samples;                        ///< number of already processed samples
64
    int         quant_step;                             ///< quantization step for the current subframe
65
    int         transient_counter;                      ///< number of transient samples from the beginning of the transient zone
66
} WmallChannelCtx;
67
68
/**
69
 * @brief main decoder context
70
 */
71
typedef struct WmallDecodeCtx {
72
    /* generic decoder variables */
73
    AVCodecContext  *avctx;
74
    AVFrame         *frame;
75
    LLAudDSPContext dsp;                           ///< accelerated DSP functions
76
    uint8_t         *frame_data;                    ///< compressed frame data
77
    int             max_frame_size;                 ///< max bitstream size
78
    PutBitContext   pb;                             ///< context for filling the frame_data buffer
79
80
    /* frame size dependent frame information (set during initialization) */
81
    uint32_t        decode_flags;                   ///< used compression features
82
    int             len_prefix;                     ///< frame is prefixed with its length
83
    int             dynamic_range_compression;      ///< frame contains DRC data
84
    uint8_t         bits_per_sample;                ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
85
    uint16_t        samples_per_frame;              ///< number of samples to output
86
    uint16_t        log2_frame_size;
87
    int8_t          num_channels;                   ///< number of channels in the stream (same as AVCodecContext.num_channels)
88
    int8_t          lfe_channel;                    ///< lfe channel index
89
    uint8_t         max_num_subframes;
90
    uint8_t         subframe_len_bits;              ///< number of bits used for the subframe length
91
    uint8_t         max_subframe_len_bit;           ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
92
    uint16_t        min_samples_per_subframe;
93
94
    /* packet decode state */
95
    GetBitContext   pgb;                            ///< bitstream reader context for the packet
96
    int             next_packet_start;              ///< start offset of the next WMA packet in the demuxer packet
97
    uint8_t         packet_offset;                  ///< offset to the frame in the packet
98
    uint8_t         packet_sequence_number;         ///< current packet number
99
    int             num_saved_bits;                 ///< saved number of bits
100
    int             frame_offset;                   ///< frame offset in the bit reservoir
101
    int             subframe_offset;                ///< subframe offset in the bit reservoir
102
    uint8_t         packet_loss;                    ///< set in case of bitstream error
103
    uint8_t         packet_done;                    ///< set when a packet is fully decoded
104
105
    /* frame decode state */
106
    uint32_t        frame_num;                      ///< current frame number (not used for decoding)
107
    GetBitContext   gb;                             ///< bitstream reader context
108
    int             buf_bit_size;                   ///< buffer size in bits
109
    int16_t         *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
110
    int32_t         *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
111
    uint8_t         drc_gain;                       ///< gain for the DRC tool
112
    int8_t          skip_frame;                     ///< skip output step
113
    int8_t          parsed_all_subframes;           ///< all subframes decoded?
114
115
    /* subframe/block decode state */
116
    int16_t         subframe_len;                   ///< current subframe length
117
    int8_t          channels_for_cur_subframe;      ///< number of channels that contain the subframe
118
    int8_t          channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
119
120
    WmallChannelCtx channel[WMALL_MAX_CHANNELS];    ///< per channel data
121
122
    // WMA Lossless-specific
123
124
    uint8_t do_arith_coding;
125
    uint8_t do_ac_filter;
126
    uint8_t do_inter_ch_decorr;
127
    uint8_t do_mclms;
128
    uint8_t do_lpc;
129
130
    int8_t  acfilter_order;
131
    int8_t  acfilter_scaling;
132
    int16_t acfilter_coeffs[16];
133
    int     acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
134
135
    int8_t  mclms_order;
136
    int8_t  mclms_scaling;
137
    int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
138
    int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
139
    int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
140
    int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
141
    int     mclms_recent;
142
143
    int     movave_scaling;
144
    int     quant_stepsize;
145
146
    struct {
147
        int order;
148
        int scaling;
149
        int coefsend;
150
        int bitsend;
151
        DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
152
        DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153
        DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
154
        int recent;
155
    } cdlms[WMALL_MAX_CHANNELS][9];
156
157
    int cdlms_ttl[WMALL_MAX_CHANNELS];
158
159
    int bV3RTM;
160
161
    int is_channel_coded[WMALL_MAX_CHANNELS];
162
    int update_speed[WMALL_MAX_CHANNELS];
163
164
    int transient[WMALL_MAX_CHANNELS];
165
    int transient_pos[WMALL_MAX_CHANNELS];
166
    int seekable_tile;
167
168
    unsigned ave_sum[WMALL_MAX_CHANNELS];
169
170
    int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
171
172
    int lpc_coefs[WMALL_MAX_CHANNELS][40];
173
    int lpc_order;
174
    int lpc_scaling;
175
    int lpc_intbits;
176
} WmallDecodeCtx;
177
178
/** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
179
#define WMASIGN(x) (((x) > 0) - ((x) < 0))
180
181
8
static av_cold int decode_init(AVCodecContext *avctx)
182
{
183
8
    WmallDecodeCtx *s  = avctx->priv_data;
184
8
    uint8_t *edata_ptr = avctx->extradata;
185
    unsigned int channel_mask;
186
    int i, log2_max_num_subframes;
187
188

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

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

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

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

6883800
CD_LMS(16, WMALL_COEFF_PAD_SIZE)
786

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

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

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

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

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

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

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

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

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

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