GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/smacker.c Lines: 267 406 65.8 %
Date: 2020-09-25 23:16:12 Branches: 129 223 57.8 %

Line Branch Exec Source
1
/*
2
 * Smacker decoder
3
 * Copyright (c) 2006 Konstantin Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * Smacker decoder
25
 */
26
27
/*
28
 * Based on http://wiki.multimedia.cx/index.php?title=Smacker
29
 */
30
31
#include <stdio.h>
32
#include <stdlib.h>
33
34
#include "libavutil/channel_layout.h"
35
36
#include "avcodec.h"
37
38
#define SMKTREE_BITS 9
39
#define SMK_NODE 0x80000000
40
41
#define SMKTREE_DECODE_MAX_RECURSION FFMIN(32, 3 * SMKTREE_BITS)
42
#define SMKTREE_DECODE_BIG_MAX_RECURSION 500
43
44
/* The maximum possible unchecked overread happens in decode_header_trees:
45
 * Decoding the MMAP tree can overread by 6 * SMKTREE_BITS + 1, followed by
46
 * three get_bits1, followed by at most 2 + 3 * 16 read bits when reading
47
 * the TYPE tree before the next check. 64 is because of 64 bit reads. */
48
#if (6 * SMKTREE_BITS + 1 + 3 + (2 + 3 * 16) + 64) <= 8 * AV_INPUT_BUFFER_PADDING_SIZE
49
#define UNCHECKED_BITSTREAM_READER 1
50
#endif
51
#define BITSTREAM_READER_LE
52
#include "bytestream.h"
53
#include "get_bits.h"
54
#include "internal.h"
55
#include "mathops.h"
56
57
typedef struct SmackVContext {
58
    AVCodecContext *avctx;
59
    AVFrame *pic;
60
61
    int *mmap_tbl, *mclr_tbl, *full_tbl, *type_tbl;
62
    int mmap_last[3], mclr_last[3], full_last[3], type_last[3];
63
} SmackVContext;
64
65
/**
66
 * Context used for code reconstructing
67
 */
68
typedef struct HuffContext {
69
    int current;
70
    uint32_t bits[256];
71
    uint8_t lengths[256];
72
    uint8_t values[256];
73
} HuffContext;
74
75
/* common parameters used for decode_bigtree */
76
typedef struct DBCtx {
77
    int current, length;
78
    int *values;
79
    VLC *v1, *v2;
80
    uint8_t vals[2];
81
    int escapes[3];
82
    int *last;
83
} DBCtx;
84
85
/* possible runs of blocks */
86
static const int block_runs[64] = {
87
      1,    2,    3,    4,    5,    6,    7,    8,
88
      9,   10,   11,   12,   13,   14,   15,   16,
89
     17,   18,   19,   20,   21,   22,   23,   24,
90
     25,   26,   27,   28,   29,   30,   31,   32,
91
     33,   34,   35,   36,   37,   38,   39,   40,
92
     41,   42,   43,   44,   45,   46,   47,   48,
93
     49,   50,   51,   52,   53,   54,   55,   56,
94
     57,   58,   59,  128,  256,  512, 1024, 2048 };
95
96
enum SmkBlockTypes {
97
    SMK_BLK_MONO = 0,
98
    SMK_BLK_FULL = 1,
99
    SMK_BLK_SKIP = 2,
100
    SMK_BLK_FILL = 3 };
101
102
/**
103
 * Decode local frame tree
104
 *
105
 * Can read SMKTREE_DECODE_MAX_RECURSION before the first check;
106
 * does not overread gb on success.
107
 */
108
9904
static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length)
109
{
110

9904
    if (length > SMKTREE_DECODE_MAX_RECURSION || length > 3 * SMKTREE_BITS) {
111
        av_log(NULL, AV_LOG_ERROR, "Maximum tree recursion level exceeded.\n");
112
        return AVERROR_INVALIDDATA;
113
    }
114
115
9904
    if(!get_bits1(gb)){ //Leaf
116
5007
        if (hc->current >= 256) {
117
            av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
118
            return AVERROR_INVALIDDATA;
119
        }
120
5007
        if (get_bits_left(gb) < 8)
121
            return AVERROR_INVALIDDATA;
122
5007
        hc->bits[hc->current]    = prefix;
123
5007
        hc->lengths[hc->current] = length;
124
5007
        hc->values[hc->current] = get_bits(gb, 8);
125
5007
        hc->current++;
126
5007
        return 0;
127
    } else { //Node
128
        int r;
129
4897
        length++;
130
4897
        r = smacker_decode_tree(gb, hc, prefix, length);
131
4897
        if(r)
132
            return r;
133
4897
        return smacker_decode_tree(gb, hc, prefix | (1U << (length - 1)), length);
134
    }
135
}
136
137
/**
138
 * Decode header tree
139
 *
140
 * Checks before the first read, can overread by 6 * SMKTREE_BITS on success.
141
 */
142
81192
static int smacker_decode_bigtree(GetBitContext *gb, DBCtx *ctx, int length)
143
{
144
    // Larger length can cause segmentation faults due to too deep recursion.
145
81192
    if (length > SMKTREE_DECODE_BIG_MAX_RECURSION) {
146
        av_log(NULL, AV_LOG_ERROR, "Maximum bigtree recursion level exceeded.\n");
147
        return AVERROR_INVALIDDATA;
148
    }
149
150
81192
    if (ctx->current >= ctx->length) {
151
        av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
152
        return AVERROR_INVALIDDATA;
153
    }
154
81192
    if (get_bits_left(gb) <= 0)
155
        return AVERROR_INVALIDDATA;
156
81192
    if(!get_bits1(gb)){ //Leaf
157
        int val, i1, i2;
158
40602
        i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3)
159
40602
                            : ctx->vals[0];
160
40602
        i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3)
161
40602
                            : ctx->vals[1];
162
40602
        val = i1 | (i2 << 8);
163
40602
        if(val == ctx->escapes[0]) {
164
9
            ctx->last[0] = ctx->current;
165
9
            val = 0;
166
40593
        } else if(val == ctx->escapes[1]) {
167
12
            ctx->last[1] = ctx->current;
168
12
            val = 0;
169
40581
        } else if(val == ctx->escapes[2]) {
170
12
            ctx->last[2] = ctx->current;
171
12
            val = 0;
172
        }
173
174
40602
        ctx->values[ctx->current++] = val;
175
40602
        return 1;
176
    } else { //Node
177
40590
        int r = 0, r_new, t;
178
179
40590
        t = ctx->current++;
180
40590
        r = smacker_decode_bigtree(gb, ctx, length + 1);
181
40590
        if(r < 0)
182
            return r;
183
40590
        ctx->values[t] = SMK_NODE | r;
184
40590
        r++;
185
40590
        r_new = smacker_decode_bigtree(gb, ctx, length + 1);
186
40590
        if (r_new < 0)
187
            return r_new;
188
40590
        return r + r_new;
189
    }
190
}
191
192
/**
193
 * Store large tree as FFmpeg's vlc codes
194
 *
195
 * Can read FFMAX(1 + SMKTREE_DECODE_MAX_RECURSION, 2 + 3 * 16) bits
196
 * before the first check; can overread by 6 * SMKTREE_BITS + 1 on success.
197
 */
198
12
static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
199
{
200
12
    VLC vlc[2] = { { 0 } };
201
    int escapes[3];
202
    DBCtx ctx;
203
    int err;
204
205
12
    if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
206
        av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
207
        return AVERROR_INVALIDDATA;
208
    }
209
210
36
    for (int i = 0; i < 2; i++) {
211
        HuffContext h;
212
24
        h.current = 0;
213
24
        if (!get_bits1(gb)) {
214
            ctx.vals[i] = 0;
215
            av_log(smk->avctx, AV_LOG_ERROR, "Skipping %s bytes tree\n",
216
                   i ? "high" : "low");
217
            continue;
218
        }
219
24
        err = smacker_decode_tree(gb, &h, 0, 0);
220
24
        if (err < 0)
221
            goto error;
222
24
        skip_bits1(gb);
223
24
        if (h.current > 1) {
224
24
            err = ff_init_vlc_sparse(&vlc[i], SMKTREE_BITS, h.current,
225
                                     h.lengths, sizeof(*h.lengths), sizeof(*h.lengths),
226
                                     h.bits,    sizeof(*h.bits),    sizeof(*h.bits),
227
                                     h.values,  sizeof(*h.values),  sizeof(*h.values),
228
                                     INIT_VLC_LE);
229
24
            if (err < 0) {
230
                av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
231
                goto error;
232
            }
233
        } else
234
            ctx.vals[i] = h.values[0];
235
    }
236
237
12
    escapes[0]  = get_bits(gb, 16);
238
12
    escapes[1]  = get_bits(gb, 16);
239
12
    escapes[2]  = get_bits(gb, 16);
240
241
12
    last[0] = last[1] = last[2] = -1;
242
243
12
    ctx.escapes[0] = escapes[0];
244
12
    ctx.escapes[1] = escapes[1];
245
12
    ctx.escapes[2] = escapes[2];
246
12
    ctx.v1 = &vlc[0];
247
12
    ctx.v2 = &vlc[1];
248
12
    ctx.last = last;
249
12
    ctx.length  = (size + 3) >> 2;
250
12
    ctx.current = 0;
251
12
    ctx.values  = av_malloc_array(ctx.length + 3, sizeof(ctx.values[0]));
252
12
    if (!ctx.values) {
253
        err = AVERROR(ENOMEM);
254
        goto error;
255
    }
256
12
    *recodes = ctx.values;
257
258
12
    err = smacker_decode_bigtree(gb, &ctx, 0);
259
12
    if (err < 0)
260
        goto error;
261
12
    skip_bits1(gb);
262
12
    if (ctx.last[0] == -1) ctx.last[0] = ctx.current++;
263
12
    if (ctx.last[1] == -1) ctx.last[1] = ctx.current++;
264
12
    if (ctx.last[2] == -1) ctx.last[2] = ctx.current++;
265
266
12
    err = 0;
267
12
error:
268
36
    for (int i = 0; i < 2; i++) {
269
24
        ff_free_vlc(&vlc[i]);
270
    }
271
272
12
    return err;
273
}
274
275
3
static int decode_header_trees(SmackVContext *smk) {
276
    GetBitContext gb;
277
    int mmap_size, mclr_size, full_size, type_size, ret;
278
3
    int skip = 0;
279
280
3
    mmap_size = AV_RL32(smk->avctx->extradata);
281
3
    mclr_size = AV_RL32(smk->avctx->extradata + 4);
282
3
    full_size = AV_RL32(smk->avctx->extradata + 8);
283
3
    type_size = AV_RL32(smk->avctx->extradata + 12);
284
285
3
    ret = init_get_bits8(&gb, smk->avctx->extradata + 16, smk->avctx->extradata_size - 16);
286
3
    if (ret < 0)
287
        return ret;
288
289
3
    if(!get_bits1(&gb)) {
290
        skip ++;
291
        av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
292
        smk->mmap_tbl = av_malloc(sizeof(int) * 2);
293
        if (!smk->mmap_tbl)
294
            return AVERROR(ENOMEM);
295
        smk->mmap_tbl[0] = 0;
296
        smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
297
    } else {
298
3
        ret = smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
299
3
        if (ret < 0)
300
            return ret;
301
    }
302
3
    if(!get_bits1(&gb)) {
303
        skip ++;
304
        av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
305
        smk->mclr_tbl = av_malloc(sizeof(int) * 2);
306
        if (!smk->mclr_tbl)
307
            return AVERROR(ENOMEM);
308
        smk->mclr_tbl[0] = 0;
309
        smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
310
    } else {
311
3
        ret = smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
312
3
        if (ret < 0)
313
            return ret;
314
    }
315
3
    if(!get_bits1(&gb)) {
316
        skip ++;
317
        av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
318
        smk->full_tbl = av_malloc(sizeof(int) * 2);
319
        if (!smk->full_tbl)
320
            return AVERROR(ENOMEM);
321
        smk->full_tbl[0] = 0;
322
        smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
323
    } else {
324
3
        ret = smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
325
3
        if (ret < 0)
326
            return ret;
327
    }
328
3
    if(!get_bits1(&gb)) {
329
        skip ++;
330
        av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
331
        smk->type_tbl = av_malloc(sizeof(int) * 2);
332
        if (!smk->type_tbl)
333
            return AVERROR(ENOMEM);
334
        smk->type_tbl[0] = 0;
335
        smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
336
    } else {
337
3
        ret = smacker_decode_header_tree(smk, &gb, &smk->type_tbl, smk->type_last, type_size);
338
3
        if (ret < 0)
339
            return ret;
340
    }
341

3
    if (skip == 4 || get_bits_left(&gb) < 0)
342
        return AVERROR_INVALIDDATA;
343
344
3
    return 0;
345
}
346
347
400
static av_always_inline void last_reset(int *recode, int *last) {
348
400
    recode[last[0]] = recode[last[1]] = recode[last[2]] = 0;
349
400
}
350
351
/* Get code and update history.
352
 * Checks before reading, does not overread. */
353
721937
static av_always_inline int smk_get_code(GetBitContext *gb, int *recode, int *last) {
354
721937
    register int *table = recode;
355
    int v;
356
357
5893869
    while(*table & SMK_NODE) {
358
5171932
        if (get_bits_left(gb) < 1)
359
            return AVERROR_INVALIDDATA;
360
5171932
        if(get_bits1(gb))
361
2453865
            table += (*table) & (~SMK_NODE);
362
5171932
        table++;
363
    }
364
721937
    v = *table;
365
366
721937
    if(v != recode[last[0]]) {
367
603120
        recode[last[2]] = recode[last[1]];
368
603120
        recode[last[1]] = recode[last[0]];
369
603120
        recode[last[0]] = v;
370
    }
371
721937
    return v;
372
}
373
374
100
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
375
                        AVPacket *avpkt)
376
{
377
100
    SmackVContext * const smk = avctx->priv_data;
378
    uint8_t *out;
379
    uint32_t *pal;
380
    GetByteContext gb2;
381
    GetBitContext gb;
382
    int blocks, blk, bw, bh;
383
    int i, ret;
384
    int stride;
385
    int flags;
386
387
100
    if (avpkt->size <= 769)
388
        return AVERROR_INVALIDDATA;
389
390
100
    if ((ret = ff_reget_buffer(avctx, smk->pic, 0)) < 0)
391
        return ret;
392
393
    /* make the palette available on the way out */
394
100
    pal = (uint32_t*)smk->pic->data[1];
395
100
    bytestream2_init(&gb2, avpkt->data, avpkt->size);
396
100
    flags = bytestream2_get_byteu(&gb2);
397
100
    smk->pic->palette_has_changed = flags & 1;
398
100
    smk->pic->key_frame = !!(flags & 2);
399
100
    if (smk->pic->key_frame)
400
        smk->pic->pict_type = AV_PICTURE_TYPE_I;
401
    else
402
100
        smk->pic->pict_type = AV_PICTURE_TYPE_P;
403
404
25700
    for(i = 0; i < 256; i++)
405
25600
        *pal++ = 0xFFU << 24 | bytestream2_get_be24u(&gb2);
406
407
100
    last_reset(smk->mmap_tbl, smk->mmap_last);
408
100
    last_reset(smk->mclr_tbl, smk->mclr_last);
409
100
    last_reset(smk->full_tbl, smk->full_last);
410
100
    last_reset(smk->type_tbl, smk->type_last);
411
100
    if ((ret = init_get_bits8(&gb, avpkt->data + 769, avpkt->size - 769)) < 0)
412
        return ret;
413
414
100
    blk = 0;
415
100
    bw = avctx->width >> 2;
416
100
    bh = avctx->height >> 2;
417
100
    blocks = bw * bh;
418
100
    stride = smk->pic->linesize[0];
419
100
    while(blk < blocks) {
420
        int type, run, mode;
421
        uint16_t pix;
422
423
44593
        type = smk_get_code(&gb, smk->type_tbl, smk->type_last);
424
44593
        if (type < 0)
425
            return type;
426
44593
        run = block_runs[(type >> 2) & 0x3F];
427

44593
        switch(type & 3){
428
15331
        case SMK_BLK_MONO:
429

43679
            while(run-- && blk < blocks){
430
                int clr, map;
431
                int hi, lo;
432
28348
                clr = smk_get_code(&gb, smk->mclr_tbl, smk->mclr_last);
433
28348
                map = smk_get_code(&gb, smk->mmap_tbl, smk->mmap_last);
434
28348
                out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
435
28348
                hi = clr >> 8;
436
28348
                lo = clr & 0xFF;
437
141740
                for(i = 0; i < 4; i++) {
438
113392
                    if(map & 1) out[0] = hi; else out[0] = lo;
439
113392
                    if(map & 2) out[1] = hi; else out[1] = lo;
440
113392
                    if(map & 4) out[2] = hi; else out[2] = lo;
441
113392
                    if(map & 8) out[3] = hi; else out[3] = lo;
442
113392
                    map >>= 4;
443
113392
                    out += stride;
444
                }
445
28348
                blk++;
446
            }
447
15331
            break;
448
11617
        case SMK_BLK_FULL:
449
11617
            mode = 0;
450
11617
            if(avctx->codec_tag == MKTAG('S', 'M', 'K', '4')) { // In case of Smacker v4 we have three modes
451
                if(get_bits1(&gb)) mode = 1;
452
                else if(get_bits1(&gb)) mode = 2;
453
            }
454

89198
            while(run-- && blk < blocks){
455

77581
                out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
456
                switch(mode){
457
77581
                case 0:
458
387905
                    for(i = 0; i < 4; i++) {
459
310324
                        pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
460
310324
                        AV_WL16(out+2,pix);
461
310324
                        pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
462
310324
                        AV_WL16(out,pix);
463
310324
                        out += stride;
464
                    }
465
77581
                    break;
466
                case 1:
467
                    pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
468
                    out[0] = out[1] = pix & 0xFF;
469
                    out[2] = out[3] = pix >> 8;
470
                    out += stride;
471
                    out[0] = out[1] = pix & 0xFF;
472
                    out[2] = out[3] = pix >> 8;
473
                    out += stride;
474
                    pix = smk_get_code(&gb, smk->full_tbl, smk->full_last);
475
                    out[0] = out[1] = pix & 0xFF;
476
                    out[2] = out[3] = pix >> 8;
477
                    out += stride;
478
                    out[0] = out[1] = pix & 0xFF;
479
                    out[2] = out[3] = pix >> 8;
480
                    break;
481
                case 2:
482
                    for(i = 0; i < 2; i++) {
483
                        uint16_t pix1, pix2;
484
                        pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
485
                        pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last);
486
                        AV_WL16(out,pix1);
487
                        AV_WL16(out+2,pix2);
488
                        out += stride;
489
                        AV_WL16(out,pix1);
490
                        AV_WL16(out+2,pix2);
491
                        out += stride;
492
                    }
493
                    break;
494
                }
495
77581
                blk++;
496
            }
497
11617
            break;
498
10001
        case SMK_BLK_SKIP:
499

288422
            while(run-- && blk < blocks)
500
278421
                blk++;
501
10001
            break;
502
7644
        case SMK_BLK_FILL:
503
7644
            mode = type >> 8;
504

23294
            while(run-- && blk < blocks){
505
                uint32_t col;
506
15650
                out = smk->pic->data[0] + (blk / bw) * (stride * 4) + (blk % bw) * 4;
507
15650
                col = mode * 0x01010101U;
508
78250
                for(i = 0; i < 4; i++) {
509
62600
                    *((uint32_t*)out) = col;
510
62600
                    out += stride;
511
                }
512
15650
                blk++;
513
            }
514
7644
            break;
515
        }
516
517
44693
    }
518
519
100
    if ((ret = av_frame_ref(data, smk->pic)) < 0)
520
        return ret;
521
522
100
    *got_frame = 1;
523
524
    /* always report that the buffer was completely consumed */
525
100
    return avpkt->size;
526
}
527
528
529
3
static av_cold int decode_end(AVCodecContext *avctx)
530
{
531
3
    SmackVContext * const smk = avctx->priv_data;
532
533
3
    av_freep(&smk->mmap_tbl);
534
3
    av_freep(&smk->mclr_tbl);
535
3
    av_freep(&smk->full_tbl);
536
3
    av_freep(&smk->type_tbl);
537
538
3
    av_frame_free(&smk->pic);
539
540
3
    return 0;
541
}
542
543
544
3
static av_cold int decode_init(AVCodecContext *avctx)
545
{
546
3
    SmackVContext * const c = avctx->priv_data;
547
    int ret;
548
549
3
    c->avctx = avctx;
550
551
3
    avctx->pix_fmt = AV_PIX_FMT_PAL8;
552
553
3
    c->pic = av_frame_alloc();
554
3
    if (!c->pic)
555
        return AVERROR(ENOMEM);
556
557
    /* decode huffman trees from extradata */
558
3
    if (avctx->extradata_size <= 16){
559
        av_log(avctx, AV_LOG_ERROR, "Extradata missing!\n");
560
        return AVERROR(EINVAL);
561
    }
562
563
3
    ret = decode_header_trees(c);
564
3
    if (ret < 0) {
565
        return ret;
566
    }
567
568
3
    return 0;
569
}
570
571
572
3
static av_cold int smka_decode_init(AVCodecContext *avctx)
573
{
574

3
    if (avctx->channels < 1 || avctx->channels > 2) {
575
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
576
        return AVERROR_INVALIDDATA;
577
    }
578
3
    avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
579
3
    avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;
580
581
3
    return 0;
582
}
583
584
/**
585
 * Decode Smacker audio data
586
 */
587
86
static int smka_decode_frame(AVCodecContext *avctx, void *data,
588
                             int *got_frame_ptr, AVPacket *avpkt)
589
{
590
86
    AVFrame *frame     = data;
591
86
    const uint8_t *buf = avpkt->data;
592
86
    int buf_size = avpkt->size;
593
    GetBitContext gb;
594
86
    VLC vlc[4]       = { { 0 } };
595
    int16_t *samples;
596
    uint8_t *samples8;
597
    uint8_t values[4];
598
    int i, res, ret;
599
    int unp_size;
600
    int bits, stereo;
601
    unsigned pred[2], val;
602
603
86
    if (buf_size <= 4) {
604
        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
605
        return AVERROR_INVALIDDATA;
606
    }
607
608
86
    unp_size = AV_RL32(buf);
609
610
86
    if (unp_size > (1U<<24)) {
611
        av_log(avctx, AV_LOG_ERROR, "packet is too big\n");
612
        return AVERROR_INVALIDDATA;
613
    }
614
615
86
    if ((ret = init_get_bits8(&gb, buf + 4, buf_size - 4)) < 0)
616
        return ret;
617
618
86
    if(!get_bits1(&gb)){
619
        av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
620
        *got_frame_ptr = 0;
621
        return 1;
622
    }
623
86
    stereo = get_bits1(&gb);
624
86
    bits = get_bits1(&gb);
625
86
    if (stereo ^ (avctx->channels != 1)) {
626
        av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
627
        return AVERROR_INVALIDDATA;
628
    }
629
86
    if (bits == (avctx->sample_fmt == AV_SAMPLE_FMT_U8)) {
630
        av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
631
        return AVERROR_INVALIDDATA;
632
    }
633
634
    /* get output buffer */
635
86
    frame->nb_samples = unp_size / (avctx->channels * (bits + 1));
636
86
    if (unp_size % (avctx->channels * (bits + 1))) {
637
        av_log(avctx, AV_LOG_ERROR,
638
               "The buffer does not contain an integer number of samples\n");
639
        return AVERROR_INVALIDDATA;
640
    }
641
86
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
642
        return ret;
643
86
    samples  = (int16_t *)frame->data[0];
644
86
    samples8 =            frame->data[0];
645
646
    // Initialize
647
172
    for(i = 0; i < (1 << (bits + stereo)); i++) {
648
        HuffContext h;
649
86
        h.current = 0;
650
86
        skip_bits1(&gb);
651
86
        if ((ret = smacker_decode_tree(&gb, &h, 0, 0)) < 0)
652
            goto error;
653
86
        skip_bits1(&gb);
654
86
        if (h.current > 1) {
655
80
            ret = ff_init_vlc_sparse(&vlc[i], SMKTREE_BITS, h.current,
656
                                     h.lengths, sizeof(*h.lengths), sizeof(*h.lengths),
657
                                     h.bits,    sizeof(*h.bits),    sizeof(*h.bits),
658
                                     h.values,  sizeof(*h.values),  sizeof(*h.values),
659
                                     INIT_VLC_LE);
660
80
            if (ret < 0) {
661
                av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
662
                goto error;
663
            }
664
        } else
665
6
            values[i] = h.values[0];
666
    }
667
    /* this codec relies on wraparound instead of clipping audio */
668
86
    if(bits) { //decode 16-bit data
669
        for(i = stereo; i >= 0; i--)
670
            pred[i] = av_bswap16(get_bits(&gb, 16));
671
        for(i = 0; i <= stereo; i++)
672
            *samples++ = pred[i];
673
        for(; i < unp_size / 2; i++) {
674
            unsigned idx = 2 * (i & stereo);
675
            if (get_bits_left(&gb) < 0) {
676
                ret = AVERROR_INVALIDDATA;
677
                goto error;
678
            }
679
            if (vlc[idx].table)
680
                res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
681
            else
682
                res = values[idx];
683
            val  = res;
684
            if (vlc[++idx].table)
685
                res = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
686
            else
687
                res = values[idx];
688
            val |= res << 8;
689
            pred[idx / 2] += val;
690
            *samples++ = pred[idx / 2];
691
        }
692
    } else { //8-bit data
693
172
        for(i = stereo; i >= 0; i--)
694
86
            pred[i] = get_bits(&gb, 8);
695
172
        for(i = 0; i <= stereo; i++)
696
86
            *samples8++ = pred[i];
697
156552
        for(; i < unp_size; i++) {
698
156466
            unsigned idx = i & stereo;
699
156466
            if (get_bits_left(&gb) < 0) {
700
                ret = AVERROR_INVALIDDATA;
701
                goto error;
702
            }
703
156466
            if (vlc[idx].table)
704
147216
                val = get_vlc2(&gb, vlc[idx].table, SMKTREE_BITS, 3);
705
            else
706
9250
                val = values[idx];
707
156466
            pred[idx] += val;
708
156466
            *samples8++ = pred[idx];
709
        }
710
    }
711
712
86
    *got_frame_ptr = 1;
713
86
    ret = buf_size;
714
715
86
error:
716
430
    for(i = 0; i < 4; i++) {
717
344
        ff_free_vlc(&vlc[i]);
718
    }
719
720
86
    return ret;
721
}
722
723
AVCodec ff_smacker_decoder = {
724
    .name           = "smackvid",
725
    .long_name      = NULL_IF_CONFIG_SMALL("Smacker video"),
726
    .type           = AVMEDIA_TYPE_VIDEO,
727
    .id             = AV_CODEC_ID_SMACKVIDEO,
728
    .priv_data_size = sizeof(SmackVContext),
729
    .init           = decode_init,
730
    .close          = decode_end,
731
    .decode         = decode_frame,
732
    .capabilities   = AV_CODEC_CAP_DR1,
733
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
734
};
735
736
AVCodec ff_smackaud_decoder = {
737
    .name           = "smackaud",
738
    .long_name      = NULL_IF_CONFIG_SMALL("Smacker audio"),
739
    .type           = AVMEDIA_TYPE_AUDIO,
740
    .id             = AV_CODEC_ID_SMACKAUDIO,
741
    .init           = smka_decode_init,
742
    .decode         = smka_decode_frame,
743
    .capabilities   = AV_CODEC_CAP_DR1,
744
};