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 int 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);
350 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
354 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
356 return decode_p_block(f, dst + (stride << log2h),
357 src + (stride << log2h),
358 log2w, log2h, stride);
359 } else if (code == 2) {
361 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
363 return decode_p_block(f, dst + (1 << log2w),
365 log2w, log2h, stride);
366 } else if (code == 6) {
367 if (bytestream2_get_bytes_left(&f->g2) < 4) {
368 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
369 return AVERROR_INVALIDDATA;
372 dst[0] = bytestream2_get_le16u(&f->g2);
373 dst[1] = bytestream2_get_le16u(&f->g2);
375 dst[0] = bytestream2_get_le16u(&f->g2);
376 dst[stride] = bytestream2_get_le16u(&f->g2);
381 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
382 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
383 return AVERROR_INVALIDDATA;
387 src += f->mv[bytestream2_get_byte(&f->g)];
388 } else if (code == 3 && f->version >= 2) {
390 } else if (code == 4) {
391 src += f->mv[bytestream2_get_byte(&f->g)];
392 if (bytestream2_get_bytes_left(&f->g2) < 2){
393 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
394 return AVERROR_INVALIDDATA;
396 dc = bytestream2_get_le16(&f->g2);
397 } else if (code == 5) {
398 if (bytestream2_get_bytes_left(&f->g2) < 2){
399 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
400 return AVERROR_INVALIDDATA;
402 av_assert0(start <= src && src <= end);
404 dc = bytestream2_get_le16(&f->g2);
407 if (start > src || src > end) {
408 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
409 return AVERROR_INVALIDDATA;
412 mcdc(dst, src, log2w, h, stride, scale, dc);
417 static int decode_p_frame(FourXContext *f, AVFrame *frame,
418 const uint8_t *buf, int length)
421 const int width = f->avctx->width;
422 const int height = f->avctx->height;
423 uint16_t *dst = (uint16_t *)frame->data[0];
424 const int stride = frame->linesize[0] >> 1;
426 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427 bytestream_offset, wordstream_offset;
430 if (!f->last_picture->data[0]) {
431 if ((ret = ff_get_buffer(f->avctx, f->last_picture,
432 AV_GET_BUFFER_FLAG_REF)) < 0) {
435 for (y=0; y<f->avctx->height; y++)
436 memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);
439 src = (uint16_t *)f->last_picture->data[0];
441 if (f->version > 1) {
444 return AVERROR_INVALIDDATA;
445 bitstream_size = AV_RL32(buf + 8);
446 wordstream_size = AV_RL32(buf + 12);
447 bytestream_size = AV_RL32(buf + 16);
450 bitstream_size = AV_RL16(buf - 4);
451 wordstream_size = AV_RL16(buf - 2);
452 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
455 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
456 bytestream_size > length - bitstream_size ||
457 wordstream_size > length - bytestream_size - bitstream_size ||
458 extra > length - bytestream_size - bitstream_size - wordstream_size) {
459 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
460 bitstream_size+ bytestream_size+ wordstream_size - length);
461 return AVERROR_INVALIDDATA;
464 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
466 if (!f->bitstream_buffer)
467 return AVERROR(ENOMEM);
468 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
470 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
472 wordstream_offset = extra + bitstream_size;
473 bytestream_offset = extra + bitstream_size + wordstream_size;
474 bytestream2_init(&f->g2, buf + wordstream_offset,
475 length - wordstream_offset);
476 bytestream2_init(&f->g, buf + bytestream_offset,
477 length - bytestream_offset);
479 init_mv(f, frame->linesize[0]);
481 for (y = 0; y < height; y += 8) {
482 for (x = 0; x < width; x += 8)
483 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
493 * decode block and dequantize.
494 * Note this is almost identical to MJPEG.
496 static int decode_i_block(FourXContext *f, int16_t *block)
498 int code, i, j, level, val;
500 if (get_bits_left(&f->gb) < 2){
501 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
506 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
508 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
509 return AVERROR_INVALIDDATA;
513 val = get_xbits(&f->gb, val);
515 val = val * dequant_table[0] + f->last_dc;
516 f->last_dc = block[0] = val;
520 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
529 level = get_xbits(&f->gb, code & 0xf);
531 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
532 return AVERROR_INVALIDDATA;
536 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
540 j = ff_zigzag_direct[i];
541 block[j] = level * dequant_table[j];
551 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
553 int16_t (*block)[64] = f->block;
554 int stride = frame->linesize[0] >> 1;
556 uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
558 for (i = 0; i < 4; i++) {
559 block[i][0] += 0x80 * 8 * 8;
563 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
564 for (i = 4; i < 6; i++)
568 /* Note transform is:
569 * y = ( 1b + 4g + 2r) / 14
570 * cb = ( 3b - 2g - 1r) / 14
571 * cr = (-1b - 4g + 5r) / 14 */
572 for (y = 0; y < 8; y++) {
573 for (x = 0; x < 8; x++) {
574 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
575 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
576 int cb = block[4][x + 8 * y];
577 int cr = block[5][x + 8 * y];
578 int cg = (cb + cr) >> 1;
584 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593 dst += 2 * stride - 2 * 8;
597 static int decode_i_mb(FourXContext *f)
602 f->dsp.clear_blocks(f->block[0]);
604 for (i = 0; i < 6; i++)
605 if ((ret = decode_i_block(f, f->block[i])) < 0)
611 static const uint8_t *read_huffman_tables(FourXContext *f,
612 const uint8_t * const buf,
615 int frequency[512] = { 0 };
618 uint8_t len_tab[257];
621 const uint8_t *ptr = buf;
622 const uint8_t *ptr_end = buf + buf_size;
625 memset(up, -1, sizeof(up));
632 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
633 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
637 for (i = start; i <= end; i++)
638 frequency[i] = *ptr++;
647 while ((ptr - buf) & 3)
648 ptr++; // 4byte align
651 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
655 for (j = 257; j < 512; j++) {
656 int min_freq[2] = { 256 * 256, 256 * 256 };
657 int smallest[2] = { 0, 0 };
659 for (i = 0; i < j; i++) {
660 if (frequency[i] == 0)
662 if (frequency[i] < min_freq[1]) {
663 if (frequency[i] < min_freq[0]) {
664 min_freq[1] = min_freq[0];
665 smallest[1] = smallest[0];
666 min_freq[0] = frequency[i];
669 min_freq[1] = frequency[i];
674 if (min_freq[1] == 256 * 256)
677 frequency[j] = min_freq[0] + min_freq[1];
678 flag[smallest[0]] = 0;
679 flag[smallest[1]] = 1;
682 frequency[smallest[0]] = frequency[smallest[1]] = 0;
685 for (j = 0; j < 257; j++) {
686 int node, len = 0, bits = 0;
688 for (node = j; up[node] != -1; node = up[node]) {
689 bits += flag[node] << len;
692 // can this happen at all ?
693 av_log(f->avctx, AV_LOG_ERROR,
694 "vlc length overflow\n");
701 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
708 static int mix(int c0, int c1)
710 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
711 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
712 int red = 2 * (c0 >> 10) + (c1 >> 10);
713 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
716 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
719 const int width = f->avctx->width;
720 const int height = f->avctx->height;
721 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
722 uint16_t *dst = (uint16_t*)frame->data[0];
723 const int stride = frame->linesize[0]>>1;
724 const uint8_t *buf_end = buf + length;
727 if (length < mbs * 8) {
728 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
729 return AVERROR_INVALIDDATA;
731 bytestream2_init(&g3, buf, length);
733 for (y = 0; y < height; y += 16) {
734 for (x = 0; x < width; x += 16) {
735 unsigned int color[4] = { 0 }, bits;
736 if (buf_end - buf < 8)
738 // warning following is purely guessed ...
739 color[0] = bytestream2_get_le16u(&g3);
740 color[1] = bytestream2_get_le16u(&g3);
742 if (color[0] & 0x8000)
743 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
744 if (color[1] & 0x8000)
745 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
747 color[2] = mix(color[0], color[1]);
748 color[3] = mix(color[1], color[0]);
750 bits = bytestream2_get_le32u(&g3);
751 for (y2 = 0; y2 < 16; y2++) {
752 for (x2 = 0; x2 < 16; x2++) {
753 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
754 dst[y2 * stride + x2] = color[(bits >> index) & 3];
759 dst += 16 * stride - x;
765 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
768 const int width = f->avctx->width;
769 const int height = f->avctx->height;
770 const unsigned int bitstream_size = AV_RL32(buf);
771 unsigned int prestream_size;
772 const uint8_t *prestream;
774 if (bitstream_size > (1 << 26))
775 return AVERROR_INVALIDDATA;
777 if (length < bitstream_size + 12) {
778 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
779 return AVERROR_INVALIDDATA;
782 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
783 prestream = buf + bitstream_size + 12;
785 if (prestream_size + bitstream_size + 12 != length
786 || prestream_size > (1 << 26)) {
787 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
788 prestream_size, bitstream_size, length);
789 return AVERROR_INVALIDDATA;
792 prestream = read_huffman_tables(f, prestream, prestream_size);
794 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
795 return AVERROR_INVALIDDATA;
798 av_assert0(prestream <= buf + length);
800 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
802 prestream_size = length + buf - prestream;
804 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
806 if (!f->bitstream_buffer)
807 return AVERROR(ENOMEM);
808 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
810 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
812 f->last_dc = 0 * 128 * 8 * 8;
814 for (y = 0; y < height; y += 16) {
815 for (x = 0; x < width; x += 16) {
816 if ((ret = decode_i_mb(f)) < 0)
819 idct_put(f, frame, x, y);
823 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
824 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
829 static int decode_frame(AVCodecContext *avctx, void *data,
830 int *got_frame, AVPacket *avpkt)
832 const uint8_t *buf = avpkt->data;
833 int buf_size = avpkt->size;
834 FourXContext *const f = avctx->priv_data;
835 AVFrame *picture = data;
836 int i, frame_4cc, frame_size, ret;
839 return AVERROR_INVALIDDATA;
841 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
843 if (buf_size < AV_RL32(buf + 4) + 8) {
844 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
845 buf_size, AV_RL32(buf + 4));
846 return AVERROR_INVALIDDATA;
849 frame_4cc = AV_RL32(buf);
851 if (frame_4cc == AV_RL32("cfrm")) {
854 const int data_size = buf_size - 20;
857 if (f->version <= 1) {
858 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
859 return AVERROR_INVALIDDATA;
862 id = AV_RL32(buf + 12);
863 whole_size = AV_RL32(buf + 16);
865 if (data_size < 0 || whole_size < 0) {
866 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
867 return AVERROR_INVALIDDATA;
870 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
871 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
872 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
875 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
876 if (f->cfrm[i].id == id)
878 if (f->cfrm[i].size == 0)
882 if (i >= CFRAME_BUFFER_COUNT) {
888 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
889 return AVERROR_INVALIDDATA;
891 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
892 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
893 // explicit check needed as memcpy below might not catch a NULL
895 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
896 return AVERROR(ENOMEM);
899 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
900 cfrm->size += data_size;
902 if (cfrm->size >= whole_size) {
904 frame_size = cfrm->size;
906 if (id != avctx->frame_number)
907 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
908 id, avctx->frame_number);
911 return AVERROR_INVALIDDATA;
913 cfrm->size = cfrm->id = 0;
914 frame_4cc = AV_RL32("pfrm");
919 frame_size = buf_size - 12;
922 FFSWAP(AVFrame*, f->current_picture, f->last_picture);
924 // alternatively we would have to use our own buffer management
925 avctx->flags |= CODEC_FLAG_EMU_EDGE;
927 if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
930 if (frame_4cc == AV_RL32("ifr2")) {
931 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
932 if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
933 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
936 } else if (frame_4cc == AV_RL32("ifrm")) {
937 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
938 if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
939 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
942 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
943 f->current_picture->pict_type = AV_PICTURE_TYPE_P;
944 if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
945 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
948 } else if (frame_4cc == AV_RL32("snd_")) {
949 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
952 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
956 f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
958 if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
967 static av_cold int decode_init(AVCodecContext *avctx)
969 FourXContext * const f = avctx->priv_data;
971 if (avctx->extradata_size != 4 || !avctx->extradata) {
972 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
973 return AVERROR_INVALIDDATA;
975 if((avctx->width % 16) || (avctx->height % 16)) {
976 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
977 return AVERROR_INVALIDDATA;
980 f->version = AV_RL32(avctx->extradata) >> 16;
981 ff_dsputil_init(&f->dsp, avctx);
986 avctx->pix_fmt = AV_PIX_FMT_RGB565;
988 avctx->pix_fmt = AV_PIX_FMT_BGR555;
990 f->current_picture = av_frame_alloc();
991 f->last_picture = av_frame_alloc();
992 if (!f->current_picture || !f->last_picture)
993 return AVERROR(ENOMEM);
999 static av_cold int decode_end(AVCodecContext *avctx)
1001 FourXContext * const f = avctx->priv_data;
1004 av_freep(&f->bitstream_buffer);
1005 f->bitstream_buffer_size = 0;
1006 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1007 av_freep(&f->cfrm[i].data);
1008 f->cfrm[i].allocated_size = 0;
1010 ff_free_vlc(&f->pre_vlc);
1011 av_frame_free(&f->current_picture);
1012 av_frame_free(&f->last_picture);
1017 AVCodec ff_fourxm_decoder = {
1019 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1020 .type = AVMEDIA_TYPE_VIDEO,
1021 .id = AV_CODEC_ID_4XM,
1022 .priv_data_size = sizeof(FourXContext),
1023 .init = decode_init,
1024 .close = decode_end,
1025 .decode = decode_frame,
1026 .capabilities = CODEC_CAP_DR1,