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
29 #include "libavutil/avassert.h"
30 #include "libavutil/frame.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/intreadwrite.h"
35 #include "bytestream.h"
41 #define BLOCK_TYPE_VLC_BITS 5
42 #define ACDC_VLC_BITS 9
44 #define CFRAME_BUFFER_COUNT 100
46 static const uint8_t block_type_tab[2][4][8][2] = {
48 { // { 8, 4, 2 } x { 8, 4, 2}
49 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
53 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
55 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
58 { // { 8, 4, 2 } x { 8, 4, 2}
59 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
63 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
65 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
70 static const uint8_t size2index[4][4] = {
77 static const int8_t mv[256][2] = {
78 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
79 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
80 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
81 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
82 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
83 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
84 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
85 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
86 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
87 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
88 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
89 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
90 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
91 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
92 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
93 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
94 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
95 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
96 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
97 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
98 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
99 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
100 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
101 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
102 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
103 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
104 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
105 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
106 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
107 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
108 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
109 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
112 /* This is simply the scaled down elementwise product of the standard JPEG
113 * quantizer table and the AAN premul table. */
114 static const uint8_t dequant_table[64] = {
115 16, 15, 13, 19, 24, 31, 28, 17,
116 17, 23, 25, 31, 36, 63, 45, 21,
117 18, 24, 27, 37, 52, 59, 49, 20,
118 16, 28, 34, 40, 60, 80, 51, 20,
119 18, 31, 48, 66, 68, 86, 56, 21,
120 19, 38, 56, 59, 64, 64, 48, 20,
121 27, 48, 55, 55, 56, 51, 35, 15,
122 20, 35, 34, 32, 31, 22, 15, 8,
125 static VLC block_type_vlc[2][4];
128 typedef struct CFrameBuffer {
129 unsigned int allocated_size;
135 typedef struct FourXContext {
136 AVCodecContext *avctx;
138 BlockDSPContext bdsp;
139 uint16_t *frame_buffer;
140 uint16_t *last_frame_buffer;
141 GetBitContext pre_gb; ///< ac/dc prefix
148 DECLARE_ALIGNED(16, int16_t, block)[6][64];
149 void *bitstream_buffer;
150 unsigned int bitstream_buffer_size;
152 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
156 #define FIX_1_082392200 70936
157 #define FIX_1_414213562 92682
158 #define FIX_1_847759065 121095
159 #define FIX_2_613125930 171254
161 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
163 static void idct(int16_t block[64])
165 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
166 int tmp10, tmp11, tmp12, tmp13;
167 int z5, z10, z11, z12, z13;
171 for (i = 0; i < 8; i++) {
172 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
173 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
175 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
176 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
178 tmp0 = tmp10 + tmp13;
179 tmp3 = tmp10 - tmp13;
180 tmp1 = tmp11 + tmp12;
181 tmp2 = tmp11 - tmp12;
183 z13 = block[8 * 5 + i] + block[8 * 3 + i];
184 z10 = block[8 * 5 + i] - block[8 * 3 + i];
185 z11 = block[8 * 1 + i] + block[8 * 7 + i];
186 z12 = block[8 * 1 + i] - block[8 * 7 + i];
189 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
191 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
192 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
193 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
199 temp[8 * 0 + i] = tmp0 + tmp7;
200 temp[8 * 7 + i] = tmp0 - tmp7;
201 temp[8 * 1 + i] = tmp1 + tmp6;
202 temp[8 * 6 + i] = tmp1 - tmp6;
203 temp[8 * 2 + i] = tmp2 + tmp5;
204 temp[8 * 5 + i] = tmp2 - tmp5;
205 temp[8 * 4 + i] = tmp3 + tmp4;
206 temp[8 * 3 + i] = tmp3 - tmp4;
209 for (i = 0; i < 8 * 8; i += 8) {
210 tmp10 = temp[0 + i] + temp[4 + i];
211 tmp11 = temp[0 + i] - temp[4 + i];
213 tmp13 = temp[2 + i] + temp[6 + i];
214 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
216 tmp0 = tmp10 + tmp13;
217 tmp3 = tmp10 - tmp13;
218 tmp1 = tmp11 + tmp12;
219 tmp2 = tmp11 - tmp12;
221 z13 = temp[5 + i] + temp[3 + i];
222 z10 = temp[5 + i] - temp[3 + i];
223 z11 = temp[1 + i] + temp[7 + i];
224 z12 = temp[1 + i] - temp[7 + i];
227 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
229 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
230 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
231 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
237 block[0 + i] = (tmp0 + tmp7) >> 6;
238 block[7 + i] = (tmp0 - tmp7) >> 6;
239 block[1 + i] = (tmp1 + tmp6) >> 6;
240 block[6 + i] = (tmp1 - tmp6) >> 6;
241 block[2 + i] = (tmp2 + tmp5) >> 6;
242 block[5 + i] = (tmp2 - tmp5) >> 6;
243 block[4 + i] = (tmp3 + tmp4) >> 6;
244 block[3 + i] = (tmp3 - tmp4) >> 6;
248 static av_cold void init_vlcs(FourXContext *f)
250 static VLC_TYPE table[2][4][32][2];
253 for (i = 0; i < 2; i++) {
254 for (j = 0; j < 4; j++) {
255 block_type_vlc[i][j].table = table[i][j];
256 block_type_vlc[i][j].table_allocated = 32;
257 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
258 &block_type_tab[i][j][0][1], 2, 1,
259 &block_type_tab[i][j][0][0], 2, 1,
260 INIT_VLC_USE_NEW_STATIC);
265 static void init_mv(FourXContext *f, int linesize)
269 for (i = 0; i < 256; i++) {
271 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
273 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
278 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
280 unsigned tmpval = AV_RN32(src); \
281 tmpval = (tmpval << 16) | (tmpval >> 16); \
282 tmpval = tmpval * (scale) + (dc); \
283 tmpval = (tmpval << 16) | (tmpval >> 16); \
284 AV_WN32A(dst, tmpval); \
287 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
289 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
290 AV_WN32A(dst, tmpval); \
294 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
295 int h, int stride, int scale, unsigned dc)
302 for (i = 0; i < h; i++) {
303 dst[0] = scale * src[0] + dc;
310 for (i = 0; i < h; i++) {
311 LE_CENTRIC_MUL(dst, src, scale, dc);
318 for (i = 0; i < h; i++) {
319 LE_CENTRIC_MUL(dst, src, scale, dc);
320 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
327 for (i = 0; i < h; i++) {
328 LE_CENTRIC_MUL(dst, src, scale, dc);
329 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
330 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
331 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
342 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
343 int log2w, int log2h, int stride)
345 const int index = size2index[log2h][log2w];
346 const int h = 1 << log2h;
347 int code = get_vlc2(&f->gb,
348 block_type_vlc[1 - (f->version > 1)][index].table,
349 BLOCK_TYPE_VLC_BITS, 1);
350 uint16_t *start = f->last_frame_buffer;
351 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
356 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
360 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
362 return decode_p_block(f, dst + (stride << log2h),
363 src + (stride << log2h),
364 log2w, log2h, stride);
365 } else if (code == 2) {
367 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
369 return decode_p_block(f, dst + (1 << log2w),
371 log2w, log2h, stride);
372 } else if (code == 6) {
373 if (bytestream2_get_bytes_left(&f->g2) < 4) {
374 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
375 return AVERROR_INVALIDDATA;
378 dst[0] = bytestream2_get_le16u(&f->g2);
379 dst[1] = bytestream2_get_le16u(&f->g2);
381 dst[0] = bytestream2_get_le16u(&f->g2);
382 dst[stride] = bytestream2_get_le16u(&f->g2);
387 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
388 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
389 return AVERROR_INVALIDDATA;
393 src += f->mv[bytestream2_get_byte(&f->g)];
394 } else if (code == 3 && f->version >= 2) {
396 } else if (code == 4) {
397 src += f->mv[bytestream2_get_byte(&f->g)];
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 dc = bytestream2_get_le16(&f->g2);
403 } else if (code == 5) {
404 if (bytestream2_get_bytes_left(&f->g2) < 2){
405 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
406 return AVERROR_INVALIDDATA;
408 av_assert0(start <= src && src <= end);
410 dc = bytestream2_get_le16(&f->g2);
413 if (start > src || src > end) {
414 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
415 return AVERROR_INVALIDDATA;
418 mcdc(dst, src, log2w, h, stride, scale, dc);
423 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
426 const int width = f->avctx->width;
427 const int height = f->avctx->height;
428 uint16_t *dst = f->frame_buffer;
430 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
431 bytestream_offset, wordstream_offset;
434 src = f->last_frame_buffer;
436 if (f->version > 1) {
439 return AVERROR_INVALIDDATA;
440 bitstream_size = AV_RL32(buf + 8);
441 wordstream_size = AV_RL32(buf + 12);
442 bytestream_size = AV_RL32(buf + 16);
445 bitstream_size = AV_RL16(buf - 4);
446 wordstream_size = AV_RL16(buf - 2);
447 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
450 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
451 bytestream_size > length - bitstream_size ||
452 wordstream_size > length - bytestream_size - bitstream_size ||
453 extra > length - bytestream_size - bitstream_size - wordstream_size) {
454 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
455 bitstream_size+ bytestream_size+ wordstream_size - length);
456 return AVERROR_INVALIDDATA;
459 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
461 if (!f->bitstream_buffer)
462 return AVERROR(ENOMEM);
463 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
465 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
467 wordstream_offset = extra + bitstream_size;
468 bytestream_offset = extra + bitstream_size + wordstream_size;
469 bytestream2_init(&f->g2, buf + wordstream_offset,
470 length - wordstream_offset);
471 bytestream2_init(&f->g, buf + bytestream_offset,
472 length - bytestream_offset);
474 init_mv(f, width * 2);
476 for (y = 0; y < height; y += 8) {
477 for (x = 0; x < width; x += 8)
478 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
488 * decode block and dequantize.
489 * Note this is almost identical to MJPEG.
491 static int decode_i_block(FourXContext *f, int16_t *block)
493 int code, i, j, level, val;
495 if (get_bits_left(&f->gb) < 2){
496 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
501 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
503 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
504 return AVERROR_INVALIDDATA;
508 val = get_xbits(&f->gb, val);
510 val = val * dequant_table[0] + f->last_dc;
511 f->last_dc = block[0] = val;
515 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
524 level = get_xbits(&f->gb, code & 0xf);
526 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
527 return AVERROR_INVALIDDATA;
531 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
535 j = ff_zigzag_direct[i];
536 block[j] = level * dequant_table[j];
546 static inline void idct_put(FourXContext *f, int x, int y)
548 int16_t (*block)[64] = f->block;
549 int stride = f->avctx->width;
551 uint16_t *dst = f->frame_buffer + y * stride + x;
553 for (i = 0; i < 4; i++) {
554 block[i][0] += 0x80 * 8 * 8;
558 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
559 for (i = 4; i < 6; i++)
563 /* Note transform is:
564 * y = ( 1b + 4g + 2r) / 14
565 * cb = ( 3b - 2g - 1r) / 14
566 * cr = (-1b - 4g + 5r) / 14 */
567 for (y = 0; y < 8; y++) {
568 for (x = 0; x < 8; x++) {
569 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
570 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
571 int cb = block[4][x + 8 * y];
572 int cr = block[5][x + 8 * y];
573 int cg = (cb + cr) >> 1;
579 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
581 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
583 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
585 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588 dst += 2 * stride - 2 * 8;
592 static int decode_i_mb(FourXContext *f)
597 f->bdsp.clear_blocks(f->block[0]);
599 for (i = 0; i < 6; i++)
600 if ((ret = decode_i_block(f, f->block[i])) < 0)
606 static const uint8_t *read_huffman_tables(FourXContext *f,
607 const uint8_t * const buf,
610 int frequency[512] = { 0 };
613 uint8_t len_tab[257];
616 const uint8_t *ptr = buf;
617 const uint8_t *ptr_end = buf + buf_size;
620 memset(up, -1, sizeof(up));
627 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
628 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
632 for (i = start; i <= end; i++)
633 frequency[i] = *ptr++;
642 while ((ptr - buf) & 3)
643 ptr++; // 4byte align
646 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
650 for (j = 257; j < 512; j++) {
651 int min_freq[2] = { 256 * 256, 256 * 256 };
652 int smallest[2] = { 0, 0 };
654 for (i = 0; i < j; i++) {
655 if (frequency[i] == 0)
657 if (frequency[i] < min_freq[1]) {
658 if (frequency[i] < min_freq[0]) {
659 min_freq[1] = min_freq[0];
660 smallest[1] = smallest[0];
661 min_freq[0] = frequency[i];
664 min_freq[1] = frequency[i];
669 if (min_freq[1] == 256 * 256)
672 frequency[j] = min_freq[0] + min_freq[1];
673 flag[smallest[0]] = 0;
674 flag[smallest[1]] = 1;
677 frequency[smallest[0]] = frequency[smallest[1]] = 0;
680 for (j = 0; j < 257; j++) {
681 int node, len = 0, bits = 0;
683 for (node = j; up[node] != -1; node = up[node]) {
684 bits += flag[node] << len;
687 // can this happen at all ?
688 av_log(f->avctx, AV_LOG_ERROR,
689 "vlc length overflow\n");
696 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
703 static int mix(int c0, int c1)
705 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
706 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
707 int red = 2 * (c0 >> 10) + (c1 >> 10);
708 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
711 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
714 const int width = f->avctx->width;
715 const int height = f->avctx->height;
716 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
717 uint16_t *dst = f->frame_buffer;
718 const uint8_t *buf_end = buf + length;
721 if (length < mbs * 8) {
722 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
723 return AVERROR_INVALIDDATA;
725 bytestream2_init(&g3, buf, length);
727 for (y = 0; y < height; y += 16) {
728 for (x = 0; x < width; x += 16) {
729 unsigned int color[4] = { 0 }, bits;
730 if (buf_end - buf < 8)
732 // warning following is purely guessed ...
733 color[0] = bytestream2_get_le16u(&g3);
734 color[1] = bytestream2_get_le16u(&g3);
736 if (color[0] & 0x8000)
737 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
738 if (color[1] & 0x8000)
739 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
741 color[2] = mix(color[0], color[1]);
742 color[3] = mix(color[1], color[0]);
744 bits = bytestream2_get_le32u(&g3);
745 for (y2 = 0; y2 < 16; y2++) {
746 for (x2 = 0; x2 < 16; x2++) {
747 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
748 dst[y2 * width + x2] = color[(bits >> index) & 3];
753 dst += 16 * width - x;
759 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
762 const int width = f->avctx->width;
763 const int height = f->avctx->height;
764 const unsigned int bitstream_size = AV_RL32(buf);
765 unsigned int prestream_size;
766 const uint8_t *prestream;
768 if (bitstream_size > (1 << 26))
769 return AVERROR_INVALIDDATA;
771 if (length < bitstream_size + 12) {
772 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
773 return AVERROR_INVALIDDATA;
776 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
777 prestream = buf + bitstream_size + 12;
779 if (prestream_size + bitstream_size + 12 != length
780 || prestream_size > (1 << 26)) {
781 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
782 prestream_size, bitstream_size, length);
783 return AVERROR_INVALIDDATA;
786 prestream = read_huffman_tables(f, prestream, prestream_size);
788 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
789 return AVERROR_INVALIDDATA;
792 av_assert0(prestream <= buf + length);
794 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
796 prestream_size = length + buf - prestream;
798 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
800 if (!f->bitstream_buffer)
801 return AVERROR(ENOMEM);
802 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
804 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
806 f->last_dc = 0 * 128 * 8 * 8;
808 for (y = 0; y < height; y += 16) {
809 for (x = 0; x < width; x += 16) {
810 if ((ret = decode_i_mb(f)) < 0)
817 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
818 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
823 static int decode_frame(AVCodecContext *avctx, void *data,
824 int *got_frame, AVPacket *avpkt)
826 const uint8_t *buf = avpkt->data;
827 int buf_size = avpkt->size;
828 FourXContext *const f = avctx->priv_data;
829 AVFrame *picture = data;
830 int i, frame_4cc, frame_size, ret;
833 return AVERROR_INVALIDDATA;
835 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
837 if (buf_size < AV_RL32(buf + 4) + 8) {
838 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
839 buf_size, AV_RL32(buf + 4));
840 return AVERROR_INVALIDDATA;
843 frame_4cc = AV_RL32(buf);
845 if (frame_4cc == AV_RL32("cfrm")) {
848 const int data_size = buf_size - 20;
851 if (f->version <= 1) {
852 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
853 return AVERROR_INVALIDDATA;
856 id = AV_RL32(buf + 12);
857 whole_size = AV_RL32(buf + 16);
859 if (data_size < 0 || whole_size < 0) {
860 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
861 return AVERROR_INVALIDDATA;
864 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
865 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
866 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
869 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
870 if (f->cfrm[i].id == id)
872 if (f->cfrm[i].size == 0)
876 if (i >= CFRAME_BUFFER_COUNT) {
882 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
883 return AVERROR_INVALIDDATA;
885 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
886 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
887 // explicit check needed as memcpy below might not catch a NULL
889 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
890 return AVERROR(ENOMEM);
893 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
894 cfrm->size += data_size;
896 if (cfrm->size >= whole_size) {
898 frame_size = cfrm->size;
900 if (id != avctx->frame_number)
901 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
902 id, avctx->frame_number);
905 return AVERROR_INVALIDDATA;
907 cfrm->size = cfrm->id = 0;
908 frame_4cc = AV_RL32("pfrm");
913 frame_size = buf_size - 12;
916 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
919 if (frame_4cc == AV_RL32("ifr2")) {
920 picture->pict_type = AV_PICTURE_TYPE_I;
921 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
922 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
925 } else if (frame_4cc == AV_RL32("ifrm")) {
926 picture->pict_type = AV_PICTURE_TYPE_I;
927 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
928 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
931 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
932 picture->pict_type = AV_PICTURE_TYPE_P;
933 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
934 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
937 } else if (frame_4cc == AV_RL32("snd_")) {
938 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
941 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
945 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
947 av_image_copy_plane(picture->data[0], picture->linesize[0],
948 (const uint8_t*)f->frame_buffer, avctx->width * 2,
949 avctx->width * 2, avctx->height);
950 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
959 static av_cold int decode_end(AVCodecContext *avctx)
961 FourXContext * const f = avctx->priv_data;
964 av_freep(&f->frame_buffer);
965 av_freep(&f->last_frame_buffer);
966 av_freep(&f->bitstream_buffer);
967 f->bitstream_buffer_size = 0;
968 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
969 av_freep(&f->cfrm[i].data);
970 f->cfrm[i].allocated_size = 0;
972 ff_free_vlc(&f->pre_vlc);
977 static av_cold int decode_init(AVCodecContext *avctx)
979 FourXContext * const f = avctx->priv_data;
982 if (avctx->extradata_size != 4 || !avctx->extradata) {
983 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
984 return AVERROR_INVALIDDATA;
986 if((avctx->width % 16) || (avctx->height % 16)) {
987 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
988 return AVERROR_INVALIDDATA;
991 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
995 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
996 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
997 if (!f->frame_buffer || !f->last_frame_buffer) {
999 return AVERROR(ENOMEM);
1002 f->version = AV_RL32(avctx->extradata) >> 16;
1003 ff_blockdsp_init(&f->bdsp, avctx);
1004 ff_dsputil_init(&f->dsp, avctx);
1009 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1011 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1016 AVCodec ff_fourxm_decoder = {
1018 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1019 .type = AVMEDIA_TYPE_VIDEO,
1020 .id = AV_CODEC_ID_4XM,
1021 .priv_data_size = sizeof(FourXContext),
1022 .init = decode_init,
1023 .close = decode_end,
1024 .decode = decode_frame,
1025 .capabilities = CODEC_CAP_DR1,