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_")){