cosmetics: typo fixes
[libav.git] / libavcodec / 4xm.c
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 4xm.c
24 * 4XM codec.
25 */
26
27 #include "avcodec.h"
28 #include "dsputil.h"
29 #include "bitstream.h"
30 #include "bytestream.h"
31
32 //#undef NDEBUG
33 //#include <assert.h>
34
35 #define BLOCK_TYPE_VLC_BITS 5
36 #define ACDC_VLC_BITS 9
37
38 #define CFRAME_BUFFER_COUNT 100
39
40 static const uint8_t block_type_tab[2][4][8][2]={
41 {
42 { //{8,4,2}x{8,4,2}
43 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
44 },{ //{8,4}x1
45 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
46 },{ //1x{8,4}
47 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
48 },{ //1x2, 2x1
49 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
50 }
51 },{
52 { //{8,4,2}x{8,4,2}
53 { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
54 },{//{8,4}x1
55 { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
56 },{//1x{8,4}
57 { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
58 },{//1x2, 2x1
59 { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
60 }
61 }
62 };
63
64 static const uint8_t size2index[4][4]={
65 {-1, 3, 1, 1},
66 { 3, 0, 0, 0},
67 { 2, 0, 0, 0},
68 { 2, 0, 0, 0},
69 };
70
71 static const int8_t mv[256][2]={
72 { 0, 0},{ 0, -1},{ -1, 0},{ 1, 0},{ 0, 1},{ -1, -1},{ 1, -1},{ -1, 1},
73 { 1, 1},{ 0, -2},{ -2, 0},{ 2, 0},{ 0, 2},{ -1, -2},{ 1, -2},{ -2, -1},
74 { 2, -1},{ -2, 1},{ 2, 1},{ -1, 2},{ 1, 2},{ -2, -2},{ 2, -2},{ -2, 2},
75 { 2, 2},{ 0, -3},{ -3, 0},{ 3, 0},{ 0, 3},{ -1, -3},{ 1, -3},{ -3, -1},
76 { 3, -1},{ -3, 1},{ 3, 1},{ -1, 3},{ 1, 3},{ -2, -3},{ 2, -3},{ -3, -2},
77 { 3, -2},{ -3, 2},{ 3, 2},{ -2, 3},{ 2, 3},{ 0, -4},{ -4, 0},{ 4, 0},
78 { 0, 4},{ -1, -4},{ 1, -4},{ -4, -1},{ 4, -1},{ 4, 1},{ -1, 4},{ 1, 4},
79 { -3, -3},{ -3, 3},{ 3, 3},{ -2, -4},{ -4, -2},{ 4, -2},{ -4, 2},{ -2, 4},
80 { 2, 4},{ -3, -4},{ 3, -4},{ 4, -3},{ -5, 0},{ -4, 3},{ -3, 4},{ 3, 4},
81 { -1, -5},{ -5, -1},{ -5, 1},{ -1, 5},{ -2, -5},{ 2, -5},{ 5, -2},{ 5, 2},
82 { -4, -4},{ -4, 4},{ -3, -5},{ -5, -3},{ -5, 3},{ 3, 5},{ -6, 0},{ 0, 6},
83 { -6, -1},{ -6, 1},{ 1, 6},{ 2, -6},{ -6, 2},{ 2, 6},{ -5, -4},{ 5, 4},
84 { 4, 5},{ -6, -3},{ 6, 3},{ -7, 0},{ -1, -7},{ 5, -5},{ -7, 1},{ -1, 7},
85 { 4, -6},{ 6, 4},{ -2, -7},{ -7, 2},{ -3, -7},{ 7, -3},{ 3, 7},{ 6, -5},
86 { 0, -8},{ -1, -8},{ -7, -4},{ -8, 1},{ 4, 7},{ 2, -8},{ -2, 8},{ 6, 6},
87 { -8, 3},{ 5, -7},{ -5, 7},{ 8, -4},{ 0, -9},{ -9, -1},{ 1, 9},{ 7, -6},
88 { -7, 6},{ -5, -8},{ -5, 8},{ -9, 3},{ 9, -4},{ 7, -7},{ 8, -6},{ 6, 8},
89 { 10, 1},{-10, 2},{ 9, -5},{ 10, -3},{ -8, -7},{-10, -4},{ 6, -9},{-11, 0},
90 { 11, 1},{-11, -2},{ -2, 11},{ 7, -9},{ -7, 9},{ 10, 6},{ -4, 11},{ 8, -9},
91 { 8, 9},{ 5, 11},{ 7,-10},{ 12, -3},{ 11, 6},{ -9, -9},{ 8, 10},{ 5, 12},
92 {-11, 7},{ 13, 2},{ 6,-12},{ 10, 9},{-11, 8},{ -7, 12},{ 0, 14},{ 14, -2},
93 { -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{ 5, 14},{-15, -1},{-14, -6},{ 3,-15},
94 { 11,-11},{ -7, 14},{ -5, 15},{ 8,-14},{ 15, 6},{ 3, 16},{ 7,-15},{-16, 5},
95 { 0, 17},{-16, -6},{-10, 14},{-16, 7},{ 12, 13},{-16, 8},{-17, 6},{-18, 3},
96 { -7, 17},{ 15, 11},{ 16, 10},{ 2,-19},{ 3,-19},{-11,-16},{-18, 8},{-19, -6},
97 { 2,-20},{-17,-11},{-10,-18},{ 8, 19},{-21, -1},{-20, 7},{ -4, 21},{ 21, 5},
98 { 15, 16},{ 2,-22},{-10,-20},{-22, 5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
99 { 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
100 { 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27, 6},{ 1,-28},
101 {-11, 26},{-17,-23},{ 7, 28},{ 11,-27},{ 29, 5},{-23,-19},{-28,-11},{-21, 22},
102 {-30, 7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
103 {-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
104 };
105
106 // this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
107 static const uint8_t dequant_table[64]={
108 16, 15, 13, 19, 24, 31, 28, 17,
109 17, 23, 25, 31, 36, 63, 45, 21,
110 18, 24, 27, 37, 52, 59, 49, 20,
111 16, 28, 34, 40, 60, 80, 51, 20,
112 18, 31, 48, 66, 68, 86, 56, 21,
113 19, 38, 56, 59, 64, 64, 48, 20,
114 27, 48, 55, 55, 56, 51, 35, 15,
115 20, 35, 34, 32, 31, 22, 15, 8,
116 };
117
118 static VLC block_type_vlc[2][4];
119
120
121 typedef struct CFrameBuffer{
122 unsigned int allocated_size;
123 unsigned int size;
124 int id;
125 uint8_t *data;
126 }CFrameBuffer;
127
128 typedef struct FourXContext{
129 AVCodecContext *avctx;
130 DSPContext dsp;
131 AVFrame current_picture, last_picture;
132 GetBitContext pre_gb; ///< ac/dc prefix
133 GetBitContext gb;
134 const uint8_t *bytestream;
135 const uint16_t *wordstream;
136 int mv[256];
137 VLC pre_vlc;
138 int last_dc;
139 DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
140 uint8_t *bitstream_buffer;
141 unsigned int bitstream_buffer_size;
142 int version;
143 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
144 } FourXContext;
145
146
147 #define FIX_1_082392200 70936
148 #define FIX_1_414213562 92682
149 #define FIX_1_847759065 121095
150 #define FIX_2_613125930 171254
151
152 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
153
154 static void idct(DCTELEM block[64]){
155 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
156 int tmp10, tmp11, tmp12, tmp13;
157 int z5, z10, z11, z12, z13;
158 int i;
159 int temp[64];
160
161 for(i=0; i<8; i++){
162 tmp10 = block[8*0 + i] + block[8*4 + i];
163 tmp11 = block[8*0 + i] - block[8*4 + i];
164
165 tmp13 = block[8*2 + i] + block[8*6 + i];
166 tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
167
168 tmp0 = tmp10 + tmp13;
169 tmp3 = tmp10 - tmp13;
170 tmp1 = tmp11 + tmp12;
171 tmp2 = tmp11 - tmp12;
172
173 z13 = block[8*5 + i] + block[8*3 + i];
174 z10 = block[8*5 + i] - block[8*3 + i];
175 z11 = block[8*1 + i] + block[8*7 + i];
176 z12 = block[8*1 + i] - block[8*7 + i];
177
178 tmp7 = z11 + z13;
179 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
180
181 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
182 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
183 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
184
185 tmp6 = tmp12 - tmp7;
186 tmp5 = tmp11 - tmp6;
187 tmp4 = tmp10 + tmp5;
188
189 temp[8*0 + i] = tmp0 + tmp7;
190 temp[8*7 + i] = tmp0 - tmp7;
191 temp[8*1 + i] = tmp1 + tmp6;
192 temp[8*6 + i] = tmp1 - tmp6;
193 temp[8*2 + i] = tmp2 + tmp5;
194 temp[8*5 + i] = tmp2 - tmp5;
195 temp[8*4 + i] = tmp3 + tmp4;
196 temp[8*3 + i] = tmp3 - tmp4;
197 }
198
199 for(i=0; i<8*8; i+=8){
200 tmp10 = temp[0 + i] + temp[4 + i];
201 tmp11 = temp[0 + i] - temp[4 + i];
202
203 tmp13 = temp[2 + i] + temp[6 + i];
204 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
205
206 tmp0 = tmp10 + tmp13;
207 tmp3 = tmp10 - tmp13;
208 tmp1 = tmp11 + tmp12;
209 tmp2 = tmp11 - tmp12;
210
211 z13 = temp[5 + i] + temp[3 + i];
212 z10 = temp[5 + i] - temp[3 + i];
213 z11 = temp[1 + i] + temp[7 + i];
214 z12 = temp[1 + i] - temp[7 + i];
215
216 tmp7 = z11 + z13;
217 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
218
219 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
220 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
221 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
222
223 tmp6 = tmp12 - tmp7;
224 tmp5 = tmp11 - tmp6;
225 tmp4 = tmp10 + tmp5;
226
227 block[0 + i] = (tmp0 + tmp7)>>6;
228 block[7 + i] = (tmp0 - tmp7)>>6;
229 block[1 + i] = (tmp1 + tmp6)>>6;
230 block[6 + i] = (tmp1 - tmp6)>>6;
231 block[2 + i] = (tmp2 + tmp5)>>6;
232 block[5 + i] = (tmp2 - tmp5)>>6;
233 block[4 + i] = (tmp3 + tmp4)>>6;
234 block[3 + i] = (tmp3 - tmp4)>>6;
235 }
236 }
237
238 static av_cold void init_vlcs(FourXContext *f){
239 int i;
240
241 for(i=0; i<8; i++){
242 init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
243 &block_type_tab[0][i][0][1], 2, 1,
244 &block_type_tab[0][i][0][0], 2, 1, 1);
245 }
246 }
247
248 static void init_mv(FourXContext *f){
249 int i;
250
251 for(i=0; i<256; i++){
252 if(f->version>1)
253 f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
254 else
255 f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
256 }
257 }
258
259 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
260 int i;
261 dc*= 0x10001;
262
263 switch(log2w){
264 case 0:
265 for(i=0; i<h; i++){
266 dst[0] = scale*src[0] + dc;
267 if(scale) src += stride;
268 dst += stride;
269 }
270 break;
271 case 1:
272 for(i=0; i<h; i++){
273 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
274 if(scale) src += stride;
275 dst += stride;
276 }
277 break;
278 case 2:
279 for(i=0; i<h; i++){
280 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
281 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
282 if(scale) src += stride;
283 dst += stride;
284 }
285 break;
286 case 3:
287 for(i=0; i<h; i++){
288 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
289 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
290 ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
291 ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
292 if(scale) src += stride;
293 dst += stride;
294 }
295 break;
296 default: assert(0);
297 }
298 }
299
300 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
301 const int index= size2index[log2h][log2w];
302 const int h= 1<<log2h;
303 int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
304 uint16_t *start= (uint16_t*)f->last_picture.data[0];
305 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
306
307 assert(code>=0 && code<=6);
308
309 if(code == 0){
310 src += f->mv[ *f->bytestream++ ];
311 if(start > src || src > end){
312 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
313 return;
314 }
315 mcdc(dst, src, log2w, h, stride, 1, 0);
316 }else if(code == 1){
317 log2h--;
318 decode_p_block(f, dst , src , log2w, log2h, stride);
319 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
320 }else if(code == 2){
321 log2w--;
322 decode_p_block(f, dst , src , log2w, log2h, stride);
323 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
324 }else if(code == 3 && f->version<2){
325 mcdc(dst, src, log2w, h, stride, 1, 0);
326 }else if(code == 4){
327 src += f->mv[ *f->bytestream++ ];
328 if(start > src || src > end){
329 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
330 return;
331 }
332 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
333 }else if(code == 5){
334 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
335 }else if(code == 6){
336 if(log2w){
337 dst[0] = le2me_16(*f->wordstream++);
338 dst[1] = le2me_16(*f->wordstream++);
339 }else{
340 dst[0 ] = le2me_16(*f->wordstream++);
341 dst[stride] = le2me_16(*f->wordstream++);
342 }
343 }
344 }
345
346 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
347 int x, y;
348 const int width= f->avctx->width;
349 const int height= f->avctx->height;
350 uint16_t *src= (uint16_t*)f->last_picture.data[0];
351 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
352 const int stride= f->current_picture.linesize[0]>>1;
353 unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
354
355 if(f->version>1){
356 extra=20;
357 bitstream_size= AV_RL32(buf+8);
358 wordstream_size= AV_RL32(buf+12);
359 bytestream_size= AV_RL32(buf+16);
360 }else{
361 extra=0;
362 bitstream_size = AV_RL16(buf-4);
363 wordstream_size= AV_RL16(buf-2);
364 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
365 }
366
367 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
368 || bitstream_size > (1<<26)
369 || bytestream_size > (1<<26)
370 || wordstream_size > (1<<26)
371 ){
372 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
373 bitstream_size+ bytestream_size+ wordstream_size - length);
374 return -1;
375 }
376
377 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
378 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
379 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
380
381 f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
382 f->bytestream= buf + extra + bitstream_size + wordstream_size;
383
384 init_mv(f);
385
386 for(y=0; y<height; y+=8){
387 for(x=0; x<width; x+=8){
388 decode_p_block(f, dst + x, src + x, 3, 3, stride);
389 }
390 src += 8*stride;
391 dst += 8*stride;
392 }
393
394 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
395 || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
396 || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
397 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
398 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
399 -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
400 -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
401 );
402
403 return 0;
404 }
405
406 /**
407 * decode block and dequantize.
408 * Note this is almost identical to MJPEG.
409 */
410 static int decode_i_block(FourXContext *f, DCTELEM *block){
411 int code, i, j, level, val;
412
413 /* DC coef */
414 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
415 if (val>>4){
416 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
417 }
418
419 if(val)
420 val = get_xbits(&f->gb, val);
421
422 val = val * dequant_table[0] + f->last_dc;
423 f->last_dc =
424 block[0] = val;
425 /* AC coefs */
426 i = 1;
427 for(;;) {
428 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
429
430 /* EOB */
431 if (code == 0)
432 break;
433 if (code == 0xf0) {
434 i += 16;
435 } else {
436 level = get_xbits(&f->gb, code & 0xf);
437 i += code >> 4;
438 if (i >= 64) {
439 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
440 return 0;
441 }
442
443 j= ff_zigzag_direct[i];
444 block[j] = level * dequant_table[j];
445 i++;
446 if (i >= 64)
447 break;
448 }
449 }
450
451 return 0;
452 }
453
454 static inline void idct_put(FourXContext *f, int x, int y){
455 DCTELEM (*block)[64]= f->block;
456 int stride= f->current_picture.linesize[0]>>1;
457 int i;
458 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
459
460 for(i=0; i<4; i++){
461 block[i][0] += 0x80*8*8;
462 idct(block[i]);
463 }
464
465 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
466 for(i=4; i<6; i++) idct(block[i]);
467 }
468
469 /* Note transform is:
470 y= ( 1b + 4g + 2r)/14
471 cb=( 3b - 2g - 1r)/14
472 cr=(-1b - 4g + 5r)/14
473 */
474 for(y=0; y<8; y++){
475 for(x=0; x<8; x++){
476 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
477 int cb= block[4][x + 8*y];
478 int cr= block[5][x + 8*y];
479 int cg= (cb + cr)>>1;
480 int y;
481
482 cb+=cb;
483
484 y = temp[0];
485 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
486 y = temp[1];
487 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
488 y = temp[8];
489 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
490 y = temp[9];
491 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
492 dst += 2;
493 }
494 dst += 2*stride - 2*8;
495 }
496 }
497
498 static int decode_i_mb(FourXContext *f){
499 int i;
500
501 f->dsp.clear_blocks(f->block[0]);
502
503 for(i=0; i<6; i++){
504 if(decode_i_block(f, f->block[i]) < 0)
505 return -1;
506 }
507
508 return 0;
509 }
510
511 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
512 int frequency[512];
513 uint8_t flag[512];
514 int up[512];
515 uint8_t len_tab[257];
516 int bits_tab[257];
517 int start, end;
518 const uint8_t *ptr= buf;
519 int j;
520
521 memset(frequency, 0, sizeof(frequency));
522 memset(up, -1, sizeof(up));
523
524 start= *ptr++;
525 end= *ptr++;
526 for(;;){
527 int i;
528
529 for(i=start; i<=end; i++){
530 frequency[i]= *ptr++;
531 }
532 start= *ptr++;
533 if(start==0) break;
534
535 end= *ptr++;
536 }
537 frequency[256]=1;
538
539 while((ptr - buf)&3) ptr++; // 4byte align
540
541 for(j=257; j<512; j++){
542 int min_freq[2]= {256*256, 256*256};
543 int smallest[2]= {0, 0};
544 int i;
545 for(i=0; i<j; i++){
546 if(frequency[i] == 0) continue;
547 if(frequency[i] < min_freq[1]){
548 if(frequency[i] < min_freq[0]){
549 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
550 min_freq[0]= frequency[i];smallest[0]= i;
551 }else{
552 min_freq[1]= frequency[i];smallest[1]= i;
553 }
554 }
555 }
556 if(min_freq[1] == 256*256) break;
557
558 frequency[j]= min_freq[0] + min_freq[1];
559 flag[ smallest[0] ]= 0;
560 flag[ smallest[1] ]= 1;
561 up[ smallest[0] ]=
562 up[ smallest[1] ]= j;
563 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
564 }
565
566 for(j=0; j<257; j++){
567 int node;
568 int len=0;
569 int bits=0;
570
571 for(node= j; up[node] != -1; node= up[node]){
572 bits += flag[node]<<len;
573 len++;
574 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
575 }
576
577 bits_tab[j]= bits;
578 len_tab[j]= len;
579 }
580
581 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
582 len_tab , 1, 1,
583 bits_tab, 4, 4, 0);
584
585 return ptr;
586 }
587
588 static int mix(int c0, int c1){
589 int blue = 2*(c0&0x001F) + (c1&0x001F);
590 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
591 int red = 2*(c0>>10) + (c1>>10);
592 return red/3*1024 + green/3*32 + blue/3;
593 }
594
595 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
596 int x, y, x2, y2;
597 const int width= f->avctx->width;
598 const int height= f->avctx->height;
599 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
600 const int stride= f->current_picture.linesize[0]>>1;
601
602 for(y=0; y<height; y+=16){
603 for(x=0; x<width; x+=16){
604 unsigned int color[4], bits;
605 memset(color, 0, sizeof(color));
606 //warning following is purely guessed ...
607 color[0]= bytestream_get_le16(&buf);
608 color[1]= bytestream_get_le16(&buf);
609
610 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
611 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
612
613 color[2]= mix(color[0], color[1]);
614 color[3]= mix(color[1], color[0]);
615
616 bits= bytestream_get_le32(&buf);
617 for(y2=0; y2<16; y2++){
618 for(x2=0; x2<16; x2++){
619 int index= 2*(x2>>2) + 8*(y2>>2);
620 dst[y2*stride+x2]= color[(bits>>index)&3];
621 }
622 }
623 dst+=16;
624 }
625 dst += 16*stride - width;
626 }
627
628 return 0;
629 }
630
631 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
632 int x, y;
633 const int width= f->avctx->width;
634 const int height= f->avctx->height;
635 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
636 const int stride= f->current_picture.linesize[0]>>1;
637 const unsigned int bitstream_size= AV_RL32(buf);
638 const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
639 unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
640 const uint8_t *prestream= buf + bitstream_size + 12;
641
642 if(prestream_size + bitstream_size + 12 != length
643 || bitstream_size > (1<<26)
644 || prestream_size > (1<<26)){
645 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
646 return -1;
647 }
648
649 prestream= read_huffman_tables(f, prestream);
650
651 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
652
653 prestream_size= length + buf - prestream;
654
655 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
656 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
657 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
658
659 f->last_dc= 0*128*8*8;
660
661 for(y=0; y<height; y+=16){
662 for(x=0; x<width; x+=16){
663 if(decode_i_mb(f) < 0)
664 return -1;
665
666 idct_put(f, x, y);
667 }
668 dst += 16*stride;
669 }
670
671 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
672 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
673
674 return 0;
675 }
676
677 static int decode_frame(AVCodecContext *avctx,
678 void *data, int *data_size,
679 const uint8_t *buf, int buf_size)
680 {
681 FourXContext * const f = avctx->priv_data;
682 AVFrame *picture = data;
683 AVFrame *p, temp;
684 int i, frame_4cc, frame_size;
685
686 frame_4cc= AV_RL32(buf);
687 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
688 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
689 }
690
691 if(frame_4cc == ff_get_fourcc("cfrm")){
692 int free_index=-1;
693 const int data_size= buf_size - 20;
694 const int id= AV_RL32(buf+12);
695 const int whole_size= AV_RL32(buf+16);
696 CFrameBuffer *cfrm;
697
698 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
699 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
700 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
701 }
702
703 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
704 if(f->cfrm[i].id == id) break;
705 if(f->cfrm[i].size == 0 ) free_index= i;
706 }
707
708 if(i>=CFRAME_BUFFER_COUNT){
709 i= free_index;
710 f->cfrm[i].id= id;
711 }
712 cfrm= &f->cfrm[i];
713
714 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
715 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
716 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
717 return -1;
718 }
719
720 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
721 cfrm->size += data_size;
722
723 if(cfrm->size >= whole_size){
724 buf= cfrm->data;
725 frame_size= cfrm->size;
726
727 if(id != avctx->frame_number){
728 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
729 }
730
731 cfrm->size= cfrm->id= 0;
732 frame_4cc= ff_get_fourcc("pfrm");
733 }else
734 return buf_size;
735 }else{
736 buf= buf + 12;
737 frame_size= buf_size - 12;
738 }
739
740 temp= f->current_picture;
741 f->current_picture= f->last_picture;
742 f->last_picture= temp;
743
744 p= &f->current_picture;
745 avctx->coded_frame= p;
746
747 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
748
749 if(p->data[0])
750 avctx->release_buffer(avctx, p);
751
752 p->reference= 1;
753 if(avctx->get_buffer(avctx, p) < 0){
754 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
755 return -1;
756 }
757
758 if(frame_4cc == ff_get_fourcc("ifr2")){
759 p->pict_type= FF_I_TYPE;
760 if(decode_i2_frame(f, buf-4, frame_size) < 0)
761 return -1;
762 }else if(frame_4cc == ff_get_fourcc("ifrm")){
763 p->pict_type= FF_I_TYPE;
764 if(decode_i_frame(f, buf, frame_size) < 0)
765 return -1;
766 }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
767 p->pict_type= FF_P_TYPE;
768 if(decode_p_frame(f, buf, frame_size) < 0)
769 return -1;
770 }else if(frame_4cc == ff_get_fourcc("snd_")){
771 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
772 }else{
773 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
774 }
775
776 p->key_frame= p->pict_type == FF_I_TYPE;
777
778 *picture= *p;
779 *data_size = sizeof(AVPicture);
780
781 emms_c();
782
783 return buf_size;
784 }
785
786
787 static void common_init(AVCodecContext *avctx){
788 FourXContext * const f = avctx->priv_data;
789
790 dsputil_init(&f->dsp, avctx);
791
792 f->avctx= avctx;
793 }
794
795 static av_cold int decode_init(AVCodecContext *avctx){
796 FourXContext * const f = avctx->priv_data;
797
798 if(avctx->extradata_size != 4 || !avctx->extradata) {
799 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
800 return 1;
801 }
802
803 f->version= AV_RL32(avctx->extradata)>>16;
804 common_init(avctx);
805 init_vlcs(f);
806
807 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
808 else avctx->pix_fmt= PIX_FMT_RGB555;
809
810 return 0;
811 }
812
813
814 static av_cold int decode_end(AVCodecContext *avctx){
815 FourXContext * const f = avctx->priv_data;
816 int i;
817
818 av_freep(&f->bitstream_buffer);
819 f->bitstream_buffer_size=0;
820 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
821 av_freep(&f->cfrm[i].data);
822 f->cfrm[i].allocated_size= 0;
823 }
824 free_vlc(&f->pre_vlc);
825
826 return 0;
827 }
828
829 AVCodec fourxm_decoder = {
830 "4xm",
831 CODEC_TYPE_VIDEO,
832 CODEC_ID_4XM,
833 sizeof(FourXContext),
834 decode_init,
835 NULL,
836 decode_end,
837 decode_frame,
838 /*CODEC_CAP_DR1,*/
839 };
840