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