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