71 #define LUT8_PART(plane, v) \ 72 AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane, \ 73 AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane, \ 74 AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane, \ 75 AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane, \ 76 AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane, \ 77 AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane, \ 78 AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane, \ 79 AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane, \ 80 AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane, \ 81 AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane, \ 82 AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane, \ 83 AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane, \ 84 AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane, \ 85 AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane, \ 86 AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane, \ 87 AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane 89 #define LUT8(plane) { \ 90 LUT8_PART(plane, 0x0000000), \ 91 LUT8_PART(plane, 0x1000000), \ 92 LUT8_PART(plane, 0x0010000), \ 93 LUT8_PART(plane, 0x1010000), \ 94 LUT8_PART(plane, 0x0000100), \ 95 LUT8_PART(plane, 0x1000100), \ 96 LUT8_PART(plane, 0x0010100), \ 97 LUT8_PART(plane, 0x1010100), \ 98 LUT8_PART(plane, 0x0000001), \ 99 LUT8_PART(plane, 0x1000001), \ 100 LUT8_PART(plane, 0x0010001), \ 101 LUT8_PART(plane, 0x1010001), \ 102 LUT8_PART(plane, 0x0000101), \ 103 LUT8_PART(plane, 0x1000101), \ 104 LUT8_PART(plane, 0x0010101), \ 105 LUT8_PART(plane, 0x1010101), \ 114 #define LUT32(plane) { \ 116 0, 0, 0, 1U << plane, \ 117 0, 0, 1U << plane, 0, \ 118 0, 0, 1U << plane, 1U << plane, \ 119 0, 1U << plane, 0, 0, \ 120 0, 1U << plane, 0, 1U << plane, \ 121 0, 1U << plane, 1U << plane, 0, \ 122 0, 1U << plane, 1U << plane, 1U << plane, \ 123 1U << plane, 0, 0, 0, \ 124 1U << plane, 0, 0, 1U << plane, \ 125 1U << plane, 0, 1U << plane, 0, \ 126 1U << plane, 0, 1U << plane, 1U << plane, \ 127 1U << plane, 1U << plane, 0, 0, \ 128 1U << plane, 1U << plane, 0, 1U << plane, \ 129 1U << plane, 1U << plane, 1U << plane, 0, \ 130 1U << plane, 1U << plane, 1U << plane, 1U << plane, \ 147 return x << 16 | x << 8 | x;
167 count =
FFMIN(palette_size / 3, count);
169 for (i = 0; i <
count; i++)
170 pal[i] = 0xFF000000 |
AV_RB24(palette + i*3);
171 if (s->
flags && count >= 32) {
172 for (i = 0; i < 32; i++)
173 pal[i + 32] = 0xFF000000 | (
AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
174 count =
FFMAX(count, 64);
179 for (i = 0; i <
count; i++)
188 for (i = 0; i <
count; i++)
209 unsigned buf_size = 0;
225 chunk_id = bytestream2_get_le32(gb);
226 data_size = bytestream2_get_be32(gb);
228 if (chunk_id ==
MKTAG(
'B',
'M',
'H',
'D')) {
230 }
else if (chunk_id ==
MKTAG(
'A',
'N',
'H',
'D')) {
237 extra = bytestream2_get_be32(gb);
243 }
else if (chunk_id ==
MKTAG(
'D',
'L',
'T',
'A') ||
244 chunk_id ==
MKTAG(
'B',
'O',
'D',
'Y')) {
245 if (chunk_id ==
MKTAG(
'B',
'O',
'D',
'Y'))
248 }
else if (chunk_id ==
MKTAG(
'C',
'M',
'A',
'P')) {
249 int count = data_size / 3;
255 for (i = 0; i <
count; i++)
256 pal[i] = 0xFF000000 | bytestream2_get_le24(gb);
258 for (i = 0; i <
count; i++)
259 pal[i] = 0xFF000000 | bytestream2_get_be24(gb);
268 buf_size = bytestream_get_be16(&buf);
269 if (buf_size <= 1 || palette_size < 0) {
271 "Invalid palette size received: %u -> palette data offset: %d\n",
272 buf_size, palette_size);
277 if (buf_size >= 41) {
279 s->
bpp = bytestream_get_byte(&buf);
280 s->
ham = bytestream_get_byte(&buf);
281 s->
flags = bytestream_get_byte(&buf);
283 s->
masking = bytestream_get_byte(&buf);
284 for (i = 0; i < 16; i++)
285 s->
tvdc[i] = bytestream_get_be16(&buf);
291 }
else if (s->
ham != (s->
bpp > 6 ? 6 : 4)) {
298 if (s->
bpp >= 8 && !s->
ham) {
321 if (!s->
bpp || s->
bpp > 32) {
340 ham_count = 8 * (1 << s->
ham);
349 memset(s->
ham_palbuf, 0, (1 << s->
ham) * 2 * sizeof (uint32_t));
350 for (i=0; i <
count; i++) {
356 for (i=0; i <
count; i++) {
361 for (i=0; i <
count; i++) {
362 uint32_t
tmp = i << (8 - s->
ham);
363 tmp |= tmp >> s->
ham;
368 s->
ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
369 s->
ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
372 for (i = 0; i < ham_count; i++)
468 uint64_t v =
AV_RN64A(dst) | lut[*buf++];
471 }
while (--buf_size);
485 unsigned mask = (*buf >> 2) & ~3;
486 dst[0] |= lut[mask++];
487 dst[1] |= lut[mask++];
488 dst[2] |= lut[mask++];
490 mask = (*buf++ << 2) & 0x3F;
491 dst[4] |= lut[mask++];
492 dst[5] |= lut[mask++];
493 dst[6] |= lut[mask++];
496 }
while (--buf_size);
499 #define DECODE_HAM_PLANE32(x) \ 500 first = buf[x] << 1; \ 501 second = buf[(x)+1] << 1; \ 502 delta &= pal[first++]; \ 503 delta |= pal[first]; \ 505 delta &= pal[second++]; \ 506 delta |= pal[second]; \ 518 const uint32_t *
const pal,
unsigned buf_size)
520 uint32_t
delta = pal[1];
522 uint32_t first, second;
529 }
while (--buf_size);
533 const uint32_t *
const pal,
unsigned width)
536 *dst++ = pal[*buf++];
553 for (x = 0; x < dst_size && bytestream2_get_bytes_left(gb) > 0;) {
555 const int8_t
value = bytestream2_get_byte(gb);
559 if (length < value + 1)
561 }
else if (value > -128) {
562 length =
FFMIN(-value + 1, dst_size - x);
563 memset(dst + x, bytestream2_get_byte(gb), length);
571 memset(dst+x, 0, dst_size - x);
581 int i, y_pos = 0, x_pos = 0;
583 if (bytestream2_get_be32(gb) !=
MKBETAG(
'V',
'D',
'A',
'T'))
587 count = bytestream2_get_be16(gb) - 2;
594 for (i = 0; i < count && x_pos < line_size; i++) {
595 int8_t cmd = bytestream2_get_byte(&cmds);
599 l = bytestream2_get_be16(gb);
600 while (l-- > 0 && x_pos < line_size) {
601 dst[x_pos + y_pos * line_size ] = bytestream2_get_byte(gb);
602 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
603 if (y_pos >= height) {
608 }
else if (cmd < 0) {
610 while (l-- > 0 && x_pos < line_size) {
611 dst[x_pos + y_pos * line_size ] = bytestream2_get_byte(gb);
612 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
613 if (y_pos >= height) {
618 }
else if (cmd == 1) {
619 l = bytestream2_get_be16(gb);
620 r = bytestream2_get_be16(gb);
621 while (l-- > 0 && x_pos < line_size) {
622 dst[x_pos + y_pos * line_size ] = r >> 8;
623 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
624 if (y_pos >= height) {
631 r = bytestream2_get_be16(gb);
632 while (l-- > 0 && x_pos < line_size) {
633 dst[x_pos + y_pos * line_size ] = r >> 8;
634 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
635 if (y_pos >= height) {
646 #define DECODE_RGBX_COMMON(type) \ 648 length = bytestream2_get_byte(gb); \ 650 length = bytestream2_get_be16(gb); \ 655 for (i = 0; i < length; i++) { \ 656 *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \ 677 uint32_t
pixel = 0xFF000000 | bytestream2_get_be24(gb);
678 length = bytestream2_get_byte(gb) & 0x7F;
694 uint32_t
pixel = bytestream2_get_be16u(gb);
695 length = pixel & 0x7;
712 const uint8_t *src_end = src + src_size;
714 while (src + 5 <= src_end) {
716 opcode = *(int8_t *)src++;
718 int size = opcode + 1;
721 memcpy(dst + y*linesize + x * 4, src, length * 4);
733 int size = -opcode + 1;
736 *(uint32_t *)(dst + y*linesize + x * 4) =
pixel;
762 int x = 0, y = 0,
plane = 0;
766 for (i = 0; i < src_size * 2;) {
767 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4)) 775 if (i >= src_size * 2)
779 d =
FFMIN(d, width - x);
780 for (j = 0; j < d; j++) {
802 int w,
int bpp,
int dst_size)
804 int planepitch =
FFALIGN(w, 16) >> 3;
805 int pitch = planepitch *
bpp;
808 unsigned ofssrc, pos;
814 for (k = 0; k <
bpp; k++) {
815 ofssrc = bytestream2_get_be32(&ptrs);
821 if (ofssrc >= buf_end - buf)
826 int16_t
offset = bytestream2_get_be16(&gb);
830 unsigned data = bytestream2_get_be16(&gb);
833 noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
835 bytestream2_put_be16(&pb, data);
837 uint16_t
count = bytestream2_get_be16(&gb);
839 pos += 2 * -(offset + 2);
840 for (i = 0; i <
count; i++) {
841 uint16_t
data = bytestream2_get_be16(&gb);
844 noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
846 bytestream2_put_be16(&pb, data);
855 int w,
int xor,
int bpp,
int dst_size)
857 int ncolumns = ((w + 15) / 16) * 2;
858 int dstpitch = ncolumns *
bpp;
859 unsigned ofsdst, ofssrc, opcode, x;
867 for (k = 0; k <
bpp; k++) {
868 ofssrc = bytestream2_get_be32(&ptrs);
873 if (ofssrc >= buf_end - buf)
877 for (j = 0; j < ncolumns; j++) {
878 ofsdst = j + k * ncolumns;
880 i = bytestream2_get_byte(&gb);
882 opcode = bytestream2_get_byte(&gb);
885 opcode = bytestream2_get_byte(&gb);
886 x = bytestream2_get_byte(&gb);
890 if (xor && ofsdst < dst_size) {
891 bytestream2_put_byte(&pb, dst[ofsdst] ^ x);
893 bytestream2_put_byte(&pb, x);
898 }
else if (opcode < 0x80) {
899 ofsdst += opcode * dstpitch;
905 if (xor && ofsdst < dst_size) {
906 bytestream2_put_byte(&pb, dst[ofsdst] ^ bytestream2_get_byte(&gb));
908 bytestream2_put_byte(&pb, bytestream2_get_byte(&gb));
922 int w,
int h,
int bpp,
int dst_size)
928 int planepitch_byte = (w + 7) / 8;
929 int planepitch = ((w + 15) / 16) * 2;
930 int kludge_j,
b,
g,
r, d;
933 pitch = planepitch *
bpp;
934 kludge_j = w < 320 ? (320 -
w) / 8 / 2 : 0;
939 type = bytestream2_get_be16(&gb);
945 flag = bytestream2_get_be16(&gb);
946 cols = bytestream2_get_be16(&gb);
947 groups = bytestream2_get_be16(&gb);
949 for (g = 0; g <
groups; g++) {
950 offset = bytestream2_get_be16(&gb);
958 offset = ((offset / (320 / 8)) * pitch) + (offset % (320 / 8)) - kludge_j;
960 offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
962 for (b = 0; b < cols; b++) {
963 for (d = 0; d <
bpp; d++) {
966 if (offset >= dst_size)
975 offset += planepitch;
978 if ((cols * bpp) & 1)
983 flag = bytestream2_get_be16(&gb);
984 rows = bytestream2_get_be16(&gb);
985 bytes = bytestream2_get_be16(&gb);
986 groups = bytestream2_get_be16(&gb);
988 for (g = 0; g <
groups; g++) {
989 offset = bytestream2_get_be16(&gb);
992 offset = ((offset / (320 / 8)) * pitch) + (offset % (320/ 8)) - kludge_j;
994 offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
996 for (r = 0; r < rows; r++) {
997 for (d = 0; d <
bpp; d++) {
998 unsigned noffset = offset + (r * pitch) + d * planepitch;
1005 for (b = 0; b < bytes; b++) {
1008 if (noffset >= dst_size)
1010 ptr = dst + noffset;
1021 if ((rows * bytes * bpp) & 1)
1033 int w,
int bpp,
int dst_size)
1035 int ncolumns = (w + 15) >> 4;
1036 int dstpitch = ncolumns * bpp * 2;
1037 unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1042 if (buf_end - buf <= 64)
1049 for (k = 0; k <
bpp; k++) {
1050 ofssrc = bytestream2_get_be32(&ptrs);
1051 ofsdata = bytestream2_get_be32(&dptrs);
1056 if (ofssrc >= buf_end - buf)
1059 if (ofsdata >= buf_end - buf)
1064 for (j = 0; j < ncolumns; j++) {
1065 ofsdst = (j + k * ncolumns) * 2;
1067 i = bytestream2_get_byte(&gb);
1069 opcode = bytestream2_get_byte(&gb);
1072 opcode = bytestream2_get_byte(&gb);
1073 x = bytestream2_get_be16(&dgb);
1077 bytestream2_put_be16(&pb, x);
1081 }
else if (opcode < 0x80) {
1082 ofsdst += opcode * dstpitch;
1088 bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1101 int w,
int bpp,
int dst_size)
1103 int ncolumns = (w + 31) >> 5;
1104 int dstpitch = ((w + 15) / 16 * 2) *
bpp;
1105 unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1110 if (buf_end - buf <= 64)
1113 h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1118 for (k = 0; k <
bpp; k++) {
1119 ofssrc = bytestream2_get_be32(&ptrs);
1120 ofsdata = bytestream2_get_be32(&dptrs);
1125 if (ofssrc >= buf_end - buf)
1128 if (ofsdata >= buf_end - buf)
1133 for (j = 0; j < ncolumns; j++) {
1134 ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1136 i = bytestream2_get_byte(&gb);
1138 opcode = bytestream2_get_byte(&gb);
1141 opcode = bytestream2_get_byte(&gb);
1142 if (h && (j == (ncolumns - 1))) {
1143 x = bytestream2_get_be16(&dgb);
1146 x = bytestream2_get_be32(&dgb);
1154 if (h && (j == (ncolumns - 1))) {
1155 bytestream2_put_be16(&pb, x);
1157 bytestream2_put_be32(&pb, x);
1162 }
else if (opcode < 0x80) {
1163 ofsdst += opcode * dstpitch;
1169 if (h && (j == (ncolumns - 1))) {
1170 bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1173 bytestream2_put_be32(&pb, bytestream2_get_be32(&dgb));
1187 int w,
int bpp,
int dst_size)
1189 int ncolumns = (w + 15) >> 4;
1190 int dstpitch = ncolumns * bpp * 2;
1191 unsigned ofsdst, ofssrc, opcode, x;
1199 for (k = 0; k <
bpp; k++) {
1200 ofssrc = bytestream2_get_be32(&ptrs);
1205 if (ofssrc >= buf_end - buf)
1209 for (j = 0; j < ncolumns; j++) {
1210 ofsdst = (j + k * ncolumns) * 2;
1212 i = bytestream2_get_be16(&gb);
1214 opcode = bytestream2_get_be16(&gb);
1217 opcode = bytestream2_get_be16(&gb);
1218 x = bytestream2_get_be16(&gb);
1222 bytestream2_put_be16(&pb, x);
1226 }
else if (opcode < 0x8000) {
1227 ofsdst += opcode * dstpitch;
1234 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1247 int w,
int bpp,
int dst_size)
1249 int ncolumns = (w + 31) >> 5;
1250 int dstpitch = ((w + 15) / 16 * 2) *
bpp;
1251 unsigned ofsdst, ofssrc, opcode, x;
1252 unsigned skip = 0x80000000,
mask = skip - 1;
1257 h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1261 for (k = 0; k <
bpp; k++) {
1262 ofssrc = bytestream2_get_be32(&ptrs);
1267 if (ofssrc >= buf_end - buf)
1271 for (j = 0; j < ncolumns; j++) {
1272 ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1274 if (h && (j == (ncolumns - 1))) {
1279 i = bytestream2_get_be32(&gb);
1281 opcode = bytestream2_get_be32(&gb);
1284 if (h && (j == ncolumns - 1)) {
1285 opcode = bytestream2_get_be16(&gb);
1286 x = bytestream2_get_be16(&gb);
1288 opcode = bytestream2_get_be32(&gb);
1289 x = bytestream2_get_be32(&gb);
1297 if (h && (j == ncolumns - 1))
1298 bytestream2_put_be16(&pb, x);
1300 bytestream2_put_be32(&pb, x);
1304 }
else if (opcode < skip) {
1305 ofsdst += opcode * dstpitch;
1312 if (h && (j == ncolumns - 1)) {
1313 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1315 bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1329 int w,
int flag,
int bpp,
int dst_size)
1331 int planepitch =
FFALIGN(w, 16) >> 3;
1332 int pitch = planepitch *
bpp;
1333 int planepitch_byte = (w + 7) / 8;
1334 unsigned entries, ofssrc;
1339 if (buf_end - buf <= 4 * bpp)
1345 for (k = 0; k <
bpp; k++) {
1346 ofssrc = bytestream2_get_be32(&ptrs);
1351 if (ofssrc >= buf_end - buf)
1356 entries = bytestream2_get_be32(&gb);
1358 int32_t opcode = bytestream2_get_be32(&gb);
1359 unsigned offset = bytestream2_get_be32(&gb);
1361 bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1363 uint32_t x = bytestream2_get_be32(&gb);
1367 bytestream2_put_be32(&pb, x);
1374 bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1386 int w,
int flag,
int bpp,
int dst_size)
1388 int planepitch =
FFALIGN(w, 16) >> 3;
1389 int pitch = planepitch *
bpp;
1390 int planepitch_byte = (w + 7) / 8;
1391 unsigned entries, ofssrc;
1396 if (buf_end - buf <= 4 * bpp)
1402 for (k = 0; k <
bpp; k++) {
1403 ofssrc = bytestream2_get_be32(&ptrs);
1408 if (ofssrc >= buf_end - buf)
1413 entries = bytestream2_get_be16(&gb);
1415 int16_t opcode = bytestream2_get_be16(&gb);
1416 unsigned offset = bytestream2_get_be32(&gb);
1418 bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1420 uint16_t x = bytestream2_get_be16(&gb);
1422 bytestream2_put_be16(&pb, x);
1429 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1441 int w,
int flag,
int bpp,
int dst_size)
1445 unsigned poff0, poff1;
1447 int planepitch_byte = (w + 7) / 8;
1448 int planepitch = ((w + 15) / 16) * 2;
1449 int pitch = planepitch *
bpp;
1451 if (buf_end - buf <= 64)
1458 dstpitch = flag ? (((w + 7) / 8) *
bpp): 2;
1460 for (k = 0; k <
bpp; k++) {
1461 poff0 = bytestream2_get_be32(&off0);
1462 poff1 = bytestream2_get_be32(&off1);
1467 if (2LL * poff0 >= buf_end - buf)
1470 if (2LL * poff1 >= buf_end - buf)
1477 uint32_t
offset = bytestream2_get_be16(&ogb);
1478 int16_t cnt = bytestream2_get_be16(&ogb);
1481 offset = ((2 *
offset) / planepitch_byte) * pitch + ((2 *
offset) % planepitch_byte) + k * planepitch;
1487 data = bytestream2_get_be16(&dgb);
1488 for (i = 0; i < cnt; i++) {
1489 bytestream2_put_be16(&pb, data);
1496 for (i = 0; i < cnt; i++) {
1497 data = bytestream2_get_be16(&dgb);
1498 bytestream2_put_be16(&pb, data);
1514 void *
data,
int *got_frame,
1520 int buf_size = avpkt->
size;
1521 const uint8_t *buf_end = buf + buf_size;
1560 for (plane = 0; plane < s->
bpp; plane++) {
1561 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1567 }
else if (s->
ham) {
1569 for (y = 0; y < avctx->
height; y++) {
1572 for (plane = 0; plane < s->
bpp; plane++) {
1574 if (start >= buf_end)
1585 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1587 memcpy(row, buf,
FFMIN(raw_width, buf_end - buf));
1590 for (x = 0; x < avctx->
width; x++)
1591 row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
1599 for (y = 0; y < avctx->
height; y++) {
1601 memset(row, 0, avctx->
width);
1602 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1607 }
else if (s->
ham) {
1608 for (y = 0; y < avctx->
height; y++) {
1611 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1618 for (y = 0; y < avctx->
height; y++) {
1620 memset(row, 0, avctx->
width << 2);
1621 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1630 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
1632 memcpy(row, buf,
FFMIN(avctx->
width, buf_end - buf));
1635 }
else if (s->
ham) {
1636 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
1654 for (y = 0; y < avctx->
height; y++) {
1656 memset(row, 0, avctx->
width);
1657 for (plane = 0; plane < s->
bpp; plane++) {
1667 for (y = 0; y < avctx->
height; y++) {
1670 for (plane = 0; plane < s->
bpp; plane++) {
1676 }
else if (s->
ham) {
1678 for (y = 0; y < avctx->
height; y++) {
1681 for (plane = 0; plane < s->
bpp; plane++) {
1692 for (y = 0; y < avctx->
height; y++) {
1694 memset(row, 0, avctx->
width << 2);
1695 for (plane = 0; plane < s->
bpp; plane++) {
1703 for (y = 0; y < avctx->
height; y++) {
1707 }
else if (s->
ham) {
1708 for (y = 0; y < avctx->
height; y++) {
1723 for (plane = 0; plane < s->
bpp; plane++) {
1724 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1730 }
else if (s->
ham) {
1732 for (y = 0; y < avctx->
height; y++) {
1735 for (plane = 0; plane < s->
bpp; plane++) {
1737 if (start >= buf_end)
1752 for (plane = 0; plane < s->
bpp; plane++) {
1754 for (y = 0; y < avctx->
height; y++) {
1833 for (y = 0; y < avctx->
height; y++) {
1835 memset(row, 0, avctx->
width);
1836 for (plane = 0; plane < s->
bpp; plane++) {
1841 memcpy(frame->
data[1], s->
pal, 256 * 4);
1842 }
else if (s->
ham) {
1846 memset(s->
ham_palbuf, 0, (1 << s->
ham) * 2 *
sizeof(uint32_t));
1847 for (i = 0; i <
count; i++) {
1850 for (i = 0; i <
count; i++) {
1851 uint32_t
tmp = i << (8 - s->
ham);
1852 tmp |= tmp >> s->
ham;
1857 s->
ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
1858 s->
ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
1861 for (i = 0; i < 8 * (1 << s->
ham); i++)
1864 for (y = 0; y < avctx->
height; y++) {
1867 for (plane = 0; plane < s->
bpp; plane++) {
1895 #if CONFIG_IFF_ILBM_DECODER #define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
unsigned is_brush
video is in ANBR format
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
Decode interleaved plane buffer up to 24bpp.
unsigned compression
delta compression method used
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
uint32_t * mask_palbuf
masking palette table
#define AV_LOG_WARNING
Something somehow does not look correct.
unsigned masking
TODO: masking method used.
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
#define avpriv_request_sample(...)
unsigned transparency
TODO: transparency color index in palette.
static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
Convert CMAP buffer (stored in extradata) to lavc palette format.
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define AV_PIX_FMT_RGB444
unsigned flags
1 for EHB, 0 is no extra half darkening
unsigned is_short
short compression method used
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static void decode_delta_e(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
Decode interleaved plane buffer up to 8bpp.
uint32_t * mask_buf
temporary buffer for palette indices
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
#define DECODE_HAM_PLANE32(x)
static av_cold int decode_end(AVCodecContext *avctx)
static void decode_deep_tvdc32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize, const int16_t *tvdc)
Decode DEEP TVDC 32-bit buffer.
8 bits with AV_PIX_FMT_RGB32 palette
uint8_t * ham_buf
temporary buffer for planar to chunky conversation
static const OptionGroupDef groups[]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
static const uint16_t mask[17]
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
#define AV_PIX_FMT_0BGR32
const char * name
Name of the codec implementation.
static const uint8_t offset[127][2]
unsigned is_interlaced
video is interlaced
int flags
A combination of AV_PKT_FLAG values.
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
enum AVPictureType pict_type
Picture type of the frame.
static void decode_short_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
int width
picture width / height.
static void decode_short_horizontal_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
static int decode_byterun(uint8_t *dst, int dst_size, GetByteContext *gb)
Decode one complete byterun1 encoded line.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset, int whence)
static av_always_inline int bytestream2_tell(GetByteContext *g)
static void decode_long_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
AVCodec ff_iff_ilbm_decoder
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define DECODE_RGBX_COMMON(type)
main external API structure.
static void decode_short_vertical_delta2(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static void decode_delta_j(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int h, int bpp, int dst_size)
static av_always_inline uint32_t gray2rgb(const uint32_t x)
static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGBN buffer.
static void decode_long_vertical_delta2(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
static void decode_delta_l(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void decode_byte_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int xor, int bpp, int dst_size)
common internal api header.
unsigned ham
0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
static const uint32_t plane32_lut[32][16 *4]
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static void decode_delta_d(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGB8 buffer.
static void decode_ham_plane32(uint32_t *dst, const uint8_t *buf, const uint32_t *const pal, unsigned buf_size)
Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
#define MKBETAG(a, b, c, d)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static av_cold int decode_init(AVCodecContext *avctx)
static const uint64_t plane8_lut[8][256]
int key_frame
1 -> keyframe, 0-> not
static int decode_byterun2(uint8_t *dst, int height, int line_size, GetByteContext *gb)
#define FFSWAP(type, a, b)
static int extract_header(AVCodecContext *const avctx, const AVPacket *const avpkt)
Extracts the IFF extra context and updates internal decoder structures.
static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf, const uint32_t *const pal, unsigned width)
int16_t tvdc[16]
TVDC lookup table.
static int unsupported(AVCodecContext *avctx)
#define MKTAG(a, b, c, d)
This structure stores compressed data.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
uint32_t * ham_palbuf
HAM decode table.
static av_always_inline int bytestream2_size_p(PutByteContext *p)
unsigned bpp
bits per plane to decode (differs from bits_per_coded_sample if HAM)
static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
Decode DEEP RLE 32-bit buffer.