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