Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 4xm.c @ b74fb935

History | View | Annotate | Download (25.2 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 vlc_type;
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
        f->mv[i] = mv[i][0] + mv[i][1]*f->current_picture.linesize[0]/2;
252
    }
253
}
254

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

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

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

    
301
    assert(code>=0 && code<=6);
302

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

    
330
static int get32(void *p){
331
    return le2me_32(*(uint32_t*)p);
332
}
333

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

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

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

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

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

    
374
    init_mv(f);
375

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

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

    
393
    return 0;
394
}
395

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

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

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

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

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

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

    
441
    return 0;
442
}
443

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

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

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

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

    
472
            cb+=cb;
473

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

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

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

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

    
498
    return 0;
499
}
500

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

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

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

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

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

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

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

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

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

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

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

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

    
575
    return ptr;
576
}
577

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

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

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

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

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

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

    
618
    return 0;
619
}
620

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

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

    
639
    prestream= read_huffman_tables(f, prestream);
640

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

    
643
    prestream_size= length + buf - prestream;
644

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

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

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

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

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

    
664
    return 0;
665
}
666

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
771
    emms_c();
772

    
773
    return buf_size;
774
}
775

    
776

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

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

    
782
    f->avctx= avctx;
783
}
784

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

    
788
    common_init(avctx);
789
    init_vlcs(f);
790

    
791
    avctx->pix_fmt= PIX_FMT_RGB565;
792

    
793
    return 0;
794
}
795

    
796

    
797
static int decode_end(AVCodecContext *avctx){
798
    FourXContext * const f = avctx->priv_data;
799
    int i;
800

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

    
809
    return 0;
810
}
811

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