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"
34 #include "bytestream.h"
40 #define BLOCK_TYPE_VLC_BITS 5
41 #define ACDC_VLC_BITS 9
43 #define CFRAME_BUFFER_COUNT 100
45 static const uint8_t block_type_tab[2][4][8][2] = {
47 { // { 8, 4, 2 } x { 8, 4, 2}
48 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
50 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
57 { // { 8, 4, 2 } x { 8, 4, 2}
58 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
69 static const uint8_t size2index[4][4] = {
76 static const int8_t mv[256][2] = {
77 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
78 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
79 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
80 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
81 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
82 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
83 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
84 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
85 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
86 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
87 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
88 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
89 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
90 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
91 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
92 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
93 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
94 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
95 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
96 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
97 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
98 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
99 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
100 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
101 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
102 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
103 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
104 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
105 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
106 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
107 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
108 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
111 /* This is simply the scaled down elementwise product of the standard JPEG
112 * quantizer table and the AAN premul table. */
113 static const uint8_t dequant_table[64] = {
114 16, 15, 13, 19, 24, 31, 28, 17,
115 17, 23, 25, 31, 36, 63, 45, 21,
116 18, 24, 27, 37, 52, 59, 49, 20,
117 16, 28, 34, 40, 60, 80, 51, 20,
118 18, 31, 48, 66, 68, 86, 56, 21,
119 19, 38, 56, 59, 64, 64, 48, 20,
120 27, 48, 55, 55, 56, 51, 35, 15,
121 20, 35, 34, 32, 31, 22, 15, 8,
124 static VLC block_type_vlc[2][4];
127 typedef struct CFrameBuffer {
128 unsigned int allocated_size;
134 typedef struct FourXContext {
135 AVCodecContext *avctx;
137 uint16_t *frame_buffer;
138 uint16_t *last_frame_buffer;
139 GetBitContext pre_gb; ///< ac/dc prefix
146 DECLARE_ALIGNED(16, int16_t, block)[6][64];
147 void *bitstream_buffer;
148 unsigned int bitstream_buffer_size;
150 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
154 #define FIX_1_082392200 70936
155 #define FIX_1_414213562 92682
156 #define FIX_1_847759065 121095
157 #define FIX_2_613125930 171254
159 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
161 static void idct(int16_t block[64])
163 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
164 int tmp10, tmp11, tmp12, tmp13;
165 int z5, z10, z11, z12, z13;
169 for (i = 0; i < 8; i++) {
170 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
171 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
173 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
174 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
176 tmp0 = tmp10 + tmp13;
177 tmp3 = tmp10 - tmp13;
178 tmp1 = tmp11 + tmp12;
179 tmp2 = tmp11 - tmp12;
181 z13 = block[8 * 5 + i] + block[8 * 3 + i];
182 z10 = block[8 * 5 + i] - block[8 * 3 + i];
183 z11 = block[8 * 1 + i] + block[8 * 7 + i];
184 z12 = block[8 * 1 + i] - block[8 * 7 + i];
187 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
189 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
190 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
191 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
197 temp[8 * 0 + i] = tmp0 + tmp7;
198 temp[8 * 7 + i] = tmp0 - tmp7;
199 temp[8 * 1 + i] = tmp1 + tmp6;
200 temp[8 * 6 + i] = tmp1 - tmp6;
201 temp[8 * 2 + i] = tmp2 + tmp5;
202 temp[8 * 5 + i] = tmp2 - tmp5;
203 temp[8 * 4 + i] = tmp3 + tmp4;
204 temp[8 * 3 + i] = tmp3 - tmp4;
207 for (i = 0; i < 8 * 8; i += 8) {
208 tmp10 = temp[0 + i] + temp[4 + i];
209 tmp11 = temp[0 + i] - temp[4 + i];
211 tmp13 = temp[2 + i] + temp[6 + i];
212 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
214 tmp0 = tmp10 + tmp13;
215 tmp3 = tmp10 - tmp13;
216 tmp1 = tmp11 + tmp12;
217 tmp2 = tmp11 - tmp12;
219 z13 = temp[5 + i] + temp[3 + i];
220 z10 = temp[5 + i] - temp[3 + i];
221 z11 = temp[1 + i] + temp[7 + i];
222 z12 = temp[1 + i] - temp[7 + i];
225 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
227 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
228 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
229 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
235 block[0 + i] = (tmp0 + tmp7) >> 6;
236 block[7 + i] = (tmp0 - tmp7) >> 6;
237 block[1 + i] = (tmp1 + tmp6) >> 6;
238 block[6 + i] = (tmp1 - tmp6) >> 6;
239 block[2 + i] = (tmp2 + tmp5) >> 6;
240 block[5 + i] = (tmp2 - tmp5) >> 6;
241 block[4 + i] = (tmp3 + tmp4) >> 6;
242 block[3 + i] = (tmp3 - tmp4) >> 6;
246 static av_cold void init_vlcs(FourXContext *f)
248 static VLC_TYPE table[2][4][32][2];
251 for (i = 0; i < 2; i++) {
252 for (j = 0; j < 4; j++) {
253 block_type_vlc[i][j].table = table[i][j];
254 block_type_vlc[i][j].table_allocated = 32;
255 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
256 &block_type_tab[i][j][0][1], 2, 1,
257 &block_type_tab[i][j][0][0], 2, 1,
258 INIT_VLC_USE_NEW_STATIC);
263 static void init_mv(FourXContext *f, int linesize)
267 for (i = 0; i < 256; i++) {
269 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
271 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
276 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
278 unsigned tmpval = AV_RN32(src); \
279 tmpval = (tmpval << 16) | (tmpval >> 16); \
280 tmpval = tmpval * (scale) + (dc); \
281 tmpval = (tmpval << 16) | (tmpval >> 16); \
282 AV_WN32A(dst, tmpval); \
285 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
287 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
288 AV_WN32A(dst, tmpval); \
292 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
293 int h, int stride, int scale, unsigned dc)
300 for (i = 0; i < h; i++) {
301 dst[0] = scale * src[0] + dc;
308 for (i = 0; i < h; i++) {
309 LE_CENTRIC_MUL(dst, src, scale, dc);
316 for (i = 0; i < h; i++) {
317 LE_CENTRIC_MUL(dst, src, scale, dc);
318 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
325 for (i = 0; i < h; i++) {
326 LE_CENTRIC_MUL(dst, src, scale, dc);
327 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
328 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
329 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
340 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
341 int log2w, int log2h, int stride)
343 const int index = size2index[log2h][log2w];
344 const int h = 1 << log2h;
345 int code = get_vlc2(&f->gb,
346 block_type_vlc[1 - (f->version > 1)][index].table,
347 BLOCK_TYPE_VLC_BITS, 1);
348 uint16_t *start = f->last_frame_buffer;
349 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
354 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
358 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
360 return decode_p_block(f, dst + (stride << log2h),
361 src + (stride << log2h),
362 log2w, log2h, stride);
363 } else if (code == 2) {
365 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
367 return decode_p_block(f, dst + (1 << log2w),
369 log2w, log2h, stride);
370 } else if (code == 6) {
371 if (bytestream2_get_bytes_left(&f->g2) < 4) {
372 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
373 return AVERROR_INVALIDDATA;
376 dst[0] = bytestream2_get_le16u(&f->g2);
377 dst[1] = bytestream2_get_le16u(&f->g2);
379 dst[0] = bytestream2_get_le16u(&f->g2);
380 dst[stride] = bytestream2_get_le16u(&f->g2);
385 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
386 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
387 return AVERROR_INVALIDDATA;
391 src += f->mv[bytestream2_get_byte(&f->g)];
392 } else if (code == 3 && f->version >= 2) {
394 } else if (code == 4) {
395 src += f->mv[bytestream2_get_byte(&f->g)];
396 if (bytestream2_get_bytes_left(&f->g2) < 2){
397 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
398 return AVERROR_INVALIDDATA;
400 dc = bytestream2_get_le16(&f->g2);
401 } else if (code == 5) {
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 av_assert0(start <= src && src <= end);
408 dc = bytestream2_get_le16(&f->g2);
411 if (start > src || src > end) {
412 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
413 return AVERROR_INVALIDDATA;
416 mcdc(dst, src, log2w, h, stride, scale, dc);
421 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
424 const int width = f->avctx->width;
425 const int height = f->avctx->height;
426 uint16_t *dst = f->frame_buffer;
428 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
429 bytestream_offset, wordstream_offset;
432 src = f->last_frame_buffer;
434 if (f->version > 1) {
437 return AVERROR_INVALIDDATA;
438 bitstream_size = AV_RL32(buf + 8);
439 wordstream_size = AV_RL32(buf + 12);
440 bytestream_size = AV_RL32(buf + 16);
443 bitstream_size = AV_RL16(buf - 4);
444 wordstream_size = AV_RL16(buf - 2);
445 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
448 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
449 bytestream_size > length - bitstream_size ||
450 wordstream_size > length - bytestream_size - bitstream_size ||
451 extra > length - bytestream_size - bitstream_size - wordstream_size) {
452 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
453 bitstream_size+ bytestream_size+ wordstream_size - length);
454 return AVERROR_INVALIDDATA;
457 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
459 if (!f->bitstream_buffer)
460 return AVERROR(ENOMEM);
461 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
463 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
465 wordstream_offset = extra + bitstream_size;
466 bytestream_offset = extra + bitstream_size + wordstream_size;
467 bytestream2_init(&f->g2, buf + wordstream_offset,
468 length - wordstream_offset);
469 bytestream2_init(&f->g, buf + bytestream_offset,
470 length - bytestream_offset);
472 init_mv(f, width * 2);
474 for (y = 0; y < height; y += 8) {
475 for (x = 0; x < width; x += 8)
476 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
486 * decode block and dequantize.
487 * Note this is almost identical to MJPEG.
489 static int decode_i_block(FourXContext *f, int16_t *block)
491 int code, i, j, level, val;
493 if (get_bits_left(&f->gb) < 2){
494 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
499 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
501 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
502 return AVERROR_INVALIDDATA;
506 val = get_xbits(&f->gb, val);
508 val = val * dequant_table[0] + f->last_dc;
509 f->last_dc = block[0] = val;
513 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
522 level = get_xbits(&f->gb, code & 0xf);
524 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
525 return AVERROR_INVALIDDATA;
529 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
533 j = ff_zigzag_direct[i];
534 block[j] = level * dequant_table[j];
544 static inline void idct_put(FourXContext *f, int x, int y)
546 int16_t (*block)[64] = f->block;
547 int stride = f->avctx->width;
549 uint16_t *dst = f->frame_buffer + y * stride + x;
551 for (i = 0; i < 4; i++) {
552 block[i][0] += 0x80 * 8 * 8;
556 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
557 for (i = 4; i < 6; i++)
561 /* Note transform is:
562 * y = ( 1b + 4g + 2r) / 14
563 * cb = ( 3b - 2g - 1r) / 14
564 * cr = (-1b - 4g + 5r) / 14 */
565 for (y = 0; y < 8; y++) {
566 for (x = 0; x < 8; x++) {
567 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
568 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
569 int cb = block[4][x + 8 * y];
570 int cr = block[5][x + 8 * y];
571 int cg = (cb + cr) >> 1;
577 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
579 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
581 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
583 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586 dst += 2 * stride - 2 * 8;
590 static int decode_i_mb(FourXContext *f)
595 f->dsp.clear_blocks(f->block[0]);
597 for (i = 0; i < 6; i++)
598 if ((ret = decode_i_block(f, f->block[i])) < 0)
604 static const uint8_t *read_huffman_tables(FourXContext *f,
605 const uint8_t * const buf,
608 int frequency[512] = { 0 };
611 uint8_t len_tab[257];
614 const uint8_t *ptr = buf;
615 const uint8_t *ptr_end = buf + buf_size;
618 memset(up, -1, sizeof(up));
625 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
626 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
630 for (i = start; i <= end; i++)
631 frequency[i] = *ptr++;
640 while ((ptr - buf) & 3)
641 ptr++; // 4byte align
644 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
648 for (j = 257; j < 512; j++) {
649 int min_freq[2] = { 256 * 256, 256 * 256 };
650 int smallest[2] = { 0, 0 };
652 for (i = 0; i < j; i++) {
653 if (frequency[i] == 0)
655 if (frequency[i] < min_freq[1]) {
656 if (frequency[i] < min_freq[0]) {
657 min_freq[1] = min_freq[0];
658 smallest[1] = smallest[0];
659 min_freq[0] = frequency[i];
662 min_freq[1] = frequency[i];
667 if (min_freq[1] == 256 * 256)
670 frequency[j] = min_freq[0] + min_freq[1];
671 flag[smallest[0]] = 0;
672 flag[smallest[1]] = 1;
675 frequency[smallest[0]] = frequency[smallest[1]] = 0;
678 for (j = 0; j < 257; j++) {
679 int node, len = 0, bits = 0;
681 for (node = j; up[node] != -1; node = up[node]) {
682 bits += flag[node] << len;
685 // can this happen at all ?
686 av_log(f->avctx, AV_LOG_ERROR,
687 "vlc length overflow\n");
694 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
701 static int mix(int c0, int c1)
703 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
704 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
705 int red = 2 * (c0 >> 10) + (c1 >> 10);
706 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
709 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
712 const int width = f->avctx->width;
713 const int height = f->avctx->height;
714 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
715 uint16_t *dst = f->frame_buffer;
716 const uint8_t *buf_end = buf + length;
719 if (length < mbs * 8) {
720 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
721 return AVERROR_INVALIDDATA;
723 bytestream2_init(&g3, buf, length);
725 for (y = 0; y < height; y += 16) {
726 for (x = 0; x < width; x += 16) {
727 unsigned int color[4] = { 0 }, bits;
728 if (buf_end - buf < 8)
730 // warning following is purely guessed ...
731 color[0] = bytestream2_get_le16u(&g3);
732 color[1] = bytestream2_get_le16u(&g3);
734 if (color[0] & 0x8000)
735 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
736 if (color[1] & 0x8000)
737 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
739 color[2] = mix(color[0], color[1]);
740 color[3] = mix(color[1], color[0]);
742 bits = bytestream2_get_le32u(&g3);
743 for (y2 = 0; y2 < 16; y2++) {
744 for (x2 = 0; x2 < 16; x2++) {
745 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
746 dst[y2 * width + x2] = color[(bits >> index) & 3];
751 dst += 16 * width - x;
757 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
760 const int width = f->avctx->width;
761 const int height = f->avctx->height;
762 const unsigned int bitstream_size = AV_RL32(buf);
763 unsigned int prestream_size;
764 const uint8_t *prestream;
766 if (bitstream_size > (1 << 26))
767 return AVERROR_INVALIDDATA;
769 if (length < bitstream_size + 12) {
770 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
771 return AVERROR_INVALIDDATA;
774 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
775 prestream = buf + bitstream_size + 12;
777 if (prestream_size + bitstream_size + 12 != length
778 || prestream_size > (1 << 26)) {
779 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
780 prestream_size, bitstream_size, length);
781 return AVERROR_INVALIDDATA;
784 prestream = read_huffman_tables(f, prestream, prestream_size);
786 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
787 return AVERROR_INVALIDDATA;
790 av_assert0(prestream <= buf + length);
792 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
794 prestream_size = length + buf - prestream;
796 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
798 if (!f->bitstream_buffer)
799 return AVERROR(ENOMEM);
800 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
802 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
804 f->last_dc = 0 * 128 * 8 * 8;
806 for (y = 0; y < height; y += 16) {
807 for (x = 0; x < width; x += 16) {
808 if ((ret = decode_i_mb(f)) < 0)
815 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
816 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
821 static int decode_frame(AVCodecContext *avctx, void *data,
822 int *got_frame, AVPacket *avpkt)
824 const uint8_t *buf = avpkt->data;
825 int buf_size = avpkt->size;
826 FourXContext *const f = avctx->priv_data;
827 AVFrame *picture = data;
828 int i, frame_4cc, frame_size, ret;
831 return AVERROR_INVALIDDATA;
833 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
835 if (buf_size < AV_RL32(buf + 4) + 8) {
836 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
837 buf_size, AV_RL32(buf + 4));
838 return AVERROR_INVALIDDATA;
841 frame_4cc = AV_RL32(buf);
843 if (frame_4cc == AV_RL32("cfrm")) {
846 const int data_size = buf_size - 20;
849 if (f->version <= 1) {
850 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
851 return AVERROR_INVALIDDATA;
854 id = AV_RL32(buf + 12);
855 whole_size = AV_RL32(buf + 16);
857 if (data_size < 0 || whole_size < 0) {
858 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
859 return AVERROR_INVALIDDATA;
862 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
863 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
864 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
867 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
868 if (f->cfrm[i].id == id)
870 if (f->cfrm[i].size == 0)
874 if (i >= CFRAME_BUFFER_COUNT) {
880 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
881 return AVERROR_INVALIDDATA;
883 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
884 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
885 // explicit check needed as memcpy below might not catch a NULL
887 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
888 return AVERROR(ENOMEM);
891 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
892 cfrm->size += data_size;
894 if (cfrm->size >= whole_size) {
896 frame_size = cfrm->size;
898 if (id != avctx->frame_number)
899 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
900 id, avctx->frame_number);
903 return AVERROR_INVALIDDATA;
905 cfrm->size = cfrm->id = 0;
906 frame_4cc = AV_RL32("pfrm");
911 frame_size = buf_size - 12;
914 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
917 if (frame_4cc == AV_RL32("ifr2")) {
918 picture->pict_type = AV_PICTURE_TYPE_I;
919 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
920 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
923 } else if (frame_4cc == AV_RL32("ifrm")) {
924 picture->pict_type = AV_PICTURE_TYPE_I;
925 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
926 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
929 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
930 picture->pict_type = AV_PICTURE_TYPE_P;
931 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
932 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
935 } else if (frame_4cc == AV_RL32("snd_")) {
936 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
939 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
943 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
945 av_image_copy_plane(picture->data[0], picture->linesize[0],
946 (const uint8_t*)f->frame_buffer, avctx->width * 2,
947 avctx->width * 2, avctx->height);
948 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
957 static av_cold int decode_end(AVCodecContext *avctx)
959 FourXContext * const f = avctx->priv_data;
962 av_freep(&f->frame_buffer);
963 av_freep(&f->last_frame_buffer);
964 av_freep(&f->bitstream_buffer);
965 f->bitstream_buffer_size = 0;
966 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
967 av_freep(&f->cfrm[i].data);
968 f->cfrm[i].allocated_size = 0;
970 ff_free_vlc(&f->pre_vlc);
975 static av_cold int decode_init(AVCodecContext *avctx)
977 FourXContext * const f = avctx->priv_data;
980 if (avctx->extradata_size != 4 || !avctx->extradata) {
981 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
982 return AVERROR_INVALIDDATA;
984 if((avctx->width % 16) || (avctx->height % 16)) {
985 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
986 return AVERROR_INVALIDDATA;
989 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
993 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
994 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
995 if (!f->frame_buffer || !f->last_frame_buffer) {
997 return AVERROR(ENOMEM);
1000 f->version = AV_RL32(avctx->extradata) >> 16;
1001 ff_dsputil_init(&f->dsp, avctx);
1006 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1008 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1013 AVCodec ff_fourxm_decoder = {
1015 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1016 .type = AVMEDIA_TYPE_VIDEO,
1017 .id = AV_CODEC_ID_4XM,
1018 .priv_data_size = sizeof(FourXContext),
1019 .init = decode_init,
1020 .close = decode_end,
1021 .decode = decode_frame,
1022 .capabilities = CODEC_CAP_DR1,