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