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/frame.h"
28 #include "libavutil/intreadwrite.h"
30 #include "bytestream.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 *last_picture;
133 GetBitContext pre_gb; ///< ac/dc prefix
140 DECLARE_ALIGNED(16, int16_t, 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(int16_t 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, int linesize)
261 for (i = 0; i < 256; i++) {
263 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
265 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 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, 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 int 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);
346 if (code < 0 || code > 6 || log2w < 0)
347 return AVERROR_INVALIDDATA;
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");
353 return AVERROR_INVALIDDATA;
355 mcdc(dst, src, log2w, h, stride, 1, 0);
356 } else if (code == 1) {
358 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
360 if ((ret = decode_p_block(f, dst + (stride << log2h),
361 src + (stride << log2h),
362 log2w, log2h, stride)) < 0)
364 } else if (code == 2) {
366 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
368 if ((ret = decode_p_block(f, dst + (1 << log2w),
370 log2w, log2h, stride)) < 0)
372 } else if (code == 3 && f->version < 2) {
373 mcdc(dst, src, log2w, h, stride, 1, 0);
374 } else if (code == 4) {
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");
378 return AVERROR_INVALIDDATA;
380 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
381 } else if (code == 5) {
382 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
383 } else if (code == 6) {
385 dst[0] = bytestream2_get_le16(&f->g2);
386 dst[1] = bytestream2_get_le16(&f->g2);
388 dst[0] = bytestream2_get_le16(&f->g2);
389 dst[stride] = bytestream2_get_le16(&f->g2);
395 static int decode_p_frame(FourXContext *f, AVFrame *frame,
396 const uint8_t *buf, int length)
399 const int width = f->avctx->width;
400 const int height = f->avctx->height;
401 uint16_t *dst = (uint16_t *)frame->data[0];
402 const int stride = frame->linesize[0] >> 1;
404 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
405 bytestream_offset, wordstream_offset;
408 if (!f->last_picture->data[0]) {
409 if ((ret = ff_get_buffer(f->avctx, f->last_picture,
410 AV_GET_BUFFER_FLAG_REF)) < 0) {
411 av_log(f->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
414 memset(f->last_picture->data[0], 0,
415 f->avctx->height * FFABS(f->last_picture->linesize[0]));
418 src = (uint16_t *)f->last_picture->data[0];
420 if (f->version > 1) {
422 bitstream_size = AV_RL32(buf + 8);
423 wordstream_size = AV_RL32(buf + 12);
424 bytestream_size = AV_RL32(buf + 16);
427 bitstream_size = AV_RL16(buf - 4);
428 wordstream_size = AV_RL16(buf - 2);
429 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
432 if (bitstream_size + bytestream_size + wordstream_size + extra != length
433 || bitstream_size > (1 << 26)
434 || bytestream_size > (1 << 26)
435 || wordstream_size > (1 << 26)) {
436 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
437 bitstream_size, bytestream_size, wordstream_size,
438 bitstream_size + bytestream_size + wordstream_size - length);
439 return AVERROR_INVALIDDATA;
442 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
443 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
444 if (!f->bitstream_buffer)
445 return AVERROR(ENOMEM);
446 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
448 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
449 0, FF_INPUT_BUFFER_PADDING_SIZE);
450 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
452 wordstream_offset = extra + bitstream_size;
453 bytestream_offset = extra + bitstream_size + wordstream_size;
454 bytestream2_init(&f->g2, buf + wordstream_offset,
455 length - wordstream_offset);
456 bytestream2_init(&f->g, buf + bytestream_offset,
457 length - bytestream_offset);
459 init_mv(f, frame->linesize[0]);
461 for (y = 0; y < height; y += 8) {
462 for (x = 0; x < width; x += 8)
463 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
473 * decode block and dequantize.
474 * Note this is almost identical to MJPEG.
476 static int decode_i_block(FourXContext *f, int16_t *block)
478 int code, i, j, level, val;
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, AVFrame *frame, int x, int y)
521 int16_t (*block)[64] = f->block;
522 int stride = frame->linesize[0] >> 1;
524 uint16_t *dst = ((uint16_t*)frame->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 int16_t *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)
570 f->dsp.clear_blocks(f->block[0]);
572 for (i = 0; i < 6; i++)
573 if ((ret = decode_i_block(f, f->block[i])) < 0)
579 static const uint8_t *read_huffman_tables(FourXContext *f,
580 const uint8_t * const buf)
582 int frequency[512] = { 0 };
585 uint8_t len_tab[257];
588 const uint8_t *ptr = buf;
591 memset(up, -1, sizeof(up));
598 for (i = start; i <= end; i++)
599 frequency[i] = *ptr++;
608 while ((ptr - buf) & 3)
609 ptr++; // 4byte align
611 for (j = 257; j < 512; j++) {
612 int min_freq[2] = { 256 * 256, 256 * 256 };
613 int smallest[2] = { 0, 0 };
615 for (i = 0; i < j; i++) {
616 if (frequency[i] == 0)
618 if (frequency[i] < min_freq[1]) {
619 if (frequency[i] < min_freq[0]) {
620 min_freq[1] = min_freq[0];
621 smallest[1] = smallest[0];
622 min_freq[0] = frequency[i];
625 min_freq[1] = frequency[i];
630 if (min_freq[1] == 256 * 256)
633 frequency[j] = min_freq[0] + min_freq[1];
634 flag[smallest[0]] = 0;
635 flag[smallest[1]] = 1;
638 frequency[smallest[0]] = frequency[smallest[1]] = 0;
641 for (j = 0; j < 257; j++) {
642 int node, len = 0, bits = 0;
644 for (node = j; up[node] != -1; node = up[node]) {
645 bits += flag[node] << len;
648 // can this happen at all ?
649 av_log(f->avctx, AV_LOG_ERROR,
650 "vlc length overflow\n");
657 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
664 static int mix(int c0, int c1)
666 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
667 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
668 int red = 2 * (c0 >> 10) + (c1 >> 10);
669 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
672 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
675 const int width = f->avctx->width;
676 const int height = f->avctx->height;
677 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
678 uint16_t *dst = (uint16_t*)frame->data[0];
679 const int stride = frame->linesize[0]>>1;
682 if (length < mbs * 8) {
683 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
684 return AVERROR_INVALIDDATA;
686 bytestream2_init(&g3, buf, length);
688 for (y = 0; y < height; y += 16) {
689 for (x = 0; x < width; x += 16) {
690 unsigned int color[4] = { 0 }, bits;
691 // warning following is purely guessed ...
692 color[0] = bytestream2_get_le16u(&g3);
693 color[1] = bytestream2_get_le16u(&g3);
695 if (color[0] & 0x8000)
696 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
697 if (color[1] & 0x8000)
698 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
700 color[2] = mix(color[0], color[1]);
701 color[3] = mix(color[1], color[0]);
703 bits = bytestream2_get_le32u(&g3);
704 for (y2 = 0; y2 < 16; y2++) {
705 for (x2 = 0; x2 < 16; x2++) {
706 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
707 dst[y2 * stride + x2] = color[(bits >> index) & 3];
712 dst += 16 * stride - x;
718 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
721 const int width = f->avctx->width;
722 const int height = f->avctx->height;
723 const unsigned int bitstream_size = AV_RL32(buf);
724 int token_count av_unused;
725 unsigned int prestream_size;
726 const uint8_t *prestream;
728 if (length < bitstream_size + 12) {
729 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
730 return AVERROR_INVALIDDATA;
733 token_count = AV_RL32(buf + bitstream_size + 8);
734 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
735 prestream = buf + bitstream_size + 12;
737 if (prestream_size + bitstream_size + 12 != length
738 || bitstream_size > (1 << 26)
739 || prestream_size > (1 << 26)) {
740 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
741 prestream_size, bitstream_size, length);
742 return AVERROR_INVALIDDATA;
745 prestream = read_huffman_tables(f, prestream);
747 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
748 return AVERROR_INVALIDDATA;
751 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
753 prestream_size = length + buf - prestream;
755 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
756 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
757 if (!f->bitstream_buffer)
758 return AVERROR(ENOMEM);
759 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
761 memset((uint8_t*)f->bitstream_buffer + prestream_size,
762 0, FF_INPUT_BUFFER_PADDING_SIZE);
763 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
765 f->last_dc = 0 * 128 * 8 * 8;
767 for (y = 0; y < height; y += 16) {
768 for (x = 0; x < width; x += 16) {
769 if ((ret = decode_i_mb(f)) < 0)
772 idct_put(f, frame, x, y);
776 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
777 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
782 static int decode_frame(AVCodecContext *avctx, void *data,
783 int *got_frame, AVPacket *avpkt)
785 const uint8_t *buf = avpkt->data;
786 int buf_size = avpkt->size;
787 FourXContext *const f = avctx->priv_data;
788 AVFrame *picture = data;
789 int i, frame_4cc, frame_size, ret;
791 frame_4cc = AV_RL32(buf);
792 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
793 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
794 buf_size, AV_RL32(buf + 4));
796 if (frame_4cc == AV_RL32("cfrm")) {
798 const int data_size = buf_size - 20;
799 const int id = AV_RL32(buf + 12);
800 const int whole_size = AV_RL32(buf + 16);
803 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
804 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
805 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
808 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
809 if (f->cfrm[i].id == id)
811 if (f->cfrm[i].size == 0)
815 if (i >= CFRAME_BUFFER_COUNT) {
821 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
822 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
823 // explicit check needed as memcpy below might not catch a NULL
825 av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
826 return AVERROR(ENOMEM);
829 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
830 cfrm->size += data_size;
832 if (cfrm->size >= whole_size) {
834 frame_size = cfrm->size;
836 if (id != avctx->frame_number)
837 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
838 id, avctx->frame_number);
841 return AVERROR_INVALIDDATA;
843 cfrm->size = cfrm->id = 0;
844 frame_4cc = AV_RL32("pfrm");
849 frame_size = buf_size - 12;
852 // alternatively we would have to use our own buffer management
853 avctx->flags |= CODEC_FLAG_EMU_EDGE;
855 if ((ret = ff_get_buffer(avctx, picture, AV_GET_BUFFER_FLAG_REF)) < 0) {
856 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
860 if (frame_4cc == AV_RL32("ifr2")) {
861 picture->pict_type = AV_PICTURE_TYPE_I;
862 if ((ret = decode_i2_frame(f, picture, buf - 4, frame_size + 4)) < 0)
864 } else if (frame_4cc == AV_RL32("ifrm")) {
865 picture->pict_type = AV_PICTURE_TYPE_I;
866 if ((ret = decode_i_frame(f, picture, buf, frame_size)) < 0)
868 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
869 picture->pict_type = AV_PICTURE_TYPE_P;
870 if ((ret = decode_p_frame(f, picture, buf, frame_size)) < 0)
872 } else if (frame_4cc == AV_RL32("snd_")) {
873 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
876 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
880 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
882 av_frame_unref(f->last_picture);
883 if ((ret = av_frame_ref(f->last_picture, picture)) < 0)
892 static av_cold int decode_init(AVCodecContext *avctx)
894 FourXContext * const f = avctx->priv_data;
896 if (avctx->extradata_size != 4 || !avctx->extradata) {
897 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
901 f->version = AV_RL32(avctx->extradata) >> 16;
902 ff_dsputil_init(&f->dsp, avctx);
907 avctx->pix_fmt = AV_PIX_FMT_RGB565;
909 avctx->pix_fmt = AV_PIX_FMT_BGR555;
911 f->last_picture = av_frame_alloc();
912 if (!f->last_picture)
913 return AVERROR(ENOMEM);
919 static av_cold int decode_end(AVCodecContext *avctx)
921 FourXContext * const f = avctx->priv_data;
924 av_freep(&f->bitstream_buffer);
925 f->bitstream_buffer_size = 0;
926 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
927 av_freep(&f->cfrm[i].data);
928 f->cfrm[i].allocated_size = 0;
930 ff_free_vlc(&f->pre_vlc);
931 av_frame_free(&f->last_picture);
936 AVCodec ff_fourxm_decoder = {
938 .type = AVMEDIA_TYPE_VIDEO,
939 .id = AV_CODEC_ID_4XM,
940 .priv_data_size = sizeof(FourXContext),
943 .decode = decode_frame,
944 .capabilities = CODEC_CAP_DR1,
945 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),