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