3 * Copyright (c) 2003 Michael Niedermayer
5 * This file is part of Libav.
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.
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.
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
29 #include "libavutil/frame.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/intreadwrite.h"
35 #include "bytestream.h"
39 #define BLOCK_TYPE_VLC_BITS 5
40 #define ACDC_VLC_BITS 9
42 #define CFRAME_BUFFER_COUNT 100
44 static const uint8_t block_type_tab[2][4][8][2] = {
46 { // { 8, 4, 2 } x { 8, 4, 2}
47 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
49 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
53 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
56 { // { 8, 4, 2 } x { 8, 4, 2}
57 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
63 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
68 static const uint8_t size2index[4][4] = {
75 static const int8_t mv[256][2] = {
76 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
77 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
78 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
79 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
80 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
81 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
82 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
83 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
84 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
85 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
86 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
87 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
88 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
89 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
90 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
91 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
92 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
93 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
94 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
95 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
96 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
97 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
98 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
99 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
100 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
101 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
102 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
103 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
104 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
105 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
106 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
107 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
110 /* This is simply the scaled down elementwise product of the standard JPEG
111 * quantizer table and the AAN premul table. */
112 static const uint8_t dequant_table[64] = {
113 16, 15, 13, 19, 24, 31, 28, 17,
114 17, 23, 25, 31, 36, 63, 45, 21,
115 18, 24, 27, 37, 52, 59, 49, 20,
116 16, 28, 34, 40, 60, 80, 51, 20,
117 18, 31, 48, 66, 68, 86, 56, 21,
118 19, 38, 56, 59, 64, 64, 48, 20,
119 27, 48, 55, 55, 56, 51, 35, 15,
120 20, 35, 34, 32, 31, 22, 15, 8,
123 static VLC block_type_vlc[2][4];
126 typedef struct CFrameBuffer {
127 unsigned int allocated_size;
133 typedef struct FourXContext {
134 AVCodecContext *avctx;
135 BlockDSPContext bdsp;
136 BswapDSPContext bbdsp;
137 uint16_t *frame_buffer;
138 uint16_t *last_frame_buffer;
139 GetBitContext pre_gb; ///< ac/dc prefix
146 DECLARE_ALIGNED(16, int16_t, block)[6][64];
147 void *bitstream_buffer;
148 unsigned int bitstream_buffer_size;
150 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
154 #define FIX_1_082392200 70936
155 #define FIX_1_414213562 92682
156 #define FIX_1_847759065 121095
157 #define FIX_2_613125930 171254
159 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
161 static void idct(int16_t block[64])
163 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
164 int tmp10, tmp11, tmp12, tmp13;
165 int z5, z10, z11, z12, z13;
169 for (i = 0; i < 8; i++) {
170 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
171 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
173 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
174 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
176 tmp0 = tmp10 + tmp13;
177 tmp3 = tmp10 - tmp13;
178 tmp1 = tmp11 + tmp12;
179 tmp2 = tmp11 - tmp12;
181 z13 = block[8 * 5 + i] + block[8 * 3 + i];
182 z10 = block[8 * 5 + i] - block[8 * 3 + i];
183 z11 = block[8 * 1 + i] + block[8 * 7 + i];
184 z12 = block[8 * 1 + i] - block[8 * 7 + i];
187 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
189 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
190 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
191 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
197 temp[8 * 0 + i] = tmp0 + tmp7;
198 temp[8 * 7 + i] = tmp0 - tmp7;
199 temp[8 * 1 + i] = tmp1 + tmp6;
200 temp[8 * 6 + i] = tmp1 - tmp6;
201 temp[8 * 2 + i] = tmp2 + tmp5;
202 temp[8 * 5 + i] = tmp2 - tmp5;
203 temp[8 * 4 + i] = tmp3 + tmp4;
204 temp[8 * 3 + i] = tmp3 - tmp4;
207 for (i = 0; i < 8 * 8; i += 8) {
208 tmp10 = temp[0 + i] + temp[4 + i];
209 tmp11 = temp[0 + i] - temp[4 + i];
211 tmp13 = temp[2 + i] + temp[6 + i];
212 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
214 tmp0 = tmp10 + tmp13;
215 tmp3 = tmp10 - tmp13;
216 tmp1 = tmp11 + tmp12;
217 tmp2 = tmp11 - tmp12;
219 z13 = temp[5 + i] + temp[3 + i];
220 z10 = temp[5 + i] - temp[3 + i];
221 z11 = temp[1 + i] + temp[7 + i];
222 z12 = temp[1 + i] - temp[7 + i];
225 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
227 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
228 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
229 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
235 block[0 + i] = (tmp0 + tmp7) >> 6;
236 block[7 + i] = (tmp0 - tmp7) >> 6;
237 block[1 + i] = (tmp1 + tmp6) >> 6;
238 block[6 + i] = (tmp1 - tmp6) >> 6;
239 block[2 + i] = (tmp2 + tmp5) >> 6;
240 block[5 + i] = (tmp2 - tmp5) >> 6;
241 block[4 + i] = (tmp3 + tmp4) >> 6;
242 block[3 + i] = (tmp3 - tmp4) >> 6;
246 static av_cold void init_vlcs(FourXContext *f)
248 static VLC_TYPE table[2][4][32][2];
251 for (i = 0; i < 2; i++) {
252 for (j = 0; j < 4; j++) {
253 block_type_vlc[i][j].table = table[i][j];
254 block_type_vlc[i][j].table_allocated = 32;
255 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
256 &block_type_tab[i][j][0][1], 2, 1,
257 &block_type_tab[i][j][0][0], 2, 1,
258 INIT_VLC_USE_NEW_STATIC);
263 static void init_mv(FourXContext *f, int linesize)
267 for (i = 0; i < 256; i++) {
269 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
271 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
276 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
278 unsigned tmpval = AV_RN32(src); \
279 tmpval = (tmpval << 16) | (tmpval >> 16); \
280 tmpval = tmpval * (scale) + (dc); \
281 tmpval = (tmpval << 16) | (tmpval >> 16); \
282 AV_WN32A(dst, tmpval); \
285 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
287 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
288 AV_WN32A(dst, tmpval); \
292 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
293 int h, int stride, int scale, unsigned dc)
300 for (i = 0; i < h; i++) {
301 dst[0] = scale * src[0] + dc;
308 for (i = 0; i < h; i++) {
309 LE_CENTRIC_MUL(dst, src, scale, dc);
316 for (i = 0; i < h; i++) {
317 LE_CENTRIC_MUL(dst, src, scale, dc);
318 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
325 for (i = 0; i < h; i++) {
326 LE_CENTRIC_MUL(dst, src, scale, dc);
327 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
328 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
329 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
340 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
341 int log2w, int log2h, int stride)
343 int index, h, code, ret, scale = 1;
344 uint16_t *start, *end;
347 if (log2h < 0 || log2w < 0)
348 return AVERROR_INVALIDDATA;
350 index = size2index[log2h][log2w];
352 return AVERROR_INVALIDDATA;
355 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
356 BLOCK_TYPE_VLC_BITS, 1);
357 if (code < 0 || code > 6)
358 return AVERROR_INVALIDDATA;
360 start = f->last_frame_buffer;
361 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
365 return AVERROR_INVALIDDATA;
366 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
368 return decode_p_block(f, dst + (stride << log2h),
369 src + (stride << log2h),
370 log2w, log2h, stride);
371 } else if (code == 2) {
373 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
375 return decode_p_block(f, dst + (1 << log2w),
377 log2w, log2h, stride);
378 } else if (code == 6) {
380 dst[0] = bytestream2_get_le16(&f->g2);
381 dst[1] = bytestream2_get_le16(&f->g2);
383 dst[0] = bytestream2_get_le16(&f->g2);
384 dst[stride] = bytestream2_get_le16(&f->g2);
390 src += f->mv[bytestream2_get_byte(&f->g)];
391 } else if (code == 3 && f->version >= 2) {
393 } else if (code == 4) {
394 src += f->mv[bytestream2_get_byte(&f->g)];
395 dc = bytestream2_get_le16(&f->g2);
396 } else if (code == 5) {
398 dc = bytestream2_get_le16(&f->g2);
401 if (start > src || src > end) {
402 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
403 return AVERROR_INVALIDDATA;
406 mcdc(dst, src, log2w, h, stride, scale, dc);
411 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
414 const int width = f->avctx->width;
415 const int height = f->avctx->height;
416 uint16_t *dst = f->frame_buffer;
418 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
419 bytestream_offset, wordstream_offset;
422 src = f->last_frame_buffer;
424 if (f->version > 1) {
426 return AVERROR_INVALIDDATA;
428 bitstream_size = AV_RL32(buf + 8);
429 wordstream_size = AV_RL32(buf + 12);
430 bytestream_size = AV_RL32(buf + 16);
433 bitstream_size = AV_RL16(buf - 4);
434 wordstream_size = AV_RL16(buf - 2);
435 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
438 if (bitstream_size + bytestream_size + wordstream_size + extra != length
439 || bitstream_size > (1 << 26)
440 || bytestream_size > (1 << 26)
441 || wordstream_size > (1 << 26)) {
442 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
443 bitstream_size, bytestream_size, wordstream_size,
444 bitstream_size + bytestream_size + wordstream_size - length);
445 return AVERROR_INVALIDDATA;
448 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
449 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
450 if (!f->bitstream_buffer)
451 return AVERROR(ENOMEM);
452 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
454 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
455 0, FF_INPUT_BUFFER_PADDING_SIZE);
456 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
458 wordstream_offset = extra + bitstream_size;
459 bytestream_offset = extra + bitstream_size + wordstream_size;
460 bytestream2_init(&f->g2, buf + wordstream_offset,
461 length - wordstream_offset);
462 bytestream2_init(&f->g, buf + bytestream_offset,
463 length - bytestream_offset);
465 init_mv(f, width * 2);
467 for (y = 0; y < height; y += 8) {
468 for (x = 0; x < width; x += 8)
469 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
479 * decode block and dequantize.
480 * Note this is almost identical to MJPEG.
482 static int decode_i_block(FourXContext *f, int16_t *block)
484 int code, i, j, level, val;
487 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
489 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
492 val = get_xbits(&f->gb, val);
494 val = val * dequant_table[0] + f->last_dc;
495 f->last_dc = block[0] = val;
499 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
507 level = get_xbits(&f->gb, code & 0xf);
510 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
514 j = ff_zigzag_direct[i];
515 block[j] = level * dequant_table[j];
525 static inline void idct_put(FourXContext *f, int x, int y)
527 int16_t (*block)[64] = f->block;
528 int stride = f->avctx->width;
530 uint16_t *dst = f->frame_buffer + y * stride + x;
532 for (i = 0; i < 4; i++) {
533 block[i][0] += 0x80 * 8 * 8;
537 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
538 for (i = 4; i < 6; i++)
542 /* Note transform is:
543 * y = ( 1b + 4g + 2r) / 14
544 * cb = ( 3b - 2g - 1r) / 14
545 * cr = (-1b - 4g + 5r) / 14 */
546 for (y = 0; y < 8; y++) {
547 for (x = 0; x < 8; x++) {
548 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
549 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
550 int cb = block[4][x + 8 * y];
551 int cr = block[5][x + 8 * y];
552 int cg = (cb + cr) >> 1;
558 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
560 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
562 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
567 dst += 2 * stride - 2 * 8;
571 static int decode_i_mb(FourXContext *f)
576 f->bdsp.clear_blocks(f->block[0]);
578 for (i = 0; i < 6; i++)
579 if ((ret = decode_i_block(f, f->block[i])) < 0)
585 static const uint8_t *read_huffman_tables(FourXContext *f,
586 const uint8_t * const buf,
589 int frequency[512] = { 0 };
592 uint8_t len_tab[257];
595 const uint8_t *ptr = buf;
598 memset(up, -1, sizeof(up));
605 len -= end - start + 1;
607 if (end < start || len < 0)
610 for (i = start; i <= end; i++)
611 frequency[i] = *ptr++;
623 while ((ptr - buf) & 3)
624 ptr++; // 4byte align
626 for (j = 257; j < 512; j++) {
627 int min_freq[2] = { 256 * 256, 256 * 256 };
628 int smallest[2] = { 0, 0 };
630 for (i = 0; i < j; i++) {
631 if (frequency[i] == 0)
633 if (frequency[i] < min_freq[1]) {
634 if (frequency[i] < min_freq[0]) {
635 min_freq[1] = min_freq[0];
636 smallest[1] = smallest[0];
637 min_freq[0] = frequency[i];
640 min_freq[1] = frequency[i];
645 if (min_freq[1] == 256 * 256)
648 frequency[j] = min_freq[0] + min_freq[1];
649 flag[smallest[0]] = 0;
650 flag[smallest[1]] = 1;
653 frequency[smallest[0]] = frequency[smallest[1]] = 0;
656 for (j = 0; j < 257; j++) {
657 int node, len = 0, bits = 0;
659 for (node = j; up[node] != -1; node = up[node]) {
660 bits += flag[node] << len;
663 // can this happen at all ?
664 av_log(f->avctx, AV_LOG_ERROR,
665 "vlc length overflow\n");
672 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
679 static int mix(int c0, int c1)
681 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
682 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
683 int red = 2 * (c0 >> 10) + (c1 >> 10);
684 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
687 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
690 const int width = f->avctx->width;
691 const int height = f->avctx->height;
692 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
693 uint16_t *dst = f->frame_buffer;
696 if (length < mbs * 8) {
697 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
698 return AVERROR_INVALIDDATA;
700 bytestream2_init(&g3, buf, length);
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);
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");
714 color[2] = mix(color[0], color[1]);
715 color[3] = mix(color[1], color[0]);
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 * width + x2] = color[(bits >> index) & 3];
726 dst += 16 * width - x;
732 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
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;
742 if (bitstream_size > (1 << 26))
743 return AVERROR_INVALIDDATA;
745 if (length < bitstream_size + 12) {
746 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
747 return AVERROR_INVALIDDATA;
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;
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;
761 prestream = read_huffman_tables(f, prestream, prestream_size);
763 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
764 return AVERROR_INVALIDDATA;
767 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
769 prestream_size = length + buf - prestream;
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->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
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);
781 f->last_dc = 0 * 128 * 8 * 8;
783 for (y = 0; y < height; y += 16) {
784 for (x = 0; x < width; x += 16) {
785 if ((ret = decode_i_mb(f)) < 0)
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");
798 static int decode_frame(AVCodecContext *avctx, void *data,
799 int *got_frame, AVPacket *avpkt)
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;
808 return AVERROR_INVALIDDATA;
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;
816 if (buf_size < AV_RL32(buf + 4) + 8) {
817 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
818 buf_size, AV_RL32(buf + 4));
819 return AVERROR_INVALIDDATA;
822 frame_4cc = AV_RL32(buf);
824 if (frame_4cc == AV_RL32("cfrm")) {
827 const int data_size = buf_size - 20;
830 id = AV_RL32(buf + 12);
831 whole_size = AV_RL32(buf + 16);
833 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
834 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
835 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
838 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
839 if (f->cfrm[i].id == id)
841 if (f->cfrm[i].size == 0)
845 if (i >= CFRAME_BUFFER_COUNT) {
851 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
852 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
853 // explicit check needed as memcpy below might not catch a NULL
855 av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
856 return AVERROR(ENOMEM);
859 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
860 cfrm->size += data_size;
862 if (cfrm->size >= whole_size) {
864 frame_size = cfrm->size;
866 if (id != avctx->frame_number)
867 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
868 id, avctx->frame_number);
871 return AVERROR_INVALIDDATA;
873 cfrm->size = cfrm->id = 0;
874 frame_4cc = AV_RL32("pfrm");
879 frame_size = buf_size - 12;
883 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) {
884 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
888 if (frame_4cc == AV_RL32("ifr2")) {
889 picture->pict_type = AV_PICTURE_TYPE_I;
890 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0)
892 } else if (frame_4cc == AV_RL32("ifrm")) {
893 picture->pict_type = AV_PICTURE_TYPE_I;
894 if ((ret = decode_i_frame(f, buf, frame_size)) < 0)
896 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
897 picture->pict_type = AV_PICTURE_TYPE_P;
898 if ((ret = decode_p_frame(f, buf, frame_size)) < 0)
900 } else if (frame_4cc == AV_RL32("snd_")) {
901 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
904 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
908 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
910 av_image_copy_plane(picture->data[0], picture->linesize[0],
911 (const uint8_t*)f->frame_buffer, avctx->width * 2,
912 avctx->width * 2, avctx->height);
913 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
922 static av_cold int decode_end(AVCodecContext *avctx)
924 FourXContext * const f = avctx->priv_data;
927 av_freep(&f->frame_buffer);
928 av_freep(&f->last_frame_buffer);
929 av_freep(&f->bitstream_buffer);
930 f->bitstream_buffer_size = 0;
931 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
932 av_freep(&f->cfrm[i].data);
933 f->cfrm[i].allocated_size = 0;
935 ff_free_vlc(&f->pre_vlc);
940 static av_cold int decode_init(AVCodecContext *avctx)
942 FourXContext * const f = avctx->priv_data;
945 if (avctx->extradata_size != 4 || !avctx->extradata) {
946 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
947 return AVERROR_INVALIDDATA;
950 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
954 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
955 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
956 if (!f->frame_buffer || !f->last_frame_buffer) {
958 return AVERROR(ENOMEM);
961 f->version = AV_RL32(avctx->extradata) >> 16;
962 ff_blockdsp_init(&f->bdsp, avctx);
963 ff_bswapdsp_init(&f->bbdsp);
968 avctx->pix_fmt = AV_PIX_FMT_RGB565;
970 avctx->pix_fmt = AV_PIX_FMT_BGR555;
975 AVCodec ff_fourxm_decoder = {
977 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
978 .type = AVMEDIA_TYPE_VIDEO,
979 .id = AV_CODEC_ID_4XM,
980 .priv_data_size = sizeof(FourXContext),
983 .decode = decode_frame,
984 .capabilities = CODEC_CAP_DR1,