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