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_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
465 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
466 if (!f->bitstream_buffer)
467 return AVERROR(ENOMEM);
468 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
470 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
471 0, FF_INPUT_BUFFER_PADDING_SIZE);
472 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
474 wordstream_offset = extra + bitstream_size;
475 bytestream_offset = extra + bitstream_size + wordstream_size;
476 bytestream2_init(&f->g2, buf + wordstream_offset,
477 length - wordstream_offset);
478 bytestream2_init(&f->g, buf + bytestream_offset,
479 length - bytestream_offset);
481 init_mv(f, frame->linesize[0]);
483 for (y = 0; y < height; y += 8) {
484 for (x = 0; x < width; x += 8)
485 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
495 * decode block and dequantize.
496 * Note this is almost identical to MJPEG.
498 static int decode_i_block(FourXContext *f, int16_t *block)
500 int code, i, j, level, val;
502 if (get_bits_left(&f->gb) < 2){
503 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
508 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
510 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
511 return AVERROR_INVALIDDATA;
515 val = get_xbits(&f->gb, val);
517 val = val * dequant_table[0] + f->last_dc;
518 f->last_dc = block[0] = val;
522 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
531 level = get_xbits(&f->gb, code & 0xf);
533 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
534 return AVERROR_INVALIDDATA;
538 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
542 j = ff_zigzag_direct[i];
543 block[j] = level * dequant_table[j];
553 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
555 int16_t (*block)[64] = f->block;
556 int stride = frame->linesize[0] >> 1;
558 uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
560 for (i = 0; i < 4; i++) {
561 block[i][0] += 0x80 * 8 * 8;
565 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
566 for (i = 4; i < 6; i++)
570 /* Note transform is:
571 * y = ( 1b + 4g + 2r) / 14
572 * cb = ( 3b - 2g - 1r) / 14
573 * cr = (-1b - 4g + 5r) / 14 */
574 for (y = 0; y < 8; y++) {
575 for (x = 0; x < 8; x++) {
576 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
577 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
578 int cb = block[4][x + 8 * y];
579 int cr = block[5][x + 8 * y];
580 int cg = (cb + cr) >> 1;
586 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595 dst += 2 * stride - 2 * 8;
599 static int decode_i_mb(FourXContext *f)
604 f->dsp.clear_blocks(f->block[0]);
606 for (i = 0; i < 6; i++)
607 if ((ret = decode_i_block(f, f->block[i])) < 0)
613 static const uint8_t *read_huffman_tables(FourXContext *f,
614 const uint8_t * const buf,
617 int frequency[512] = { 0 };
620 uint8_t len_tab[257];
623 const uint8_t *ptr = buf;
624 const uint8_t *ptr_end = buf + buf_size;
627 memset(up, -1, sizeof(up));
634 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
635 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
639 for (i = start; i <= end; i++)
640 frequency[i] = *ptr++;
649 while ((ptr - buf) & 3)
650 ptr++; // 4byte align
653 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
657 for (j = 257; j < 512; j++) {
658 int min_freq[2] = { 256 * 256, 256 * 256 };
659 int smallest[2] = { 0, 0 };
661 for (i = 0; i < j; i++) {
662 if (frequency[i] == 0)
664 if (frequency[i] < min_freq[1]) {
665 if (frequency[i] < min_freq[0]) {
666 min_freq[1] = min_freq[0];
667 smallest[1] = smallest[0];
668 min_freq[0] = frequency[i];
671 min_freq[1] = frequency[i];
676 if (min_freq[1] == 256 * 256)
679 frequency[j] = min_freq[0] + min_freq[1];
680 flag[smallest[0]] = 0;
681 flag[smallest[1]] = 1;
684 frequency[smallest[0]] = frequency[smallest[1]] = 0;
687 for (j = 0; j < 257; j++) {
688 int node, len = 0, bits = 0;
690 for (node = j; up[node] != -1; node = up[node]) {
691 bits += flag[node] << len;
694 // can this happen at all ?
695 av_log(f->avctx, AV_LOG_ERROR,
696 "vlc length overflow\n");
703 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
710 static int mix(int c0, int c1)
712 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
713 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
714 int red = 2 * (c0 >> 10) + (c1 >> 10);
715 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
718 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
721 const int width = f->avctx->width;
722 const int height = f->avctx->height;
723 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
724 uint16_t *dst = (uint16_t*)frame->data[0];
725 const int stride = frame->linesize[0]>>1;
726 const uint8_t *buf_end = buf + length;
729 if (length < mbs * 8) {
730 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
731 return AVERROR_INVALIDDATA;
733 bytestream2_init(&g3, buf, length);
735 for (y = 0; y < height; y += 16) {
736 for (x = 0; x < width; x += 16) {
737 unsigned int color[4] = { 0 }, bits;
738 if (buf_end - buf < 8)
740 // warning following is purely guessed ...
741 color[0] = bytestream2_get_le16u(&g3);
742 color[1] = bytestream2_get_le16u(&g3);
744 if (color[0] & 0x8000)
745 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
746 if (color[1] & 0x8000)
747 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
749 color[2] = mix(color[0], color[1]);
750 color[3] = mix(color[1], color[0]);
752 bits = bytestream2_get_le32u(&g3);
753 for (y2 = 0; y2 < 16; y2++) {
754 for (x2 = 0; x2 < 16; x2++) {
755 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
756 dst[y2 * stride + x2] = color[(bits >> index) & 3];
761 dst += 16 * stride - x;
767 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
770 const int width = f->avctx->width;
771 const int height = f->avctx->height;
772 const unsigned int bitstream_size = AV_RL32(buf);
773 unsigned int prestream_size;
774 const uint8_t *prestream;
776 if (bitstream_size > (1 << 26))
777 return AVERROR_INVALIDDATA;
779 if (length < bitstream_size + 12) {
780 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
781 return AVERROR_INVALIDDATA;
784 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
785 prestream = buf + bitstream_size + 12;
787 if (prestream_size + bitstream_size + 12 != length
788 || prestream_size > (1 << 26)) {
789 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
790 prestream_size, bitstream_size, length);
791 return AVERROR_INVALIDDATA;
794 prestream = read_huffman_tables(f, prestream, prestream_size);
796 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
797 return AVERROR_INVALIDDATA;
800 av_assert0(prestream <= buf + length);
802 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
804 prestream_size = length + buf - prestream;
806 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
807 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
808 if (!f->bitstream_buffer)
809 return AVERROR(ENOMEM);
810 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
812 memset((uint8_t*)f->bitstream_buffer + prestream_size,
813 0, FF_INPUT_BUFFER_PADDING_SIZE);
814 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
816 f->last_dc = 0 * 128 * 8 * 8;
818 for (y = 0; y < height; y += 16) {
819 for (x = 0; x < width; x += 16) {
820 if ((ret = decode_i_mb(f)) < 0)
823 idct_put(f, frame, x, y);
827 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
828 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
833 static int decode_frame(AVCodecContext *avctx, void *data,
834 int *got_frame, AVPacket *avpkt)
836 const uint8_t *buf = avpkt->data;
837 int buf_size = avpkt->size;
838 FourXContext *const f = avctx->priv_data;
839 AVFrame *picture = data;
840 int i, frame_4cc, frame_size, ret;
843 return AVERROR_INVALIDDATA;
845 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
847 if (buf_size < AV_RL32(buf + 4) + 8) {
848 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
849 buf_size, AV_RL32(buf + 4));
850 return AVERROR_INVALIDDATA;
853 frame_4cc = AV_RL32(buf);
855 if (frame_4cc == AV_RL32("cfrm")) {
858 const int data_size = buf_size - 20;
861 if (f->version <= 1) {
862 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
863 return AVERROR_INVALIDDATA;
866 id = AV_RL32(buf + 12);
867 whole_size = AV_RL32(buf + 16);
869 if (data_size < 0 || whole_size < 0) {
870 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
871 return AVERROR_INVALIDDATA;
874 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
875 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
876 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
879 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
880 if (f->cfrm[i].id == id)
882 if (f->cfrm[i].size == 0)
886 if (i >= CFRAME_BUFFER_COUNT) {
892 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
893 return AVERROR_INVALIDDATA;
895 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
896 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
897 // explicit check needed as memcpy below might not catch a NULL
899 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
900 return AVERROR(ENOMEM);
903 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
904 cfrm->size += data_size;
906 if (cfrm->size >= whole_size) {
908 frame_size = cfrm->size;
910 if (id != avctx->frame_number)
911 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
912 id, avctx->frame_number);
915 return AVERROR_INVALIDDATA;
917 cfrm->size = cfrm->id = 0;
918 frame_4cc = AV_RL32("pfrm");
923 frame_size = buf_size - 12;
926 FFSWAP(AVFrame*, f->current_picture, f->last_picture);
928 // alternatively we would have to use our own buffer management
929 avctx->flags |= CODEC_FLAG_EMU_EDGE;
931 if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
934 if (frame_4cc == AV_RL32("ifr2")) {
935 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
936 if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
937 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
940 } else if (frame_4cc == AV_RL32("ifrm")) {
941 f->current_picture->pict_type = AV_PICTURE_TYPE_I;
942 if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
943 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
946 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
947 f->current_picture->pict_type = AV_PICTURE_TYPE_P;
948 if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
949 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
952 } else if (frame_4cc == AV_RL32("snd_")) {
953 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
956 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
960 f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
962 if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
971 static av_cold int decode_init(AVCodecContext *avctx)
973 FourXContext * const f = avctx->priv_data;
975 if (avctx->extradata_size != 4 || !avctx->extradata) {
976 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
977 return AVERROR_INVALIDDATA;
979 if((avctx->width % 16) || (avctx->height % 16)) {
980 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
981 return AVERROR_INVALIDDATA;
984 f->version = AV_RL32(avctx->extradata) >> 16;
985 ff_dsputil_init(&f->dsp, avctx);
990 avctx->pix_fmt = AV_PIX_FMT_RGB565;
992 avctx->pix_fmt = AV_PIX_FMT_BGR555;
994 f->current_picture = av_frame_alloc();
995 f->last_picture = av_frame_alloc();
996 if (!f->current_picture || !f->last_picture)
997 return AVERROR(ENOMEM);
1003 static av_cold int decode_end(AVCodecContext *avctx)
1005 FourXContext * const f = avctx->priv_data;
1008 av_freep(&f->bitstream_buffer);
1009 f->bitstream_buffer_size = 0;
1010 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1011 av_freep(&f->cfrm[i].data);
1012 f->cfrm[i].allocated_size = 0;
1014 ff_free_vlc(&f->pre_vlc);
1015 av_frame_free(&f->current_picture);
1016 av_frame_free(&f->last_picture);
1021 AVCodec ff_fourxm_decoder = {
1023 .type = AVMEDIA_TYPE_VIDEO,
1024 .id = AV_CODEC_ID_4XM,
1025 .priv_data_size = sizeof(FourXContext),
1026 .init = decode_init,
1027 .close = decode_end,
1028 .decode = decode_frame,
1029 .capabilities = CODEC_CAP_DR1,
1030 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),