Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 4xm.c @ 9ac34d94

History | View | Annotate | Download (25.4 KB)

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 "mpegvideo.h"
30

    
31
//#undef NDEBUG
32
//#include <assert.h>
33

    
34
#define BLOCK_TYPE_VLC_BITS 5
35
#define ACDC_VLC_BITS 9
36

    
37
#define CFRAME_BUFFER_COUNT 100
38

    
39
static const uint8_t block_type_tab[2][4][8][2]={
40
 {
41
  {   //{8,4,2}x{8,4,2}
42
    { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
43
  },{ //{8,4}x1
44
    { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
45
  },{ //1x{8,4}
46
    { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
47
  },{ //1x2, 2x1
48
    { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
49
  }
50
 },{
51
  {  //{8,4,2}x{8,4,2}
52
    { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
53
  },{//{8,4}x1
54
    { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
55
  },{//1x{8,4}
56
    { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
57
  },{//1x2, 2x1
58
    { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
59
  }
60
 }
61
};
62

    
63
static const uint8_t size2index[4][4]={
64
  {-1, 3, 1, 1},
65
  { 3, 0, 0, 0},
66
  { 2, 0, 0, 0},
67
  { 2, 0, 0, 0},
68
};
69

    
70
static const int8_t mv[256][2]={
71
{  0,  0},{  0, -1},{ -1,  0},{  1,  0},{  0,  1},{ -1, -1},{  1, -1},{ -1,  1},
72
{  1,  1},{  0, -2},{ -2,  0},{  2,  0},{  0,  2},{ -1, -2},{  1, -2},{ -2, -1},
73
{  2, -1},{ -2,  1},{  2,  1},{ -1,  2},{  1,  2},{ -2, -2},{  2, -2},{ -2,  2},
74
{  2,  2},{  0, -3},{ -3,  0},{  3,  0},{  0,  3},{ -1, -3},{  1, -3},{ -3, -1},
75
{  3, -1},{ -3,  1},{  3,  1},{ -1,  3},{  1,  3},{ -2, -3},{  2, -3},{ -3, -2},
76
{  3, -2},{ -3,  2},{  3,  2},{ -2,  3},{  2,  3},{  0, -4},{ -4,  0},{  4,  0},
77
{  0,  4},{ -1, -4},{  1, -4},{ -4, -1},{  4, -1},{  4,  1},{ -1,  4},{  1,  4},
78
{ -3, -3},{ -3,  3},{  3,  3},{ -2, -4},{ -4, -2},{  4, -2},{ -4,  2},{ -2,  4},
79
{  2,  4},{ -3, -4},{  3, -4},{  4, -3},{ -5,  0},{ -4,  3},{ -3,  4},{  3,  4},
80
{ -1, -5},{ -5, -1},{ -5,  1},{ -1,  5},{ -2, -5},{  2, -5},{  5, -2},{  5,  2},
81
{ -4, -4},{ -4,  4},{ -3, -5},{ -5, -3},{ -5,  3},{  3,  5},{ -6,  0},{  0,  6},
82
{ -6, -1},{ -6,  1},{  1,  6},{  2, -6},{ -6,  2},{  2,  6},{ -5, -4},{  5,  4},
83
{  4,  5},{ -6, -3},{  6,  3},{ -7,  0},{ -1, -7},{  5, -5},{ -7,  1},{ -1,  7},
84
{  4, -6},{  6,  4},{ -2, -7},{ -7,  2},{ -3, -7},{  7, -3},{  3,  7},{  6, -5},
85
{  0, -8},{ -1, -8},{ -7, -4},{ -8,  1},{  4,  7},{  2, -8},{ -2,  8},{  6,  6},
86
{ -8,  3},{  5, -7},{ -5,  7},{  8, -4},{  0, -9},{ -9, -1},{  1,  9},{  7, -6},
87
{ -7,  6},{ -5, -8},{ -5,  8},{ -9,  3},{  9, -4},{  7, -7},{  8, -6},{  6,  8},
88
{ 10,  1},{-10,  2},{  9, -5},{ 10, -3},{ -8, -7},{-10, -4},{  6, -9},{-11,  0},
89
{ 11,  1},{-11, -2},{ -2, 11},{  7, -9},{ -7,  9},{ 10,  6},{ -4, 11},{  8, -9},
90
{  8,  9},{  5, 11},{  7,-10},{ 12, -3},{ 11,  6},{ -9, -9},{  8, 10},{  5, 12},
91
{-11,  7},{ 13,  2},{  6,-12},{ 10,  9},{-11,  8},{ -7, 12},{  0, 14},{ 14, -2},
92
{ -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{  5, 14},{-15, -1},{-14, -6},{  3,-15},
93
{ 11,-11},{ -7, 14},{ -5, 15},{  8,-14},{ 15,  6},{  3, 16},{  7,-15},{-16,  5},
94
{  0, 17},{-16, -6},{-10, 14},{-16,  7},{ 12, 13},{-16,  8},{-17,  6},{-18,  3},
95
{ -7, 17},{ 15, 11},{ 16, 10},{  2,-19},{  3,-19},{-11,-16},{-18,  8},{-19, -6},
96
{  2,-20},{-17,-11},{-10,-18},{  8, 19},{-21, -1},{-20,  7},{ -4, 21},{ 21,  5},
97
{ 15, 16},{  2,-22},{-10,-20},{-22,  5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
98
{ 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
99
{ 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27,  6},{  1,-28},
100
{-11, 26},{-17,-23},{  7, 28},{ 11,-27},{ 29,  5},{-23,-19},{-28,-11},{-21, 22},
101
{-30,  7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
102
{-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
103
};
104

    
105
// this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
106
static const uint8_t dequant_table[64]={
107
 16, 15, 13, 19, 24, 31, 28, 17,
108
 17, 23, 25, 31, 36, 63, 45, 21,
109
 18, 24, 27, 37, 52, 59, 49, 20,
110
 16, 28, 34, 40, 60, 80, 51, 20,
111
 18, 31, 48, 66, 68, 86, 56, 21,
112
 19, 38, 56, 59, 64, 64, 48, 20,
113
 27, 48, 55, 55, 56, 51, 35, 15,
114
 20, 35, 34, 32, 31, 22, 15,  8,
115
};
116

    
117
static VLC block_type_vlc[2][4];
118

    
119

    
120
typedef struct CFrameBuffer{
121
    unsigned int allocated_size;
122
    unsigned int size;
123
    int id;
124
    uint8_t *data;
125
}CFrameBuffer;
126

    
127
typedef struct FourXContext{
128
    AVCodecContext *avctx;
129
    DSPContext dsp;
130
    AVFrame current_picture, last_picture;
131
    GetBitContext pre_gb;          ///< ac/dc prefix
132
    GetBitContext gb;
133
    uint8_t *bytestream;
134
    uint16_t *wordstream;
135
    int mv[256];
136
    VLC pre_vlc;
137
    int last_dc;
138
    DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
139
    uint8_t *bitstream_buffer;
140
    unsigned int bitstream_buffer_size;
141
    int version;
142
    CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
143
} FourXContext;
144

    
145

    
146
#define FIX_1_082392200  70936
147
#define FIX_1_414213562  92682
148
#define FIX_1_847759065 121095
149
#define FIX_2_613125930 171254
150

    
151
#define MULTIPLY(var,const)  (((var)*(const)) >> 16)
152

    
153
static void idct(DCTELEM block[64]){
154
    int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
155
    int tmp10, tmp11, tmp12, tmp13;
156
    int z5, z10, z11, z12, z13;
157
    int i;
158
    int temp[64];
159

    
160
    for(i=0; i<8; i++){
161
        tmp10 = block[8*0 + i] + block[8*4 + i];
162
        tmp11 = block[8*0 + i] - block[8*4 + i];
163

    
164
        tmp13 =          block[8*2 + i] + block[8*6 + i];
165
        tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
166

    
167
        tmp0 = tmp10 + tmp13;
168
        tmp3 = tmp10 - tmp13;
169
        tmp1 = tmp11 + tmp12;
170
        tmp2 = tmp11 - tmp12;
171

    
172
        z13 = block[8*5 + i] + block[8*3 + i];
173
        z10 = block[8*5 + i] - block[8*3 + i];
174
        z11 = block[8*1 + i] + block[8*7 + i];
175
        z12 = block[8*1 + i] - block[8*7 + i];
176

    
177
        tmp7  =          z11 + z13;
178
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
179

    
180
        z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
181
        tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
182
        tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
183

    
184
        tmp6 = tmp12 - tmp7;
185
        tmp5 = tmp11 - tmp6;
186
        tmp4 = tmp10 + tmp5;
187

    
188
        temp[8*0 + i] = tmp0 + tmp7;
189
        temp[8*7 + i] = tmp0 - tmp7;
190
        temp[8*1 + i] = tmp1 + tmp6;
191
        temp[8*6 + i] = tmp1 - tmp6;
192
        temp[8*2 + i] = tmp2 + tmp5;
193
        temp[8*5 + i] = tmp2 - tmp5;
194
        temp[8*4 + i] = tmp3 + tmp4;
195
        temp[8*3 + i] = tmp3 - tmp4;
196
    }
197

    
198
    for(i=0; i<8*8; i+=8){
199
        tmp10 = temp[0 + i] + temp[4 + i];
200
        tmp11 = temp[0 + i] - temp[4 + i];
201

    
202
        tmp13 = temp[2 + i] + temp[6 + i];
203
        tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
204

    
205
        tmp0 = tmp10 + tmp13;
206
        tmp3 = tmp10 - tmp13;
207
        tmp1 = tmp11 + tmp12;
208
        tmp2 = tmp11 - tmp12;
209

    
210
        z13 = temp[5 + i] + temp[3 + i];
211
        z10 = temp[5 + i] - temp[3 + i];
212
        z11 = temp[1 + i] + temp[7 + i];
213
        z12 = temp[1 + i] - temp[7 + i];
214

    
215
        tmp7 = z11 + z13;
216
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
217

    
218
        z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
219
        tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
220
        tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
221

    
222
        tmp6 = tmp12 - tmp7;
223
        tmp5 = tmp11 - tmp6;
224
        tmp4 = tmp10 + tmp5;
225

    
226
        block[0 + i] = (tmp0 + tmp7)>>6;
227
        block[7 + i] = (tmp0 - tmp7)>>6;
228
        block[1 + i] = (tmp1 + tmp6)>>6;
229
        block[6 + i] = (tmp1 - tmp6)>>6;
230
        block[2 + i] = (tmp2 + tmp5)>>6;
231
        block[5 + i] = (tmp2 - tmp5)>>6;
232
        block[4 + i] = (tmp3 + tmp4)>>6;
233
        block[3 + i] = (tmp3 - tmp4)>>6;
234
    }
235
}
236

    
237
static void init_vlcs(FourXContext *f){
238
    int i;
239

    
240
    for(i=0; i<8; i++){
241
        init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
242
                 &block_type_tab[0][i][0][1], 2, 1,
243
                 &block_type_tab[0][i][0][0], 2, 1, 1);
244
    }
245
}
246

    
247
static void init_mv(FourXContext *f){
248
    int i;
249

    
250
    for(i=0; i<256; i++){
251
        if(f->version)
252
            f->mv[i] = mv[i][0]   + mv[i][1]  *f->current_picture.linesize[0]/2;
253
        else
254
            f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
255
    }
256
}
257

    
258
static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
259
   int i;
260
   dc*= 0x10001;
261

    
262
   switch(log2w){
263
   case 0:
264
        for(i=0; i<h; i++){
265
            dst[0] = scale*src[0] + dc;
266
            if(scale) src += stride;
267
            dst += stride;
268
        }
269
        break;
270
    case 1:
271
        for(i=0; i<h; i++){
272
            ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
273
            if(scale) src += stride;
274
            dst += stride;
275
        }
276
        break;
277
    case 2:
278
        for(i=0; i<h; i++){
279
            ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
280
            ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
281
            if(scale) src += stride;
282
            dst += stride;
283
        }
284
        break;
285
    case 3:
286
        for(i=0; i<h; i++){
287
            ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
288
            ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
289
            ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
290
            ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
291
            if(scale) src += stride;
292
            dst += stride;
293
        }
294
        break;
295
    default: assert(0);
296
    }
297
}
298

    
299
static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
300
    const int index= size2index[log2h][log2w];
301
    const int h= 1<<log2h;
302
    int code= get_vlc2(&f->gb, block_type_vlc[1-f->version][index].table, BLOCK_TYPE_VLC_BITS, 1);
303

    
304
    assert(code>=0 && code<=6);
305

    
306
    if(code == 0){
307
        src += f->mv[ *f->bytestream++ ];
308
        mcdc(dst, src, log2w, h, stride, 1, 0);
309
    }else if(code == 1){
310
        log2h--;
311
        decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
312
        decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
313
    }else if(code == 2){
314
        log2w--;
315
        decode_p_block(f, dst             , src             , log2w, log2h, stride);
316
        decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
317
    }else if(code == 4){
318
        src += f->mv[ *f->bytestream++ ];
319
        mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
320
    }else if(code == 5){
321
        mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
322
    }else if(code == 6){
323
        if(log2w){
324
            dst[0] = le2me_16(*f->wordstream++);
325
            dst[1] = le2me_16(*f->wordstream++);
326
        }else{
327
            dst[0     ] = le2me_16(*f->wordstream++);
328
            dst[stride] = le2me_16(*f->wordstream++);
329
        }
330
    }
331
}
332

    
333
static int get32(void *p){
334
    return le2me_32(*(uint32_t*)p);
335
}
336

    
337
static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
338
    int x, y;
339
    const int width= f->avctx->width;
340
    const int height= f->avctx->height;
341
    uint16_t *src= (uint16_t*)f->last_picture.data[0];
342
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
343
    const int stride= f->current_picture.linesize[0]>>1;
344
    unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
345

    
346
    if(f->version){
347
        extra=20;
348
        bitstream_size= get32(buf+8);
349
        wordstream_size= get32(buf+12);
350
        bytestream_size= get32(buf+16);
351
    }else{
352
        extra=0;
353
        bitstream_size = AV_RL16(buf-4);
354
        wordstream_size= AV_RL16(buf-2);
355
        bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
356
    }
357

    
358
    if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
359
       || bitstream_size  > (1<<26)
360
       || bytestream_size > (1<<26)
361
       || wordstream_size > (1<<26)
362
       ){
363
        av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
364
        bitstream_size+ bytestream_size+ wordstream_size - length);
365
        return -1;
366
    }
367

    
368
    f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
369
    f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + extra), bitstream_size/4);
370
    init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
371

    
372
    f->wordstream= (uint16_t*)(buf + extra + bitstream_size);
373
    f->bytestream= buf + extra + bitstream_size + wordstream_size;
374

    
375
    init_mv(f);
376

    
377
    for(y=0; y<height; y+=8){
378
        for(x=0; x<width; x+=8){
379
            decode_p_block(f, dst + x, src + x, 3, 3, stride);
380
        }
381
        src += 8*stride;
382
        dst += 8*stride;
383
    }
384

    
385
    if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
386
       || (((char*)f->wordstream - (char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
387
       || (((char*)f->bytestream - (char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
388
        av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
389
            bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
390
            -(((char*)f->bytestream - (char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
391
            -(((char*)f->wordstream - (char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
392
        );
393

    
394
    return 0;
395
}
396

    
397
/**
398
 * decode block and dequantize.
399
 * Note this is allmost identical to mjpeg
400
 */
401
static int decode_i_block(FourXContext *f, DCTELEM *block){
402
    int code, i, j, level, val;
403

    
404
    /* DC coef */
405
    val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
406
    if (val>>4){
407
        av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
408
    }
409

    
410
    if(val)
411
        val = get_xbits(&f->gb, val);
412

    
413
    val = val * dequant_table[0] + f->last_dc;
414
    f->last_dc =
415
    block[0] = val;
416
    /* AC coefs */
417
    i = 1;
418
    for(;;) {
419
        code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
420

    
421
        /* EOB */
422
        if (code == 0)
423
            break;
424
        if (code == 0xf0) {
425
            i += 16;
426
        } else {
427
            level = get_xbits(&f->gb, code & 0xf);
428
            i += code >> 4;
429
            if (i >= 64) {
430
                av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
431
                return 0;
432
            }
433

    
434
            j= ff_zigzag_direct[i];
435
            block[j] = level * dequant_table[j];
436
            i++;
437
            if (i >= 64)
438
                break;
439
        }
440
    }
441

    
442
    return 0;
443
}
444

    
445
static inline void idct_put(FourXContext *f, int x, int y){
446
    DCTELEM (*block)[64]= f->block;
447
    int stride= f->current_picture.linesize[0]>>1;
448
    int i;
449
    uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
450

    
451
    for(i=0; i<4; i++){
452
        block[i][0] += 0x80*8*8;
453
        idct(block[i]);
454
    }
455

    
456
    if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
457
        for(i=4; i<6; i++) idct(block[i]);
458
    }
459

    
460
/* Note transform is:
461
y= ( 1b + 4g + 2r)/14
462
cb=( 3b - 2g - 1r)/14
463
cr=(-1b - 4g + 5r)/14
464
*/
465
    for(y=0; y<8; y++){
466
        for(x=0; x<8; x++){
467
            DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
468
            int cb= block[4][x + 8*y];
469
            int cr= block[5][x + 8*y];
470
            int cg= (cb + cr)>>1;
471
            int y;
472

    
473
            cb+=cb;
474

    
475
            y = temp[0];
476
            dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
477
            y = temp[1];
478
            dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
479
            y = temp[8];
480
            dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
481
            y = temp[9];
482
            dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
483
            dst += 2;
484
        }
485
        dst += 2*stride - 2*8;
486
    }
487
}
488

    
489
static int decode_i_mb(FourXContext *f){
490
    int i;
491

    
492
    f->dsp.clear_blocks(f->block[0]);
493

    
494
    for(i=0; i<6; i++){
495
        if(decode_i_block(f, f->block[i]) < 0)
496
            return -1;
497
    }
498

    
499
    return 0;
500
}
501

    
502
static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
503
    int frequency[512];
504
    uint8_t flag[512];
505
    int up[512];
506
    uint8_t len_tab[257];
507
    int bits_tab[257];
508
    int start, end;
509
    uint8_t *ptr= buf;
510
    int j;
511

    
512
    memset(frequency, 0, sizeof(frequency));
513
    memset(up, -1, sizeof(up));
514

    
515
    start= *ptr++;
516
    end= *ptr++;
517
    for(;;){
518
        int i;
519

    
520
        for(i=start; i<=end; i++){
521
            frequency[i]= *ptr++;
522
        }
523
        start= *ptr++;
524
        if(start==0) break;
525

    
526
        end= *ptr++;
527
    }
528
    frequency[256]=1;
529

    
530
    while((ptr - buf)&3) ptr++; // 4byte align
531

    
532
    for(j=257; j<512; j++){
533
        int min_freq[2]= {256*256, 256*256};
534
        int smallest[2]= {0, 0};
535
        int i;
536
        for(i=0; i<j; i++){
537
            if(frequency[i] == 0) continue;
538
            if(frequency[i] < min_freq[1]){
539
                if(frequency[i] < min_freq[0]){
540
                    min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
541
                    min_freq[0]= frequency[i];smallest[0]= i;
542
                }else{
543
                    min_freq[1]= frequency[i];smallest[1]= i;
544
                }
545
            }
546
        }
547
        if(min_freq[1] == 256*256) break;
548

    
549
        frequency[j]= min_freq[0] + min_freq[1];
550
        flag[ smallest[0] ]= 0;
551
        flag[ smallest[1] ]= 1;
552
        up[ smallest[0] ]=
553
        up[ smallest[1] ]= j;
554
        frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
555
    }
556

    
557
    for(j=0; j<257; j++){
558
        int node;
559
        int len=0;
560
        int bits=0;
561

    
562
        for(node= j; up[node] != -1; node= up[node]){
563
            bits += flag[node]<<len;
564
            len++;
565
            if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
566
        }
567

    
568
        bits_tab[j]= bits;
569
        len_tab[j]= len;
570
    }
571

    
572
    init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
573
             len_tab , 1, 1,
574
             bits_tab, 4, 4, 0);
575

    
576
    return ptr;
577
}
578

    
579
static int mix(int c0, int c1){
580
    int blue = 2*(c0&0x001F) + (c1&0x001F);
581
    int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
582
    int red  = 2*(c0>>10) + (c1>>10);
583
    return red/3*1024 + green/3*32 + blue/3;
584
}
585

    
586
static int decode_i2_frame(FourXContext *f, uint8_t *buf, int length){
587
    int x, y, x2, y2;
588
    const int width= f->avctx->width;
589
    const int height= f->avctx->height;
590
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
591
    const int stride= f->current_picture.linesize[0]>>1;
592

    
593
    for(y=0; y<height; y+=16){
594
        for(x=0; x<width; x+=16){
595
            unsigned int color[4], bits;
596
            memset(color, 0, sizeof(color));
597
//warning following is purely guessed ...
598
            color[0]= AV_RN16(buf); buf+=2; //FIXME use bytestream
599
            color[1]= AV_RN16(buf); buf+=2;
600

    
601
            if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
602
            if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
603

    
604
            color[2]= mix(color[0], color[1]);
605
            color[3]= mix(color[1], color[0]);
606

    
607
            bits= AV_RL32(buf); buf+= 4;
608
            for(y2=0; y2<16; y2++){
609
                for(x2=0; x2<16; x2++){
610
                    int index= 2*(x2>>2) + 8*(y2>>2);
611
                    dst[y2*stride+x2]= color[(bits>>index)&3];
612
                }
613
            }
614
            dst+=16;
615
        }
616
        dst += 16*stride - width;
617
    }
618

    
619
    return 0;
620
}
621

    
622
static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
623
    int x, y;
624
    const int width= f->avctx->width;
625
    const int height= f->avctx->height;
626
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
627
    const int stride= f->current_picture.linesize[0]>>1;
628
    const unsigned int bitstream_size= get32(buf);
629
    const int token_count av_unused = get32(buf + bitstream_size + 8);
630
    unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
631
    uint8_t *prestream= buf + bitstream_size + 12;
632

    
633
    if(prestream_size + bitstream_size + 12 != length
634
       || bitstream_size > (1<<26)
635
       || prestream_size > (1<<26)){
636
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
637
        return -1;
638
    }
639

    
640
    prestream= read_huffman_tables(f, prestream);
641

    
642
    init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
643

    
644
    prestream_size= length + buf - prestream;
645

    
646
    f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
647
    f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
648
    init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
649

    
650
    f->last_dc= 0*128*8*8;
651

    
652
    for(y=0; y<height; y+=16){
653
        for(x=0; x<width; x+=16){
654
            if(decode_i_mb(f) < 0)
655
                return -1;
656

    
657
            idct_put(f, x, y);
658
        }
659
        dst += 16*stride;
660
    }
661

    
662
    if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
663
        av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
664

    
665
    return 0;
666
}
667

    
668
static int decode_frame(AVCodecContext *avctx,
669
                        void *data, int *data_size,
670
                        uint8_t *buf, int buf_size)
671
{
672
    FourXContext * const f = avctx->priv_data;
673
    AVFrame *picture = data;
674
    AVFrame *p, temp;
675
    int i, frame_4cc, frame_size;
676

    
677
    frame_4cc= get32(buf);
678
    if(buf_size != get32(buf+4)+8 || buf_size < 20){
679
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
680
    }
681

    
682
    if(frame_4cc == ff_get_fourcc("cfrm")){
683
        int free_index=-1;
684
        const int data_size= buf_size - 20;
685
        const int id= get32(buf+12);
686
        const int whole_size= get32(buf+16);
687
        CFrameBuffer *cfrm;
688

    
689
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
690
            if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
691
                av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
692
        }
693

    
694
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
695
            if(f->cfrm[i].id   == id) break;
696
            if(f->cfrm[i].size == 0 ) free_index= i;
697
        }
698

    
699
        if(i>=CFRAME_BUFFER_COUNT){
700
            i= free_index;
701
            f->cfrm[i].id= id;
702
        }
703
        cfrm= &f->cfrm[i];
704

    
705
        cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
706
        if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
707
            av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
708
            return -1;
709
        }
710

    
711
        memcpy(cfrm->data + cfrm->size, buf+20, data_size);
712
        cfrm->size += data_size;
713

    
714
        if(cfrm->size >= whole_size){
715
            buf= cfrm->data;
716
            frame_size= cfrm->size;
717

    
718
            if(id != avctx->frame_number){
719
                av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
720
            }
721

    
722
            cfrm->size= cfrm->id= 0;
723
            frame_4cc= ff_get_fourcc("pfrm");
724
        }else
725
            return buf_size;
726
    }else{
727
        buf= buf + 12;
728
        frame_size= buf_size - 12;
729
    }
730

    
731
    temp= f->current_picture;
732
    f->current_picture= f->last_picture;
733
    f->last_picture= temp;
734

    
735
    p= &f->current_picture;
736
    avctx->coded_frame= p;
737

    
738
    avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
739

    
740
    if(p->data[0])
741
        avctx->release_buffer(avctx, p);
742

    
743
    p->reference= 1;
744
    if(avctx->get_buffer(avctx, p) < 0){
745
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
746
        return -1;
747
    }
748

    
749
    if(frame_4cc == ff_get_fourcc("ifr2")){
750
        p->pict_type= I_TYPE;
751
        if(decode_i2_frame(f, buf-4, frame_size) < 0)
752
            return -1;
753
    }else if(frame_4cc == ff_get_fourcc("ifrm")){
754
        p->pict_type= I_TYPE;
755
        if(decode_i_frame(f, buf, frame_size) < 0)
756
            return -1;
757
    }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
758
        p->pict_type= P_TYPE;
759
        if(decode_p_frame(f, buf, frame_size) < 0)
760
            return -1;
761
    }else if(frame_4cc == ff_get_fourcc("snd_")){
762
        av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
763
    }else{
764
        av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
765
    }
766

    
767
    p->key_frame= p->pict_type == I_TYPE;
768

    
769
    *picture= *p;
770
    *data_size = sizeof(AVPicture);
771

    
772
    emms_c();
773

    
774
    return buf_size;
775
}
776

    
777

    
778
static void common_init(AVCodecContext *avctx){
779
    FourXContext * const f = avctx->priv_data;
780

    
781
    dsputil_init(&f->dsp, avctx);
782

    
783
    f->avctx= avctx;
784
}
785

    
786
static int decode_init(AVCodecContext *avctx){
787
    FourXContext * const f = avctx->priv_data;
788

    
789
    f->version= avctx->codec_tag == 0x40000;
790
    common_init(avctx);
791
    init_vlcs(f);
792

    
793
    if(f->version) avctx->pix_fmt= PIX_FMT_RGB565;
794
    else           avctx->pix_fmt= PIX_FMT_RGB555;
795

    
796
    return 0;
797
}
798

    
799

    
800
static int decode_end(AVCodecContext *avctx){
801
    FourXContext * const f = avctx->priv_data;
802
    int i;
803

    
804
    av_freep(&f->bitstream_buffer);
805
    f->bitstream_buffer_size=0;
806
    for(i=0; i<CFRAME_BUFFER_COUNT; i++){
807
        av_freep(&f->cfrm[i].data);
808
        f->cfrm[i].allocated_size= 0;
809
    }
810
    free_vlc(&f->pre_vlc);
811

    
812
    return 0;
813
}
814

    
815
AVCodec fourxm_decoder = {
816
    "4xm",
817
    CODEC_TYPE_VIDEO,
818
    CODEC_ID_4XM,
819
    sizeof(FourXContext),
820
    decode_init,
821
    NULL,
822
    decode_end,
823
    decode_frame,
824
    /*CODEC_CAP_DR1,*/
825
};
826