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