Replace memset(0) by zero initializations.
[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] = { 0 };
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(up, -1, sizeof(up));
565
566     start = *ptr++;
567     end   = *ptr++;
568     for (;;) {
569         int i;
570
571         for (i = start; i <= end; i++)
572             frequency[i] = *ptr++;
573         start = *ptr++;
574         if (start == 0)
575             break;
576
577         end = *ptr++;
578     }
579     frequency[256] = 1;
580
581     while ((ptr - buf) & 3)
582         ptr++; // 4byte align
583
584     for (j = 257; j < 512; j++) {
585         int min_freq[2] = { 256 * 256, 256 * 256 };
586         int smallest[2] = { 0, 0 };
587         int i;
588         for (i = 0; i < j; i++) {
589             if (frequency[i] == 0)
590                 continue;
591             if (frequency[i] < min_freq[1]) {
592                 if (frequency[i] < min_freq[0]) {
593                     min_freq[1] = min_freq[0];
594                     smallest[1] = smallest[0];
595                     min_freq[0] = frequency[i];
596                     smallest[0] = i;
597                 } else {
598                     min_freq[1] = frequency[i];
599                     smallest[1] = i;
600                 }
601             }
602         }
603         if (min_freq[1] == 256 * 256)
604             break;
605
606         frequency[j]           = min_freq[0] + min_freq[1];
607         flag[smallest[0]]      = 0;
608         flag[smallest[1]]      = 1;
609         up[smallest[0]]        =
610         up[smallest[1]]        = j;
611         frequency[smallest[0]] = frequency[smallest[1]] = 0;
612     }
613
614     for (j = 0; j < 257; j++) {
615         int node, len = 0, bits = 0;
616
617         for (node = j; up[node] != -1; node = up[node]) {
618             bits += flag[node] << len;
619             len++;
620             if (len > 31)
621                 // can this happen at all ?
622                 av_log(f->avctx, AV_LOG_ERROR,
623                        "vlc length overflow\n");
624         }
625
626         bits_tab[j] = bits;
627         len_tab[j]  = len;
628     }
629
630     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
631                  bits_tab, 4, 4, 0))
632         return NULL;
633
634     return ptr;
635 }
636
637 static int mix(int c0, int c1)
638 {
639     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
640     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
641     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
642     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
643 }
644
645 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
646 {
647     int x, y, x2, y2;
648     const int width  = f->avctx->width;
649     const int height = f->avctx->height;
650     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
651     uint16_t *dst    = (uint16_t*)f->current_picture.data[0];
652     const int stride =            f->current_picture.linesize[0]>>1;
653     GetByteContext g3;
654
655     if (length < mbs * 8) {
656         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
657         return AVERROR_INVALIDDATA;
658     }
659     bytestream2_init(&g3, buf, length);
660
661     for (y = 0; y < height; y += 16) {
662         for (x = 0; x < width; x += 16) {
663             unsigned int color[4] = { 0 }, bits;
664             // warning following is purely guessed ...
665             color[0] = bytestream2_get_le16u(&g3);
666             color[1] = bytestream2_get_le16u(&g3);
667
668             if (color[0] & 0x8000)
669                 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
670             if (color[1] & 0x8000)
671                 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
672
673             color[2] = mix(color[0], color[1]);
674             color[3] = mix(color[1], color[0]);
675
676             bits = bytestream2_get_le32u(&g3);
677             for (y2 = 0; y2 < 16; y2++) {
678                 for (x2 = 0; x2 < 16; x2++) {
679                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
680                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
681                 }
682             }
683             dst += 16;
684         }
685         dst += 16 * stride - x;
686     }
687
688     return 0;
689 }
690
691 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
692 {
693     int x, y;
694     const int width  = f->avctx->width;
695     const int height = f->avctx->height;
696     const unsigned int bitstream_size = AV_RL32(buf);
697     int token_count av_unused;
698     unsigned int prestream_size;
699     const uint8_t *prestream;
700
701     if (length < bitstream_size + 12) {
702         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
703         return AVERROR_INVALIDDATA;
704     }
705
706     token_count    =     AV_RL32(buf + bitstream_size + 8);
707     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
708     prestream      =             buf + bitstream_size + 12;
709
710     if (prestream_size + bitstream_size + 12 != length
711         || bitstream_size > (1 << 26)
712         || prestream_size > (1 << 26)) {
713         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
714                prestream_size, bitstream_size, length);
715         return -1;
716     }
717
718     prestream = read_huffman_tables(f, prestream);
719
720     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
721
722     prestream_size = length + buf - prestream;
723
724     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
725                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
726     if (!f->bitstream_buffer)
727         return AVERROR(ENOMEM);
728     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
729                      prestream_size / 4);
730     memset((uint8_t*)f->bitstream_buffer + prestream_size,
731            0, FF_INPUT_BUFFER_PADDING_SIZE);
732     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
733
734     f->last_dc = 0 * 128 * 8 * 8;
735
736     for (y = 0; y < height; y += 16) {
737         for (x = 0; x < width; x += 16) {
738             if (decode_i_mb(f) < 0)
739                 return -1;
740
741             idct_put(f, x, y);
742         }
743     }
744
745     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
746         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
747
748     return 0;
749 }
750
751 static int decode_frame(AVCodecContext *avctx, void *data,
752                         int *data_size, AVPacket *avpkt)
753 {
754     const uint8_t *buf    = avpkt->data;
755     int buf_size          = avpkt->size;
756     FourXContext *const f = avctx->priv_data;
757     AVFrame *picture      = data;
758     AVFrame *p, temp;
759     int i, frame_4cc, frame_size;
760
761     frame_4cc = AV_RL32(buf);
762     if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
763         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
764                buf_size, AV_RL32(buf + 4));
765
766     if (frame_4cc == AV_RL32("cfrm")) {
767         int free_index       = -1;
768         const int data_size  = buf_size - 20;
769         const int id         = AV_RL32(buf + 12);
770         const int whole_size = AV_RL32(buf + 16);
771         CFrameBuffer *cfrm;
772
773         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
774             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
775                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
776                        f->cfrm[i].id);
777
778         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
779             if (f->cfrm[i].id == id)
780                 break;
781             if (f->cfrm[i].size == 0)
782                 free_index = i;
783         }
784
785         if (i >= CFRAME_BUFFER_COUNT) {
786             i             = free_index;
787             f->cfrm[i].id = id;
788         }
789         cfrm = &f->cfrm[i];
790
791         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
792                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
793         // explicit check needed as memcpy below might not catch a NULL
794         if (!cfrm->data) {
795             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
796             return -1;
797         }
798
799         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
800         cfrm->size += data_size;
801
802         if (cfrm->size >= whole_size) {
803             buf        = cfrm->data;
804             frame_size = cfrm->size;
805
806             if (id != avctx->frame_number)
807                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
808                        id, avctx->frame_number);
809
810             cfrm->size = cfrm->id = 0;
811             frame_4cc  = AV_RL32("pfrm");
812         } else
813             return buf_size;
814     } else {
815         buf        = buf      + 12;
816         frame_size = buf_size - 12;
817     }
818
819     temp               = f->current_picture;
820     f->current_picture = f->last_picture;
821     f->last_picture    = temp;
822
823     p                  = &f->current_picture;
824     avctx->coded_frame = p;
825
826     // alternatively we would have to use our own buffer management
827     avctx->flags |= CODEC_FLAG_EMU_EDGE;
828
829     if (p->data[0])
830         avctx->release_buffer(avctx, p);
831
832     p->reference = 1;
833     if (avctx->get_buffer(avctx, p) < 0) {
834         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
835         return -1;
836     }
837
838     if (frame_4cc == AV_RL32("ifr2")) {
839         p->pict_type = AV_PICTURE_TYPE_I;
840         if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0)
841             return -1;
842     } else if (frame_4cc == AV_RL32("ifrm")) {
843         p->pict_type = AV_PICTURE_TYPE_I;
844         if (decode_i_frame(f, buf, frame_size) < 0)
845             return -1;
846     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
847         if (!f->last_picture.data[0]) {
848             f->last_picture.reference = 1;
849             if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
850                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
851                 return -1;
852             }
853         }
854
855         p->pict_type = AV_PICTURE_TYPE_P;
856         if (decode_p_frame(f, buf, frame_size) < 0)
857             return -1;
858     } else if (frame_4cc == AV_RL32("snd_")) {
859         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
860                buf_size);
861     } else {
862         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
863                buf_size);
864     }
865
866     p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
867
868     *picture   = *p;
869     *data_size = sizeof(AVPicture);
870
871     emms_c();
872
873     return buf_size;
874 }
875
876
877 static av_cold void common_init(AVCodecContext *avctx)
878 {
879     FourXContext * const f = avctx->priv_data;
880
881     ff_dsputil_init(&f->dsp, avctx);
882
883     f->avctx = avctx;
884 }
885
886 static av_cold int decode_init(AVCodecContext *avctx)
887 {
888     FourXContext * const f = avctx->priv_data;
889
890     if (avctx->extradata_size != 4 || !avctx->extradata) {
891         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
892         return 1;
893     }
894
895     f->version = AV_RL32(avctx->extradata) >> 16;
896     common_init(avctx);
897     init_vlcs(f);
898
899     if (f->version > 2)
900         avctx->pix_fmt = PIX_FMT_RGB565;
901     else
902         avctx->pix_fmt = PIX_FMT_BGR555;
903
904     return 0;
905 }
906
907
908 static av_cold int decode_end(AVCodecContext *avctx)
909 {
910     FourXContext * const f = avctx->priv_data;
911     int i;
912
913     av_freep(&f->bitstream_buffer);
914     f->bitstream_buffer_size = 0;
915     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
916         av_freep(&f->cfrm[i].data);
917         f->cfrm[i].allocated_size = 0;
918     }
919     ff_free_vlc(&f->pre_vlc);
920     if (f->current_picture.data[0])
921         avctx->release_buffer(avctx, &f->current_picture);
922     if (f->last_picture.data[0])
923         avctx->release_buffer(avctx, &f->last_picture);
924
925     return 0;
926 }
927
928 AVCodec ff_fourxm_decoder = {
929     .name           = "4xm",
930     .type           = AVMEDIA_TYPE_VIDEO,
931     .id             = CODEC_ID_4XM,
932     .priv_data_size = sizeof(FourXContext),
933     .init           = decode_init,
934     .close          = decode_end,
935     .decode         = decode_frame,
936     .capabilities   = CODEC_CAP_DR1,
937     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
938 };