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"
36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
39 #define CFRAME_BUFFER_COUNT 100
41 static const uint8_t block_type_tab[2][4][8][2] = {
43 { // { 8, 4, 2 } x { 8, 4, 2}
44 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
46 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
48 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
53 { // { 8, 4, 2 } x { 8, 4, 2}
54 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
56 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
65 static const uint8_t size2index[4][4] = {
72 static const int8_t mv[256][2] = {
73 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
74 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
75 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
76 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
77 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
78 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
79 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
80 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
81 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
82 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
83 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
84 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
85 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
86 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
87 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
88 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
89 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
90 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
91 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
92 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
93 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
94 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
95 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
96 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
97 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
98 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
99 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
100 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
101 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
102 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
103 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
104 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
107 /* This is simply the scaled down elementwise product of the standard JPEG
108 * quantizer table and the AAN premul table. */
109 static const uint8_t dequant_table[64] = {
110 16, 15, 13, 19, 24, 31, 28, 17,
111 17, 23, 25, 31, 36, 63, 45, 21,
112 18, 24, 27, 37, 52, 59, 49, 20,
113 16, 28, 34, 40, 60, 80, 51, 20,
114 18, 31, 48, 66, 68, 86, 56, 21,
115 19, 38, 56, 59, 64, 64, 48, 20,
116 27, 48, 55, 55, 56, 51, 35, 15,
117 20, 35, 34, 32, 31, 22, 15, 8,
120 static VLC block_type_vlc[2][4];
123 typedef struct CFrameBuffer {
124 unsigned int allocated_size;
130 typedef struct FourXContext {
131 AVCodecContext *avctx;
133 AVFrame current_picture, last_picture;
134 GetBitContext pre_gb; ///< ac/dc prefix
141 DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
142 void *bitstream_buffer;
143 unsigned int bitstream_buffer_size;
145 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
149 #define FIX_1_082392200 70936
150 #define FIX_1_414213562 92682
151 #define FIX_1_847759065 121095
152 #define FIX_2_613125930 171254
154 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
156 static void idct(DCTELEM block[64])
158 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
159 int tmp10, tmp11, tmp12, tmp13;
160 int z5, z10, z11, z12, z13;
164 for (i = 0; i < 8; i++) {
165 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
166 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
168 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
169 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
171 tmp0 = tmp10 + tmp13;
172 tmp3 = tmp10 - tmp13;
173 tmp1 = tmp11 + tmp12;
174 tmp2 = tmp11 - tmp12;
176 z13 = block[8 * 5 + i] + block[8 * 3 + i];
177 z10 = block[8 * 5 + i] - block[8 * 3 + i];
178 z11 = block[8 * 1 + i] + block[8 * 7 + i];
179 z12 = block[8 * 1 + i] - block[8 * 7 + i];
182 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
184 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
185 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
186 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
192 temp[8 * 0 + i] = tmp0 + tmp7;
193 temp[8 * 7 + i] = tmp0 - tmp7;
194 temp[8 * 1 + i] = tmp1 + tmp6;
195 temp[8 * 6 + i] = tmp1 - tmp6;
196 temp[8 * 2 + i] = tmp2 + tmp5;
197 temp[8 * 5 + i] = tmp2 - tmp5;
198 temp[8 * 4 + i] = tmp3 + tmp4;
199 temp[8 * 3 + i] = tmp3 - tmp4;
202 for (i = 0; i < 8 * 8; i += 8) {
203 tmp10 = temp[0 + i] + temp[4 + i];
204 tmp11 = temp[0 + i] - temp[4 + i];
206 tmp13 = temp[2 + i] + temp[6 + i];
207 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
209 tmp0 = tmp10 + tmp13;
210 tmp3 = tmp10 - tmp13;
211 tmp1 = tmp11 + tmp12;
212 tmp2 = tmp11 - tmp12;
214 z13 = temp[5 + i] + temp[3 + i];
215 z10 = temp[5 + i] - temp[3 + i];
216 z11 = temp[1 + i] + temp[7 + i];
217 z12 = temp[1 + i] - temp[7 + i];
220 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
222 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
223 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
224 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
230 block[0 + i] = (tmp0 + tmp7) >> 6;
231 block[7 + i] = (tmp0 - tmp7) >> 6;
232 block[1 + i] = (tmp1 + tmp6) >> 6;
233 block[6 + i] = (tmp1 - tmp6) >> 6;
234 block[2 + i] = (tmp2 + tmp5) >> 6;
235 block[5 + i] = (tmp2 - tmp5) >> 6;
236 block[4 + i] = (tmp3 + tmp4) >> 6;
237 block[3 + i] = (tmp3 - tmp4) >> 6;
241 static av_cold void init_vlcs(FourXContext *f)
243 static VLC_TYPE table[8][32][2];
246 for (i = 0; i < 8; i++) {
247 block_type_vlc[0][i].table = table[i];
248 block_type_vlc[0][i].table_allocated = 32;
249 init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
250 &block_type_tab[0][i][0][1], 2, 1,
251 &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
255 static void init_mv(FourXContext *f)
259 for (i = 0; i < 256; i++) {
261 f->mv[i] = mv[i][0] + mv[i][1] * f->current_picture.linesize[0] / 2;
263 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * f->current_picture.linesize[0] / 2;
268 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
270 unsigned tmpval = AV_RN32(src); \
271 tmpval = (tmpval << 16) | (tmpval >> 16); \
272 tmpval = tmpval * (scale) + (dc); \
273 tmpval = (tmpval << 16) | (tmpval >> 16); \
274 AV_WN32A(dst, tmpval); \
277 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
279 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
280 AV_WN32A(dst, tmpval); \
284 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
285 int h, int stride, int scale, unsigned dc)
292 for (i = 0; i < h; i++) {
293 dst[0] = scale * src[0] + dc;
300 for (i = 0; i < h; i++) {
301 LE_CENTRIC_MUL(dst, src, scale, dc);
308 for (i = 0; i < h; i++) {
309 LE_CENTRIC_MUL(dst, src, scale, dc);
310 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
317 for (i = 0; i < h; i++) {
318 LE_CENTRIC_MUL(dst, src, scale, dc);
319 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
320 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
321 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
332 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
333 int log2w, int log2h, int stride)
335 const int index = size2index[log2h][log2w];
336 const int h = 1 << log2h;
337 int code = get_vlc2(&f->gb,
338 block_type_vlc[1 - (f->version > 1)][index].table,
339 BLOCK_TYPE_VLC_BITS, 1);
340 uint16_t *start = (uint16_t *)f->last_picture.data[0];
341 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
343 assert(code >= 0 && code <= 6);
346 src += f->mv[bytestream2_get_byte(&f->g)];
347 if (start > src || src > end) {
348 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
351 mcdc(dst, src, log2w, h, stride, 1, 0);
352 } else if (code == 1) {
354 decode_p_block(f, dst, src, log2w, log2h, stride);
355 decode_p_block(f, dst + (stride << log2h),
356 src + (stride << log2h), log2w, log2h, stride);
357 } else if (code == 2) {
359 decode_p_block(f, dst , src, log2w, log2h, stride);
360 decode_p_block(f, dst + (1 << log2w),
361 src + (1 << log2w), log2w, log2h, stride);
362 } else if (code == 3 && f->version < 2) {
363 mcdc(dst, src, log2w, h, stride, 1, 0);
364 } else if (code == 4) {
365 src += f->mv[bytestream2_get_byte(&f->g)];
366 if (start > src || src > end) {
367 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
370 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
371 } else if (code == 5) {
372 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
373 } else if (code == 6) {
375 dst[0] = bytestream2_get_le16(&f->g2);
376 dst[1] = bytestream2_get_le16(&f->g2);
378 dst[0] = bytestream2_get_le16(&f->g2);
379 dst[stride] = bytestream2_get_le16(&f->g2);
384 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
387 const int width = f->avctx->width;
388 const int height = f->avctx->height;
389 uint16_t *src = (uint16_t *)f->last_picture.data[0];
390 uint16_t *dst = (uint16_t *)f->current_picture.data[0];
391 const int stride = f->current_picture.linesize[0] >> 1;
392 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
393 bytestream_offset, wordstream_offset;
395 if (f->version > 1) {
397 bitstream_size = AV_RL32(buf + 8);
398 wordstream_size = AV_RL32(buf + 12);
399 bytestream_size = AV_RL32(buf + 16);
402 bitstream_size = AV_RL16(buf - 4);
403 wordstream_size = AV_RL16(buf - 2);
404 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
407 if (bitstream_size + bytestream_size + wordstream_size + extra != length
408 || bitstream_size > (1 << 26)
409 || bytestream_size > (1 << 26)
410 || wordstream_size > (1 << 26)) {
411 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
412 bitstream_size, bytestream_size, wordstream_size,
413 bitstream_size + bytestream_size + wordstream_size - length);
417 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
418 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
419 if (!f->bitstream_buffer)
420 return AVERROR(ENOMEM);
421 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
423 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
424 0, FF_INPUT_BUFFER_PADDING_SIZE);
425 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
427 wordstream_offset = extra + bitstream_size;
428 bytestream_offset = extra + bitstream_size + wordstream_size;
429 bytestream2_init(&f->g2, buf + wordstream_offset,
430 length - wordstream_offset);
431 bytestream2_init(&f->g, buf + bytestream_offset,
432 length - bytestream_offset);
436 for (y = 0; y < height; y += 8) {
437 for (x = 0; x < width; x += 8)
438 decode_p_block(f, dst + x, src + x, 3, 3, stride);
447 * decode block and dequantize.
448 * Note this is almost identical to MJPEG.
450 static int decode_i_block(FourXContext *f, DCTELEM *block)
452 int code, i, j, level, val;
455 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
457 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
460 val = get_xbits(&f->gb, val);
462 val = val * dequant_table[0] + f->last_dc;
463 f->last_dc = block[0] = val;
467 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
475 level = get_xbits(&f->gb, code & 0xf);
478 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
482 j = ff_zigzag_direct[i];
483 block[j] = level * dequant_table[j];
493 static inline void idct_put(FourXContext *f, int x, int y)
495 DCTELEM (*block)[64] = f->block;
496 int stride = f->current_picture.linesize[0] >> 1;
498 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
500 for (i = 0; i < 4; i++) {
501 block[i][0] += 0x80 * 8 * 8;
505 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
506 for (i = 4; i < 6; i++)
510 /* Note transform is:
511 * y = ( 1b + 4g + 2r) / 14
512 * cb = ( 3b - 2g - 1r) / 14
513 * cr = (-1b - 4g + 5r) / 14 */
514 for (y = 0; y < 8; y++) {
515 for (x = 0; x < 8; x++) {
516 DCTELEM *temp = block[(x >> 2) + 2 * (y >> 2)] +
517 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
518 int cb = block[4][x + 8 * y];
519 int cr = block[5][x + 8 * y];
520 int cg = (cb + cr) >> 1;
526 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
528 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
530 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
532 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
535 dst += 2 * stride - 2 * 8;
539 static int decode_i_mb(FourXContext *f)
543 f->dsp.clear_blocks(f->block[0]);
545 for (i = 0; i < 6; i++)
546 if (decode_i_block(f, f->block[i]) < 0)
552 static const uint8_t *read_huffman_tables(FourXContext *f,
553 const uint8_t * const buf)
558 uint8_t len_tab[257];
561 const uint8_t *ptr = buf;
564 memset(frequency, 0, sizeof(frequency));
565 memset(up, -1, sizeof(up));
572 for (i = start; i <= end; i++)
573 frequency[i] = *ptr++;
582 while ((ptr - buf) & 3)
583 ptr++; // 4byte align
585 for (j = 257; j < 512; j++) {
586 int min_freq[2] = { 256 * 256, 256 * 256 };
587 int smallest[2] = { 0, 0 };
589 for (i = 0; i < j; i++) {
590 if (frequency[i] == 0)
592 if (frequency[i] < min_freq[1]) {
593 if (frequency[i] < min_freq[0]) {
594 min_freq[1] = min_freq[0];
595 smallest[1] = smallest[0];
596 min_freq[0] = frequency[i];
599 min_freq[1] = frequency[i];
604 if (min_freq[1] == 256 * 256)
607 frequency[j] = min_freq[0] + min_freq[1];
608 flag[smallest[0]] = 0;
609 flag[smallest[1]] = 1;
612 frequency[smallest[0]] = frequency[smallest[1]] = 0;
615 for (j = 0; j < 257; j++) {
616 int node, len = 0, bits = 0;
618 for (node = j; up[node] != -1; node = up[node]) {
619 bits += flag[node] << len;
622 // can this happen at all ?
623 av_log(f->avctx, AV_LOG_ERROR,
624 "vlc length overflow\n");
631 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
638 static int mix(int c0, int c1)
640 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
641 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
642 int red = 2 * (c0 >> 10) + (c1 >> 10);
643 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
646 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
649 const int width = f->avctx->width;
650 const int height = f->avctx->height;
651 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
652 uint16_t *dst = (uint16_t*)f->current_picture.data[0];
653 const int stride = f->current_picture.linesize[0]>>1;
656 if (length < mbs * 8) {
657 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
658 return AVERROR_INVALIDDATA;
660 bytestream2_init(&g3, buf, length);
662 for (y = 0; y < height; y += 16) {
663 for (x = 0; x < width; x += 16) {
664 unsigned int color[4], bits;
665 memset(color, 0, sizeof(color));
666 // warning following is purely guessed ...
667 color[0] = bytestream2_get_le16u(&g3);
668 color[1] = bytestream2_get_le16u(&g3);
670 if (color[0] & 0x8000)
671 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
672 if (color[1] & 0x8000)
673 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
675 color[2] = mix(color[0], color[1]);
676 color[3] = mix(color[1], color[0]);
678 bits = bytestream2_get_le32u(&g3);
679 for (y2 = 0; y2 < 16; y2++) {
680 for (x2 = 0; x2 < 16; x2++) {
681 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
682 dst[y2 * stride + x2] = color[(bits >> index) & 3];
687 dst += 16 * stride - x;
693 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
696 const int width = f->avctx->width;
697 const int height = f->avctx->height;
698 const unsigned int bitstream_size = AV_RL32(buf);
699 int token_count av_unused;
700 unsigned int prestream_size;
701 const uint8_t *prestream;
703 if (length < bitstream_size + 12) {
704 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
705 return AVERROR_INVALIDDATA;
708 token_count = AV_RL32(buf + bitstream_size + 8);
709 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
710 prestream = buf + bitstream_size + 12;
712 if (prestream_size + bitstream_size + 12 != length
713 || bitstream_size > (1 << 26)
714 || prestream_size > (1 << 26)) {
715 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
716 prestream_size, bitstream_size, length);
720 prestream = read_huffman_tables(f, prestream);
722 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
724 prestream_size = length + buf - prestream;
726 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
727 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
728 if (!f->bitstream_buffer)
729 return AVERROR(ENOMEM);
730 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
732 memset((uint8_t*)f->bitstream_buffer + prestream_size,
733 0, FF_INPUT_BUFFER_PADDING_SIZE);
734 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
736 f->last_dc = 0 * 128 * 8 * 8;
738 for (y = 0; y < height; y += 16) {
739 for (x = 0; x < width; x += 16) {
740 if (decode_i_mb(f) < 0)
747 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
748 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
753 static int decode_frame(AVCodecContext *avctx, void *data,
754 int *data_size, AVPacket *avpkt)
756 const uint8_t *buf = avpkt->data;
757 int buf_size = avpkt->size;
758 FourXContext *const f = avctx->priv_data;
759 AVFrame *picture = data;
761 int i, frame_4cc, frame_size;
763 frame_4cc = AV_RL32(buf);
764 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
765 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
766 buf_size, AV_RL32(buf + 4));
768 if (frame_4cc == AV_RL32("cfrm")) {
770 const int data_size = buf_size - 20;
771 const int id = AV_RL32(buf + 12);
772 const int whole_size = AV_RL32(buf + 16);
775 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
776 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
777 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
780 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
781 if (f->cfrm[i].id == id)
783 if (f->cfrm[i].size == 0)
787 if (i >= CFRAME_BUFFER_COUNT) {
793 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
794 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
795 // explicit check needed as memcpy below might not catch a NULL
797 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
801 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
802 cfrm->size += data_size;
804 if (cfrm->size >= whole_size) {
806 frame_size = cfrm->size;
808 if (id != avctx->frame_number)
809 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
810 id, avctx->frame_number);
812 cfrm->size = cfrm->id = 0;
813 frame_4cc = AV_RL32("pfrm");
818 frame_size = buf_size - 12;
821 temp = f->current_picture;
822 f->current_picture = f->last_picture;
823 f->last_picture = temp;
825 p = &f->current_picture;
826 avctx->coded_frame = p;
828 // alternatively we would have to use our own buffer management
829 avctx->flags |= CODEC_FLAG_EMU_EDGE;
832 avctx->release_buffer(avctx, p);
835 if (avctx->get_buffer(avctx, p) < 0) {
836 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
840 if (frame_4cc == AV_RL32("ifr2")) {
841 p->pict_type = AV_PICTURE_TYPE_I;
842 if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0)
844 } else if (frame_4cc == AV_RL32("ifrm")) {
845 p->pict_type = AV_PICTURE_TYPE_I;
846 if (decode_i_frame(f, buf, frame_size) < 0)
848 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
849 if (!f->last_picture.data[0]) {
850 f->last_picture.reference = 1;
851 if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
852 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
857 p->pict_type = AV_PICTURE_TYPE_P;
858 if (decode_p_frame(f, buf, frame_size) < 0)
860 } else if (frame_4cc == AV_RL32("snd_")) {
861 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
864 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
868 p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
871 *data_size = sizeof(AVPicture);
879 static av_cold void common_init(AVCodecContext *avctx)
881 FourXContext * const f = avctx->priv_data;
883 dsputil_init(&f->dsp, avctx);
888 static av_cold int decode_init(AVCodecContext *avctx)
890 FourXContext * const f = avctx->priv_data;
892 if (avctx->extradata_size != 4 || !avctx->extradata) {
893 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
897 f->version = AV_RL32(avctx->extradata) >> 16;
902 avctx->pix_fmt = PIX_FMT_RGB565;
904 avctx->pix_fmt = PIX_FMT_BGR555;
910 static av_cold int decode_end(AVCodecContext *avctx)
912 FourXContext * const f = avctx->priv_data;
915 av_freep(&f->bitstream_buffer);
916 f->bitstream_buffer_size = 0;
917 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
918 av_freep(&f->cfrm[i].data);
919 f->cfrm[i].allocated_size = 0;
921 free_vlc(&f->pre_vlc);
922 if (f->current_picture.data[0])
923 avctx->release_buffer(avctx, &f->current_picture);
924 if (f->last_picture.data[0])
925 avctx->release_buffer(avctx, &f->last_picture);
930 AVCodec ff_fourxm_decoder = {
932 .type = AVMEDIA_TYPE_VIDEO,
934 .priv_data_size = sizeof(FourXContext),
937 .decode = decode_frame,
938 .capabilities = CODEC_CAP_DR1,
939 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),