3e0e6813317b6e20bf90150111559720688e136c
[ffmpeg.git] / libavcodec / 4xm.c
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 "libavutil/avassert.h"
28 #include "libavutil/frame.h"
29 #include "libavutil/intreadwrite.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "dsputil.h"
33 #include "get_bits.h"
34 #include "internal.h"
35
36
37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
39
40 #define CFRAME_BUFFER_COUNT 100
41
42 static const uint8_t block_type_tab[2][4][8][2] = {
43     {
44         {    // { 8, 4, 2 } x { 8, 4, 2}
45             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
46         }, { // { 8, 4 } x 1
47             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
48         }, { // 1 x { 8, 4 }
49             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50         }, { // 1 x 2, 2 x 1
51             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
52         }
53     }, {
54         {   // { 8, 4, 2 } x { 8, 4, 2}
55             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
56         }, {// { 8, 4 } x 1
57             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58         }, {// 1 x { 8, 4 }
59             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60         }, {// 1 x 2, 2 x 1
61             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
62       }
63     }
64 };
65
66 static const uint8_t size2index[4][4] = {
67     { -1, 3, 1, 1 },
68     {  3, 0, 0, 0 },
69     {  2, 0, 0, 0 },
70     {  2, 0, 0, 0 },
71 };
72
73 static const int8_t mv[256][2] = {
74     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
75     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
76     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
77     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
78     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
79     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
80     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
81     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
82     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
83     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
84     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
85     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
86     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
87     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
88     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
89     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
90     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
91     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
92     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
93     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
94     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
95     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
96     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
97     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
98     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
99     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
100     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
101     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
102     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
103     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
104     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
105     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
106 };
107
108 /* This is simply the scaled down elementwise product of the standard JPEG
109  * quantizer table and the AAN premul table. */
110 static const uint8_t dequant_table[64] = {
111     16, 15, 13, 19, 24, 31, 28, 17,
112     17, 23, 25, 31, 36, 63, 45, 21,
113     18, 24, 27, 37, 52, 59, 49, 20,
114     16, 28, 34, 40, 60, 80, 51, 20,
115     18, 31, 48, 66, 68, 86, 56, 21,
116     19, 38, 56, 59, 64, 64, 48, 20,
117     27, 48, 55, 55, 56, 51, 35, 15,
118     20, 35, 34, 32, 31, 22, 15,  8,
119 };
120
121 static VLC block_type_vlc[2][4];
122
123
124 typedef struct CFrameBuffer {
125     unsigned int allocated_size;
126     unsigned int size;
127     int id;
128     uint8_t *data;
129 } CFrameBuffer;
130
131 typedef struct FourXContext {
132     AVCodecContext *avctx;
133     DSPContext dsp;
134     AVFrame *current_picture, *last_picture;
135     GetBitContext pre_gb;          ///< ac/dc prefix
136     GetBitContext gb;
137     GetByteContext g;
138     GetByteContext g2;
139     int mv[256];
140     VLC pre_vlc;
141     int last_dc;
142     DECLARE_ALIGNED(16, int16_t, block)[6][64];
143     void *bitstream_buffer;
144     unsigned int bitstream_buffer_size;
145     int version;
146     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
147 } FourXContext;
148
149
150 #define FIX_1_082392200  70936
151 #define FIX_1_414213562  92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
154
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
156
157 static void idct(int16_t block[64])
158 {
159     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160     int tmp10, tmp11, tmp12, tmp13;
161     int z5, z10, z11, z12, z13;
162     int i;
163     int temp[64];
164
165     for (i = 0; i < 8; i++) {
166         tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167         tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
168
169         tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
170         tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
171
172         tmp0 = tmp10 + tmp13;
173         tmp3 = tmp10 - tmp13;
174         tmp1 = tmp11 + tmp12;
175         tmp2 = tmp11 - tmp12;
176
177         z13 = block[8 * 5 + i] + block[8 * 3 + i];
178         z10 = block[8 * 5 + i] - block[8 * 3 + i];
179         z11 = block[8 * 1 + i] + block[8 * 7 + i];
180         z12 = block[8 * 1 + i] - block[8 * 7 + i];
181
182         tmp7  =          z11 + z13;
183         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
184
185         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
186         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
187         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
188
189         tmp6 = tmp12 - tmp7;
190         tmp5 = tmp11 - tmp6;
191         tmp4 = tmp10 + tmp5;
192
193         temp[8 * 0 + i] = tmp0 + tmp7;
194         temp[8 * 7 + i] = tmp0 - tmp7;
195         temp[8 * 1 + i] = tmp1 + tmp6;
196         temp[8 * 6 + i] = tmp1 - tmp6;
197         temp[8 * 2 + i] = tmp2 + tmp5;
198         temp[8 * 5 + i] = tmp2 - tmp5;
199         temp[8 * 4 + i] = tmp3 + tmp4;
200         temp[8 * 3 + i] = tmp3 - tmp4;
201     }
202
203     for (i = 0; i < 8 * 8; i += 8) {
204         tmp10 = temp[0 + i] + temp[4 + i];
205         tmp11 = temp[0 + i] - temp[4 + i];
206
207         tmp13 = temp[2 + i] + temp[6 + i];
208         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
209
210         tmp0 = tmp10 + tmp13;
211         tmp3 = tmp10 - tmp13;
212         tmp1 = tmp11 + tmp12;
213         tmp2 = tmp11 - tmp12;
214
215         z13 = temp[5 + i] + temp[3 + i];
216         z10 = temp[5 + i] - temp[3 + i];
217         z11 = temp[1 + i] + temp[7 + i];
218         z12 = temp[1 + i] - temp[7 + i];
219
220         tmp7  = z11 + z13;
221         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
222
223         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
224         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
225         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
226
227         tmp6 = tmp12 - tmp7;
228         tmp5 = tmp11 - tmp6;
229         tmp4 = tmp10 + tmp5;
230
231         block[0 + i] = (tmp0 + tmp7) >> 6;
232         block[7 + i] = (tmp0 - tmp7) >> 6;
233         block[1 + i] = (tmp1 + tmp6) >> 6;
234         block[6 + i] = (tmp1 - tmp6) >> 6;
235         block[2 + i] = (tmp2 + tmp5) >> 6;
236         block[5 + i] = (tmp2 - tmp5) >> 6;
237         block[4 + i] = (tmp3 + tmp4) >> 6;
238         block[3 + i] = (tmp3 - tmp4) >> 6;
239     }
240 }
241
242 static av_cold void init_vlcs(FourXContext *f)
243 {
244     static VLC_TYPE table[2][4][32][2];
245     int i, j;
246
247     for (i = 0; i < 2; i++) {
248         for (j = 0; j < 4; j++) {
249             block_type_vlc[i][j].table           = table[i][j];
250             block_type_vlc[i][j].table_allocated = 32;
251             init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
252                      &block_type_tab[i][j][0][1], 2, 1,
253                      &block_type_tab[i][j][0][0], 2, 1,
254                      INIT_VLC_USE_NEW_STATIC);
255         }
256     }
257 }
258
259 static void init_mv(FourXContext *f, int linesize)
260 {
261     int i;
262
263     for (i = 0; i < 256; i++) {
264         if (f->version > 1)
265             f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
266         else
267             f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
268     }
269 }
270
271 #if HAVE_BIGENDIAN
272 #define LE_CENTRIC_MUL(dst, src, scale, dc)             \
273     {                                                   \
274         unsigned tmpval = AV_RN32(src);                 \
275         tmpval = (tmpval << 16) | (tmpval >> 16);       \
276         tmpval = tmpval * (scale) + (dc);               \
277         tmpval = (tmpval << 16) | (tmpval >> 16);       \
278         AV_WN32A(dst, tmpval);                          \
279     }
280 #else
281 #define LE_CENTRIC_MUL(dst, src, scale, dc)              \
282     {                                                    \
283         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284         AV_WN32A(dst, tmpval);                           \
285     }
286 #endif
287
288 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
289                         int h, int stride, int scale, unsigned dc)
290 {
291     int i;
292     dc *= 0x10001;
293
294     switch (log2w) {
295     case 0:
296         for (i = 0; i < h; i++) {
297             dst[0] = scale * src[0] + dc;
298             if (scale)
299                 src += stride;
300             dst += stride;
301         }
302         break;
303     case 1:
304         for (i = 0; i < h; i++) {
305             LE_CENTRIC_MUL(dst, src, scale, dc);
306             if (scale)
307                 src += stride;
308             dst += stride;
309         }
310         break;
311     case 2:
312         for (i = 0; i < h; i++) {
313             LE_CENTRIC_MUL(dst, src, scale, dc);
314             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
315             if (scale)
316                 src += stride;
317             dst += stride;
318         }
319         break;
320     case 3:
321         for (i = 0; i < h; i++) {
322             LE_CENTRIC_MUL(dst,     src,     scale, dc);
323             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
324             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
325             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
326             if (scale)
327                 src += stride;
328             dst += stride;
329         }
330         break;
331     default:
332         av_assert0(0);
333     }
334 }
335
336 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
337                           int log2w, int log2h, int stride)
338 {
339     const int index = size2index[log2h][log2w];
340     const int h     = 1 << log2h;
341     int code        = get_vlc2(&f->gb,
342                                block_type_vlc[1 - (f->version > 1)][index].table,
343                                BLOCK_TYPE_VLC_BITS, 1);
344     uint16_t *start = (uint16_t *)f->last_picture->data[0];
345     uint16_t *end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
346     int ret;
347     int scale   = 1;
348     unsigned dc = 0;
349
350     av_assert0(code >= 0 && code <= 6 && log2w >= 0);
351
352     if (code == 1) {
353         log2h--;
354         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
355             return ret;
356         return decode_p_block(f, dst + (stride << log2h),
357                               src + (stride << log2h),
358                               log2w, log2h, stride);
359     } else if (code == 2) {
360         log2w--;
361         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
362             return ret;
363         return decode_p_block(f, dst + (1 << log2w),
364                               src + (1 << log2w),
365                               log2w, log2h, stride);
366     } else if (code == 6) {
367         if (bytestream2_get_bytes_left(&f->g2) < 4) {
368             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
369             return AVERROR_INVALIDDATA;
370         }
371         if (log2w) {
372             dst[0]      = bytestream2_get_le16u(&f->g2);
373             dst[1]      = bytestream2_get_le16u(&f->g2);
374         } else {
375             dst[0]      = bytestream2_get_le16u(&f->g2);
376             dst[stride] = bytestream2_get_le16u(&f->g2);
377         }
378         return 0;
379     }
380
381     if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
382         av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
383         return AVERROR_INVALIDDATA;
384     }
385
386     if (code == 0) {
387         src  += f->mv[bytestream2_get_byte(&f->g)];
388     } else if (code == 3 && f->version >= 2) {
389         return 0;
390     } else if (code == 4) {
391         src  += f->mv[bytestream2_get_byte(&f->g)];
392         if (bytestream2_get_bytes_left(&f->g2) < 2){
393             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
394             return AVERROR_INVALIDDATA;
395         }
396         dc    = bytestream2_get_le16(&f->g2);
397     } else if (code == 5) {
398         if (bytestream2_get_bytes_left(&f->g2) < 2){
399             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
400             return AVERROR_INVALIDDATA;
401         }
402         av_assert0(start <= src && src <= end);
403         scale = 0;
404         dc    = bytestream2_get_le16(&f->g2);
405     }
406
407     if (start > src || src > end) {
408         av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
409         return AVERROR_INVALIDDATA;
410     }
411
412     mcdc(dst, src, log2w, h, stride, scale, dc);
413
414     return 0;
415 }
416
417 static int decode_p_frame(FourXContext *f, AVFrame *frame,
418                           const uint8_t *buf, int length)
419 {
420     int x, y;
421     const int width  = f->avctx->width;
422     const int height = f->avctx->height;
423     uint16_t *dst    = (uint16_t *)frame->data[0];
424     const int stride =             frame->linesize[0] >> 1;
425     uint16_t *src;
426     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427                  bytestream_offset, wordstream_offset;
428     int ret;
429
430     if (!f->last_picture->data[0]) {
431         if ((ret = ff_get_buffer(f->avctx, f->last_picture,
432                                  AV_GET_BUFFER_FLAG_REF)) < 0) {
433             return ret;
434         }
435         for (y=0; y<f->avctx->height; y++)
436             memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);
437     }
438
439     src = (uint16_t *)f->last_picture->data[0];
440
441     if (f->version > 1) {
442         extra           = 20;
443         if (length < extra)
444             return AVERROR_INVALIDDATA;
445         bitstream_size  = AV_RL32(buf + 8);
446         wordstream_size = AV_RL32(buf + 12);
447         bytestream_size = AV_RL32(buf + 16);
448     } else {
449         extra           = 0;
450         bitstream_size  = AV_RL16(buf - 4);
451         wordstream_size = AV_RL16(buf - 2);
452         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
453     }
454
455     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
456         bytestream_size > length - bitstream_size ||
457         wordstream_size > length - bytestream_size - bitstream_size ||
458         extra > length - bytestream_size - bitstream_size - wordstream_size) {
459         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
460         bitstream_size+ bytestream_size+ wordstream_size - length);
461         return AVERROR_INVALIDDATA;
462     }
463
464     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
465                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
466     if (!f->bitstream_buffer)
467         return AVERROR(ENOMEM);
468     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
469                      bitstream_size / 4);
470     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
471            0, FF_INPUT_BUFFER_PADDING_SIZE);
472     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
473
474     wordstream_offset = extra + bitstream_size;
475     bytestream_offset = extra + bitstream_size + wordstream_size;
476     bytestream2_init(&f->g2, buf + wordstream_offset,
477                      length - wordstream_offset);
478     bytestream2_init(&f->g, buf + bytestream_offset,
479                      length - bytestream_offset);
480
481     init_mv(f, frame->linesize[0]);
482
483     for (y = 0; y < height; y += 8) {
484         for (x = 0; x < width; x += 8)
485             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
486                 return ret;
487         src += 8 * stride;
488         dst += 8 * stride;
489     }
490
491     return 0;
492 }
493
494 /**
495  * decode block and dequantize.
496  * Note this is almost identical to MJPEG.
497  */
498 static int decode_i_block(FourXContext *f, int16_t *block)
499 {
500     int code, i, j, level, val;
501
502     if (get_bits_left(&f->gb) < 2){
503         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
504         return -1;
505     }
506
507     /* DC coef */
508     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
509     if (val >> 4)
510         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
511
512     if (val)
513         val = get_xbits(&f->gb, val);
514
515     val        = val * dequant_table[0] + f->last_dc;
516     f->last_dc = block[0] = val;
517     /* AC coefs */
518     i = 1;
519     for (;;) {
520         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
521
522         /* EOB */
523         if (code == 0)
524             break;
525         if (code == 0xf0) {
526             i += 16;
527         } else {
528             level = get_xbits(&f->gb, code & 0xf);
529             i    += code >> 4;
530             if (i >= 64) {
531                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
532                 return 0;
533             }
534
535             j = ff_zigzag_direct[i];
536             block[j] = level * dequant_table[j];
537             i++;
538             if (i >= 64)
539                 break;
540         }
541     }
542
543     return 0;
544 }
545
546 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
547 {
548     int16_t (*block)[64] = f->block;
549     int stride           = frame->linesize[0] >> 1;
550     int i;
551     uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
552
553     for (i = 0; i < 4; i++) {
554         block[i][0] += 0x80 * 8 * 8;
555         idct(block[i]);
556     }
557
558     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
559         for (i = 4; i < 6; i++)
560             idct(block[i]);
561     }
562
563     /* Note transform is:
564      * y  = ( 1b + 4g + 2r) / 14
565      * cb = ( 3b - 2g - 1r) / 14
566      * cr = (-1b - 4g + 5r) / 14 */
567     for (y = 0; y < 8; y++) {
568         for (x = 0; x < 8; x++) {
569             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
570                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
571             int cb = block[4][x + 8 * y];
572             int cr = block[5][x + 8 * y];
573             int cg = (cb + cr) >> 1;
574             int y;
575
576             cb += cb;
577
578             y               = temp[0];
579             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
580             y               = temp[1];
581             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
582             y               = temp[8];
583             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
584             y               = temp[9];
585             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586             dst            += 2;
587         }
588         dst += 2 * stride - 2 * 8;
589     }
590 }
591
592 static int decode_i_mb(FourXContext *f)
593 {
594     int ret;
595     int i;
596
597     f->dsp.clear_blocks(f->block[0]);
598
599     for (i = 0; i < 6; i++)
600         if ((ret = decode_i_block(f, f->block[i])) < 0)
601             return ret;
602
603     return 0;
604 }
605
606 static const uint8_t *read_huffman_tables(FourXContext *f,
607                                           const uint8_t * const buf,
608                                           int buf_size)
609 {
610     int frequency[512] = { 0 };
611     uint8_t flag[512];
612     int up[512];
613     uint8_t len_tab[257];
614     int bits_tab[257];
615     int start, end;
616     const uint8_t *ptr = buf;
617     const uint8_t *ptr_end = buf + buf_size;
618     int j;
619
620     memset(up, -1, sizeof(up));
621
622     start = *ptr++;
623     end   = *ptr++;
624     for (;;) {
625         int i;
626
627         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
628             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
629             return NULL;
630         }
631
632         for (i = start; i <= end; i++)
633             frequency[i] = *ptr++;
634         start = *ptr++;
635         if (start == 0)
636             break;
637
638         end = *ptr++;
639     }
640     frequency[256] = 1;
641
642     while ((ptr - buf) & 3)
643         ptr++; // 4byte align
644
645     if (ptr > ptr_end) {
646         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
647         return NULL;
648     }
649
650     for (j = 257; j < 512; j++) {
651         int min_freq[2] = { 256 * 256, 256 * 256 };
652         int smallest[2] = { 0, 0 };
653         int i;
654         for (i = 0; i < j; i++) {
655             if (frequency[i] == 0)
656                 continue;
657             if (frequency[i] < min_freq[1]) {
658                 if (frequency[i] < min_freq[0]) {
659                     min_freq[1] = min_freq[0];
660                     smallest[1] = smallest[0];
661                     min_freq[0] = frequency[i];
662                     smallest[0] = i;
663                 } else {
664                     min_freq[1] = frequency[i];
665                     smallest[1] = i;
666                 }
667             }
668         }
669         if (min_freq[1] == 256 * 256)
670             break;
671
672         frequency[j]           = min_freq[0] + min_freq[1];
673         flag[smallest[0]]      = 0;
674         flag[smallest[1]]      = 1;
675         up[smallest[0]]        =
676         up[smallest[1]]        = j;
677         frequency[smallest[0]] = frequency[smallest[1]] = 0;
678     }
679
680     for (j = 0; j < 257; j++) {
681         int node, len = 0, bits = 0;
682
683         for (node = j; up[node] != -1; node = up[node]) {
684             bits += flag[node] << len;
685             len++;
686             if (len > 31)
687                 // can this happen at all ?
688                 av_log(f->avctx, AV_LOG_ERROR,
689                        "vlc length overflow\n");
690         }
691
692         bits_tab[j] = bits;
693         len_tab[j]  = len;
694     }
695
696     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
697                  bits_tab, 4, 4, 0))
698         return NULL;
699
700     return ptr;
701 }
702
703 static int mix(int c0, int c1)
704 {
705     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
706     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
707     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
708     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
709 }
710
711 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
712 {
713     int x, y, x2, y2;
714     const int width  = f->avctx->width;
715     const int height = f->avctx->height;
716     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
717     uint16_t *dst    = (uint16_t*)frame->data[0];
718     const int stride =            frame->linesize[0]>>1;
719     const uint8_t *buf_end = buf + length;
720     GetByteContext g3;
721
722     if (length < mbs * 8) {
723         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
724         return AVERROR_INVALIDDATA;
725     }
726     bytestream2_init(&g3, buf, length);
727
728     for (y = 0; y < height; y += 16) {
729         for (x = 0; x < width; x += 16) {
730             unsigned int color[4] = { 0 }, bits;
731             if (buf_end - buf < 8)
732                 return -1;
733             // warning following is purely guessed ...
734             color[0] = bytestream2_get_le16u(&g3);
735             color[1] = bytestream2_get_le16u(&g3);
736
737             if (color[0] & 0x8000)
738                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
739             if (color[1] & 0x8000)
740                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
741
742             color[2] = mix(color[0], color[1]);
743             color[3] = mix(color[1], color[0]);
744
745             bits = bytestream2_get_le32u(&g3);
746             for (y2 = 0; y2 < 16; y2++) {
747                 for (x2 = 0; x2 < 16; x2++) {
748                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
749                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
750                 }
751             }
752             dst += 16;
753         }
754         dst += 16 * stride - x;
755     }
756
757     return 0;
758 }
759
760 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
761 {
762     int x, y, ret;
763     const int width  = f->avctx->width;
764     const int height = f->avctx->height;
765     const unsigned int bitstream_size = AV_RL32(buf);
766     unsigned int prestream_size;
767     const uint8_t *prestream;
768
769     if (bitstream_size > (1 << 26))
770         return AVERROR_INVALIDDATA;
771
772     if (length < bitstream_size + 12) {
773         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
774         return AVERROR_INVALIDDATA;
775     }
776
777     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
778     prestream      =             buf + bitstream_size + 12;
779
780     if (prestream_size + bitstream_size + 12 != length
781         || prestream_size > (1 << 26)) {
782         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
783                prestream_size, bitstream_size, length);
784         return AVERROR_INVALIDDATA;
785     }
786
787     prestream = read_huffman_tables(f, prestream, prestream_size);
788     if (!prestream) {
789         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
790         return AVERROR_INVALIDDATA;
791     }
792
793     av_assert0(prestream <= buf + length);
794
795     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
796
797     prestream_size = length + buf - prestream;
798
799     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
800                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
801     if (!f->bitstream_buffer)
802         return AVERROR(ENOMEM);
803     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
804                      prestream_size / 4);
805     memset((uint8_t*)f->bitstream_buffer + prestream_size,
806            0, FF_INPUT_BUFFER_PADDING_SIZE);
807     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
808
809     f->last_dc = 0 * 128 * 8 * 8;
810
811     for (y = 0; y < height; y += 16) {
812         for (x = 0; x < width; x += 16) {
813             if ((ret = decode_i_mb(f)) < 0)
814                 return ret;
815
816             idct_put(f, frame, x, y);
817         }
818     }
819
820     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
821         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
822
823     return 0;
824 }
825
826 static int decode_frame(AVCodecContext *avctx, void *data,
827                         int *got_frame, AVPacket *avpkt)
828 {
829     const uint8_t *buf    = avpkt->data;
830     int buf_size          = avpkt->size;
831     FourXContext *const f = avctx->priv_data;
832     AVFrame *picture      = data;
833     int i, frame_4cc, frame_size, ret;
834
835     if (buf_size < 20)
836         return AVERROR_INVALIDDATA;
837
838     if (buf_size < AV_RL32(buf + 4) + 8) {
839         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
840                buf_size, AV_RL32(buf + 4));
841         return AVERROR_INVALIDDATA;
842     }
843
844     frame_4cc = AV_RL32(buf);
845
846     if (frame_4cc == AV_RL32("cfrm")) {
847         int free_index       = -1;
848         int id, whole_size;
849         const int data_size  = buf_size - 20;
850         CFrameBuffer *cfrm;
851
852         if (f->version <= 1) {
853             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
854             return AVERROR_INVALIDDATA;
855         }
856
857         id         = AV_RL32(buf + 12);
858         whole_size = AV_RL32(buf + 16);
859
860         if (data_size < 0 || whole_size < 0) {
861             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
862             return AVERROR_INVALIDDATA;
863         }
864
865         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
866             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
867                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
868                        f->cfrm[i].id);
869
870         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
871             if (f->cfrm[i].id == id)
872                 break;
873             if (f->cfrm[i].size == 0)
874                 free_index = i;
875         }
876
877         if (i >= CFRAME_BUFFER_COUNT) {
878             i             = free_index;
879             f->cfrm[i].id = id;
880         }
881         cfrm = &f->cfrm[i];
882
883         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
884             return AVERROR_INVALIDDATA;
885
886         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
887                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
888         // explicit check needed as memcpy below might not catch a NULL
889         if (!cfrm->data) {
890             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
891             return AVERROR(ENOMEM);
892         }
893
894         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
895         cfrm->size += data_size;
896
897         if (cfrm->size >= whole_size) {
898             buf        = cfrm->data;
899             frame_size = cfrm->size;
900
901             if (id != avctx->frame_number)
902                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
903                        id, avctx->frame_number);
904
905             if (f->version <= 1)
906                 return AVERROR_INVALIDDATA;
907
908             cfrm->size = cfrm->id = 0;
909             frame_4cc  = AV_RL32("pfrm");
910         } else
911             return buf_size;
912     } else {
913         buf        = buf      + 12;
914         frame_size = buf_size - 12;
915     }
916
917     FFSWAP(AVFrame*, f->current_picture, f->last_picture);
918
919     // alternatively we would have to use our own buffer management
920     avctx->flags |= CODEC_FLAG_EMU_EDGE;
921
922     if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
923         return ret;
924
925     if (frame_4cc == AV_RL32("ifr2")) {
926         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
927         if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
928             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
929             return ret;
930         }
931     } else if (frame_4cc == AV_RL32("ifrm")) {
932         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
933         if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
934             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
935             return ret;
936         }
937     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
938         f->current_picture->pict_type = AV_PICTURE_TYPE_P;
939         if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
940             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
941             return ret;
942         }
943     } else if (frame_4cc == AV_RL32("snd_")) {
944         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
945                buf_size);
946     } else {
947         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
948                buf_size);
949     }
950
951     f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
952
953     if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
954         return ret;
955     *got_frame = 1;
956
957     emms_c();
958
959     return buf_size;
960 }
961
962 static av_cold int decode_init(AVCodecContext *avctx)
963 {
964     FourXContext * const f = avctx->priv_data;
965
966     if (avctx->extradata_size != 4 || !avctx->extradata) {
967         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
968         return AVERROR_INVALIDDATA;
969     }
970     if((avctx->width % 16) || (avctx->height % 16)) {
971         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
972         return AVERROR_INVALIDDATA;
973     }
974
975     f->version = AV_RL32(avctx->extradata) >> 16;
976     ff_dsputil_init(&f->dsp, avctx);
977     f->avctx = avctx;
978     init_vlcs(f);
979
980     if (f->version > 2)
981         avctx->pix_fmt = AV_PIX_FMT_RGB565;
982     else
983         avctx->pix_fmt = AV_PIX_FMT_BGR555;
984
985     f->current_picture = av_frame_alloc();
986     f->last_picture    = av_frame_alloc();
987     if (!f->current_picture  || !f->last_picture)
988         return AVERROR(ENOMEM);
989
990     return 0;
991 }
992
993
994 static av_cold int decode_end(AVCodecContext *avctx)
995 {
996     FourXContext * const f = avctx->priv_data;
997     int i;
998
999     av_freep(&f->bitstream_buffer);
1000     f->bitstream_buffer_size = 0;
1001     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1002         av_freep(&f->cfrm[i].data);
1003         f->cfrm[i].allocated_size = 0;
1004     }
1005     ff_free_vlc(&f->pre_vlc);
1006     av_frame_free(&f->current_picture);
1007     av_frame_free(&f->last_picture);
1008
1009     return 0;
1010 }
1011
1012 AVCodec ff_fourxm_decoder = {
1013     .name           = "4xm",
1014     .type           = AVMEDIA_TYPE_VIDEO,
1015     .id             = AV_CODEC_ID_4XM,
1016     .priv_data_size = sizeof(FourXContext),
1017     .init           = decode_init,
1018     .close          = decode_end,
1019     .decode         = decode_frame,
1020     .capabilities   = CODEC_CAP_DR1,
1021     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1022 };