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
27 #include "libavutil/avassert.h"
28 #include "libavutil/frame.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/intreadwrite.h"
32 #include "bytestream.h"
38 #define BLOCK_TYPE_VLC_BITS 5
39 #define ACDC_VLC_BITS 9
41 #define CFRAME_BUFFER_COUNT 100
43 static const uint8_t block_type_tab[2][4][8][2] = {
45 { // { 8, 4, 2 } x { 8, 4, 2}
46 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
48 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
55 { // { 8, 4, 2 } x { 8, 4, 2}
56 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
67 static const uint8_t size2index[4][4] = {
74 static const int8_t mv[256][2] = {
75 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
76 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
77 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
78 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
79 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
80 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
81 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
82 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
83 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
84 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
85 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
86 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
87 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
88 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
89 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
90 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
91 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
92 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
93 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
94 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
95 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
96 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
97 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
98 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
99 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
100 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
101 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
102 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
103 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
104 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
105 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
106 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
109 /* This is simply the scaled down elementwise product of the standard JPEG
110 * quantizer table and the AAN premul table. */
111 static const uint8_t dequant_table[64] = {
112 16, 15, 13, 19, 24, 31, 28, 17,
113 17, 23, 25, 31, 36, 63, 45, 21,
114 18, 24, 27, 37, 52, 59, 49, 20,
115 16, 28, 34, 40, 60, 80, 51, 20,
116 18, 31, 48, 66, 68, 86, 56, 21,
117 19, 38, 56, 59, 64, 64, 48, 20,
118 27, 48, 55, 55, 56, 51, 35, 15,
119 20, 35, 34, 32, 31, 22, 15, 8,
122 static VLC block_type_vlc[2][4];
125 typedef struct CFrameBuffer {
126 unsigned int allocated_size;
132 typedef struct FourXContext {
133 AVCodecContext *avctx;
135 uint16_t *frame_buffer;
136 uint16_t *last_frame_buffer;
137 GetBitContext pre_gb; ///< ac/dc prefix
144 DECLARE_ALIGNED(16, int16_t, block)[6][64];
145 void *bitstream_buffer;
146 unsigned int bitstream_buffer_size;
148 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
152 #define FIX_1_082392200 70936
153 #define FIX_1_414213562 92682
154 #define FIX_1_847759065 121095
155 #define FIX_2_613125930 171254
157 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
159 static void idct(int16_t block[64])
161 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
162 int tmp10, tmp11, tmp12, tmp13;
163 int z5, z10, z11, z12, z13;
167 for (i = 0; i < 8; i++) {
168 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
169 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
171 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
172 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
174 tmp0 = tmp10 + tmp13;
175 tmp3 = tmp10 - tmp13;
176 tmp1 = tmp11 + tmp12;
177 tmp2 = tmp11 - tmp12;
179 z13 = block[8 * 5 + i] + block[8 * 3 + i];
180 z10 = block[8 * 5 + i] - block[8 * 3 + i];
181 z11 = block[8 * 1 + i] + block[8 * 7 + i];
182 z12 = block[8 * 1 + i] - block[8 * 7 + i];
185 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
187 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
188 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
189 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
195 temp[8 * 0 + i] = tmp0 + tmp7;
196 temp[8 * 7 + i] = tmp0 - tmp7;
197 temp[8 * 1 + i] = tmp1 + tmp6;
198 temp[8 * 6 + i] = tmp1 - tmp6;
199 temp[8 * 2 + i] = tmp2 + tmp5;
200 temp[8 * 5 + i] = tmp2 - tmp5;
201 temp[8 * 4 + i] = tmp3 + tmp4;
202 temp[8 * 3 + i] = tmp3 - tmp4;
205 for (i = 0; i < 8 * 8; i += 8) {
206 tmp10 = temp[0 + i] + temp[4 + i];
207 tmp11 = temp[0 + i] - temp[4 + i];
209 tmp13 = temp[2 + i] + temp[6 + i];
210 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
212 tmp0 = tmp10 + tmp13;
213 tmp3 = tmp10 - tmp13;
214 tmp1 = tmp11 + tmp12;
215 tmp2 = tmp11 - tmp12;
217 z13 = temp[5 + i] + temp[3 + i];
218 z10 = temp[5 + i] - temp[3 + i];
219 z11 = temp[1 + i] + temp[7 + i];
220 z12 = temp[1 + i] - temp[7 + i];
223 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
225 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
226 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
227 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
233 block[0 + i] = (tmp0 + tmp7) >> 6;
234 block[7 + i] = (tmp0 - tmp7) >> 6;
235 block[1 + i] = (tmp1 + tmp6) >> 6;
236 block[6 + i] = (tmp1 - tmp6) >> 6;
237 block[2 + i] = (tmp2 + tmp5) >> 6;
238 block[5 + i] = (tmp2 - tmp5) >> 6;
239 block[4 + i] = (tmp3 + tmp4) >> 6;
240 block[3 + i] = (tmp3 - tmp4) >> 6;
244 static av_cold void init_vlcs(FourXContext *f)
246 static VLC_TYPE table[2][4][32][2];
249 for (i = 0; i < 2; i++) {
250 for (j = 0; j < 4; j++) {
251 block_type_vlc[i][j].table = table[i][j];
252 block_type_vlc[i][j].table_allocated = 32;
253 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
254 &block_type_tab[i][j][0][1], 2, 1,
255 &block_type_tab[i][j][0][0], 2, 1,
256 INIT_VLC_USE_NEW_STATIC);
261 static void init_mv(FourXContext *f, int linesize)
265 for (i = 0; i < 256; i++) {
267 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
269 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
274 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
276 unsigned tmpval = AV_RN32(src); \
277 tmpval = (tmpval << 16) | (tmpval >> 16); \
278 tmpval = tmpval * (scale) + (dc); \
279 tmpval = (tmpval << 16) | (tmpval >> 16); \
280 AV_WN32A(dst, tmpval); \
283 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
285 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
286 AV_WN32A(dst, tmpval); \
290 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
291 int h, int stride, int scale, unsigned dc)
298 for (i = 0; i < h; i++) {
299 dst[0] = scale * src[0] + dc;
306 for (i = 0; i < h; i++) {
307 LE_CENTRIC_MUL(dst, src, scale, dc);
314 for (i = 0; i < h; i++) {
315 LE_CENTRIC_MUL(dst, src, scale, dc);
316 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
323 for (i = 0; i < h; i++) {
324 LE_CENTRIC_MUL(dst, src, scale, dc);
325 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
326 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
327 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
338 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
339 int log2w, int log2h, int stride)
341 const int index = size2index[log2h][log2w];
342 const int h = 1 << log2h;
343 int code = get_vlc2(&f->gb,
344 block_type_vlc[1 - (f->version > 1)][index].table,
345 BLOCK_TYPE_VLC_BITS, 1);
346 uint16_t *start = f->last_frame_buffer;
347 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
352 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
356 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
358 return decode_p_block(f, dst + (stride << log2h),
359 src + (stride << log2h),
360 log2w, log2h, stride);
361 } else if (code == 2) {
363 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
365 return decode_p_block(f, dst + (1 << log2w),
367 log2w, log2h, stride);
368 } else if (code == 6) {
369 if (bytestream2_get_bytes_left(&f->g2) < 4) {
370 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
371 return AVERROR_INVALIDDATA;
374 dst[0] = bytestream2_get_le16u(&f->g2);
375 dst[1] = bytestream2_get_le16u(&f->g2);
377 dst[0] = bytestream2_get_le16u(&f->g2);
378 dst[stride] = bytestream2_get_le16u(&f->g2);
383 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
384 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
385 return AVERROR_INVALIDDATA;
389 src += f->mv[bytestream2_get_byte(&f->g)];
390 } else if (code == 3 && f->version >= 2) {
392 } else if (code == 4) {
393 src += f->mv[bytestream2_get_byte(&f->g)];
394 if (bytestream2_get_bytes_left(&f->g2) < 2){
395 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
396 return AVERROR_INVALIDDATA;
398 dc = bytestream2_get_le16(&f->g2);
399 } else if (code == 5) {
400 if (bytestream2_get_bytes_left(&f->g2) < 2){
401 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
402 return AVERROR_INVALIDDATA;
404 av_assert0(start <= src && src <= end);
406 dc = bytestream2_get_le16(&f->g2);
409 if (start > src || src > end) {
410 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
411 return AVERROR_INVALIDDATA;
414 mcdc(dst, src, log2w, h, stride, scale, dc);
419 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
422 const int width = f->avctx->width;
423 const int height = f->avctx->height;
424 uint16_t *dst = f->frame_buffer;
426 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427 bytestream_offset, wordstream_offset;
430 src = f->last_frame_buffer;
432 if (f->version > 1) {
435 return AVERROR_INVALIDDATA;
436 bitstream_size = AV_RL32(buf + 8);
437 wordstream_size = AV_RL32(buf + 12);
438 bytestream_size = AV_RL32(buf + 16);
441 bitstream_size = AV_RL16(buf - 4);
442 wordstream_size = AV_RL16(buf - 2);
443 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
446 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
447 bytestream_size > length - bitstream_size ||
448 wordstream_size > length - bytestream_size - bitstream_size ||
449 extra > length - bytestream_size - bitstream_size - wordstream_size) {
450 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
451 bitstream_size+ bytestream_size+ wordstream_size - length);
452 return AVERROR_INVALIDDATA;
455 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
457 if (!f->bitstream_buffer)
458 return AVERROR(ENOMEM);
459 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
461 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
463 wordstream_offset = extra + bitstream_size;
464 bytestream_offset = extra + bitstream_size + wordstream_size;
465 bytestream2_init(&f->g2, buf + wordstream_offset,
466 length - wordstream_offset);
467 bytestream2_init(&f->g, buf + bytestream_offset,
468 length - bytestream_offset);
470 init_mv(f, width * 2);
472 for (y = 0; y < height; y += 8) {
473 for (x = 0; x < width; x += 8)
474 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
484 * decode block and dequantize.
485 * Note this is almost identical to MJPEG.
487 static int decode_i_block(FourXContext *f, int16_t *block)
489 int code, i, j, level, val;
491 if (get_bits_left(&f->gb) < 2){
492 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
497 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
499 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
500 return AVERROR_INVALIDDATA;
504 val = get_xbits(&f->gb, val);
506 val = val * dequant_table[0] + f->last_dc;
507 f->last_dc = block[0] = val;
511 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
520 level = get_xbits(&f->gb, code & 0xf);
522 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
523 return AVERROR_INVALIDDATA;
527 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
531 j = ff_zigzag_direct[i];
532 block[j] = level * dequant_table[j];
542 static inline void idct_put(FourXContext *f, int x, int y)
544 int16_t (*block)[64] = f->block;
545 int stride = f->avctx->width;
547 uint16_t *dst = f->frame_buffer + y * stride + x;
549 for (i = 0; i < 4; i++) {
550 block[i][0] += 0x80 * 8 * 8;
554 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
555 for (i = 4; i < 6; i++)
559 /* Note transform is:
560 * y = ( 1b + 4g + 2r) / 14
561 * cb = ( 3b - 2g - 1r) / 14
562 * cr = (-1b - 4g + 5r) / 14 */
563 for (y = 0; y < 8; y++) {
564 for (x = 0; x < 8; x++) {
565 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
566 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
567 int cb = block[4][x + 8 * y];
568 int cr = block[5][x + 8 * y];
569 int cg = (cb + cr) >> 1;
575 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
577 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
579 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
581 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
584 dst += 2 * stride - 2 * 8;
588 static int decode_i_mb(FourXContext *f)
593 f->dsp.clear_blocks(f->block[0]);
595 for (i = 0; i < 6; i++)
596 if ((ret = decode_i_block(f, f->block[i])) < 0)
602 static const uint8_t *read_huffman_tables(FourXContext *f,
603 const uint8_t * const buf,
606 int frequency[512] = { 0 };
609 uint8_t len_tab[257];
612 const uint8_t *ptr = buf;
613 const uint8_t *ptr_end = buf + buf_size;
616 memset(up, -1, sizeof(up));
623 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
624 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
628 for (i = start; i <= end; i++)
629 frequency[i] = *ptr++;
638 while ((ptr - buf) & 3)
639 ptr++; // 4byte align
642 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
646 for (j = 257; j < 512; j++) {
647 int min_freq[2] = { 256 * 256, 256 * 256 };
648 int smallest[2] = { 0, 0 };
650 for (i = 0; i < j; i++) {
651 if (frequency[i] == 0)
653 if (frequency[i] < min_freq[1]) {
654 if (frequency[i] < min_freq[0]) {
655 min_freq[1] = min_freq[0];
656 smallest[1] = smallest[0];
657 min_freq[0] = frequency[i];
660 min_freq[1] = frequency[i];
665 if (min_freq[1] == 256 * 256)
668 frequency[j] = min_freq[0] + min_freq[1];
669 flag[smallest[0]] = 0;
670 flag[smallest[1]] = 1;
673 frequency[smallest[0]] = frequency[smallest[1]] = 0;
676 for (j = 0; j < 257; j++) {
677 int node, len = 0, bits = 0;
679 for (node = j; up[node] != -1; node = up[node]) {
680 bits += flag[node] << len;
683 // can this happen at all ?
684 av_log(f->avctx, AV_LOG_ERROR,
685 "vlc length overflow\n");
692 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
699 static int mix(int c0, int c1)
701 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
702 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
703 int red = 2 * (c0 >> 10) + (c1 >> 10);
704 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
707 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
710 const int width = f->avctx->width;
711 const int height = f->avctx->height;
712 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
713 uint16_t *dst = f->frame_buffer;
714 const uint8_t *buf_end = buf + length;
717 if (length < mbs * 8) {
718 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
719 return AVERROR_INVALIDDATA;
721 bytestream2_init(&g3, buf, length);
723 for (y = 0; y < height; y += 16) {
724 for (x = 0; x < width; x += 16) {
725 unsigned int color[4] = { 0 }, bits;
726 if (buf_end - buf < 8)
728 // warning following is purely guessed ...
729 color[0] = bytestream2_get_le16u(&g3);
730 color[1] = bytestream2_get_le16u(&g3);
732 if (color[0] & 0x8000)
733 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
734 if (color[1] & 0x8000)
735 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
737 color[2] = mix(color[0], color[1]);
738 color[3] = mix(color[1], color[0]);
740 bits = bytestream2_get_le32u(&g3);
741 for (y2 = 0; y2 < 16; y2++) {
742 for (x2 = 0; x2 < 16; x2++) {
743 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
744 dst[y2 * width + x2] = color[(bits >> index) & 3];
749 dst += 16 * width - x;
755 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
758 const int width = f->avctx->width;
759 const int height = f->avctx->height;
760 const unsigned int bitstream_size = AV_RL32(buf);
761 unsigned int prestream_size;
762 const uint8_t *prestream;
764 if (bitstream_size > (1 << 26))
765 return AVERROR_INVALIDDATA;
767 if (length < bitstream_size + 12) {
768 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
769 return AVERROR_INVALIDDATA;
772 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
773 prestream = buf + bitstream_size + 12;
775 if (prestream_size + bitstream_size + 12 != length
776 || prestream_size > (1 << 26)) {
777 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
778 prestream_size, bitstream_size, length);
779 return AVERROR_INVALIDDATA;
782 prestream = read_huffman_tables(f, prestream, prestream_size);
784 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
785 return AVERROR_INVALIDDATA;
788 av_assert0(prestream <= buf + length);
790 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
792 prestream_size = length + buf - prestream;
794 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
796 if (!f->bitstream_buffer)
797 return AVERROR(ENOMEM);
798 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
800 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
802 f->last_dc = 0 * 128 * 8 * 8;
804 for (y = 0; y < height; y += 16) {
805 for (x = 0; x < width; x += 16) {
806 if ((ret = decode_i_mb(f)) < 0)
813 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
814 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
819 static int decode_frame(AVCodecContext *avctx, void *data,
820 int *got_frame, AVPacket *avpkt)
822 const uint8_t *buf = avpkt->data;
823 int buf_size = avpkt->size;
824 FourXContext *const f = avctx->priv_data;
825 AVFrame *picture = data;
826 int i, frame_4cc, frame_size, ret;
829 return AVERROR_INVALIDDATA;
831 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
833 if (buf_size < AV_RL32(buf + 4) + 8) {
834 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
835 buf_size, AV_RL32(buf + 4));
836 return AVERROR_INVALIDDATA;
839 frame_4cc = AV_RL32(buf);
841 if (frame_4cc == AV_RL32("cfrm")) {
844 const int data_size = buf_size - 20;
847 if (f->version <= 1) {
848 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
849 return AVERROR_INVALIDDATA;
852 id = AV_RL32(buf + 12);
853 whole_size = AV_RL32(buf + 16);
855 if (data_size < 0 || whole_size < 0) {
856 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
857 return AVERROR_INVALIDDATA;
860 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
861 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
862 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
865 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
866 if (f->cfrm[i].id == id)
868 if (f->cfrm[i].size == 0)
872 if (i >= CFRAME_BUFFER_COUNT) {
878 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
879 return AVERROR_INVALIDDATA;
881 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
882 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
883 // explicit check needed as memcpy below might not catch a NULL
885 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
886 return AVERROR(ENOMEM);
889 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
890 cfrm->size += data_size;
892 if (cfrm->size >= whole_size) {
894 frame_size = cfrm->size;
896 if (id != avctx->frame_number)
897 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
898 id, avctx->frame_number);
901 return AVERROR_INVALIDDATA;
903 cfrm->size = cfrm->id = 0;
904 frame_4cc = AV_RL32("pfrm");
909 frame_size = buf_size - 12;
912 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
915 if (frame_4cc == AV_RL32("ifr2")) {
916 picture->pict_type = AV_PICTURE_TYPE_I;
917 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
918 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
921 } else if (frame_4cc == AV_RL32("ifrm")) {
922 picture->pict_type = AV_PICTURE_TYPE_I;
923 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
924 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
927 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
928 picture->pict_type = AV_PICTURE_TYPE_P;
929 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
930 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
933 } else if (frame_4cc == AV_RL32("snd_")) {
934 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
937 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
941 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
943 av_image_copy_plane(picture->data[0], picture->linesize[0],
944 (const uint8_t*)f->frame_buffer, avctx->width * 2,
945 avctx->width * 2, avctx->height);
946 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
955 static av_cold int decode_end(AVCodecContext *avctx)
957 FourXContext * const f = avctx->priv_data;
960 av_freep(&f->frame_buffer);
961 av_freep(&f->last_frame_buffer);
962 av_freep(&f->bitstream_buffer);
963 f->bitstream_buffer_size = 0;
964 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
965 av_freep(&f->cfrm[i].data);
966 f->cfrm[i].allocated_size = 0;
968 ff_free_vlc(&f->pre_vlc);
973 static av_cold int decode_init(AVCodecContext *avctx)
975 FourXContext * const f = avctx->priv_data;
978 if (avctx->extradata_size != 4 || !avctx->extradata) {
979 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
980 return AVERROR_INVALIDDATA;
982 if((avctx->width % 16) || (avctx->height % 16)) {
983 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
984 return AVERROR_INVALIDDATA;
987 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
991 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
992 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
993 if (!f->frame_buffer || !f->last_frame_buffer) {
995 return AVERROR(ENOMEM);
998 f->version = AV_RL32(avctx->extradata) >> 16;
999 ff_dsputil_init(&f->dsp, avctx);
1004 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1006 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1011 AVCodec ff_fourxm_decoder = {
1013 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1014 .type = AVMEDIA_TYPE_VIDEO,
1015 .id = AV_CODEC_ID_4XM,
1016 .priv_data_size = sizeof(FourXContext),
1017 .init = decode_init,
1018 .close = decode_end,
1019 .decode = decode_frame,
1020 .capabilities = CODEC_CAP_DR1,