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);
346 if (code < 0 || code > 6 || log2w < 0)
347 return AVERROR_INVALIDDATA;
350 src += f->mv[bytestream2_get_byte(&f->g)];
351 if (start > src || src > end) {
352 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
353 return AVERROR_INVALIDDATA;
355 mcdc(dst, src, log2w, h, stride, 1, 0);
356 } else if (code == 1) {
358 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
360 if ((ret = decode_p_block(f, dst + (stride << log2h),
361 src + (stride << log2h),
362 log2w, log2h, stride)) < 0)
364 } else if (code == 2) {
366 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
368 if ((ret = decode_p_block(f, dst + (1 << log2w),
370 log2w, log2h, stride)) < 0)
372 } else if (code == 3 && f->version < 2) {
373 if (start > src || src > end) {
374 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
375 return AVERROR_INVALIDDATA;
377 mcdc(dst, src, log2w, h, stride, 1, 0);
378 } else if (code == 4) {
379 src += f->mv[bytestream2_get_byte(&f->g)];
380 if (start > src || src > end) {
381 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
382 return AVERROR_INVALIDDATA;
384 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
385 } else if (code == 5) {
386 if (start > src || src > end) {
387 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
388 return AVERROR_INVALIDDATA;
390 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
391 } else if (code == 6) {
393 dst[0] = bytestream2_get_le16(&f->g2);
394 dst[1] = bytestream2_get_le16(&f->g2);
396 dst[0] = bytestream2_get_le16(&f->g2);
397 dst[stride] = bytestream2_get_le16(&f->g2);
403 static int decode_p_frame(FourXContext *f, AVFrame *frame,
404 const uint8_t *buf, int length)
407 const int width = f->avctx->width;
408 const int height = f->avctx->height;
409 uint16_t *dst = (uint16_t *)frame->data[0];
410 const int stride = frame->linesize[0] >> 1;
412 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
413 bytestream_offset, wordstream_offset;
416 if (!f->last_picture->data[0]) {
417 if ((ret = ff_get_buffer(f->avctx, f->last_picture,
418 AV_GET_BUFFER_FLAG_REF)) < 0) {
419 av_log(f->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
422 memset(f->last_picture->data[0], 0,
423 f->avctx->height * FFABS(f->last_picture->linesize[0]));
426 src = (uint16_t *)f->last_picture->data[0];
428 if (f->version > 1) {
430 return AVERROR_INVALIDDATA;
432 bitstream_size = AV_RL32(buf + 8);
433 wordstream_size = AV_RL32(buf + 12);
434 bytestream_size = AV_RL32(buf + 16);
437 bitstream_size = AV_RL16(buf - 4);
438 wordstream_size = AV_RL16(buf - 2);
439 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
442 if (bitstream_size + bytestream_size + wordstream_size + extra != length
443 || bitstream_size > (1 << 26)
444 || bytestream_size > (1 << 26)
445 || wordstream_size > (1 << 26)) {
446 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
447 bitstream_size, bytestream_size, wordstream_size,
448 bitstream_size + bytestream_size + wordstream_size - length);
449 return AVERROR_INVALIDDATA;
452 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
453 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
454 if (!f->bitstream_buffer)
455 return AVERROR(ENOMEM);
456 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
458 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
459 0, FF_INPUT_BUFFER_PADDING_SIZE);
460 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
462 wordstream_offset = extra + bitstream_size;
463 bytestream_offset = extra + bitstream_size + wordstream_size;
464 bytestream2_init(&f->g2, buf + wordstream_offset,
465 length - wordstream_offset);
466 bytestream2_init(&f->g, buf + bytestream_offset,
467 length - bytestream_offset);
469 init_mv(f, frame->linesize[0]);
471 for (y = 0; y < height; y += 8) {
472 for (x = 0; x < width; x += 8)
473 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
483 * decode block and dequantize.
484 * Note this is almost identical to MJPEG.
486 static int decode_i_block(FourXContext *f, int16_t *block)
488 int code, i, j, level, val;
491 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
493 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
496 val = get_xbits(&f->gb, val);
498 val = val * dequant_table[0] + f->last_dc;
499 f->last_dc = block[0] = val;
503 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
511 level = get_xbits(&f->gb, code & 0xf);
514 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
518 j = ff_zigzag_direct[i];
519 block[j] = level * dequant_table[j];
529 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
531 int16_t (*block)[64] = f->block;
532 int stride = frame->linesize[0] >> 1;
534 uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
536 for (i = 0; i < 4; i++) {
537 block[i][0] += 0x80 * 8 * 8;
541 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
542 for (i = 4; i < 6; i++)
546 /* Note transform is:
547 * y = ( 1b + 4g + 2r) / 14
548 * cb = ( 3b - 2g - 1r) / 14
549 * cr = (-1b - 4g + 5r) / 14 */
550 for (y = 0; y < 8; y++) {
551 for (x = 0; x < 8; x++) {
552 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
553 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
554 int cb = block[4][x + 8 * y];
555 int cr = block[5][x + 8 * y];
556 int cg = (cb + cr) >> 1;
562 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
566 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
568 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
571 dst += 2 * stride - 2 * 8;
575 static int decode_i_mb(FourXContext *f)
580 f->dsp.clear_blocks(f->block[0]);
582 for (i = 0; i < 6; i++)
583 if ((ret = decode_i_block(f, f->block[i])) < 0)
589 static const uint8_t *read_huffman_tables(FourXContext *f,
590 const uint8_t * const buf,
593 int frequency[512] = { 0 };
596 uint8_t len_tab[257];
599 const uint8_t *ptr = buf;
602 memset(up, -1, sizeof(up));
609 len -= end - start + 1;
611 if (end < start || len < 0)
614 for (i = start; i <= end; i++)
615 frequency[i] = *ptr++;
627 while ((ptr - buf) & 3)
628 ptr++; // 4byte align
630 for (j = 257; j < 512; j++) {
631 int min_freq[2] = { 256 * 256, 256 * 256 };
632 int smallest[2] = { 0, 0 };
634 for (i = 0; i < j; i++) {
635 if (frequency[i] == 0)
637 if (frequency[i] < min_freq[1]) {
638 if (frequency[i] < min_freq[0]) {
639 min_freq[1] = min_freq[0];
640 smallest[1] = smallest[0];
641 min_freq[0] = frequency[i];
644 min_freq[1] = frequency[i];
649 if (min_freq[1] == 256 * 256)
652 frequency[j] = min_freq[0] + min_freq[1];
653 flag[smallest[0]] = 0;
654 flag[smallest[1]] = 1;
657 frequency[smallest[0]] = frequency[smallest[1]] = 0;
660 for (j = 0; j < 257; j++) {
661 int node, len = 0, bits = 0;
663 for (node = j; up[node] != -1; node = up[node]) {
664 bits += flag[node] << len;
667 // can this happen at all ?
668 av_log(f->avctx, AV_LOG_ERROR,
669 "vlc length overflow\n");
676 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
683 static int mix(int c0, int c1)
685 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
686 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
687 int red = 2 * (c0 >> 10) + (c1 >> 10);
688 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
691 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
694 const int width = f->avctx->width;
695 const int height = f->avctx->height;
696 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
697 uint16_t *dst = (uint16_t*)frame->data[0];
698 const int stride = frame->linesize[0]>>1;
701 if (length < mbs * 8) {
702 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
703 return AVERROR_INVALIDDATA;
705 bytestream2_init(&g3, buf, length);
707 for (y = 0; y < height; y += 16) {
708 for (x = 0; x < width; x += 16) {
709 unsigned int color[4] = { 0 }, bits;
710 // warning following is purely guessed ...
711 color[0] = bytestream2_get_le16u(&g3);
712 color[1] = bytestream2_get_le16u(&g3);
714 if (color[0] & 0x8000)
715 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
716 if (color[1] & 0x8000)
717 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
719 color[2] = mix(color[0], color[1]);
720 color[3] = mix(color[1], color[0]);
722 bits = bytestream2_get_le32u(&g3);
723 for (y2 = 0; y2 < 16; y2++) {
724 for (x2 = 0; x2 < 16; x2++) {
725 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
726 dst[y2 * stride + x2] = color[(bits >> index) & 3];
731 dst += 16 * stride - x;
737 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
740 const int width = f->avctx->width;
741 const int height = f->avctx->height;
742 const unsigned int bitstream_size = AV_RL32(buf);
743 int token_count av_unused;
744 unsigned int prestream_size;
745 const uint8_t *prestream;
747 if (length < bitstream_size + 12) {
748 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
749 return AVERROR_INVALIDDATA;
752 token_count = AV_RL32(buf + bitstream_size + 8);
753 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
754 prestream = buf + bitstream_size + 12;
756 if (prestream_size + bitstream_size + 12 != length
757 || bitstream_size > (1 << 26)
758 || prestream_size > (1 << 26)) {
759 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
760 prestream_size, bitstream_size, length);
761 return AVERROR_INVALIDDATA;
764 prestream = read_huffman_tables(f, prestream, prestream_size);
766 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
767 return AVERROR_INVALIDDATA;
770 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
772 prestream_size = length + buf - prestream;
774 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
775 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
776 if (!f->bitstream_buffer)
777 return AVERROR(ENOMEM);
778 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
780 memset((uint8_t*)f->bitstream_buffer + prestream_size,
781 0, FF_INPUT_BUFFER_PADDING_SIZE);
782 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
784 f->last_dc = 0 * 128 * 8 * 8;
786 for (y = 0; y < height; y += 16) {
787 for (x = 0; x < width; x += 16) {
788 if ((ret = decode_i_mb(f)) < 0)
791 idct_put(f, frame, x, y);
795 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
796 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
801 static int decode_frame(AVCodecContext *avctx, void *data,
802 int *got_frame, AVPacket *avpkt)
804 const uint8_t *buf = avpkt->data;
805 int buf_size = avpkt->size;
806 FourXContext *const f = avctx->priv_data;
807 AVFrame *picture = data;
808 int i, frame_4cc, frame_size, ret;
811 return AVERROR_INVALIDDATA;
813 if (buf_size < AV_RL32(buf + 4) + 8) {
814 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
815 buf_size, AV_RL32(buf + 4));
816 return AVERROR_INVALIDDATA;
819 frame_4cc = AV_RL32(buf);
821 if (frame_4cc == AV_RL32("cfrm")) {
824 const int data_size = buf_size - 20;
828 return AVERROR_INVALIDDATA;
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;
882 // alternatively we would have to use our own buffer management
883 avctx->flags |= CODEC_FLAG_EMU_EDGE;
885 if ((ret = ff_get_buffer(avctx, picture, AV_GET_BUFFER_FLAG_REF)) < 0) {
886 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
890 if (frame_4cc == AV_RL32("ifr2")) {
891 picture->pict_type = AV_PICTURE_TYPE_I;
892 if ((ret = decode_i2_frame(f, picture, buf - 4, frame_size + 4)) < 0)
894 } else if (frame_4cc == AV_RL32("ifrm")) {
895 picture->pict_type = AV_PICTURE_TYPE_I;
896 if ((ret = decode_i_frame(f, picture, buf, frame_size)) < 0)
898 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
899 picture->pict_type = AV_PICTURE_TYPE_P;
900 if ((ret = decode_p_frame(f, picture, buf, frame_size)) < 0)
902 } else if (frame_4cc == AV_RL32("snd_")) {
903 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
906 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
910 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
912 av_frame_unref(f->last_picture);
913 if ((ret = av_frame_ref(f->last_picture, picture)) < 0)
922 static av_cold int decode_init(AVCodecContext *avctx)
924 FourXContext * const f = avctx->priv_data;
926 if (avctx->extradata_size != 4 || !avctx->extradata) {
927 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
931 f->version = AV_RL32(avctx->extradata) >> 16;
932 ff_dsputil_init(&f->dsp, avctx);
937 avctx->pix_fmt = AV_PIX_FMT_RGB565;
939 avctx->pix_fmt = AV_PIX_FMT_BGR555;
941 f->last_picture = av_frame_alloc();
942 if (!f->last_picture)
943 return AVERROR(ENOMEM);
949 static av_cold int decode_end(AVCodecContext *avctx)
951 FourXContext * const f = avctx->priv_data;
954 av_freep(&f->bitstream_buffer);
955 f->bitstream_buffer_size = 0;
956 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
957 av_freep(&f->cfrm[i].data);
958 f->cfrm[i].allocated_size = 0;
960 ff_free_vlc(&f->pre_vlc);
961 av_frame_free(&f->last_picture);
966 AVCodec ff_fourxm_decoder = {
968 .type = AVMEDIA_TYPE_VIDEO,
969 .id = AV_CODEC_ID_4XM,
970 .priv_data_size = sizeof(FourXContext),
973 .decode = decode_frame,
974 .capabilities = CODEC_CAP_DR1,
975 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),