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 mcdc(dst, src, log2w, h, stride, 1, 0);
348 src += f->
mv[bytestream2_get_byte(&f->
g)];
349 if(start > src || src > end){
353 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->
g2));
355 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->
g2));
358 dst[0] = bytestream2_get_le16(&f->
g2);
359 dst[1] = bytestream2_get_le16(&f->
g2);
361 dst[0 ] = bytestream2_get_le16(&f->
g2);
362 dst[
stride] = bytestream2_get_le16(&f->
g2);
374 unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset;
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)
394 bitstream_size+ bytestream_size+ wordstream_size - length);
405 wordstream_offset = extra + bitstream_size;
406 bytestream_offset = extra + bitstream_size + wordstream_size;
413 for(x=0; x<
width; x+=8){
428 int code, i, j,
level, val;
478 block[i][0] += 0x80*8*8;
493 DCTELEM *temp=
block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
494 int cb=
block[4][x + 8*y];
495 int cr=
block[5][x + 8*y];
496 int cg= (cb + cr)>>1;
502 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
504 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
506 dst[
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
508 dst[1+
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
511 dst += 2*stride - 2*8;
532 uint8_t len_tab[257];
535 const uint8_t *ptr= buf;
538 memset(frequency, 0,
sizeof(frequency));
539 memset(up, -1,
sizeof(up));
546 for(i=start; i<=end; i++){
547 frequency[i]= *ptr++;
556 while((ptr - buf)&3) ptr++;
558 for(j=257; j<512; j++){
559 int min_freq[2]= {256*256, 256*256};
560 int smallest[2]= {0, 0};
563 if(frequency[i] == 0)
continue;
564 if(frequency[i] < min_freq[1]){
565 if(frequency[i] < min_freq[0]){
566 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
567 min_freq[0]= frequency[i];smallest[0]= i;
569 min_freq[1]= frequency[i];smallest[1]= i;
573 if(min_freq[1] == 256*256)
break;
575 frequency[j]= min_freq[0] + min_freq[1];
576 flag[ smallest[0] ]= 0;
577 flag[ smallest[1] ]= 1;
579 up[ smallest[1] ]= j;
580 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
583 for(j=0; j<257; j++){
588 for(node= j; up[node] != -1; node= up[node]){
589 bits += flag[node]<<
len;
607 int blue = 2*(c0&0x001F) + (c1&0x001F);
608 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
609 int red = 2*(c0>>10) + (c1>>10);
610 return red/3*1024 + green/3*32 + blue/3;
617 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
622 if(length < mbs * 8) {
628 for(y=0; y<
height; y+=16){
629 for(x=0; x<
width; x+=16){
631 memset(color, 0,
sizeof(color));
633 color[0]= bytestream2_get_le16u(&g3);
634 color[1]= bytestream2_get_le16u(&g3);
639 color[2]=
mix(color[0], color[1]);
640 color[3]=
mix(color[1], color[0]);
642 bits= bytestream2_get_le32u(&g3);
643 for(y2=0; y2<16; y2++){
644 for(x2=0; x2<16; x2++){
645 int index= 2*(x2>>2) + 8*(y2>>2);
661 const unsigned int bitstream_size=
AV_RL32(buf);
663 unsigned int prestream_size;
664 const uint8_t *prestream;
666 if (length < bitstream_size + 12) {
671 token_count =
AV_RL32(buf + bitstream_size + 8);
672 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
673 prestream = buf + bitstream_size + 12;
675 if(prestream_size + bitstream_size + 12 != length
676 || bitstream_size > (1<<26)
677 || prestream_size > (1<<26)){
686 prestream_size= length + buf - prestream;
697 for(y=0; y<
height; y+=16){
698 for(x=0; x<
width; x+=16){
713 void *
data,
int *data_size,
716 const uint8_t *buf = avpkt->
data;
717 int buf_size = avpkt->
size;
721 int i, frame_4cc, frame_size;
724 if(buf_size !=
AV_RL32(buf+4)+8 || buf_size < 20){
728 if(frame_4cc ==
AV_RL32(
"cfrm")){
730 const int data_size= buf_size - 20;
732 const int whole_size=
AV_RL32(buf+16);
741 if(f->
cfrm[i].
id ==
id)
break;
742 if(f->
cfrm[i].
size == 0 ) free_index= i;
745 if(i>=CFRAME_BUFFER_COUNT){
757 memcpy(cfrm->
data + cfrm->
size, buf+20, data_size);
758 cfrm->
size += data_size;
760 if(cfrm->
size >= whole_size){
762 frame_size= cfrm->
size;
774 frame_size= buf_size - 12;
795 if(frame_4cc ==
AV_RL32(
"ifr2")){
799 }
else if(frame_4cc ==
AV_RL32(
"ifrm")){
803 }
else if(frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")){
815 }
else if(frame_4cc ==
AV_RL32(
"snd_")){