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