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