Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 4xm.c @ b6f508bb

History | View | Annotate | Download (25.6 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
#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
    uint8_t *bytestream;
135
    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 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)
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][index].table, BLOCK_TYPE_VLC_BITS, 1);
304

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

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

    
336
static int get32(void *p){
337
    return le2me_32(*(uint32_t*)p);
338
}
339

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

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

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

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

    
375
    f->wordstream= (uint16_t*)(buf + extra + bitstream_size);
376
    f->bytestream= buf + extra + bitstream_size + wordstream_size;
377

    
378
    init_mv(f);
379

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

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

    
397
    return 0;
398
}
399

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

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

    
413
    if(val)
414
        val = get_xbits(&f->gb, val);
415

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

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

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

    
445
    return 0;
446
}
447

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

    
454
    for(i=0; i<4; i++){
455
        block[i][0] += 0x80*8*8;
456
        idct(block[i]);
457
    }
458

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

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

    
476
            cb+=cb;
477

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

    
492
static int decode_i_mb(FourXContext *f){
493
    int i;
494

    
495
    f->dsp.clear_blocks(f->block[0]);
496

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

    
502
    return 0;
503
}
504

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

    
515
    memset(frequency, 0, sizeof(frequency));
516
    memset(up, -1, sizeof(up));
517

    
518
    start= *ptr++;
519
    end= *ptr++;
520
    for(;;){
521
        int i;
522

    
523
        for(i=start; i<=end; i++){
524
            frequency[i]= *ptr++;
525
        }
526
        start= *ptr++;
527
        if(start==0) break;
528

    
529
        end= *ptr++;
530
    }
531
    frequency[256]=1;
532

    
533
    while((ptr - buf)&3) ptr++; // 4byte align
534

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

    
552
        frequency[j]= min_freq[0] + min_freq[1];
553
        flag[ smallest[0] ]= 0;
554
        flag[ smallest[1] ]= 1;
555
        up[ smallest[0] ]=
556
        up[ smallest[1] ]= j;
557
        frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
558
    }
559

    
560
    for(j=0; j<257; j++){
561
        int node;
562
        int len=0;
563
        int bits=0;
564

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

    
571
        bits_tab[j]= bits;
572
        len_tab[j]= len;
573
    }
574

    
575
    init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
576
             len_tab , 1, 1,
577
             bits_tab, 4, 4, 0);
578

    
579
    return ptr;
580
}
581

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

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

    
596
    for(y=0; y<height; y+=16){
597
        for(x=0; x<width; x+=16){
598
            unsigned int color[4], bits;
599
            memset(color, 0, sizeof(color));
600
//warning following is purely guessed ...
601
            color[0]= bytestream_get_le16(&buf);
602
            color[1]= bytestream_get_le16(&buf);
603

    
604
            if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
605
            if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
606

    
607
            color[2]= mix(color[0], color[1]);
608
            color[3]= mix(color[1], color[0]);
609

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

    
622
    return 0;
623
}
624

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

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

    
643
    prestream= read_huffman_tables(f, prestream);
644

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

    
647
    prestream_size= length + buf - prestream;
648

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

    
653
    f->last_dc= 0*128*8*8;
654

    
655
    for(y=0; y<height; y+=16){
656
        for(x=0; x<width; x+=16){
657
            if(decode_i_mb(f) < 0)
658
                return -1;
659

    
660
            idct_put(f, x, y);
661
        }
662
        dst += 16*stride;
663
    }
664

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

    
668
    return 0;
669
}
670

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

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

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

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

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

    
702
        if(i>=CFRAME_BUFFER_COUNT){
703
            i= free_index;
704
            f->cfrm[i].id= id;
705
        }
706
        cfrm= &f->cfrm[i];
707

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

    
714
        memcpy(cfrm->data + cfrm->size, buf+20, data_size);
715
        cfrm->size += data_size;
716

    
717
        if(cfrm->size >= whole_size){
718
            buf= cfrm->data;
719
            frame_size= cfrm->size;
720

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

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

    
734
    temp= f->current_picture;
735
    f->current_picture= f->last_picture;
736
    f->last_picture= temp;
737

    
738
    p= &f->current_picture;
739
    avctx->coded_frame= p;
740

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

    
743
    if(p->data[0])
744
        avctx->release_buffer(avctx, p);
745

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

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

    
770
    p->key_frame= p->pict_type == I_TYPE;
771

    
772
    *picture= *p;
773
    *data_size = sizeof(AVPicture);
774

    
775
    emms_c();
776

    
777
    return buf_size;
778
}
779

    
780

    
781
static void common_init(AVCodecContext *avctx){
782
    FourXContext * const f = avctx->priv_data;
783

    
784
    dsputil_init(&f->dsp, avctx);
785

    
786
    f->avctx= avctx;
787
}
788

    
789
static int decode_init(AVCodecContext *avctx){
790
    FourXContext * const f = avctx->priv_data;
791

    
792
    if(avctx->extradata_size != 4 || !avctx->extradata) {
793
        av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
794
        return 1;
795
    }
796

    
797
    f->version= AV_RL32(avctx->extradata) == 0x40000;
798
    common_init(avctx);
799
    init_vlcs(f);
800

    
801
    if(f->version) avctx->pix_fmt= PIX_FMT_RGB565;
802
    else           avctx->pix_fmt= PIX_FMT_RGB555;
803

    
804
    return 0;
805
}
806

    
807

    
808
static int decode_end(AVCodecContext *avctx){
809
    FourXContext * const f = avctx->priv_data;
810
    int i;
811

    
812
    av_freep(&f->bitstream_buffer);
813
    f->bitstream_buffer_size=0;
814
    for(i=0; i<CFRAME_BUFFER_COUNT; i++){
815
        av_freep(&f->cfrm[i].data);
816
        f->cfrm[i].allocated_size= 0;
817
    }
818
    free_vlc(&f->pre_vlc);
819

    
820
    return 0;
821
}
822

    
823
AVCodec fourxm_decoder = {
824
    "4xm",
825
    CODEC_TYPE_VIDEO,
826
    CODEC_ID_4XM,
827
    sizeof(FourXContext),
828
    decode_init,
829
    NULL,
830
    decode_end,
831
    decode_frame,
832
    /*CODEC_CAP_DR1,*/
833
};
834