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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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