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