Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 4xm.c @ 84dc2d8a

History | View | Annotate | Download (26.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 libavcodec/4xm.c
24
 * 4XM codec.
25
 */
26

    
27
#include "libavutil/intreadwrite.h"
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "get_bits.h"
31
#include "bytestream.h"
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

    
41
static const uint8_t block_type_tab[2][4][8][2]={
42
 {
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
  }
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
 }
63
};
64

    
65
static 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

    
72
static 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
108
static 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

    
119
static VLC block_type_vlc[2][4];
120

    
121

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

    
129
typedef struct FourXContext{
130
    AVCodecContext *avctx;
131
    DSPContext dsp;
132
    AVFrame current_picture, last_picture;
133
    GetBitContext pre_gb;          ///< ac/dc prefix
134
    GetBitContext gb;
135
    const uint8_t *bytestream;
136
    const uint16_t *wordstream;
137
    int mv[256];
138
    VLC pre_vlc;
139
    int last_dc;
140
    DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
141
    void *bitstream_buffer;
142
    unsigned int bitstream_buffer_size;
143
    int version;
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

    
155
static 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];
161

    
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;
173

    
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
    }
199

    
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

    
239
static av_cold void init_vlcs(FourXContext *f){
240
    static VLC_TYPE table[8][32][2];
241
    int i;
242

    
243
    for(i=0; i<8; i++){
244
        block_type_vlc[0][i].table= table[i];
245
        block_type_vlc[0][i].table_allocated= 32;
246
        init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
247
                 &block_type_tab[0][i][0][1], 2, 1,
248
                 &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
249
    }
250
}
251

    
252
static void init_mv(FourXContext *f){
253
    int i;
254

    
255
    for(i=0; i<256; i++){
256
        if(f->version>1)
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;
260
    }
261
}
262

    
263
static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
264
   int i;
265
   dc*= 0x10001;
266

    
267
   switch(log2w){
268
   case 0:
269
        for(i=0; i<h; i++){
270
            dst[0] = scale*src[0] + dc;
271
            if(scale) src += stride;
272
            dst += stride;
273
        }
274
        break;
275
    case 1:
276
        for(i=0; i<h; i++){
277
            ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
278
            if(scale) src += stride;
279
            dst += stride;
280
        }
281
        break;
282
    case 2:
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
            if(scale) src += stride;
287
            dst += stride;
288
        }
289
        break;
290
    case 3:
291
        for(i=0; i<h; i++){
292
            ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
293
            ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
294
            ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
295
            ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
296
            if(scale) src += stride;
297
            dst += stride;
298
        }
299
        break;
300
    default: assert(0);
301
    }
302
}
303

    
304
static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
305
    const int index= size2index[log2h][log2w];
306
    const int h= 1<<log2h;
307
    int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
308
    uint16_t *start= (uint16_t*)f->last_picture.data[0];
309
    uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
310

    
311
    assert(code>=0 && code<=6);
312

    
313
    if(code == 0){
314
        src += f->mv[ *f->bytestream++ ];
315
        if(start > src || src > end){
316
            av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
317
            return;
318
        }
319
        mcdc(dst, src, log2w, h, stride, 1, 0);
320
    }else if(code == 1){
321
        log2h--;
322
        decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
323
        decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
324
    }else if(code == 2){
325
        log2w--;
326
        decode_p_block(f, dst             , src             , log2w, log2h, stride);
327
        decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
328
    }else if(code == 3 && f->version<2){
329
        mcdc(dst, src, log2w, h, stride, 1, 0);
330
    }else if(code == 4){
331
        src += f->mv[ *f->bytestream++ ];
332
        if(start > src || src > end){
333
            av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
334
            return;
335
        }
336
        mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
337
    }else if(code == 5){
338
        mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
339
    }else if(code == 6){
340
        if(log2w){
341
            dst[0] = le2me_16(*f->wordstream++);
342
            dst[1] = le2me_16(*f->wordstream++);
343
        }else{
344
            dst[0     ] = le2me_16(*f->wordstream++);
345
            dst[stride] = le2me_16(*f->wordstream++);
346
        }
347
    }
348
}
349

    
350
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
351
    int x, y;
352
    const int width= f->avctx->width;
353
    const int height= f->avctx->height;
354
    uint16_t *src= (uint16_t*)f->last_picture.data[0];
355
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
356
    const int stride= f->current_picture.linesize[0]>>1;
357
    unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
358

    
359
    if(f->version>1){
360
        extra=20;
361
        bitstream_size= AV_RL32(buf+8);
362
        wordstream_size= AV_RL32(buf+12);
363
        bytestream_size= AV_RL32(buf+16);
364
    }else{
365
        extra=0;
366
        bitstream_size = AV_RL16(buf-4);
367
        wordstream_size= AV_RL16(buf-2);
368
        bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
369
    }
370

    
371
    if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
372
       || bitstream_size  > (1<<26)
373
       || bytestream_size > (1<<26)
374
       || wordstream_size > (1<<26)
375
       ){
376
        av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
377
        bitstream_size+ bytestream_size+ wordstream_size - length);
378
        return -1;
379
    }
380

    
381
    av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
382
    if (!f->bitstream_buffer)
383
        return AVERROR(ENOMEM);
384
    f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
385
    init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
386

    
387
    f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
388
    f->bytestream= buf + extra + bitstream_size + wordstream_size;
389

    
390
    init_mv(f);
391

    
392
    for(y=0; y<height; y+=8){
393
        for(x=0; x<width; x+=8){
394
            decode_p_block(f, dst + x, src + x, 3, 3, stride);
395
        }
396
        src += 8*stride;
397
        dst += 8*stride;
398
    }
399

    
400
    if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
401
       || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
402
       || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
403
        av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
404
            bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
405
            -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
406
            -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
407
        );
408

    
409
    return 0;
410
}
411

    
412
/**
413
 * decode block and dequantize.
414
 * Note this is almost identical to MJPEG.
415
 */
416
static int decode_i_block(FourXContext *f, DCTELEM *block){
417
    int code, i, j, level, val;
418

    
419
    /* DC coef */
420
    val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
421
    if (val>>4){
422
        av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
423
    }
424

    
425
    if(val)
426
        val = get_xbits(&f->gb, val);
427

    
428
    val = val * dequant_table[0] + f->last_dc;
429
    f->last_dc =
430
    block[0] = val;
431
    /* AC coefs */
432
    i = 1;
433
    for(;;) {
434
        code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
435

    
436
        /* EOB */
437
        if (code == 0)
438
            break;
439
        if (code == 0xf0) {
440
            i += 16;
441
        } else {
442
            level = get_xbits(&f->gb, code & 0xf);
443
            i += code >> 4;
444
            if (i >= 64) {
445
                av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
446
                return 0;
447
            }
448

    
449
            j= ff_zigzag_direct[i];
450
            block[j] = level * dequant_table[j];
451
            i++;
452
            if (i >= 64)
453
                break;
454
        }
455
    }
456

    
457
    return 0;
458
}
459

    
460
static inline void idct_put(FourXContext *f, int x, int y){
461
    DCTELEM (*block)[64]= f->block;
462
    int stride= f->current_picture.linesize[0]>>1;
463
    int i;
464
    uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
465

    
466
    for(i=0; i<4; i++){
467
        block[i][0] += 0x80*8*8;
468
        idct(block[i]);
469
    }
470

    
471
    if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
472
        for(i=4; i<6; i++) idct(block[i]);
473
    }
474

    
475
/* Note transform is:
476
y= ( 1b + 4g + 2r)/14
477
cb=( 3b - 2g - 1r)/14
478
cr=(-1b - 4g + 5r)/14
479
*/
480
    for(y=0; y<8; y++){
481
        for(x=0; x<8; x++){
482
            DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
483
            int cb= block[4][x + 8*y];
484
            int cr= block[5][x + 8*y];
485
            int cg= (cb + cr)>>1;
486
            int y;
487

    
488
            cb+=cb;
489

    
490
            y = temp[0];
491
            dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
492
            y = temp[1];
493
            dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
494
            y = temp[8];
495
            dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
496
            y = temp[9];
497
            dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
498
            dst += 2;
499
        }
500
        dst += 2*stride - 2*8;
501
    }
502
}
503

    
504
static int decode_i_mb(FourXContext *f){
505
    int i;
506

    
507
    f->dsp.clear_blocks(f->block[0]);
508

    
509
    for(i=0; i<6; i++){
510
        if(decode_i_block(f, f->block[i]) < 0)
511
            return -1;
512
    }
513

    
514
    return 0;
515
}
516

    
517
static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
518
    int frequency[512];
519
    uint8_t flag[512];
520
    int up[512];
521
    uint8_t len_tab[257];
522
    int bits_tab[257];
523
    int start, end;
524
    const uint8_t *ptr= buf;
525
    int j;
526

    
527
    memset(frequency, 0, sizeof(frequency));
528
    memset(up, -1, sizeof(up));
529

    
530
    start= *ptr++;
531
    end= *ptr++;
532
    for(;;){
533
        int i;
534

    
535
        for(i=start; i<=end; i++){
536
            frequency[i]= *ptr++;
537
        }
538
        start= *ptr++;
539
        if(start==0) break;
540

    
541
        end= *ptr++;
542
    }
543
    frequency[256]=1;
544

    
545
    while((ptr - buf)&3) ptr++; // 4byte align
546

    
547
    for(j=257; j<512; j++){
548
        int min_freq[2]= {256*256, 256*256};
549
        int smallest[2]= {0, 0};
550
        int i;
551
        for(i=0; i<j; i++){
552
            if(frequency[i] == 0) continue;
553
            if(frequency[i] < min_freq[1]){
554
                if(frequency[i] < min_freq[0]){
555
                    min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
556
                    min_freq[0]= frequency[i];smallest[0]= i;
557
                }else{
558
                    min_freq[1]= frequency[i];smallest[1]= i;
559
                }
560
            }
561
        }
562
        if(min_freq[1] == 256*256) break;
563

    
564
        frequency[j]= min_freq[0] + min_freq[1];
565
        flag[ smallest[0] ]= 0;
566
        flag[ smallest[1] ]= 1;
567
        up[ smallest[0] ]=
568
        up[ smallest[1] ]= j;
569
        frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
570
    }
571

    
572
    for(j=0; j<257; j++){
573
        int node;
574
        int len=0;
575
        int bits=0;
576

    
577
        for(node= j; up[node] != -1; node= up[node]){
578
            bits += flag[node]<<len;
579
            len++;
580
            if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
581
        }
582

    
583
        bits_tab[j]= bits;
584
        len_tab[j]= len;
585
    }
586

    
587
    init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
588
             len_tab , 1, 1,
589
             bits_tab, 4, 4, 0);
590

    
591
    return ptr;
592
}
593

    
594
static int mix(int c0, int c1){
595
    int blue = 2*(c0&0x001F) + (c1&0x001F);
596
    int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
597
    int red  = 2*(c0>>10) + (c1>>10);
598
    return red/3*1024 + green/3*32 + blue/3;
599
}
600

    
601
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
602
    int x, y, x2, y2;
603
    const int width= f->avctx->width;
604
    const int height= f->avctx->height;
605
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
606
    const int stride= f->current_picture.linesize[0]>>1;
607

    
608
    for(y=0; y<height; y+=16){
609
        for(x=0; x<width; x+=16){
610
            unsigned int color[4], bits;
611
            memset(color, 0, sizeof(color));
612
//warning following is purely guessed ...
613
            color[0]= bytestream_get_le16(&buf);
614
            color[1]= bytestream_get_le16(&buf);
615

    
616
            if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
617
            if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
618

    
619
            color[2]= mix(color[0], color[1]);
620
            color[3]= mix(color[1], color[0]);
621

    
622
            bits= bytestream_get_le32(&buf);
623
            for(y2=0; y2<16; y2++){
624
                for(x2=0; x2<16; x2++){
625
                    int index= 2*(x2>>2) + 8*(y2>>2);
626
                    dst[y2*stride+x2]= color[(bits>>index)&3];
627
                }
628
            }
629
            dst+=16;
630
        }
631
        dst += 16*stride - width;
632
    }
633

    
634
    return 0;
635
}
636

    
637
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
638
    int x, y;
639
    const int width= f->avctx->width;
640
    const int height= f->avctx->height;
641
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
642
    const int stride= f->current_picture.linesize[0]>>1;
643
    const unsigned int bitstream_size= AV_RL32(buf);
644
    const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
645
    unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
646
    const uint8_t *prestream= buf + bitstream_size + 12;
647

    
648
    if(prestream_size + bitstream_size + 12 != length
649
       || bitstream_size > (1<<26)
650
       || prestream_size > (1<<26)){
651
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
652
        return -1;
653
    }
654

    
655
    prestream= read_huffman_tables(f, prestream);
656

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

    
659
    prestream_size= length + buf - prestream;
660

    
661
    av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
662
    if (!f->bitstream_buffer)
663
        return AVERROR(ENOMEM);
664
    f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
665
    init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
666

    
667
    f->last_dc= 0*128*8*8;
668

    
669
    for(y=0; y<height; y+=16){
670
        for(x=0; x<width; x+=16){
671
            if(decode_i_mb(f) < 0)
672
                return -1;
673

    
674
            idct_put(f, x, y);
675
        }
676
        dst += 16*stride;
677
    }
678

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

    
682
    return 0;
683
}
684

    
685
static int decode_frame(AVCodecContext *avctx,
686
                        void *data, int *data_size,
687
                        AVPacket *avpkt)
688
{
689
    const uint8_t *buf = avpkt->data;
690
    int buf_size = avpkt->size;
691
    FourXContext * const f = avctx->priv_data;
692
    AVFrame *picture = data;
693
    AVFrame *p, temp;
694
    int i, frame_4cc, frame_size;
695

    
696
    frame_4cc= AV_RL32(buf);
697
    if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
698
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
699
    }
700

    
701
    if(frame_4cc == AV_RL32("cfrm")){
702
        int free_index=-1;
703
        const int data_size= buf_size - 20;
704
        const int id= AV_RL32(buf+12);
705
        const int whole_size= AV_RL32(buf+16);
706
        CFrameBuffer *cfrm;
707

    
708
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
709
            if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
710
                av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
711
        }
712

    
713
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
714
            if(f->cfrm[i].id   == id) break;
715
            if(f->cfrm[i].size == 0 ) free_index= i;
716
        }
717

    
718
        if(i>=CFRAME_BUFFER_COUNT){
719
            i= free_index;
720
            f->cfrm[i].id= id;
721
        }
722
        cfrm= &f->cfrm[i];
723

    
724
        cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
725
        if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
726
            av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
727
            return -1;
728
        }
729

    
730
        memcpy(cfrm->data + cfrm->size, buf+20, data_size);
731
        cfrm->size += data_size;
732

    
733
        if(cfrm->size >= whole_size){
734
            buf= cfrm->data;
735
            frame_size= cfrm->size;
736

    
737
            if(id != avctx->frame_number){
738
                av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
739
            }
740

    
741
            cfrm->size= cfrm->id= 0;
742
            frame_4cc= AV_RL32("pfrm");
743
        }else
744
            return buf_size;
745
    }else{
746
        buf= buf + 12;
747
        frame_size= buf_size - 12;
748
    }
749

    
750
    temp= f->current_picture;
751
    f->current_picture= f->last_picture;
752
    f->last_picture= temp;
753

    
754
    p= &f->current_picture;
755
    avctx->coded_frame= p;
756

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

    
759
    if(p->data[0])
760
        avctx->release_buffer(avctx, p);
761

    
762
    p->reference= 1;
763
    if(avctx->get_buffer(avctx, p) < 0){
764
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
765
        return -1;
766
    }
767

    
768
    if(frame_4cc == AV_RL32("ifr2")){
769
        p->pict_type= FF_I_TYPE;
770
        if(decode_i2_frame(f, buf-4, frame_size) < 0)
771
            return -1;
772
    }else if(frame_4cc == AV_RL32("ifrm")){
773
        p->pict_type= FF_I_TYPE;
774
        if(decode_i_frame(f, buf, frame_size) < 0)
775
            return -1;
776
    }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
777
        p->pict_type= FF_P_TYPE;
778
        if(decode_p_frame(f, buf, frame_size) < 0)
779
            return -1;
780
    }else if(frame_4cc == AV_RL32("snd_")){
781
        av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
782
    }else{
783
        av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
784
    }
785

    
786
    p->key_frame= p->pict_type == FF_I_TYPE;
787

    
788
    *picture= *p;
789
    *data_size = sizeof(AVPicture);
790

    
791
    emms_c();
792

    
793
    return buf_size;
794
}
795

    
796

    
797
static av_cold void common_init(AVCodecContext *avctx){
798
    FourXContext * const f = avctx->priv_data;
799

    
800
    dsputil_init(&f->dsp, avctx);
801

    
802
    f->avctx= avctx;
803
}
804

    
805
static av_cold int decode_init(AVCodecContext *avctx){
806
    FourXContext * const f = avctx->priv_data;
807

    
808
    if(avctx->extradata_size != 4 || !avctx->extradata) {
809
        av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
810
        return 1;
811
    }
812

    
813
    f->version= AV_RL32(avctx->extradata)>>16;
814
    common_init(avctx);
815
    init_vlcs(f);
816

    
817
    if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
818
    else             avctx->pix_fmt= PIX_FMT_BGR555;
819

    
820
    return 0;
821
}
822

    
823

    
824
static av_cold int decode_end(AVCodecContext *avctx){
825
    FourXContext * const f = avctx->priv_data;
826
    int i;
827

    
828
    av_freep(&f->bitstream_buffer);
829
    f->bitstream_buffer_size=0;
830
    for(i=0; i<CFRAME_BUFFER_COUNT; i++){
831
        av_freep(&f->cfrm[i].data);
832
        f->cfrm[i].allocated_size= 0;
833
    }
834
    free_vlc(&f->pre_vlc);
835
    if(f->current_picture.data[0])
836
        avctx->release_buffer(avctx, &f->current_picture);
837
    if(f->last_picture.data[0])
838
        avctx->release_buffer(avctx, &f->last_picture);
839

    
840
    return 0;
841
}
842

    
843
AVCodec fourxm_decoder = {
844
    "4xm",
845
    CODEC_TYPE_VIDEO,
846
    CODEC_ID_4XM,
847
    sizeof(FourXContext),
848
    decode_init,
849
    NULL,
850
    decode_end,
851
    decode_frame,
852
    CODEC_CAP_DR1,
853
    .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
854
};
855