aic: Fix slice size computation for widths multiples of 32 macroblocks
[ffmpeg.git] / libavcodec / 4xm.c
1 /*
2  * 4XM codec
3  * Copyright (c) 2003 Michael Niedermayer
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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/frame.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/intreadwrite.h"
32 #include "avcodec.h"
33 #include "blockdsp.h"
34 #include "bswapdsp.h"
35 #include "bytestream.h"
36 #include "get_bits.h"
37 #include "internal.h"
38
39 #define BLOCK_TYPE_VLC_BITS 5
40 #define ACDC_VLC_BITS 9
41
42 #define CFRAME_BUFFER_COUNT 100
43
44 static const uint8_t block_type_tab[2][4][8][2] = {
45     {
46         {    // { 8, 4, 2 } x { 8, 4, 2}
47             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
48         }, { // { 8, 4 } x 1
49             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50         }, { // 1 x { 8, 4 }
51             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52         }, { // 1 x 2, 2 x 1
53             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
54         }
55     }, {
56         {   // { 8, 4, 2 } x { 8, 4, 2}
57             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58         }, {// { 8, 4 } x 1
59             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60         }, {// 1 x { 8, 4 }
61             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62         }, {// 1 x 2, 2 x 1
63             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
64       }
65     }
66 };
67
68 static const uint8_t size2index[4][4] = {
69     { -1, 3, 1, 1 },
70     {  3, 0, 0, 0 },
71     {  2, 0, 0, 0 },
72     {  2, 0, 0, 0 },
73 };
74
75 static const int8_t mv[256][2] = {
76     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
77     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
78     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
79     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
80     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
81     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
82     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
83     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
84     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
85     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
86     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
87     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
88     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
89     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
90     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
91     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
92     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
93     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
94     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
95     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
96     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
97     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
98     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
99     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
100     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
101     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
102     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
103     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
104     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
105     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
106     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
107     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
108 };
109
110 /* This is simply the scaled down elementwise product of the standard JPEG
111  * quantizer table and the AAN premul table. */
112 static const uint8_t dequant_table[64] = {
113     16, 15, 13, 19, 24, 31, 28, 17,
114     17, 23, 25, 31, 36, 63, 45, 21,
115     18, 24, 27, 37, 52, 59, 49, 20,
116     16, 28, 34, 40, 60, 80, 51, 20,
117     18, 31, 48, 66, 68, 86, 56, 21,
118     19, 38, 56, 59, 64, 64, 48, 20,
119     27, 48, 55, 55, 56, 51, 35, 15,
120     20, 35, 34, 32, 31, 22, 15,  8,
121 };
122
123 static VLC block_type_vlc[2][4];
124
125
126 typedef struct CFrameBuffer {
127     unsigned int allocated_size;
128     unsigned int size;
129     int id;
130     uint8_t *data;
131 } CFrameBuffer;
132
133 typedef struct FourXContext {
134     AVCodecContext *avctx;
135     BlockDSPContext bdsp;
136     BswapDSPContext bbdsp;
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, 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         break;
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     int index, h, code, ret, scale = 1;
344     uint16_t *start, *end;
345     unsigned dc = 0;
346
347     if (log2h < 0 || log2w < 0)
348         return AVERROR_INVALIDDATA;
349
350     index = size2index[log2h][log2w];
351     if (index < 0)
352         return AVERROR_INVALIDDATA;
353
354     h     = 1 << log2h;
355     code  = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
356                      BLOCK_TYPE_VLC_BITS, 1);
357     if (code < 0 || code > 6)
358         return AVERROR_INVALIDDATA;
359
360     start = f->last_frame_buffer;
361     end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
362
363     if (code == 1) {
364         if (--log2h < 0)
365             return AVERROR_INVALIDDATA;
366         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
367             return ret;
368         return decode_p_block(f, dst + (stride << log2h),
369                               src + (stride << log2h),
370                               log2w, log2h, stride);
371     } else if (code == 2) {
372         log2w--;
373         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
374             return ret;
375         return decode_p_block(f, dst + (1 << log2w),
376                               src + (1 << log2w),
377                               log2w, log2h, stride);
378     } else if (code == 6) {
379         if (log2w) {
380             dst[0]      = bytestream2_get_le16(&f->g2);
381             dst[1]      = bytestream2_get_le16(&f->g2);
382         } else {
383             dst[0]      = bytestream2_get_le16(&f->g2);
384             dst[stride] = bytestream2_get_le16(&f->g2);
385         }
386         return 0;
387     }
388
389     if (code == 0) {
390         src  += f->mv[bytestream2_get_byte(&f->g)];
391     } else if (code == 3 && f->version >= 2) {
392         return 0;
393     } else if (code == 4) {
394         src  += f->mv[bytestream2_get_byte(&f->g)];
395         dc    = bytestream2_get_le16(&f->g2);
396     } else if (code == 5) {
397         scale = 0;
398         dc    = bytestream2_get_le16(&f->g2);
399     }
400
401     if (start > src || src > end) {
402         av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
403         return AVERROR_INVALIDDATA;
404     }
405
406     mcdc(dst, src, log2w, h, stride, scale, dc);
407
408     return 0;
409 }
410
411 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
412 {
413     int x, y;
414     const int width  = f->avctx->width;
415     const int height = f->avctx->height;
416     uint16_t *dst    = f->frame_buffer;
417     uint16_t *src;
418     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
419                  bytestream_offset, wordstream_offset;
420     int ret;
421
422     src = f->last_frame_buffer;
423
424     if (f->version > 1) {
425         if (length < 20)
426             return AVERROR_INVALIDDATA;
427         extra           = 20;
428         bitstream_size  = AV_RL32(buf + 8);
429         wordstream_size = AV_RL32(buf + 12);
430         bytestream_size = AV_RL32(buf + 16);
431     } else {
432         extra           = 0;
433         bitstream_size  = AV_RL16(buf - 4);
434         wordstream_size = AV_RL16(buf - 2);
435         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
436     }
437
438     if (bitstream_size + bytestream_size + wordstream_size + extra != length
439         || bitstream_size  > (1 << 26)
440         || bytestream_size > (1 << 26)
441         || wordstream_size > (1 << 26)) {
442         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
443                bitstream_size, bytestream_size, wordstream_size,
444                bitstream_size + bytestream_size + wordstream_size - length);
445         return AVERROR_INVALIDDATA;
446     }
447
448     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
449                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
450     if (!f->bitstream_buffer)
451         return AVERROR(ENOMEM);
452     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
453                        bitstream_size / 4);
454     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
455            0, FF_INPUT_BUFFER_PADDING_SIZE);
456     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
457
458     wordstream_offset = extra + bitstream_size;
459     bytestream_offset = extra + bitstream_size + wordstream_size;
460     bytestream2_init(&f->g2, buf + wordstream_offset,
461                      length - wordstream_offset);
462     bytestream2_init(&f->g, buf + bytestream_offset,
463                      length - bytestream_offset);
464
465     init_mv(f, width * 2);
466
467     for (y = 0; y < height; y += 8) {
468         for (x = 0; x < width; x += 8)
469             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
470                 return ret;
471         src += 8 * width;
472         dst += 8 * width;
473     }
474
475     return 0;
476 }
477
478 /**
479  * decode block and dequantize.
480  * Note this is almost identical to MJPEG.
481  */
482 static int decode_i_block(FourXContext *f, int16_t *block)
483 {
484     int code, i, j, level, val;
485
486     /* DC coef */
487     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
488     if (val >> 4)
489         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
490
491     if (val)
492         val = get_xbits(&f->gb, val);
493
494     val        = val * dequant_table[0] + f->last_dc;
495     f->last_dc = block[0] = val;
496     /* AC coefs */
497     i = 1;
498     for (;;) {
499         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
500
501         /* EOB */
502         if (code == 0)
503             break;
504         if (code == 0xf0) {
505             i += 16;
506         } else {
507             level = get_xbits(&f->gb, code & 0xf);
508             i    += code >> 4;
509             if (i >= 64) {
510                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
511                 return 0;
512             }
513
514             j = ff_zigzag_direct[i];
515             block[j] = level * dequant_table[j];
516             i++;
517             if (i >= 64)
518                 break;
519         }
520     }
521
522     return 0;
523 }
524
525 static inline void idct_put(FourXContext *f, int x, int y)
526 {
527     int16_t (*block)[64] = f->block;
528     int stride           = f->avctx->width;
529     int i;
530     uint16_t *dst = f->frame_buffer + y * stride + x;
531
532     for (i = 0; i < 4; i++) {
533         block[i][0] += 0x80 * 8 * 8;
534         idct(block[i]);
535     }
536
537     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
538         for (i = 4; i < 6; i++)
539             idct(block[i]);
540     }
541
542     /* Note transform is:
543      * y  = ( 1b + 4g + 2r) / 14
544      * cb = ( 3b - 2g - 1r) / 14
545      * cr = (-1b - 4g + 5r) / 14 */
546     for (y = 0; y < 8; y++) {
547         for (x = 0; x < 8; x++) {
548             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
549                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
550             int cb = block[4][x + 8 * y];
551             int cr = block[5][x + 8 * y];
552             int cg = (cb + cr) >> 1;
553             int y;
554
555             cb += cb;
556
557             y               = temp[0];
558             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
559             y               = temp[1];
560             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
561             y               = temp[8];
562             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
563             y               = temp[9];
564             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
565             dst            += 2;
566         }
567         dst += 2 * stride - 2 * 8;
568     }
569 }
570
571 static int decode_i_mb(FourXContext *f)
572 {
573     int ret;
574     int i;
575
576     f->bdsp.clear_blocks(f->block[0]);
577
578     for (i = 0; i < 6; i++)
579         if ((ret = decode_i_block(f, f->block[i])) < 0)
580             return ret;
581
582     return 0;
583 }
584
585 static const uint8_t *read_huffman_tables(FourXContext *f,
586                                           const uint8_t * const buf,
587                                           int len)
588 {
589     int frequency[512] = { 0 };
590     uint8_t flag[512];
591     int up[512];
592     uint8_t len_tab[257];
593     int bits_tab[257];
594     int start, end;
595     const uint8_t *ptr = buf;
596     int j;
597
598     memset(up, -1, sizeof(up));
599
600     start = *ptr++;
601     end   = *ptr++;
602     for (;;) {
603         int i;
604
605         len -= end - start + 1;
606
607         if (end < start || len < 0)
608             return NULL;
609
610         for (i = start; i <= end; i++)
611             frequency[i] = *ptr++;
612         start = *ptr++;
613         if (start == 0)
614             break;
615
616         if (--len < 0)
617             return NULL;
618
619         end = *ptr++;
620     }
621     frequency[256] = 1;
622
623     while ((ptr - buf) & 3)
624         ptr++; // 4byte align
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, 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    = f->frame_buffer;
694     GetByteContext g3;
695
696     if (length < mbs * 8) {
697         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
698         return AVERROR_INVALIDDATA;
699     }
700     bytestream2_init(&g3, buf, length);
701
702     for (y = 0; y < height; y += 16) {
703         for (x = 0; x < width; x += 16) {
704             unsigned int color[4] = { 0 }, bits;
705             // warning following is purely guessed ...
706             color[0] = bytestream2_get_le16u(&g3);
707             color[1] = bytestream2_get_le16u(&g3);
708
709             if (color[0] & 0x8000)
710                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
711             if (color[1] & 0x8000)
712                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
713
714             color[2] = mix(color[0], color[1]);
715             color[3] = mix(color[1], color[0]);
716
717             bits = bytestream2_get_le32u(&g3);
718             for (y2 = 0; y2 < 16; y2++) {
719                 for (x2 = 0; x2 < 16; x2++) {
720                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
721                     dst[y2 * width + x2] = color[(bits >> index) & 3];
722                 }
723             }
724             dst += 16;
725         }
726         dst += 16 * width - x;
727     }
728
729     return 0;
730 }
731
732 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
733 {
734     int x, y, ret;
735     const int width  = f->avctx->width;
736     const int height = f->avctx->height;
737     const unsigned int bitstream_size = AV_RL32(buf);
738     int token_count av_unused;
739     unsigned int prestream_size;
740     const uint8_t *prestream;
741
742     if (bitstream_size > (1 << 26))
743         return AVERROR_INVALIDDATA;
744
745     if (length < bitstream_size + 12) {
746         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
747         return AVERROR_INVALIDDATA;
748     }
749
750     token_count    =     AV_RL32(buf + bitstream_size + 8);
751     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
752     prestream      =             buf + bitstream_size + 12;
753
754     if (prestream_size + bitstream_size + 12 != length
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, prestream_size);
762     if (!prestream) {
763         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
764         return AVERROR_INVALIDDATA;
765     }
766
767     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
768
769     prestream_size = length + buf - prestream;
770
771     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
772                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
773     if (!f->bitstream_buffer)
774         return AVERROR(ENOMEM);
775     f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
776                        prestream_size / 4);
777     memset((uint8_t*)f->bitstream_buffer + prestream_size,
778            0, FF_INPUT_BUFFER_PADDING_SIZE);
779     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
780
781     f->last_dc = 0 * 128 * 8 * 8;
782
783     for (y = 0; y < height; y += 16) {
784         for (x = 0; x < width; x += 16) {
785             if ((ret = decode_i_mb(f)) < 0)
786                 return ret;
787
788             idct_put(f, x, y);
789         }
790     }
791
792     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
793         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
794
795     return 0;
796 }
797
798 static int decode_frame(AVCodecContext *avctx, void *data,
799                         int *got_frame, AVPacket *avpkt)
800 {
801     const uint8_t *buf    = avpkt->data;
802     int buf_size          = avpkt->size;
803     FourXContext *const f = avctx->priv_data;
804     AVFrame *picture      = data;
805     int i, frame_4cc, frame_size, ret;
806
807     if (buf_size < 20)
808         return AVERROR_INVALIDDATA;
809
810     if (avctx->width % 16 || avctx->height % 16) {
811         av_log(avctx, AV_LOG_ERROR,
812                "Dimensions non-multiple of 16 are invalid.\n");
813         return AVERROR_INVALIDDATA;
814     }
815
816     if (buf_size < AV_RL32(buf + 4) + 8) {
817         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
818                buf_size, AV_RL32(buf + 4));
819         return AVERROR_INVALIDDATA;
820     }
821
822     frame_4cc = AV_RL32(buf);
823
824     if (frame_4cc == AV_RL32("cfrm")) {
825         int free_index       = -1;
826         int id, whole_size;
827         const int data_size  = buf_size - 20;
828         CFrameBuffer *cfrm;
829
830         id         = AV_RL32(buf + 12);
831         whole_size = AV_RL32(buf + 16);
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         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
852                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
853         // explicit check needed as memcpy below might not catch a NULL
854         if (!cfrm->data) {
855             av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
856             return AVERROR(ENOMEM);
857         }
858
859         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
860         cfrm->size += data_size;
861
862         if (cfrm->size >= whole_size) {
863             buf        = cfrm->data;
864             frame_size = cfrm->size;
865
866             if (id != avctx->frame_number)
867                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
868                        id, avctx->frame_number);
869
870             if (f->version <= 1)
871                 return AVERROR_INVALIDDATA;
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
883     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) {
884         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
885         return ret;
886     }
887
888     if (frame_4cc == AV_RL32("ifr2")) {
889         picture->pict_type = AV_PICTURE_TYPE_I;
890         if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0)
891             return ret;
892     } else if (frame_4cc == AV_RL32("ifrm")) {
893         picture->pict_type = AV_PICTURE_TYPE_I;
894         if ((ret = decode_i_frame(f, buf, frame_size)) < 0)
895             return ret;
896     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
897         picture->pict_type = AV_PICTURE_TYPE_P;
898         if ((ret = decode_p_frame(f, buf, frame_size)) < 0)
899             return ret;
900     } else if (frame_4cc == AV_RL32("snd_")) {
901         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
902                buf_size);
903     } else {
904         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
905                buf_size);
906     }
907
908     picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
909
910     av_image_copy_plane(picture->data[0], picture->linesize[0],
911                         (const uint8_t*)f->frame_buffer,  avctx->width * 2,
912                         avctx->width * 2, avctx->height);
913     FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
914
915     *got_frame = 1;
916
917     emms_c();
918
919     return buf_size;
920 }
921
922 static av_cold int decode_end(AVCodecContext *avctx)
923 {
924     FourXContext * const f = avctx->priv_data;
925     int i;
926
927     av_freep(&f->frame_buffer);
928     av_freep(&f->last_frame_buffer);
929     av_freep(&f->bitstream_buffer);
930     f->bitstream_buffer_size = 0;
931     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
932         av_freep(&f->cfrm[i].data);
933         f->cfrm[i].allocated_size = 0;
934     }
935     ff_free_vlc(&f->pre_vlc);
936
937     return 0;
938 }
939
940 static av_cold int decode_init(AVCodecContext *avctx)
941 {
942     FourXContext * const f = avctx->priv_data;
943     int ret;
944
945     if (avctx->extradata_size != 4 || !avctx->extradata) {
946         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
947         return AVERROR_INVALIDDATA;
948     }
949
950     ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
951     if (ret < 0)
952         return ret;
953
954     f->frame_buffer      = av_mallocz(avctx->width * avctx->height * 2);
955     f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
956     if (!f->frame_buffer || !f->last_frame_buffer) {
957         decode_end(avctx);
958         return AVERROR(ENOMEM);
959     }
960
961     f->version = AV_RL32(avctx->extradata) >> 16;
962     ff_blockdsp_init(&f->bdsp, avctx);
963     ff_bswapdsp_init(&f->bbdsp);
964     f->avctx = avctx;
965     init_vlcs(f);
966
967     if (f->version > 2)
968         avctx->pix_fmt = AV_PIX_FMT_RGB565;
969     else
970         avctx->pix_fmt = AV_PIX_FMT_BGR555;
971
972     return 0;
973 }
974
975 AVCodec ff_fourxm_decoder = {
976     .name           = "4xm",
977     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
978     .type           = AVMEDIA_TYPE_VIDEO,
979     .id             = AV_CODEC_ID_4XM,
980     .priv_data_size = sizeof(FourXContext),
981     .init           = decode_init,
982     .close          = decode_end,
983     .decode         = decode_frame,
984     .capabilities   = CODEC_CAP_DR1,
985 };