36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
39 #define CFRAME_BUFFER_COUNT 100
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}
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}
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,
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)
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];
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];
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];
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];
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;
244 block_type_vlc[0][i].
table= table[i];
255 for(i=0; i<256; i++){
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;
323 const int h= 1<<log2h;
326 uint16_t *end= start + stride*(f->
avctx->
height-h+1) - (1<<log2w);
328 assert(code>=0 && code<=6);
331 src += f->
mv[bytestream2_get_byte(&f->
g)];
332 if(start > src || src > end){
336 mcdc(dst, src, log2w, h, stride, 1, 0);
340 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), 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 if (start > src || src > end) {
350 mcdc(dst, src, log2w, h, stride, 1, 0);
352 src += f->
mv[bytestream2_get_byte(&f->
g)];
353 if(start > src || src > end){
357 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->
g2));
359 if (start > src || src > end) {
363 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->
g2));
366 dst[0] = bytestream2_get_le16(&f->
g2);
367 dst[1] = bytestream2_get_le16(&f->
g2);
369 dst[0 ] = bytestream2_get_le16(&f->
g2);
370 dst[
stride] = bytestream2_get_le16(&f->
g2);
382 unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset;
388 bitstream_size=
AV_RL32(buf+8);
389 wordstream_size=
AV_RL32(buf+12);
390 bytestream_size=
AV_RL32(buf+16);
393 bitstream_size =
AV_RL16(buf-4);
394 wordstream_size=
AV_RL16(buf-2);
395 bytestream_size=
FFMAX(length - bitstream_size - wordstream_size, 0);
398 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
399 || bitstream_size > (1<<26)
400 || bytestream_size > (1<<26)
401 || wordstream_size > (1<<26)
404 bitstream_size+ bytestream_size+ wordstream_size - length);
415 wordstream_offset = extra + bitstream_size;
416 bytestream_offset = extra + bitstream_size + wordstream_size;
423 for(x=0; x<
width; x+=8){
438 int code, i, j,
level, val;
488 block[i][0] += 0x80*8*8;
503 DCTELEM *temp=
block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
504 int cb=
block[4][x + 8*y];
505 int cr=
block[5][x + 8*y];
506 int cg= (cb + cr)>>1;
512 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
514 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
516 dst[
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
518 dst[1+
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
521 dst += 2*stride - 2*8;
539 const uint8_t *
const buf,
545 uint8_t len_tab[257];
548 const uint8_t *ptr= buf;
551 memset(frequency, 0,
sizeof(frequency));
552 memset(up, -1,
sizeof(up));
559 len -= end - start + 1;
561 if (end < start || len < 0)
564 for(i=start; i<=end; i++){
565 frequency[i]= *ptr++;
577 while((ptr - buf)&3) ptr++;
579 for(j=257; j<512; j++){
580 int min_freq[2]= {256*256, 256*256};
581 int smallest[2]= {0, 0};
584 if(frequency[i] == 0)
continue;
585 if(frequency[i] < min_freq[1]){
586 if(frequency[i] < min_freq[0]){
587 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
588 min_freq[0]= frequency[i];smallest[0]= i;
590 min_freq[1]= frequency[i];smallest[1]= i;
594 if(min_freq[1] == 256*256)
break;
596 frequency[j]= min_freq[0] + min_freq[1];
597 flag[ smallest[0] ]= 0;
598 flag[ smallest[1] ]= 1;
600 up[ smallest[1] ]= j;
601 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
604 for(j=0; j<257; j++){
609 for(node= j; up[node] != -1; node= up[node]){
610 bits += flag[node]<<
len;
628 int blue = 2*(c0&0x001F) + (c1&0x001F);
629 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
630 int red = 2*(c0>>10) + (c1>>10);
631 return red/3*1024 + green/3*32 + blue/3;
638 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
643 if(length < mbs * 8) {
649 for(y=0; y<
height; y+=16){
650 for(x=0; x<
width; x+=16){
652 memset(color, 0,
sizeof(color));
654 color[0]= bytestream2_get_le16u(&g3);
655 color[1]= bytestream2_get_le16u(&g3);
660 color[2]=
mix(color[0], color[1]);
661 color[3]=
mix(color[1], color[0]);
663 bits= bytestream2_get_le32u(&g3);
664 for(y2=0; y2<16; y2++){
665 for(x2=0; x2<16; x2++){
666 int index= 2*(x2>>2) + 8*(y2>>2);
682 const unsigned int bitstream_size=
AV_RL32(buf);
684 unsigned int prestream_size;
685 const uint8_t *prestream;
687 if (bitstream_size > (1 << 26))
690 if (length < bitstream_size + 12) {
695 token_count =
AV_RL32(buf + bitstream_size + 8);
696 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
697 prestream = buf + bitstream_size + 12;
699 if(prestream_size + bitstream_size + 12 != length
700 || prestream_size > (1<<26)){
713 prestream_size= length + buf - prestream;
724 for(y=0; y<
height; y+=16){
725 for(x=0; x<
width; x+=16){
740 void *
data,
int *data_size,
743 const uint8_t *buf = avpkt->
data;
744 int buf_size = avpkt->
size;
748 int i, frame_4cc, frame_size;
755 "Dimensions non-multiple of 16 are invalid.\n");
759 if (buf_size <
AV_RL32(buf + 4) + 8) {
761 "size mismatch %d %d\n", buf_size,
AV_RL32(buf + 4));
766 if(frame_4cc ==
AV_RL32(
"cfrm")){
769 const int data_size = buf_size - 20;
776 whole_size =
AV_RL32(buf + 16);
784 if(f->
cfrm[i].
id ==
id)
break;
785 if(f->
cfrm[i].
size == 0 ) free_index= i;
788 if(i>=CFRAME_BUFFER_COUNT){
800 memcpy(cfrm->
data + cfrm->
size, buf+20, data_size);
801 cfrm->
size += data_size;
803 if(cfrm->
size >= whole_size){
805 frame_size= cfrm->
size;
820 frame_size= buf_size - 12;
841 if(frame_4cc ==
AV_RL32(
"ifr2")){
845 }
else if(frame_4cc ==
AV_RL32(
"ifrm")){
849 }
else if(frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")){
862 }
else if(frame_4cc ==
AV_RL32(
"snd_")){
int(* get_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of each frame to get a buffer for it.
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const uint8_t ff_zigzag_direct[64]
static void idct(DCTELEM block[64])
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
AVFrame * coded_frame
the picture in the bitstream
static av_cold void init_vlcs(FourXContext *f)
AVCodec ff_fourxm_decoder
static VLC block_type_vlc[2][4]
#define DECLARE_ALIGNED(n, t, v)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static void init_mv(FourXContext *f)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
unsigned int allocated_size
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static const uint8_t block_type_tab[2][4][8][2]
static av_cold int decode_init(AVCodecContext *avctx)
bitstream reader API header.
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
static int init(AVCodecParserContext *s)
static int decode_i_block(FourXContext *f, DCTELEM *block)
decode block and dequantize.
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static int decode_i_mb(FourXContext *f)
struct CFrameBuffer CFrameBuffer
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride)
#define LE_CENTRIC_MUL(dst, src, scale, dc)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void av_log(void *avcl, int level, const char *fmt,...)
static const uint8_t size2index[4][4]
const char * name
Name of the codec implementation.
#define CODEC_FLAG_EMU_EDGE
Don't draw edges.
static av_always_inline void emms_c(void)
Empty mmx state.
#define CFRAME_BUFFER_COUNT
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int len)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
int width
picture width / height.
static void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
#define INIT_VLC_USE_NEW_STATIC
static const int8_t mv[256][2]
struct FourXContext FourXContext
static void idct_put(FourXContext *f, int x, int y)
static int mix(int c0, int c1)
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
static av_cold void common_init(AVCodecContext *avctx)
main external API structure.
static void close(AVCodecParserContext *s)
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
struct AVPicture AVPicture
four components are given, that's all.
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
static const uint8_t dequant_table[64]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
unsigned int bitstream_buffer_size
static av_cold int decode_end(AVCodecContext *avctx)
static const uint16_t scale[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void(* clear_blocks)(DCTELEM *blocks)
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
GetBitContext pre_gb
ac/dc prefix
static const uint8_t color[]
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
int frame_number
audio or video frame number
#define BLOCK_TYPE_VLC_BITS
#define MULTIPLY(var, const)
void ff_free_vlc(VLC *vlc)