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);
530 level = get_xbits(&f->gb, code & 0xf);
532 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
533 return AVERROR_INVALIDDATA;
537 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
541 j = ff_zigzag_direct[i];
542 block[j] = level * dequant_table[j];
552 static inline void idct_put(FourXContext *f, int x, int y)
554 int16_t (*block)[64] = f->block;
555 int stride = f->avctx->width;
557 uint16_t *dst = f->frame_buffer + y * stride + x;
559 for (i = 0; i < 4; i++) {
560 block[i][0] += 0x80 * 8 * 8;
564 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
565 for (i = 4; i < 6; i++)
569 /* Note transform is:
570 * y = ( 1b + 4g + 2r) / 14
571 * cb = ( 3b - 2g - 1r) / 14
572 * cr = (-1b - 4g + 5r) / 14 */
573 for (y = 0; y < 8; y++) {
574 for (x = 0; x < 8; x++) {
575 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
576 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
577 int cb = block[4][x + 8 * y];
578 int cr = block[5][x + 8 * y];
579 int cg = (cb + cr) >> 1;
585 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
587 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
589 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594 dst += 2 * stride - 2 * 8;
598 static int decode_i_mb(FourXContext *f)
603 f->bdsp.clear_blocks(f->block[0]);
605 for (i = 0; i < 6; i++)
606 if ((ret = decode_i_block(f, f->block[i])) < 0)
612 static const uint8_t *read_huffman_tables(FourXContext *f,
613 const uint8_t * const buf,
616 int frequency[512] = { 0 };
619 uint8_t len_tab[257];
622 const uint8_t *ptr = buf;
623 const uint8_t *ptr_end = buf + buf_size;
626 memset(up, -1, sizeof(up));
633 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
634 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
638 for (i = start; i <= end; i++)
639 frequency[i] = *ptr++;
648 while ((ptr - buf) & 3)
649 ptr++; // 4byte align
652 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
656 for (j = 257; j < 512; j++) {
657 int min_freq[2] = { 256 * 256, 256 * 256 };
658 int smallest[2] = { 0, 0 };
660 for (i = 0; i < j; i++) {
661 if (frequency[i] == 0)
663 if (frequency[i] < min_freq[1]) {
664 if (frequency[i] < min_freq[0]) {
665 min_freq[1] = min_freq[0];
666 smallest[1] = smallest[0];
667 min_freq[0] = frequency[i];
670 min_freq[1] = frequency[i];
675 if (min_freq[1] == 256 * 256)
678 frequency[j] = min_freq[0] + min_freq[1];
679 flag[smallest[0]] = 0;
680 flag[smallest[1]] = 1;
683 frequency[smallest[0]] = frequency[smallest[1]] = 0;
686 for (j = 0; j < 257; j++) {
687 int node, len = 0, bits = 0;
689 for (node = j; up[node] != -1; node = up[node]) {
690 bits += flag[node] << len;
693 // can this happen at all ?
694 av_log(f->avctx, AV_LOG_ERROR,
695 "vlc length overflow\n");
702 ff_free_vlc(&f->pre_vlc);
703 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
710 static int mix(int c0, int c1)
712 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
713 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
714 int red = 2 * (c0 >> 10) + (c1 >> 10);
715 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
718 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
721 const int width = f->avctx->width;
722 const int height = f->avctx->height;
723 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
724 uint16_t *dst = f->frame_buffer;
725 const uint8_t *buf_end = buf + length;
728 if (length < mbs * 8) {
729 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
730 return AVERROR_INVALIDDATA;
732 bytestream2_init(&g3, buf, length);
734 for (y = 0; y < height; y += 16) {
735 for (x = 0; x < width; x += 16) {
736 unsigned int color[4] = { 0 }, bits;
737 if (buf_end - buf < 8)
738 return AVERROR_INVALIDDATA;
739 // warning following is purely guessed ...
740 color[0] = bytestream2_get_le16u(&g3);
741 color[1] = bytestream2_get_le16u(&g3);
743 if (color[0] & 0x8000)
744 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
745 if (color[1] & 0x8000)
746 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
748 color[2] = mix(color[0], color[1]);
749 color[3] = mix(color[1], color[0]);
751 bits = bytestream2_get_le32u(&g3);
752 for (y2 = 0; y2 < 16; y2++) {
753 for (x2 = 0; x2 < 16; x2++) {
754 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
755 dst[y2 * width + x2] = color[(bits >> index) & 3];
760 dst += 16 * width - x;
766 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
769 const int width = f->avctx->width;
770 const int height = f->avctx->height;
771 const unsigned int bitstream_size = AV_RL32(buf);
772 unsigned int prestream_size;
773 const uint8_t *prestream;
775 if (bitstream_size > (1 << 26))
776 return AVERROR_INVALIDDATA;
778 if (length < bitstream_size + 12) {
779 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
780 return AVERROR_INVALIDDATA;
783 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
784 prestream = buf + bitstream_size + 12;
786 if (prestream_size + bitstream_size + 12 != length
787 || prestream_size > (1 << 26)) {
788 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
789 prestream_size, bitstream_size, length);
790 return AVERROR_INVALIDDATA;
793 prestream = read_huffman_tables(f, prestream, prestream_size);
795 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
796 return AVERROR_INVALIDDATA;
799 av_assert0(prestream <= buf + length);
801 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
803 prestream_size = length + buf - prestream;
805 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
807 if (!f->bitstream_buffer)
808 return AVERROR(ENOMEM);
809 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
811 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
813 f->last_dc = 0 * 128 * 8 * 8;
815 for (y = 0; y < height; y += 16) {
816 for (x = 0; x < width; x += 16) {
817 if ((ret = decode_i_mb(f)) < 0)
824 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
825 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
830 static int decode_frame(AVCodecContext *avctx, void *data,
831 int *got_frame, AVPacket *avpkt)
833 const uint8_t *buf = avpkt->data;
834 int buf_size = avpkt->size;
835 FourXContext *const f = avctx->priv_data;
836 AVFrame *picture = data;
837 int i, frame_4cc, frame_size, ret;
840 return AVERROR_INVALIDDATA;
842 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
844 if (buf_size < AV_RL32(buf + 4) + 8) {
845 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
846 buf_size, AV_RL32(buf + 4));
847 return AVERROR_INVALIDDATA;
850 frame_4cc = AV_RL32(buf);
852 if (frame_4cc == AV_RL32("cfrm")) {
855 const int data_size = buf_size - 20;
858 if (f->version <= 1) {
859 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
860 return AVERROR_INVALIDDATA;
863 id = AV_RL32(buf + 12);
864 whole_size = AV_RL32(buf + 16);
866 if (data_size < 0 || whole_size < 0) {
867 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
868 return AVERROR_INVALIDDATA;
871 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
872 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
873 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
876 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
877 if (f->cfrm[i].id == id)
879 if (f->cfrm[i].size == 0)
883 if (i >= CFRAME_BUFFER_COUNT) {
889 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
890 return AVERROR_INVALIDDATA;
892 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
893 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
894 // explicit check needed as memcpy below might not catch a NULL
896 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
897 return AVERROR(ENOMEM);
900 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
901 cfrm->size += data_size;
903 if (cfrm->size >= whole_size) {
905 frame_size = cfrm->size;
907 if (id != avctx->frame_number)
908 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
909 id, avctx->frame_number);
912 return AVERROR_INVALIDDATA;
914 cfrm->size = cfrm->id = 0;
915 frame_4cc = AV_RL32("pfrm");
920 frame_size = buf_size - 12;
923 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
926 if (frame_4cc == AV_RL32("ifr2")) {
927 picture->pict_type = AV_PICTURE_TYPE_I;
928 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
929 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
932 } else if (frame_4cc == AV_RL32("ifrm")) {
933 picture->pict_type = AV_PICTURE_TYPE_I;
934 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
935 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
938 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
939 picture->pict_type = AV_PICTURE_TYPE_P;
940 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
941 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
944 } else if (frame_4cc == AV_RL32("snd_")) {
945 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
948 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
952 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
954 av_image_copy_plane(picture->data[0], picture->linesize[0],
955 (const uint8_t*)f->frame_buffer, avctx->width * 2,
956 avctx->width * 2, avctx->height);
957 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
966 static av_cold int decode_end(AVCodecContext *avctx)
968 FourXContext * const f = avctx->priv_data;
971 av_freep(&f->frame_buffer);
972 av_freep(&f->last_frame_buffer);
973 av_freep(&f->bitstream_buffer);
974 f->bitstream_buffer_size = 0;
975 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
976 av_freep(&f->cfrm[i].data);
977 f->cfrm[i].allocated_size = 0;
979 ff_free_vlc(&f->pre_vlc);
984 static av_cold int decode_init(AVCodecContext *avctx)
986 FourXContext * const f = avctx->priv_data;
989 if (avctx->extradata_size != 4 || !avctx->extradata) {
990 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
991 return AVERROR_INVALIDDATA;
993 if((avctx->width % 16) || (avctx->height % 16)) {
994 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
995 return AVERROR_INVALIDDATA;
998 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1002 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1003 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1004 if (!f->frame_buffer || !f->last_frame_buffer) {
1006 return AVERROR(ENOMEM);
1009 f->version = AV_RL32(avctx->extradata) >> 16;
1010 ff_blockdsp_init(&f->bdsp, avctx);
1011 ff_bswapdsp_init(&f->bbdsp);
1016 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1018 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1023 AVCodec ff_fourxm_decoder = {
1025 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1026 .type = AVMEDIA_TYPE_VIDEO,
1027 .id = AV_CODEC_ID_4XM,
1028 .priv_data_size = sizeof(FourXContext),
1029 .init = decode_init,
1030 .close = decode_end,
1031 .decode = decode_frame,
1032 .capabilities = AV_CODEC_CAP_DR1,