Merge commit '7513234bdd93f80593bfee3eb2da8c8f0d3992da'
[ffmpeg.git] / libavcodec / 4xm.c
1 /*
2  * 4XM codec
3  * Copyright (c) 2003 Michael Niedermayer
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * 4XM codec.
25  */
26
27 #include "libavutil/avassert.h"
28 #include "libavutil/frame.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/intreadwrite.h"
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "dsputil.h"
34 #include "get_bits.h"
35 #include "internal.h"
36
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, const 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         av_assert0(0);
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     av_assert0(code >= 0 && code <= 6 && log2w >= 0);
353
354     if (code == 1) {
355         log2h--;
356         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
357             return ret;
358         return decode_p_block(f, dst + (stride << log2h),
359                               src + (stride << log2h),
360                               log2w, log2h, stride);
361     } else if (code == 2) {
362         log2w--;
363         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
364             return ret;
365         return decode_p_block(f, dst + (1 << log2w),
366                               src + (1 << log2w),
367                               log2w, log2h, stride);
368     } else if (code == 6) {
369         if (bytestream2_get_bytes_left(&f->g2) < 4) {
370             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
371             return AVERROR_INVALIDDATA;
372         }
373         if (log2w) {
374             dst[0]      = bytestream2_get_le16u(&f->g2);
375             dst[1]      = bytestream2_get_le16u(&f->g2);
376         } else {
377             dst[0]      = bytestream2_get_le16u(&f->g2);
378             dst[stride] = bytestream2_get_le16u(&f->g2);
379         }
380         return 0;
381     }
382
383     if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
384         av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
385         return AVERROR_INVALIDDATA;
386     }
387
388     if (code == 0) {
389         src  += f->mv[bytestream2_get_byte(&f->g)];
390     } else if (code == 3 && f->version >= 2) {
391         return 0;
392     } else if (code == 4) {
393         src  += f->mv[bytestream2_get_byte(&f->g)];
394         if (bytestream2_get_bytes_left(&f->g2) < 2){
395             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
396             return AVERROR_INVALIDDATA;
397         }
398         dc    = bytestream2_get_le16(&f->g2);
399     } else if (code == 5) {
400         if (bytestream2_get_bytes_left(&f->g2) < 2){
401             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
402             return AVERROR_INVALIDDATA;
403         }
404         av_assert0(start <= src && src <= end);
405         scale = 0;
406         dc    = bytestream2_get_le16(&f->g2);
407     }
408
409     if (start > src || src > end) {
410         av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
411         return AVERROR_INVALIDDATA;
412     }
413
414     mcdc(dst, src, log2w, h, stride, scale, dc);
415
416     return 0;
417 }
418
419 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
420 {
421     int x, y;
422     const int width  = f->avctx->width;
423     const int height = f->avctx->height;
424     uint16_t *dst    = f->frame_buffer;
425     uint16_t *src;
426     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427                  bytestream_offset, wordstream_offset;
428     int ret;
429
430     src = f->last_frame_buffer;
431
432     if (f->version > 1) {
433         extra           = 20;
434         if (length < extra)
435             return AVERROR_INVALIDDATA;
436         bitstream_size  = AV_RL32(buf + 8);
437         wordstream_size = AV_RL32(buf + 12);
438         bytestream_size = AV_RL32(buf + 16);
439     } else {
440         extra           = 0;
441         bitstream_size  = AV_RL16(buf - 4);
442         wordstream_size = AV_RL16(buf - 2);
443         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
444     }
445
446     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
447         bytestream_size > length - bitstream_size ||
448         wordstream_size > length - bytestream_size - bitstream_size ||
449         extra > length - bytestream_size - bitstream_size - wordstream_size) {
450         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
451         bitstream_size+ bytestream_size+ wordstream_size - length);
452         return AVERROR_INVALIDDATA;
453     }
454
455     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
456                           bitstream_size);
457     if (!f->bitstream_buffer)
458         return AVERROR(ENOMEM);
459     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
460                      bitstream_size / 4);
461     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
462
463     wordstream_offset = extra + bitstream_size;
464     bytestream_offset = extra + bitstream_size + wordstream_size;
465     bytestream2_init(&f->g2, buf + wordstream_offset,
466                      length - wordstream_offset);
467     bytestream2_init(&f->g, buf + bytestream_offset,
468                      length - bytestream_offset);
469
470     init_mv(f, width * 2);
471
472     for (y = 0; y < height; y += 8) {
473         for (x = 0; x < width; x += 8)
474             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
475                 return ret;
476         src += 8 * width;
477         dst += 8 * width;
478     }
479
480     return 0;
481 }
482
483 /**
484  * decode block and dequantize.
485  * Note this is almost identical to MJPEG.
486  */
487 static int decode_i_block(FourXContext *f, int16_t *block)
488 {
489     int code, i, j, level, val;
490
491     if (get_bits_left(&f->gb) < 2){
492         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
493         return -1;
494     }
495
496     /* DC coef */
497     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
498     if (val >> 4) {
499         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
500         return AVERROR_INVALIDDATA;
501     }
502
503     if (val)
504         val = get_xbits(&f->gb, val);
505
506     val        = val * dequant_table[0] + f->last_dc;
507     f->last_dc = block[0] = val;
508     /* AC coefs */
509     i = 1;
510     for (;;) {
511         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
512
513         /* EOB */
514         if (code == 0)
515             break;
516         if (code == 0xf0) {
517             i += 16;
518         } else {
519             if (code & 0xf) {
520                 level = get_xbits(&f->gb, code & 0xf);
521             } else {
522                 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
523                 return AVERROR_INVALIDDATA;
524             }
525             i    += code >> 4;
526             if (i >= 64) {
527                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
528                 return 0;
529             }
530
531             j = ff_zigzag_direct[i];
532             block[j] = level * dequant_table[j];
533             i++;
534             if (i >= 64)
535                 break;
536         }
537     }
538
539     return 0;
540 }
541
542 static inline void idct_put(FourXContext *f, int x, int y)
543 {
544     int16_t (*block)[64] = f->block;
545     int stride           = f->avctx->width;
546     int i;
547     uint16_t *dst = f->frame_buffer + y * stride + x;
548
549     for (i = 0; i < 4; i++) {
550         block[i][0] += 0x80 * 8 * 8;
551         idct(block[i]);
552     }
553
554     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
555         for (i = 4; i < 6; i++)
556             idct(block[i]);
557     }
558
559     /* Note transform is:
560      * y  = ( 1b + 4g + 2r) / 14
561      * cb = ( 3b - 2g - 1r) / 14
562      * cr = (-1b - 4g + 5r) / 14 */
563     for (y = 0; y < 8; y++) {
564         for (x = 0; x < 8; x++) {
565             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
566                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
567             int cb = block[4][x + 8 * y];
568             int cr = block[5][x + 8 * y];
569             int cg = (cb + cr) >> 1;
570             int y;
571
572             cb += cb;
573
574             y               = temp[0];
575             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
576             y               = temp[1];
577             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
578             y               = temp[8];
579             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
580             y               = temp[9];
581             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
582             dst            += 2;
583         }
584         dst += 2 * stride - 2 * 8;
585     }
586 }
587
588 static int decode_i_mb(FourXContext *f)
589 {
590     int ret;
591     int i;
592
593     f->dsp.clear_blocks(f->block[0]);
594
595     for (i = 0; i < 6; i++)
596         if ((ret = decode_i_block(f, f->block[i])) < 0)
597             return ret;
598
599     return 0;
600 }
601
602 static const uint8_t *read_huffman_tables(FourXContext *f,
603                                           const uint8_t * const buf,
604                                           int buf_size)
605 {
606     int frequency[512] = { 0 };
607     uint8_t flag[512];
608     int up[512];
609     uint8_t len_tab[257];
610     int bits_tab[257];
611     int start, end;
612     const uint8_t *ptr = buf;
613     const uint8_t *ptr_end = buf + buf_size;
614     int j;
615
616     memset(up, -1, sizeof(up));
617
618     start = *ptr++;
619     end   = *ptr++;
620     for (;;) {
621         int i;
622
623         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
624             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
625             return NULL;
626         }
627
628         for (i = start; i <= end; i++)
629             frequency[i] = *ptr++;
630         start = *ptr++;
631         if (start == 0)
632             break;
633
634         end = *ptr++;
635     }
636     frequency[256] = 1;
637
638     while ((ptr - buf) & 3)
639         ptr++; // 4byte align
640
641     if (ptr > ptr_end) {
642         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
643         return NULL;
644     }
645
646     for (j = 257; j < 512; j++) {
647         int min_freq[2] = { 256 * 256, 256 * 256 };
648         int smallest[2] = { 0, 0 };
649         int i;
650         for (i = 0; i < j; i++) {
651             if (frequency[i] == 0)
652                 continue;
653             if (frequency[i] < min_freq[1]) {
654                 if (frequency[i] < min_freq[0]) {
655                     min_freq[1] = min_freq[0];
656                     smallest[1] = smallest[0];
657                     min_freq[0] = frequency[i];
658                     smallest[0] = i;
659                 } else {
660                     min_freq[1] = frequency[i];
661                     smallest[1] = i;
662                 }
663             }
664         }
665         if (min_freq[1] == 256 * 256)
666             break;
667
668         frequency[j]           = min_freq[0] + min_freq[1];
669         flag[smallest[0]]      = 0;
670         flag[smallest[1]]      = 1;
671         up[smallest[0]]        =
672         up[smallest[1]]        = j;
673         frequency[smallest[0]] = frequency[smallest[1]] = 0;
674     }
675
676     for (j = 0; j < 257; j++) {
677         int node, len = 0, bits = 0;
678
679         for (node = j; up[node] != -1; node = up[node]) {
680             bits += flag[node] << len;
681             len++;
682             if (len > 31)
683                 // can this happen at all ?
684                 av_log(f->avctx, AV_LOG_ERROR,
685                        "vlc length overflow\n");
686         }
687
688         bits_tab[j] = bits;
689         len_tab[j]  = len;
690     }
691
692     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
693                  bits_tab, 4, 4, 0))
694         return NULL;
695
696     return ptr;
697 }
698
699 static int mix(int c0, int c1)
700 {
701     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
702     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
703     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
704     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
705 }
706
707 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
708 {
709     int x, y, x2, y2;
710     const int width  = f->avctx->width;
711     const int height = f->avctx->height;
712     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
713     uint16_t *dst    = f->frame_buffer;
714     const uint8_t *buf_end = buf + length;
715     GetByteContext g3;
716
717     if (length < mbs * 8) {
718         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
719         return AVERROR_INVALIDDATA;
720     }
721     bytestream2_init(&g3, buf, length);
722
723     for (y = 0; y < height; y += 16) {
724         for (x = 0; x < width; x += 16) {
725             unsigned int color[4] = { 0 }, bits;
726             if (buf_end - buf < 8)
727                 return -1;
728             // warning following is purely guessed ...
729             color[0] = bytestream2_get_le16u(&g3);
730             color[1] = bytestream2_get_le16u(&g3);
731
732             if (color[0] & 0x8000)
733                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
734             if (color[1] & 0x8000)
735                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
736
737             color[2] = mix(color[0], color[1]);
738             color[3] = mix(color[1], color[0]);
739
740             bits = bytestream2_get_le32u(&g3);
741             for (y2 = 0; y2 < 16; y2++) {
742                 for (x2 = 0; x2 < 16; x2++) {
743                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
744                     dst[y2 * width + x2] = color[(bits >> index) & 3];
745                 }
746             }
747             dst += 16;
748         }
749         dst += 16 * width - x;
750     }
751
752     return 0;
753 }
754
755 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
756 {
757     int x, y, ret;
758     const int width  = f->avctx->width;
759     const int height = f->avctx->height;
760     const unsigned int bitstream_size = AV_RL32(buf);
761     unsigned int prestream_size;
762     const uint8_t *prestream;
763
764     if (bitstream_size > (1 << 26))
765         return AVERROR_INVALIDDATA;
766
767     if (length < bitstream_size + 12) {
768         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
769         return AVERROR_INVALIDDATA;
770     }
771
772     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
773     prestream      =             buf + bitstream_size + 12;
774
775     if (prestream_size + bitstream_size + 12 != length
776         || prestream_size > (1 << 26)) {
777         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
778                prestream_size, bitstream_size, length);
779         return AVERROR_INVALIDDATA;
780     }
781
782     prestream = read_huffman_tables(f, prestream, prestream_size);
783     if (!prestream) {
784         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
785         return AVERROR_INVALIDDATA;
786     }
787
788     av_assert0(prestream <= buf + length);
789
790     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
791
792     prestream_size = length + buf - prestream;
793
794     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
795                           prestream_size);
796     if (!f->bitstream_buffer)
797         return AVERROR(ENOMEM);
798     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
799                      prestream_size / 4);
800     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
801
802     f->last_dc = 0 * 128 * 8 * 8;
803
804     for (y = 0; y < height; y += 16) {
805         for (x = 0; x < width; x += 16) {
806             if ((ret = decode_i_mb(f)) < 0)
807                 return ret;
808
809             idct_put(f, x, y);
810         }
811     }
812
813     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
814         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
815
816     return 0;
817 }
818
819 static int decode_frame(AVCodecContext *avctx, void *data,
820                         int *got_frame, AVPacket *avpkt)
821 {
822     const uint8_t *buf    = avpkt->data;
823     int buf_size          = avpkt->size;
824     FourXContext *const f = avctx->priv_data;
825     AVFrame *picture      = data;
826     int i, frame_4cc, frame_size, ret;
827
828     if (buf_size < 20)
829         return AVERROR_INVALIDDATA;
830
831     av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
832
833     if (buf_size < AV_RL32(buf + 4) + 8) {
834         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
835                buf_size, AV_RL32(buf + 4));
836         return AVERROR_INVALIDDATA;
837     }
838
839     frame_4cc = AV_RL32(buf);
840
841     if (frame_4cc == AV_RL32("cfrm")) {
842         int free_index       = -1;
843         int id, whole_size;
844         const int data_size  = buf_size - 20;
845         CFrameBuffer *cfrm;
846
847         if (f->version <= 1) {
848             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
849             return AVERROR_INVALIDDATA;
850         }
851
852         id         = AV_RL32(buf + 12);
853         whole_size = AV_RL32(buf + 16);
854
855         if (data_size < 0 || whole_size < 0) {
856             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
857             return AVERROR_INVALIDDATA;
858         }
859
860         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
861             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
862                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
863                        f->cfrm[i].id);
864
865         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
866             if (f->cfrm[i].id == id)
867                 break;
868             if (f->cfrm[i].size == 0)
869                 free_index = i;
870         }
871
872         if (i >= CFRAME_BUFFER_COUNT) {
873             i             = free_index;
874             f->cfrm[i].id = id;
875         }
876         cfrm = &f->cfrm[i];
877
878         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
879             return AVERROR_INVALIDDATA;
880
881         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
882                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
883         // explicit check needed as memcpy below might not catch a NULL
884         if (!cfrm->data) {
885             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
886             return AVERROR(ENOMEM);
887         }
888
889         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
890         cfrm->size += data_size;
891
892         if (cfrm->size >= whole_size) {
893             buf        = cfrm->data;
894             frame_size = cfrm->size;
895
896             if (id != avctx->frame_number)
897                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
898                        id, avctx->frame_number);
899
900             if (f->version <= 1)
901                 return AVERROR_INVALIDDATA;
902
903             cfrm->size = cfrm->id = 0;
904             frame_4cc  = AV_RL32("pfrm");
905         } else
906             return buf_size;
907     } else {
908         buf        = buf      + 12;
909         frame_size = buf_size - 12;
910     }
911
912     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
913         return ret;
914
915     if (frame_4cc == AV_RL32("ifr2")) {
916         picture->pict_type = AV_PICTURE_TYPE_I;
917         if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
918             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
919             return ret;
920         }
921     } else if (frame_4cc == AV_RL32("ifrm")) {
922         picture->pict_type = AV_PICTURE_TYPE_I;
923         if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
924             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
925             return ret;
926         }
927     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
928         picture->pict_type = AV_PICTURE_TYPE_P;
929         if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
930             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
931             return ret;
932         }
933     } else if (frame_4cc == AV_RL32("snd_")) {
934         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
935                buf_size);
936     } else {
937         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
938                buf_size);
939     }
940
941     picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
942
943     av_image_copy_plane(picture->data[0], picture->linesize[0],
944                         (const uint8_t*)f->frame_buffer,  avctx->width * 2,
945                         avctx->width * 2, avctx->height);
946     FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
947
948     *got_frame = 1;
949
950     emms_c();
951
952     return buf_size;
953 }
954
955 static av_cold int decode_end(AVCodecContext *avctx)
956 {
957     FourXContext * const f = avctx->priv_data;
958     int i;
959
960     av_freep(&f->frame_buffer);
961     av_freep(&f->last_frame_buffer);
962     av_freep(&f->bitstream_buffer);
963     f->bitstream_buffer_size = 0;
964     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
965         av_freep(&f->cfrm[i].data);
966         f->cfrm[i].allocated_size = 0;
967     }
968     ff_free_vlc(&f->pre_vlc);
969
970     return 0;
971 }
972
973 static av_cold int decode_init(AVCodecContext *avctx)
974 {
975     FourXContext * const f = avctx->priv_data;
976     int ret;
977
978     if (avctx->extradata_size != 4 || !avctx->extradata) {
979         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
980         return AVERROR_INVALIDDATA;
981     }
982     if((avctx->width % 16) || (avctx->height % 16)) {
983         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
984         return AVERROR_INVALIDDATA;
985     }
986
987     ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
988     if (ret < 0)
989         return ret;
990
991     f->frame_buffer      = av_mallocz(avctx->width * avctx->height * 2);
992     f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
993     if (!f->frame_buffer || !f->last_frame_buffer) {
994         decode_end(avctx);
995         return AVERROR(ENOMEM);
996     }
997
998     f->version = AV_RL32(avctx->extradata) >> 16;
999     ff_dsputil_init(&f->dsp, avctx);
1000     f->avctx = avctx;
1001     init_vlcs(f);
1002
1003     if (f->version > 2)
1004         avctx->pix_fmt = AV_PIX_FMT_RGB565;
1005     else
1006         avctx->pix_fmt = AV_PIX_FMT_BGR555;
1007
1008     return 0;
1009 }
1010
1011 AVCodec ff_fourxm_decoder = {
1012     .name           = "4xm",
1013     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1014     .type           = AVMEDIA_TYPE_VIDEO,
1015     .id             = AV_CODEC_ID_4XM,
1016     .priv_data_size = sizeof(FourXContext),
1017     .init           = decode_init,
1018     .close          = decode_end,
1019     .decode         = decode_frame,
1020     .capabilities   = CODEC_CAP_DR1,
1021 };