FFmpeg
Loading...
Searching...
No Matches
4xm.c
Go to the documentation of this file.
1/*
2 * 4XM codec
3 * Copyright (c) 2003 Michael Niedermayer
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22/**
23 * @file
24 * 4XM codec.
25 */
26
27#include <inttypes.h>
28
29#include "libavutil/avassert.h"
30#include "libavutil/frame.h"
31#include "libavutil/imgutils.h"
32#include "libavutil/intreadwrite.h"
33#include "libavutil/mem.h"
34#include "libavutil/mem_internal.h"
35#include "libavutil/thread.h"
36#include "avcodec.h"
37#include "blockdsp.h"
38#include "bswapdsp.h"
39#include "bytestream.h"
40#include "codec_internal.h"
41#include "decode.h"
42#include "get_bits.h"
43
44
45#define BLOCK_TYPE_VLC_BITS 5
46#define ACDC_VLC_BITS 9
47
48#define CFRAME_BUFFER_COUNT 100
49
50static const uint8_t block_type_tab[2][4][8][2] = {
51 {
52 { // { 8, 4, 2 } x { 8, 4, 2}
53 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
54 }, { // { 8, 4 } x 1
55 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56 }, { // 1 x { 8, 4 }
57 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
58 }, { // 1 x 2, 2 x 1
59 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
60 }
61 }, {
62 { // { 8, 4, 2 } x { 8, 4, 2}
63 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 }, {// { 8, 4 } x 1
65 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66 }, {// 1 x { 8, 4 }
67 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
68 }, {// 1 x 2, 2 x 1
69 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
70 }
71 }
72};
73
74static const uint8_t size2index[4][4] = {
75 { -1, 3, 1, 1 },
76 { 3, 0, 0, 0 },
77 { 2, 0, 0, 0 },
78 { 2, 0, 0, 0 },
79};
80
81static const int8_t mv[256][2] = {
82 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
83 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
84 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
85 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
86 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
87 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
88 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
89 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
90 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
91 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
92 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
93 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
94 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
95 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
96 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
97 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
98 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
99 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
100 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
101 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
102 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
103 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
104 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
105 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
106 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
107 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
108 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
109 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
110 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
111 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
112 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
113 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
114};
115
116/* This is simply the scaled down elementwise product of the standard JPEG
117 * quantizer table and the AAN premul table. */
118static const uint8_t dequant_table[64] = {
119 16, 15, 13, 19, 24, 31, 28, 17,
120 17, 23, 25, 31, 36, 63, 45, 21,
121 18, 24, 27, 37, 52, 59, 49, 20,
122 16, 28, 34, 40, 60, 80, 51, 20,
123 18, 31, 48, 66, 68, 86, 56, 21,
124 19, 38, 56, 59, 64, 64, 48, 20,
125 27, 48, 55, 55, 56, 51, 35, 15,
126 20, 35, 34, 32, 31, 22, 15, 8,
127};
128
129static VLCElem block_type_vlc[2][4][32];
130
131
132typedef struct CFrameBuffer {
133 unsigned int allocated_size;
134 unsigned int size;
135 int id;
136 uint8_t *data;
137} CFrameBuffer;
138
158
159
160#define FIX_1_082392200 70936
161#define FIX_1_414213562 92682
162#define FIX_1_847759065 121095
163#define FIX_2_613125930 171254
164
165#define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
166
167static void idct(int16_t block[64])
168{
169 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
170 int tmp10, tmp11, tmp12, tmp13;
171 int z5, z10, z11, z12, z13;
172 int i;
173 int temp[64];
174
175 for (i = 0; i < 8; i++) {
176 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
177 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
178
179 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
180 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
181
182 tmp0 = tmp10 + tmp13;
183 tmp3 = tmp10 - tmp13;
184 tmp1 = tmp11 + tmp12;
185 tmp2 = tmp11 - tmp12;
186
187 z13 = block[8 * 5 + i] + block[8 * 3 + i];
188 z10 = block[8 * 5 + i] - block[8 * 3 + i];
189 z11 = block[8 * 1 + i] + block[8 * 7 + i];
190 z12 = block[8 * 1 + i] - block[8 * 7 + i];
191
192 tmp7 = z11 + z13;
193 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
194
195 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
196 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
197 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
198
199 tmp6 = tmp12 - tmp7;
200 tmp5 = tmp11 - tmp6;
201 tmp4 = tmp10 + tmp5;
202
203 temp[8 * 0 + i] = tmp0 + tmp7;
204 temp[8 * 7 + i] = tmp0 - tmp7;
205 temp[8 * 1 + i] = tmp1 + tmp6;
206 temp[8 * 6 + i] = tmp1 - tmp6;
207 temp[8 * 2 + i] = tmp2 + tmp5;
208 temp[8 * 5 + i] = tmp2 - tmp5;
209 temp[8 * 4 + i] = tmp3 + tmp4;
210 temp[8 * 3 + i] = tmp3 - tmp4;
211 }
212
213 for (i = 0; i < 8 * 8; i += 8) {
214 tmp10 = temp[0 + i] + temp[4 + i];
215 tmp11 = temp[0 + i] - temp[4 + i];
216
217 tmp13 = temp[2 + i] + temp[6 + i];
218 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
219
220 tmp0 = tmp10 + tmp13;
221 tmp3 = tmp10 - tmp13;
222 tmp1 = tmp11 + tmp12;
223 tmp2 = tmp11 - tmp12;
224
225 z13 = temp[5 + i] + temp[3 + i];
226 z10 = temp[5 + i] - temp[3 + i];
227 z11 = temp[1 + i] + temp[7 + i];
228 z12 = temp[1 + i] - temp[7 + i];
229
230 tmp7 = z11 + z13;
231 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
232
233 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
234 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
235 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
236
237 tmp6 = tmp12 - tmp7;
238 tmp5 = tmp11 - tmp6;
239 tmp4 = tmp10 + tmp5;
240
241 block[0 + i] = (tmp0 + tmp7) >> 6;
242 block[7 + i] = (tmp0 - tmp7) >> 6;
243 block[1 + i] = (tmp1 + tmp6) >> 6;
244 block[6 + i] = (tmp1 - tmp6) >> 6;
245 block[2 + i] = (tmp2 + tmp5) >> 6;
246 block[5 + i] = (tmp2 - tmp5) >> 6;
247 block[4 + i] = (tmp3 + tmp4) >> 6;
248 block[3 + i] = (tmp3 - tmp4) >> 6;
249 }
250}
251
252static av_cold void init_vlcs(void)
253{
254 int i, j;
255
256 for (i = 0; i < 2; i++) {
257 for (j = 0; j < 4; j++) {
258 ff_vlc_init_table_sparse(block_type_vlc[i][j], FF_ARRAY_ELEMS(block_type_vlc[i][j]),
259 BLOCK_TYPE_VLC_BITS, 7,
260 &block_type_tab[i][j][0][1], 2, 1,
261 &block_type_tab[i][j][0][0], 2, 1,
262 NULL, 0, 0, 0);
263 }
264 }
265}
266
267static void init_mv(FourXContext *f, int linesize)
268{
269 int i;
270
271 for (i = 0; i < 256; i++) {
272 if (f->version > 1)
273 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
274 else
275 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
276 }
277}
278
279#if HAVE_BIGENDIAN
280#define LE_CENTRIC_MUL(dst, src, scale, dc) \
281 { \
282 unsigned tmpval = AV_RN32(src); \
283 tmpval = (tmpval << 16) | (tmpval >> 16); \
284 tmpval = tmpval * (scale) + (dc); \
285 tmpval = (tmpval << 16) | (tmpval >> 16); \
286 AV_WN32A(dst, tmpval); \
287 }
288#else
289#define LE_CENTRIC_MUL(dst, src, scale, dc) \
290 { \
291 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
292 AV_WN32A(dst, tmpval); \
293 }
294#endif
295
296static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
297 int h, int stride, int scale, unsigned dc)
298{
299 int i;
300 dc *= 0x10001;
301
302 switch (log2w) {
303 case 0:
304 for (i = 0; i < h; i++) {
305 dst[0] = scale * src[0] + dc;
306 if (scale)
307 src += stride;
308 dst += stride;
309 }
310 break;
311 case 1:
312 for (i = 0; i < h; i++) {
313 LE_CENTRIC_MUL(dst, src, scale, dc);
314 if (scale)
315 src += stride;
316 dst += stride;
317 }
318 break;
319 case 2:
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 if (scale)
324 src += stride;
325 dst += stride;
326 }
327 break;
328 case 3:
329 for (i = 0; i < h; i++) {
330 LE_CENTRIC_MUL(dst, src, scale, dc);
331 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
332 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
333 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
334 if (scale)
335 src += stride;
336 dst += stride;
337 }
338 break;
339 default:
340 av_unreachable("log2w starts at 3 and gets only decremented during "
341 "recursive calls to decode_p_block");
342 }
343}
344
345static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
346 int log2w, int log2h, int stride)
347{
348 int index, h, code, ret, scale = 1;
349 uint16_t *start, *end;
350 unsigned dc = 0;
351
352 av_assert0(log2w >= 0 && log2h >= 0);
353
354 index = size2index[log2h][log2w];
355 av_assert0(index >= 0);
356
357 if (get_bits_left(&f->gb) < 1)
358 return AVERROR_INVALIDDATA;
359 h = 1 << log2h;
360 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index],
361 BLOCK_TYPE_VLC_BITS, 1);
362 av_assert0(code >= 0 && code <= 6);
363
364 start = f->last_frame_buffer;
365 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
366
367 if (code == 1) {
368 log2h--;
369 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
370 return ret;
371 return decode_p_block(f, dst + (stride << log2h),
372 src + (stride << log2h),
373 log2w, log2h, stride);
374 } else if (code == 2) {
375 log2w--;
376 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
377 return ret;
378 return decode_p_block(f, dst + (1 << log2w),
379 src + (1 << log2w),
380 log2w, log2h, stride);
381 } else if (code == 6) {
382 if (bytestream2_get_bytes_left(&f->g2) < 4) {
383 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
384 return AVERROR_INVALIDDATA;
385 }
386 if (log2w) {
387 dst[0] = bytestream2_get_le16u(&f->g2);
388 dst[1] = bytestream2_get_le16u(&f->g2);
389 } else {
390 dst[0] = bytestream2_get_le16u(&f->g2);
391 dst[stride] = bytestream2_get_le16u(&f->g2);
392 }
393 return 0;
394 }
395
396 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
397 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
398 return AVERROR_INVALIDDATA;
399 }
400
401 if (code == 0) {
402 src += f->mv[bytestream2_get_byte(&f->g)];
403 } else if (code == 3 && f->version >= 2) {
404 return 0;
405 } else if (code == 4) {
406 src += f->mv[bytestream2_get_byte(&f->g)];
407 if (bytestream2_get_bytes_left(&f->g2) < 2){
408 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
409 return AVERROR_INVALIDDATA;
410 }
411 dc = bytestream2_get_le16(&f->g2);
412 } else if (code == 5) {
413 if (bytestream2_get_bytes_left(&f->g2) < 2){
414 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
415 return AVERROR_INVALIDDATA;
416 }
417 av_assert0(start <= src && src <= end);
418 scale = 0;
419 dc = bytestream2_get_le16(&f->g2);
420 }
421
422 if (start > src || src > end) {
423 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
424 return AVERROR_INVALIDDATA;
425 }
426
427 mcdc(dst, src, log2w, h, stride, scale, dc);
428
429 return 0;
430}
431
432static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
433{
434 int x, y;
435 const int width = f->avctx->width;
436 const int height = f->avctx->height;
437 uint16_t *dst = f->frame_buffer;
438 uint16_t *src;
439 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
440 bytestream_offset, wordstream_offset;
441 int ret;
442
443 src = f->last_frame_buffer;
444
445 if (f->version > 1) {
446 extra = 20;
447 if (length < extra)
448 return AVERROR_INVALIDDATA;
449 bitstream_size = AV_RL32(buf + 8);
450 wordstream_size = AV_RL32(buf + 12);
451 bytestream_size = AV_RL32(buf + 16);
452 } else {
453 extra = 0;
454 bitstream_size = AV_RL16(buf - 4);
455 wordstream_size = AV_RL16(buf - 2);
456 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
457 }
458
459 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
460 bytestream_size > length - bitstream_size ||
461 wordstream_size > length - bytestream_size - bitstream_size ||
462 extra > length - bytestream_size - bitstream_size - wordstream_size) {
463 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
464 bitstream_size+ bytestream_size+ wordstream_size - length);
465 return AVERROR_INVALIDDATA;
466 }
467
468 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
469 bitstream_size);
470 if (!f->bitstream_buffer)
471 return AVERROR(ENOMEM);
472 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
473 bitstream_size / 4);
474 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
475
476 wordstream_offset = extra + bitstream_size;
477 bytestream_offset = extra + bitstream_size + wordstream_size;
478 bytestream2_init(&f->g2, buf + wordstream_offset,
479 length - wordstream_offset);
480 bytestream2_init(&f->g, buf + bytestream_offset,
481 length - bytestream_offset);
482
483 init_mv(f, width * 2);
484
485 for (y = 0; y < height; y += 8) {
486 for (x = 0; x < width; x += 8)
487 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
488 return ret;
489 src += 8 * width;
490 dst += 8 * width;
491 }
492
493 return 0;
494}
495
496/**
497 * decode block and dequantize.
498 * Note this is almost identical to MJPEG.
499 */
500static int decode_i_block(FourXContext *f, int16_t *block)
501{
502 int code, i, j, level, val;
503
504 if (get_bits_left(&f->pre_gb) < 2) {
505 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
506 return AVERROR_INVALIDDATA;
507 }
508
509 /* DC coef */
510 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
511 if (val >> 4) {
512 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
513 return AVERROR_INVALIDDATA;
514 }
515
516 if (val)
517 val = get_xbits(&f->gb, val);
518
519 val = val * dequant_table[0] + f->last_dc;
520 f->last_dc = block[0] = val;
521 /* AC coefs */
522 i = 1;
523 for (;;) {
524 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
525
526 /* EOB */
527 if (code == 0)
528 break;
529 if (code == 0xf0) {
530 i += 16;
531 if (i >= 64) {
532 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
533 return 0;
534 }
535 } else {
536 if (code & 0xf) {
537 level = get_xbits(&f->gb, code & 0xf);
538 } else {
539 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
540 return AVERROR_INVALIDDATA;
541 }
542 i += code >> 4;
543 if (i >= 64) {
544 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
545 return 0;
546 }
547
548 j = ff_zigzag_direct[i];
549 block[j] = level * dequant_table[j];
550 i++;
551 if (i >= 64)
552 break;
553 }
554 }
555
556 return 0;
557}
558
559static inline void idct_put(FourXContext *f, int x, int y)
560{
561 int16_t (*block)[64] = f->block;
562 int stride = f->avctx->width;
563 int i;
564 uint16_t *dst = f->frame_buffer + y * stride + x;
565
566 for (i = 0; i < 4; i++) {
567 block[i][0] += 0x80 * 8 * 8;
568 idct(block[i]);
569 }
570
571 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
572 for (i = 4; i < 6; i++)
573 idct(block[i]);
574 }
575
576 /* Note transform is:
577 * y = ( 1b + 4g + 2r) / 14
578 * cb = ( 3b - 2g - 1r) / 14
579 * cr = (-1b - 4g + 5r) / 14 */
580 for (y = 0; y < 8; y++) {
581 for (x = 0; x < 8; x++) {
582 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
583 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
584 int cb = block[4][x + 8 * y];
585 int cr = block[5][x + 8 * y];
586 int cg = (cb + cr) >> 1;
587 int y;
588
589 cb += cb;
590
591 y = temp[0];
592 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593 y = temp[1];
594 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595 y = temp[8];
596 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
597 y = temp[9];
598 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
599 dst += 2;
600 }
601 dst += 2 * stride - 2 * 8;
602 }
603}
604
605static int decode_i_mb(FourXContext *f)
606{
607 int ret;
608 int i;
609
610 f->bdsp.clear_blocks(f->block[0]);
611
612 for (i = 0; i < 6; i++)
613 if ((ret = decode_i_block(f, f->block[i])) < 0)
614 return ret;
615
616 return 0;
617}
618
619static const uint8_t *read_huffman_tables(FourXContext *f,
620 const uint8_t * const buf,
621 int buf_size)
622{
623 int frequency[512] = { 0 };
624 uint8_t flag[512];
625 int up[512];
626 uint8_t len_tab[257];
627 int bits_tab[257];
628 int start, end;
629 const uint8_t *ptr = buf;
630 const uint8_t *ptr_end = buf + buf_size;
631 int j;
632
633 memset(up, -1, sizeof(up));
634
635 start = *ptr++;
636 end = *ptr++;
637 for (;;) {
638 int i;
639
640 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
641 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
642 return NULL;
643 }
644
645 for (i = start; i <= end; i++)
646 frequency[i] = *ptr++;
647 start = *ptr++;
648 if (start == 0)
649 break;
650
651 end = *ptr++;
652 }
653 frequency[256] = 1;
654
655 while ((ptr - buf) & 3)
656 ptr++; // 4byte align
657
658 if (ptr > ptr_end) {
659 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
660 return NULL;
661 }
662
663 for (j = 257; j < 512; j++) {
664 int min_freq[2] = { 256 * 256, 256 * 256 };
665 int smallest[2] = { 0, 0 };
666 int i;
667 for (i = 0; i < j; i++) {
668 if (frequency[i] == 0)
669 continue;
670 if (frequency[i] < min_freq[1]) {
671 if (frequency[i] < min_freq[0]) {
672 min_freq[1] = min_freq[0];
673 smallest[1] = smallest[0];
674 min_freq[0] = frequency[i];
675 smallest[0] = i;
676 } else {
677 min_freq[1] = frequency[i];
678 smallest[1] = i;
679 }
680 }
681 }
682 if (min_freq[1] == 256 * 256)
683 break;
684
685 frequency[j] = min_freq[0] + min_freq[1];
686 flag[smallest[0]] = 0;
687 flag[smallest[1]] = 1;
688 up[smallest[0]] =
689 up[smallest[1]] = j;
690 frequency[smallest[0]] = frequency[smallest[1]] = 0;
691 }
692
693 for (j = 0; j < 257; j++) {
694 int node, len = 0, bits = 0;
695
696 for (node = j; up[node] != -1; node = up[node]) {
697 bits += flag[node] << len;
698 len++;
699 if (len > 31)
700 // can this happen at all ?
701 av_log(f->avctx, AV_LOG_ERROR,
702 "vlc length overflow\n");
703 }
704
705 bits_tab[j] = bits;
706 len_tab[j] = len;
707 }
708
709 ff_vlc_free(&f->pre_vlc);
710 if (vlc_init(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
711 bits_tab, 4, 4, 0))
712 return NULL;
713
714 return ptr;
715}
716
717static int mix(int c0, int c1)
718{
719 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
720 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
721 int red = 2 * (c0 >> 10) + (c1 >> 10);
722 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
723}
724
725static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
726{
727 int x, y, x2, y2;
728 const int width = f->avctx->width;
729 const int height = f->avctx->height;
730 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
731 uint16_t *dst = f->frame_buffer;
732 const uint8_t *buf_end = buf + length;
733 GetByteContext g3;
734
735 if (length < mbs * 8) {
736 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
737 return AVERROR_INVALIDDATA;
738 }
739 bytestream2_init(&g3, buf, length);
740
741 for (y = 0; y < height; y += 16) {
742 for (x = 0; x < width; x += 16) {
743 unsigned int color[4] = { 0 }, bits;
744 if (buf_end - buf < 8)
745 return AVERROR_INVALIDDATA;
746 // warning following is purely guessed ...
747 color[0] = bytestream2_get_le16u(&g3);
748 color[1] = bytestream2_get_le16u(&g3);
749
750 if (color[0] & 0x8000)
751 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
752 if (color[1] & 0x8000)
753 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
754
755 color[2] = mix(color[0], color[1]);
756 color[3] = mix(color[1], color[0]);
757
758 bits = bytestream2_get_le32u(&g3);
759 for (y2 = 0; y2 < 16; y2++) {
760 for (x2 = 0; x2 < 16; x2++) {
761 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
762 dst[y2 * width + x2] = color[(bits >> index) & 3];
763 }
764 }
765 dst += 16;
766 }
767 dst += 16 * width - x;
768 }
769
770 return 0;
771}
772
773static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
774{
775 int x, y, ret;
776 const int width = f->avctx->width;
777 const int height = f->avctx->height;
778 const unsigned int bitstream_size = AV_RL32(buf);
779 unsigned int prestream_size;
780 const uint8_t *prestream;
781
782 if (bitstream_size > (1 << 26))
783 return AVERROR_INVALIDDATA;
784
785 if (length < bitstream_size + 12) {
786 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
787 return AVERROR_INVALIDDATA;
788 }
789
790 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
791 prestream = buf + bitstream_size + 12;
792
793 if (prestream_size + bitstream_size + 12 != length
794 || prestream_size > (1 << 26)) {
795 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
796 prestream_size, bitstream_size, length);
797 return AVERROR_INVALIDDATA;
798 }
799
800 prestream = read_huffman_tables(f, prestream, prestream_size);
801 if (!prestream) {
802 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
803 return AVERROR_INVALIDDATA;
804 }
805
806 av_assert0(prestream <= buf + length);
807
808 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
809
810 prestream_size = length + buf - prestream;
811
812 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
813 prestream_size);
814 if (!f->bitstream_buffer)
815 return AVERROR(ENOMEM);
816 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
817 prestream_size / 4);
818 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
819
820 f->last_dc = 0 * 128 * 8 * 8;
821
822 for (y = 0; y < height; y += 16) {
823 for (x = 0; x < width; x += 16) {
824 if ((ret = decode_i_mb(f)) < 0)
825 return ret;
826
827 idct_put(f, x, y);
828 }
829 }
830
831 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
832 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
833
834 return 0;
835}
836
837static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
838 int *got_frame, AVPacket *avpkt)
839{
840 const uint8_t *buf = avpkt->data;
841 int buf_size = avpkt->size;
842 FourXContext *const f = avctx->priv_data;
843 int i, frame_4cc, frame_size, ret;
844
845 if (buf_size < 20)
846 return AVERROR_INVALIDDATA;
847
848 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
849
850 if (buf_size < AV_RL32(buf + 4) + 8) {
851 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
852 buf_size, AV_RL32(buf + 4));
853 return AVERROR_INVALIDDATA;
854 }
855
856 frame_4cc = AV_RL32(buf);
857
858 if (frame_4cc == AV_RL32("cfrm")) {
859 int free_index = -1;
860 int id, whole_size;
861 const int data_size = buf_size - 20;
862 CFrameBuffer *cfrm;
863
864 if (f->version <= 1) {
865 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
866 return AVERROR_INVALIDDATA;
867 }
868
869 id = AV_RL32(buf + 12);
870 whole_size = AV_RL32(buf + 16);
871
872 if (data_size < 0 || whole_size < 0) {
873 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
874 return AVERROR_INVALIDDATA;
875 }
876
877 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
878 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_num)
879 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
880 f->cfrm[i].id);
881
882 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
883 if (f->cfrm[i].id == id)
884 break;
885 if (f->cfrm[i].size == 0)
886 free_index = i;
887 }
888
889 if (i >= CFRAME_BUFFER_COUNT) {
890 if (free_index < 0)
891 return AVERROR_INVALIDDATA;
892 i = free_index;
893 f->cfrm[i].id = id;
894 }
895 cfrm = &f->cfrm[i];
896
897 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
898 return AVERROR_INVALIDDATA;
899
900 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
901 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
902 // explicit check needed as memcpy below might not catch a NULL
903 if (!cfrm->data) {
904 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
905 return AVERROR(ENOMEM);
906 }
907
908 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
909 cfrm->size += data_size;
910
911 if (cfrm->size >= whole_size) {
912 buf = cfrm->data;
913 frame_size = cfrm->size;
914
915 if (id != avctx->frame_num)
916 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %"PRId64"\n",
917 id, avctx->frame_num);
918
919 if (f->version <= 1)
920 return AVERROR_INVALIDDATA;
921
922 cfrm->size = cfrm->id = 0;
923 frame_4cc = AV_RL32("pfrm");
924 } else
925 return buf_size;
926 } else {
927 buf = buf + 12;
928 frame_size = buf_size - 12;
929 }
930
931 if ( frame_4cc == AV_RL32("ifr2") || frame_4cc == AV_RL32("ifrm")
932 || frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
933 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
934 return ret;
935 }
936
937 if (frame_4cc == AV_RL32("ifr2")) {
938 picture->pict_type = AV_PICTURE_TYPE_I;
939 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
940 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
941 return ret;
942 }
943 } else if (frame_4cc == AV_RL32("ifrm")) {
944 picture->pict_type = AV_PICTURE_TYPE_I;
945 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
946 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
947 return ret;
948 }
949 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
950 picture->pict_type = AV_PICTURE_TYPE_P;
951 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
952 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
953 return ret;
954 }
955 } else if (frame_4cc == AV_RL32("snd_")) {
956 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
957 buf_size);
958 return AVERROR_INVALIDDATA;
959 } else {
960 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
961 buf_size);
962 return AVERROR_INVALIDDATA;
963 }
964
965 if (picture->pict_type == AV_PICTURE_TYPE_I)
966 picture->flags |= AV_FRAME_FLAG_KEY;
967 else
968 picture->flags &= ~AV_FRAME_FLAG_KEY;
969
970 av_image_copy_plane(picture->data[0], picture->linesize[0],
971 (const uint8_t*)f->frame_buffer, avctx->width * 2,
972 avctx->width * 2, avctx->height);
973 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
974
975 *got_frame = 1;
976
977 return buf_size;
978}
979
980static av_cold int decode_end(AVCodecContext *avctx)
981{
982 FourXContext * const f = avctx->priv_data;
983 int i;
984
985 av_freep(&f->frame_buffer);
986 av_freep(&f->last_frame_buffer);
987 av_freep(&f->bitstream_buffer);
988 f->bitstream_buffer_size = 0;
989 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
990 av_freep(&f->cfrm[i].data);
991 f->cfrm[i].allocated_size = 0;
992 }
993 ff_vlc_free(&f->pre_vlc);
994
995 return 0;
996}
997
998static av_cold int decode_init(AVCodecContext *avctx)
999{
1000 static AVOnce init_static_once = AV_ONCE_INIT;
1001 FourXContext * const f = avctx->priv_data;
1002 int ret;
1003
1004 if (avctx->extradata_size != 4 || !avctx->extradata) {
1005 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
1006 return AVERROR_INVALIDDATA;
1007 }
1008 if((avctx->width % 16) || (avctx->height % 16)) {
1009 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1010 return AVERROR_INVALIDDATA;
1011 }
1012
1013 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1014 if (ret < 0)
1015 return ret;
1016
1017 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1018 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1019 if (!f->frame_buffer || !f->last_frame_buffer)
1020 return AVERROR(ENOMEM);
1021
1022 f->version = AV_RL32(avctx->extradata) >> 16;
1023 ff_blockdsp_init(&f->bdsp);
1024 ff_bswapdsp_init(&f->bbdsp);
1025 f->avctx = avctx;
1026
1027 if (f->version > 2)
1028 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1029 else
1030 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1031
1032 ff_thread_once(&init_static_once, init_vlcs);
1033
1034 return 0;
1035}
1036
1037const FFCodec ff_fourxm_decoder = {
1038 .p.name = "4xm",
1039 CODEC_LONG_NAME("4X Movie"),
1040 .p.type = AVMEDIA_TYPE_VIDEO,
1041 .p.id = AV_CODEC_ID_4XM,
1042 .priv_data_size = sizeof(FourXContext),
1043 .init = decode_init,
1044 .close = decode_end,
1045 FF_CODEC_DECODE_CB(decode_frame),
1046 .p.capabilities = AV_CODEC_CAP_DR1,
1047 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1048};
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
val
static double val(void *priv, double ch)
Definition aeval.c:77
close
static av_cold void close(AVCodecParserContext *s)
Definition apv_parser.c:197
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition avassert.h:109
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
avcodec.h
Libavcodec external API header.
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition bytestream.h:158
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition bytestream.h:137
flag
#define flag(name)
Definition cbs_h264.c:60
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
f
#define f(width, name)
Definition cbs_vp8.c:236
codec_internal.h
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition codec_internal.h:374
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition codec_internal.h:359
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition codec_internal.h:43
NULL
#define NULL
Definition coverity.c:32
block
static int16_t block[64]
Definition dct.c:125
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1777
id
enum AVCodecID id
Definition dts2pts.c:607
init
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:608
bits
static const uint8_t bits[8]
Definition fastaudio.c:100
frame.h
reference-counted frame API
frame_size
static const uint8_t frame_size[4]
Definition g723_1.h:222
get_bits.h
bitstream reader API header.
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition get_bits.h:645
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition get_bits.h:688
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition get_bits.h:517
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition get_bits.h:294
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition avcodec.h:302
AV_CODEC_ID_4XM
@ AV_CODEC_ID_4XM
Definition codec_id.h:84
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition defs.h:40
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition utils.c:53
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:687
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition mem.c:495
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition imgutils.c:318
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition imgutils.c:374
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition avutil.h:278
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition avutil.h:279
index
int index
Definition gxfenc.c:90
imgutils.h
misc image utilities
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition intra.c:278
AV_RL32
#define AV_RL32(p)
Definition intreadwrite.h:419
AV_RL16
#define AV_RL16(p)
Definition intreadwrite.h:405
mv
static const int8_t mv[256][2]
Definition 4xm.c:81
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition 4xm.c:559
init_mv
static void init_mv(FourXContext *f, int linesize)
Definition 4xm.c:267
decode_i_frame
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:773
ACDC_VLC_BITS
#define ACDC_VLC_BITS
Definition 4xm.c:46
dequant_table
static const uint8_t dequant_table[64]
Definition 4xm.c:118
decode_p_frame
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:432
decode_p_block
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition 4xm.c:345
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition 4xm.c:998
block_type_tab
static const uint8_t block_type_tab[2][4][8][2]
Definition 4xm.c:50
idct
static void idct(int16_t block[64])
Definition 4xm.c:167
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition 4xm.c:500
mix
static int mix(int c0, int c1)
Definition 4xm.c:717
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition 4xm.c:980
ff_fourxm_decoder
const FFCodec ff_fourxm_decoder
Definition 4xm.c:1037
CFRAME_BUFFER_COUNT
#define CFRAME_BUFFER_COUNT
Definition 4xm.c:48
size2index
static const uint8_t size2index[4][4]
Definition 4xm.c:74
FIX_1_847759065
#define FIX_1_847759065
Definition 4xm.c:162
MULTIPLY
#define MULTIPLY(var, const)
Definition 4xm.c:165
decode_i_mb
static int decode_i_mb(FourXContext *f)
Definition 4xm.c:605
FIX_2_613125930
#define FIX_2_613125930
Definition 4xm.c:163
block_type_vlc
static VLCElem block_type_vlc[2][4][32]
Definition 4xm.c:129
decode_i2_frame
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:725
FIX_1_414213562
#define FIX_1_414213562
Definition 4xm.c:161
FIX_1_082392200
#define FIX_1_082392200
Definition 4xm.c:160
init_vlcs
static av_cold void init_vlcs(void)
Definition 4xm.c:252
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition 4xm.c:837
read_huffman_tables
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition 4xm.c:619
LE_CENTRIC_MUL
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition 4xm.c:289
mcdc
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition 4xm.c:296
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition 4xm.c:45
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition blockdsp.c:58
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition bswapdsp.c:37
av_cold
#define av_cold
Definition attributes.h:117
AVOnce
#define AVOnce
Definition thread.h:202
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition thread.h:205
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition thread.h:203
FFSWAP
#define FFSWAP(type, a, b)
Definition macros.h:52
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
FFALIGN
#define FFALIGN(x, a)
Definition macros.h:78
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition mathtables.c:137
mem.h
Memory handling functions.
mem_internal.h
c1
static const uint64_t c1
Definition murmur3.c:52
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition pixfmt.h:538
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition pixfmt.h:532
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
code
const uint8_t * code
Definition spdifenc.c:433
AVCodecContext
main external API structure.
Definition avcodec.h:443
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:643
AVCodecContext::width
int width
picture width / height.
Definition avcodec.h:604
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition avcodec.h:1883
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
AVCodecContext::extradata_size
int extradata_size
Definition avcodec.h:527
AVCodecContext::priv_data
void * priv_data
Definition avcodec.h:470
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:493
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition frame.h:716
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition frame.h:517
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition frame.h:564
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVPacket::size
int size
Definition packet.h:604
AVPacket::data
uint8_t * data
Definition packet.h:603
CFrameBuffer::allocated_size
unsigned int allocated_size
Definition 4xm.c:133
CFrameBuffer::data
uint8_t * data
Definition 4xm.c:136
CFrameBuffer::id
int id
Definition 4xm.c:135
CFrameBuffer::size
unsigned int size
Definition 4xm.c:134
FourXContext::bdsp
BlockDSPContext bdsp
Definition 4xm.c:141
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition 4xm.c:156
FourXContext::gb
GetBitContext gb
Definition 4xm.c:146
FourXContext::pre_vlc
VLC pre_vlc
Definition 4xm.c:150
FourXContext::DECLARE_ALIGNED
DECLARE_ALIGNED(32, int16_t, block)[6][64]
FourXContext::last_frame_buffer
uint16_t * last_frame_buffer
Definition 4xm.c:144
FourXContext::version
int version
Definition 4xm.c:155
FourXContext::bbdsp
BswapDSPContext bbdsp
Definition 4xm.c:142
FourXContext::pre_gb
GetBitContext pre_gb
ac/dc prefix
Definition 4xm.c:145
FourXContext::g
GetByteContext g
Definition 4xm.c:147
FourXContext::last_dc
int last_dc
Definition 4xm.c:151
FourXContext::g2
GetByteContext g2
Definition 4xm.c:148
FourXContext::mv
int mv[256]
Definition 4xm.c:149
FourXContext::avctx
AVCodecContext * avctx
Definition 4xm.c:140
FourXContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition 4xm.c:154
FourXContext::bitstream_buffer
void * bitstream_buffer
Definition 4xm.c:153
FourXContext::frame_buffer
uint16_t * frame_buffer
Definition 4xm.c:143
VLCElem
Definition vlc.h:32
VLC
Definition vlc.h:50
level
uint8_t level
Definition svq3.c:208
stride
#define stride
Definition h264pred_template.c:536
av_mallocz
#define av_mallocz(s)
Definition tableprint_vlc.h:31
av_freep
#define av_freep(p)
Definition tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
src
#define src
Definition vp8dsp.c:248
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
cr
static double cr(void *priv, double x, double y)
Definition vf_geq.c:248
cb
static double cb(void *priv, double x, double y)
Definition vf_geq.c:247
temp
else temp
Definition vf_mcdeint.c:275
ff_vlc_init_table_sparse
av_cold void ff_vlc_init_table_sparse(VLCElem table[], int table_size, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition vlc.c:384
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition vlc.c:580
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition vlc.h:70
len
int len
Definition vorbis_enc_data.h:426
h
h
Definition vp9dsp_template.c:2070
Generated on Sun Aug 16 2026 20:20:43 for FFmpeg by doxygen 1.13.2