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"
33#include "libavutil/mem.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;
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++) {
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++) {
314 if (scale)
315 src += stride;
316 dst += stride;
317 }
318 break;
319 case 2:
320 for (i = 0; i < h; i++) {
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++) {
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],
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 memcpy(f->bitstream_buffer, buf + extra, bitstream_size);
473 f->bbdsp.bswap_buf(f->bitstream_buffer, f->bitstream_buffer,
474 bitstream_size / 4);
475 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
476
477 wordstream_offset = extra + bitstream_size;
478 bytestream_offset = extra + bitstream_size + wordstream_size;
479 bytestream2_init(&f->g2, buf + wordstream_offset,
480 length - wordstream_offset);
481 bytestream2_init(&f->g, buf + bytestream_offset,
482 length - bytestream_offset);
483
484 init_mv(f, width * 2);
485
486 for (y = 0; y < height; y += 8) {
487 for (x = 0; x < width; x += 8)
488 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
489 return ret;
490 src += 8 * width;
491 dst += 8 * width;
492 }
493
494 return 0;
495}
496
497/**
498 * decode block and dequantize.
499 * Note this is almost identical to MJPEG.
500 */
501static int decode_i_block(FourXContext *f, int16_t *block)
502{
503 int code, i, j, level, val;
504
505 if (get_bits_left(&f->pre_gb) < 2) {
506 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
507 return AVERROR_INVALIDDATA;
508 }
509
510 /* DC coef */
511 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
512 if (val >> 4) {
513 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
514 return AVERROR_INVALIDDATA;
515 }
516
517 if (val)
518 val = get_xbits(&f->gb, val);
519
520 val = val * dequant_table[0] + f->last_dc;
521 f->last_dc = block[0] = val;
522 /* AC coefs */
523 i = 1;
524 for (;;) {
525 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
526
527 /* EOB */
528 if (code == 0)
529 break;
530 if (code == 0xf0) {
531 i += 16;
532 if (i >= 64) {
533 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
534 return 0;
535 }
536 } else {
537 if (code & 0xf) {
538 level = get_xbits(&f->gb, code & 0xf);
539 } else {
540 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
541 return AVERROR_INVALIDDATA;
542 }
543 i += code >> 4;
544 if (i >= 64) {
545 av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
546 return 0;
547 }
548
549 j = ff_zigzag_direct[i];
550 block[j] = level * dequant_table[j];
551 i++;
552 if (i >= 64)
553 break;
554 }
555 }
556
557 return 0;
558}
559
560static inline void idct_put(FourXContext *f, int x, int y)
561{
562 int16_t (*block)[64] = f->block;
563 int stride = f->avctx->width;
564 int i;
565 uint16_t *dst = f->frame_buffer + y * stride + x;
566
567 for (i = 0; i < 4; i++) {
568 block[i][0] += 0x80 * 8 * 8;
569 idct(block[i]);
570 }
571
572 if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
573 for (i = 4; i < 6; i++)
574 idct(block[i]);
575 }
576
577 /* Note transform is:
578 * y = ( 1b + 4g + 2r) / 14
579 * cb = ( 3b - 2g - 1r) / 14
580 * cr = (-1b - 4g + 5r) / 14 */
581 for (y = 0; y < 8; y++) {
582 for (x = 0; x < 8; x++) {
583 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
584 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
585 int cb = block[4][x + 8 * y];
586 int cr = block[5][x + 8 * y];
587 int cg = (cb + cr) >> 1;
588 int y;
589
590 cb += cb;
591
592 y = temp[0];
593 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594 y = temp[1];
595 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596 y = temp[8];
597 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
598 y = temp[9];
599 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
600 dst += 2;
601 }
602 dst += 2 * stride - 2 * 8;
603 }
604}
605
607{
608 int ret;
609 int i;
610
611 f->bdsp.clear_blocks(f->block[0]);
612
613 for (i = 0; i < 6; i++)
614 if ((ret = decode_i_block(f, f->block[i])) < 0)
615 return ret;
616
617 return 0;
618}
619
620static const uint8_t *read_huffman_tables(FourXContext *f,
621 const uint8_t * const buf,
622 int buf_size)
623{
624 int frequency[512] = { 0 };
625 uint8_t flag[512];
626 int up[512];
627 uint8_t len_tab[257];
628 int bits_tab[257];
629 int start, end;
630 const uint8_t *ptr = buf;
631 const uint8_t *ptr_end = buf + buf_size;
632 int j;
633
634 memset(up, -1, sizeof(up));
635
636 start = *ptr++;
637 end = *ptr++;
638 for (;;) {
639 int i;
640
641 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
642 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
643 return NULL;
644 }
645
646 for (i = start; i <= end; i++)
647 frequency[i] = *ptr++;
648 start = *ptr++;
649 if (start == 0)
650 break;
651
652 end = *ptr++;
653 }
654 frequency[256] = 1;
655
656 while ((ptr - buf) & 3)
657 ptr++; // 4byte align
658
659 if (ptr > ptr_end) {
660 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
661 return NULL;
662 }
663
664 for (j = 257; j < 512; j++) {
665 int min_freq[2] = { 256 * 256, 256 * 256 };
666 int smallest[2] = { 0, 0 };
667 int i;
668 for (i = 0; i < j; i++) {
669 if (frequency[i] == 0)
670 continue;
671 if (frequency[i] < min_freq[1]) {
672 if (frequency[i] < min_freq[0]) {
673 min_freq[1] = min_freq[0];
674 smallest[1] = smallest[0];
675 min_freq[0] = frequency[i];
676 smallest[0] = i;
677 } else {
678 min_freq[1] = frequency[i];
679 smallest[1] = i;
680 }
681 }
682 }
683 if (min_freq[1] == 256 * 256)
684 break;
685
686 frequency[j] = min_freq[0] + min_freq[1];
687 flag[smallest[0]] = 0;
688 flag[smallest[1]] = 1;
689 up[smallest[0]] =
690 up[smallest[1]] = j;
691 frequency[smallest[0]] = frequency[smallest[1]] = 0;
692 }
693
694 for (j = 0; j < 257; j++) {
695 int node, len = 0, bits = 0;
696
697 for (node = j; up[node] != -1; node = up[node]) {
698 bits += flag[node] << len;
699 len++;
700 if (len > 31)
701 // can this happen at all ?
702 av_log(f->avctx, AV_LOG_ERROR,
703 "vlc length overflow\n");
704 }
705
706 bits_tab[j] = bits;
707 len_tab[j] = len;
708 }
709
710 ff_vlc_free(&f->pre_vlc);
711 if (vlc_init(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
712 bits_tab, 4, 4, 0))
713 return NULL;
714
715 return ptr;
716}
717
718static int mix(int c0, int c1)
719{
720 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
721 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
722 int red = 2 * (c0 >> 10) + (c1 >> 10);
723 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
724}
725
726static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
727{
728 int x, y, x2, y2;
729 const int width = f->avctx->width;
730 const int height = f->avctx->height;
731 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
732 uint16_t *dst = f->frame_buffer;
733 const uint8_t *buf_end = buf + length;
735
736 if (length < mbs * 8) {
737 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
738 return AVERROR_INVALIDDATA;
739 }
740 bytestream2_init(&g3, buf, length);
741
742 for (y = 0; y < height; y += 16) {
743 for (x = 0; x < width; x += 16) {
744 unsigned int color[4] = { 0 }, bits;
745 if (buf_end - buf < 8)
746 return AVERROR_INVALIDDATA;
747 // warning following is purely guessed ...
748 color[0] = bytestream2_get_le16u(&g3);
749 color[1] = bytestream2_get_le16u(&g3);
750
751 if (color[0] & 0x8000)
752 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
753 if (color[1] & 0x8000)
754 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
755
756 color[2] = mix(color[0], color[1]);
757 color[3] = mix(color[1], color[0]);
758
759 bits = bytestream2_get_le32u(&g3);
760 for (y2 = 0; y2 < 16; y2++) {
761 for (x2 = 0; x2 < 16; x2++) {
762 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
763 dst[y2 * width + x2] = color[(bits >> index) & 3];
764 }
765 }
766 dst += 16;
767 }
768 dst += 16 * width - x;
769 }
770
771 return 0;
772}
773
774static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
775{
776 int x, y, ret;
777 const int width = f->avctx->width;
778 const int height = f->avctx->height;
779 const unsigned int bitstream_size = AV_RL32(buf);
780 unsigned int prestream_size;
781 const uint8_t *prestream;
782
783 if (bitstream_size > (1 << 26))
784 return AVERROR_INVALIDDATA;
785
786 if (length < bitstream_size + 12) {
787 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
788 return AVERROR_INVALIDDATA;
789 }
790
791 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
792 prestream = buf + bitstream_size + 12;
793
794 if (prestream_size + bitstream_size + 12 != length
795 || prestream_size > (1 << 26)) {
796 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
797 prestream_size, bitstream_size, length);
798 return AVERROR_INVALIDDATA;
799 }
800
801 prestream = read_huffman_tables(f, prestream, prestream_size);
802 if (!prestream) {
803 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
804 return AVERROR_INVALIDDATA;
805 }
806
807 av_assert0(prestream <= buf + length);
808
809 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
810
811 prestream_size = length + buf - prestream;
812
813 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
814 prestream_size);
815 if (!f->bitstream_buffer)
816 return AVERROR(ENOMEM);
817 memcpy(f->bitstream_buffer, prestream, prestream_size);
818 f->bbdsp.bswap_buf(f->bitstream_buffer, f->bitstream_buffer,
819 prestream_size / 4);
820 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
821
822 f->last_dc = 0 * 128 * 8 * 8;
823
824 for (y = 0; y < height; y += 16) {
825 for (x = 0; x < width; x += 16) {
826 if ((ret = decode_i_mb(f)) < 0)
827 return ret;
828
829 idct_put(f, x, y);
830 }
831 }
832
833 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
834 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
835
836 return 0;
837}
838
839static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
840 int *got_frame, AVPacket *avpkt)
841{
842 const uint8_t *buf = avpkt->data;
843 int buf_size = avpkt->size;
844 FourXContext *const f = avctx->priv_data;
845 int i, frame_4cc, frame_size, ret;
846
847 if (buf_size < 20)
848 return AVERROR_INVALIDDATA;
849
850 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
851
852 if (buf_size < AV_RL32(buf + 4) + 8) {
853 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
854 buf_size, AV_RL32(buf + 4));
855 return AVERROR_INVALIDDATA;
856 }
857
858 frame_4cc = AV_RL32(buf);
859
860 if (frame_4cc == AV_RL32("cfrm")) {
861 int free_index = -1;
862 int id, whole_size;
863 const int data_size = buf_size - 20;
864 CFrameBuffer *cfrm;
865
866 if (f->version <= 1) {
867 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
868 return AVERROR_INVALIDDATA;
869 }
870
871 id = AV_RL32(buf + 12);
872 whole_size = AV_RL32(buf + 16);
873
874 if (data_size < 0 || whole_size < 0) {
875 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
876 return AVERROR_INVALIDDATA;
877 }
878
879 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
880 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_num)
881 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
882 f->cfrm[i].id);
883
884 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
885 if (f->cfrm[i].id == id)
886 break;
887 if (f->cfrm[i].size == 0)
888 free_index = i;
889 }
890
891 if (i >= CFRAME_BUFFER_COUNT) {
892 if (free_index < 0)
893 return AVERROR_INVALIDDATA;
894 i = free_index;
895 f->cfrm[i].id = id;
896 }
897 cfrm = &f->cfrm[i];
898
899 if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
900 return AVERROR_INVALIDDATA;
901
902 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
903 cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
904 // explicit check needed as memcpy below might not catch a NULL
905 if (!cfrm->data) {
906 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
907 return AVERROR(ENOMEM);
908 }
909
910 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
911 cfrm->size += data_size;
912
913 if (cfrm->size >= whole_size) {
914 buf = cfrm->data;
915 frame_size = cfrm->size;
916
917 if (id != avctx->frame_num)
918 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %"PRId64"\n",
919 id, avctx->frame_num);
920
921 if (f->version <= 1)
922 return AVERROR_INVALIDDATA;
923
924 cfrm->size = cfrm->id = 0;
925 frame_4cc = AV_RL32("pfrm");
926 } else
927 return buf_size;
928 } else {
929 buf = buf + 12;
930 frame_size = buf_size - 12;
931 }
932
933 if ( frame_4cc == AV_RL32("ifr2") || frame_4cc == AV_RL32("ifrm")
934 || frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
935 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
936 return ret;
937 }
938
939 if (frame_4cc == AV_RL32("ifr2")) {
940 picture->pict_type = AV_PICTURE_TYPE_I;
941 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
942 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
943 return ret;
944 }
945 } else if (frame_4cc == AV_RL32("ifrm")) {
946 picture->pict_type = AV_PICTURE_TYPE_I;
947 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
948 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
949 return ret;
950 }
951 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
952 picture->pict_type = AV_PICTURE_TYPE_P;
953 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
954 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
955 return ret;
956 }
957 } else if (frame_4cc == AV_RL32("snd_")) {
958 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
959 buf_size);
960 return AVERROR_INVALIDDATA;
961 } else {
962 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
963 buf_size);
964 return AVERROR_INVALIDDATA;
965 }
966
967 if (picture->pict_type == AV_PICTURE_TYPE_I)
968 picture->flags |= AV_FRAME_FLAG_KEY;
969 else
970 picture->flags &= ~AV_FRAME_FLAG_KEY;
971
972 av_image_copy_plane(picture->data[0], picture->linesize[0],
973 (const uint8_t*)f->frame_buffer, avctx->width * 2,
974 avctx->width * 2, avctx->height);
975 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
976
977 *got_frame = 1;
978
979 return buf_size;
980}
981
983{
984 FourXContext * const f = avctx->priv_data;
985 int i;
986
987 av_freep(&f->frame_buffer);
988 av_freep(&f->last_frame_buffer);
989 av_freep(&f->bitstream_buffer);
990 f->bitstream_buffer_size = 0;
991 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
992 av_freep(&f->cfrm[i].data);
993 f->cfrm[i].allocated_size = 0;
994 }
995 ff_vlc_free(&f->pre_vlc);
996
997 return 0;
998}
999
1001{
1002 static AVOnce init_static_once = AV_ONCE_INIT;
1003 FourXContext * const f = avctx->priv_data;
1004 int ret;
1005
1006 if (avctx->extradata_size != 4 || !avctx->extradata) {
1007 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
1008 return AVERROR_INVALIDDATA;
1009 }
1010 if((avctx->width % 16) || (avctx->height % 16)) {
1011 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1012 return AVERROR_INVALIDDATA;
1013 }
1014
1015 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1016 if (ret < 0)
1017 return ret;
1018
1019 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1020 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1021 if (!f->frame_buffer || !f->last_frame_buffer)
1022 return AVERROR(ENOMEM);
1023
1024 f->version = AV_RL32(avctx->extradata) >> 16;
1025 ff_blockdsp_init(&f->bdsp);
1026 ff_bswapdsp_init(&f->bbdsp);
1027 f->avctx = avctx;
1028
1029 if (f->version > 2)
1030 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1031 else
1032 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1033
1034 ff_thread_once(&init_static_once, init_vlcs);
1035
1036 return 0;
1037}
1038
1040 .p.name = "4xm",
1041 CODEC_LONG_NAME("4X Movie"),
1042 .p.type = AVMEDIA_TYPE_VIDEO,
1043 .p.id = AV_CODEC_ID_4XM,
1044 .priv_data_size = sizeof(FourXContext),
1045 .init = decode_init,
1046 .close = decode_end,
1048 .p.capabilities = AV_CODEC_CAP_DR1,
1049 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1050};
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
static double val(void *priv, double ch)
Definition aeval.c:77
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition avassert.h:109
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
Libavcodec external API header.
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition bytestream.h:137
#define flag(name)
Definition cbs_h264.c:60
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define f(width, name)
Definition cbs_vp8.c:236
#define FF_CODEC_DECODE_CB(func)
#define CODEC_LONG_NAME(str)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define NULL
Definition coverity.c:32
static int16_t block[64]
Definition dct.c:125
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1814
enum AVCodecID id
Definition dts2pts.c:612
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:613
static const uint8_t bits[8]
Definition fastaudio.c:100
int ret
Definition ffplay.c:391
reference-counted frame API
static const uint8_t frame_size[4]
Definition g723_1.h:222
bitstream reader API header.
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
static int get_bits_left(GetBitContext *gb)
Definition get_bits.h:688
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition get_bits.h:517
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
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition avcodec.h:302
@ AV_CODEC_ID_4XM
Definition codec_id.h:84
#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
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
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
#define AVERROR(e)
Definition error.h:45
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:694
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
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:601
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
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
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
Intra.
Definition avutil.h:278
@ AV_PICTURE_TYPE_P
Predicted.
Definition avutil.h:279
int index
Definition gxfenc.c:90
static av_always_inline void scale(vec_s32 res[4], vec_s16 res_packed[2], const int shift)
misc image utilities
#define AV_RL32(p)
#define AV_RL16(p)
static const int8_t mv[256][2]
Definition 4xm.c:81
static void idct_put(FourXContext *f, int x, int y)
Definition 4xm.c:560
static void init_mv(FourXContext *f, int linesize)
Definition 4xm.c:267
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:774
#define ACDC_VLC_BITS
Definition 4xm.c:46
static const uint8_t dequant_table[64]
Definition 4xm.c:118
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:432
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition 4xm.c:345
static av_cold int decode_init(AVCodecContext *avctx)
Definition 4xm.c:1000
static const uint8_t block_type_tab[2][4][8][2]
Definition 4xm.c:50
static void idct(int16_t block[64])
Definition 4xm.c:167
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition 4xm.c:501
static int mix(int c0, int c1)
Definition 4xm.c:718
static av_cold int decode_end(AVCodecContext *avctx)
Definition 4xm.c:982
const FFCodec ff_fourxm_decoder
Definition 4xm.c:1039
#define CFRAME_BUFFER_COUNT
Definition 4xm.c:48
static const uint8_t size2index[4][4]
Definition 4xm.c:74
#define FIX_1_847759065
Definition 4xm.c:162
#define MULTIPLY(var, const)
Definition 4xm.c:165
static int decode_i_mb(FourXContext *f)
Definition 4xm.c:606
#define FIX_2_613125930
Definition 4xm.c:163
static VLCElem block_type_vlc[2][4][32]
Definition 4xm.c:129
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition 4xm.c:726
#define FIX_1_414213562
Definition 4xm.c:161
#define FIX_1_082392200
Definition 4xm.c:160
static av_cold void init_vlcs(void)
Definition 4xm.c:252
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition 4xm.c:839
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition 4xm.c:620
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition 4xm.c:289
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition 4xm.c:296
#define BLOCK_TYPE_VLC_BITS
Definition 4xm.c:45
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition blockdsp.c:58
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition bswapdsp.c:37
av_cold void CBS_FUNC close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition cbs.c:118
#define av_cold
Definition attributes.h:117
#define AVOnce
Definition thread.h:202
static int ff_thread_once(char *control, void(*routine)(void))
Definition thread.h:205
#define AV_ONCE_INIT
Definition thread.h:203
#define FFSWAP(type, a, b)
Definition macros.h:52
#define FFMAX(a, b)
Definition macros.h:47
#define FFALIGN(x, a)
Definition macros.h:78
const uint8_t ff_zigzag_direct[64]
Definition mathtables.c:137
Memory handling functions.
static const uint64_t c1
Definition murmur3.c:52
#define AV_PIX_FMT_BGR555
Definition pixfmt.h:541
#define AV_PIX_FMT_RGB565
Definition pixfmt.h:535
#define FF_ARRAY_ELEMS(a)
const uint8_t * code
Definition spdifenc.c:433
main external API structure.
Definition avcodec.h:443
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:644
int width
picture width / height.
Definition avcodec.h:605
int64_t frame_num
Frame counter, set by libavcodec.
Definition avcodec.h:1893
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
int extradata_size
Definition avcodec.h:527
void * priv_data
Definition avcodec.h:470
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:500
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition frame.h:723
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:524
enum AVPictureType pict_type
Picture type of the frame.
Definition frame.h:571
This structure stores compressed data.
Definition packet.h:587
int size
Definition packet.h:611
uint8_t * data
Definition packet.h:610
unsigned int allocated_size
Definition 4xm.c:133
uint8_t * data
Definition 4xm.c:136
int id
Definition 4xm.c:135
unsigned int size
Definition 4xm.c:134
BlockDSPContext bdsp
Definition 4xm.c:141
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition 4xm.c:156
GetBitContext gb
Definition 4xm.c:146
VLC pre_vlc
Definition 4xm.c:150
DECLARE_ALIGNED(32, int16_t, block)[6][64]
uint16_t * last_frame_buffer
Definition 4xm.c:144
int version
Definition 4xm.c:155
BswapDSPContext bbdsp
Definition 4xm.c:142
GetBitContext pre_gb
ac/dc prefix
Definition 4xm.c:145
GetByteContext g
Definition 4xm.c:147
int last_dc
Definition 4xm.c:151
GetByteContext g2
Definition 4xm.c:148
int mv[256]
Definition 4xm.c:149
AVCodecContext * avctx
Definition 4xm.c:140
unsigned int bitstream_buffer_size
Definition 4xm.c:154
void * bitstream_buffer
Definition 4xm.c:153
uint16_t * frame_buffer
Definition 4xm.c:143
Definition vlc.h:32
Definition vlc.h:50
uint8_t level
Definition svq3.c:208
#define stride
#define av_mallocz(s)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition vp8dsp.c:248
#define height
Definition dsp.h:99
#define width
Definition dsp.h:99
static double cr(void *priv, double x, double y)
Definition vf_geq.c:248
static double cb(void *priv, double x, double y)
Definition vf_geq.c:247
else temp
Definition vf_mcdeint.c:275
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
void ff_vlc_free(VLC *vlc)
Definition vlc.c:580
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition vlc.h:70
int len