3 * Copyright (c) 2003 Michael Niedermayer
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/frame.h"
29 #include "libavutil/intreadwrite.h"
31 #include "bytestream.h"
37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
40 #define CFRAME_BUFFER_COUNT 100
42 static const uint8_t block_type_tab[2][4][8][2] = {
44 { // { 8, 4, 2 } x { 8, 4, 2}
45 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
47 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
54 { // { 8, 4, 2 } x { 8, 4, 2}
55 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
66 static const uint8_t size2index[4][4] = {
73 static const int8_t mv[256][2] = {
74 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
108 /* This is simply the scaled down elementwise product of the standard JPEG
109 * quantizer table and the AAN premul table. */
110 static const uint8_t dequant_table[64] = {
111 16, 15, 13, 19, 24, 31, 28, 17,
112 17, 23, 25, 31, 36, 63, 45, 21,
113 18, 24, 27, 37, 52, 59, 49, 20,
114 16, 28, 34, 40, 60, 80, 51, 20,
115 18, 31, 48, 66, 68, 86, 56, 21,
116 19, 38, 56, 59, 64, 64, 48, 20,
117 27, 48, 55, 55, 56, 51, 35, 15,
118 20, 35, 34, 32, 31, 22, 15, 8,
121 static VLC block_type_vlc[2][4];
124 typedef struct CFrameBuffer {
125 unsigned int allocated_size;
131 typedef struct FourXContext {
132 AVCodecContext *avctx;
134 AVFrame *current_picture, *last_picture;
135 GetBitContext pre_gb; ///< ac/dc prefix
142 DECLARE_ALIGNED(16, int16_t, block)[6][64];
143 void *bitstream_buffer;
144 unsigned int bitstream_buffer_size;
146 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
157 static void idct(int16_t block[64])
159 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160 int tmp10, tmp11, tmp12, tmp13;
161 int z5, z10, z11, z12, z13;
165 for (i = 0; i < 8; i++) {
166 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
169 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
170 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
172 tmp0 = tmp10 + tmp13;
173 tmp3 = tmp10 - tmp13;
174 tmp1 = tmp11 + tmp12;
175 tmp2 = tmp11 - tmp12;
177 z13 = block[8 * 5 + i] + block[8 * 3 + i];
178 z10 = block[8 * 5 + i] - block[8 * 3 + i];
179 z11 = block[8 * 1 + i] + block[8 * 7 + i];
180 z12 = block[8 * 1 + i] - block[8 * 7 + i];
183 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
185 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
186 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
187 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
193 temp[8 * 0 + i] = tmp0 + tmp7;
194 temp[8 * 7 + i] = tmp0 - tmp7;
195 temp[8 * 1 + i] = tmp1 + tmp6;
196 temp[8 * 6 + i] = tmp1 - tmp6;
197 temp[8 * 2 + i] = tmp2 + tmp5;
198 temp[8 * 5 + i] = tmp2 - tmp5;
199 temp[8 * 4 + i] = tmp3 + tmp4;
200 temp[8 * 3 + i] = tmp3 - tmp4;
203 for (i = 0; i < 8 * 8; i += 8) {
204 tmp10 = temp[0 + i] + temp[4 + i];
205 tmp11 = temp[0 + i] - temp[4 + i];
207 tmp13 = temp[2 + i] + temp[6 + i];
208 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
210 tmp0 = tmp10 + tmp13;
211 tmp3 = tmp10 - tmp13;
212 tmp1 = tmp11 + tmp12;
213 tmp2 = tmp11 - tmp12;
215 z13 = temp[5 + i] + temp[3 + i];
216 z10 = temp[5 + i] - temp[3 + i];
217 z11 = temp[1 + i] + temp[7 + i];
218 z12 = temp[1 + i] - temp[7 + i];
221 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
223 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
224 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
225 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
231 block[0 + i] = (tmp0 + tmp7) >> 6;
232 block[7 + i] = (tmp0 - tmp7) >> 6;
233 block[1 + i] = (tmp1 + tmp6) >> 6;
234 block[6 + i] = (tmp1 - tmp6) >> 6;
235 block[2 + i] = (tmp2 + tmp5) >> 6;
236 block[5 + i] = (tmp2 - tmp5) >> 6;
237 block[4 + i] = (tmp3 + tmp4) >> 6;
238 block[3 + i] = (tmp3 - tmp4) >> 6;
242 static av_cold void init_vlcs(FourXContext *f)
244 static VLC_TYPE table[2][4][32][2];
247 for (i = 0; i < 2; i++) {
248 for (j = 0; j < 4; j++) {
249 block_type_vlc[i][j].table = table[i][j];
250 block_type_vlc[i][j].table_allocated = 32;
251 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
252 &block_type_tab[i][j][0][1], 2, 1,
253 &block_type_tab[i][j][0][0], 2, 1,
254 INIT_VLC_USE_NEW_STATIC);
259 static void init_mv(FourXContext *f, int linesize)
263 for (i = 0; i < 256; i++) {
265 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
267 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
274 unsigned tmpval = AV_RN32(src); \
275 tmpval = (tmpval << 16) | (tmpval >> 16); \
276 tmpval = tmpval * (scale) + (dc); \
277 tmpval = (tmpval << 16) | (tmpval >> 16); \
278 AV_WN32A(dst, tmpval); \
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
283 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284 AV_WN32A(dst, tmpval); \
288 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
289 int h, int stride, int scale, unsigned dc)
296 for (i = 0; i < h; i++) {
297 dst[0] = scale * src[0] + dc;
304 for (i = 0; i < h; i++) {
305 LE_CENTRIC_MUL(dst, src, scale, dc);
312 for (i = 0; i < h; i++) {
313 LE_CENTRIC_MUL(dst, src, scale, dc);
314 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321 for (i = 0; i < h; i++) {
322 LE_CENTRIC_MUL(dst, src, scale, dc);
323 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
324 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
325 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
336 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
337 int log2w, int log2h, int stride)
339 const int index = size2index[log2h][log2w];
340 const int h = 1 << log2h;
341 int code = get_vlc2(&f->gb,
342 block_type_vlc[1 - (f->version > 1)][index].table,
343 BLOCK_TYPE_VLC_BITS, 1);
344 uint16_t *start = (uint16_t *)f->last_picture->data[0];
345 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
347 av_assert2(code >= 0 && code <= 6);
350 if (bytestream2_get_bytes_left(&f->g) < 1) {
351 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
354 src += f->mv[bytestream2_get_byteu(&f->g)];
355 if (start > src || src > end) {
356 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
359 mcdc(dst, src, log2w, h, stride, 1, 0);
360 } else if (code == 1) {
362 decode_p_block(f, dst, src, log2w, log2h, stride);
363 decode_p_block(f, dst + (stride << log2h),
364 src + (stride << log2h), log2w, log2h, stride);
365 } else if (code == 2) {
367 decode_p_block(f, dst , src, log2w, log2h, stride);
368 decode_p_block(f, dst + (1 << log2w),
369 src + (1 << log2w), log2w, log2h, stride);
370 } else if (code == 3 && f->version < 2) {
371 mcdc(dst, src, log2w, h, stride, 1, 0);
372 } else if (code == 4) {
373 if (bytestream2_get_bytes_left(&f->g) < 1) {
374 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
377 src += f->mv[bytestream2_get_byteu(&f->g)];
378 if (start > src || src > end) {
379 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
382 if (bytestream2_get_bytes_left(&f->g2) < 2){
383 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
386 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->g2));
387 } else if (code == 5) {
388 if (bytestream2_get_bytes_left(&f->g2) < 2) {
389 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
392 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->g2));
393 } else if (code == 6) {
394 if (bytestream2_get_bytes_left(&f->g2) < 4) {
395 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
399 dst[0] = bytestream2_get_le16u(&f->g2);
400 dst[1] = bytestream2_get_le16u(&f->g2);
402 dst[0] = bytestream2_get_le16u(&f->g2);
403 dst[stride] = bytestream2_get_le16u(&f->g2);
408 static int decode_p_frame(FourXContext *f, AVFrame *frame,
409 const uint8_t *buf, int length)
412 const int width = f->avctx->width;
413 const int height = f->avctx->height;
414 uint16_t *src = (uint16_t *)f->last_picture->data[0];
415 uint16_t *dst = (uint16_t *)frame->data[0];
416 const int stride = frame->linesize[0] >> 1;
417 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
418 bytestream_offset, wordstream_offset;
420 if (f->version > 1) {
424 bitstream_size = AV_RL32(buf + 8);
425 wordstream_size = AV_RL32(buf + 12);
426 bytestream_size = AV_RL32(buf + 16);
429 bitstream_size = AV_RL16(buf - 4);
430 wordstream_size = AV_RL16(buf - 2);
431 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
434 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
435 bytestream_size > length - bitstream_size ||
436 wordstream_size > length - bytestream_size - bitstream_size ||
437 extra > length - bytestream_size - bitstream_size - wordstream_size) {
438 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
439 bitstream_size+ bytestream_size+ wordstream_size - length);
440 return AVERROR_INVALIDDATA;
443 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
444 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
445 if (!f->bitstream_buffer)
446 return AVERROR(ENOMEM);
447 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
449 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
450 0, FF_INPUT_BUFFER_PADDING_SIZE);
451 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
453 wordstream_offset = extra + bitstream_size;
454 bytestream_offset = extra + bitstream_size + wordstream_size;
455 bytestream2_init(&f->g2, buf + wordstream_offset,
456 length - wordstream_offset);
457 bytestream2_init(&f->g, buf + bytestream_offset,
458 length - bytestream_offset);
460 init_mv(f, frame->linesize[0]);
462 for (y = 0; y < height; y += 8) {
463 for (x = 0; x < width; x += 8)
464 decode_p_block(f, dst + x, src + x, 3, 3, stride);
473 * decode block and dequantize.
474 * Note this is almost identical to MJPEG.
476 static int decode_i_block(FourXContext *f, int16_t *block)
478 int code, i, j, level, val;
480 if (get_bits_left(&f->gb) < 2){
481 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
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, int buf_size)
587 int frequency[512] = { 0 };
590 uint8_t len_tab[257];
593 const uint8_t *ptr = buf;
594 const uint8_t *ptr_end = buf + buf_size;
597 memset(up, -1, sizeof(up));
604 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
605 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
608 for (i = start; i <= end; i++)
609 frequency[i] = *ptr++;
618 while ((ptr - buf) & 3)
619 ptr++; // 4byte align
622 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
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, AVFrame *frame, 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 = (uint16_t*)frame->data[0];
694 const int stride = frame->linesize[0]>>1;
695 const uint8_t *buf_end = buf + length;
698 if (length < mbs * 8) {
699 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
700 return AVERROR_INVALIDDATA;
702 bytestream2_init(&g3, buf, length);
704 for (y = 0; y < height; y += 16) {
705 for (x = 0; x < width; x += 16) {
706 unsigned int color[4] = { 0 }, bits;
707 if (buf_end - buf < 8)
709 // warning following is purely guessed ...
710 color[0] = bytestream2_get_le16u(&g3);
711 color[1] = bytestream2_get_le16u(&g3);
713 if (color[0] & 0x8000)
714 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
715 if (color[1] & 0x8000)
716 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
718 color[2] = mix(color[0], color[1]);
719 color[3] = mix(color[1], color[0]);
721 bits = bytestream2_get_le32u(&g3);
722 for (y2 = 0; y2 < 16; y2++) {
723 for (x2 = 0; x2 < 16; x2++) {
724 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
725 dst[y2 * stride + x2] = color[(bits >> index) & 3];
730 dst += 16 * stride - x;
736 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
739 const int width = f->avctx->width;
740 const int height = f->avctx->height;
741 const unsigned int bitstream_size = AV_RL32(buf);
742 unsigned int prestream_size;
743 const uint8_t *prestream;
745 if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
746 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
747 return AVERROR_INVALIDDATA;
750 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
751 prestream = buf + bitstream_size + 12;
753 if (prestream_size + bitstream_size + 12 != length
754 || bitstream_size > (1 << 26)
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, buf + length - prestream);
763 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
764 return AVERROR_INVALIDDATA;
767 av_assert0(prestream <= buf + length);
769 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
771 prestream_size = length + buf - prestream;
773 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
774 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
775 if (!f->bitstream_buffer)
776 return AVERROR(ENOMEM);
777 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
779 memset((uint8_t*)f->bitstream_buffer + prestream_size,
780 0, FF_INPUT_BUFFER_PADDING_SIZE);
781 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
783 f->last_dc = 0 * 128 * 8 * 8;
785 for (y = 0; y < height; y += 16) {
786 for (x = 0; x < width; x += 16) {
787 if ((ret = decode_i_mb(f)) < 0)
790 idct_put(f, frame, x, y);
794 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
795 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
800 static int decode_frame(AVCodecContext *avctx, void *data,
801 int *got_frame, AVPacket *avpkt)
803 const uint8_t *buf = avpkt->data;
804 int buf_size = avpkt->size;
805 FourXContext *const f = avctx->priv_data;
806 AVFrame *picture = data;
807 int i, frame_4cc, frame_size, ret;
810 return AVERROR_INVALIDDATA;
811 frame_4cc = AV_RL32(buf);
812 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
813 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
814 buf_size, AV_RL32(buf + 4));
816 if (frame_4cc == AV_RL32("cfrm")) {
818 const int data_size = buf_size - 20;
819 const int id = AV_RL32(buf + 12);
820 const int whole_size = AV_RL32(buf + 16);
823 if (data_size < 0 || whole_size < 0) {
824 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
825 return AVERROR_INVALIDDATA;
828 if (f->version <= 1) {
829 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
830 return AVERROR_INVALIDDATA;
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 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
852 return AVERROR_INVALIDDATA;
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
858 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
859 return AVERROR(ENOMEM);
862 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
863 cfrm->size += data_size;
865 if (cfrm->size >= whole_size) {
867 frame_size = cfrm->size;
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);
873 cfrm->size = cfrm->id = 0;
874 frame_4cc = AV_RL32("pfrm");
879 frame_size = buf_size - 12;
882 FFSWAP(AVFrame*, f->current_picture, f->last_picture);
884 // alternatively we would have to use our own buffer management
885 avctx->flags |= CODEC_FLAG_EMU_EDGE;
887 if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
890 if (frame_4cc == AV_RL32("ifr2")) {
891 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
892 if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
893 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
896 } else if (frame_4cc == AV_RL32("ifrm")) {
897 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
898 if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
899 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
902 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
903 if (!f->last_picture->data[0]) {
904 if ((ret = ff_get_buffer(avctx, f->last_picture,
905 AV_GET_BUFFER_FLAG_REF)) < 0)
907 for (i=0; i<avctx->height; i++)
908 memset(f->last_picture->data[0] + i*f->last_picture->linesize[0], 0, 2*avctx->width);
911 f->current_picture->pict_type = AV_PICTURE_TYPE_P;
912 if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
913 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
916 } else if (frame_4cc == AV_RL32("snd_")) {
917 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
920 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
924 f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
926 if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
935 static av_cold int decode_init(AVCodecContext *avctx)
937 FourXContext * const f = avctx->priv_data;
939 if (avctx->extradata_size != 4 || !avctx->extradata) {
940 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
941 return AVERROR_INVALIDDATA;
943 if((avctx->width % 16) || (avctx->height % 16)) {
944 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
945 return AVERROR_INVALIDDATA;
948 f->version = AV_RL32(avctx->extradata) >> 16;
949 ff_dsputil_init(&f->dsp, avctx);
954 avctx->pix_fmt = AV_PIX_FMT_RGB565;
956 avctx->pix_fmt = AV_PIX_FMT_BGR555;
958 f->current_picture = av_frame_alloc();
959 f->last_picture = av_frame_alloc();
960 if (!f->current_picture || !f->last_picture)
961 return AVERROR(ENOMEM);
967 static av_cold int decode_end(AVCodecContext *avctx)
969 FourXContext * const f = avctx->priv_data;
972 av_freep(&f->bitstream_buffer);
973 f->bitstream_buffer_size = 0;
974 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
975 av_freep(&f->cfrm[i].data);
976 f->cfrm[i].allocated_size = 0;
978 ff_free_vlc(&f->pre_vlc);
979 av_frame_free(&f->current_picture);
980 av_frame_free(&f->last_picture);
985 AVCodec ff_fourxm_decoder = {
987 .type = AVMEDIA_TYPE_VIDEO,
988 .id = AV_CODEC_ID_4XM,
989 .priv_data_size = sizeof(FourXContext),
992 .decode = decode_frame,
993 .capabilities = CODEC_CAP_DR1,
994 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),