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"
36 #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;
137 BlockDSPContext bdsp;
138 BswapDSPContext bbdsp;
139 uint16_t *frame_buffer;
140 uint16_t *last_frame_buffer;
141 GetBitContext pre_gb; ///< ac/dc prefix
148 DECLARE_ALIGNED(32, 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, const uint16_t *src,
343 int log2w, int log2h, int stride)
345 int index, h, code, ret, scale = 1;
346 uint16_t *start, *end;
349 av_assert0(log2w >= 0 && log2h >= 0);
351 index = size2index[log2h][log2w];
352 av_assert0(index >= 0);
355 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
356 BLOCK_TYPE_VLC_BITS, 1);
357 av_assert0(code >= 0 && code <= 6);
359 start = f->last_frame_buffer;
360 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
364 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
366 return decode_p_block(f, dst + (stride << log2h),
367 src + (stride << log2h),
368 log2w, log2h, stride);
369 } else if (code == 2) {
371 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
373 return decode_p_block(f, dst + (1 << log2w),
375 log2w, log2h, stride);
376 } else if (code == 6) {
377 if (bytestream2_get_bytes_left(&f->g2) < 4) {
378 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
379 return AVERROR_INVALIDDATA;
382 dst[0] = bytestream2_get_le16u(&f->g2);
383 dst[1] = bytestream2_get_le16u(&f->g2);
385 dst[0] = bytestream2_get_le16u(&f->g2);
386 dst[stride] = bytestream2_get_le16u(&f->g2);
391 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
392 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
393 return AVERROR_INVALIDDATA;
397 src += f->mv[bytestream2_get_byte(&f->g)];
398 } else if (code == 3 && f->version >= 2) {
400 } else if (code == 4) {
401 src += f->mv[bytestream2_get_byte(&f->g)];
402 if (bytestream2_get_bytes_left(&f->g2) < 2){
403 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
404 return AVERROR_INVALIDDATA;
406 dc = bytestream2_get_le16(&f->g2);
407 } else if (code == 5) {
408 if (bytestream2_get_bytes_left(&f->g2) < 2){
409 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
410 return AVERROR_INVALIDDATA;
412 av_assert0(start <= src && src <= end);
414 dc = bytestream2_get_le16(&f->g2);
417 if (start > src || src > end) {
418 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
419 return AVERROR_INVALIDDATA;
422 mcdc(dst, src, log2w, h, stride, scale, dc);
427 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
430 const int width = f->avctx->width;
431 const int height = f->avctx->height;
432 uint16_t *dst = f->frame_buffer;
434 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
435 bytestream_offset, wordstream_offset;
438 src = f->last_frame_buffer;
440 if (f->version > 1) {
443 return AVERROR_INVALIDDATA;
444 bitstream_size = AV_RL32(buf + 8);
445 wordstream_size = AV_RL32(buf + 12);
446 bytestream_size = AV_RL32(buf + 16);
449 bitstream_size = AV_RL16(buf - 4);
450 wordstream_size = AV_RL16(buf - 2);
451 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
454 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
455 bytestream_size > length - bitstream_size ||
456 wordstream_size > length - bytestream_size - bitstream_size ||
457 extra > length - bytestream_size - bitstream_size - wordstream_size) {
458 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
459 bitstream_size+ bytestream_size+ wordstream_size - length);
460 return AVERROR_INVALIDDATA;
463 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
465 if (!f->bitstream_buffer)
466 return AVERROR(ENOMEM);
467 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
469 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
471 wordstream_offset = extra + bitstream_size;
472 bytestream_offset = extra + bitstream_size + wordstream_size;
473 bytestream2_init(&f->g2, buf + wordstream_offset,
474 length - wordstream_offset);
475 bytestream2_init(&f->g, buf + bytestream_offset,
476 length - bytestream_offset);
478 init_mv(f, width * 2);
480 for (y = 0; y < height; y += 8) {
481 for (x = 0; x < width; x += 8)
482 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
492 * decode block and dequantize.
493 * Note this is almost identical to MJPEG.
495 static int decode_i_block(FourXContext *f, int16_t *block)
497 int code, i, j, level, val;
499 if (get_bits_left(&f->gb) < 2){
500 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
501 return AVERROR_INVALIDDATA;
505 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
507 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
508 return AVERROR_INVALIDDATA;
512 val = get_xbits(&f->gb, val);
514 val = val * dequant_table[0] + f->last_dc;
515 f->last_dc = block[0] = val;
519 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
528 level = get_xbits(&f->gb, code & 0xf);
530 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
531 return AVERROR_INVALIDDATA;
535 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
539 j = ff_zigzag_direct[i];
540 block[j] = level * dequant_table[j];
550 static inline void idct_put(FourXContext *f, int x, int y)
552 int16_t (*block)[64] = f->block;
553 int stride = f->avctx->width;
555 uint16_t *dst = f->frame_buffer + y * stride + x;
557 for (i = 0; i < 4; i++) {
558 block[i][0] += 0x80 * 8 * 8;
562 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
563 for (i = 4; i < 6; i++)
567 /* Note transform is:
568 * y = ( 1b + 4g + 2r) / 14
569 * cb = ( 3b - 2g - 1r) / 14
570 * cr = (-1b - 4g + 5r) / 14 */
571 for (y = 0; y < 8; y++) {
572 for (x = 0; x < 8; x++) {
573 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
574 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
575 int cb = block[4][x + 8 * y];
576 int cr = block[5][x + 8 * y];
577 int cg = (cb + cr) >> 1;
583 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
585 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
587 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
589 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592 dst += 2 * stride - 2 * 8;
596 static int decode_i_mb(FourXContext *f)
601 f->bdsp.clear_blocks(f->block[0]);
603 for (i = 0; i < 6; i++)
604 if ((ret = decode_i_block(f, f->block[i])) < 0)
610 static const uint8_t *read_huffman_tables(FourXContext *f,
611 const uint8_t * const buf,
614 int frequency[512] = { 0 };
617 uint8_t len_tab[257];
620 const uint8_t *ptr = buf;
621 const uint8_t *ptr_end = buf + buf_size;
624 memset(up, -1, sizeof(up));
631 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
632 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
636 for (i = start; i <= end; i++)
637 frequency[i] = *ptr++;
646 while ((ptr - buf) & 3)
647 ptr++; // 4byte align
650 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
654 for (j = 257; j < 512; j++) {
655 int min_freq[2] = { 256 * 256, 256 * 256 };
656 int smallest[2] = { 0, 0 };
658 for (i = 0; i < j; i++) {
659 if (frequency[i] == 0)
661 if (frequency[i] < min_freq[1]) {
662 if (frequency[i] < min_freq[0]) {
663 min_freq[1] = min_freq[0];
664 smallest[1] = smallest[0];
665 min_freq[0] = frequency[i];
668 min_freq[1] = frequency[i];
673 if (min_freq[1] == 256 * 256)
676 frequency[j] = min_freq[0] + min_freq[1];
677 flag[smallest[0]] = 0;
678 flag[smallest[1]] = 1;
681 frequency[smallest[0]] = frequency[smallest[1]] = 0;
684 for (j = 0; j < 257; j++) {
685 int node, len = 0, bits = 0;
687 for (node = j; up[node] != -1; node = up[node]) {
688 bits += flag[node] << len;
691 // can this happen at all ?
692 av_log(f->avctx, AV_LOG_ERROR,
693 "vlc length overflow\n");
700 ff_free_vlc(&f->pre_vlc);
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, 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 = f->frame_buffer;
723 const uint8_t *buf_end = buf + length;
726 if (length < mbs * 8) {
727 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
728 return AVERROR_INVALIDDATA;
730 bytestream2_init(&g3, buf, length);
732 for (y = 0; y < height; y += 16) {
733 for (x = 0; x < width; x += 16) {
734 unsigned int color[4] = { 0 }, bits;
735 if (buf_end - buf < 8)
736 return AVERROR_INVALIDDATA;
737 // warning following is purely guessed ...
738 color[0] = bytestream2_get_le16u(&g3);
739 color[1] = bytestream2_get_le16u(&g3);
741 if (color[0] & 0x8000)
742 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
743 if (color[1] & 0x8000)
744 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
746 color[2] = mix(color[0], color[1]);
747 color[3] = mix(color[1], color[0]);
749 bits = bytestream2_get_le32u(&g3);
750 for (y2 = 0; y2 < 16; y2++) {
751 for (x2 = 0; x2 < 16; x2++) {
752 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
753 dst[y2 * width + x2] = color[(bits >> index) & 3];
758 dst += 16 * width - x;
764 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
767 const int width = f->avctx->width;
768 const int height = f->avctx->height;
769 const unsigned int bitstream_size = AV_RL32(buf);
770 unsigned int prestream_size;
771 const uint8_t *prestream;
773 if (bitstream_size > (1 << 26))
774 return AVERROR_INVALIDDATA;
776 if (length < bitstream_size + 12) {
777 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
778 return AVERROR_INVALIDDATA;
781 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
782 prestream = buf + bitstream_size + 12;
784 if (prestream_size + bitstream_size + 12 != length
785 || prestream_size > (1 << 26)) {
786 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
787 prestream_size, bitstream_size, length);
788 return AVERROR_INVALIDDATA;
791 prestream = read_huffman_tables(f, prestream, prestream_size);
793 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
794 return AVERROR_INVALIDDATA;
797 av_assert0(prestream <= buf + length);
799 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
801 prestream_size = length + buf - prestream;
803 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
805 if (!f->bitstream_buffer)
806 return AVERROR(ENOMEM);
807 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
809 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
811 f->last_dc = 0 * 128 * 8 * 8;
813 for (y = 0; y < height; y += 16) {
814 for (x = 0; x < width; x += 16) {
815 if ((ret = decode_i_mb(f)) < 0)
822 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
823 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
828 static int decode_frame(AVCodecContext *avctx, void *data,
829 int *got_frame, AVPacket *avpkt)
831 const uint8_t *buf = avpkt->data;
832 int buf_size = avpkt->size;
833 FourXContext *const f = avctx->priv_data;
834 AVFrame *picture = data;
835 int i, frame_4cc, frame_size, ret;
838 return AVERROR_INVALIDDATA;
840 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
842 if (buf_size < AV_RL32(buf + 4) + 8) {
843 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
844 buf_size, AV_RL32(buf + 4));
845 return AVERROR_INVALIDDATA;
848 frame_4cc = AV_RL32(buf);
850 if (frame_4cc == AV_RL32("cfrm")) {
853 const int data_size = buf_size - 20;
856 if (f->version <= 1) {
857 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
858 return AVERROR_INVALIDDATA;
861 id = AV_RL32(buf + 12);
862 whole_size = AV_RL32(buf + 16);
864 if (data_size < 0 || whole_size < 0) {
865 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
866 return AVERROR_INVALIDDATA;
869 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
870 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
871 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
874 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
875 if (f->cfrm[i].id == id)
877 if (f->cfrm[i].size == 0)
881 if (i >= CFRAME_BUFFER_COUNT) {
887 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
888 return AVERROR_INVALIDDATA;
890 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
891 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
892 // explicit check needed as memcpy below might not catch a NULL
894 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
895 return AVERROR(ENOMEM);
898 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
899 cfrm->size += data_size;
901 if (cfrm->size >= whole_size) {
903 frame_size = cfrm->size;
905 if (id != avctx->frame_number)
906 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
907 id, avctx->frame_number);
910 return AVERROR_INVALIDDATA;
912 cfrm->size = cfrm->id = 0;
913 frame_4cc = AV_RL32("pfrm");
918 frame_size = buf_size - 12;
921 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
924 if (frame_4cc == AV_RL32("ifr2")) {
925 picture->pict_type = AV_PICTURE_TYPE_I;
926 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
927 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
930 } else if (frame_4cc == AV_RL32("ifrm")) {
931 picture->pict_type = AV_PICTURE_TYPE_I;
932 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
933 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
936 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
937 picture->pict_type = AV_PICTURE_TYPE_P;
938 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
939 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
942 } else if (frame_4cc == AV_RL32("snd_")) {
943 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
946 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
950 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
952 av_image_copy_plane(picture->data[0], picture->linesize[0],
953 (const uint8_t*)f->frame_buffer, avctx->width * 2,
954 avctx->width * 2, avctx->height);
955 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
964 static av_cold int decode_end(AVCodecContext *avctx)
966 FourXContext * const f = avctx->priv_data;
969 av_freep(&f->frame_buffer);
970 av_freep(&f->last_frame_buffer);
971 av_freep(&f->bitstream_buffer);
972 f->bitstream_buffer_size = 0;
973 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
974 av_freep(&f->cfrm[i].data);
975 f->cfrm[i].allocated_size = 0;
977 ff_free_vlc(&f->pre_vlc);
982 static av_cold int decode_init(AVCodecContext *avctx)
984 FourXContext * const f = avctx->priv_data;
987 if (avctx->extradata_size != 4 || !avctx->extradata) {
988 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
989 return AVERROR_INVALIDDATA;
991 if((avctx->width % 16) || (avctx->height % 16)) {
992 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
993 return AVERROR_INVALIDDATA;
996 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1000 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1001 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1002 if (!f->frame_buffer || !f->last_frame_buffer) {
1004 return AVERROR(ENOMEM);
1007 f->version = AV_RL32(avctx->extradata) >> 16;
1008 ff_blockdsp_init(&f->bdsp, avctx);
1009 ff_bswapdsp_init(&f->bbdsp);
1014 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1016 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1021 AVCodec ff_fourxm_decoder = {
1023 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1024 .type = AVMEDIA_TYPE_VIDEO,
1025 .id = AV_CODEC_ID_4XM,
1026 .priv_data_size = sizeof(FourXContext),
1027 .init = decode_init,
1028 .close = decode_end,
1029 .decode = decode_frame,
1030 .capabilities = AV_CODEC_CAP_DR1,