3 * Copyright (c) 2003 Michael Niedermayer
5 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/intreadwrite.h"
31 #include "bytestream.h"
36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
39 #define CFRAME_BUFFER_COUNT 100
41 static const uint8_t block_type_tab[2][4][8][2]={
44 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
46 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
48 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
50 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
54 { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
56 { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
58 { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
60 { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
65 static const uint8_t size2index[4][4]={
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}
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,
119 static VLC block_type_vlc[2][4];
122 typedef struct CFrameBuffer{
123 unsigned int allocated_size;
129 typedef struct FourXContext{
130 AVCodecContext *avctx;
132 AVFrame current_picture, last_picture;
133 GetBitContext pre_gb; ///< ac/dc prefix
140 DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
141 void *bitstream_buffer;
142 unsigned int bitstream_buffer_size;
144 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
148 #define FIX_1_082392200 70936
149 #define FIX_1_414213562 92682
150 #define FIX_1_847759065 121095
151 #define FIX_2_613125930 171254
153 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
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;
163 tmp10 = block[8*0 + i] + block[8*4 + i];
164 tmp11 = block[8*0 + i] - block[8*4 + i];
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;
169 tmp0 = tmp10 + tmp13;
170 tmp3 = tmp10 - tmp13;
171 tmp1 = tmp11 + tmp12;
172 tmp2 = tmp11 - tmp12;
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];
180 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
182 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
183 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
184 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
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;
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];
204 tmp13 = temp[2 + i] + temp[6 + i];
205 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
207 tmp0 = tmp10 + tmp13;
208 tmp3 = tmp10 - tmp13;
209 tmp1 = tmp11 + tmp12;
210 tmp2 = tmp11 - tmp12;
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];
218 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
220 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
221 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
222 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
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;
239 static av_cold void init_vlcs(FourXContext *f){
240 static VLC_TYPE table[8][32][2];
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);
252 static void init_mv(FourXContext *f){
255 for(i=0; i<256; i++){
257 f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
259 f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
264 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
266 unsigned tmpval = AV_RN32(src); \
267 tmpval = (tmpval << 16) | (tmpval >> 16); \
268 tmpval = tmpval * (scale) + (dc); \
269 tmpval = (tmpval << 16) | (tmpval >> 16); \
270 AV_WN32A(dst, tmpval); \
273 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
275 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
276 AV_WN32A(dst, tmpval); \
280 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc){
287 dst[0] = scale*src[0] + dc;
288 if(scale) src += stride;
294 LE_CENTRIC_MUL(dst, src, scale, dc);
295 if(scale) src += stride;
301 LE_CENTRIC_MUL(dst, src, scale, dc);
302 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
303 if(scale) src += stride;
309 LE_CENTRIC_MUL(dst, src, scale, dc);
310 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
311 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
312 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
313 if(scale) src += stride;
321 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
322 const int index= size2index[log2h][log2w];
323 const int h= 1<<log2h;
324 int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
325 uint16_t *start= (uint16_t*)f->last_picture.data[0];
326 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
328 assert(code>=0 && code<=6);
331 if (f->g.buffer_end - f->g.buffer < 1){
332 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
335 src += f->mv[ *f->g.buffer++ ];
336 if(start > src || src > end){
337 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
340 mcdc(dst, src, log2w, h, stride, 1, 0);
343 decode_p_block(f, dst , src , log2w, log2h, stride);
344 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
347 decode_p_block(f, dst , src , log2w, log2h, stride);
348 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
349 }else if(code == 3 && f->version<2){
350 mcdc(dst, src, log2w, h, stride, 1, 0);
352 if (f->g.buffer_end - f->g.buffer < 1){
353 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
356 src += f->mv[ *f->g.buffer++ ];
357 if(start > src || src > end){
358 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
361 if (f->g2.buffer_end - f->g2.buffer < 1){
362 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
365 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
367 if (f->g2.buffer_end - f->g2.buffer < 1){
368 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
371 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
373 if (f->g2.buffer_end - f->g2.buffer < 2){
374 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
378 dst[0] = bytestream2_get_le16(&f->g2);
379 dst[1] = bytestream2_get_le16(&f->g2);
381 dst[0 ] = bytestream2_get_le16(&f->g2);
382 dst[stride] = bytestream2_get_le16(&f->g2);
387 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
389 const int width= f->avctx->width;
390 const int height= f->avctx->height;
391 uint16_t *src= (uint16_t*)f->last_picture.data[0];
392 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
393 const int stride= f->current_picture.linesize[0]>>1;
394 unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset;
400 bitstream_size= AV_RL32(buf+8);
401 wordstream_size= AV_RL32(buf+12);
402 bytestream_size= AV_RL32(buf+16);
405 bitstream_size = AV_RL16(buf-4);
406 wordstream_size= AV_RL16(buf-2);
407 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
410 if (bitstream_size > length ||
411 bytestream_size > length - bitstream_size ||
412 wordstream_size > length - bytestream_size - bitstream_size ||
413 extra > length - bytestream_size - bitstream_size - wordstream_size){
414 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
415 bitstream_size+ bytestream_size+ wordstream_size - length);
419 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
420 if (!f->bitstream_buffer)
421 return AVERROR(ENOMEM);
422 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
423 memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
424 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
426 wordstream_offset = extra + bitstream_size;
427 bytestream_offset = extra + bitstream_size + wordstream_size;
428 bytestream2_init(&f->g2, buf + wordstream_offset, length - wordstream_offset);
429 bytestream2_init(&f->g, buf + bytestream_offset, length - bytestream_offset);
433 for(y=0; y<height; y+=8){
434 for(x=0; x<width; x+=8){
435 decode_p_block(f, dst + x, src + x, 3, 3, stride);
445 * decode block and dequantize.
446 * Note this is almost identical to MJPEG.
448 static int decode_i_block(FourXContext *f, DCTELEM *block){
449 int code, i, j, level, val;
451 if(get_bits_left(&f->gb) < 2){
452 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
457 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
459 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
463 val = get_xbits(&f->gb, val);
465 val = val * dequant_table[0] + f->last_dc;
471 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
479 level = get_xbits(&f->gb, code & 0xf);
482 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
486 j= ff_zigzag_direct[i];
487 block[j] = level * dequant_table[j];
497 static inline void idct_put(FourXContext *f, int x, int y){
498 DCTELEM (*block)[64]= f->block;
499 int stride= f->current_picture.linesize[0]>>1;
501 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
504 block[i][0] += 0x80*8*8;
508 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
509 for(i=4; i<6; i++) idct(block[i]);
512 /* Note transform is:
513 y= ( 1b + 4g + 2r)/14
514 cb=( 3b - 2g - 1r)/14
515 cr=(-1b - 4g + 5r)/14
519 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
520 int cb= block[4][x + 8*y];
521 int cr= block[5][x + 8*y];
522 int cg= (cb + cr)>>1;
528 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
530 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
532 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
534 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
537 dst += 2*stride - 2*8;
541 static int decode_i_mb(FourXContext *f){
544 f->dsp.clear_blocks(f->block[0]);
547 if(decode_i_block(f, f->block[i]) < 0)
554 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf, int buf_size){
558 uint8_t len_tab[257];
561 const uint8_t *ptr= buf;
562 const uint8_t *ptr_end = buf + buf_size;
565 memset(frequency, 0, sizeof(frequency));
566 memset(up, -1, sizeof(up));
573 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
575 for(i=start; i<=end; i++){
576 frequency[i]= *ptr++;
585 while((ptr - buf)&3) ptr++; // 4byte align
587 for(j=257; j<512; j++){
588 int min_freq[2]= {256*256, 256*256};
589 int smallest[2]= {0, 0};
592 if(frequency[i] == 0) continue;
593 if(frequency[i] < min_freq[1]){
594 if(frequency[i] < min_freq[0]){
595 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
596 min_freq[0]= frequency[i];smallest[0]= i;
598 min_freq[1]= frequency[i];smallest[1]= i;
602 if(min_freq[1] == 256*256) break;
604 frequency[j]= min_freq[0] + min_freq[1];
605 flag[ smallest[0] ]= 0;
606 flag[ smallest[1] ]= 1;
608 up[ smallest[1] ]= j;
609 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
612 for(j=0; j<257; j++){
617 for(node= j; up[node] != -1; node= up[node]){
618 bits += flag[node]<<len;
620 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
627 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
635 static int mix(int c0, int c1){
636 int blue = 2*(c0&0x001F) + (c1&0x001F);
637 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
638 int red = 2*(c0>>10) + (c1>>10);
639 return red/3*1024 + green/3*32 + blue/3;
642 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
644 const int width= f->avctx->width;
645 const int height= f->avctx->height;
646 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
647 const int stride= f->current_picture.linesize[0]>>1;
648 const uint8_t *buf_end = buf + length;
650 for(y=0; y<height; y+=16){
651 for(x=0; x<width; x+=16){
652 unsigned int color[4], bits;
653 if (buf_end - buf < 8)
655 memset(color, 0, sizeof(color));
656 //warning following is purely guessed ...
657 color[0]= bytestream_get_le16(&buf);
658 color[1]= bytestream_get_le16(&buf);
660 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
661 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
663 color[2]= mix(color[0], color[1]);
664 color[3]= mix(color[1], color[0]);
666 bits= bytestream_get_le32(&buf);
667 for(y2=0; y2<16; y2++){
668 for(x2=0; x2<16; x2++){
669 int index= 2*(x2>>2) + 8*(y2>>2);
670 dst[y2*stride+x2]= color[(bits>>index)&3];
675 dst += 16*stride - width;
681 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
683 const int width= f->avctx->width;
684 const int height= f->avctx->height;
685 const unsigned int bitstream_size= AV_RL32(buf);
686 unsigned int prestream_size;
687 const uint8_t *prestream;
689 if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
690 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
691 return AVERROR_INVALIDDATA;
694 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
695 prestream = buf + bitstream_size + 12;
697 if (prestream_size > (1<<26) ||
698 prestream_size != length - (bitstream_size + 12)){
699 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
703 prestream= read_huffman_tables(f, prestream, buf + length - prestream);
707 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
709 prestream_size= length + buf - prestream;
711 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
712 if (!f->bitstream_buffer)
713 return AVERROR(ENOMEM);
714 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
715 memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
716 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
718 f->last_dc= 0*128*8*8;
720 for(y=0; y<height; y+=16){
721 for(x=0; x<width; x+=16){
722 if(decode_i_mb(f) < 0)
729 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
730 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
735 static int decode_frame(AVCodecContext *avctx,
736 void *data, int *data_size,
739 const uint8_t *buf = avpkt->data;
740 int buf_size = avpkt->size;
741 FourXContext * const f = avctx->priv_data;
742 AVFrame *picture = data;
744 int i, frame_4cc, frame_size;
747 return AVERROR_INVALIDDATA;
748 frame_4cc= AV_RL32(buf);
749 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
750 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
753 if(frame_4cc == AV_RL32("cfrm")){
755 const int data_size= buf_size - 20;
756 const int id= AV_RL32(buf+12);
757 const int whole_size= AV_RL32(buf+16);
760 if (data_size < 0 || whole_size < 0){
761 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
762 return AVERROR_INVALIDDATA;
765 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
766 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
767 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
770 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
771 if(f->cfrm[i].id == id) break;
772 if(f->cfrm[i].size == 0 ) free_index= i;
775 if(i>=CFRAME_BUFFER_COUNT){
781 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
782 return AVERROR_INVALIDDATA;
783 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
784 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
785 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
789 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
790 cfrm->size += data_size;
792 if(cfrm->size >= whole_size){
794 frame_size= cfrm->size;
796 if(id != avctx->frame_number){
797 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
800 cfrm->size= cfrm->id= 0;
801 frame_4cc= AV_RL32("pfrm");
806 frame_size= buf_size - 12;
809 temp= f->current_picture;
810 f->current_picture= f->last_picture;
811 f->last_picture= temp;
813 p= &f->current_picture;
814 avctx->coded_frame= p;
816 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
819 if (avctx->reget_buffer(avctx, p) < 0) {
820 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
824 if(frame_4cc == AV_RL32("ifr2")){
825 p->pict_type= AV_PICTURE_TYPE_I;
826 if(decode_i2_frame(f, buf-4, frame_size+4) < 0){
827 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
830 }else if(frame_4cc == AV_RL32("ifrm")){
831 p->pict_type= AV_PICTURE_TYPE_I;
832 if(decode_i_frame(f, buf, frame_size) < 0){
833 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
836 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
837 if(!f->last_picture.data[0]){
838 f->last_picture.reference= 3;
839 if(avctx->get_buffer(avctx, &f->last_picture) < 0){
840 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
845 p->pict_type= AV_PICTURE_TYPE_P;
846 if(decode_p_frame(f, buf, frame_size) < 0){
847 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
850 }else if(frame_4cc == AV_RL32("snd_")){
851 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
853 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
856 p->key_frame= p->pict_type == AV_PICTURE_TYPE_I;
859 *data_size = sizeof(AVPicture);
867 static av_cold void common_init(AVCodecContext *avctx){
868 FourXContext * const f = avctx->priv_data;
870 dsputil_init(&f->dsp, avctx);
875 static av_cold int decode_init(AVCodecContext *avctx){
876 FourXContext * const f = avctx->priv_data;
878 if(avctx->extradata_size != 4 || !avctx->extradata) {
879 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
882 if((avctx->width % 16) || (avctx->height % 16)) {
883 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
884 return AVERROR_INVALIDDATA;
887 avcodec_get_frame_defaults(&f->current_picture);
888 avcodec_get_frame_defaults(&f->last_picture);
889 f->version= AV_RL32(avctx->extradata)>>16;
893 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
894 else avctx->pix_fmt= PIX_FMT_BGR555;
900 static av_cold int decode_end(AVCodecContext *avctx){
901 FourXContext * const f = avctx->priv_data;
904 av_freep(&f->bitstream_buffer);
905 f->bitstream_buffer_size=0;
906 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
907 av_freep(&f->cfrm[i].data);
908 f->cfrm[i].allocated_size= 0;
910 free_vlc(&f->pre_vlc);
911 if(f->current_picture.data[0])
912 avctx->release_buffer(avctx, &f->current_picture);
913 if(f->last_picture.data[0])
914 avctx->release_buffer(avctx, &f->last_picture);
919 AVCodec ff_fourxm_decoder = {
921 .type = AVMEDIA_TYPE_VIDEO,
923 .priv_data_size = sizeof(FourXContext),
926 .decode = decode_frame,
927 .capabilities = CODEC_CAP_DR1,
928 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),