44 #define BLOCK_TYPE_VLC_BITS 5
45 #define ACDC_VLC_BITS 9
47 #define CFRAME_BUFFER_COUNT 100
52 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
54 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
58 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
62 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
68 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
80 static const int8_t
mv[256][2] = {
81 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
82 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
83 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
84 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
85 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
86 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
87 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
88 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
89 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
90 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
91 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
92 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
93 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
94 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
95 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
96 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
97 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
98 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
99 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
100 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
101 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
102 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
103 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
104 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
105 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
106 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
107 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
108 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
109 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
110 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
111 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
112 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
118 16, 15, 13, 19, 24, 31, 28, 17,
119 17, 23, 25, 31, 36, 63, 45, 21,
120 18, 24, 27, 37, 52, 59, 49, 20,
121 16, 28, 34, 40, 60, 80, 51, 20,
122 18, 31, 48, 66, 68, 86, 56, 21,
123 19, 38, 56, 59, 64, 64, 48, 20,
124 27, 48, 55, 55, 56, 51, 35, 15,
125 20, 35, 34, 32, 31, 22, 15, 8,
159 #define FIX_1_082392200 70936
160 #define FIX_1_414213562 92682
161 #define FIX_1_847759065 121095
162 #define FIX_2_613125930 171254
164 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
168 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
169 int tmp10, tmp11, tmp12, tmp13;
170 int z5, z10, z11, z12, z13;
174 for (
i = 0;
i < 8;
i++) {
181 tmp0 = tmp10 + tmp13;
182 tmp3 = tmp10 - tmp13;
183 tmp1 = tmp11 + tmp12;
184 tmp2 = tmp11 - tmp12;
202 temp[8 * 0 +
i] = tmp0 + tmp7;
203 temp[8 * 7 +
i] = tmp0 - tmp7;
204 temp[8 * 1 +
i] = tmp1 + tmp6;
205 temp[8 * 6 +
i] = tmp1 - tmp6;
206 temp[8 * 2 +
i] = tmp2 + tmp5;
207 temp[8 * 5 +
i] = tmp2 - tmp5;
208 temp[8 * 4 +
i] = tmp3 + tmp4;
209 temp[8 * 3 +
i] = tmp3 - tmp4;
212 for (
i = 0;
i < 8 * 8;
i += 8) {
219 tmp0 = tmp10 + tmp13;
220 tmp3 = tmp10 - tmp13;
221 tmp1 = tmp11 + tmp12;
222 tmp2 = tmp11 - tmp12;
240 block[0 +
i] = (tmp0 + tmp7) >> 6;
241 block[7 +
i] = (tmp0 - tmp7) >> 6;
242 block[1 +
i] = (tmp1 + tmp6) >> 6;
243 block[6 +
i] = (tmp1 - tmp6) >> 6;
244 block[2 +
i] = (tmp2 + tmp5) >> 6;
245 block[5 +
i] = (tmp2 - tmp5) >> 6;
246 block[4 +
i] = (tmp3 + tmp4) >> 6;
247 block[3 +
i] = (tmp3 - tmp4) >> 6;
256 for (
i = 0;
i < 2;
i++) {
257 for (j = 0; j < 4; j++) {
272 for (
i = 0;
i < 256;
i++) {
274 f->mv[
i] =
mv[
i][0] +
mv[
i][1] * linesize / 2;
276 f->mv[
i] = (
i & 15) - 8 + ((
i >> 4) - 8) * linesize / 2;
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
283 unsigned tmpval = AV_RN32(src); \
284 tmpval = (tmpval << 16) | (tmpval >> 16); \
285 tmpval = tmpval * (scale) + (dc); \
286 tmpval = (tmpval << 16) | (tmpval >> 16); \
287 AV_WN32A(dst, tmpval); \
290 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
292 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
293 AV_WN32A(dst, tmpval); \
297 static inline void mcdc(uint16_t *dst,
const uint16_t *
src,
int log2w,
305 for (
i = 0;
i <
h;
i++) {
313 for (
i = 0;
i <
h;
i++) {
321 for (
i = 0;
i <
h;
i++) {
330 for (
i = 0;
i <
h;
i++) {
346 int log2w,
int log2h,
int stride)
349 uint16_t *start, *end;
364 start =
f->last_frame_buffer;
365 end = start +
stride * (
f->avctx->height -
h + 1) - (1 << log2w);
374 }
else if (
code == 2) {
381 }
else if (
code == 6) {
387 dst[0] = bytestream2_get_le16u(&
f->g2);
388 dst[1] = bytestream2_get_le16u(&
f->g2);
390 dst[0] = bytestream2_get_le16u(&
f->g2);
391 dst[
stride] = bytestream2_get_le16u(&
f->g2);
402 src +=
f->mv[bytestream2_get_byte(&
f->g)];
403 }
else if (
code == 3 &&
f->version >= 2) {
405 }
else if (
code == 4) {
406 src +=
f->mv[bytestream2_get_byte(&
f->g)];
411 dc = bytestream2_get_le16(&
f->g2);
412 }
else if (
code == 5) {
419 dc = bytestream2_get_le16(&
f->g2);
422 if (start >
src ||
src > end) {
435 const int width =
f->avctx->width;
436 const int height =
f->avctx->height;
437 uint16_t *dst =
f->frame_buffer;
439 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
440 bytestream_offset, wordstream_offset;
443 src =
f->last_frame_buffer;
445 if (
f->version > 1) {
449 bitstream_size =
AV_RL32(buf + 8);
450 wordstream_size =
AV_RL32(buf + 12);
451 bytestream_size =
AV_RL32(buf + 16);
454 bitstream_size =
AV_RL16(buf - 4);
455 wordstream_size =
AV_RL16(buf - 2);
456 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
459 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
460 bytestream_size > length - bitstream_size ||
461 wordstream_size > length - bytestream_size - bitstream_size ||
462 extra > length - bytestream_size - bitstream_size - wordstream_size) {
463 av_log(
f->avctx,
AV_LOG_ERROR,
"lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
464 bitstream_size+ bytestream_size+ wordstream_size - length);
470 if (!
f->bitstream_buffer)
472 f->bbdsp.bswap_buf(
f->bitstream_buffer, (
const uint32_t *) (buf + extra),
476 wordstream_offset = extra + bitstream_size;
477 bytestream_offset = extra + bitstream_size + wordstream_size;
479 length - wordstream_offset);
481 length - bytestream_offset);
485 for (y = 0; y <
height; y += 8) {
486 for (x = 0; x <
width; x += 8)
561 int16_t (*
block)[64] =
f->block;
564 uint16_t *dst =
f->frame_buffer + y *
stride + x;
566 for (
i = 0;
i < 4;
i++) {
567 block[
i][0] += 0x80 * 8 * 8;
572 for (
i = 4;
i < 6;
i++)
580 for (y = 0; y < 8; y++) {
581 for (x = 0; x < 8; x++) {
582 int16_t *
temp =
block[(x >> 2) + 2 * (y >> 2)] +
583 2 * (x & 3) + 2 * 8 * (y & 3);
586 int cg = (
cb +
cr) >> 1;
592 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
594 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
596 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
598 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
601 dst += 2 *
stride - 2 * 8;
610 f->bdsp.clear_blocks(
f->block[0]);
612 for (
i = 0;
i < 6;
i++)
620 const uint8_t *
const buf,
623 int frequency[512] = { 0 };
626 uint8_t len_tab[257];
629 const uint8_t *ptr = buf;
630 const uint8_t *ptr_end = buf + buf_size;
633 memset(up, -1,
sizeof(up));
640 if (ptr_end - ptr <
FFMAX(end - start + 1, 0) + 1) {
645 for (
i = start;
i <= end;
i++)
646 frequency[
i] = *ptr++;
655 while ((ptr - buf) & 3)
663 for (j = 257; j < 512; j++) {
664 int min_freq[2] = { 256 * 256, 256 * 256 };
665 int smallest[2] = { 0, 0 };
667 for (
i = 0;
i < j;
i++) {
668 if (frequency[
i] == 0)
670 if (frequency[
i] < min_freq[1]) {
671 if (frequency[
i] < min_freq[0]) {
672 min_freq[1] = min_freq[0];
673 smallest[1] = smallest[0];
674 min_freq[0] = frequency[
i];
677 min_freq[1] = frequency[
i];
682 if (min_freq[1] == 256 * 256)
685 frequency[j] = min_freq[0] + min_freq[1];
686 flag[smallest[0]] = 0;
687 flag[smallest[1]] = 1;
690 frequency[smallest[0]] = frequency[smallest[1]] = 0;
693 for (j = 0; j < 257; j++) {
696 for (node = j; up[node] != -1; node = up[node]) {
702 "vlc length overflow\n");
719 int blue = 2 * (c0 & 0x001F) + (
c1 & 0x001F);
720 int green = (2 * (c0 & 0x03E0) + (
c1 & 0x03E0)) >> 5;
721 int red = 2 * (c0 >> 10) + (
c1 >> 10);
722 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
728 const int width =
f->avctx->width;
729 const int height =
f->avctx->height;
731 uint16_t *dst =
f->frame_buffer;
732 const uint8_t *buf_end = buf + length;
735 if (length < mbs * 8) {
741 for (y = 0; y <
height; y += 16) {
742 for (x = 0; x <
width; x += 16) {
744 if (buf_end - buf < 8)
747 color[0] = bytestream2_get_le16u(&g3);
748 color[1] = bytestream2_get_le16u(&g3);
750 if (
color[0] & 0x8000)
752 if (
color[1] & 0x8000)
758 bits = bytestream2_get_le32u(&g3);
759 for (y2 = 0; y2 < 16; y2++) {
760 for (x2 = 0; x2 < 16; x2++) {
761 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
767 dst += 16 *
width - x;
776 const int width =
f->avctx->width;
777 const int height =
f->avctx->height;
778 const unsigned int bitstream_size =
AV_RL32(buf);
779 unsigned int prestream_size;
780 const uint8_t *prestream;
782 if (bitstream_size > (1 << 26))
785 if (length < bitstream_size + 12) {
790 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
791 prestream = buf + bitstream_size + 12;
793 if (prestream_size + bitstream_size + 12 != length
794 || prestream_size > (1 << 26)) {
796 prestream_size, bitstream_size, length);
810 prestream_size = length + buf - prestream;
814 if (!
f->bitstream_buffer)
816 f->bbdsp.bswap_buf(
f->bitstream_buffer, (
const uint32_t *) prestream,
820 f->last_dc = 0 * 128 * 8 * 8;
822 for (y = 0; y <
height; y += 16) {
823 for (x = 0; x <
width; x += 16) {
840 const uint8_t *buf = avpkt->
data;
841 int buf_size = avpkt->
size;
850 if (buf_size <
AV_RL32(buf + 4) + 8) {
858 if (frame_4cc ==
AV_RL32(
"cfrm")) {
861 const int data_size = buf_size - 20;
864 if (
f->version <= 1) {
870 whole_size =
AV_RL32(buf + 16);
872 if (data_size < 0 || whole_size < 0) {
883 if (
f->cfrm[
i].id ==
id)
885 if (
f->cfrm[
i].size == 0)
908 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
909 cfrm->
size += data_size;
911 if (cfrm->
size >= whole_size) {
922 cfrm->
size = cfrm->
id = 0;
934 if (frame_4cc ==
AV_RL32(
"ifr2")) {
940 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
946 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
952 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
968 (
const uint8_t*)
f->frame_buffer, avctx->
width * 2,
970 FFSWAP(uint16_t *,
f->frame_buffer,
f->last_frame_buffer);
985 f->bitstream_buffer_size = 0;
988 f->cfrm[
i].allocated_size = 0;
1016 if (!
f->frame_buffer || !
f->last_frame_buffer)