GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/4xm.c Lines: 452 536 84.3 %
Date: 2019-11-18 18:00:01 Branches: 209 285 73.3 %

Line Branch Exec Source
1
/*
2
 * 4XM codec
3
 * Copyright (c) 2003 Michael Niedermayer
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
 * 4XM codec.
25
 */
26
27
#include <inttypes.h>
28
29
#include "libavutil/avassert.h"
30
#include "libavutil/frame.h"
31
#include "libavutil/imgutils.h"
32
#include "libavutil/intreadwrite.h"
33
#include "avcodec.h"
34
#include "blockdsp.h"
35
#include "bswapdsp.h"
36
#include "bytestream.h"
37
#include "get_bits.h"
38
#include "internal.h"
39
40
41
#define BLOCK_TYPE_VLC_BITS 5
42
#define ACDC_VLC_BITS 9
43
44
#define CFRAME_BUFFER_COUNT 100
45
46
static const uint8_t block_type_tab[2][4][8][2] = {
47
    {
48
        {    // { 8, 4, 2 } x { 8, 4, 2}
49
            { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
50
        }, { // { 8, 4 } x 1
51
            { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52
        }, { // 1 x { 8, 4 }
53
            { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54
        }, { // 1 x 2, 2 x 1
55
            { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
56
        }
57
    }, {
58
        {   // { 8, 4, 2 } x { 8, 4, 2}
59
            { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60
        }, {// { 8, 4 } x 1
61
            { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62
        }, {// 1 x { 8, 4 }
63
            { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64
        }, {// 1 x 2, 2 x 1
65
            { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
66
      }
67
    }
68
};
69
70
static const uint8_t size2index[4][4] = {
71
    { -1, 3, 1, 1 },
72
    {  3, 0, 0, 0 },
73
    {  2, 0, 0, 0 },
74
    {  2, 0, 0, 0 },
75
};
76
77
static const int8_t mv[256][2] = {
78
    {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
79
    {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
80
    {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
81
    {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
82
    {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
83
    {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
84
    {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
85
    {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
86
    {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
87
    {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
88
    {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
89
    {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
90
    {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
91
    {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
92
    {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
93
    {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
94
    {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
95
    {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
96
    {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
97
    {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
98
    { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
99
    {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
100
    {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
101
    {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
102
    {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
103
    {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
104
    {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
105
    {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
106
    {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
107
    { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
108
    { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
109
    { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
110
};
111
112
/* This is simply the scaled down elementwise product of the standard JPEG
113
 * quantizer table and the AAN premul table. */
114
static const uint8_t dequant_table[64] = {
115
    16, 15, 13, 19, 24, 31, 28, 17,
116
    17, 23, 25, 31, 36, 63, 45, 21,
117
    18, 24, 27, 37, 52, 59, 49, 20,
118
    16, 28, 34, 40, 60, 80, 51, 20,
119
    18, 31, 48, 66, 68, 86, 56, 21,
120
    19, 38, 56, 59, 64, 64, 48, 20,
121
    27, 48, 55, 55, 56, 51, 35, 15,
122
    20, 35, 34, 32, 31, 22, 15,  8,
123
};
124
125
static VLC block_type_vlc[2][4];
126
127
128
typedef struct CFrameBuffer {
129
    unsigned int allocated_size;
130
    unsigned int size;
131
    int id;
132
    uint8_t *data;
133
} CFrameBuffer;
134
135
typedef struct FourXContext {
136
    AVCodecContext *avctx;
137
    BlockDSPContext bdsp;
138
    BswapDSPContext bbdsp;
139
    uint16_t *frame_buffer;
140
    uint16_t *last_frame_buffer;
141
    GetBitContext pre_gb;          ///< ac/dc prefix
142
    GetBitContext gb;
143
    GetByteContext g;
144
    GetByteContext g2;
145
    int mv[256];
146
    VLC pre_vlc;
147
    int last_dc;
148
    DECLARE_ALIGNED(32, int16_t, block)[6][64];
149
    void *bitstream_buffer;
150
    unsigned int bitstream_buffer_size;
151
    int version;
152
    CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
153
} FourXContext;
154
155
156
#define FIX_1_082392200  70936
157
#define FIX_1_414213562  92682
158
#define FIX_1_847759065 121095
159
#define FIX_2_613125930 171254
160
161
#define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
162
163
7200
static void idct(int16_t block[64])
164
{
165
    int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
166
    int tmp10, tmp11, tmp12, tmp13;
167
    int z5, z10, z11, z12, z13;
168
    int i;
169
    int temp[64];
170
171
64800
    for (i = 0; i < 8; i++) {
172
57600
        tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
173
57600
        tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
174
175
57600
        tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
176
57600
        tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
177
178
57600
        tmp0 = tmp10 + tmp13;
179
57600
        tmp3 = tmp10 - tmp13;
180
57600
        tmp1 = tmp11 + tmp12;
181
57600
        tmp2 = tmp11 - tmp12;
182
183
57600
        z13 = block[8 * 5 + i] + block[8 * 3 + i];
184
57600
        z10 = block[8 * 5 + i] - block[8 * 3 + i];
185
57600
        z11 = block[8 * 1 + i] + block[8 * 7 + i];
186
57600
        z12 = block[8 * 1 + i] - block[8 * 7 + i];
187
188
57600
        tmp7  =          z11 + z13;
189
57600
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
190
191
57600
        z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
192
57600
        tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
193
57600
        tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
194
195
57600
        tmp6 = tmp12 - tmp7;
196
57600
        tmp5 = tmp11 - tmp6;
197
57600
        tmp4 = tmp10 + tmp5;
198
199
57600
        temp[8 * 0 + i] = tmp0 + tmp7;
200
57600
        temp[8 * 7 + i] = tmp0 - tmp7;
201
57600
        temp[8 * 1 + i] = tmp1 + tmp6;
202
57600
        temp[8 * 6 + i] = tmp1 - tmp6;
203
57600
        temp[8 * 2 + i] = tmp2 + tmp5;
204
57600
        temp[8 * 5 + i] = tmp2 - tmp5;
205
57600
        temp[8 * 4 + i] = tmp3 + tmp4;
206
57600
        temp[8 * 3 + i] = tmp3 - tmp4;
207
    }
208
209
64800
    for (i = 0; i < 8 * 8; i += 8) {
210
57600
        tmp10 = temp[0 + i] + temp[4 + i];
211
57600
        tmp11 = temp[0 + i] - temp[4 + i];
212
213
57600
        tmp13 = temp[2 + i] + temp[6 + i];
214
57600
        tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
215
216
57600
        tmp0 = tmp10 + tmp13;
217
57600
        tmp3 = tmp10 - tmp13;
218
57600
        tmp1 = tmp11 + tmp12;
219
57600
        tmp2 = tmp11 - tmp12;
220
221
57600
        z13 = temp[5 + i] + temp[3 + i];
222
57600
        z10 = temp[5 + i] - temp[3 + i];
223
57600
        z11 = temp[1 + i] + temp[7 + i];
224
57600
        z12 = temp[1 + i] - temp[7 + i];
225
226
57600
        tmp7  = z11 + z13;
227
57600
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
228
229
57600
        z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
230
57600
        tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
231
57600
        tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
232
233
57600
        tmp6 = tmp12 - tmp7;
234
57600
        tmp5 = tmp11 - tmp6;
235
57600
        tmp4 = tmp10 + tmp5;
236
237
57600
        block[0 + i] = (tmp0 + tmp7) >> 6;
238
57600
        block[7 + i] = (tmp0 - tmp7) >> 6;
239
57600
        block[1 + i] = (tmp1 + tmp6) >> 6;
240
57600
        block[6 + i] = (tmp1 - tmp6) >> 6;
241
57600
        block[2 + i] = (tmp2 + tmp5) >> 6;
242
57600
        block[5 + i] = (tmp2 - tmp5) >> 6;
243
57600
        block[4 + i] = (tmp3 + tmp4) >> 6;
244
57600
        block[3 + i] = (tmp3 - tmp4) >> 6;
245
    }
246
7200
}
247
248
5
static av_cold void init_vlcs(FourXContext *f)
249
{
250
    static VLC_TYPE table[2][4][32][2];
251
    int i, j;
252
253
15
    for (i = 0; i < 2; i++) {
254
50
        for (j = 0; j < 4; j++) {
255
40
            block_type_vlc[i][j].table           = table[i][j];
256
40
            block_type_vlc[i][j].table_allocated = 32;
257
40
            init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
258
                     &block_type_tab[i][j][0][1], 2, 1,
259
                     &block_type_tab[i][j][0][0], 2, 1,
260
                     INIT_VLC_USE_NEW_STATIC);
261
        }
262
    }
263
5
}
264
265
183
static void init_mv(FourXContext *f, int linesize)
266
{
267
    int i;
268
269
47031
    for (i = 0; i < 256; i++) {
270
46848
        if (f->version > 1)
271
3584
            f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
272
        else
273
43264
            f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
274
    }
275
183
}
276
277
#if HAVE_BIGENDIAN
278
#define LE_CENTRIC_MUL(dst, src, scale, dc)             \
279
    {                                                   \
280
        unsigned tmpval = AV_RN32(src);                 \
281
        tmpval = (tmpval << 16) | (tmpval >> 16);       \
282
        tmpval = tmpval * (scale) + (dc);               \
283
        tmpval = (tmpval << 16) | (tmpval >> 16);       \
284
        AV_WN32A(dst, tmpval);                          \
285
    }
286
#else
287
#define LE_CENTRIC_MUL(dst, src, scale, dc)              \
288
    {                                                    \
289
        unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
290
        AV_WN32A(dst, tmpval);                           \
291
    }
292
#endif
293
294
257504
static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
295
                        int h, int stride, int scale, unsigned dc)
296
{
297
    int i;
298
257504
    dc *= 0x10001;
299
300

257504
    switch (log2w) {
301
55650
    case 0:
302
334032
        for (i = 0; i < h; i++) {
303
278382
            dst[0] = scale * src[0] + dc;
304
278382
            if (scale)
305
276226
                src += stride;
306
278382
            dst += stride;
307
        }
308
55650
        break;
309
46051
    case 1:
310
213546
        for (i = 0; i < h; i++) {
311
167495
            LE_CENTRIC_MUL(dst, src, scale, dc);
312
167495
            if (scale)
313
161189
                src += stride;
314
167495
            dst += stride;
315
        }
316
46051
        break;
317
46050
    case 2:
318
190270
        for (i = 0; i < h; i++) {
319
144220
            LE_CENTRIC_MUL(dst, src, scale, dc);
320
144220
            LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321
144220
            if (scale)
322
136750
                src += stride;
323
144220
            dst += stride;
324
        }
325
46050
        break;
326
109753
    case 3:
327
804388
        for (i = 0; i < h; i++) {
328
694635
            LE_CENTRIC_MUL(dst,     src,     scale, dc);
329
694635
            LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
330
694635
            LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
331
694635
            LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
332
694635
            if (scale)
333
656084
                src += stride;
334
694635
            dst += stride;
335
        }
336
109753
        break;
337
    default:
338
        av_assert0(0);
339
    }
340
257504
}
341
342
458368
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
343
                          int log2w, int log2h, int stride)
344
{
345
458368
    int index, h, code, ret, scale = 1;
346
    uint16_t *start, *end;
347
458368
    unsigned dc = 0;
348
349

458368
    av_assert0(log2w >= 0 && log2h >= 0);
350
351
458368
    index = size2index[log2h][log2w];
352
458368
    av_assert0(index >= 0);
353
354
458368
    if (get_bits_left(&f->gb) < 1)
355
        return AVERROR_INVALIDDATA;
356
458368
    h     = 1 << log2h;
357
458368
    code  = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
358
                     BLOCK_TYPE_VLC_BITS, 1);
359

458368
    av_assert0(code >= 0 && code <= 6);
360
361
458368
    start = f->last_frame_buffer;
362
458368
    end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
363
364
458368
    if (code == 1) {
365
72772
        log2h--;
366
72772
        if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
367
            return ret;
368
72772
        return decode_p_block(f, dst + (stride << log2h),
369
72772
                              src + (stride << log2h),
370
                              log2w, log2h, stride);
371
385596
    } else if (code == 2) {
372
87322
        log2w--;
373
87322
        if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
374
            return ret;
375
87322
        return decode_p_block(f, dst + (1 << log2w),
376
87322
                              src + (1 << log2w),
377
                              log2w, log2h, stride);
378
298274
    } else if (code == 6) {
379
3858
        if (bytestream2_get_bytes_left(&f->g2) < 4) {
380
            av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
381
            return AVERROR_INVALIDDATA;
382
        }
383
3858
        if (log2w) {
384
2594
            dst[0]      = bytestream2_get_le16u(&f->g2);
385
2594
            dst[1]      = bytestream2_get_le16u(&f->g2);
386
        } else {
387
1264
            dst[0]      = bytestream2_get_le16u(&f->g2);
388
1264
            dst[stride] = bytestream2_get_le16u(&f->g2);
389
        }
390
3858
        return 0;
391
    }
392
393

294416
    if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
394
        av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
395
        return AVERROR_INVALIDDATA;
396
    }
397
398
294416
    if (code == 0) {
399
165799
        src  += f->mv[bytestream2_get_byte(&f->g)];
400

128617
    } else if (code == 3 && f->version >= 2) {
401
36912
        return 0;
402
91705
    } else if (code == 4) {
403
31474
        src  += f->mv[bytestream2_get_byte(&f->g)];
404
31474
        if (bytestream2_get_bytes_left(&f->g2) < 2){
405
            av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
406
            return AVERROR_INVALIDDATA;
407
        }
408
31474
        dc    = bytestream2_get_le16(&f->g2);
409
60231
    } else if (code == 5) {
410
8852
        if (bytestream2_get_bytes_left(&f->g2) < 2){
411
            av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
412
            return AVERROR_INVALIDDATA;
413
        }
414

8852
        av_assert0(start <= src && src <= end);
415
8852
        scale = 0;
416
8852
        dc    = bytestream2_get_le16(&f->g2);
417
    }
418
419

257504
    if (start > src || src > end) {
420
        av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
421
        return AVERROR_INVALIDDATA;
422
    }
423
424
257504
    mcdc(dst, src, log2w, h, stride, scale, dc);
425
426
257504
    return 0;
427
}
428
429
183
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
430
{
431
    int x, y;
432
183
    const int width  = f->avctx->width;
433
183
    const int height = f->avctx->height;
434
183
    uint16_t *dst    = f->frame_buffer;
435
    uint16_t *src;
436
    unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
437
                 bytestream_offset, wordstream_offset;
438
    int ret;
439
440
183
    src = f->last_frame_buffer;
441
442
183
    if (f->version > 1) {
443
14
        extra           = 20;
444
14
        if (length < extra)
445
            return AVERROR_INVALIDDATA;
446
14
        bitstream_size  = AV_RL32(buf + 8);
447
14
        wordstream_size = AV_RL32(buf + 12);
448
14
        bytestream_size = AV_RL32(buf + 16);
449
    } else {
450
169
        extra           = 0;
451
169
        bitstream_size  = AV_RL16(buf - 4);
452
169
        wordstream_size = AV_RL16(buf - 2);
453
169
        bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
454
    }
455
456

183
    if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
457
183
        bytestream_size > length - bitstream_size ||
458
183
        wordstream_size > length - bytestream_size - bitstream_size ||
459
183
        extra > length - bytestream_size - bitstream_size - wordstream_size) {
460
        av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
461
        bitstream_size+ bytestream_size+ wordstream_size - length);
462
        return AVERROR_INVALIDDATA;
463
    }
464
465
183
    av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
466
                          bitstream_size);
467
183
    if (!f->bitstream_buffer)
468
        return AVERROR(ENOMEM);
469
183
    f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
470
183
                       bitstream_size / 4);
471
183
    init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
472
473
183
    wordstream_offset = extra + bitstream_size;
474
183
    bytestream_offset = extra + bitstream_size + wordstream_size;
475
183
    bytestream2_init(&f->g2, buf + wordstream_offset,
476
183
                     length - wordstream_offset);
477
183
    bytestream2_init(&f->g, buf + bytestream_offset,
478
183
                     length - bytestream_offset);
479
480
183
    init_mv(f, width * 2);
481
482
3389
    for (y = 0; y < height; y += 8) {
483
141386
        for (x = 0; x < width; x += 8)
484
138180
            if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
485
                return ret;
486
3206
        src += 8 * width;
487
3206
        dst += 8 * width;
488
    }
489
490
183
    return 0;
491
}
492
493
/**
494
 * decode block and dequantize.
495
 * Note this is almost identical to MJPEG.
496
 */
497
7200
static int decode_i_block(FourXContext *f, int16_t *block)
498
{
499
    int code, i, j, level, val;
500
501
7200
    if (get_bits_left(&f->gb) < 2){
502
        av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
503
        return AVERROR_INVALIDDATA;
504
    }
505
506
    /* DC coef */
507
7200
    val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
508
7200
    if (val >> 4) {
509
        av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
510
        return AVERROR_INVALIDDATA;
511
    }
512
513
7200
    if (val)
514
6688
        val = get_xbits(&f->gb, val);
515
516
7200
    val        = val * dequant_table[0] + f->last_dc;
517
7200
    f->last_dc = block[0] = val;
518
    /* AC coefs */
519
7200
    i = 1;
520
    for (;;) {
521
80423
        code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
522
523
        /* EOB */
524
80423
        if (code == 0)
525
7068
            break;
526
73355
        if (code == 0xf0) {
527
56
            i += 16;
528
56
            if (i >= 64) {
529
                av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
530
                return 0;
531
            }
532
        } else {
533
73299
            if (code & 0xf) {
534
73299
                level = get_xbits(&f->gb, code & 0xf);
535
            } else {
536
                av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
537
                return AVERROR_INVALIDDATA;
538
            }
539
73299
            i    += code >> 4;
540
73299
            if (i >= 64) {
541
                av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
542
                return 0;
543
            }
544
545
73299
            j = ff_zigzag_direct[i];
546
73299
            block[j] = level * dequant_table[j];
547
73299
            i++;
548
73299
            if (i >= 64)
549
132
                break;
550
        }
551
    }
552
553
7200
    return 0;
554
}
555
556
1200
static inline void idct_put(FourXContext *f, int x, int y)
557
{
558
1200
    int16_t (*block)[64] = f->block;
559
1200
    int stride           = f->avctx->width;
560
    int i;
561
1200
    uint16_t *dst = f->frame_buffer + y * stride + x;
562
563
6000
    for (i = 0; i < 4; i++) {
564
4800
        block[i][0] += 0x80 * 8 * 8;
565
4800
        idct(block[i]);
566
    }
567
568
1200
    if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
569
3600
        for (i = 4; i < 6; i++)
570
2400
            idct(block[i]);
571
    }
572
573
    /* Note transform is:
574
     * y  = ( 1b + 4g + 2r) / 14
575
     * cb = ( 3b - 2g - 1r) / 14
576
     * cr = (-1b - 4g + 5r) / 14 */
577
10800
    for (y = 0; y < 8; y++) {
578
86400
        for (x = 0; x < 8; x++) {
579
76800
            int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
580
76800
                            2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
581
76800
            int cb = block[4][x + 8 * y];
582
76800
            int cr = block[5][x + 8 * y];
583
76800
            int cg = (cb + cr) >> 1;
584
            int y;
585
586
76800
            cb += cb;
587
588
76800
            y               = temp[0];
589
76800
            dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590
76800
            y               = temp[1];
591
76800
            dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592
76800
            y               = temp[8];
593
76800
            dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594
76800
            y               = temp[9];
595
76800
            dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596
76800
            dst            += 2;
597
        }
598
9600
        dst += 2 * stride - 2 * 8;
599
    }
600
1200
}
601
602
1200
static int decode_i_mb(FourXContext *f)
603
{
604
    int ret;
605
    int i;
606
607
1200
    f->bdsp.clear_blocks(f->block[0]);
608
609
8400
    for (i = 0; i < 6; i++)
610
7200
        if ((ret = decode_i_block(f, f->block[i])) < 0)
611
            return ret;
612
613
1200
    return 0;
614
}
615
616
1
static const uint8_t *read_huffman_tables(FourXContext *f,
617
                                          const uint8_t * const buf,
618
                                          int buf_size)
619
{
620
1
    int frequency[512] = { 0 };
621
    uint8_t flag[512];
622
    int up[512];
623
    uint8_t len_tab[257];
624
    int bits_tab[257];
625
    int start, end;
626
1
    const uint8_t *ptr = buf;
627
1
    const uint8_t *ptr_end = buf + buf_size;
628
    int j;
629
630
1
    memset(up, -1, sizeof(up));
631
632
1
    start = *ptr++;
633
1
    end   = *ptr++;
634
15
    for (;;) {
635
        int i;
636
637
16
        if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
638
            av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
639
            return NULL;
640
        }
641
642
77
        for (i = start; i <= end; i++)
643
61
            frequency[i] = *ptr++;
644
16
        start = *ptr++;
645
16
        if (start == 0)
646
1
            break;
647
648
15
        end = *ptr++;
649
    }
650
1
    frequency[256] = 1;
651
652
3
    while ((ptr - buf) & 3)
653
2
        ptr++; // 4byte align
654
655
1
    if (ptr > ptr_end) {
656
        av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
657
        return NULL;
658
    }
659
660
61
    for (j = 257; j < 512; j++) {
661
61
        int min_freq[2] = { 256 * 256, 256 * 256 };
662
61
        int smallest[2] = { 0, 0 };
663
        int i;
664
17568
        for (i = 0; i < j; i++) {
665
17507
            if (frequency[i] == 0)
666
15616
                continue;
667
1891
            if (frequency[i] < min_freq[1]) {
668
722
                if (frequency[i] < min_freq[0]) {
669
406
                    min_freq[1] = min_freq[0];
670
406
                    smallest[1] = smallest[0];
671
406
                    min_freq[0] = frequency[i];
672
406
                    smallest[0] = i;
673
                } else {
674
316
                    min_freq[1] = frequency[i];
675
316
                    smallest[1] = i;
676
                }
677
            }
678
        }
679
61
        if (min_freq[1] == 256 * 256)
680
1
            break;
681
682
60
        frequency[j]           = min_freq[0] + min_freq[1];
683
60
        flag[smallest[0]]      = 0;
684
60
        flag[smallest[1]]      = 1;
685
60
        up[smallest[0]]        =
686
60
        up[smallest[1]]        = j;
687
60
        frequency[smallest[0]] = frequency[smallest[1]] = 0;
688
    }
689
690
258
    for (j = 0; j < 257; j++) {
691
257
        int node, len = 0, bits = 0;
692
693
767
        for (node = j; up[node] != -1; node = up[node]) {
694
510
            bits += flag[node] << len;
695
510
            len++;
696
510
            if (len > 31)
697
                // can this happen at all ?
698
                av_log(f->avctx, AV_LOG_ERROR,
699
                       "vlc length overflow\n");
700
        }
701
702
257
        bits_tab[j] = bits;
703
257
        len_tab[j]  = len;
704
    }
705
706
1
    ff_free_vlc(&f->pre_vlc);
707
1
    if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
708
                 bits_tab, 4, 4, 0))
709
        return NULL;
710
711
1
    return ptr;
712
}
713
714
1050
static int mix(int c0, int c1)
715
{
716
1050
    int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
717
1050
    int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
718
1050
    int red   =  2 * (c0 >> 10)    + (c1 >> 10);
719
1050
    return red / 3 * 1024 + green / 3 * 32 + blue / 3;
720
}
721
722
5
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
723
{
724
    int x, y, x2, y2;
725
5
    const int width  = f->avctx->width;
726
5
    const int height = f->avctx->height;
727
5
    const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
728
5
    uint16_t *dst    = f->frame_buffer;
729
5
    const uint8_t *buf_end = buf + length;
730
    GetByteContext g3;
731
732
5
    if (length < mbs * 8) {
733
        av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
734
        return AVERROR_INVALIDDATA;
735
    }
736
5
    bytestream2_init(&g3, buf, length);
737
738
40
    for (y = 0; y < height; y += 16) {
739
560
        for (x = 0; x < width; x += 16) {
740
525
            unsigned int color[4] = { 0 }, bits;
741
525
            if (buf_end - buf < 8)
742
                return AVERROR_INVALIDDATA;
743
            // warning following is purely guessed ...
744
525
            color[0] = bytestream2_get_le16u(&g3);
745
525
            color[1] = bytestream2_get_le16u(&g3);
746
747
525
            if (color[0] & 0x8000)
748
                av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
749
525
            if (color[1] & 0x8000)
750
                av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
751
752
525
            color[2] = mix(color[0], color[1]);
753
525
            color[3] = mix(color[1], color[0]);
754
755
525
            bits = bytestream2_get_le32u(&g3);
756
8925
            for (y2 = 0; y2 < 16; y2++) {
757
142800
                for (x2 = 0; x2 < 16; x2++) {
758
134400
                    int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
759
134400
                    dst[y2 * width + x2] = color[(bits >> index) & 3];
760
                }
761
            }
762
525
            dst += 16;
763
        }
764
35
        dst += 16 * width - x;
765
    }
766
767
5
    return 0;
768
}
769
770
1
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
771
{
772
    int x, y, ret;
773
1
    const int width  = f->avctx->width;
774
1
    const int height = f->avctx->height;
775
1
    const unsigned int bitstream_size = AV_RL32(buf);
776
    unsigned int prestream_size;
777
    const uint8_t *prestream;
778
779
1
    if (bitstream_size > (1 << 26))
780
        return AVERROR_INVALIDDATA;
781
782
1
    if (length < bitstream_size + 12) {
783
        av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
784
        return AVERROR_INVALIDDATA;
785
    }
786
787
1
    prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
788
1
    prestream      =             buf + bitstream_size + 12;
789
790
1
    if (prestream_size + bitstream_size + 12 != length
791
1
        || prestream_size > (1 << 26)) {
792
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
793
               prestream_size, bitstream_size, length);
794
        return AVERROR_INVALIDDATA;
795
    }
796
797
1
    prestream = read_huffman_tables(f, prestream, prestream_size);
798
1
    if (!prestream) {
799
        av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
800
        return AVERROR_INVALIDDATA;
801
    }
802
803
1
    av_assert0(prestream <= buf + length);
804
805
1
    init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
806
807
1
    prestream_size = length + buf - prestream;
808
809
1
    av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
810
                          prestream_size);
811
1
    if (!f->bitstream_buffer)
812
        return AVERROR(ENOMEM);
813
1
    f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
814
1
                       prestream_size / 4);
815
1
    init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
816
817
1
    f->last_dc = 0 * 128 * 8 * 8;
818
819
31
    for (y = 0; y < height; y += 16) {
820
1230
        for (x = 0; x < width; x += 16) {
821
1200
            if ((ret = decode_i_mb(f)) < 0)
822
                return ret;
823
824
1200
            idct_put(f, x, y);
825
        }
826
    }
827
828
1
    if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
829
        av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
830
831
1
    return 0;
832
}
833
834
201
static int decode_frame(AVCodecContext *avctx, void *data,
835
                        int *got_frame, AVPacket *avpkt)
836
{
837
201
    const uint8_t *buf    = avpkt->data;
838
201
    int buf_size          = avpkt->size;
839
201
    FourXContext *const f = avctx->priv_data;
840
201
    AVFrame *picture      = data;
841
    int i, frame_4cc, frame_size, ret;
842
843
201
    if (buf_size < 20)
844
        return AVERROR_INVALIDDATA;
845
846

201
    av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
847
848
201
    if (buf_size < AV_RL32(buf + 4) + 8) {
849
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
850
               buf_size, AV_RL32(buf + 4));
851
        return AVERROR_INVALIDDATA;
852
    }
853
854
201
    frame_4cc = AV_RL32(buf);
855
856
201
    if (frame_4cc == AV_RL32("cfrm")) {
857
14
        int free_index       = -1;
858
        int id, whole_size;
859
14
        const int data_size  = buf_size - 20;
860
        CFrameBuffer *cfrm;
861
862
14
        if (f->version <= 1) {
863
            av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
864
            return AVERROR_INVALIDDATA;
865
        }
866
867
14
        id         = AV_RL32(buf + 12);
868
14
        whole_size = AV_RL32(buf + 16);
869
870

14
        if (data_size < 0 || whole_size < 0) {
871
            av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
872
            return AVERROR_INVALIDDATA;
873
        }
874
875
1414
        for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
876

1400
            if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
877
                av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
878
                       f->cfrm[i].id);
879
880
1398
        for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
881
1396
            if (f->cfrm[i].id == id)
882
12
                break;
883
1384
            if (f->cfrm[i].size == 0)
884
1382
                free_index = i;
885
        }
886
887
14
        if (i >= CFRAME_BUFFER_COUNT) {
888
2
            i             = free_index;
889
2
            f->cfrm[i].id = id;
890
        }
891
14
        cfrm = &f->cfrm[i];
892
893
14
        if (data_size > UINT_MAX -  cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
894
            return AVERROR_INVALIDDATA;
895
896
28
        cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
897
14
                                     cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
898
        // explicit check needed as memcpy below might not catch a NULL
899
14
        if (!cfrm->data) {
900
            av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
901
            return AVERROR(ENOMEM);
902
        }
903
904
14
        memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
905
14
        cfrm->size += data_size;
906
907
14
        if (cfrm->size >= whole_size) {
908
2
            buf        = cfrm->data;
909
2
            frame_size = cfrm->size;
910
911
2
            if (id != avctx->frame_number)
912
                av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
913
                       id, avctx->frame_number);
914
915
2
            if (f->version <= 1)
916
                return AVERROR_INVALIDDATA;
917
918
2
            cfrm->size = cfrm->id = 0;
919
2
            frame_4cc  = AV_RL32("pfrm");
920
        } else
921
12
            return buf_size;
922
    } else {
923
187
        buf        = buf      + 12;
924
187
        frame_size = buf_size - 12;
925
    }
926
927
189
    if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
928
        return ret;
929
930
189
    if (frame_4cc == AV_RL32("ifr2")) {
931
5
        picture->pict_type = AV_PICTURE_TYPE_I;
932
5
        if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
933
            av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
934
            return ret;
935
        }
936
184
    } else if (frame_4cc == AV_RL32("ifrm")) {
937
1
        picture->pict_type = AV_PICTURE_TYPE_I;
938
1
        if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
939
            av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
940
            return ret;
941
        }
942

183
    } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
943
183
        picture->pict_type = AV_PICTURE_TYPE_P;
944
183
        if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
945
            av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
946
            return ret;
947
        }
948
    } else if (frame_4cc == AV_RL32("snd_")) {
949
        av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
950
               buf_size);
951
    } else {
952
        av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
953
               buf_size);
954
    }
955
956
189
    picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
957
958
189
    av_image_copy_plane(picture->data[0], picture->linesize[0],
959
189
                        (const uint8_t*)f->frame_buffer,  avctx->width * 2,
960
189
                        avctx->width * 2, avctx->height);
961
189
    FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
962
963
189
    *got_frame = 1;
964
965
189
    emms_c();
966
967
189
    return buf_size;
968
}
969
970
5
static av_cold int decode_end(AVCodecContext *avctx)
971
{
972
5
    FourXContext * const f = avctx->priv_data;
973
    int i;
974
975
5
    av_freep(&f->frame_buffer);
976
5
    av_freep(&f->last_frame_buffer);
977
5
    av_freep(&f->bitstream_buffer);
978
5
    f->bitstream_buffer_size = 0;
979
505
    for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
980
500
        av_freep(&f->cfrm[i].data);
981
500
        f->cfrm[i].allocated_size = 0;
982
    }
983
5
    ff_free_vlc(&f->pre_vlc);
984
985
5
    return 0;
986
}
987
988
5
static av_cold int decode_init(AVCodecContext *avctx)
989
{
990
5
    FourXContext * const f = avctx->priv_data;
991
    int ret;
992
993

5
    if (avctx->extradata_size != 4 || !avctx->extradata) {
994
        av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
995
        return AVERROR_INVALIDDATA;
996
    }
997

5
    if((avctx->width % 16) || (avctx->height % 16)) {
998
        av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
999
        return AVERROR_INVALIDDATA;
1000
    }
1001
1002
5
    ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1003
5
    if (ret < 0)
1004
        return ret;
1005
1006
5
    f->frame_buffer      = av_mallocz(avctx->width * avctx->height * 2);
1007
5
    f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1008

5
    if (!f->frame_buffer || !f->last_frame_buffer) {
1009
        decode_end(avctx);
1010
        return AVERROR(ENOMEM);
1011
    }
1012
1013
5
    f->version = AV_RL32(avctx->extradata) >> 16;
1014
5
    ff_blockdsp_init(&f->bdsp, avctx);
1015
5
    ff_bswapdsp_init(&f->bbdsp);
1016
5
    f->avctx = avctx;
1017
5
    init_vlcs(f);
1018
1019
5
    if (f->version > 2)
1020
3
        avctx->pix_fmt = AV_PIX_FMT_RGB565;
1021
    else
1022
2
        avctx->pix_fmt = AV_PIX_FMT_BGR555;
1023
1024
5
    return 0;
1025
}
1026
1027
AVCodec ff_fourxm_decoder = {
1028
    .name           = "4xm",
1029
    .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1030
    .type           = AVMEDIA_TYPE_VIDEO,
1031
    .id             = AV_CODEC_ID_4XM,
1032
    .priv_data_size = sizeof(FourXContext),
1033
    .init           = decode_init,
1034
    .close          = decode_end,
1035
    .decode         = decode_frame,
1036
    .capabilities   = AV_CODEC_CAP_DR1,
1037
};