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"
34 #include "libavutil/avassert.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, int16_t, 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(int16_t 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[2][4][32][2];
246 for (i = 0; i < 2; i++) {
247 for (j = 0; j < 4; j++) {
248 block_type_vlc[i][j].table = table[i][j];
249 block_type_vlc[i][j].table_allocated = 32;
250 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
251 &block_type_tab[i][j][0][1], 2, 1,
252 &block_type_tab[i][j][0][0], 2, 1,
253 INIT_VLC_USE_NEW_STATIC);
258 static void init_mv(FourXContext *f)
262 for (i = 0; i < 256; i++) {
264 f->mv[i] = mv[i][0] + mv[i][1] * f->current_picture->linesize[0] / 2;
266 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * f->current_picture->linesize[0] / 2;
271 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
273 unsigned tmpval = AV_RN32(src); \
274 tmpval = (tmpval << 16) | (tmpval >> 16); \
275 tmpval = tmpval * (scale) + (dc); \
276 tmpval = (tmpval << 16) | (tmpval >> 16); \
277 AV_WN32A(dst, tmpval); \
280 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
282 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
283 AV_WN32A(dst, tmpval); \
287 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
288 int h, int stride, int scale, unsigned dc)
295 for (i = 0; i < h; i++) {
296 dst[0] = scale * src[0] + dc;
303 for (i = 0; i < h; i++) {
304 LE_CENTRIC_MUL(dst, src, scale, dc);
311 for (i = 0; i < h; i++) {
312 LE_CENTRIC_MUL(dst, src, scale, dc);
313 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
320 for (i = 0; i < h; i++) {
321 LE_CENTRIC_MUL(dst, src, scale, dc);
322 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
323 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
324 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
335 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
336 int log2w, int log2h, int stride)
338 const int index = size2index[log2h][log2w];
339 const int h = 1 << log2h;
340 int code = get_vlc2(&f->gb,
341 block_type_vlc[1 - (f->version > 1)][index].table,
342 BLOCK_TYPE_VLC_BITS, 1);
343 uint16_t *start = (uint16_t *)f->last_picture->data[0];
344 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
346 av_assert2(code >= 0 && code <= 6);
349 if (bytestream2_get_bytes_left(&f->g) < 1) {
350 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
353 src += f->mv[bytestream2_get_byteu(&f->g)];
354 if (start > src || src > end) {
355 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
358 mcdc(dst, src, log2w, h, stride, 1, 0);
359 } else if (code == 1) {
361 decode_p_block(f, dst, src, log2w, log2h, stride);
362 decode_p_block(f, dst + (stride << log2h),
363 src + (stride << log2h), log2w, log2h, stride);
364 } else if (code == 2) {
366 decode_p_block(f, dst , src, log2w, log2h, stride);
367 decode_p_block(f, dst + (1 << log2w),
368 src + (1 << log2w), log2w, log2h, stride);
369 } else if (code == 3 && f->version < 2) {
370 mcdc(dst, src, log2w, h, stride, 1, 0);
371 } else if (code == 4) {
372 if (bytestream2_get_bytes_left(&f->g) < 1) {
373 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
376 src += f->mv[bytestream2_get_byteu(&f->g)];
377 if (start > src || src > end) {
378 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
381 if (bytestream2_get_bytes_left(&f->g2) < 2){
382 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
385 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->g2));
386 } else if (code == 5) {
387 if (bytestream2_get_bytes_left(&f->g2) < 2) {
388 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
391 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->g2));
392 } else if (code == 6) {
393 if (bytestream2_get_bytes_left(&f->g2) < 4) {
394 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
398 dst[0] = bytestream2_get_le16u(&f->g2);
399 dst[1] = bytestream2_get_le16u(&f->g2);
401 dst[0] = bytestream2_get_le16u(&f->g2);
402 dst[stride] = bytestream2_get_le16u(&f->g2);
407 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
410 const int width = f->avctx->width;
411 const int height = f->avctx->height;
412 uint16_t *src = (uint16_t *)f->last_picture->data[0];
413 uint16_t *dst = (uint16_t *)f->current_picture->data[0];
414 const int stride = f->current_picture->linesize[0] >> 1;
415 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
416 bytestream_offset, wordstream_offset;
418 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 > length || bitstream_size >= INT_MAX/8 ||
433 bytestream_size > length - bitstream_size ||
434 wordstream_size > length - bytestream_size - bitstream_size ||
435 extra > length - bytestream_size - bitstream_size - wordstream_size) {
436 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
437 bitstream_size+ bytestream_size+ wordstream_size - length);
438 return AVERROR_INVALIDDATA;
441 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
442 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
443 if (!f->bitstream_buffer)
444 return AVERROR(ENOMEM);
445 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
447 memset((uint8_t*)f->bitstream_buffer + bitstream_size,
448 0, FF_INPUT_BUFFER_PADDING_SIZE);
449 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
451 wordstream_offset = extra + bitstream_size;
452 bytestream_offset = extra + bitstream_size + wordstream_size;
453 bytestream2_init(&f->g2, buf + wordstream_offset,
454 length - wordstream_offset);
455 bytestream2_init(&f->g, buf + bytestream_offset,
456 length - bytestream_offset);
460 for (y = 0; y < height; y += 8) {
461 for (x = 0; x < width; x += 8)
462 decode_p_block(f, dst + x, src + x, 3, 3, stride);
471 * decode block and dequantize.
472 * Note this is almost identical to MJPEG.
474 static int decode_i_block(FourXContext *f, int16_t *block)
476 int code, i, j, level, val;
478 if (get_bits_left(&f->gb) < 2){
479 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
484 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
486 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
489 val = get_xbits(&f->gb, val);
491 val = val * dequant_table[0] + f->last_dc;
492 f->last_dc = block[0] = val;
496 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
504 level = get_xbits(&f->gb, code & 0xf);
507 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
511 j = ff_zigzag_direct[i];
512 block[j] = level * dequant_table[j];
522 static inline void idct_put(FourXContext *f, int x, int y)
524 int16_t (*block)[64] = f->block;
525 int stride = f->current_picture->linesize[0] >> 1;
527 uint16_t *dst = ((uint16_t*)f->current_picture->data[0]) + y * stride + x;
529 for (i = 0; i < 4; i++) {
530 block[i][0] += 0x80 * 8 * 8;
534 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
535 for (i = 4; i < 6; i++)
539 /* Note transform is:
540 * y = ( 1b + 4g + 2r) / 14
541 * cb = ( 3b - 2g - 1r) / 14
542 * cr = (-1b - 4g + 5r) / 14 */
543 for (y = 0; y < 8; y++) {
544 for (x = 0; x < 8; x++) {
545 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
546 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
547 int cb = block[4][x + 8 * y];
548 int cr = block[5][x + 8 * y];
549 int cg = (cb + cr) >> 1;
555 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
557 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
559 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
561 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst += 2 * stride - 2 * 8;
568 static int decode_i_mb(FourXContext *f)
573 f->dsp.clear_blocks(f->block[0]);
575 for (i = 0; i < 6; i++)
576 if ((ret = decode_i_block(f, f->block[i])) < 0)
582 static const uint8_t *read_huffman_tables(FourXContext *f,
583 const uint8_t * const buf, int buf_size)
585 int frequency[512] = { 0 };
588 uint8_t len_tab[257];
591 const uint8_t *ptr = buf;
592 const uint8_t *ptr_end = buf + buf_size;
595 memset(up, -1, sizeof(up));
602 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
603 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
606 for (i = start; i <= end; i++)
607 frequency[i] = *ptr++;
616 while ((ptr - buf) & 3)
617 ptr++; // 4byte align
620 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
624 for (j = 257; j < 512; j++) {
625 int min_freq[2] = { 256 * 256, 256 * 256 };
626 int smallest[2] = { 0, 0 };
628 for (i = 0; i < j; i++) {
629 if (frequency[i] == 0)
631 if (frequency[i] < min_freq[1]) {
632 if (frequency[i] < min_freq[0]) {
633 min_freq[1] = min_freq[0];
634 smallest[1] = smallest[0];
635 min_freq[0] = frequency[i];
638 min_freq[1] = frequency[i];
643 if (min_freq[1] == 256 * 256)
646 frequency[j] = min_freq[0] + min_freq[1];
647 flag[smallest[0]] = 0;
648 flag[smallest[1]] = 1;
651 frequency[smallest[0]] = frequency[smallest[1]] = 0;
654 for (j = 0; j < 257; j++) {
655 int node, len = 0, bits = 0;
657 for (node = j; up[node] != -1; node = up[node]) {
658 bits += flag[node] << len;
661 // can this happen at all ?
662 av_log(f->avctx, AV_LOG_ERROR,
663 "vlc length overflow\n");
670 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
677 static int mix(int c0, int c1)
679 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
680 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
681 int red = 2 * (c0 >> 10) + (c1 >> 10);
682 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
685 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
688 const int width = f->avctx->width;
689 const int height = f->avctx->height;
690 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
691 uint16_t *dst = (uint16_t*)f->current_picture->data[0];
692 const int stride = f->current_picture->linesize[0]>>1;
693 const uint8_t *buf_end = buf + length;
696 if (length < mbs * 8) {
697 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
698 return AVERROR_INVALIDDATA;
700 bytestream2_init(&g3, buf, length);
702 for (y = 0; y < height; y += 16) {
703 for (x = 0; x < width; x += 16) {
704 unsigned int color[4] = { 0 }, bits;
705 if (buf_end - buf < 8)
707 // warning following is purely guessed ...
708 color[0] = bytestream2_get_le16u(&g3);
709 color[1] = bytestream2_get_le16u(&g3);
711 if (color[0] & 0x8000)
712 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
713 if (color[1] & 0x8000)
714 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
716 color[2] = mix(color[0], color[1]);
717 color[3] = mix(color[1], color[0]);
719 bits = bytestream2_get_le32u(&g3);
720 for (y2 = 0; y2 < 16; y2++) {
721 for (x2 = 0; x2 < 16; x2++) {
722 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
723 dst[y2 * stride + x2] = color[(bits >> index) & 3];
728 dst += 16 * stride - x;
734 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
737 const int width = f->avctx->width;
738 const int height = f->avctx->height;
739 const unsigned int bitstream_size = AV_RL32(buf);
740 unsigned int prestream_size;
741 const uint8_t *prestream;
743 if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
744 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
745 return AVERROR_INVALIDDATA;
748 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
749 prestream = buf + bitstream_size + 12;
751 if (prestream_size + bitstream_size + 12 != length
752 || bitstream_size > (1 << 26)
753 || prestream_size > (1 << 26)) {
754 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
755 prestream_size, bitstream_size, length);
756 return AVERROR_INVALIDDATA;
759 prestream = read_huffman_tables(f, prestream, buf + length - prestream);
763 av_assert0(prestream <= buf + length);
765 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
767 prestream_size = length + buf - prestream;
769 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
770 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
771 if (!f->bitstream_buffer)
772 return AVERROR(ENOMEM);
773 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
775 memset((uint8_t*)f->bitstream_buffer + prestream_size,
776 0, FF_INPUT_BUFFER_PADDING_SIZE);
777 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
779 f->last_dc = 0 * 128 * 8 * 8;
781 for (y = 0; y < height; y += 16) {
782 for (x = 0; x < width; x += 16) {
783 if ((ret = decode_i_mb(f)) < 0)
790 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
791 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
796 static int decode_frame(AVCodecContext *avctx, void *data,
797 int *got_frame, AVPacket *avpkt)
799 const uint8_t *buf = avpkt->data;
800 int buf_size = avpkt->size;
801 FourXContext *const f = avctx->priv_data;
802 AVFrame *picture = data;
804 int i, frame_4cc, frame_size, ret;
807 return AVERROR_INVALIDDATA;
808 frame_4cc = AV_RL32(buf);
809 if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
810 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
811 buf_size, AV_RL32(buf + 4));
813 if (frame_4cc == AV_RL32("cfrm")) {
815 const int data_size = buf_size - 20;
816 const int id = AV_RL32(buf + 12);
817 const int whole_size = AV_RL32(buf + 16);
820 if (data_size < 0 || whole_size < 0) {
821 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
822 return AVERROR_INVALIDDATA;
825 if (f->version <= 1) {
826 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
827 return AVERROR_INVALIDDATA;
830 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
831 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
832 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
835 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
836 if (f->cfrm[i].id == id)
838 if (f->cfrm[i].size == 0)
842 if (i >= CFRAME_BUFFER_COUNT) {
848 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
849 return AVERROR_INVALIDDATA;
851 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
852 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
853 // explicit check needed as memcpy below might not catch a NULL
855 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
856 return AVERROR(ENOMEM);
859 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
860 cfrm->size += data_size;
862 if (cfrm->size >= whole_size) {
864 frame_size = cfrm->size;
866 if (id != avctx->frame_number)
867 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
868 id, avctx->frame_number);
870 cfrm->size = cfrm->id = 0;
871 frame_4cc = AV_RL32("pfrm");
876 frame_size = buf_size - 12;
879 FFSWAP(AVFrame*, f->current_picture, f->last_picture);
881 p = f->current_picture;
882 avctx->coded_frame = p;
884 // alternatively we would have to use our own buffer management
885 avctx->flags |= CODEC_FLAG_EMU_EDGE;
888 if ((ret = avctx->reget_buffer(avctx, p)) < 0) {
889 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
893 if (frame_4cc == AV_RL32("ifr2")) {
894 p->pict_type= AV_PICTURE_TYPE_I;
895 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
896 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
899 } else if (frame_4cc == AV_RL32("ifrm")) {
900 p->pict_type= AV_PICTURE_TYPE_I;
901 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
902 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
905 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
906 if (!f->last_picture->data[0]) {
907 f->last_picture->reference = 3;
908 if ((ret = ff_get_buffer(avctx, f->last_picture)) < 0) {
909 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
912 for (i=0; i<avctx->height; i++)
913 memset(f->last_picture->data[0] + i*f->last_picture->linesize[0], 0, 2*avctx->width);
916 p->pict_type = AV_PICTURE_TYPE_P;
917 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
918 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
921 } else if (frame_4cc == AV_RL32("snd_")) {
922 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
925 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
929 p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
939 static av_cold int decode_init(AVCodecContext *avctx)
941 FourXContext * const f = avctx->priv_data;
943 if (avctx->extradata_size != 4 || !avctx->extradata) {
944 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
945 return AVERROR_INVALIDDATA;
947 if((avctx->width % 16) || (avctx->height % 16)) {
948 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
949 return AVERROR_INVALIDDATA;
952 f->version = AV_RL32(avctx->extradata) >> 16;
953 ff_dsputil_init(&f->dsp, avctx);
958 avctx->pix_fmt = AV_PIX_FMT_RGB565;
960 avctx->pix_fmt = AV_PIX_FMT_BGR555;
962 f->current_picture = avcodec_alloc_frame();
963 f->last_picture = avcodec_alloc_frame();
964 if (!f->current_picture || !f->last_picture) {
965 avcodec_free_frame(&f->current_picture);
966 avcodec_free_frame(&f->last_picture);
967 return AVERROR(ENOMEM);
974 static av_cold int decode_end(AVCodecContext *avctx)
976 FourXContext * const f = avctx->priv_data;
979 av_freep(&f->bitstream_buffer);
980 f->bitstream_buffer_size = 0;
981 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
982 av_freep(&f->cfrm[i].data);
983 f->cfrm[i].allocated_size = 0;
985 ff_free_vlc(&f->pre_vlc);
986 if (f->current_picture->data[0])
987 avctx->release_buffer(avctx, f->current_picture);
988 if (f->last_picture->data[0])
989 avctx->release_buffer(avctx, f->last_picture);
990 avcodec_free_frame(&f->current_picture);
991 avcodec_free_frame(&f->last_picture);
996 AVCodec ff_fourxm_decoder = {
998 .type = AVMEDIA_TYPE_VIDEO,
999 .id = AV_CODEC_ID_4XM,
1000 .priv_data_size = sizeof(FourXContext),
1001 .init = decode_init,
1002 .close = decode_end,
1003 .decode = decode_frame,
1004 .capabilities = CODEC_CAP_DR1,
1005 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),