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) ((int)((var) * (unsigned)(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);
354 if (get_bits_left(&f->gb) < 1)
355 return AVERROR_INVALIDDATA;
357 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
358 BLOCK_TYPE_VLC_BITS, 1);
359 av_assert0(code >= 0 && code <= 6);
361 start = f->last_frame_buffer;
362 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
366 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
368 return decode_p_block(f, dst + (stride << log2h),
369 src + (stride << log2h),
370 log2w, log2h, stride);
371 } else if (code == 2) {
373 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
375 return decode_p_block(f, dst + (1 << log2w),
377 log2w, log2h, stride);
378 } else if (code == 6) {
379 if (bytestream2_get_bytes_left(&f->g2) < 4) {
380 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
381 return AVERROR_INVALIDDATA;
384 dst[0] = bytestream2_get_le16u(&f->g2);
385 dst[1] = bytestream2_get_le16u(&f->g2);
387 dst[0] = bytestream2_get_le16u(&f->g2);
388 dst[stride] = bytestream2_get_le16u(&f->g2);
393 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
394 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
395 return AVERROR_INVALIDDATA;
399 src += f->mv[bytestream2_get_byte(&f->g)];
400 } else if (code == 3 && f->version >= 2) {
402 } else if (code == 4) {
403 src += f->mv[bytestream2_get_byte(&f->g)];
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 dc = bytestream2_get_le16(&f->g2);
409 } else if (code == 5) {
410 if (bytestream2_get_bytes_left(&f->g2) < 2){
411 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
412 return AVERROR_INVALIDDATA;
414 av_assert0(start <= src && src <= end);
416 dc = bytestream2_get_le16(&f->g2);
419 if (start > src || src > end) {
420 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
421 return AVERROR_INVALIDDATA;
424 mcdc(dst, src, log2w, h, stride, scale, dc);
429 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
432 const int width = f->avctx->width;
433 const int height = f->avctx->height;
434 uint16_t *dst = f->frame_buffer;
436 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
437 bytestream_offset, wordstream_offset;
440 src = f->last_frame_buffer;
442 if (f->version > 1) {
445 return AVERROR_INVALIDDATA;
446 bitstream_size = AV_RL32(buf + 8);
447 wordstream_size = AV_RL32(buf + 12);
448 bytestream_size = AV_RL32(buf + 16);
451 bitstream_size = AV_RL16(buf - 4);
452 wordstream_size = AV_RL16(buf - 2);
453 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
456 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
457 bytestream_size > length - bitstream_size ||
458 wordstream_size > length - bytestream_size - bitstream_size ||
459 extra > length - bytestream_size - bitstream_size - wordstream_size) {
460 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
461 bitstream_size+ bytestream_size+ wordstream_size - length);
462 return AVERROR_INVALIDDATA;
465 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
467 if (!f->bitstream_buffer)
468 return AVERROR(ENOMEM);
469 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
471 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
473 wordstream_offset = extra + bitstream_size;
474 bytestream_offset = extra + bitstream_size + wordstream_size;
475 bytestream2_init(&f->g2, buf + wordstream_offset,
476 length - wordstream_offset);
477 bytestream2_init(&f->g, buf + bytestream_offset,
478 length - bytestream_offset);
480 init_mv(f, width * 2);
482 for (y = 0; y < height; y += 8) {
483 for (x = 0; x < width; x += 8)
484 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
494 * decode block and dequantize.
495 * Note this is almost identical to MJPEG.
497 static int decode_i_block(FourXContext *f, int16_t *block)
499 int code, i, j, level, val;
501 if (get_bits_left(&f->gb) < 2){
502 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
503 return AVERROR_INVALIDDATA;
507 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
509 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
510 return AVERROR_INVALIDDATA;
514 val = get_xbits(&f->gb, val);
516 val = val * dequant_table[0] + f->last_dc;
517 f->last_dc = block[0] = val;
521 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
529 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
534 level = get_xbits(&f->gb, code & 0xf);
536 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
537 return AVERROR_INVALIDDATA;
541 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
545 j = ff_zigzag_direct[i];
546 block[j] = level * dequant_table[j];
556 static inline void idct_put(FourXContext *f, int x, int y)
558 int16_t (*block)[64] = f->block;
559 int stride = f->avctx->width;
561 uint16_t *dst = f->frame_buffer + y * stride + x;
563 for (i = 0; i < 4; i++) {
564 block[i][0] += 0x80 * 8 * 8;
568 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
569 for (i = 4; i < 6; i++)
573 /* Note transform is:
574 * y = ( 1b + 4g + 2r) / 14
575 * cb = ( 3b - 2g - 1r) / 14
576 * cr = (-1b - 4g + 5r) / 14 */
577 for (y = 0; y < 8; y++) {
578 for (x = 0; x < 8; x++) {
579 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
580 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
581 int cb = block[4][x + 8 * y];
582 int cr = block[5][x + 8 * y];
583 int cg = (cb + cr) >> 1;
589 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
598 dst += 2 * stride - 2 * 8;
602 static int decode_i_mb(FourXContext *f)
607 f->bdsp.clear_blocks(f->block[0]);
609 for (i = 0; i < 6; i++)
610 if ((ret = decode_i_block(f, f->block[i])) < 0)
616 static const uint8_t *read_huffman_tables(FourXContext *f,
617 const uint8_t * const buf,
620 int frequency[512] = { 0 };
623 uint8_t len_tab[257];
626 const uint8_t *ptr = buf;
627 const uint8_t *ptr_end = buf + buf_size;
630 memset(up, -1, sizeof(up));
637 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
638 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
642 for (i = start; i <= end; i++)
643 frequency[i] = *ptr++;
652 while ((ptr - buf) & 3)
653 ptr++; // 4byte align
656 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
660 for (j = 257; j < 512; j++) {
661 int min_freq[2] = { 256 * 256, 256 * 256 };
662 int smallest[2] = { 0, 0 };
664 for (i = 0; i < j; i++) {
665 if (frequency[i] == 0)
667 if (frequency[i] < min_freq[1]) {
668 if (frequency[i] < min_freq[0]) {
669 min_freq[1] = min_freq[0];
670 smallest[1] = smallest[0];
671 min_freq[0] = frequency[i];
674 min_freq[1] = frequency[i];
679 if (min_freq[1] == 256 * 256)
682 frequency[j] = min_freq[0] + min_freq[1];
683 flag[smallest[0]] = 0;
684 flag[smallest[1]] = 1;
687 frequency[smallest[0]] = frequency[smallest[1]] = 0;
690 for (j = 0; j < 257; j++) {
691 int node, len = 0, bits = 0;
693 for (node = j; up[node] != -1; node = up[node]) {
694 bits += flag[node] << len;
697 // can this happen at all ?
698 av_log(f->avctx, AV_LOG_ERROR,
699 "vlc length overflow\n");
706 ff_free_vlc(&f->pre_vlc);
707 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
714 static int mix(int c0, int c1)
716 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
717 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
718 int red = 2 * (c0 >> 10) + (c1 >> 10);
719 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
722 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
725 const int width = f->avctx->width;
726 const int height = f->avctx->height;
727 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
728 uint16_t *dst = f->frame_buffer;
729 const uint8_t *buf_end = buf + length;
732 if (length < mbs * 8) {
733 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
734 return AVERROR_INVALIDDATA;
736 bytestream2_init(&g3, buf, length);
738 for (y = 0; y < height; y += 16) {
739 for (x = 0; x < width; x += 16) {
740 unsigned int color[4] = { 0 }, bits;
741 if (buf_end - buf < 8)
742 return AVERROR_INVALIDDATA;
743 // warning following is purely guessed ...
744 color[0] = bytestream2_get_le16u(&g3);
745 color[1] = bytestream2_get_le16u(&g3);
747 if (color[0] & 0x8000)
748 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
749 if (color[1] & 0x8000)
750 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
752 color[2] = mix(color[0], color[1]);
753 color[3] = mix(color[1], color[0]);
755 bits = bytestream2_get_le32u(&g3);
756 for (y2 = 0; y2 < 16; y2++) {
757 for (x2 = 0; x2 < 16; x2++) {
758 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
759 dst[y2 * width + x2] = color[(bits >> index) & 3];
764 dst += 16 * width - x;
770 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
773 const int width = f->avctx->width;
774 const int height = f->avctx->height;
775 const unsigned int bitstream_size = AV_RL32(buf);
776 unsigned int prestream_size;
777 const uint8_t *prestream;
779 if (bitstream_size > (1 << 26))
780 return AVERROR_INVALIDDATA;
782 if (length < bitstream_size + 12) {
783 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
784 return AVERROR_INVALIDDATA;
787 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
788 prestream = buf + bitstream_size + 12;
790 if (prestream_size + bitstream_size + 12 != length
791 || prestream_size > (1 << 26)) {
792 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
793 prestream_size, bitstream_size, length);
794 return AVERROR_INVALIDDATA;
797 prestream = read_huffman_tables(f, prestream, prestream_size);
799 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
800 return AVERROR_INVALIDDATA;
803 av_assert0(prestream <= buf + length);
805 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
807 prestream_size = length + buf - prestream;
809 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
811 if (!f->bitstream_buffer)
812 return AVERROR(ENOMEM);
813 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
815 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
817 f->last_dc = 0 * 128 * 8 * 8;
819 for (y = 0; y < height; y += 16) {
820 for (x = 0; x < width; x += 16) {
821 if ((ret = decode_i_mb(f)) < 0)
828 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
829 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
834 static int decode_frame(AVCodecContext *avctx, void *data,
835 int *got_frame, AVPacket *avpkt)
837 const uint8_t *buf = avpkt->data;
838 int buf_size = avpkt->size;
839 FourXContext *const f = avctx->priv_data;
840 AVFrame *picture = data;
841 int i, frame_4cc, frame_size, ret;
844 return AVERROR_INVALIDDATA;
846 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
848 if (buf_size < AV_RL32(buf + 4) + 8) {
849 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
850 buf_size, AV_RL32(buf + 4));
851 return AVERROR_INVALIDDATA;
854 frame_4cc = AV_RL32(buf);
856 if (frame_4cc == AV_RL32("cfrm")) {
859 const int data_size = buf_size - 20;
862 if (f->version <= 1) {
863 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
864 return AVERROR_INVALIDDATA;
867 id = AV_RL32(buf + 12);
868 whole_size = AV_RL32(buf + 16);
870 if (data_size < 0 || whole_size < 0) {
871 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
872 return AVERROR_INVALIDDATA;
875 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
876 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
877 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
880 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
881 if (f->cfrm[i].id == id)
883 if (f->cfrm[i].size == 0)
887 if (i >= CFRAME_BUFFER_COUNT) {
893 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
894 return AVERROR_INVALIDDATA;
896 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
897 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
898 // explicit check needed as memcpy below might not catch a NULL
900 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
901 return AVERROR(ENOMEM);
904 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
905 cfrm->size += data_size;
907 if (cfrm->size >= whole_size) {
909 frame_size = cfrm->size;
911 if (id != avctx->frame_number)
912 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
913 id, avctx->frame_number);
916 return AVERROR_INVALIDDATA;
918 cfrm->size = cfrm->id = 0;
919 frame_4cc = AV_RL32("pfrm");
924 frame_size = buf_size - 12;
927 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
930 if (frame_4cc == AV_RL32("ifr2")) {
931 picture->pict_type = AV_PICTURE_TYPE_I;
932 if ((ret = decode_i2_frame(f, 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 picture->pict_type = AV_PICTURE_TYPE_I;
938 if ((ret = decode_i_frame(f, 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 picture->pict_type = AV_PICTURE_TYPE_P;
944 if ((ret = decode_p_frame(f, 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 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
958 av_image_copy_plane(picture->data[0], picture->linesize[0],
959 (const uint8_t*)f->frame_buffer, avctx->width * 2,
960 avctx->width * 2, avctx->height);
961 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
970 static av_cold int decode_end(AVCodecContext *avctx)
972 FourXContext * const f = avctx->priv_data;
975 av_freep(&f->frame_buffer);
976 av_freep(&f->last_frame_buffer);
977 av_freep(&f->bitstream_buffer);
978 f->bitstream_buffer_size = 0;
979 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
980 av_freep(&f->cfrm[i].data);
981 f->cfrm[i].allocated_size = 0;
983 ff_free_vlc(&f->pre_vlc);
988 static av_cold int decode_init(AVCodecContext *avctx)
990 FourXContext * const f = avctx->priv_data;
993 if (avctx->extradata_size != 4 || !avctx->extradata) {
994 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
995 return AVERROR_INVALIDDATA;
997 if((avctx->width % 16) || (avctx->height % 16)) {
998 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
999 return AVERROR_INVALIDDATA;
1002 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1006 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1007 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1008 if (!f->frame_buffer || !f->last_frame_buffer) {
1010 return AVERROR(ENOMEM);
1013 f->version = AV_RL32(avctx->extradata) >> 16;
1014 ff_blockdsp_init(&f->bdsp, avctx);
1015 ff_bswapdsp_init(&f->bbdsp);
1020 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1022 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1027 AVCodec ff_fourxm_decoder = {
1029 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1030 .type = AVMEDIA_TYPE_VIDEO,
1031 .id = AV_CODEC_ID_4XM,
1032 .priv_data_size = sizeof(FourXContext),
1033 .init = decode_init,
1034 .close = decode_end,
1035 .decode = decode_frame,
1036 .capabilities = AV_CODEC_CAP_DR1,