repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / 4xm.c
CommitLineData
2ba45a60
DM		 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 "avcodec.h"
34#include "blockdsp.h"
35#include "bswapdsp.h"
36#include "bytestream.h"
37#include "get_bits.h"
38#include "internal.h"
39
40
41#define BLOCK_TYPE_VLC_BITS 5
42#define ACDC_VLC_BITS 9
43
44#define CFRAME_BUFFER_COUNT 100
45
46static const uint8_t block_type_tab[2][4][8][2] = {
47 {
48 { // { 8, 4, 2 } x { 8, 4, 2}
49 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
50 }, { // { 8, 4 } x 1
51 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52 }, { // 1 x { 8, 4 }
53 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54 }, { // 1 x 2, 2 x 1
55 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
56 }
57 }, {
58 { // { 8, 4, 2 } x { 8, 4, 2}
59 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60 }, {// { 8, 4 } x 1
61 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 }, {// 1 x { 8, 4 }
63 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 }, {// 1 x 2, 2 x 1
65 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
66 }
67 }
68};
69
70static const uint8_t size2index[4][4] = {
71 { -1, 3, 1, 1 },
72 { 3, 0, 0, 0 },
73 { 2, 0, 0, 0 },
74 { 2, 0, 0, 0 },
75};
76
77static const int8_t mv[256][2] = {
78 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
79 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
80 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
81 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
82 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
83 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
84 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
85 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
86 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
87 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
88 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
89 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
90 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
91 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
92 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
93 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
94 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
95 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
96 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
97 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
98 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
99 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
100 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
101 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
102 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
103 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
104 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
105 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
106 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
107 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
108 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
109 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
110};
111
112/* This is simply the scaled down elementwise product of the standard JPEG
113 * quantizer table and the AAN premul table. */
114static const uint8_t dequant_table[64] = {
115 16, 15, 13, 19, 24, 31, 28, 17,
116 17, 23, 25, 31, 36, 63, 45, 21,
117 18, 24, 27, 37, 52, 59, 49, 20,
118 16, 28, 34, 40, 60, 80, 51, 20,
119 18, 31, 48, 66, 68, 86, 56, 21,
120 19, 38, 56, 59, 64, 64, 48, 20,
121 27, 48, 55, 55, 56, 51, 35, 15,
122 20, 35, 34, 32, 31, 22, 15, 8,
123};
124
125static VLC block_type_vlc[2][4];
126
127
128typedef struct CFrameBuffer {
129 unsigned int allocated_size;
130 unsigned int size;
131 int id;
132 uint8_t *data;
133} CFrameBuffer;
134
135typedef struct FourXContext {
136 AVCodecContext *avctx;
137 BlockDSPContext bdsp;
138 BswapDSPContext bbdsp;
139 uint16_t *frame_buffer;
140 uint16_t *last_frame_buffer;
141 GetBitContext pre_gb; ///< ac/dc prefix
142 GetBitContext gb;
143 GetByteContext g;
144 GetByteContext g2;
145 int mv[256];
146 VLC pre_vlc;
147 int last_dc;
148 DECLARE_ALIGNED(16, int16_t, block)[6][64];
149 void *bitstream_buffer;
150 unsigned int bitstream_buffer_size;
151 int version;
152 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
153} FourXContext;
154
155
156#define FIX_1_082392200 70936
157#define FIX_1_414213562 92682
158#define FIX_1_847759065 121095
159#define FIX_2_613125930 171254
160
161#define MULTIPLY(var, const) (((var) * (const)) >> 16)
162
163static void idct(int16_t block[64])
164{
165 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
166 int tmp10, tmp11, tmp12, tmp13;
167 int z5, z10, z11, z12, z13;
168 int i;
169 int temp[64];
170
171 for (i = 0; i < 8; i++) {
172 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
173 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
174
175 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
176 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
177
178 tmp0 = tmp10 + tmp13;
179 tmp3 = tmp10 - tmp13;
180 tmp1 = tmp11 + tmp12;
181 tmp2 = tmp11 - tmp12;
182
183 z13 = block[8 * 5 + i] + block[8 * 3 + i];
184 z10 = block[8 * 5 + i] - block[8 * 3 + i];
185 z11 = block[8 * 1 + i] + block[8 * 7 + i];
186 z12 = block[8 * 1 + i] - block[8 * 7 + i];
187
188 tmp7 = z11 + z13;
189 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
190
191 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
192 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
193 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
194
195 tmp6 = tmp12 - tmp7;
196 tmp5 = tmp11 - tmp6;
197 tmp4 = tmp10 + tmp5;
198
199 temp[8 * 0 + i] = tmp0 + tmp7;
200 temp[8 * 7 + i] = tmp0 - tmp7;
201 temp[8 * 1 + i] = tmp1 + tmp6;
202 temp[8 * 6 + i] = tmp1 - tmp6;
203 temp[8 * 2 + i] = tmp2 + tmp5;
204 temp[8 * 5 + i] = tmp2 - tmp5;
205 temp[8 * 4 + i] = tmp3 + tmp4;
206 temp[8 * 3 + i] = tmp3 - tmp4;
207 }
208
209 for (i = 0; i < 8 * 8; i += 8) {
210 tmp10 = temp[0 + i] + temp[4 + i];
211 tmp11 = temp[0 + i] - temp[4 + i];
212
213 tmp13 = temp[2 + i] + temp[6 + i];
214 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
215
216 tmp0 = tmp10 + tmp13;
217 tmp3 = tmp10 - tmp13;
218 tmp1 = tmp11 + tmp12;
219 tmp2 = tmp11 - tmp12;
220
221 z13 = temp[5 + i] + temp[3 + i];
222 z10 = temp[5 + i] - temp[3 + i];
223 z11 = temp[1 + i] + temp[7 + i];
224 z12 = temp[1 + i] - temp[7 + i];
225
226 tmp7 = z11 + z13;
227 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
228
229 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
230 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
231 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
232
233 tmp6 = tmp12 - tmp7;
234 tmp5 = tmp11 - tmp6;
235 tmp4 = tmp10 + tmp5;
236
237 block[0 + i] = (tmp0 + tmp7) >> 6;
238 block[7 + i] = (tmp0 - tmp7) >> 6;
239 block[1 + i] = (tmp1 + tmp6) >> 6;
240 block[6 + i] = (tmp1 - tmp6) >> 6;
241 block[2 + i] = (tmp2 + tmp5) >> 6;
242 block[5 + i] = (tmp2 - tmp5) >> 6;
243 block[4 + i] = (tmp3 + tmp4) >> 6;
244 block[3 + i] = (tmp3 - tmp4) >> 6;
245 }
246}
247
248static av_cold void init_vlcs(FourXContext *f)
249{
250 static VLC_TYPE table[2][4][32][2];
251 int i, j;
252
253 for (i = 0; i < 2; i++) {
254 for (j = 0; j < 4; j++) {
255 block_type_vlc[i][j].table = table[i][j];
256 block_type_vlc[i][j].table_allocated = 32;
257 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
258 &block_type_tab[i][j][0][1], 2, 1,
259 &block_type_tab[i][j][0][0], 2, 1,
260 INIT_VLC_USE_NEW_STATIC);
261 }
262 }
263}
264
265static void init_mv(FourXContext *f, int linesize)
266{
267 int i;
268
269 for (i = 0; i < 256; i++) {
270 if (f->version > 1)
271 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
272 else
273 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
274 }
275}
276
277#if HAVE_BIGENDIAN
278#define LE_CENTRIC_MUL(dst, src, scale, dc) \
279 { \
280 unsigned tmpval = AV_RN32(src); \
281 tmpval = (tmpval << 16) | (tmpval >> 16); \
282 tmpval = tmpval * (scale) + (dc); \
283 tmpval = (tmpval << 16) | (tmpval >> 16); \
284 AV_WN32A(dst, tmpval); \
285 }
286#else
287#define LE_CENTRIC_MUL(dst, src, scale, dc) \
288 { \
289 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
290 AV_WN32A(dst, tmpval); \
291 }
292#endif
293
294static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
295 int h, int stride, int scale, unsigned dc)
296{
297 int i;
298 dc *= 0x10001;
299
300 switch (log2w) {
301 case 0:
302 for (i = 0; i < h; i++) {
303 dst[0] = scale * src[0] + dc;
304 if (scale)
305 src += stride;
306 dst += stride;
307 }
308 break;
309 case 1:
310 for (i = 0; i < h; i++) {
311 LE_CENTRIC_MUL(dst, src, scale, dc);
312 if (scale)
313 src += stride;
314 dst += stride;
315 }
316 break;
317 case 2:
318 for (i = 0; i < h; i++) {
319 LE_CENTRIC_MUL(dst, src, scale, dc);
320 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321 if (scale)
322 src += stride;
323 dst += stride;
324 }
325 break;
326 case 3:
327 for (i = 0; i < h; i++) {
328 LE_CENTRIC_MUL(dst, src, scale, dc);
329 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
330 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
331 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
332 if (scale)
333 src += stride;
334 dst += stride;
335 }
336 break;
337 default:
338 av_assert0(0);
339 }
340}
341
342static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
343 int log2w, int log2h, int stride)
344{
345 const int index = size2index[log2h][log2w];
346 const int h = 1 << log2h;
347 int code = get_vlc2(&f->gb,
348 block_type_vlc[1 - (f->version > 1)][index].table,
349 BLOCK_TYPE_VLC_BITS, 1);
350 uint16_t *start = f->last_frame_buffer;
351 uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
352 int ret;
353 int scale = 1;
354 unsigned dc = 0;
355
356 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
357
358 if (code == 1) {
359 log2h--;
360 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
361 return ret;
362 return decode_p_block(f, dst + (stride << log2h),
363 src + (stride << log2h),
364 log2w, log2h, stride);
365 } else if (code == 2) {
366 log2w--;
367 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
368 return ret;
369 return decode_p_block(f, dst + (1 << log2w),
370 src + (1 << log2w),
371 log2w, log2h, stride);
372 } else if (code == 6) {
373 if (bytestream2_get_bytes_left(&f->g2) < 4) {
374 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
375 return AVERROR_INVALIDDATA;
376 }
377 if (log2w) {
378 dst[0] = bytestream2_get_le16u(&f->g2);
379 dst[1] = bytestream2_get_le16u(&f->g2);
380 } else {
381 dst[0] = bytestream2_get_le16u(&f->g2);
382 dst[stride] = bytestream2_get_le16u(&f->g2);
383 }
384 return 0;
385 }
386
387 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
388 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
389 return AVERROR_INVALIDDATA;
390 }
391
392 if (code == 0) {
393 src += f->mv[bytestream2_get_byte(&f->g)];
394 } else if (code == 3 && f->version >= 2) {
395 return 0;
396 } else if (code == 4) {
397 src += f->mv[bytestream2_get_byte(&f->g)];
398 if (bytestream2_get_bytes_left(&f->g2) < 2){
399 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
400 return AVERROR_INVALIDDATA;
401 }
402 dc = bytestream2_get_le16(&f->g2);
403 } else if (code == 5) {
404 if (bytestream2_get_bytes_left(&f->g2) < 2){
405 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
406 return AVERROR_INVALIDDATA;
407 }
408 av_assert0(start <= src && src <= end);
409 scale = 0;
410 dc = bytestream2_get_le16(&f->g2);
411 }
412
413 if (start > src || src > end) {
414 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
415 return AVERROR_INVALIDDATA;
416 }
417
418 mcdc(dst, src, log2w, h, stride, scale, dc);
419
420 return 0;
421}
422
423static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
424{
425 int x, y;
426 const int width = f->avctx->width;
427 const int height = f->avctx->height;
428 uint16_t *dst = f->frame_buffer;
429 uint16_t *src;
430 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
431 bytestream_offset, wordstream_offset;
432 int ret;
433
434 src = f->last_frame_buffer;
435
436 if (f->version > 1) {
437 extra = 20;
438 if (length < extra)
439 return AVERROR_INVALIDDATA;
440 bitstream_size = AV_RL32(buf + 8);
441 wordstream_size = AV_RL32(buf + 12);
442 bytestream_size = AV_RL32(buf + 16);
443 } else {
444 extra = 0;
445 bitstream_size = AV_RL16(buf - 4);
446 wordstream_size = AV_RL16(buf - 2);
447 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
448 }
449
450 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
451 bytestream_size > length - bitstream_size ||
452 wordstream_size > length - bytestream_size - bitstream_size ||
453 extra > length - bytestream_size - bitstream_size - wordstream_size) {
454 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
455 bitstream_size+ bytestream_size+ wordstream_size - length);
456 return AVERROR_INVALIDDATA;
457 }
458
459 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
460 bitstream_size);
461 if (!f->bitstream_buffer)
462 return AVERROR(ENOMEM);
463 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
464 bitstream_size / 4);
465 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
466
467 wordstream_offset = extra + bitstream_size;
468 bytestream_offset = extra + bitstream_size + wordstream_size;
469 bytestream2_init(&f->g2, buf + wordstream_offset,
470 length - wordstream_offset);
471 bytestream2_init(&f->g, buf + bytestream_offset,
472 length - bytestream_offset);
473
474 init_mv(f, width * 2);
475
476 for (y = 0; y < height; y += 8) {
477 for (x = 0; x < width; x += 8)
478 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
479 return ret;
480 src += 8 * width;
481 dst += 8 * width;
482 }
483
484 return 0;
485}
486
487/**
488 * decode block and dequantize.
489 * Note this is almost identical to MJPEG.
490 */
491static int decode_i_block(FourXContext *f, int16_t *block)
492{
493 int code, i, j, level, val;
494
495 if (get_bits_left(&f->gb) < 2){
496 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
497 return -1;
498 }
499
500 /* DC coef */
501 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
502 if (val >> 4) {
503 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
504 return AVERROR_INVALIDDATA;
505 }
506
507 if (val)
508 val = get_xbits(&f->gb, val);
509
510 val = val * dequant_table[0] + f->last_dc;
511 f->last_dc = block[0] = val;
512 /* AC coefs */
513 i = 1;
514 for (;;) {
515 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
516
517 /* EOB */
518 if (code == 0)
519 break;
520 if (code == 0xf0) {
521 i += 16;
522 } else {
523 if (code & 0xf) {
524 level = get_xbits(&f->gb, code & 0xf);
525 } else {
526 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
527 return AVERROR_INVALIDDATA;
528 }
529 i += code >> 4;
530 if (i >= 64) {
531 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
532 return 0;
533 }
534
535 j = ff_zigzag_direct[i];
536 block[j] = level * dequant_table[j];
537 i++;
538 if (i >= 64)
539 break;
540 }
541 }
542
543 return 0;
544}
545
546static inline void idct_put(FourXContext *f, int x, int y)
547{
548 int16_t (*block)[64] = f->block;
549 int stride = f->avctx->width;
550 int i;
551 uint16_t *dst = f->frame_buffer + y * stride + x;
552
553 for (i = 0; i < 4; i++) {
554 block[i][0] += 0x80 * 8 * 8;
555 idct(block[i]);
556 }
557
558 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
559 for (i = 4; i < 6; i++)
560 idct(block[i]);
561 }
562
563 /* Note transform is:
564 * y = ( 1b + 4g + 2r) / 14
565 * cb = ( 3b - 2g - 1r) / 14
566 * cr = (-1b - 4g + 5r) / 14 */
567 for (y = 0; y < 8; y++) {
568 for (x = 0; x < 8; x++) {
569 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
570 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
571 int cb = block[4][x + 8 * y];
572 int cr = block[5][x + 8 * y];
573 int cg = (cb + cr) >> 1;
574 int y;
575
576 cb += cb;
577
578 y = temp[0];
579 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
580 y = temp[1];
581 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
582 y = temp[8];
583 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
584 y = temp[9];
585 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586 dst += 2;
587 }
588 dst += 2 * stride - 2 * 8;
589 }
590}
591
592static int decode_i_mb(FourXContext *f)
593{
594 int ret;
595 int i;
596
597 f->bdsp.clear_blocks(f->block[0]);
598
599 for (i = 0; i < 6; i++)
600 if ((ret = decode_i_block(f, f->block[i])) < 0)
601 return ret;
602
603 return 0;
604}
605
606static const uint8_t *read_huffman_tables(FourXContext *f,
607 const uint8_t * const buf,
608 int buf_size)
609{
610 int frequency[512] = { 0 };
611 uint8_t flag[512];
612 int up[512];
613 uint8_t len_tab[257];
614 int bits_tab[257];
615 int start, end;
616 const uint8_t *ptr = buf;
617 const uint8_t *ptr_end = buf + buf_size;
618 int j;
619
620 memset(up, -1, sizeof(up));
621
622 start = *ptr++;
623 end = *ptr++;
624 for (;;) {
625 int i;
626
627 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
628 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
629 return NULL;
630 }
631
632 for (i = start; i <= end; i++)
633 frequency[i] = *ptr++;
634 start = *ptr++;
635 if (start == 0)
636 break;
637
638 end = *ptr++;
639 }
640 frequency[256] = 1;
641
642 while ((ptr - buf) & 3)
643 ptr++; // 4byte align
644
645 if (ptr > ptr_end) {
646 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
647 return NULL;
648 }
649
650 for (j = 257; j < 512; j++) {
651 int min_freq[2] = { 256 * 256, 256 * 256 };
652 int smallest[2] = { 0, 0 };
653 int i;
654 for (i = 0; i < j; i++) {
655 if (frequency[i] == 0)
656 continue;
657 if (frequency[i] < min_freq[1]) {
658 if (frequency[i] < min_freq[0]) {
659 min_freq[1] = min_freq[0];
660 smallest[1] = smallest[0];
661 min_freq[0] = frequency[i];
662 smallest[0] = i;
663 } else {
664 min_freq[1] = frequency[i];
665 smallest[1] = i;
666 }
667 }
668 }
669 if (min_freq[1] == 256 * 256)
670 break;
671
672 frequency[j] = min_freq[0] + min_freq[1];
673 flag[smallest[0]] = 0;
674 flag[smallest[1]] = 1;
675 up[smallest[0]] =
676 up[smallest[1]] = j;
677 frequency[smallest[0]] = frequency[smallest[1]] = 0;
678 }
679
680 for (j = 0; j < 257; j++) {
681 int node, len = 0, bits = 0;
682
683 for (node = j; up[node] != -1; node = up[node]) {
684 bits += flag[node] << len;
685 len++;
686 if (len > 31)
687 // can this happen at all ?
688 av_log(f->avctx, AV_LOG_ERROR,
689 "vlc length overflow\n");
690 }
691
692 bits_tab[j] = bits;
693 len_tab[j] = len;
694 }
695
696 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
697 bits_tab, 4, 4, 0))
698 return NULL;
699
700 return ptr;
701}
702
703static int mix(int c0, int c1)
704{
705 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
706 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
707 int red = 2 * (c0 >> 10) + (c1 >> 10);
708 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
709}
710
711static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
712{
713 int x, y, x2, y2;
714 const int width = f->avctx->width;
715 const int height = f->avctx->height;
716 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
717 uint16_t *dst = f->frame_buffer;
718 const uint8_t *buf_end = buf + length;
719 GetByteContext g3;
720
721 if (length < mbs * 8) {
722 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
723 return AVERROR_INVALIDDATA;
724 }
725 bytestream2_init(&g3, buf, length);
726
727 for (y = 0; y < height; y += 16) {
728 for (x = 0; x < width; x += 16) {
729 unsigned int color[4] = { 0 }, bits;
730 if (buf_end - buf < 8)
731 return -1;
732 // warning following is purely guessed ...
733 color[0] = bytestream2_get_le16u(&g3);
734 color[1] = bytestream2_get_le16u(&g3);
735
736 if (color[0] & 0x8000)
737 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
738 if (color[1] & 0x8000)
739 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
740
741 color[2] = mix(color[0], color[1]);
742 color[3] = mix(color[1], color[0]);
743
744 bits = bytestream2_get_le32u(&g3);
745 for (y2 = 0; y2 < 16; y2++) {
746 for (x2 = 0; x2 < 16; x2++) {
747 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
748 dst[y2 * width + x2] = color[(bits >> index) & 3];
749 }
750 }
751 dst += 16;
752 }
753 dst += 16 * width - x;
754 }
755
756 return 0;
757}
758
759static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
760{
761 int x, y, ret;
762 const int width = f->avctx->width;
763 const int height = f->avctx->height;
764 const unsigned int bitstream_size = AV_RL32(buf);
765 unsigned int prestream_size;
766 const uint8_t *prestream;
767
768 if (bitstream_size > (1 << 26))
769 return AVERROR_INVALIDDATA;
770
771 if (length < bitstream_size + 12) {
772 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
773 return AVERROR_INVALIDDATA;
774 }
775
776 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
777 prestream = buf + bitstream_size + 12;
778
779 if (prestream_size + bitstream_size + 12 != length
780 || prestream_size > (1 << 26)) {
781 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
782 prestream_size, bitstream_size, length);
783 return AVERROR_INVALIDDATA;
784 }
785
786 prestream = read_huffman_tables(f, prestream, prestream_size);
787 if (!prestream) {
788 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
789 return AVERROR_INVALIDDATA;
790 }
791
792 av_assert0(prestream <= buf + length);
793
794 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
795
796 prestream_size = length + buf - prestream;
797
798 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
799 prestream_size);
800 if (!f->bitstream_buffer)
801 return AVERROR(ENOMEM);
802 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
803 prestream_size / 4);
804 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
805
806 f->last_dc = 0 * 128 * 8 * 8;
807
808 for (y = 0; y < height; y += 16) {
809 for (x = 0; x < width; x += 16) {
810 if ((ret = decode_i_mb(f)) < 0)
811 return ret;
812
813 idct_put(f, x, y);
814 }
815 }
816
817 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
818 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
819
820 return 0;
821}
822
823static int decode_frame(AVCodecContext *avctx, void *data,
824 int *got_frame, AVPacket *avpkt)
825{
826 const uint8_t *buf = avpkt->data;
827 int buf_size = avpkt->size;
828 FourXContext *const f = avctx->priv_data;
829 AVFrame *picture = data;
830 int i, frame_4cc, frame_size, ret;
831
832 if (buf_size < 20)
833 return AVERROR_INVALIDDATA;
834
835 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
836
837 if (buf_size < AV_RL32(buf + 4) + 8) {
838 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
839 buf_size, AV_RL32(buf + 4));
840 return AVERROR_INVALIDDATA;
841 }
842
843 frame_4cc = AV_RL32(buf);
844
845 if (frame_4cc == AV_RL32("cfrm")) {
846 int free_index = -1;
847 int id, whole_size;
848 const int data_size = buf_size - 20;
849 CFrameBuffer *cfrm;
850
851 if (f->version <= 1) {
852 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
853 return AVERROR_INVALIDDATA;
854 }
855
856 id = AV_RL32(buf + 12);
857 whole_size = AV_RL32(buf + 16);
858
859 if (data_size < 0 || whole_size < 0) {
860 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
861 return AVERROR_INVALIDDATA;
862 }
863
864 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
865 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
866 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
867 f->cfrm[i].id);
868
869 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
870 if (f->cfrm[i].id == id)
871 break;
872 if (f->cfrm[i].size == 0)
873 free_index = i;
874 }
875
876 if (i >= CFRAME_BUFFER_COUNT) {
877 i = free_index;
878 f->cfrm[i].id = id;
879 }
880 cfrm = &f->cfrm[i];
881
882 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
883 return AVERROR_INVALIDDATA;
884
885 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
886 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
887 // explicit check needed as memcpy below might not catch a NULL
888 if (!cfrm->data) {
889 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
890 return AVERROR(ENOMEM);
891 }
892
893 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
894 cfrm->size += data_size;
895
896 if (cfrm->size >= whole_size) {
897 buf = cfrm->data;
898 frame_size = cfrm->size;
899
900 if (id != avctx->frame_number)
901 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
902 id, avctx->frame_number);
903
904 if (f->version <= 1)
905 return AVERROR_INVALIDDATA;
906
907 cfrm->size = cfrm->id = 0;
908 frame_4cc = AV_RL32("pfrm");
909 } else
910 return buf_size;
911 } else {
912 buf = buf + 12;
913 frame_size = buf_size - 12;
914 }
915
916 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
917 return ret;
918
919 if (frame_4cc == AV_RL32("ifr2")) {
920 picture->pict_type = AV_PICTURE_TYPE_I;
921 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
922 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
923 return ret;
924 }
925 } else if (frame_4cc == AV_RL32("ifrm")) {
926 picture->pict_type = AV_PICTURE_TYPE_I;
927 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
928 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
929 return ret;
930 }
931 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
932 picture->pict_type = AV_PICTURE_TYPE_P;
933 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
934 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
935 return ret;
936 }
937 } else if (frame_4cc == AV_RL32("snd_")) {
938 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
939 buf_size);
940 } else {
941 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
942 buf_size);
943 }
944
945 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
946
947 av_image_copy_plane(picture->data[0], picture->linesize[0],
948 (const uint8_t*)f->frame_buffer, avctx->width * 2,
949 avctx->width * 2, avctx->height);
950 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
951
952 *got_frame = 1;
953
954 emms_c();
955
956 return buf_size;
957}
958
959static av_cold int decode_end(AVCodecContext *avctx)
960{
961 FourXContext * const f = avctx->priv_data;
962 int i;
963
964 av_freep(&f->frame_buffer);
965 av_freep(&f->last_frame_buffer);
966 av_freep(&f->bitstream_buffer);
967 f->bitstream_buffer_size = 0;
968 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
969 av_freep(&f->cfrm[i].data);
970 f->cfrm[i].allocated_size = 0;
971 }
972 ff_free_vlc(&f->pre_vlc);
973
974 return 0;
975}
976
977static av_cold int decode_init(AVCodecContext *avctx)
978{
979 FourXContext * const f = avctx->priv_data;
980 int ret;
981
982 if (avctx->extradata_size != 4 || !avctx->extradata) {
983 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
984 return AVERROR_INVALIDDATA;
985 }
986 if((avctx->width % 16) || (avctx->height % 16)) {
987 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
988 return AVERROR_INVALIDDATA;
989 }
990
991 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
992 if (ret < 0)
993 return ret;
994
995 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
996 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
997 if (!f->frame_buffer || !f->last_frame_buffer) {
998 decode_end(avctx);
999 return AVERROR(ENOMEM);
1000 }
1001
1002 f->version = AV_RL32(avctx->extradata) >> 16;
1003 ff_blockdsp_init(&f->bdsp, avctx);
1004 ff_bswapdsp_init(&f->bbdsp);
1005 f->avctx = avctx;
1006 init_vlcs(f);
1007
1008 if (f->version > 2)
1009 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1010 else
1011 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1012
1013 return 0;
1014}
1015
1016AVCodec ff_fourxm_decoder = {
1017 .name = "4xm",
1018 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1019 .type = AVMEDIA_TYPE_VIDEO,
1020 .id = AV_CODEC_ID_4XM,
1021 .priv_data_size = sizeof(FourXContext),
1022 .init = decode_init,
1023 .close = decode_end,
1024 .decode = decode_frame,
1025 .capabilities = CODEC_CAP_DR1,
1026};
ffmpeg Piment Noir Debian package repository