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 }
110 16, 15, 13, 19, 24, 31, 28, 17,
111 17, 23, 25, 31, 36, 63, 45, 21,
112 18, 24, 27, 37, 52, 59, 49, 20,
113 16, 28, 34, 40, 60, 80, 51, 20,
114 18, 31, 48, 66, 68, 86, 56, 21,
115 19, 38, 56, 59, 64, 64, 48, 20,
116 27, 48, 55, 55, 56, 51, 35, 15,
117 20, 35, 34, 32, 31, 22, 15, 8,
149 #define FIX_1_082392200 70936
150 #define FIX_1_414213562 92682
151 #define FIX_1_847759065 121095
152 #define FIX_2_613125930 171254
154 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
158 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
159 int tmp10, tmp11, tmp12, tmp13;
160 int z5, z10, z11, z12, z13;
164 for (i = 0; i < 8; i++) {
165 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
166 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
168 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
171 tmp0 = tmp10 + tmp13;
172 tmp3 = tmp10 - tmp13;
173 tmp1 = tmp11 + tmp12;
174 tmp2 = tmp11 - tmp12;
176 z13 = block[8 * 5 + i] + block[8 * 3 + i];
177 z10 = block[8 * 5 + i] - block[8 * 3 + i];
178 z11 = block[8 * 1 + i] + block[8 * 7 + i];
179 z12 = block[8 * 1 + i] - block[8 * 7 + i];
192 temp[8 * 0 + i] = tmp0 + tmp7;
193 temp[8 * 7 + i] = tmp0 - tmp7;
194 temp[8 * 1 + i] = tmp1 + tmp6;
195 temp[8 * 6 + i] = tmp1 - tmp6;
196 temp[8 * 2 + i] = tmp2 + tmp5;
197 temp[8 * 5 + i] = tmp2 - tmp5;
198 temp[8 * 4 + i] = tmp3 + tmp4;
199 temp[8 * 3 + i] = tmp3 - tmp4;
202 for (i = 0; i < 8 * 8; i += 8) {
203 tmp10 = temp[0 + i] + temp[4 + i];
204 tmp11 = temp[0 + i] - temp[4 + i];
206 tmp13 = temp[2 + i] + temp[6 + i];
209 tmp0 = tmp10 + tmp13;
210 tmp3 = tmp10 - tmp13;
211 tmp1 = tmp11 + tmp12;
212 tmp2 = tmp11 - tmp12;
214 z13 = temp[5 + i] + temp[3 + i];
215 z10 = temp[5 + i] - temp[3 + i];
216 z11 = temp[1 + i] + temp[7 + i];
217 z12 = temp[1 + i] - temp[7 + i];
230 block[0 + i] = (tmp0 + tmp7) >> 6;
231 block[7 + i] = (tmp0 - tmp7) >> 6;
232 block[1 + i] = (tmp1 + tmp6) >> 6;
233 block[6 + i] = (tmp1 - tmp6) >> 6;
234 block[2 + i] = (tmp2 + tmp5) >> 6;
235 block[5 + i] = (tmp2 - tmp5) >> 6;
236 block[4 + i] = (tmp3 + tmp4) >> 6;
237 block[3 + i] = (tmp3 - tmp4) >> 6;
246 for (i = 0; i < 2; i++) {
247 for (j = 0; j < 4; j++) {
248 block_type_vlc[i][j].
table = table[i][j];
262 for (i = 0; i < 256; i++) {
271 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
273 unsigned tmpval = AV_RN32(src); \
274 tmpval = (tmpval << 16) | (tmpval >> 16); \
275 tmpval = tmpval * (scale) + (dc); \
276 tmpval = (tmpval << 16) | (tmpval >> 16); \
277 AV_WN32A(dst, tmpval); \
280 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
282 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
283 AV_WN32A(dst, tmpval); \
287 static inline void mcdc(uint16_t *
dst,
const uint16_t *src,
int log2w,
295 for (i = 0; i < h; i++) {
296 dst[0] = scale * src[0] + dc;
303 for (i = 0; i < h; i++) {
311 for (i = 0; i < h; i++) {
320 for (i = 0; i < h; i++) {
336 int log2w,
int log2h,
int stride)
339 const int h = 1 << log2h;
344 uint16_t *
end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
353 src += f->
mv[bytestream2_get_byteu(&f->
g)];
354 if (start > src || src >
end) {
358 mcdc(dst, src, log2w, h, stride, 1, 0);
359 }
else if (code == 1) {
363 src + (stride << log2h), log2w, log2h, stride);
364 }
else if (code == 2) {
368 src + (1 << log2w), log2w, log2h, stride);
369 }
else if (code == 3 && f->
version < 2) {
370 mcdc(dst, src, log2w, h, stride, 1, 0);
371 }
else if (code == 4) {
376 src += f->
mv[bytestream2_get_byteu(&f->
g)];
377 if (start > src || src >
end) {
385 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->
g2));
386 }
else if (code == 5) {
391 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->
g2));
392 }
else if (code == 6) {
398 dst[0] = bytestream2_get_le16u(&f->
g2);
399 dst[1] = bytestream2_get_le16u(&f->
g2);
401 dst[0] = bytestream2_get_le16u(&f->
g2);
402 dst[
stride] = bytestream2_get_le16u(&f->
g2);
415 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
416 bytestream_offset, wordstream_offset;
422 bitstream_size =
AV_RL32(buf + 8);
423 wordstream_size =
AV_RL32(buf + 12);
424 bytestream_size =
AV_RL32(buf + 16);
427 bitstream_size =
AV_RL16(buf - 4);
428 wordstream_size =
AV_RL16(buf - 2);
429 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
432 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
433 bytestream_size > length - bitstream_size ||
434 wordstream_size > length - bytestream_size - bitstream_size ||
435 extra > length - bytestream_size - bitstream_size - wordstream_size) {
437 bitstream_size+ bytestream_size+ wordstream_size - length);
451 wordstream_offset = extra + bitstream_size;
452 bytestream_offset = extra + bitstream_size + wordstream_size;
454 length - wordstream_offset);
456 length - bytestream_offset);
460 for (y = 0; y <
height; y += 8) {
461 for (x = 0; x <
width; x += 8)
476 int code, i, j,
level, val;
529 for (i = 0; i < 4; i++) {
530 block[i][0] += 0x80 * 8 * 8;
535 for (i = 4; i < 6; i++)
543 for (y = 0; y < 8; y++) {
544 for (x = 0; x < 8; x++) {
546 2 * (x & 3) + 2 * 8 * (y & 3);
549 int cg = (cb +
cr) >> 1;
555 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
557 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
559 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
561 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst += 2 * stride - 2 * 8;
574 for (i = 0; i < 6; i++)
582 const uint8_t *
const buf,
int buf_size)
584 int frequency[512] = { 0 };
591 const uint8_t *ptr_end = buf + buf_size;
594 memset(up, -1,
sizeof(up));
601 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
603 for (i = start; i <=
end; i++)
604 frequency[i] = *ptr++;
613 while ((ptr - buf) & 3)
616 for (j = 257; j < 512; j++) {
617 int min_freq[2] = { 256 * 256, 256 * 256 };
618 int smallest[2] = { 0, 0 };
620 for (i = 0; i < j; i++) {
621 if (frequency[i] == 0)
623 if (frequency[i] < min_freq[1]) {
624 if (frequency[i] < min_freq[0]) {
625 min_freq[1] = min_freq[0];
626 smallest[1] = smallest[0];
627 min_freq[0] = frequency[i];
630 min_freq[1] = frequency[i];
635 if (min_freq[1] == 256 * 256)
638 frequency[j] = min_freq[0] + min_freq[1];
639 flag[smallest[0]] = 0;
640 flag[smallest[1]] = 1;
643 frequency[smallest[0]] = frequency[smallest[1]] = 0;
646 for (j = 0; j < 257; j++) {
649 for (node = j; up[node] != -1; node = up[node]) {
655 "vlc length overflow\n");
671 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
672 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
673 int red = 2 * (c0 >> 10) + (c1 >> 10);
674 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
682 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
685 const uint8_t *buf_end = buf + length;
688 if (length < mbs * 8) {
694 for (y = 0; y <
height; y += 16) {
695 for (x = 0; x <
width; x += 16) {
697 if (buf_end - buf < 8)
700 color[0] = bytestream2_get_le16u(&g3);
701 color[1] = bytestream2_get_le16u(&g3);
703 if (color[0] & 0x8000)
705 if (color[1] & 0x8000)
708 color[2] =
mix(color[0], color[1]);
709 color[3] =
mix(color[1], color[0]);
711 bits = bytestream2_get_le32u(&g3);
712 for (y2 = 0; y2 < 16; y2++) {
713 for (x2 = 0; x2 < 16; x2++) {
714 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
731 const unsigned int bitstream_size =
AV_RL32(buf);
732 unsigned int prestream_size;
735 if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
740 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
741 prestream = buf + bitstream_size + 12;
743 if (prestream_size + bitstream_size + 12 != length
744 || bitstream_size > (1 << 26)
745 || prestream_size > (1 << 26)) {
747 prestream_size, bitstream_size, length);
759 prestream_size = length + buf - prestream;
773 for (y = 0; y <
height; y += 16) {
774 for (x = 0; x <
width; x += 16) {
792 int buf_size = avpkt->
size;
801 if (buf_size !=
AV_RL32(buf + 4) + 8 || buf_size < 20)
805 if (frame_4cc ==
AV_RL32(
"cfrm")) {
807 const int data_size = buf_size - 20;
808 const int id =
AV_RL32(buf + 12);
809 const int whole_size =
AV_RL32(buf + 16);
812 if (data_size < 0 || whole_size < 0) {
834 if (i >= CFRAME_BUFFER_COUNT) {
851 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
852 cfrm->
size += data_size;
854 if (cfrm->
size >= whole_size) {
856 frame_size = cfrm->
size;
862 cfrm->
size = cfrm->
id = 0;
868 frame_size = buf_size - 12;
887 if (frame_4cc ==
AV_RL32(
"ifr2")) {
893 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
899 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
906 for (i=0; i<avctx->
height; i++)
915 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {