3 * Copyright (c) 2003 Michael Niedermayer
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/intreadwrite.h"
29 #include "bytestream.h"
37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
40 #define CFRAME_BUFFER_COUNT 100
42 static const uint8_t block_type_tab[2][4][8][2] = {
44 { // { 8, 4, 2 } x { 8, 4, 2}
45 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
47 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
54 { // { 8, 4, 2 } x { 8, 4, 2}
55 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
66 static const uint8_t size2index[4][4] = {
73 static const int8_t mv[256][2] = {
74 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
108 /* This is simply the scaled down elementwise product of the standard JPEG
109 * quantizer table and the AAN premul table. */
110 static const uint8_t dequant_table[64] = {
111 16, 15, 13, 19, 24, 31, 28, 17,
112 17, 23, 25, 31, 36, 63, 45, 21,
113 18, 24, 27, 37, 52, 59, 49, 20,
114 16, 28, 34, 40, 60, 80, 51, 20,
115 18, 31, 48, 66, 68, 86, 56, 21,
116 19, 38, 56, 59, 64, 64, 48, 20,
117 27, 48, 55, 55, 56, 51, 35, 15,
118 20, 35, 34, 32, 31, 22, 15, 8,
121 static VLC block_type_vlc[2][4];
124 typedef struct CFrameBuffer {
125 unsigned int allocated_size;
131 typedef struct FourXContext {
132 AVCodecContext *avctx;
134 AVFrame *current_picture, *last_picture;
135 GetBitContext pre_gb; ///< ac/dc prefix
142 DECLARE_ALIGNED(16, int16_t, block)[6][64];
143 void *bitstream_buffer;
144 unsigned int bitstream_buffer_size;
146 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
157 static void idct(int16_t block[64])
159 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160 int tmp10, tmp11, tmp12, tmp13;
161 int z5, z10, z11, z12, z13;
165 for (i = 0; i < 8; i++) {
166 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
169 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
170 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
172 tmp0 = tmp10 + tmp13;
173 tmp3 = tmp10 - tmp13;
174 tmp1 = tmp11 + tmp12;
175 tmp2 = tmp11 - tmp12;
177 z13 = block[8 * 5 + i] + block[8 * 3 + i];
178 z10 = block[8 * 5 + i] - block[8 * 3 + i];
179 z11 = block[8 * 1 + i] + block[8 * 7 + i];
180 z12 = block[8 * 1 + i] - block[8 * 7 + i];
183 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
185 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
186 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
187 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
193 temp[8 * 0 + i] = tmp0 + tmp7;
194 temp[8 * 7 + i] = tmp0 - tmp7;
195 temp[8 * 1 + i] = tmp1 + tmp6;
196 temp[8 * 6 + i] = tmp1 - tmp6;
197 temp[8 * 2 + i] = tmp2 + tmp5;
198 temp[8 * 5 + i] = tmp2 - tmp5;
199 temp[8 * 4 + i] = tmp3 + tmp4;
200 temp[8 * 3 + i] = tmp3 - tmp4;
203 for (i = 0; i < 8 * 8; i += 8) {
204 tmp10 = temp[0 + i] + temp[4 + i];
205 tmp11 = temp[0 + i] - temp[4 + i];
207 tmp13 = temp[2 + i] + temp[6 + i];
208 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
210 tmp0 = tmp10 + tmp13;
211 tmp3 = tmp10 - tmp13;
212 tmp1 = tmp11 + tmp12;
213 tmp2 = tmp11 - tmp12;
215 z13 = temp[5 + i] + temp[3 + i];
216 z10 = temp[5 + i] - temp[3 + i];
217 z11 = temp[1 + i] + temp[7 + i];
218 z12 = temp[1 + i] - temp[7 + i];
221 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
223 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
224 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
225 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
231 block[0 + i] = (tmp0 + tmp7) >> 6;
232 block[7 + i] = (tmp0 - tmp7) >> 6;
233 block[1 + i] = (tmp1 + tmp6) >> 6;
234 block[6 + i] = (tmp1 - tmp6) >> 6;
235 block[2 + i] = (tmp2 + tmp5) >> 6;
236 block[5 + i] = (tmp2 - tmp5) >> 6;
237 block[4 + i] = (tmp3 + tmp4) >> 6;
238 block[3 + i] = (tmp3 - tmp4) >> 6;
242 static av_cold void init_vlcs(FourXContext *f)
244 static VLC_TYPE table[2][4][32][2];
247 for (i = 0; i < 2; i++) {
248 for (j = 0; j < 4; j++) {
249 block_type_vlc[i][j].table = table[i][j];
250 block_type_vlc[i][j].table_allocated = 32;
251 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
252 &block_type_tab[i][j][0][1], 2, 1,
253 &block_type_tab[i][j][0][0], 2, 1,
254 INIT_VLC_USE_NEW_STATIC);
259 static void init_mv(FourXContext *f)
263 for (i = 0; i < 256; i++) {
265 f->mv[i] = mv[i][0] + mv[i][1] * f->current_picture->linesize[0] / 2;
267 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * f->current_picture->linesize[0] / 2;
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
274 unsigned tmpval = AV_RN32(src); \
275 tmpval = (tmpval << 16) | (tmpval >> 16); \
276 tmpval = tmpval * (scale) + (dc); \
277 tmpval = (tmpval << 16) | (tmpval >> 16); \
278 AV_WN32A(dst, tmpval); \
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
283 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284 AV_WN32A(dst, tmpval); \
288 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
289 int h, int stride, int scale, unsigned dc)
296 for (i = 0; i < h; i++) {
297 dst[0] = scale * src[0] + dc;
304 for (i = 0; i < h; i++) {
305 LE_CENTRIC_MUL(dst, src, scale, dc);
312 for (i = 0; i < h; i++) {
313 LE_CENTRIC_MUL(dst, src, scale, dc);
314 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321 for (i = 0; i < h; i++) {
322 LE_CENTRIC_MUL(dst, src, scale, dc);
323 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
324 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
325 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
336 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
337 int log2w, int log2h, int stride)
339 const int index = size2index[log2h][log2w];
340 const int h = 1 << log2h;
341 int code = get_vlc2(&f->gb,
342 block_type_vlc[1 - (f->version > 1)][index].table,
343 BLOCK_TYPE_VLC_BITS, 1);
344 uint16_t *start = (uint16_t *)f->last_picture->data[0];
345 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
347 assert(code >= 0 && code <= 6);
350 src += f->mv[bytestream2_get_byte(&f->g)];
351 if (start > src || src > end) {
352 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
355 mcdc(dst, src, log2w, h, stride, 1, 0);
356 } else if (code == 1) {
358 decode_p_block(f, dst, src, log2w, log2h, stride);
359 decode_p_block(f, dst + (stride << log2h),
360 src + (stride << log2h), log2w, log2h, stride);
361 } else if (code == 2) {
363 decode_p_block(f, dst , src, log2w, log2h, stride);
364 decode_p_block(f, dst + (1 << log2w),
365 src + (1 << log2w), log2w, log2h, stride);
366 } else if (code == 3 && f->version < 2) {
367 mcdc(dst, src, log2w, h, stride, 1, 0);
368 } else if (code == 4) {
369 src += f->mv[bytestream2_get_byte(&f->g)];
370 if (start > src || src > end) {
371 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
374 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
375 } else if (code == 5) {
376 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
377 } else if (code == 6) {
379 dst[0] = bytestream2_get_le16(&f->g2);
380 dst[1] = bytestream2_get_le16(&f->g2);
382 dst[0] = bytestream2_get_le16(&f->g2);
383 dst[stride] = bytestream2_get_le16(&f->g2);
388 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
391 const int width = f->avctx->width;
392 const int height = f->avctx->height;
393 uint16_t *src = (uint16_t *)f->last_picture->data[0];
394 uint16_t *dst = (uint16_t *)f->current_picture->data[0];
395 const int stride = f->current_picture->linesize[0] >> 1;
396 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
397 bytestream_offset, wordstream_offset;
399 if (f->version > 1) {
401 bitstream_size = AV_RL32(buf + 8);
402 wordstream_size = AV_RL32(buf + 12);
403 bytestream_size = AV_RL32(buf + 16);
406 bitstream_size = AV_RL16(buf - 4);
407 wordstream_size = AV_RL16(buf - 2);
408 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
411 if (bitstream_size + bytestream_size + wordstream_size + extra != length
412 || bitstream_size > (1 << 26)
413 || bytestream_size > (1 << 26)
414 || wordstream_size > (1 << 26)) {
415 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
416 bitstream_size, bytestream_size, wordstream_size,
417 bitstream_size + bytestream_size + wordstream_size - length);
418 return AVERROR_INVALIDDATA;
421 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
422 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
423 if (!f->bitstream_buffer)
424 return AVERROR(ENOMEM);
425 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
427 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
428 0, FF_INPUT_BUFFER_PADDING_SIZE);
429 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
431 wordstream_offset = extra + bitstream_size;
432 bytestream_offset = extra + bitstream_size + wordstream_size;
433 bytestream2_init(&f->g2, buf + wordstream_offset,
434 length - wordstream_offset);
435 bytestream2_init(&f->g, buf + bytestream_offset,
436 length - bytestream_offset);
440 for (y = 0; y < height; y += 8) {
441 for (x = 0; x < width; x += 8)
442 decode_p_block(f, dst + x, src + x, 3, 3, stride);
451 * decode block and dequantize.
452 * Note this is almost identical to MJPEG.
454 static int decode_i_block(FourXContext *f, int16_t *block)
456 int code, i, j, level, val;
459 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
461 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
464 val = get_xbits(&f->gb, val);
466 val = val * dequant_table[0] + f->last_dc;
467 f->last_dc = block[0] = val;
471 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
479 level = get_xbits(&f->gb, code & 0xf);
482 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
486 j = ff_zigzag_direct[i];
487 block[j] = level * dequant_table[j];
497 static inline void idct_put(FourXContext *f, int x, int y)
499 int16_t (*block)[64] = f->block;
500 int stride = f->current_picture->linesize[0] >> 1;
502 uint16_t *dst = ((uint16_t*)f->current_picture->data[0]) + y * stride + x;
504 for (i = 0; i < 4; i++) {
505 block[i][0] += 0x80 * 8 * 8;
509 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
510 for (i = 4; i < 6; i++)
514 /* Note transform is:
515 * y = ( 1b + 4g + 2r) / 14
516 * cb = ( 3b - 2g - 1r) / 14
517 * cr = (-1b - 4g + 5r) / 14 */
518 for (y = 0; y < 8; y++) {
519 for (x = 0; x < 8; x++) {
520 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
521 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
522 int cb = block[4][x + 8 * y];
523 int cr = block[5][x + 8 * y];
524 int cg = (cb + cr) >> 1;
530 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
532 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
534 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
536 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
539 dst += 2 * stride - 2 * 8;
543 static int decode_i_mb(FourXContext *f)
548 f->dsp.clear_blocks(f->block[0]);
550 for (i = 0; i < 6; i++)
551 if ((ret = decode_i_block(f, f->block[i])) < 0)
557 static const uint8_t *read_huffman_tables(FourXContext *f,
558 const uint8_t * const buf)
560 int frequency[512] = { 0 };
563 uint8_t len_tab[257];
566 const uint8_t *ptr = buf;
569 memset(up, -1, sizeof(up));
576 for (i = start; i <= end; i++)
577 frequency[i] = *ptr++;
586 while ((ptr - buf) & 3)
587 ptr++; // 4byte align
589 for (j = 257; j < 512; j++) {
590 int min_freq[2] = { 256 * 256, 256 * 256 };
591 int smallest[2] = { 0, 0 };
593 for (i = 0; i < j; i++) {
594 if (frequency[i] == 0)
596 if (frequency[i] < min_freq[1]) {
597 if (frequency[i] < min_freq[0]) {
598 min_freq[1] = min_freq[0];
599 smallest[1] = smallest[0];
600 min_freq[0] = frequency[i];
603 min_freq[1] = frequency[i];
608 if (min_freq[1] == 256 * 256)
611 frequency[j] = min_freq[0] + min_freq[1];
612 flag[smallest[0]] = 0;
613 flag[smallest[1]] = 1;
616 frequency[smallest[0]] = frequency[smallest[1]] = 0;
619 for (j = 0; j < 257; j++) {
620 int node, len = 0, bits = 0;
622 for (node = j; up[node] != -1; node = up[node]) {
623 bits += flag[node] << len;
626 // can this happen at all ?
627 av_log(f->avctx, AV_LOG_ERROR,
628 "vlc length overflow\n");
635 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
642 static int mix(int c0, int c1)
644 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
645 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
646 int red = 2 * (c0 >> 10) + (c1 >> 10);
647 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
650 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
653 const int width = f->avctx->width;
654 const int height = f->avctx->height;
655 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
656 uint16_t *dst = (uint16_t*)f->current_picture->data[0];
657 const int stride = f->current_picture->linesize[0]>>1;
660 if (length < mbs * 8) {
661 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
662 return AVERROR_INVALIDDATA;
664 bytestream2_init(&g3, buf, length);
666 for (y = 0; y < height; y += 16) {
667 for (x = 0; x < width; x += 16) {
668 unsigned int color[4] = { 0 }, bits;
669 // warning following is purely guessed ...
670 color[0] = bytestream2_get_le16u(&g3);
671 color[1] = bytestream2_get_le16u(&g3);
673 if (color[0] & 0x8000)
674 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
675 if (color[1] & 0x8000)
676 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
678 color[2] = mix(color[0], color[1]);
679 color[3] = mix(color[1], color[0]);
681 bits = bytestream2_get_le32u(&g3);
682 for (y2 = 0; y2 < 16; y2++) {
683 for (x2 = 0; x2 < 16; x2++) {
684 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
685 dst[y2 * stride + x2] = color[(bits >> index) & 3];
690 dst += 16 * stride - x;
696 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
699 const int width = f->avctx->width;
700 const int height = f->avctx->height;
701 const unsigned int bitstream_size = AV_RL32(buf);
702 int token_count av_unused;
703 unsigned int prestream_size;
704 const uint8_t *prestream;
706 if (length < bitstream_size + 12) {
707 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
708 return AVERROR_INVALIDDATA;
711 token_count = AV_RL32(buf + bitstream_size + 8);
712 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
713 prestream = buf + bitstream_size + 12;
715 if (prestream_size + bitstream_size + 12 != length
716 || bitstream_size > (1 << 26)
717 || prestream_size > (1 << 26)) {
718 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
719 prestream_size, bitstream_size, length);
720 return AVERROR_INVALIDDATA;
723 prestream = read_huffman_tables(f, prestream);
725 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
727 prestream_size = length + buf - prestream;
729 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
730 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
731 if (!f->bitstream_buffer)
732 return AVERROR(ENOMEM);
733 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
735 memset((uint8_t*)f->bitstream_buffer + prestream_size,
736 0, FF_INPUT_BUFFER_PADDING_SIZE);
737 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
739 f->last_dc = 0 * 128 * 8 * 8;
741 for (y = 0; y < height; y += 16) {
742 for (x = 0; x < width; x += 16) {
743 if ((ret = decode_i_mb(f)) < 0)
750 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
751 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
756 static int decode_frame(AVCodecContext *avctx, void *data,
757 int *got_frame, AVPacket *avpkt)
759 const uint8_t *buf = avpkt->data;
760 int buf_size = avpkt->size;
761 FourXContext *const f = avctx->priv_data;
762 AVFrame *picture = data;
764 int i, frame_4cc, frame_size, ret;
766 frame_4cc = AV_RL32(buf);
767 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
768 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
769 buf_size, AV_RL32(buf + 4));
771 if (frame_4cc == AV_RL32("cfrm")) {
773 const int data_size = buf_size - 20;
774 const int id = AV_RL32(buf + 12);
775 const int whole_size = AV_RL32(buf + 16);
778 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
779 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
780 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
783 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
784 if (f->cfrm[i].id == id)
786 if (f->cfrm[i].size == 0)
790 if (i >= CFRAME_BUFFER_COUNT) {
796 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
797 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
798 // explicit check needed as memcpy below might not catch a NULL
800 av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
801 return AVERROR(ENOMEM);
804 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
805 cfrm->size += data_size;
807 if (cfrm->size >= whole_size) {
809 frame_size = cfrm->size;
811 if (id != avctx->frame_number)
812 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
813 id, avctx->frame_number);
815 cfrm->size = cfrm->id = 0;
816 frame_4cc = AV_RL32("pfrm");
821 frame_size = buf_size - 12;
824 FFSWAP(AVFrame*, f->current_picture, f->last_picture);
826 p = f->current_picture;
827 avctx->coded_frame = p;
829 // alternatively we would have to use our own buffer management
830 avctx->flags |= CODEC_FLAG_EMU_EDGE;
833 avctx->release_buffer(avctx, p);
836 if ((ret = ff_get_buffer(avctx, p)) < 0) {
837 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
841 if (frame_4cc == AV_RL32("ifr2")) {
842 p->pict_type = AV_PICTURE_TYPE_I;
843 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0)
845 } else if (frame_4cc == AV_RL32("ifrm")) {
846 p->pict_type = AV_PICTURE_TYPE_I;
847 if ((ret = decode_i_frame(f, buf, frame_size)) < 0)
849 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
850 if (!f->last_picture->data[0]) {
851 f->last_picture->reference = 1;
852 if ((ret = ff_get_buffer(avctx, f->last_picture)) < 0) {
853 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
856 memset(f->last_picture->data[0], 0, avctx->height * FFABS(f->last_picture->linesize[0]));
859 p->pict_type = AV_PICTURE_TYPE_P;
860 if ((ret = decode_p_frame(f, buf, frame_size)) < 0)
862 } else if (frame_4cc == AV_RL32("snd_")) {
863 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
866 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
870 p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
880 static av_cold int decode_init(AVCodecContext *avctx)
882 FourXContext * const f = avctx->priv_data;
884 if (avctx->extradata_size != 4 || !avctx->extradata) {
885 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
889 f->version = AV_RL32(avctx->extradata) >> 16;
890 ff_dsputil_init(&f->dsp, avctx);
895 avctx->pix_fmt = AV_PIX_FMT_RGB565;
897 avctx->pix_fmt = AV_PIX_FMT_BGR555;
899 f->current_picture = avcodec_alloc_frame();
900 f->last_picture = avcodec_alloc_frame();
901 if (!f->current_picture || !f->last_picture) {
902 avcodec_free_frame(&f->current_picture);
903 avcodec_free_frame(&f->last_picture);
904 return AVERROR(ENOMEM);
911 static av_cold int decode_end(AVCodecContext *avctx)
913 FourXContext * const f = avctx->priv_data;
916 av_freep(&f->bitstream_buffer);
917 f->bitstream_buffer_size = 0;
918 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
919 av_freep(&f->cfrm[i].data);
920 f->cfrm[i].allocated_size = 0;
922 ff_free_vlc(&f->pre_vlc);
923 if (f->current_picture->data[0])
924 avctx->release_buffer(avctx, f->current_picture);
925 if (f->last_picture->data[0])
926 avctx->release_buffer(avctx, f->last_picture);
927 avcodec_free_frame(&f->current_picture);
928 avcodec_free_frame(&f->last_picture);
933 AVCodec ff_fourxm_decoder = {
935 .type = AVMEDIA_TYPE_VIDEO,
936 .id = AV_CODEC_ID_4XM,
937 .priv_data_size = sizeof(FourXContext),
940 .decode = decode_frame,
941 .capabilities = CODEC_CAP_DR1,
942 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),