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