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;
386 bitstream_size=
AV_RL32(buf+8);
387 wordstream_size=
AV_RL32(buf+12);
388 bytestream_size=
AV_RL32(buf+16);
391 bitstream_size =
AV_RL16(buf-4);
392 wordstream_size=
AV_RL16(buf-2);
393 bytestream_size=
FFMAX(length - bitstream_size - wordstream_size, 0);
396 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
397 || bitstream_size > (1<<26)
398 || bytestream_size > (1<<26)
399 || wordstream_size > (1<<26)
402 bitstream_size+ bytestream_size+ wordstream_size - length);
413 wordstream_offset = extra + bitstream_size;
414 bytestream_offset = extra + bitstream_size + wordstream_size;
421 for(x=0; x<
width; x+=8){
436 int code, i, j,
level, val;
486 block[i][0] += 0x80*8*8;
501 DCTELEM *temp=
block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
502 int cb=
block[4][x + 8*y];
503 int cr=
block[5][x + 8*y];
504 int cg= (cb + cr)>>1;
510 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
512 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
514 dst[
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
516 dst[1+
stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
519 dst += 2*stride - 2*8;
540 uint8_t len_tab[257];
543 const uint8_t *ptr= buf;
546 memset(frequency, 0,
sizeof(frequency));
547 memset(up, -1,
sizeof(up));
554 for(i=start; i<=end; i++){
555 frequency[i]= *ptr++;
564 while((ptr - buf)&3) ptr++;
566 for(j=257; j<512; j++){
567 int min_freq[2]= {256*256, 256*256};
568 int smallest[2]= {0, 0};
571 if(frequency[i] == 0)
continue;
572 if(frequency[i] < min_freq[1]){
573 if(frequency[i] < min_freq[0]){
574 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
575 min_freq[0]= frequency[i];smallest[0]= i;
577 min_freq[1]= frequency[i];smallest[1]= i;
581 if(min_freq[1] == 256*256)
break;
583 frequency[j]= min_freq[0] + min_freq[1];
584 flag[ smallest[0] ]= 0;
585 flag[ smallest[1] ]= 1;
587 up[ smallest[1] ]= j;
588 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
591 for(j=0; j<257; j++){
596 for(node= j; up[node] != -1; node= up[node]){
597 bits += flag[node]<<
len;
615 int blue = 2*(c0&0x001F) + (c1&0x001F);
616 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
617 int red = 2*(c0>>10) + (c1>>10);
618 return red/3*1024 + green/3*32 + blue/3;
625 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
630 if(length < mbs * 8) {
636 for(y=0; y<
height; y+=16){
637 for(x=0; x<
width; x+=16){
639 memset(color, 0,
sizeof(color));
641 color[0]= bytestream2_get_le16u(&g3);
642 color[1]= bytestream2_get_le16u(&g3);
647 color[2]=
mix(color[0], color[1]);
648 color[3]=
mix(color[1], color[0]);
650 bits= bytestream2_get_le32u(&g3);
651 for(y2=0; y2<16; y2++){
652 for(x2=0; x2<16; x2++){
653 int index= 2*(x2>>2) + 8*(y2>>2);
669 const unsigned int bitstream_size=
AV_RL32(buf);
671 unsigned int prestream_size;
672 const uint8_t *prestream;
674 if (bitstream_size > (1 << 26))
677 if (length < bitstream_size + 12) {
682 token_count =
AV_RL32(buf + bitstream_size + 8);
683 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
684 prestream = buf + bitstream_size + 12;
686 if(prestream_size + bitstream_size + 12 != length
687 || prestream_size > (1<<26)){
700 prestream_size= length + buf - prestream;
711 for(y=0; y<
height; y+=16){
712 for(x=0; x<
width; x+=16){
727 void *
data,
int *data_size,
730 const uint8_t *buf = avpkt->
data;
731 int buf_size = avpkt->
size;
735 int i, frame_4cc, frame_size;
738 if(buf_size !=
AV_RL32(buf+4)+8 || buf_size < 20){
742 if(frame_4cc ==
AV_RL32(
"cfrm")){
744 const int data_size= buf_size - 20;
746 const int whole_size=
AV_RL32(buf+16);
755 if(f->
cfrm[i].
id ==
id)
break;
756 if(f->
cfrm[i].
size == 0 ) free_index= i;
759 if(i>=CFRAME_BUFFER_COUNT){
771 memcpy(cfrm->
data + cfrm->
size, buf+20, data_size);
772 cfrm->
size += data_size;
774 if(cfrm->
size >= whole_size){
776 frame_size= cfrm->
size;
791 frame_size= buf_size - 12;
812 if(frame_4cc ==
AV_RL32(
"ifr2")){
816 }
else if(frame_4cc ==
AV_RL32(
"ifrm")){
820 }
else if(frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")){
833 }
else if(frame_4cc ==
AV_RL32(
"snd_")){