4xm: check for invalid zero ac coeffs
[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             if (code & 0xf) {
529                 level = get_xbits(&f->gb, code & 0xf);
530             } else {
531                 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
532                 return AVERROR_INVALIDDATA;
533             }
534             i    += code >> 4;
535             if (i >= 64) {
536                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
537                 return 0;
538             }
539
540             j = ff_zigzag_direct[i];
541             block[j] = level * dequant_table[j];
542             i++;
543             if (i >= 64)
544                 break;
545         }
546     }
547
548     return 0;
549 }
550
551 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
552 {
553     int16_t (*block)[64] = f->block;
554     int stride           = frame->linesize[0] >> 1;
555     int i;
556     uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
557
558     for (i = 0; i < 4; i++) {
559         block[i][0] += 0x80 * 8 * 8;
560         idct(block[i]);
561     }
562
563     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
564         for (i = 4; i < 6; i++)
565             idct(block[i]);
566     }
567
568     /* Note transform is:
569      * y  = ( 1b + 4g + 2r) / 14
570      * cb = ( 3b - 2g - 1r) / 14
571      * cr = (-1b - 4g + 5r) / 14 */
572     for (y = 0; y < 8; y++) {
573         for (x = 0; x < 8; x++) {
574             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
575                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
576             int cb = block[4][x + 8 * y];
577             int cr = block[5][x + 8 * y];
578             int cg = (cb + cr) >> 1;
579             int y;
580
581             cb += cb;
582
583             y               = temp[0];
584             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
585             y               = temp[1];
586             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
587             y               = temp[8];
588             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
589             y               = temp[9];
590             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591             dst            += 2;
592         }
593         dst += 2 * stride - 2 * 8;
594     }
595 }
596
597 static int decode_i_mb(FourXContext *f)
598 {
599     int ret;
600     int i;
601
602     f->dsp.clear_blocks(f->block[0]);
603
604     for (i = 0; i < 6; i++)
605         if ((ret = decode_i_block(f, f->block[i])) < 0)
606             return ret;
607
608     return 0;
609 }
610
611 static const uint8_t *read_huffman_tables(FourXContext *f,
612                                           const uint8_t * const buf,
613                                           int buf_size)
614 {
615     int frequency[512] = { 0 };
616     uint8_t flag[512];
617     int up[512];
618     uint8_t len_tab[257];
619     int bits_tab[257];
620     int start, end;
621     const uint8_t *ptr = buf;
622     const uint8_t *ptr_end = buf + buf_size;
623     int j;
624
625     memset(up, -1, sizeof(up));
626
627     start = *ptr++;
628     end   = *ptr++;
629     for (;;) {
630         int i;
631
632         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
633             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
634             return NULL;
635         }
636
637         for (i = start; i <= end; i++)
638             frequency[i] = *ptr++;
639         start = *ptr++;
640         if (start == 0)
641             break;
642
643         end = *ptr++;
644     }
645     frequency[256] = 1;
646
647     while ((ptr - buf) & 3)
648         ptr++; // 4byte align
649
650     if (ptr > ptr_end) {
651         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
652         return NULL;
653     }
654
655     for (j = 257; j < 512; j++) {
656         int min_freq[2] = { 256 * 256, 256 * 256 };
657         int smallest[2] = { 0, 0 };
658         int i;
659         for (i = 0; i < j; i++) {
660             if (frequency[i] == 0)
661                 continue;
662             if (frequency[i] < min_freq[1]) {
663                 if (frequency[i] < min_freq[0]) {
664                     min_freq[1] = min_freq[0];
665                     smallest[1] = smallest[0];
666                     min_freq[0] = frequency[i];
667                     smallest[0] = i;
668                 } else {
669                     min_freq[1] = frequency[i];
670                     smallest[1] = i;
671                 }
672             }
673         }
674         if (min_freq[1] == 256 * 256)
675             break;
676
677         frequency[j]           = min_freq[0] + min_freq[1];
678         flag[smallest[0]]      = 0;
679         flag[smallest[1]]      = 1;
680         up[smallest[0]]        =
681         up[smallest[1]]        = j;
682         frequency[smallest[0]] = frequency[smallest[1]] = 0;
683     }
684
685     for (j = 0; j < 257; j++) {
686         int node, len = 0, bits = 0;
687
688         for (node = j; up[node] != -1; node = up[node]) {
689             bits += flag[node] << len;
690             len++;
691             if (len > 31)
692                 // can this happen at all ?
693                 av_log(f->avctx, AV_LOG_ERROR,
694                        "vlc length overflow\n");
695         }
696
697         bits_tab[j] = bits;
698         len_tab[j]  = len;
699     }
700
701     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
702                  bits_tab, 4, 4, 0))
703         return NULL;
704
705     return ptr;
706 }
707
708 static int mix(int c0, int c1)
709 {
710     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
711     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
712     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
713     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
714 }
715
716 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
717 {
718     int x, y, x2, y2;
719     const int width  = f->avctx->width;
720     const int height = f->avctx->height;
721     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
722     uint16_t *dst    = (uint16_t*)frame->data[0];
723     const int stride =            frame->linesize[0]>>1;
724     const uint8_t *buf_end = buf + length;
725     GetByteContext g3;
726
727     if (length < mbs * 8) {
728         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
729         return AVERROR_INVALIDDATA;
730     }
731     bytestream2_init(&g3, buf, length);
732
733     for (y = 0; y < height; y += 16) {
734         for (x = 0; x < width; x += 16) {
735             unsigned int color[4] = { 0 }, bits;
736             if (buf_end - buf < 8)
737                 return -1;
738             // warning following is purely guessed ...
739             color[0] = bytestream2_get_le16u(&g3);
740             color[1] = bytestream2_get_le16u(&g3);
741
742             if (color[0] & 0x8000)
743                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
744             if (color[1] & 0x8000)
745                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
746
747             color[2] = mix(color[0], color[1]);
748             color[3] = mix(color[1], color[0]);
749
750             bits = bytestream2_get_le32u(&g3);
751             for (y2 = 0; y2 < 16; y2++) {
752                 for (x2 = 0; x2 < 16; x2++) {
753                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
754                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
755                 }
756             }
757             dst += 16;
758         }
759         dst += 16 * stride - x;
760     }
761
762     return 0;
763 }
764
765 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
766 {
767     int x, y, ret;
768     const int width  = f->avctx->width;
769     const int height = f->avctx->height;
770     const unsigned int bitstream_size = AV_RL32(buf);
771     unsigned int prestream_size;
772     const uint8_t *prestream;
773
774     if (bitstream_size > (1 << 26))
775         return AVERROR_INVALIDDATA;
776
777     if (length < bitstream_size + 12) {
778         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
779         return AVERROR_INVALIDDATA;
780     }
781
782     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
783     prestream      =             buf + bitstream_size + 12;
784
785     if (prestream_size + bitstream_size + 12 != length
786         || prestream_size > (1 << 26)) {
787         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
788                prestream_size, bitstream_size, length);
789         return AVERROR_INVALIDDATA;
790     }
791
792     prestream = read_huffman_tables(f, prestream, prestream_size);
793     if (!prestream) {
794         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
795         return AVERROR_INVALIDDATA;
796     }
797
798     av_assert0(prestream <= buf + length);
799
800     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
801
802     prestream_size = length + buf - prestream;
803
804     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
805                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
806     if (!f->bitstream_buffer)
807         return AVERROR(ENOMEM);
808     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
809                      prestream_size / 4);
810     memset((uint8_t*)f->bitstream_buffer + prestream_size,
811            0, FF_INPUT_BUFFER_PADDING_SIZE);
812     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
813
814     f->last_dc = 0 * 128 * 8 * 8;
815
816     for (y = 0; y < height; y += 16) {
817         for (x = 0; x < width; x += 16) {
818             if ((ret = decode_i_mb(f)) < 0)
819                 return ret;
820
821             idct_put(f, frame, x, y);
822         }
823     }
824
825     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
826         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
827
828     return 0;
829 }
830
831 static int decode_frame(AVCodecContext *avctx, void *data,
832                         int *got_frame, AVPacket *avpkt)
833 {
834     const uint8_t *buf    = avpkt->data;
835     int buf_size          = avpkt->size;
836     FourXContext *const f = avctx->priv_data;
837     AVFrame *picture      = data;
838     int i, frame_4cc, frame_size, ret;
839
840     if (buf_size < 20)
841         return AVERROR_INVALIDDATA;
842
843     if (buf_size < AV_RL32(buf + 4) + 8) {
844         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
845                buf_size, AV_RL32(buf + 4));
846         return AVERROR_INVALIDDATA;
847     }
848
849     frame_4cc = AV_RL32(buf);
850
851     if (frame_4cc == AV_RL32("cfrm")) {
852         int free_index       = -1;
853         int id, whole_size;
854         const int data_size  = buf_size - 20;
855         CFrameBuffer *cfrm;
856
857         if (f->version <= 1) {
858             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
859             return AVERROR_INVALIDDATA;
860         }
861
862         id         = AV_RL32(buf + 12);
863         whole_size = AV_RL32(buf + 16);
864
865         if (data_size < 0 || whole_size < 0) {
866             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
867             return AVERROR_INVALIDDATA;
868         }
869
870         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
871             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
872                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
873                        f->cfrm[i].id);
874
875         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
876             if (f->cfrm[i].id == id)
877                 break;
878             if (f->cfrm[i].size == 0)
879                 free_index = i;
880         }
881
882         if (i >= CFRAME_BUFFER_COUNT) {
883             i             = free_index;
884             f->cfrm[i].id = id;
885         }
886         cfrm = &f->cfrm[i];
887
888         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
889             return AVERROR_INVALIDDATA;
890
891         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
892                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
893         // explicit check needed as memcpy below might not catch a NULL
894         if (!cfrm->data) {
895             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
896             return AVERROR(ENOMEM);
897         }
898
899         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
900         cfrm->size += data_size;
901
902         if (cfrm->size >= whole_size) {
903             buf        = cfrm->data;
904             frame_size = cfrm->size;
905
906             if (id != avctx->frame_number)
907                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
908                        id, avctx->frame_number);
909
910             if (f->version <= 1)
911                 return AVERROR_INVALIDDATA;
912
913             cfrm->size = cfrm->id = 0;
914             frame_4cc  = AV_RL32("pfrm");
915         } else
916             return buf_size;
917     } else {
918         buf        = buf      + 12;
919         frame_size = buf_size - 12;
920     }
921
922     FFSWAP(AVFrame*, f->current_picture, f->last_picture);
923
924     // alternatively we would have to use our own buffer management
925     avctx->flags |= CODEC_FLAG_EMU_EDGE;
926
927     if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
928         return ret;
929
930     if (frame_4cc == AV_RL32("ifr2")) {
931         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
932         if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
933             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
934             return ret;
935         }
936     } else if (frame_4cc == AV_RL32("ifrm")) {
937         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
938         if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
939             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
940             return ret;
941         }
942     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
943         f->current_picture->pict_type = AV_PICTURE_TYPE_P;
944         if ((ret = decode_p_frame(f, f->current_picture, 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     f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
957
958     if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
959         return ret;
960     *got_frame = 1;
961
962     emms_c();
963
964     return buf_size;
965 }
966
967 static av_cold int decode_init(AVCodecContext *avctx)
968 {
969     FourXContext * const f = avctx->priv_data;
970
971     if (avctx->extradata_size != 4 || !avctx->extradata) {
972         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
973         return AVERROR_INVALIDDATA;
974     }
975     if((avctx->width % 16) || (avctx->height % 16)) {
976         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
977         return AVERROR_INVALIDDATA;
978     }
979
980     f->version = AV_RL32(avctx->extradata) >> 16;
981     ff_dsputil_init(&f->dsp, avctx);
982     f->avctx = avctx;
983     init_vlcs(f);
984
985     if (f->version > 2)
986         avctx->pix_fmt = AV_PIX_FMT_RGB565;
987     else
988         avctx->pix_fmt = AV_PIX_FMT_BGR555;
989
990     f->current_picture = av_frame_alloc();
991     f->last_picture    = av_frame_alloc();
992     if (!f->current_picture  || !f->last_picture)
993         return AVERROR(ENOMEM);
994
995     return 0;
996 }
997
998
999 static av_cold int decode_end(AVCodecContext *avctx)
1000 {
1001     FourXContext * const f = avctx->priv_data;
1002     int i;
1003
1004     av_freep(&f->bitstream_buffer);
1005     f->bitstream_buffer_size = 0;
1006     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1007         av_freep(&f->cfrm[i].data);
1008         f->cfrm[i].allocated_size = 0;
1009     }
1010     ff_free_vlc(&f->pre_vlc);
1011     av_frame_free(&f->current_picture);
1012     av_frame_free(&f->last_picture);
1013
1014     return 0;
1015 }
1016
1017 AVCodec ff_fourxm_decoder = {
1018     .name           = "4xm",
1019     .type           = AVMEDIA_TYPE_VIDEO,
1020     .id             = AV_CODEC_ID_4XM,
1021     .priv_data_size = sizeof(FourXContext),
1022     .init           = decode_init,
1023     .close          = decode_end,
1024     .decode         = decode_frame,
1025     .capabilities   = CODEC_CAP_DR1,
1026     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1027 };