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
135 const uint8_t *bytestream;
136 const uint16_t *wordstream;
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, int 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 src += f->mv[ *f->bytestream++ ];
332 if(start > src || src > end){
333 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
336 mcdc(dst, src, log2w, h, stride, 1, 0);
339 decode_p_block(f, dst , src , log2w, log2h, stride);
340 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
343 decode_p_block(f, dst , src , log2w, log2h, stride);
344 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
345 }else if(code == 3 && f->version<2){
346 mcdc(dst, src, log2w, h, stride, 1, 0);
348 src += f->mv[ *f->bytestream++ ];
349 if(start > src || src > end){
350 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
353 mcdc(dst, src, log2w, h, stride, 1, av_le2ne16(*f->wordstream++));
355 mcdc(dst, src, log2w, h, stride, 0, av_le2ne16(*f->wordstream++));
358 dst[0] = av_le2ne16(*f->wordstream++);
359 dst[1] = av_le2ne16(*f->wordstream++);
361 dst[0 ] = av_le2ne16(*f->wordstream++);
362 dst[stride] = av_le2ne16(*f->wordstream++);
367 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
369 const int width= f->avctx->width;
370 const int height= f->avctx->height;
371 uint16_t *src= (uint16_t*)f->last_picture.data[0];
372 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
373 const int stride= f->current_picture.linesize[0]>>1;
374 unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
378 bitstream_size= AV_RL32(buf+8);
379 wordstream_size= AV_RL32(buf+12);
380 bytestream_size= AV_RL32(buf+16);
383 bitstream_size = AV_RL16(buf-4);
384 wordstream_size= AV_RL16(buf-2);
385 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
388 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
389 || bitstream_size > (1<<26)
390 || bytestream_size > (1<<26)
391 || wordstream_size > (1<<26)
393 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
394 bitstream_size+ bytestream_size+ wordstream_size - length);
398 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
399 if (!f->bitstream_buffer)
400 return AVERROR(ENOMEM);
401 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
402 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
404 f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
405 f->bytestream= buf + extra + bitstream_size + wordstream_size;
409 for(y=0; y<height; y+=8){
410 for(x=0; x<width; x+=8){
411 decode_p_block(f, dst + x, src + x, 3, 3, stride);
417 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
418 || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
419 || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
420 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
421 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
422 -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
423 -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
430 * decode block and dequantize.
431 * Note this is almost identical to MJPEG.
433 static int decode_i_block(FourXContext *f, DCTELEM *block){
434 int code, i, j, level, val;
437 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
439 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
443 val = get_xbits(&f->gb, val);
445 val = val * dequant_table[0] + f->last_dc;
451 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
459 level = get_xbits(&f->gb, code & 0xf);
462 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
466 j= ff_zigzag_direct[i];
467 block[j] = level * dequant_table[j];
477 static inline void idct_put(FourXContext *f, int x, int y){
478 DCTELEM (*block)[64]= f->block;
479 int stride= f->current_picture.linesize[0]>>1;
481 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
484 block[i][0] += 0x80*8*8;
488 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
489 for(i=4; i<6; i++) idct(block[i]);
492 /* Note transform is:
493 y= ( 1b + 4g + 2r)/14
494 cb=( 3b - 2g - 1r)/14
495 cr=(-1b - 4g + 5r)/14
499 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
500 int cb= block[4][x + 8*y];
501 int cr= block[5][x + 8*y];
502 int cg= (cb + cr)>>1;
508 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
510 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
512 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
514 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
517 dst += 2*stride - 2*8;
521 static int decode_i_mb(FourXContext *f){
524 f->dsp.clear_blocks(f->block[0]);
527 if(decode_i_block(f, f->block[i]) < 0)
534 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
538 uint8_t len_tab[257];
541 const uint8_t *ptr= buf;
544 memset(frequency, 0, sizeof(frequency));
545 memset(up, -1, sizeof(up));
552 for(i=start; i<=end; i++){
553 frequency[i]= *ptr++;
562 while((ptr - buf)&3) ptr++; // 4byte align
564 for(j=257; j<512; j++){
565 int min_freq[2]= {256*256, 256*256};
566 int smallest[2]= {0, 0};
569 if(frequency[i] == 0) continue;
570 if(frequency[i] < min_freq[1]){
571 if(frequency[i] < min_freq[0]){
572 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
573 min_freq[0]= frequency[i];smallest[0]= i;
575 min_freq[1]= frequency[i];smallest[1]= i;
579 if(min_freq[1] == 256*256) break;
581 frequency[j]= min_freq[0] + min_freq[1];
582 flag[ smallest[0] ]= 0;
583 flag[ smallest[1] ]= 1;
585 up[ smallest[1] ]= j;
586 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
589 for(j=0; j<257; j++){
594 for(node= j; up[node] != -1; node= up[node]){
595 bits += flag[node]<<len;
597 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
604 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
611 static int mix(int c0, int c1){
612 int blue = 2*(c0&0x001F) + (c1&0x001F);
613 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
614 int red = 2*(c0>>10) + (c1>>10);
615 return red/3*1024 + green/3*32 + blue/3;
618 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
620 const int width= f->avctx->width;
621 const int height= f->avctx->height;
622 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
623 const int stride= f->current_picture.linesize[0]>>1;
625 for(y=0; y<height; y+=16){
626 for(x=0; x<width; x+=16){
627 unsigned int color[4], bits;
628 memset(color, 0, sizeof(color));
629 //warning following is purely guessed ...
630 color[0]= bytestream_get_le16(&buf);
631 color[1]= bytestream_get_le16(&buf);
633 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
634 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
636 color[2]= mix(color[0], color[1]);
637 color[3]= mix(color[1], color[0]);
639 bits= bytestream_get_le32(&buf);
640 for(y2=0; y2<16; y2++){
641 for(x2=0; x2<16; x2++){
642 int index= 2*(x2>>2) + 8*(y2>>2);
643 dst[y2*stride+x2]= color[(bits>>index)&3];
648 dst += 16*stride - width;
654 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
656 const int width= f->avctx->width;
657 const int height= f->avctx->height;
658 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
659 const int stride= f->current_picture.linesize[0]>>1;
660 const unsigned int bitstream_size= AV_RL32(buf);
661 const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
662 unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
663 const uint8_t *prestream= buf + bitstream_size + 12;
665 if(prestream_size + bitstream_size + 12 != length
666 || bitstream_size > (1<<26)
667 || prestream_size > (1<<26)){
668 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
672 prestream= read_huffman_tables(f, prestream);
674 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
676 prestream_size= length + buf - prestream;
678 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
679 if (!f->bitstream_buffer)
680 return AVERROR(ENOMEM);
681 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
682 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
684 f->last_dc= 0*128*8*8;
686 for(y=0; y<height; y+=16){
687 for(x=0; x<width; x+=16){
688 if(decode_i_mb(f) < 0)
696 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
697 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
702 static int decode_frame(AVCodecContext *avctx,
703 void *data, int *data_size,
706 const uint8_t *buf = avpkt->data;
707 int buf_size = avpkt->size;
708 FourXContext * const f = avctx->priv_data;
709 AVFrame *picture = data;
711 int i, frame_4cc, frame_size;
713 frame_4cc= AV_RL32(buf);
714 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
715 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
718 if(frame_4cc == AV_RL32("cfrm")){
720 const int data_size= buf_size - 20;
721 const int id= AV_RL32(buf+12);
722 const int whole_size= AV_RL32(buf+16);
725 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
726 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
727 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
730 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
731 if(f->cfrm[i].id == id) break;
732 if(f->cfrm[i].size == 0 ) free_index= i;
735 if(i>=CFRAME_BUFFER_COUNT){
741 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
742 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
743 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
747 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
748 cfrm->size += data_size;
750 if(cfrm->size >= whole_size){
752 frame_size= cfrm->size;
754 if(id != avctx->frame_number){
755 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
758 cfrm->size= cfrm->id= 0;
759 frame_4cc= AV_RL32("pfrm");
764 frame_size= buf_size - 12;
767 temp= f->current_picture;
768 f->current_picture= f->last_picture;
769 f->last_picture= temp;
771 p= &f->current_picture;
772 avctx->coded_frame= p;
774 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
777 avctx->release_buffer(avctx, p);
780 if(avctx->get_buffer(avctx, p) < 0){
781 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
785 if(frame_4cc == AV_RL32("ifr2")){
786 p->pict_type= FF_I_TYPE;
787 if(decode_i2_frame(f, buf-4, frame_size) < 0)
789 }else if(frame_4cc == AV_RL32("ifrm")){
790 p->pict_type= FF_I_TYPE;
791 if(decode_i_frame(f, buf, frame_size) < 0)
793 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
794 p->pict_type= FF_P_TYPE;
795 if(decode_p_frame(f, buf, frame_size) < 0)
797 }else if(frame_4cc == AV_RL32("snd_")){
798 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
800 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
803 p->key_frame= p->pict_type == FF_I_TYPE;
806 *data_size = sizeof(AVPicture);
814 static av_cold void common_init(AVCodecContext *avctx){
815 FourXContext * const f = avctx->priv_data;
817 dsputil_init(&f->dsp, avctx);
822 static av_cold int decode_init(AVCodecContext *avctx){
823 FourXContext * const f = avctx->priv_data;
825 if(avctx->extradata_size != 4 || !avctx->extradata) {
826 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
830 f->version= AV_RL32(avctx->extradata)>>16;
834 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
835 else avctx->pix_fmt= PIX_FMT_BGR555;
841 static av_cold int decode_end(AVCodecContext *avctx){
842 FourXContext * const f = avctx->priv_data;
845 av_freep(&f->bitstream_buffer);
846 f->bitstream_buffer_size=0;
847 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
848 av_freep(&f->cfrm[i].data);
849 f->cfrm[i].allocated_size= 0;
851 free_vlc(&f->pre_vlc);
852 if(f->current_picture.data[0])
853 avctx->release_buffer(avctx, &f->current_picture);
854 if(f->last_picture.data[0])
855 avctx->release_buffer(avctx, &f->last_picture);
860 AVCodec fourxm_decoder = {
864 sizeof(FourXContext),
870 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),