37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
40 #define CFRAME_BUFFER_COUNT 100
45 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
47 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
55 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
73 static const int8_t
mv[256][2] = {
74 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
111 16, 15, 13, 19, 24, 31, 28, 17,
112 17, 23, 25, 31, 36, 63, 45, 21,
113 18, 24, 27, 37, 52, 59, 49, 20,
114 16, 28, 34, 40, 60, 80, 51, 20,
115 18, 31, 48, 66, 68, 86, 56, 21,
116 19, 38, 56, 59, 64, 64, 48, 20,
117 27, 48, 55, 55, 56, 51, 35, 15,
118 20, 35, 34, 32, 31, 22, 15, 8,
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
159 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160 int tmp10, tmp11, tmp12, tmp13;
161 int z5, z10, z11, z12, z13;
165 for (i = 0; i < 8; i++) {
166 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
169 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
172 tmp0 = tmp10 + tmp13;
173 tmp3 = tmp10 - tmp13;
174 tmp1 = tmp11 + tmp12;
175 tmp2 = tmp11 - tmp12;
177 z13 = block[8 * 5 + i] + block[8 * 3 + i];
178 z10 = block[8 * 5 + i] - block[8 * 3 + i];
179 z11 = block[8 * 1 + i] + block[8 * 7 + i];
180 z12 = block[8 * 1 + i] - block[8 * 7 + i];
193 temp[8 * 0 + i] = tmp0 + tmp7;
194 temp[8 * 7 + i] = tmp0 - tmp7;
195 temp[8 * 1 + i] = tmp1 + tmp6;
196 temp[8 * 6 + i] = tmp1 - tmp6;
197 temp[8 * 2 + i] = tmp2 + tmp5;
198 temp[8 * 5 + i] = tmp2 - tmp5;
199 temp[8 * 4 + i] = tmp3 + tmp4;
200 temp[8 * 3 + i] = tmp3 - tmp4;
203 for (i = 0; i < 8 * 8; i += 8) {
204 tmp10 = temp[0 + i] + temp[4 + i];
205 tmp11 = temp[0 + i] - temp[4 + i];
207 tmp13 = temp[2 + i] + temp[6 + i];
210 tmp0 = tmp10 + tmp13;
211 tmp3 = tmp10 - tmp13;
212 tmp1 = tmp11 + tmp12;
213 tmp2 = tmp11 - tmp12;
215 z13 = temp[5 + i] + temp[3 + i];
216 z10 = temp[5 + i] - temp[3 + i];
217 z11 = temp[1 + i] + temp[7 + i];
218 z12 = temp[1 + i] - temp[7 + i];
231 block[0 + i] = (tmp0 + tmp7) >> 6;
232 block[7 + i] = (tmp0 - tmp7) >> 6;
233 block[1 + i] = (tmp1 + tmp6) >> 6;
234 block[6 + i] = (tmp1 - tmp6) >> 6;
235 block[2 + i] = (tmp2 + tmp5) >> 6;
236 block[5 + i] = (tmp2 - tmp5) >> 6;
237 block[4 + i] = (tmp3 + tmp4) >> 6;
238 block[3 + i] = (tmp3 - tmp4) >> 6;
247 for (i = 0; i < 2; i++) {
248 for (j = 0; j < 4; j++) {
249 block_type_vlc[i][j].
table = table[i][j];
263 for (i = 0; i < 256; i++) {
265 f->
mv[i] =
mv[i][0] +
mv[i][1] * linesize / 2;
267 f->
mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
274 unsigned tmpval = AV_RN32(src); \
275 tmpval = (tmpval << 16) | (tmpval >> 16); \
276 tmpval = tmpval * (scale) + (dc); \
277 tmpval = (tmpval << 16) | (tmpval >> 16); \
278 AV_WN32A(dst, tmpval); \
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
283 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284 AV_WN32A(dst, tmpval); \
288 static inline void mcdc(uint16_t *dst,
const uint16_t *
src,
int log2w,
296 for (i = 0; i < h; i++) {
297 dst[0] = scale * src[0] +
dc;
304 for (i = 0; i < h; i++) {
312 for (i = 0; i < h; i++) {
321 for (i = 0; i < h; i++) {
337 int log2w,
int log2h,
int stride)
340 const int h = 1 << log2h;
345 uint16_t *
end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
350 av_assert0(code >= 0 && code <= 6 && log2w >= 0);
354 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
357 src + (stride << log2h),
358 log2w, log2h, stride);
359 }
else if (code == 2) {
361 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
365 log2w, log2h, stride);
366 }
else if (code == 6) {
372 dst[0] = bytestream2_get_le16u(&f->
g2);
373 dst[1] = bytestream2_get_le16u(&f->
g2);
375 dst[0] = bytestream2_get_le16u(&f->
g2);
376 dst[
stride] = bytestream2_get_le16u(&f->
g2);
387 src += f->
mv[bytestream2_get_byte(&f->
g)];
388 }
else if (code == 3 && f->
version >= 2) {
390 }
else if (code == 4) {
391 src += f->
mv[bytestream2_get_byte(&f->
g)];
396 dc = bytestream2_get_le16(&f->
g2);
397 }
else if (code == 5) {
404 dc = bytestream2_get_le16(&f->
g2);
407 if (start > src || src >
end) {
412 mcdc(dst, src, log2w, h, stride, scale, dc);
423 uint16_t *dst = (uint16_t *)frame->
data[0];
426 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427 bytestream_offset, wordstream_offset;
445 bitstream_size =
AV_RL32(buf + 8);
446 wordstream_size =
AV_RL32(buf + 12);
447 bytestream_size =
AV_RL32(buf + 16);
450 bitstream_size =
AV_RL16(buf - 4);
451 wordstream_size =
AV_RL16(buf - 2);
452 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
455 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
456 bytestream_size > length - bitstream_size ||
457 wordstream_size > length - bytestream_size - bitstream_size ||
458 extra > length - bytestream_size - bitstream_size - wordstream_size) {
460 bitstream_size+ bytestream_size+ wordstream_size - length);
474 wordstream_offset = extra + bitstream_size;
475 bytestream_offset = extra + bitstream_size + wordstream_size;
477 length - wordstream_offset);
479 length - bytestream_offset);
483 for (y = 0; y <
height; y += 8) {
484 for (x = 0; x <
width; x += 8)
558 uint16_t *dst = ((uint16_t*)frame->
data[0]) + y * stride + x;
560 for (i = 0; i < 4; i++) {
561 block[i][0] += 0x80 * 8 * 8;
566 for (i = 4; i < 6; i++)
574 for (y = 0; y < 8; y++) {
575 for (x = 0; x < 8; x++) {
576 int16_t *
temp =
block[(x >> 2) + 2 * (y >> 2)] +
577 2 * (x & 3) + 2 * 8 * (y & 3);
580 int cg = (cb +
cr) >> 1;
586 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595 dst += 2 * stride - 2 * 8;
606 for (i = 0; i < 6; i++)
617 int frequency[512] = { 0 };
624 const uint8_t *ptr_end = buf + buf_size;
627 memset(up, -1,
sizeof(up));
634 if (ptr_end - ptr <
FFMAX(end - start + 1, 0) + 1) {
639 for (i = start; i <=
end; i++)
640 frequency[i] = *ptr++;
649 while ((ptr - buf) & 3)
657 for (j = 257; j < 512; j++) {
658 int min_freq[2] = { 256 * 256, 256 * 256 };
659 int smallest[2] = { 0, 0 };
661 for (i = 0; i < j; i++) {
662 if (frequency[i] == 0)
664 if (frequency[i] < min_freq[1]) {
665 if (frequency[i] < min_freq[0]) {
666 min_freq[1] = min_freq[0];
667 smallest[1] = smallest[0];
668 min_freq[0] = frequency[i];
671 min_freq[1] = frequency[i];
676 if (min_freq[1] == 256 * 256)
679 frequency[j] = min_freq[0] + min_freq[1];
680 flag[smallest[0]] = 0;
681 flag[smallest[1]] = 1;
684 frequency[smallest[0]] = frequency[smallest[1]] = 0;
687 for (j = 0; j < 257; j++) {
690 for (node = j; up[node] != -1; node = up[node]) {
696 "vlc length overflow\n");
712 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
713 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
714 int red = 2 * (c0 >> 10) + (c1 >> 10);
715 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
723 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
724 uint16_t *dst = (uint16_t*)frame->
data[0];
726 const uint8_t *buf_end = buf + length;
729 if (length < mbs * 8) {
735 for (y = 0; y <
height; y += 16) {
736 for (x = 0; x <
width; x += 16) {
738 if (buf_end - buf < 8)
741 color[0] = bytestream2_get_le16u(&g3);
742 color[1] = bytestream2_get_le16u(&g3);
744 if (color[0] & 0x8000)
746 if (color[1] & 0x8000)
749 color[2] =
mix(color[0], color[1]);
750 color[3] =
mix(color[1], color[0]);
752 bits = bytestream2_get_le32u(&g3);
753 for (y2 = 0; y2 < 16; y2++) {
754 for (x2 = 0; x2 < 16; x2++) {
755 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
772 const unsigned int bitstream_size =
AV_RL32(buf);
773 unsigned int prestream_size;
776 if (bitstream_size > (1 << 26))
779 if (length < bitstream_size + 12) {
784 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
785 prestream = buf + bitstream_size + 12;
787 if (prestream_size + bitstream_size + 12 != length
788 || prestream_size > (1 << 26)) {
790 prestream_size, bitstream_size, length);
804 prestream_size = length + buf - prestream;
818 for (y = 0; y <
height; y += 16) {
819 for (x = 0; x <
width; x += 16) {
837 int buf_size = avpkt->
size;
845 if (buf_size <
AV_RL32(buf + 4) + 8) {
853 if (frame_4cc ==
AV_RL32(
"cfrm")) {
856 const int data_size = buf_size - 20;
865 whole_size =
AV_RL32(buf + 16);
867 if (data_size < 0 || whole_size < 0) {
884 if (i >= CFRAME_BUFFER_COUNT) {
901 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
902 cfrm->
size += data_size;
904 if (cfrm->
size >= whole_size) {
906 frame_size = cfrm->
size;
915 cfrm->
size = cfrm->
id = 0;
921 frame_size = buf_size - 12;
932 if (frame_4cc ==
AV_RL32(
"ifr2")) {
938 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
944 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
950 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {