60 #define LUT8_PART(plane, v) \
61 AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane, \
62 AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane, \
63 AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane, \
64 AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane, \
65 AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane, \
66 AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane, \
67 AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane, \
68 AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane, \
69 AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane, \
70 AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane, \
71 AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane, \
72 AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane, \
73 AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane, \
74 AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane, \
75 AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane, \
76 AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
78 #define LUT8(plane) { \
79 LUT8_PART(plane, 0x0000000), \
80 LUT8_PART(plane, 0x1000000), \
81 LUT8_PART(plane, 0x0010000), \
82 LUT8_PART(plane, 0x1010000), \
83 LUT8_PART(plane, 0x0000100), \
84 LUT8_PART(plane, 0x1000100), \
85 LUT8_PART(plane, 0x0010100), \
86 LUT8_PART(plane, 0x1010100), \
87 LUT8_PART(plane, 0x0000001), \
88 LUT8_PART(plane, 0x1000001), \
89 LUT8_PART(plane, 0x0010001), \
90 LUT8_PART(plane, 0x1010001), \
91 LUT8_PART(plane, 0x0000101), \
92 LUT8_PART(plane, 0x1000101), \
93 LUT8_PART(plane, 0x0010101), \
94 LUT8_PART(plane, 0x1010101), \
103 #define LUT32(plane) { \
105 0, 0, 0, 1 << plane, \
106 0, 0, 1 << plane, 0, \
107 0, 0, 1 << plane, 1 << plane, \
108 0, 1 << plane, 0, 0, \
109 0, 1 << plane, 0, 1 << plane, \
110 0, 1 << plane, 1 << plane, 0, \
111 0, 1 << plane, 1 << plane, 1 << plane, \
112 1 << plane, 0, 0, 0, \
113 1 << plane, 0, 0, 1 << plane, \
114 1 << plane, 0, 1 << plane, 0, \
115 1 << plane, 0, 1 << plane, 1 << plane, \
116 1 << plane, 1 << plane, 0, 0, \
117 1 << plane, 1 << plane, 0, 1 << plane, \
118 1 << plane, 1 << plane, 1 << plane, 0, \
119 1 << plane, 1 << plane, 1 << plane, 1 << plane, \
136 return x << 16 | x << 8 | x;
156 count =
FFMIN(palette_size / 3, count);
158 for (i=0; i <
count; i++) {
159 pal[i] = 0xFF000000 |
AV_RB24(palette + i*3);
161 if (s->
flags && count >= 32) {
162 for (i = 0; i < 32; i++)
163 pal[i + 32] = 0xFF000000 | (
AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
164 count =
FFMAX(count, 64);
169 for (i=0; i <
count; i++) {
175 for (i = 0; i <
count; i++)
210 buf_size = bytestream_get_be16(&buf);
211 if (buf_size <= 1 || image_size <= 1) {
213 "Invalid image size received: %u -> image data offset: %d\n",
214 buf_size, image_size);
219 buf_size = bytestream_get_be16(&buf);
220 if (buf_size <= 1 || palette_size < 0) {
222 "Invalid palette size received: %u -> palette data offset: %d\n",
223 buf_size, palette_size);
228 if (buf_size >= 41) {
230 s->
bpp = bytestream_get_byte(&buf);
231 s->
ham = bytestream_get_byte(&buf);
232 s->
flags = bytestream_get_byte(&buf);
234 s->
masking = bytestream_get_byte(&buf);
235 for (i = 0; i < 16; i++)
236 s->
tvdc[i] = bytestream_get_be16(&buf);
239 if (s->
bpp >= 8 && !s->
ham) {
262 if (!s->
bpp || s->
bpp > 32) {
265 }
else if (s->
ham >= 8) {
282 ham_count = 8 * (1 << s->
ham);
291 memset(s->
ham_palbuf, 0, (1 << s->
ham) * 2 * sizeof (uint32_t));
292 for (i=0; i <
count; i++) {
298 for (i=0; i <
count; i++) {
303 for (i=0; i <
count; i++) {
304 uint32_t tmp = i << (8 - s->
ham);
305 tmp |= tmp >> s->
ham;
310 s->
ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
311 s->
ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
314 for (i = 0; i < ham_count; i++)
389 uint64_t
v =
AV_RN64A(dst) | lut[*buf++];
392 }
while (--buf_size);
406 unsigned mask = (*buf >> 2) & ~3;
407 dst[0] |= lut[mask++];
408 dst[1] |= lut[mask++];
409 dst[2] |= lut[mask++];
411 mask = (*buf++ << 2) & 0x3F;
412 dst[4] |= lut[mask++];
413 dst[5] |= lut[mask++];
414 dst[6] |= lut[mask++];
417 }
while (--buf_size);
420 #define DECODE_HAM_PLANE32(x) \
421 first = buf[x] << 1; \
422 second = buf[(x)+1] << 1; \
423 delta &= pal[first++]; \
424 delta |= pal[first]; \
426 delta &= pal[second++]; \
427 delta |= pal[second]; \
439 const uint32_t *
const pal,
unsigned buf_size)
441 uint32_t
delta = pal[1];
443 uint32_t first, second;
450 }
while (--buf_size);
454 const uint32_t *
const pal,
unsigned width)
457 *dst++ = pal[*buf++];
474 for (x = 0; x < dst_size && buf < buf_end;) {
476 const int8_t
value = *buf++;
479 memcpy(dst + x, buf,
FFMIN3(length, dst_size - x, buf_end - buf));
481 }
else if (value > -128) {
483 memset(dst + x, *buf++,
FFMIN(length, dst_size - x));
489 return buf - buf_start;
492 #define DECODE_RGBX_COMMON(type) \
494 length = bytestream2_get_byte(gb); \
496 length = bytestream2_get_be16(gb); \
501 for (i = 0; i < length; i++) { \
502 *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
523 uint32_t
pixel = 0xFF000000 | bytestream2_get_be24(gb);
524 length = bytestream2_get_byte(gb) & 0x7F;
540 uint32_t
pixel = bytestream2_get_be16u(gb);
541 length = pixel & 0x7;
558 const uint8_t *src_end = src + src_size;
560 while (src + 5 <= src_end) {
562 opcode = *(int8_t *)src++;
564 int size = opcode + 1;
565 for (i = 0; i <
size; i++) {
567 memcpy(dst +
y*linesize + x * 4, src, length * 4);
579 int size = -opcode + 1;
581 for (i = 0; i <
size; i++) {
582 *(uint32_t *)(dst +
y*linesize + x * 4) =
pixel;
608 int x = 0,
y = 0, plane = 0;
612 for (i = 0; i < src_size * 2;) {
613 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4))
618 dst[
y * linesize + x*4 + plane] =
pixel;
621 if (i >= src_size * 2)
625 d =
FFMIN(d, width - x);
626 for (j = 0; j < d; j++) {
627 dst[
y * linesize + x*4 + plane] =
pixel;
654 void *
data,
int *got_frame,
660 const uint8_t *buf_end = buf+buf_size;
684 for (plane = 0; plane < s->
bpp; plane++) {
685 for(y = 0; y < avctx->
height && buf < buf_end; y++ ) {
693 for(y = 0; y < avctx->
height; y++) {
696 for (plane = 0; plane < s->
bpp; plane++) {
698 if (start >= buf_end)
710 for(y = 0; y < avctx->
height && buf < buf_end; y++ ) {
712 memcpy(row, buf,
FFMIN(raw_width, buf_end - buf));
715 for(x = 0; x < avctx->
width; x++)
716 row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
721 for(y = 0; y < avctx->
height; y++ ) {
723 memset(row, 0, avctx->
width);
724 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
730 for (y = 0; y < avctx->
height; y++) {
733 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
740 for(y = 0; y < avctx->
height; y++ ) {
742 memset(row, 0, avctx->
width << 2);
743 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
751 for(y = 0; y < avctx->
height && buf_end >
buf; y++ ) {
753 memcpy(row, buf,
FFMIN(avctx->
width, buf_end - buf));
757 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
770 for(y = 0; y < avctx->
height ; y++ ) {
772 memset(row, 0, avctx->
width);
773 for (plane = 0; plane < s->
bpp; plane++) {
779 for (y = 0; y < avctx->
height ; y++ ) {
782 for (plane = 0; plane < s->
bpp; plane++) {
789 for (y = 0; y < avctx->
height ; y++) {
792 for (plane = 0; plane < s->
bpp; plane++) {
799 for(y = 0; y < avctx->
height ; y++ ) {
801 memset(row, 0, avctx->
width << 2);
802 for (plane = 0; plane < s->
bpp; plane++) {
810 for(y = 0; y < avctx->
height ; y++ ) {
815 for (y = 0; y < avctx->
height ; y++) {
871 #if CONFIG_IFF_ILBM_DECODER
872 AVCodec ff_iff_ilbm_decoder = {
884 #if CONFIG_IFF_BYTERUN1_DECODER
885 AVCodec ff_iff_byterun1_decoder = {