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
27 #include "libavutil/frame.h"
28 #include "libavutil/intreadwrite.h"
30 #include "bytestream.h"
35 #define BLOCK_TYPE_VLC_BITS 5
36 #define ACDC_VLC_BITS 9
38 #define CFRAME_BUFFER_COUNT 100
40 static const uint8_t block_type_tab[2][4][8][2] = {
42 { // { 8, 4, 2 } x { 8, 4, 2}
43 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
45 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
47 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
52 { // { 8, 4, 2 } x { 8, 4, 2}
53 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
55 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
64 static const uint8_t size2index[4][4] = {
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 }
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,
119 static VLC block_type_vlc[2][4];
122 typedef struct CFrameBuffer {
123 unsigned int allocated_size;
129 typedef struct FourXContext {
130 AVCodecContext *avctx;
132 AVFrame *last_picture;
133 GetBitContext pre_gb; ///< ac/dc prefix
140 DECLARE_ALIGNED(16, int16_t, block)[6][64];
141 void *bitstream_buffer;
142 unsigned int bitstream_buffer_size;
144 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
148 #define FIX_1_082392200 70936
149 #define FIX_1_414213562 92682
150 #define FIX_1_847759065 121095
151 #define FIX_2_613125930 171254
153 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
155 static void idct(int16_t block[64])
157 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
158 int tmp10, tmp11, tmp12, tmp13;
159 int z5, z10, z11, z12, z13;
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];
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;
170 tmp0 = tmp10 + tmp13;
171 tmp3 = tmp10 - tmp13;
172 tmp1 = tmp11 + tmp12;
173 tmp2 = tmp11 - tmp12;
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];
181 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
183 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
184 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
185 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
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;
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];
205 tmp13 = temp[2 + i] + temp[6 + i];
206 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
208 tmp0 = tmp10 + tmp13;
209 tmp3 = tmp10 - tmp13;
210 tmp1 = tmp11 + tmp12;
211 tmp2 = tmp11 - tmp12;
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];
219 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
221 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
222 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
223 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
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;
240 static av_cold void init_vlcs(FourXContext *f)
242 static VLC_TYPE table[2][4][32][2];
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);
257 static void init_mv(FourXContext *f, int linesize)
261 for (i = 0; i < 256; i++) {
263 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
265 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
270 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
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); \
279 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
281 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
282 AV_WN32A(dst, tmpval); \
286 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
287 int h, int stride, int scale, unsigned dc)
294 for (i = 0; i < h; i++) {
295 dst[0] = scale * src[0] + dc;
302 for (i = 0; i < h; i++) {
303 LE_CENTRIC_MUL(dst, src, scale, dc);
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);
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);
334 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
335 int log2w, int log2h, int stride)
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);
348 if (code < 0 || code > 6 || log2w < 0)
349 return AVERROR_INVALIDDATA;
353 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
355 return decode_p_block(f, dst + (stride << log2h),
356 src + (stride << log2h),
357 log2w, log2h, stride);
358 } else if (code == 2) {
360 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
362 return decode_p_block(f, dst + (1 << log2w),
364 log2w, log2h, stride);
365 } else if (code == 6) {
367 dst[0] = bytestream2_get_le16(&f->g2);
368 dst[1] = bytestream2_get_le16(&f->g2);
370 dst[0] = bytestream2_get_le16(&f->g2);
371 dst[stride] = bytestream2_get_le16(&f->g2);
377 src += f->mv[bytestream2_get_byte(&f->g)];
378 } else if (code == 3 && f->version >= 2) {
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) {
385 dc = bytestream2_get_le16(&f->g2);
388 if (start > src || src > end) {
389 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
390 return AVERROR_INVALIDDATA;
393 mcdc(dst, src, log2w, h, stride, scale, dc);
398 static int decode_p_frame(FourXContext *f, AVFrame *frame,
399 const uint8_t *buf, int length)
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;
407 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
408 bytestream_offset, wordstream_offset;
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");
417 memset(f->last_picture->data[0], 0,
418 f->avctx->height * FFABS(f->last_picture->linesize[0]));
421 src = (uint16_t *)f->last_picture->data[0];
423 if (f->version > 1) {
425 return AVERROR_INVALIDDATA;
427 bitstream_size = AV_RL32(buf + 8);
428 wordstream_size = AV_RL32(buf + 12);
429 bytestream_size = AV_RL32(buf + 16);
432 bitstream_size = AV_RL16(buf - 4);
433 wordstream_size = AV_RL16(buf - 2);
434 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
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;
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),
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);
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);
464 init_mv(f, frame->linesize[0]);
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)
478 * decode block and dequantize.
479 * Note this is almost identical to MJPEG.
481 static int decode_i_block(FourXContext *f, int16_t *block)
483 int code, i, j, level, val;
486 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
488 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
491 val = get_xbits(&f->gb, val);
493 val = val * dequant_table[0] + f->last_dc;
494 f->last_dc = block[0] = val;
498 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
506 level = get_xbits(&f->gb, code & 0xf);
509 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
513 j = ff_zigzag_direct[i];
514 block[j] = level * dequant_table[j];
524 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
526 int16_t (*block)[64] = f->block;
527 int stride = frame->linesize[0] >> 1;
529 uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
531 for (i = 0; i < 4; i++) {
532 block[i][0] += 0x80 * 8 * 8;
536 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
537 for (i = 4; i < 6; i++)
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;
557 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
559 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
561 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
563 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
566 dst += 2 * stride - 2 * 8;
570 static int decode_i_mb(FourXContext *f)
575 f->dsp.clear_blocks(f->block[0]);
577 for (i = 0; i < 6; i++)
578 if ((ret = decode_i_block(f, f->block[i])) < 0)
584 static const uint8_t *read_huffman_tables(FourXContext *f,
585 const uint8_t * const buf,
588 int frequency[512] = { 0 };
591 uint8_t len_tab[257];
594 const uint8_t *ptr = buf;
597 memset(up, -1, sizeof(up));
604 len -= end - start + 1;
606 if (end < start || len < 0)
609 for (i = start; i <= end; i++)
610 frequency[i] = *ptr++;
622 while ((ptr - buf) & 3)
623 ptr++; // 4byte align
625 for (j = 257; j < 512; j++) {
626 int min_freq[2] = { 256 * 256, 256 * 256 };
627 int smallest[2] = { 0, 0 };
629 for (i = 0; i < j; i++) {
630 if (frequency[i] == 0)
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];
639 min_freq[1] = frequency[i];
644 if (min_freq[1] == 256 * 256)
647 frequency[j] = min_freq[0] + min_freq[1];
648 flag[smallest[0]] = 0;
649 flag[smallest[1]] = 1;
652 frequency[smallest[0]] = frequency[smallest[1]] = 0;
655 for (j = 0; j < 257; j++) {
656 int node, len = 0, bits = 0;
658 for (node = j; up[node] != -1; node = up[node]) {
659 bits += flag[node] << len;
662 // can this happen at all ?
663 av_log(f->avctx, AV_LOG_ERROR,
664 "vlc length overflow\n");
671 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
678 static int mix(int c0, int c1)
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;
686 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
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;
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 * stride + x2] = color[(bits >> index) & 3];
726 dst += 16 * stride - x;
732 static int decode_i_frame(FourXContext *f, AVFrame *frame, 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->dsp.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)
788 idct_put(f, frame, x, y);
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 (buf_size < AV_RL32(buf + 4) + 8) {
811 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
812 buf_size, AV_RL32(buf + 4));
813 return AVERROR_INVALIDDATA;
816 frame_4cc = AV_RL32(buf);
818 if (frame_4cc == AV_RL32("cfrm")) {
821 const int data_size = buf_size - 20;
825 return AVERROR_INVALIDDATA;
827 id = AV_RL32(buf + 12);
828 whole_size = AV_RL32(buf + 16);
830 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
831 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
832 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
835 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
836 if (f->cfrm[i].id == id)
838 if (f->cfrm[i].size == 0)
842 if (i >= CFRAME_BUFFER_COUNT) {
848 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
849 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
850 // explicit check needed as memcpy below might not catch a NULL
852 av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
853 return AVERROR(ENOMEM);
856 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
857 cfrm->size += data_size;
859 if (cfrm->size >= whole_size) {
861 frame_size = cfrm->size;
863 if (id != avctx->frame_number)
864 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
865 id, avctx->frame_number);
868 return AVERROR_INVALIDDATA;
870 cfrm->size = cfrm->id = 0;
871 frame_4cc = AV_RL32("pfrm");
876 frame_size = buf_size - 12;
879 // alternatively we would have to use our own buffer management
880 avctx->flags |= CODEC_FLAG_EMU_EDGE;
882 if ((ret = ff_get_buffer(avctx, picture, AV_GET_BUFFER_FLAG_REF)) < 0) {
883 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
887 if (frame_4cc == AV_RL32("ifr2")) {
888 picture->pict_type = AV_PICTURE_TYPE_I;
889 if ((ret = decode_i2_frame(f, picture, buf - 4, frame_size + 4)) < 0)
891 } else if (frame_4cc == AV_RL32("ifrm")) {
892 picture->pict_type = AV_PICTURE_TYPE_I;
893 if ((ret = decode_i_frame(f, picture, buf, frame_size)) < 0)
895 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
896 picture->pict_type = AV_PICTURE_TYPE_P;
897 if ((ret = decode_p_frame(f, picture, buf, frame_size)) < 0)
899 } else if (frame_4cc == AV_RL32("snd_")) {
900 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
903 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
907 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
909 av_frame_unref(f->last_picture);
910 if ((ret = av_frame_ref(f->last_picture, picture)) < 0)
919 static av_cold int decode_init(AVCodecContext *avctx)
921 FourXContext * const f = avctx->priv_data;
923 if (avctx->extradata_size != 4 || !avctx->extradata) {
924 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
928 f->version = AV_RL32(avctx->extradata) >> 16;
929 ff_dsputil_init(&f->dsp, avctx);
934 avctx->pix_fmt = AV_PIX_FMT_RGB565;
936 avctx->pix_fmt = AV_PIX_FMT_BGR555;
938 f->last_picture = av_frame_alloc();
939 if (!f->last_picture)
940 return AVERROR(ENOMEM);
946 static av_cold int decode_end(AVCodecContext *avctx)
948 FourXContext * const f = avctx->priv_data;
951 av_freep(&f->bitstream_buffer);
952 f->bitstream_buffer_size = 0;
953 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
954 av_freep(&f->cfrm[i].data);
955 f->cfrm[i].allocated_size = 0;
957 ff_free_vlc(&f->pre_vlc);
958 av_frame_free(&f->last_picture);
963 AVCodec ff_fourxm_decoder = {
965 .type = AVMEDIA_TYPE_VIDEO,
966 .id = AV_CODEC_ID_4XM,
967 .priv_data_size = sizeof(FourXContext),
970 .decode = decode_frame,
971 .capabilities = CODEC_CAP_DR1,
972 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),