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/intreadwrite.h"
29 #include "bytestream.h"
33 #include "libavutil/avassert.h"
35 #define BLOCK_TYPE_VLC_BITS 5
36 #define ACDC_VLC_BITS 9
38 #define CFRAME_BUFFER_COUNT 100
40 static const uint8_t block_type_tab[2][4][8][2] = {
42 { // { 8, 4, 2 } x { 8, 4, 2}
43 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
45 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
47 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
52 { // { 8, 4, 2 } x { 8, 4, 2}
53 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
55 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
64 static const uint8_t size2index[4][4] = {
71 static const int8_t mv[256][2] = {
72 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
73 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
74 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
75 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
76 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
77 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
78 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
79 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
80 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
81 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
82 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
83 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
84 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
85 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
86 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
87 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
88 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
89 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
90 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
91 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
92 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
93 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
94 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
95 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
96 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
97 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
98 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
99 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
100 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
101 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
102 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
103 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
106 /* This is simply the scaled down elementwise product of the standard JPEG
107 * quantizer table and the AAN premul table. */
108 static const uint8_t dequant_table[64] = {
109 16, 15, 13, 19, 24, 31, 28, 17,
110 17, 23, 25, 31, 36, 63, 45, 21,
111 18, 24, 27, 37, 52, 59, 49, 20,
112 16, 28, 34, 40, 60, 80, 51, 20,
113 18, 31, 48, 66, 68, 86, 56, 21,
114 19, 38, 56, 59, 64, 64, 48, 20,
115 27, 48, 55, 55, 56, 51, 35, 15,
116 20, 35, 34, 32, 31, 22, 15, 8,
119 static VLC block_type_vlc[2][4];
122 typedef struct CFrameBuffer {
123 unsigned int allocated_size;
129 typedef struct FourXContext {
130 AVCodecContext *avctx;
132 AVFrame current_picture, last_picture;
133 GetBitContext pre_gb; ///< ac/dc prefix
140 DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
141 void *bitstream_buffer;
142 unsigned int bitstream_buffer_size;
144 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
148 #define FIX_1_082392200 70936
149 #define FIX_1_414213562 92682
150 #define FIX_1_847759065 121095
151 #define FIX_2_613125930 171254
153 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
155 static void idct(DCTELEM block[64])
157 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
158 int tmp10, tmp11, tmp12, tmp13;
159 int z5, z10, z11, z12, z13;
163 for (i = 0; i < 8; i++) {
164 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
165 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
167 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
168 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
170 tmp0 = tmp10 + tmp13;
171 tmp3 = tmp10 - tmp13;
172 tmp1 = tmp11 + tmp12;
173 tmp2 = tmp11 - tmp12;
175 z13 = block[8 * 5 + i] + block[8 * 3 + i];
176 z10 = block[8 * 5 + i] - block[8 * 3 + i];
177 z11 = block[8 * 1 + i] + block[8 * 7 + i];
178 z12 = block[8 * 1 + i] - block[8 * 7 + i];
181 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
183 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
184 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
185 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
191 temp[8 * 0 + i] = tmp0 + tmp7;
192 temp[8 * 7 + i] = tmp0 - tmp7;
193 temp[8 * 1 + i] = tmp1 + tmp6;
194 temp[8 * 6 + i] = tmp1 - tmp6;
195 temp[8 * 2 + i] = tmp2 + tmp5;
196 temp[8 * 5 + i] = tmp2 - tmp5;
197 temp[8 * 4 + i] = tmp3 + tmp4;
198 temp[8 * 3 + i] = tmp3 - tmp4;
201 for (i = 0; i < 8 * 8; i += 8) {
202 tmp10 = temp[0 + i] + temp[4 + i];
203 tmp11 = temp[0 + i] - temp[4 + i];
205 tmp13 = temp[2 + i] + temp[6 + i];
206 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
208 tmp0 = tmp10 + tmp13;
209 tmp3 = tmp10 - tmp13;
210 tmp1 = tmp11 + tmp12;
211 tmp2 = tmp11 - tmp12;
213 z13 = temp[5 + i] + temp[3 + i];
214 z10 = temp[5 + i] - temp[3 + i];
215 z11 = temp[1 + i] + temp[7 + i];
216 z12 = temp[1 + i] - temp[7 + i];
219 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
221 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
222 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
223 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
229 block[0 + i] = (tmp0 + tmp7) >> 6;
230 block[7 + i] = (tmp0 - tmp7) >> 6;
231 block[1 + i] = (tmp1 + tmp6) >> 6;
232 block[6 + i] = (tmp1 - tmp6) >> 6;
233 block[2 + i] = (tmp2 + tmp5) >> 6;
234 block[5 + i] = (tmp2 - tmp5) >> 6;
235 block[4 + i] = (tmp3 + tmp4) >> 6;
236 block[3 + i] = (tmp3 - tmp4) >> 6;
240 static av_cold void init_vlcs(FourXContext *f)
242 static VLC_TYPE table[2][4][32][2];
245 for (i = 0; i < 2; i++) {
246 for (j = 0; j < 4; j++) {
247 block_type_vlc[i][j].table = table[i][j];
248 block_type_vlc[i][j].table_allocated = 32;
249 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
250 &block_type_tab[i][j][0][1], 2, 1,
251 &block_type_tab[i][j][0][0], 2, 1,
252 INIT_VLC_USE_NEW_STATIC);
257 static void init_mv(FourXContext *f)
261 for (i = 0; i < 256; i++) {
263 f->mv[i] = mv[i][0] + mv[i][1] * f->current_picture.linesize[0] / 2;
265 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * f->current_picture.linesize[0] / 2;
270 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
272 unsigned tmpval = AV_RN32(src); \
273 tmpval = (tmpval << 16) | (tmpval >> 16); \
274 tmpval = tmpval * (scale) + (dc); \
275 tmpval = (tmpval << 16) | (tmpval >> 16); \
276 AV_WN32A(dst, tmpval); \
279 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
281 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
282 AV_WN32A(dst, tmpval); \
286 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
287 int h, int stride, int scale, unsigned dc)
294 for (i = 0; i < h; i++) {
295 dst[0] = scale * src[0] + dc;
302 for (i = 0; i < h; i++) {
303 LE_CENTRIC_MUL(dst, src, scale, dc);
310 for (i = 0; i < h; i++) {
311 LE_CENTRIC_MUL(dst, src, scale, dc);
312 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
319 for (i = 0; i < h; i++) {
320 LE_CENTRIC_MUL(dst, src, scale, dc);
321 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
322 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
323 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
334 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
335 int log2w, int log2h, int stride)
337 const int index = size2index[log2h][log2w];
338 const int h = 1 << log2h;
339 int code = get_vlc2(&f->gb,
340 block_type_vlc[1 - (f->version > 1)][index].table,
341 BLOCK_TYPE_VLC_BITS, 1);
342 uint16_t *start = (uint16_t *)f->last_picture.data[0];
343 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
345 av_assert2(code >= 0 && code <= 6);
348 if (f->g.buffer_end - f->g.buffer < 1) {
349 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
352 src += f->mv[bytestream2_get_byte(&f->g)];
353 if (start > src || src > end) {
354 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
357 mcdc(dst, src, log2w, h, stride, 1, 0);
358 } else if (code == 1) {
360 decode_p_block(f, dst, src, log2w, log2h, stride);
361 decode_p_block(f, dst + (stride << log2h),
362 src + (stride << log2h), log2w, log2h, stride);
363 } else if (code == 2) {
365 decode_p_block(f, dst , src, log2w, log2h, stride);
366 decode_p_block(f, dst + (1 << log2w),
367 src + (1 << log2w), log2w, log2h, stride);
368 } else if (code == 3 && f->version < 2) {
369 mcdc(dst, src, log2w, h, stride, 1, 0);
370 } else if (code == 4) {
371 if (f->g.buffer_end - f->g.buffer < 1) {
372 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
375 src += f->mv[bytestream2_get_byte(&f->g)];
376 if (start > src || src > end) {
377 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
380 if (f->g2.buffer_end - f->g2.buffer < 1){
381 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
384 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
385 } else if (code == 5) {
386 if (f->g2.buffer_end - f->g2.buffer < 1) {
387 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
390 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
391 } else if (code == 6) {
392 if (f->g2.buffer_end - f->g2.buffer < 2) {
393 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
397 dst[0] = bytestream2_get_le16(&f->g2);
398 dst[1] = bytestream2_get_le16(&f->g2);
400 dst[0] = bytestream2_get_le16(&f->g2);
401 dst[stride] = bytestream2_get_le16(&f->g2);
406 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
409 const int width = f->avctx->width;
410 const int height = f->avctx->height;
411 uint16_t *src = (uint16_t *)f->last_picture.data[0];
412 uint16_t *dst = (uint16_t *)f->current_picture.data[0];
413 const int stride = f->current_picture.linesize[0] >> 1;
414 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
415 bytestream_offset, wordstream_offset;
417 if (f->version > 1) {
421 bitstream_size = AV_RL32(buf + 8);
422 wordstream_size = AV_RL32(buf + 12);
423 bytestream_size = AV_RL32(buf + 16);
426 bitstream_size = AV_RL16(buf - 4);
427 wordstream_size = AV_RL16(buf - 2);
428 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
431 if (bitstream_size > length ||
432 bytestream_size > length - bitstream_size ||
433 wordstream_size > length - bytestream_size - bitstream_size ||
434 extra > length - bytestream_size - bitstream_size - wordstream_size) {
435 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
436 bitstream_size+ bytestream_size+ wordstream_size - length);
440 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
441 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
442 if (!f->bitstream_buffer)
443 return AVERROR(ENOMEM);
444 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
446 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
447 0, FF_INPUT_BUFFER_PADDING_SIZE);
448 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
450 wordstream_offset = extra + bitstream_size;
451 bytestream_offset = extra + bitstream_size + wordstream_size;
452 bytestream2_init(&f->g2, buf + wordstream_offset,
453 length - wordstream_offset);
454 bytestream2_init(&f->g, buf + bytestream_offset,
455 length - bytestream_offset);
459 for (y = 0; y < height; y += 8) {
460 for (x = 0; x < width; x += 8)
461 decode_p_block(f, dst + x, src + x, 3, 3, stride);
470 * decode block and dequantize.
471 * Note this is almost identical to MJPEG.
473 static int decode_i_block(FourXContext *f, DCTELEM *block)
475 int code, i, j, level, val;
477 if (get_bits_left(&f->gb) < 2){
478 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
483 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
485 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
488 val = get_xbits(&f->gb, val);
490 val = val * dequant_table[0] + f->last_dc;
491 f->last_dc = block[0] = val;
495 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
503 level = get_xbits(&f->gb, code & 0xf);
506 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
510 j = ff_zigzag_direct[i];
511 block[j] = level * dequant_table[j];
521 static inline void idct_put(FourXContext *f, int x, int y)
523 DCTELEM (*block)[64] = f->block;
524 int stride = f->current_picture.linesize[0] >> 1;
526 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
528 for (i = 0; i < 4; i++) {
529 block[i][0] += 0x80 * 8 * 8;
533 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
534 for (i = 4; i < 6; i++)
538 /* Note transform is:
539 * y = ( 1b + 4g + 2r) / 14
540 * cb = ( 3b - 2g - 1r) / 14
541 * cr = (-1b - 4g + 5r) / 14 */
542 for (y = 0; y < 8; y++) {
543 for (x = 0; x < 8; x++) {
544 DCTELEM *temp = block[(x >> 2) + 2 * (y >> 2)] +
545 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
546 int cb = block[4][x + 8 * y];
547 int cr = block[5][x + 8 * y];
548 int cg = (cb + cr) >> 1;
554 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
556 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
558 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
560 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
563 dst += 2 * stride - 2 * 8;
567 static int decode_i_mb(FourXContext *f)
571 f->dsp.clear_blocks(f->block[0]);
573 for (i = 0; i < 6; i++)
574 if (decode_i_block(f, f->block[i]) < 0)
580 static const uint8_t *read_huffman_tables(FourXContext *f,
581 const uint8_t * const buf, int buf_size)
583 int frequency[512] = { 0 };
586 uint8_t len_tab[257];
589 const uint8_t *ptr = buf;
590 const uint8_t *ptr_end = buf + buf_size;
593 memset(up, -1, sizeof(up));
600 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
602 for (i = start; i <= end; i++)
603 frequency[i] = *ptr++;
612 while ((ptr - buf) & 3)
613 ptr++; // 4byte align
615 for (j = 257; j < 512; j++) {
616 int min_freq[2] = { 256 * 256, 256 * 256 };
617 int smallest[2] = { 0, 0 };
619 for (i = 0; i < j; i++) {
620 if (frequency[i] == 0)
622 if (frequency[i] < min_freq[1]) {
623 if (frequency[i] < min_freq[0]) {
624 min_freq[1] = min_freq[0];
625 smallest[1] = smallest[0];
626 min_freq[0] = frequency[i];
629 min_freq[1] = frequency[i];
634 if (min_freq[1] == 256 * 256)
637 frequency[j] = min_freq[0] + min_freq[1];
638 flag[smallest[0]] = 0;
639 flag[smallest[1]] = 1;
642 frequency[smallest[0]] = frequency[smallest[1]] = 0;
645 for (j = 0; j < 257; j++) {
646 int node, len = 0, bits = 0;
648 for (node = j; up[node] != -1; node = up[node]) {
649 bits += flag[node] << len;
652 // can this happen at all ?
653 av_log(f->avctx, AV_LOG_ERROR,
654 "vlc length overflow\n");
661 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
668 static int mix(int c0, int c1)
670 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
671 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
672 int red = 2 * (c0 >> 10) + (c1 >> 10);
673 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
676 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
679 const int width = f->avctx->width;
680 const int height = f->avctx->height;
681 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
682 uint16_t *dst = (uint16_t*)f->current_picture.data[0];
683 const int stride = f->current_picture.linesize[0]>>1;
684 const uint8_t *buf_end = buf + length;
687 if (length < mbs * 8) {
688 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
689 return AVERROR_INVALIDDATA;
691 bytestream2_init(&g3, buf, length);
693 for (y = 0; y < height; y += 16) {
694 for (x = 0; x < width; x += 16) {
695 unsigned int color[4] = { 0 }, bits;
696 if (buf_end - buf < 8)
698 // warning following is purely guessed ...
699 color[0] = bytestream2_get_le16u(&g3);
700 color[1] = bytestream2_get_le16u(&g3);
702 if (color[0] & 0x8000)
703 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
704 if (color[1] & 0x8000)
705 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
707 color[2] = mix(color[0], color[1]);
708 color[3] = mix(color[1], color[0]);
710 bits = bytestream2_get_le32u(&g3);
711 for (y2 = 0; y2 < 16; y2++) {
712 for (x2 = 0; x2 < 16; x2++) {
713 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
714 dst[y2 * stride + x2] = color[(bits >> index) & 3];
719 dst += 16 * stride - x;
725 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
728 const int width = f->avctx->width;
729 const int height = f->avctx->height;
730 const unsigned int bitstream_size = AV_RL32(buf);
731 unsigned int prestream_size;
732 const uint8_t *prestream;
734 if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
735 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
736 return AVERROR_INVALIDDATA;
739 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
740 prestream = buf + bitstream_size + 12;
742 if (prestream_size + bitstream_size + 12 != length
743 || bitstream_size > (1 << 26)
744 || prestream_size > (1 << 26)) {
745 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
746 prestream_size, bitstream_size, length);
750 prestream = read_huffman_tables(f, prestream, buf + length - prestream);
754 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
756 prestream_size = length + buf - prestream;
758 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
759 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
760 if (!f->bitstream_buffer)
761 return AVERROR(ENOMEM);
762 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
764 memset((uint8_t*)f->bitstream_buffer + prestream_size,
765 0, FF_INPUT_BUFFER_PADDING_SIZE);
766 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
768 f->last_dc = 0 * 128 * 8 * 8;
770 for (y = 0; y < height; y += 16) {
771 for (x = 0; x < width; x += 16) {
772 if (decode_i_mb(f) < 0)
779 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
780 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
785 static int decode_frame(AVCodecContext *avctx, void *data,
786 int *data_size, AVPacket *avpkt)
788 const uint8_t *buf = avpkt->data;
789 int buf_size = avpkt->size;
790 FourXContext *const f = avctx->priv_data;
791 AVFrame *picture = data;
793 int i, frame_4cc, frame_size;
796 return AVERROR_INVALIDDATA;
797 frame_4cc = AV_RL32(buf);
798 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
799 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
800 buf_size, AV_RL32(buf + 4));
802 if (frame_4cc == AV_RL32("cfrm")) {
804 const int data_size = buf_size - 20;
805 const int id = AV_RL32(buf + 12);
806 const int whole_size = AV_RL32(buf + 16);
809 if (data_size < 0 || whole_size < 0) {
810 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
811 return AVERROR_INVALIDDATA;
814 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
815 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
816 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
819 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
820 if (f->cfrm[i].id == id)
822 if (f->cfrm[i].size == 0)
826 if (i >= CFRAME_BUFFER_COUNT) {
832 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
833 return AVERROR_INVALIDDATA;
835 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
836 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
837 // explicit check needed as memcpy below might not catch a NULL
839 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
843 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
844 cfrm->size += data_size;
846 if (cfrm->size >= whole_size) {
848 frame_size = cfrm->size;
850 if (id != avctx->frame_number)
851 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
852 id, avctx->frame_number);
854 cfrm->size = cfrm->id = 0;
855 frame_4cc = AV_RL32("pfrm");
860 frame_size = buf_size - 12;
863 temp = f->current_picture;
864 f->current_picture = f->last_picture;
865 f->last_picture = temp;
867 p = &f->current_picture;
868 avctx->coded_frame = p;
870 // alternatively we would have to use our own buffer management
871 avctx->flags |= CODEC_FLAG_EMU_EDGE;
874 if (avctx->reget_buffer(avctx, p) < 0) {
875 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
879 if (frame_4cc == AV_RL32("ifr2")) {
880 p->pict_type= AV_PICTURE_TYPE_I;
881 if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0) {
882 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
885 } else if (frame_4cc == AV_RL32("ifrm")) {
886 p->pict_type= AV_PICTURE_TYPE_I;
887 if (decode_i_frame(f, buf, frame_size) < 0) {
888 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
891 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
892 if (!f->last_picture.data[0]) {
893 f->last_picture.reference = 3;
894 if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
895 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
900 p->pict_type = AV_PICTURE_TYPE_P;
901 if (decode_p_frame(f, buf, frame_size) < 0) {
902 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
905 } else if (frame_4cc == AV_RL32("snd_")) {
906 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
909 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
913 p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
916 *data_size = sizeof(AVPicture);
924 static av_cold void common_init(AVCodecContext *avctx)
926 FourXContext * const f = avctx->priv_data;
928 ff_dsputil_init(&f->dsp, avctx);
933 static av_cold int decode_init(AVCodecContext *avctx)
935 FourXContext * const f = avctx->priv_data;
937 if (avctx->extradata_size != 4 || !avctx->extradata) {
938 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
941 if((avctx->width % 16) || (avctx->height % 16)) {
942 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
943 return AVERROR_INVALIDDATA;
946 avcodec_get_frame_defaults(&f->current_picture);
947 avcodec_get_frame_defaults(&f->last_picture);
948 f->version = AV_RL32(avctx->extradata) >> 16;
953 avctx->pix_fmt = PIX_FMT_RGB565;
955 avctx->pix_fmt = PIX_FMT_BGR555;
961 static av_cold int decode_end(AVCodecContext *avctx)
963 FourXContext * const f = avctx->priv_data;
966 av_freep(&f->bitstream_buffer);
967 f->bitstream_buffer_size = 0;
968 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
969 av_freep(&f->cfrm[i].data);
970 f->cfrm[i].allocated_size = 0;
972 ff_free_vlc(&f->pre_vlc);
973 if (f->current_picture.data[0])
974 avctx->release_buffer(avctx, &f->current_picture);
975 if (f->last_picture.data[0])
976 avctx->release_buffer(avctx, &f->last_picture);
981 AVCodec ff_fourxm_decoder = {
983 .type = AVMEDIA_TYPE_VIDEO,
985 .priv_data_size = sizeof(FourXContext),
988 .decode = decode_frame,
989 .capabilities = CODEC_CAP_DR1,
990 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),