repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.5.0~trusty1.1
[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
f6fa7814 342static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
2ba45a60
DM		 343 int log2w, int log2h, int stride)
344{
f6fa7814
DM		 345 int index, h, code, ret, scale = 1;
346 uint16_t *start, *end;
2ba45a60
DM		 347 unsigned dc = 0;
348
f6fa7814
DM		 349 av_assert0(log2w >= 0 && log2h >= 0);
350
351 index = size2index[log2h][log2w];
352 av_assert0(index >= 0);
353
354 h = 1 << log2h;
355 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
356 BLOCK_TYPE_VLC_BITS, 1);
357 av_assert0(code >= 0 && code <= 6);
358
359 start = f->last_frame_buffer;
360 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
2ba45a60
DM		 361
362 if (code == 1) {
363 log2h--;
364 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
365 return ret;
366 return decode_p_block(f, dst + (stride << log2h),
367 src + (stride << log2h),
368 log2w, log2h, stride);
369 } else if (code == 2) {
370 log2w--;
371 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
372 return ret;
373 return decode_p_block(f, dst + (1 << log2w),
374 src + (1 << log2w),
375 log2w, log2h, stride);
376 } else if (code == 6) {
377 if (bytestream2_get_bytes_left(&f->g2) < 4) {
378 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
379 return AVERROR_INVALIDDATA;
380 }
381 if (log2w) {
382 dst[0] = bytestream2_get_le16u(&f->g2);
383 dst[1] = bytestream2_get_le16u(&f->g2);
384 } else {
385 dst[0] = bytestream2_get_le16u(&f->g2);
386 dst[stride] = bytestream2_get_le16u(&f->g2);
387 }
388 return 0;
389 }
390
391 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
392 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
393 return AVERROR_INVALIDDATA;
394 }
395
396 if (code == 0) {
397 src += f->mv[bytestream2_get_byte(&f->g)];
398 } else if (code == 3 && f->version >= 2) {
399 return 0;
400 } else if (code == 4) {
401 src += f->mv[bytestream2_get_byte(&f->g)];
402 if (bytestream2_get_bytes_left(&f->g2) < 2){
403 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
404 return AVERROR_INVALIDDATA;
405 }
406 dc = bytestream2_get_le16(&f->g2);
407 } else if (code == 5) {
408 if (bytestream2_get_bytes_left(&f->g2) < 2){
409 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
410 return AVERROR_INVALIDDATA;
411 }
412 av_assert0(start <= src && src <= end);
413 scale = 0;
414 dc = bytestream2_get_le16(&f->g2);
415 }
416
417 if (start > src || src > end) {
418 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
419 return AVERROR_INVALIDDATA;
420 }
421
422 mcdc(dst, src, log2w, h, stride, scale, dc);
423
424 return 0;
425}
426
427static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
428{
429 int x, y;
430 const int width = f->avctx->width;
431 const int height = f->avctx->height;
432 uint16_t *dst = f->frame_buffer;
433 uint16_t *src;
434 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
435 bytestream_offset, wordstream_offset;
436 int ret;
437
438 src = f->last_frame_buffer;
439
440 if (f->version > 1) {
441 extra = 20;
442 if (length < extra)
443 return AVERROR_INVALIDDATA;
444 bitstream_size = AV_RL32(buf + 8);
445 wordstream_size = AV_RL32(buf + 12);
446 bytestream_size = AV_RL32(buf + 16);
447 } else {
448 extra = 0;
449 bitstream_size = AV_RL16(buf - 4);
450 wordstream_size = AV_RL16(buf - 2);
451 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
452 }
453
454 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
455 bytestream_size > length - bitstream_size ||
456 wordstream_size > length - bytestream_size - bitstream_size ||
457 extra > length - bytestream_size - bitstream_size - wordstream_size) {
458 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
459 bitstream_size+ bytestream_size+ wordstream_size - length);
460 return AVERROR_INVALIDDATA;
461 }
462
463 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
464 bitstream_size);
465 if (!f->bitstream_buffer)
466 return AVERROR(ENOMEM);
467 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
468 bitstream_size / 4);
469 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
470
471 wordstream_offset = extra + bitstream_size;
472 bytestream_offset = extra + bitstream_size + wordstream_size;
473 bytestream2_init(&f->g2, buf + wordstream_offset,
474 length - wordstream_offset);
475 bytestream2_init(&f->g, buf + bytestream_offset,
476 length - bytestream_offset);
477
478 init_mv(f, width * 2);
479
480 for (y = 0; y < height; y += 8) {
481 for (x = 0; x < width; x += 8)
482 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
483 return ret;
484 src += 8 * width;
485 dst += 8 * width;
486 }
487
488 return 0;
489}
490
491/**
492 * decode block and dequantize.
493 * Note this is almost identical to MJPEG.
494 */
495static int decode_i_block(FourXContext *f, int16_t *block)
496{
497 int code, i, j, level, val;
498
499 if (get_bits_left(&f->gb) < 2){
500 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
501 return -1;
502 }
503
504 /* DC coef */
505 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
506 if (val >> 4) {
507 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
508 return AVERROR_INVALIDDATA;
509 }
510
511 if (val)
512 val = get_xbits(&f->gb, val);
513
514 val = val * dequant_table[0] + f->last_dc;
515 f->last_dc = block[0] = val;
516 /* AC coefs */
517 i = 1;
518 for (;;) {
519 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
520
521 /* EOB */
522 if (code == 0)
523 break;
524 if (code == 0xf0) {
525 i += 16;
526 } else {
527 if (code & 0xf) {
528 level = get_xbits(&f->gb, code & 0xf);
529 } else {
530 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
531 return AVERROR_INVALIDDATA;
532 }
533 i += code >> 4;
534 if (i >= 64) {
535 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
536 return 0;
537 }
538
539 j = ff_zigzag_direct[i];
540 block[j] = level * dequant_table[j];
541 i++;
542 if (i >= 64)
543 break;
544 }
545 }
546
547 return 0;
548}
549
550static inline void idct_put(FourXContext *f, int x, int y)
551{
552 int16_t (*block)[64] = f->block;
553 int stride = f->avctx->width;
554 int i;
555 uint16_t *dst = f->frame_buffer + y * stride + x;
556
557 for (i = 0; i < 4; i++) {
558 block[i][0] += 0x80 * 8 * 8;
559 idct(block[i]);
560 }
561
562 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
563 for (i = 4; i < 6; i++)
564 idct(block[i]);
565 }
566
567 /* Note transform is:
568 * y = ( 1b + 4g + 2r) / 14
569 * cb = ( 3b - 2g - 1r) / 14
570 * cr = (-1b - 4g + 5r) / 14 */
571 for (y = 0; y < 8; y++) {
572 for (x = 0; x < 8; x++) {
573 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
574 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
575 int cb = block[4][x + 8 * y];
576 int cr = block[5][x + 8 * y];
577 int cg = (cb + cr) >> 1;
578 int y;
579
580 cb += cb;
581
582 y = temp[0];
583 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
584 y = temp[1];
585 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586 y = temp[8];
587 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588 y = temp[9];
589 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590 dst += 2;
591 }
592 dst += 2 * stride - 2 * 8;
593 }
594}
595
596static int decode_i_mb(FourXContext *f)
597{
598 int ret;
599 int i;
600
601 f->bdsp.clear_blocks(f->block[0]);
602
603 for (i = 0; i < 6; i++)
604 if ((ret = decode_i_block(f, f->block[i])) < 0)
605 return ret;
606
607 return 0;
608}
609
610static const uint8_t *read_huffman_tables(FourXContext *f,
611 const uint8_t * const buf,
612 int buf_size)
613{
614 int frequency[512] = { 0 };
615 uint8_t flag[512];
616 int up[512];
617 uint8_t len_tab[257];
618 int bits_tab[257];
619 int start, end;
620 const uint8_t *ptr = buf;
621 const uint8_t *ptr_end = buf + buf_size;
622 int j;
623
624 memset(up, -1, sizeof(up));
625
626 start = *ptr++;
627 end = *ptr++;
628 for (;;) {
629 int i;
630
631 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
632 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
633 return NULL;
634 }
635
636 for (i = start; i <= end; i++)
637 frequency[i] = *ptr++;
638 start = *ptr++;
639 if (start == 0)
640 break;
641
642 end = *ptr++;
643 }
644 frequency[256] = 1;
645
646 while ((ptr - buf) & 3)
647 ptr++; // 4byte align
648
649 if (ptr > ptr_end) {
650 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
651 return NULL;
652 }
653
654 for (j = 257; j < 512; j++) {
655 int min_freq[2] = { 256 * 256, 256 * 256 };
656 int smallest[2] = { 0, 0 };
657 int i;
658 for (i = 0; i < j; i++) {
659 if (frequency[i] == 0)
660 continue;
661 if (frequency[i] < min_freq[1]) {
662 if (frequency[i] < min_freq[0]) {
663 min_freq[1] = min_freq[0];
664 smallest[1] = smallest[0];
665 min_freq[0] = frequency[i];
666 smallest[0] = i;
667 } else {
668 min_freq[1] = frequency[i];
669 smallest[1] = i;
670 }
671 }
672 }
673 if (min_freq[1] == 256 * 256)
674 break;
675
676 frequency[j] = min_freq[0] + min_freq[1];
677 flag[smallest[0]] = 0;
678 flag[smallest[1]] = 1;
679 up[smallest[0]] =
680 up[smallest[1]] = j;
681 frequency[smallest[0]] = frequency[smallest[1]] = 0;
682 }
683
684 for (j = 0; j < 257; j++) {
685 int node, len = 0, bits = 0;
686
687 for (node = j; up[node] != -1; node = up[node]) {
688 bits += flag[node] << len;
689 len++;
690 if (len > 31)
691 // can this happen at all ?
692 av_log(f->avctx, AV_LOG_ERROR,
693 "vlc length overflow\n");
694 }
695
696 bits_tab[j] = bits;
697 len_tab[j] = len;
698 }
699
700 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
701 bits_tab, 4, 4, 0))
702 return NULL;
703
704 return ptr;
705}
706
707static int mix(int c0, int c1)
708{
709 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
710 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
711 int red = 2 * (c0 >> 10) + (c1 >> 10);
712 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
713}
714
715static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
716{
717 int x, y, x2, y2;
718 const int width = f->avctx->width;
719 const int height = f->avctx->height;
720 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
721 uint16_t *dst = f->frame_buffer;
722 const uint8_t *buf_end = buf + length;
723 GetByteContext g3;
724
725 if (length < mbs * 8) {
726 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
727 return AVERROR_INVALIDDATA;
728 }
729 bytestream2_init(&g3, buf, length);
730
731 for (y = 0; y < height; y += 16) {
732 for (x = 0; x < width; x += 16) {
733 unsigned int color[4] = { 0 }, bits;
734 if (buf_end - buf < 8)
735 return -1;
736 // warning following is purely guessed ...
737 color[0] = bytestream2_get_le16u(&g3);
738 color[1] = bytestream2_get_le16u(&g3);
739
740 if (color[0] & 0x8000)
741 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
742 if (color[1] & 0x8000)
743 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
744
745 color[2] = mix(color[0], color[1]);
746 color[3] = mix(color[1], color[0]);
747
748 bits = bytestream2_get_le32u(&g3);
749 for (y2 = 0; y2 < 16; y2++) {
750 for (x2 = 0; x2 < 16; x2++) {
751 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
752 dst[y2 * width + x2] = color[(bits >> index) & 3];
753 }
754 }
755 dst += 16;
756 }
757 dst += 16 * width - x;
758 }
759
760 return 0;
761}
762
763static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
764{
765 int x, y, ret;
766 const int width = f->avctx->width;
767 const int height = f->avctx->height;
768 const unsigned int bitstream_size = AV_RL32(buf);
769 unsigned int prestream_size;
770 const uint8_t *prestream;
771
772 if (bitstream_size > (1 << 26))
773 return AVERROR_INVALIDDATA;
774
775 if (length < bitstream_size + 12) {
776 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
777 return AVERROR_INVALIDDATA;
778 }
779
780 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
781 prestream = buf + bitstream_size + 12;
782
783 if (prestream_size + bitstream_size + 12 != length
784 || prestream_size > (1 << 26)) {
785 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
786 prestream_size, bitstream_size, length);
787 return AVERROR_INVALIDDATA;
788 }
789
790 prestream = read_huffman_tables(f, prestream, prestream_size);
791 if (!prestream) {
792 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
793 return AVERROR_INVALIDDATA;
794 }
795
796 av_assert0(prestream <= buf + length);
797
798 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
799
800 prestream_size = length + buf - prestream;
801
802 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
803 prestream_size);
804 if (!f->bitstream_buffer)
805 return AVERROR(ENOMEM);
806 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
807 prestream_size / 4);
808 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
809
810 f->last_dc = 0 * 128 * 8 * 8;
811
812 for (y = 0; y < height; y += 16) {
813 for (x = 0; x < width; x += 16) {
814 if ((ret = decode_i_mb(f)) < 0)
815 return ret;
816
817 idct_put(f, x, y);
818 }
819 }
820
821 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
822 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
823
824 return 0;
825}
826
827static int decode_frame(AVCodecContext *avctx, void *data,
828 int *got_frame, AVPacket *avpkt)
829{
830 const uint8_t *buf = avpkt->data;
831 int buf_size = avpkt->size;
832 FourXContext *const f = avctx->priv_data;
833 AVFrame *picture = data;
834 int i, frame_4cc, frame_size, ret;
835
836 if (buf_size < 20)
837 return AVERROR_INVALIDDATA;
838
839 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
840
841 if (buf_size < AV_RL32(buf + 4) + 8) {
842 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
843 buf_size, AV_RL32(buf + 4));
844 return AVERROR_INVALIDDATA;
845 }
846
847 frame_4cc = AV_RL32(buf);
848
849 if (frame_4cc == AV_RL32("cfrm")) {
850 int free_index = -1;
851 int id, whole_size;
852 const int data_size = buf_size - 20;
853 CFrameBuffer *cfrm;
854
855 if (f->version <= 1) {
856 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
857 return AVERROR_INVALIDDATA;
858 }
859
860 id = AV_RL32(buf + 12);
861 whole_size = AV_RL32(buf + 16);
862
863 if (data_size < 0 || whole_size < 0) {
864 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
865 return AVERROR_INVALIDDATA;
866 }
867
868 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
869 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
870 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
871 f->cfrm[i].id);
872
873 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
874 if (f->cfrm[i].id == id)
875 break;
876 if (f->cfrm[i].size == 0)
877 free_index = i;
878 }
879
880 if (i >= CFRAME_BUFFER_COUNT) {
881 i = free_index;
882 f->cfrm[i].id = id;
883 }
884 cfrm = &f->cfrm[i];
885
886 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
887 return AVERROR_INVALIDDATA;
888
889 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
890 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
891 // explicit check needed as memcpy below might not catch a NULL
892 if (!cfrm->data) {
893 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
894 return AVERROR(ENOMEM);
895 }
896
897 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
898 cfrm->size += data_size;
899
900 if (cfrm->size >= whole_size) {
901 buf = cfrm->data;
902 frame_size = cfrm->size;
903
904 if (id != avctx->frame_number)
905 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
906 id, avctx->frame_number);
907
908 if (f->version <= 1)
909 return AVERROR_INVALIDDATA;
910
911 cfrm->size = cfrm->id = 0;
912 frame_4cc = AV_RL32("pfrm");
913 } else
914 return buf_size;
915 } else {
916 buf = buf + 12;
917 frame_size = buf_size - 12;
918 }
919
920 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
921 return ret;
922
923 if (frame_4cc == AV_RL32("ifr2")) {
924 picture->pict_type = AV_PICTURE_TYPE_I;
925 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
926 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
927 return ret;
928 }
929 } else if (frame_4cc == AV_RL32("ifrm")) {
930 picture->pict_type = AV_PICTURE_TYPE_I;
931 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
932 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
933 return ret;
934 }
935 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
936 picture->pict_type = AV_PICTURE_TYPE_P;
937 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
938 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
939 return ret;
940 }
941 } else if (frame_4cc == AV_RL32("snd_")) {
942 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
943 buf_size);
944 } else {
945 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
946 buf_size);
947 }
948
949 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
950
951 av_image_copy_plane(picture->data[0], picture->linesize[0],
952 (const uint8_t*)f->frame_buffer, avctx->width * 2,
953 avctx->width * 2, avctx->height);
954 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
955
956 *got_frame = 1;
957
958 emms_c();
959
960 return buf_size;
961}
962
963static av_cold int decode_end(AVCodecContext *avctx)
964{
965 FourXContext * const f = avctx->priv_data;
966 int i;
967
968 av_freep(&f->frame_buffer);
969 av_freep(&f->last_frame_buffer);
970 av_freep(&f->bitstream_buffer);
971 f->bitstream_buffer_size = 0;
972 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
973 av_freep(&f->cfrm[i].data);
974 f->cfrm[i].allocated_size = 0;
975 }
976 ff_free_vlc(&f->pre_vlc);
977
978 return 0;
979}
980
981static av_cold int decode_init(AVCodecContext *avctx)
982{
983 FourXContext * const f = avctx->priv_data;
984 int ret;
985
986 if (avctx->extradata_size != 4 || !avctx->extradata) {
987 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
988 return AVERROR_INVALIDDATA;
989 }
990 if((avctx->width % 16) || (avctx->height % 16)) {
991 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
992 return AVERROR_INVALIDDATA;
993 }
994
995 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
996 if (ret < 0)
997 return ret;
998
999 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1000 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1001 if (!f->frame_buffer || !f->last_frame_buffer) {
1002 decode_end(avctx);
1003 return AVERROR(ENOMEM);
1004 }
1005
1006 f->version = AV_RL32(avctx->extradata) >> 16;
1007 ff_blockdsp_init(&f->bdsp, avctx);
1008 ff_bswapdsp_init(&f->bbdsp);
1009 f->avctx = avctx;
1010 init_vlcs(f);
1011
1012 if (f->version > 2)
1013 avctx->pix_fmt = AV_PIX_FMT_RGB565;
1014 else
1015 avctx->pix_fmt = AV_PIX_FMT_BGR555;
1016
1017 return 0;
1018}
1019
1020AVCodec ff_fourxm_decoder = {
1021 .name = "4xm",
1022 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1023 .type = AVMEDIA_TYPE_VIDEO,
1024 .id = AV_CODEC_ID_4XM,
1025 .priv_data_size = sizeof(FourXContext),
1026 .init = decode_init,
1027 .close = decode_end,
1028 .decode = decode_frame,
1029 .capabilities = CODEC_CAP_DR1,
1030};
ffmpeg Piment Noir Debian package repository