Merge commit 'be373cb50d3c411366fec7eef2eb3681abe48f96'
[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
348     av_assert0(code >= 0 && code <= 6 && log2w >= 0);
349
350     if (code == 0) {
351         if (bytestream2_get_bytes_left(&f->g) < 1) {
352             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
353             return AVERROR_INVALIDDATA;
354         }
355         src += f->mv[bytestream2_get_byteu(&f->g)];
356         if (start > src || src > end) {
357             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
358             return AVERROR_INVALIDDATA;
359         }
360         mcdc(dst, src, log2w, h, stride, 1, 0);
361     } else if (code == 1) {
362         log2h--;
363         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
364             return ret;
365         if ((ret = decode_p_block(f, dst + (stride << log2h),
366                                   src + (stride << log2h),
367                                   log2w, log2h, stride)) < 0)
368             return ret;
369     } else if (code == 2) {
370         log2w--;
371         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
372             return ret;
373         if ((ret = decode_p_block(f, dst + (1 << log2w),
374                                   src + (1 << log2w),
375                                   log2w, log2h, stride)) < 0)
376             return ret;
377     } else if (code == 3 && f->version < 2) {
378         mcdc(dst, src, log2w, h, stride, 1, 0);
379     } else if (code == 4) {
380         if (bytestream2_get_bytes_left(&f->g) < 1) {
381             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
382             return AVERROR_INVALIDDATA;
383         }
384         src += f->mv[bytestream2_get_byteu(&f->g)];
385         if (start > src || src > end) {
386             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
387             return AVERROR_INVALIDDATA;
388         }
389         if (bytestream2_get_bytes_left(&f->g2) < 2){
390             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
391             return AVERROR_INVALIDDATA;
392         }
393         mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->g2));
394     } else if (code == 5) {
395         if (bytestream2_get_bytes_left(&f->g2) < 2) {
396             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
397             return AVERROR_INVALIDDATA;
398         }
399         mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->g2));
400     } else if (code == 6) {
401         if (bytestream2_get_bytes_left(&f->g2) < 4) {
402             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
403             return AVERROR_INVALIDDATA;
404         }
405         if (log2w) {
406             dst[0]      = bytestream2_get_le16u(&f->g2);
407             dst[1]      = bytestream2_get_le16u(&f->g2);
408         } else {
409             dst[0]      = bytestream2_get_le16u(&f->g2);
410             dst[stride] = bytestream2_get_le16u(&f->g2);
411         }
412     }
413     return 0;
414 }
415
416 static int decode_p_frame(FourXContext *f, AVFrame *frame,
417                           const uint8_t *buf, int length)
418 {
419     int x, y;
420     const int width  = f->avctx->width;
421     const int height = f->avctx->height;
422     uint16_t *dst    = (uint16_t *)frame->data[0];
423     const int stride =             frame->linesize[0] >> 1;
424     uint16_t *src;
425     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
426                  bytestream_offset, wordstream_offset;
427     int ret;
428
429     if (!f->last_picture->data[0]) {
430         if ((ret = ff_get_buffer(f->avctx, f->last_picture,
431                                  AV_GET_BUFFER_FLAG_REF)) < 0) {
432             return ret;
433         }
434         for (y=0; y<f->avctx->height; y++)
435             memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);
436     }
437
438     src = (uint16_t *)f->last_picture->data[0];
439
440     if (f->version > 1) {
441         extra           = 20;
442         if (length < extra)
443             return AVERROR_INVALIDDATA;
444         bitstream_size  = AV_RL32(buf + 8);
445         wordstream_size = AV_RL32(buf + 12);
446         bytestream_size = AV_RL32(buf + 16);
447     } else {
448         extra           = 0;
449         bitstream_size  = AV_RL16(buf - 4);
450         wordstream_size = AV_RL16(buf - 2);
451         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
452     }
453
454     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
455         bytestream_size > length - bitstream_size ||
456         wordstream_size > length - bytestream_size - bitstream_size ||
457         extra > length - bytestream_size - bitstream_size - wordstream_size) {
458         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
459         bitstream_size+ bytestream_size+ wordstream_size - length);
460         return AVERROR_INVALIDDATA;
461     }
462
463     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
464                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
465     if (!f->bitstream_buffer)
466         return AVERROR(ENOMEM);
467     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
468                      bitstream_size / 4);
469     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
470            0, FF_INPUT_BUFFER_PADDING_SIZE);
471     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
472
473     wordstream_offset = extra + bitstream_size;
474     bytestream_offset = extra + bitstream_size + wordstream_size;
475     bytestream2_init(&f->g2, buf + wordstream_offset,
476                      length - wordstream_offset);
477     bytestream2_init(&f->g, buf + bytestream_offset,
478                      length - bytestream_offset);
479
480     init_mv(f, frame->linesize[0]);
481
482     for (y = 0; y < height; y += 8) {
483         for (x = 0; x < width; x += 8)
484             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
485                 return ret;
486         src += 8 * stride;
487         dst += 8 * stride;
488     }
489
490     return 0;
491 }
492
493 /**
494  * decode block and dequantize.
495  * Note this is almost identical to MJPEG.
496  */
497 static int decode_i_block(FourXContext *f, int16_t *block)
498 {
499     int code, i, j, level, val;
500
501     if (get_bits_left(&f->gb) < 2){
502         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
503         return -1;
504     }
505
506     /* DC coef */
507     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
508     if (val >> 4)
509         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
510
511     if (val)
512         val = get_xbits(&f->gb, val);
513
514     val        = val * dequant_table[0] + f->last_dc;
515     f->last_dc = block[0] = val;
516     /* AC coefs */
517     i = 1;
518     for (;;) {
519         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
520
521         /* EOB */
522         if (code == 0)
523             break;
524         if (code == 0xf0) {
525             i += 16;
526         } else {
527             level = get_xbits(&f->gb, code & 0xf);
528             i    += code >> 4;
529             if (i >= 64) {
530                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
531                 return 0;
532             }
533
534             j = ff_zigzag_direct[i];
535             block[j] = level * dequant_table[j];
536             i++;
537             if (i >= 64)
538                 break;
539         }
540     }
541
542     return 0;
543 }
544
545 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
546 {
547     int16_t (*block)[64] = f->block;
548     int stride           = frame->linesize[0] >> 1;
549     int i;
550     uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
551
552     for (i = 0; i < 4; i++) {
553         block[i][0] += 0x80 * 8 * 8;
554         idct(block[i]);
555     }
556
557     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
558         for (i = 4; i < 6; i++)
559             idct(block[i]);
560     }
561
562     /* Note transform is:
563      * y  = ( 1b + 4g + 2r) / 14
564      * cb = ( 3b - 2g - 1r) / 14
565      * cr = (-1b - 4g + 5r) / 14 */
566     for (y = 0; y < 8; y++) {
567         for (x = 0; x < 8; x++) {
568             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
569                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
570             int cb = block[4][x + 8 * y];
571             int cr = block[5][x + 8 * y];
572             int cg = (cb + cr) >> 1;
573             int y;
574
575             cb += cb;
576
577             y               = temp[0];
578             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
579             y               = temp[1];
580             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
581             y               = temp[8];
582             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
583             y               = temp[9];
584             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
585             dst            += 2;
586         }
587         dst += 2 * stride - 2 * 8;
588     }
589 }
590
591 static int decode_i_mb(FourXContext *f)
592 {
593     int ret;
594     int i;
595
596     f->dsp.clear_blocks(f->block[0]);
597
598     for (i = 0; i < 6; i++)
599         if ((ret = decode_i_block(f, f->block[i])) < 0)
600             return ret;
601
602     return 0;
603 }
604
605 static const uint8_t *read_huffman_tables(FourXContext *f,
606                                           const uint8_t * const buf,
607                                           int buf_size)
608 {
609     int frequency[512] = { 0 };
610     uint8_t flag[512];
611     int up[512];
612     uint8_t len_tab[257];
613     int bits_tab[257];
614     int start, end;
615     const uint8_t *ptr = buf;
616     const uint8_t *ptr_end = buf + buf_size;
617     int j;
618
619     memset(up, -1, sizeof(up));
620
621     start = *ptr++;
622     end   = *ptr++;
623     for (;;) {
624         int i;
625
626         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
627             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
628             return NULL;
629         }
630
631         for (i = start; i <= end; i++)
632             frequency[i] = *ptr++;
633         start = *ptr++;
634         if (start == 0)
635             break;
636
637         end = *ptr++;
638     }
639     frequency[256] = 1;
640
641     while ((ptr - buf) & 3)
642         ptr++; // 4byte align
643
644     if (ptr > ptr_end) {
645         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
646         return NULL;
647     }
648
649     for (j = 257; j < 512; j++) {
650         int min_freq[2] = { 256 * 256, 256 * 256 };
651         int smallest[2] = { 0, 0 };
652         int i;
653         for (i = 0; i < j; i++) {
654             if (frequency[i] == 0)
655                 continue;
656             if (frequency[i] < min_freq[1]) {
657                 if (frequency[i] < min_freq[0]) {
658                     min_freq[1] = min_freq[0];
659                     smallest[1] = smallest[0];
660                     min_freq[0] = frequency[i];
661                     smallest[0] = i;
662                 } else {
663                     min_freq[1] = frequency[i];
664                     smallest[1] = i;
665                 }
666             }
667         }
668         if (min_freq[1] == 256 * 256)
669             break;
670
671         frequency[j]           = min_freq[0] + min_freq[1];
672         flag[smallest[0]]      = 0;
673         flag[smallest[1]]      = 1;
674         up[smallest[0]]        =
675         up[smallest[1]]        = j;
676         frequency[smallest[0]] = frequency[smallest[1]] = 0;
677     }
678
679     for (j = 0; j < 257; j++) {
680         int node, len = 0, bits = 0;
681
682         for (node = j; up[node] != -1; node = up[node]) {
683             bits += flag[node] << len;
684             len++;
685             if (len > 31)
686                 // can this happen at all ?
687                 av_log(f->avctx, AV_LOG_ERROR,
688                        "vlc length overflow\n");
689         }
690
691         bits_tab[j] = bits;
692         len_tab[j]  = len;
693     }
694
695     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
696                  bits_tab, 4, 4, 0))
697         return NULL;
698
699     return ptr;
700 }
701
702 static int mix(int c0, int c1)
703 {
704     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
705     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
706     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
707     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
708 }
709
710 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
711 {
712     int x, y, x2, y2;
713     const int width  = f->avctx->width;
714     const int height = f->avctx->height;
715     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
716     uint16_t *dst    = (uint16_t*)frame->data[0];
717     const int stride =            frame->linesize[0]>>1;
718     const uint8_t *buf_end = buf + length;
719     GetByteContext g3;
720
721     if (length < mbs * 8) {
722         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
723         return AVERROR_INVALIDDATA;
724     }
725     bytestream2_init(&g3, buf, length);
726
727     for (y = 0; y < height; y += 16) {
728         for (x = 0; x < width; x += 16) {
729             unsigned int color[4] = { 0 }, bits;
730             if (buf_end - buf < 8)
731                 return -1;
732             // warning following is purely guessed ...
733             color[0] = bytestream2_get_le16u(&g3);
734             color[1] = bytestream2_get_le16u(&g3);
735
736             if (color[0] & 0x8000)
737                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
738             if (color[1] & 0x8000)
739                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
740
741             color[2] = mix(color[0], color[1]);
742             color[3] = mix(color[1], color[0]);
743
744             bits = bytestream2_get_le32u(&g3);
745             for (y2 = 0; y2 < 16; y2++) {
746                 for (x2 = 0; x2 < 16; x2++) {
747                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
748                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
749                 }
750             }
751             dst += 16;
752         }
753         dst += 16 * stride - x;
754     }
755
756     return 0;
757 }
758
759 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
760 {
761     int x, y, ret;
762     const int width  = f->avctx->width;
763     const int height = f->avctx->height;
764     const unsigned int bitstream_size = AV_RL32(buf);
765     unsigned int prestream_size;
766     const uint8_t *prestream;
767
768     if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
769         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
770         return AVERROR_INVALIDDATA;
771     }
772
773     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
774     prestream      =             buf + bitstream_size + 12;
775
776     if (prestream_size + bitstream_size + 12 != length
777         || bitstream_size > (1 << 26)
778         || prestream_size > (1 << 26)) {
779         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
780                prestream_size, bitstream_size, length);
781         return AVERROR_INVALIDDATA;
782     }
783
784     prestream = read_huffman_tables(f, prestream, prestream_size);
785     if (!prestream) {
786         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
787         return AVERROR_INVALIDDATA;
788     }
789
790     av_assert0(prestream <= buf + length);
791
792     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
793
794     prestream_size = length + buf - prestream;
795
796     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
797                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
798     if (!f->bitstream_buffer)
799         return AVERROR(ENOMEM);
800     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
801                      prestream_size / 4);
802     memset((uint8_t*)f->bitstream_buffer + prestream_size,
803            0, FF_INPUT_BUFFER_PADDING_SIZE);
804     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
805
806     f->last_dc = 0 * 128 * 8 * 8;
807
808     for (y = 0; y < height; y += 16) {
809         for (x = 0; x < width; x += 16) {
810             if ((ret = decode_i_mb(f)) < 0)
811                 return ret;
812
813             idct_put(f, frame, x, y);
814         }
815     }
816
817     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
818         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
819
820     return 0;
821 }
822
823 static int decode_frame(AVCodecContext *avctx, void *data,
824                         int *got_frame, AVPacket *avpkt)
825 {
826     const uint8_t *buf    = avpkt->data;
827     int buf_size          = avpkt->size;
828     FourXContext *const f = avctx->priv_data;
829     AVFrame *picture      = data;
830     int i, frame_4cc, frame_size, ret;
831
832     if (buf_size < 20)
833         return AVERROR_INVALIDDATA;
834
835     if (buf_size < AV_RL32(buf + 4) + 8) {
836         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
837                buf_size, AV_RL32(buf + 4));
838         return AVERROR_INVALIDDATA;
839     }
840
841     frame_4cc = AV_RL32(buf);
842
843     if (frame_4cc == AV_RL32("cfrm")) {
844         int free_index       = -1;
845         int id, whole_size;
846         const int data_size  = buf_size - 20;
847         CFrameBuffer *cfrm;
848
849         if (f->version <= 1) {
850             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
851             return AVERROR_INVALIDDATA;
852         }
853
854         id         = AV_RL32(buf + 12);
855         whole_size = AV_RL32(buf + 16);
856
857         if (data_size < 0 || whole_size < 0) {
858             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
859             return AVERROR_INVALIDDATA;
860         }
861
862         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
863             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
864                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
865                        f->cfrm[i].id);
866
867         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
868             if (f->cfrm[i].id == id)
869                 break;
870             if (f->cfrm[i].size == 0)
871                 free_index = i;
872         }
873
874         if (i >= CFRAME_BUFFER_COUNT) {
875             i             = free_index;
876             f->cfrm[i].id = id;
877         }
878         cfrm = &f->cfrm[i];
879
880         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
881             return AVERROR_INVALIDDATA;
882
883         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
884                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
885         // explicit check needed as memcpy below might not catch a NULL
886         if (!cfrm->data) {
887             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
888             return AVERROR(ENOMEM);
889         }
890
891         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
892         cfrm->size += data_size;
893
894         if (cfrm->size >= whole_size) {
895             buf        = cfrm->data;
896             frame_size = cfrm->size;
897
898             if (id != avctx->frame_number)
899                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
900                        id, avctx->frame_number);
901
902             if (f->version <= 1)
903                 return AVERROR_INVALIDDATA;
904
905             cfrm->size = cfrm->id = 0;
906             frame_4cc  = AV_RL32("pfrm");
907         } else
908             return buf_size;
909     } else {
910         buf        = buf      + 12;
911         frame_size = buf_size - 12;
912     }
913
914     FFSWAP(AVFrame*, f->current_picture, f->last_picture);
915
916     // alternatively we would have to use our own buffer management
917     avctx->flags |= CODEC_FLAG_EMU_EDGE;
918
919     if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
920         return ret;
921
922     if (frame_4cc == AV_RL32("ifr2")) {
923         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
924         if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
925             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
926             return ret;
927         }
928     } else if (frame_4cc == AV_RL32("ifrm")) {
929         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
930         if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
931             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
932             return ret;
933         }
934     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
935         f->current_picture->pict_type = AV_PICTURE_TYPE_P;
936         if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
937             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
938             return ret;
939         }
940     } else if (frame_4cc == AV_RL32("snd_")) {
941         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
942                buf_size);
943     } else {
944         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
945                buf_size);
946     }
947
948     f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
949
950     if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
951         return ret;
952     *got_frame = 1;
953
954     emms_c();
955
956     return buf_size;
957 }
958
959 static av_cold int decode_init(AVCodecContext *avctx)
960 {
961     FourXContext * const f = avctx->priv_data;
962
963     if (avctx->extradata_size != 4 || !avctx->extradata) {
964         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
965         return AVERROR_INVALIDDATA;
966     }
967     if((avctx->width % 16) || (avctx->height % 16)) {
968         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
969         return AVERROR_INVALIDDATA;
970     }
971
972     f->version = AV_RL32(avctx->extradata) >> 16;
973     ff_dsputil_init(&f->dsp, avctx);
974     f->avctx = avctx;
975     init_vlcs(f);
976
977     if (f->version > 2)
978         avctx->pix_fmt = AV_PIX_FMT_RGB565;
979     else
980         avctx->pix_fmt = AV_PIX_FMT_BGR555;
981
982     f->current_picture = av_frame_alloc();
983     f->last_picture    = av_frame_alloc();
984     if (!f->current_picture  || !f->last_picture)
985         return AVERROR(ENOMEM);
986
987     return 0;
988 }
989
990
991 static av_cold int decode_end(AVCodecContext *avctx)
992 {
993     FourXContext * const f = avctx->priv_data;
994     int i;
995
996     av_freep(&f->bitstream_buffer);
997     f->bitstream_buffer_size = 0;
998     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
999         av_freep(&f->cfrm[i].data);
1000         f->cfrm[i].allocated_size = 0;
1001     }
1002     ff_free_vlc(&f->pre_vlc);
1003     av_frame_free(&f->current_picture);
1004     av_frame_free(&f->last_picture);
1005
1006     return 0;
1007 }
1008
1009 AVCodec ff_fourxm_decoder = {
1010     .name           = "4xm",
1011     .type           = AVMEDIA_TYPE_VIDEO,
1012     .id             = AV_CODEC_ID_4XM,
1013     .priv_data_size = sizeof(FourXContext),
1014     .init           = decode_init,
1015     .close          = decode_end,
1016     .decode         = decode_frame,
1017     .capabilities   = CODEC_CAP_DR1,
1018     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1019 };