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"
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 if (f->g.buffer_end - f->g.buffer < 1) {
347 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
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 if (f->g.buffer_end - f->g.buffer < 1) {
370 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
373 src += f->mv[bytestream2_get_byte(&f->g)];
374 if (start > src || src > end) {
375 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
378 if (f->g2.buffer_end - f->g2.buffer < 1){
379 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
382 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
383 } else if (code == 5) {
384 if (f->g2.buffer_end - f->g2.buffer < 1) {
385 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
388 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
389 } else if (code == 6) {
390 if (f->g2.buffer_end - f->g2.buffer < 2) {
391 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
395 dst[0] = bytestream2_get_le16(&f->g2);
396 dst[1] = bytestream2_get_le16(&f->g2);
398 dst[0] = bytestream2_get_le16(&f->g2);
399 dst[stride] = bytestream2_get_le16(&f->g2);
404 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
407 const int width = f->avctx->width;
408 const int height = f->avctx->height;
409 uint16_t *src = (uint16_t *)f->last_picture.data[0];
410 uint16_t *dst = (uint16_t *)f->current_picture.data[0];
411 const int stride = f->current_picture.linesize[0] >> 1;
412 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
413 bytestream_offset, wordstream_offset;
415 if (f->version > 1) {
419 bitstream_size = AV_RL32(buf + 8);
420 wordstream_size = AV_RL32(buf + 12);
421 bytestream_size = AV_RL32(buf + 16);
424 bitstream_size = AV_RL16(buf - 4);
425 wordstream_size = AV_RL16(buf - 2);
426 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
429 if (bitstream_size > length ||
430 bytestream_size > length - bitstream_size ||
431 wordstream_size > length - bytestream_size - bitstream_size ||
432 extra > length - bytestream_size - bitstream_size - wordstream_size) {
433 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
434 bitstream_size+ bytestream_size+ wordstream_size - length);
438 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
439 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
440 if (!f->bitstream_buffer)
441 return AVERROR(ENOMEM);
442 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
444 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
445 0, FF_INPUT_BUFFER_PADDING_SIZE);
446 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
448 wordstream_offset = extra + bitstream_size;
449 bytestream_offset = extra + bitstream_size + wordstream_size;
450 bytestream2_init(&f->g2, buf + wordstream_offset,
451 length - wordstream_offset);
452 bytestream2_init(&f->g, buf + bytestream_offset,
453 length - bytestream_offset);
457 for (y = 0; y < height; y += 8) {
458 for (x = 0; x < width; x += 8)
459 decode_p_block(f, dst + x, src + x, 3, 3, stride);
468 * decode block and dequantize.
469 * Note this is almost identical to MJPEG.
471 static int decode_i_block(FourXContext *f, DCTELEM *block)
473 int code, i, j, level, val;
475 if (get_bits_left(&f->gb) < 2){
476 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
481 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
483 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
486 val = get_xbits(&f->gb, val);
488 val = val * dequant_table[0] + f->last_dc;
489 f->last_dc = block[0] = val;
493 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
501 level = get_xbits(&f->gb, code & 0xf);
504 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
508 j = ff_zigzag_direct[i];
509 block[j] = level * dequant_table[j];
519 static inline void idct_put(FourXContext *f, int x, int y)
521 DCTELEM (*block)[64] = f->block;
522 int stride = f->current_picture.linesize[0] >> 1;
524 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
526 for (i = 0; i < 4; i++) {
527 block[i][0] += 0x80 * 8 * 8;
531 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
532 for (i = 4; i < 6; i++)
536 /* Note transform is:
537 * y = ( 1b + 4g + 2r) / 14
538 * cb = ( 3b - 2g - 1r) / 14
539 * cr = (-1b - 4g + 5r) / 14 */
540 for (y = 0; y < 8; y++) {
541 for (x = 0; x < 8; x++) {
542 DCTELEM *temp = block[(x >> 2) + 2 * (y >> 2)] +
543 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
544 int cb = block[4][x + 8 * y];
545 int cr = block[5][x + 8 * y];
546 int cg = (cb + cr) >> 1;
552 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
554 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
556 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
558 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
561 dst += 2 * stride - 2 * 8;
565 static int decode_i_mb(FourXContext *f)
569 f->dsp.clear_blocks(f->block[0]);
571 for (i = 0; i < 6; i++)
572 if (decode_i_block(f, f->block[i]) < 0)
578 static const uint8_t *read_huffman_tables(FourXContext *f,
579 const uint8_t * const buf, int buf_size)
584 uint8_t len_tab[257];
587 const uint8_t *ptr = buf;
588 const uint8_t *ptr_end = buf + buf_size;
591 memset(frequency, 0, sizeof(frequency));
592 memset(up, -1, sizeof(up));
599 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
601 for (i = start; i <= end; i++)
602 frequency[i] = *ptr++;
611 while ((ptr - buf) & 3)
612 ptr++; // 4byte align
614 for (j = 257; j < 512; j++) {
615 int min_freq[2] = { 256 * 256, 256 * 256 };
616 int smallest[2] = { 0, 0 };
618 for (i = 0; i < j; i++) {
619 if (frequency[i] == 0)
621 if (frequency[i] < min_freq[1]) {
622 if (frequency[i] < min_freq[0]) {
623 min_freq[1] = min_freq[0];
624 smallest[1] = smallest[0];
625 min_freq[0] = frequency[i];
628 min_freq[1] = frequency[i];
633 if (min_freq[1] == 256 * 256)
636 frequency[j] = min_freq[0] + min_freq[1];
637 flag[smallest[0]] = 0;
638 flag[smallest[1]] = 1;
641 frequency[smallest[0]] = frequency[smallest[1]] = 0;
644 for (j = 0; j < 257; j++) {
645 int node, len = 0, bits = 0;
647 for (node = j; up[node] != -1; node = up[node]) {
648 bits += flag[node] << len;
651 // can this happen at all ?
652 av_log(f->avctx, AV_LOG_ERROR,
653 "vlc length overflow\n");
660 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
667 static int mix(int c0, int c1)
669 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
670 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
671 int red = 2 * (c0 >> 10) + (c1 >> 10);
672 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
675 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
678 const int width = f->avctx->width;
679 const int height = f->avctx->height;
680 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
681 uint16_t *dst = (uint16_t*)f->current_picture.data[0];
682 const int stride = f->current_picture.linesize[0]>>1;
683 const uint8_t *buf_end = buf + length;
686 if (length < mbs * 8) {
687 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
688 return AVERROR_INVALIDDATA;
690 bytestream2_init(&g3, buf, length);
692 for (y = 0; y < height; y += 16) {
693 for (x = 0; x < width; x += 16) {
694 unsigned int color[4], bits;
695 if (buf_end - buf < 8)
697 memset(color, 0, sizeof(color));
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"),