4xm, timefilter: K&R formatting cosmetics
[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 "libavutil/intreadwrite.h"
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "dsputil.h"
31 #include "get_bits.h"
32
33 //#undef NDEBUG
34 //#include <assert.h>
35
36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
38
39 #define CFRAME_BUFFER_COUNT 100
40
41 static const uint8_t block_type_tab[2][4][8][2] = {
42     {
43         {    // { 8, 4, 2 } x { 8, 4, 2}
44             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
45         }, { // { 8, 4 } x 1
46             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
47         }, { // 1 x { 8, 4 }
48             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49         }, { // 1 x 2, 2 x 1
50             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
51         }
52     }, {
53         {   // { 8, 4, 2 } x { 8, 4, 2}
54             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
55         }, {// { 8, 4 } x 1
56             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57         }, {// 1 x { 8, 4 }
58             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59         }, {// 1 x 2, 2 x 1
60             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
61       }
62     }
63 };
64
65 static const uint8_t size2index[4][4] = {
66     { -1, 3, 1, 1 },
67     {  3, 0, 0, 0 },
68     {  2, 0, 0, 0 },
69     {  2, 0, 0, 0 },
70 };
71
72 static const int8_t mv[256][2] = {
73     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
74     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
75     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
76     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
77     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
78     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
79     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
80     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
81     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
82     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
83     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
84     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
85     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
86     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
87     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
88     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
89     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
90     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
91     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
92     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
93     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
94     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
95     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
96     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
97     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
98     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
99     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
100     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
101     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
102     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
103     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
104     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
105 };
106
107 /* This is simply the scaled down elementwise product of the standard JPEG
108  * quantizer table and the AAN premul table. */
109 static const uint8_t dequant_table[64] = {
110     16, 15, 13, 19, 24, 31, 28, 17,
111     17, 23, 25, 31, 36, 63, 45, 21,
112     18, 24, 27, 37, 52, 59, 49, 20,
113     16, 28, 34, 40, 60, 80, 51, 20,
114     18, 31, 48, 66, 68, 86, 56, 21,
115     19, 38, 56, 59, 64, 64, 48, 20,
116     27, 48, 55, 55, 56, 51, 35, 15,
117     20, 35, 34, 32, 31, 22, 15,  8,
118 };
119
120 static VLC block_type_vlc[2][4];
121
122
123 typedef struct CFrameBuffer {
124     unsigned int allocated_size;
125     unsigned int size;
126     int id;
127     uint8_t *data;
128 } CFrameBuffer;
129
130 typedef struct FourXContext {
131     AVCodecContext *avctx;
132     DSPContext dsp;
133     AVFrame current_picture, last_picture;
134     GetBitContext pre_gb;          ///< ac/dc prefix
135     GetBitContext gb;
136     GetByteContext g;
137     GetByteContext g2;
138     int mv[256];
139     VLC pre_vlc;
140     int last_dc;
141     DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
142     void *bitstream_buffer;
143     unsigned int bitstream_buffer_size;
144     int version;
145     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
146 } FourXContext;
147
148
149 #define FIX_1_082392200  70936
150 #define FIX_1_414213562  92682
151 #define FIX_1_847759065 121095
152 #define FIX_2_613125930 171254
153
154 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
155
156 static void idct(DCTELEM block[64])
157 {
158     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
159     int tmp10, tmp11, tmp12, tmp13;
160     int z5, z10, z11, z12, z13;
161     int i;
162     int temp[64];
163
164     for (i = 0; i < 8; i++) {
165         tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
166         tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
167
168         tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
169         tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
170
171         tmp0 = tmp10 + tmp13;
172         tmp3 = tmp10 - tmp13;
173         tmp1 = tmp11 + tmp12;
174         tmp2 = tmp11 - tmp12;
175
176         z13 = block[8 * 5 + i] + block[8 * 3 + i];
177         z10 = block[8 * 5 + i] - block[8 * 3 + i];
178         z11 = block[8 * 1 + i] + block[8 * 7 + i];
179         z12 = block[8 * 1 + i] - block[8 * 7 + i];
180
181         tmp7  =          z11 + z13;
182         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
183
184         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
185         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
186         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
187
188         tmp6 = tmp12 - tmp7;
189         tmp5 = tmp11 - tmp6;
190         tmp4 = tmp10 + tmp5;
191
192         temp[8 * 0 + i] = tmp0 + tmp7;
193         temp[8 * 7 + i] = tmp0 - tmp7;
194         temp[8 * 1 + i] = tmp1 + tmp6;
195         temp[8 * 6 + i] = tmp1 - tmp6;
196         temp[8 * 2 + i] = tmp2 + tmp5;
197         temp[8 * 5 + i] = tmp2 - tmp5;
198         temp[8 * 4 + i] = tmp3 + tmp4;
199         temp[8 * 3 + i] = tmp3 - tmp4;
200     }
201
202     for (i = 0; i < 8 * 8; i += 8) {
203         tmp10 = temp[0 + i] + temp[4 + i];
204         tmp11 = temp[0 + i] - temp[4 + i];
205
206         tmp13 = temp[2 + i] + temp[6 + i];
207         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
208
209         tmp0 = tmp10 + tmp13;
210         tmp3 = tmp10 - tmp13;
211         tmp1 = tmp11 + tmp12;
212         tmp2 = tmp11 - tmp12;
213
214         z13 = temp[5 + i] + temp[3 + i];
215         z10 = temp[5 + i] - temp[3 + i];
216         z11 = temp[1 + i] + temp[7 + i];
217         z12 = temp[1 + i] - temp[7 + i];
218
219         tmp7  = z11 + z13;
220         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
221
222         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
223         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
224         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
225
226         tmp6 = tmp12 - tmp7;
227         tmp5 = tmp11 - tmp6;
228         tmp4 = tmp10 + tmp5;
229
230         block[0 + i] = (tmp0 + tmp7) >> 6;
231         block[7 + i] = (tmp0 - tmp7) >> 6;
232         block[1 + i] = (tmp1 + tmp6) >> 6;
233         block[6 + i] = (tmp1 - tmp6) >> 6;
234         block[2 + i] = (tmp2 + tmp5) >> 6;
235         block[5 + i] = (tmp2 - tmp5) >> 6;
236         block[4 + i] = (tmp3 + tmp4) >> 6;
237         block[3 + i] = (tmp3 - tmp4) >> 6;
238     }
239 }
240
241 static av_cold void init_vlcs(FourXContext *f)
242 {
243     static VLC_TYPE table[8][32][2];
244     int i;
245
246     for (i = 0; i < 8; i++) {
247         block_type_vlc[0][i].table           = table[i];
248         block_type_vlc[0][i].table_allocated = 32;
249         init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
250                  &block_type_tab[0][i][0][1], 2, 1,
251                  &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
252     }
253 }
254
255 static void init_mv(FourXContext *f)
256 {
257     int i;
258
259     for (i = 0; i < 256; i++) {
260         if (f->version > 1)
261             f->mv[i] = mv[i][0] + mv[i][1] * f->current_picture.linesize[0] / 2;
262         else
263             f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * f->current_picture.linesize[0] / 2;
264     }
265 }
266
267 #if HAVE_BIGENDIAN
268 #define LE_CENTRIC_MUL(dst, src, scale, dc)             \
269     {                                                   \
270         unsigned tmpval = AV_RN32(src);                 \
271         tmpval = (tmpval << 16) | (tmpval >> 16);       \
272         tmpval = tmpval * (scale) + (dc);               \
273         tmpval = (tmpval << 16) | (tmpval >> 16);       \
274         AV_WN32A(dst, tmpval);                          \
275     }
276 #else
277 #define LE_CENTRIC_MUL(dst, src, scale, dc)              \
278     {                                                    \
279         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
280         AV_WN32A(dst, tmpval);                           \
281     }
282 #endif
283
284 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
285                         int h, int stride, int scale, unsigned dc)
286 {
287     int i;
288     dc *= 0x10001;
289
290     switch (log2w) {
291     case 0:
292         for (i = 0; i < h; i++) {
293             dst[0] = scale * src[0] + dc;
294             if (scale)
295                 src += stride;
296             dst += stride;
297         }
298         break;
299     case 1:
300         for (i = 0; i < h; i++) {
301             LE_CENTRIC_MUL(dst, src, scale, dc);
302             if (scale)
303                 src += stride;
304             dst += stride;
305         }
306         break;
307     case 2:
308         for (i = 0; i < h; i++) {
309             LE_CENTRIC_MUL(dst, src, scale, dc);
310             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
311             if (scale)
312                 src += stride;
313             dst += stride;
314         }
315         break;
316     case 3:
317         for (i = 0; i < h; i++) {
318             LE_CENTRIC_MUL(dst,     src,     scale, dc);
319             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
320             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
321             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
322             if (scale)
323                 src += stride;
324             dst += stride;
325         }
326         break;
327     default:
328         assert(0);
329     }
330 }
331
332 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
333                            int log2w, int log2h, int stride)
334 {
335     const int index = size2index[log2h][log2w];
336     const int h     = 1 << log2h;
337     int code        = get_vlc2(&f->gb,
338                                block_type_vlc[1 - (f->version > 1)][index].table,
339                                BLOCK_TYPE_VLC_BITS, 1);
340     uint16_t *start = (uint16_t *)f->last_picture.data[0];
341     uint16_t *end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
342
343     assert(code >= 0 && code <= 6);
344
345     if (code == 0) {
346         src += f->mv[bytestream2_get_byte(&f->g)];
347         if (start > src || src > end) {
348             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
349             return;
350         }
351         mcdc(dst, src, log2w, h, stride, 1, 0);
352     } else if (code == 1) {
353         log2h--;
354         decode_p_block(f, dst, src, log2w, log2h, stride);
355         decode_p_block(f, dst + (stride << log2h),
356                           src + (stride << log2h), log2w, log2h, stride);
357     } else if (code == 2) {
358         log2w--;
359         decode_p_block(f, dst , src, log2w, log2h, stride);
360         decode_p_block(f, dst + (1 << log2w),
361                           src + (1 << log2w), log2w, log2h, stride);
362     } else if (code == 3 && f->version < 2) {
363         mcdc(dst, src, log2w, h, stride, 1, 0);
364     } else if (code == 4) {
365         src += f->mv[bytestream2_get_byte(&f->g)];
366         if (start > src || src > end) {
367             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
368             return;
369         }
370         mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
371     } else if (code == 5) {
372         mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
373     } else if (code == 6) {
374         if (log2w) {
375             dst[0]      = bytestream2_get_le16(&f->g2);
376             dst[1]      = bytestream2_get_le16(&f->g2);
377         } else {
378             dst[0]      = bytestream2_get_le16(&f->g2);
379             dst[stride] = bytestream2_get_le16(&f->g2);
380         }
381     }
382 }
383
384 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
385 {
386     int x, y;
387     const int width  = f->avctx->width;
388     const int height = f->avctx->height;
389     uint16_t *src    = (uint16_t *)f->last_picture.data[0];
390     uint16_t *dst    = (uint16_t *)f->current_picture.data[0];
391     const int stride =             f->current_picture.linesize[0] >> 1;
392     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
393                  bytestream_offset, wordstream_offset;
394
395     if (f->version > 1) {
396         extra           = 20;
397         bitstream_size  = AV_RL32(buf + 8);
398         wordstream_size = AV_RL32(buf + 12);
399         bytestream_size = AV_RL32(buf + 16);
400     } else {
401         extra           = 0;
402         bitstream_size  = AV_RL16(buf - 4);
403         wordstream_size = AV_RL16(buf - 2);
404         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
405     }
406
407     if (bitstream_size + bytestream_size + wordstream_size + extra != length
408         || bitstream_size  > (1 << 26)
409         || bytestream_size > (1 << 26)
410         || wordstream_size > (1 << 26)) {
411         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
412                bitstream_size, bytestream_size, wordstream_size,
413                bitstream_size + bytestream_size + wordstream_size - length);
414         return -1;
415     }
416
417     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
418                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
419     if (!f->bitstream_buffer)
420         return AVERROR(ENOMEM);
421     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
422                      bitstream_size / 4);
423     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
424            0, FF_INPUT_BUFFER_PADDING_SIZE);
425     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
426
427     wordstream_offset = extra + bitstream_size;
428     bytestream_offset = extra + bitstream_size + wordstream_size;
429     bytestream2_init(&f->g2, buf + wordstream_offset,
430                      length - wordstream_offset);
431     bytestream2_init(&f->g, buf + bytestream_offset,
432                      length - bytestream_offset);
433
434     init_mv(f);
435
436     for (y = 0; y < height; y += 8) {
437         for (x = 0; x < width; x += 8)
438             decode_p_block(f, dst + x, src + x, 3, 3, stride);
439         src += 8 * stride;
440         dst += 8 * stride;
441     }
442
443     return 0;
444 }
445
446 /**
447  * decode block and dequantize.
448  * Note this is almost identical to MJPEG.
449  */
450 static int decode_i_block(FourXContext *f, DCTELEM *block)
451 {
452     int code, i, j, level, val;
453
454     /* DC coef */
455     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
456     if (val >> 4)
457         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
458
459     if (val)
460         val = get_xbits(&f->gb, val);
461
462     val        = val * dequant_table[0] + f->last_dc;
463     f->last_dc = block[0] = val;
464     /* AC coefs */
465     i = 1;
466     for (;;) {
467         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
468
469         /* EOB */
470         if (code == 0)
471             break;
472         if (code == 0xf0) {
473             i += 16;
474         } else {
475             level = get_xbits(&f->gb, code & 0xf);
476             i    += code >> 4;
477             if (i >= 64) {
478                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
479                 return 0;
480             }
481
482             j = ff_zigzag_direct[i];
483             block[j] = level * dequant_table[j];
484             i++;
485             if (i >= 64)
486                 break;
487         }
488     }
489
490     return 0;
491 }
492
493 static inline void idct_put(FourXContext *f, int x, int y)
494 {
495     DCTELEM (*block)[64] = f->block;
496     int stride           = f->current_picture.linesize[0] >> 1;
497     int i;
498     uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
499
500     for (i = 0; i < 4; i++) {
501         block[i][0] += 0x80 * 8 * 8;
502         idct(block[i]);
503     }
504
505     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
506         for (i = 4; i < 6; i++)
507             idct(block[i]);
508     }
509
510     /* Note transform is:
511      * y  = ( 1b + 4g + 2r) / 14
512      * cb = ( 3b - 2g - 1r) / 14
513      * cr = (-1b - 4g + 5r) / 14 */
514     for (y = 0; y < 8; y++) {
515         for (x = 0; x < 8; x++) {
516             DCTELEM *temp = block[(x >> 2) + 2 * (y >> 2)] +
517                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
518             int cb = block[4][x + 8 * y];
519             int cr = block[5][x + 8 * y];
520             int cg = (cb + cr) >> 1;
521             int y;
522
523             cb += cb;
524
525             y               = temp[0];
526             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
527             y               = temp[1];
528             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
529             y               = temp[8];
530             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
531             y               = temp[9];
532             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
533             dst            += 2;
534         }
535         dst += 2 * stride - 2 * 8;
536     }
537 }
538
539 static int decode_i_mb(FourXContext *f)
540 {
541     int i;
542
543     f->dsp.clear_blocks(f->block[0]);
544
545     for (i = 0; i < 6; i++)
546         if (decode_i_block(f, f->block[i]) < 0)
547             return -1;
548
549     return 0;
550 }
551
552 static const uint8_t *read_huffman_tables(FourXContext *f,
553                                           const uint8_t * const buf)
554 {
555     int frequency[512];
556     uint8_t flag[512];
557     int up[512];
558     uint8_t len_tab[257];
559     int bits_tab[257];
560     int start, end;
561     const uint8_t *ptr = buf;
562     int j;
563
564     memset(frequency, 0, sizeof(frequency));
565     memset(up, -1, sizeof(up));
566
567     start = *ptr++;
568     end   = *ptr++;
569     for (;;) {
570         int i;
571
572         for (i = start; i <= end; i++)
573             frequency[i] = *ptr++;
574         start = *ptr++;
575         if (start == 0)
576             break;
577
578         end = *ptr++;
579     }
580     frequency[256] = 1;
581
582     while ((ptr - buf) & 3)
583         ptr++; // 4byte align
584
585     for (j = 257; j < 512; j++) {
586         int min_freq[2] = { 256 * 256, 256 * 256 };
587         int smallest[2] = { 0, 0 };
588         int i;
589         for (i = 0; i < j; i++) {
590             if (frequency[i] == 0)
591                 continue;
592             if (frequency[i] < min_freq[1]) {
593                 if (frequency[i] < min_freq[0]) {
594                     min_freq[1] = min_freq[0];
595                     smallest[1] = smallest[0];
596                     min_freq[0] = frequency[i];
597                     smallest[0] = i;
598                 } else {
599                     min_freq[1] = frequency[i];
600                     smallest[1] = i;
601                 }
602             }
603         }
604         if (min_freq[1] == 256 * 256)
605             break;
606
607         frequency[j]           = min_freq[0] + min_freq[1];
608         flag[smallest[0]]      = 0;
609         flag[smallest[1]]      = 1;
610         up[smallest[0]]        =
611         up[smallest[1]]        = j;
612         frequency[smallest[0]] = frequency[smallest[1]] = 0;
613     }
614
615     for (j = 0; j < 257; j++) {
616         int node, len = 0, bits = 0;
617
618         for (node = j; up[node] != -1; node = up[node]) {
619             bits += flag[node] << len;
620             len++;
621             if (len > 31)
622                 // can this happen at all ?
623                 av_log(f->avctx, AV_LOG_ERROR,
624                        "vlc length overflow\n");
625         }
626
627         bits_tab[j] = bits;
628         len_tab[j]  = len;
629     }
630
631     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
632                  bits_tab, 4, 4, 0))
633         return NULL;
634
635     return ptr;
636 }
637
638 static int mix(int c0, int c1)
639 {
640     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
641     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
642     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
643     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
644 }
645
646 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
647 {
648     int x, y, x2, y2;
649     const int width  = f->avctx->width;
650     const int height = f->avctx->height;
651     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
652     uint16_t *dst    = (uint16_t*)f->current_picture.data[0];
653     const int stride =            f->current_picture.linesize[0]>>1;
654     GetByteContext g3;
655
656     if (length < mbs * 8) {
657         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
658         return AVERROR_INVALIDDATA;
659     }
660     bytestream2_init(&g3, buf, length);
661
662     for (y = 0; y < height; y += 16) {
663         for (x = 0; x < width; x += 16) {
664             unsigned int color[4], bits;
665             memset(color, 0, sizeof(color));
666             // warning following is purely guessed ...
667             color[0] = bytestream2_get_le16u(&g3);
668             color[1] = bytestream2_get_le16u(&g3);
669
670             if (color[0] & 0x8000)
671                 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
672             if (color[1] & 0x8000)
673                 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
674
675             color[2] = mix(color[0], color[1]);
676             color[3] = mix(color[1], color[0]);
677
678             bits = bytestream2_get_le32u(&g3);
679             for (y2 = 0; y2 < 16; y2++) {
680                 for (x2 = 0; x2 < 16; x2++) {
681                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
682                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
683                 }
684             }
685             dst += 16;
686         }
687         dst += 16 * stride - x;
688     }
689
690     return 0;
691 }
692
693 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
694 {
695     int x, y;
696     const int width  = f->avctx->width;
697     const int height = f->avctx->height;
698     const unsigned int bitstream_size = AV_RL32(buf);
699     int token_count av_unused;
700     unsigned int prestream_size;
701     const uint8_t *prestream;
702
703     if (length < bitstream_size + 12) {
704         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
705         return AVERROR_INVALIDDATA;
706     }
707
708     token_count    =     AV_RL32(buf + bitstream_size + 8);
709     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
710     prestream      =             buf + bitstream_size + 12;
711
712     if (prestream_size + bitstream_size + 12 != length
713         || bitstream_size > (1 << 26)
714         || prestream_size > (1 << 26)) {
715         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
716                prestream_size, bitstream_size, length);
717         return -1;
718     }
719
720     prestream = read_huffman_tables(f, prestream);
721
722     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
723
724     prestream_size = length + buf - prestream;
725
726     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
727                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
728     if (!f->bitstream_buffer)
729         return AVERROR(ENOMEM);
730     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
731                      prestream_size / 4);
732     memset((uint8_t*)f->bitstream_buffer + prestream_size,
733            0, FF_INPUT_BUFFER_PADDING_SIZE);
734     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
735
736     f->last_dc = 0 * 128 * 8 * 8;
737
738     for (y = 0; y < height; y += 16) {
739         for (x = 0; x < width; x += 16) {
740             if (decode_i_mb(f) < 0)
741                 return -1;
742
743             idct_put(f, x, y);
744         }
745     }
746
747     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
748         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
749
750     return 0;
751 }
752
753 static int decode_frame(AVCodecContext *avctx, void *data,
754                         int *data_size, AVPacket *avpkt)
755 {
756     const uint8_t *buf    = avpkt->data;
757     int buf_size          = avpkt->size;
758     FourXContext *const f = avctx->priv_data;
759     AVFrame *picture      = data;
760     AVFrame *p, temp;
761     int i, frame_4cc, frame_size;
762
763     frame_4cc = AV_RL32(buf);
764     if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
765         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
766                buf_size, AV_RL32(buf + 4));
767
768     if (frame_4cc == AV_RL32("cfrm")) {
769         int free_index       = -1;
770         const int data_size  = buf_size - 20;
771         const int id         = AV_RL32(buf + 12);
772         const int whole_size = AV_RL32(buf + 16);
773         CFrameBuffer *cfrm;
774
775         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
776             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
777                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
778                        f->cfrm[i].id);
779
780         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
781             if (f->cfrm[i].id == id)
782                 break;
783             if (f->cfrm[i].size == 0)
784                 free_index = i;
785         }
786
787         if (i >= CFRAME_BUFFER_COUNT) {
788             i             = free_index;
789             f->cfrm[i].id = id;
790         }
791         cfrm = &f->cfrm[i];
792
793         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
794                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
795         // explicit check needed as memcpy below might not catch a NULL
796         if (!cfrm->data) {
797             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
798             return -1;
799         }
800
801         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
802         cfrm->size += data_size;
803
804         if (cfrm->size >= whole_size) {
805             buf        = cfrm->data;
806             frame_size = cfrm->size;
807
808             if (id != avctx->frame_number)
809                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
810                        id, avctx->frame_number);
811
812             cfrm->size = cfrm->id = 0;
813             frame_4cc  = AV_RL32("pfrm");
814         } else
815             return buf_size;
816     } else {
817         buf        = buf      + 12;
818         frame_size = buf_size - 12;
819     }
820
821     temp               = f->current_picture;
822     f->current_picture = f->last_picture;
823     f->last_picture    = temp;
824
825     p                  = &f->current_picture;
826     avctx->coded_frame = p;
827
828     // alternatively we would have to use our own buffer management
829     avctx->flags |= CODEC_FLAG_EMU_EDGE;
830
831     if (p->data[0])
832         avctx->release_buffer(avctx, p);
833
834     p->reference = 1;
835     if (avctx->get_buffer(avctx, p) < 0) {
836         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
837         return -1;
838     }
839
840     if (frame_4cc == AV_RL32("ifr2")) {
841         p->pict_type = AV_PICTURE_TYPE_I;
842         if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0)
843             return -1;
844     } else if (frame_4cc == AV_RL32("ifrm")) {
845         p->pict_type = AV_PICTURE_TYPE_I;
846         if (decode_i_frame(f, buf, frame_size) < 0)
847             return -1;
848     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
849         if (!f->last_picture.data[0]) {
850             f->last_picture.reference = 1;
851             if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
852                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
853                 return -1;
854             }
855         }
856
857         p->pict_type = AV_PICTURE_TYPE_P;
858         if (decode_p_frame(f, buf, frame_size) < 0)
859             return -1;
860     } else if (frame_4cc == AV_RL32("snd_")) {
861         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
862                buf_size);
863     } else {
864         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
865                buf_size);
866     }
867
868     p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
869
870     *picture   = *p;
871     *data_size = sizeof(AVPicture);
872
873     emms_c();
874
875     return buf_size;
876 }
877
878
879 static av_cold void common_init(AVCodecContext *avctx)
880 {
881     FourXContext * const f = avctx->priv_data;
882
883     dsputil_init(&f->dsp, avctx);
884
885     f->avctx = avctx;
886 }
887
888 static av_cold int decode_init(AVCodecContext *avctx)
889 {
890     FourXContext * const f = avctx->priv_data;
891
892     if (avctx->extradata_size != 4 || !avctx->extradata) {
893         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
894         return 1;
895     }
896
897     f->version = AV_RL32(avctx->extradata) >> 16;
898     common_init(avctx);
899     init_vlcs(f);
900
901     if (f->version > 2)
902         avctx->pix_fmt = PIX_FMT_RGB565;
903     else
904         avctx->pix_fmt = PIX_FMT_BGR555;
905
906     return 0;
907 }
908
909
910 static av_cold int decode_end(AVCodecContext *avctx)
911 {
912     FourXContext * const f = avctx->priv_data;
913     int i;
914
915     av_freep(&f->bitstream_buffer);
916     f->bitstream_buffer_size = 0;
917     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
918         av_freep(&f->cfrm[i].data);
919         f->cfrm[i].allocated_size = 0;
920     }
921     free_vlc(&f->pre_vlc);
922     if (f->current_picture.data[0])
923         avctx->release_buffer(avctx, &f->current_picture);
924     if (f->last_picture.data[0])
925         avctx->release_buffer(avctx, &f->last_picture);
926
927     return 0;
928 }
929
930 AVCodec ff_fourxm_decoder = {
931     .name           = "4xm",
932     .type           = AVMEDIA_TYPE_VIDEO,
933     .id             = CODEC_ID_4XM,
934     .priv_data_size = sizeof(FourXContext),
935     .init           = decode_init,
936     .close          = decode_end,
937     .decode         = decode_frame,
938     .capabilities   = CODEC_CAP_DR1,
939     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
940 };