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) {
338 ham_count = 8 * (1 << s->
ham);
347 memset(s->
ham_palbuf, 0, (1 << s->
ham) * 2 * sizeof (uint32_t));
348 for (i=0; i <
count; i++) {
354 for (i=0; i <
count; i++) {
359 for (i=0; i <
count; i++) {
360 uint32_t
tmp = i << (8 - s->
ham);
361 tmp |= tmp >> s->
ham;
366 s->
ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
367 s->
ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
370 for (i = 0; i < ham_count; i++)
465 uint64_t v =
AV_RN64A(dst) | lut[*buf++];
468 }
while (--buf_size);
482 unsigned mask = (*buf >> 2) & ~3;
483 dst[0] |= lut[mask++];
484 dst[1] |= lut[mask++];
485 dst[2] |= lut[mask++];
487 mask = (*buf++ << 2) & 0x3F;
488 dst[4] |= lut[mask++];
489 dst[5] |= lut[mask++];
490 dst[6] |= lut[mask++];
493 }
while (--buf_size);
496 #define DECODE_HAM_PLANE32(x) \ 497 first = buf[x] << 1; \ 498 second = buf[(x)+1] << 1; \ 499 delta &= pal[first++]; \ 500 delta |= pal[first]; \ 502 delta &= pal[second++]; \ 503 delta |= pal[second]; \ 515 const uint32_t *
const pal,
unsigned buf_size)
517 uint32_t
delta = pal[1];
519 uint32_t first, second;
526 }
while (--buf_size);
530 const uint32_t *
const pal,
unsigned width)
533 *dst++ = pal[*buf++];
550 for (x = 0; x < dst_size && bytestream2_get_bytes_left(gb) > 0;) {
552 const int8_t
value = bytestream2_get_byte(gb);
556 if (length < value + 1)
558 }
else if (value > -128) {
559 length =
FFMIN(-value + 1, dst_size - x);
560 memset(dst + x, bytestream2_get_byte(gb), length);
568 memset(dst+x, 0, dst_size - x);
578 int i, y_pos = 0, x_pos = 0;
580 if (bytestream2_get_be32(gb) !=
MKBETAG(
'V',
'D',
'A',
'T'))
584 count = bytestream2_get_be16(gb) - 2;
591 for (i = 0; i < count && x_pos < line_size; i++) {
592 int8_t cmd = bytestream2_get_byte(&cmds);
596 l = bytestream2_get_be16(gb);
597 while (l-- > 0 && x_pos < line_size) {
598 dst[x_pos + y_pos * line_size ] = bytestream2_get_byte(gb);
599 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
600 if (y_pos >= height) {
605 }
else if (cmd < 0) {
607 while (l-- > 0 && x_pos < line_size) {
608 dst[x_pos + y_pos * line_size ] = bytestream2_get_byte(gb);
609 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
610 if (y_pos >= height) {
615 }
else if (cmd == 1) {
616 l = bytestream2_get_be16(gb);
617 r = bytestream2_get_be16(gb);
618 while (l-- > 0 && x_pos < line_size) {
619 dst[x_pos + y_pos * line_size ] = r >> 8;
620 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
621 if (y_pos >= height) {
628 r = bytestream2_get_be16(gb);
629 while (l-- > 0 && x_pos < line_size) {
630 dst[x_pos + y_pos * line_size ] = r >> 8;
631 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
632 if (y_pos >= height) {
643 #define DECODE_RGBX_COMMON(type) \ 645 length = bytestream2_get_byte(gb); \ 647 length = bytestream2_get_be16(gb); \ 652 for (i = 0; i < length; i++) { \ 653 *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \ 674 uint32_t
pixel = 0xFF000000 | bytestream2_get_be24(gb);
675 length = bytestream2_get_byte(gb) & 0x7F;
691 uint32_t
pixel = bytestream2_get_be16u(gb);
692 length = pixel & 0x7;
709 const uint8_t *src_end = src + src_size;
711 while (src + 5 <= src_end) {
713 opcode = *(int8_t *)src++;
715 int size = opcode + 1;
718 memcpy(dst + y*linesize + x * 4, src, length * 4);
730 int size = -opcode + 1;
733 *(uint32_t *)(dst + y*linesize + x * 4) =
pixel;
759 int x = 0, y = 0,
plane = 0;
763 for (i = 0; i < src_size * 2;) {
764 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4)) 772 if (i >= src_size * 2)
776 d =
FFMIN(d, width - x);
777 for (j = 0; j < d; j++) {
799 int w,
int bpp,
int dst_size)
801 int planepitch =
FFALIGN(w, 16) >> 3;
802 int pitch = planepitch *
bpp;
805 unsigned ofssrc, pos;
811 for (k = 0; k <
bpp; k++) {
812 ofssrc = bytestream2_get_be32(&ptrs);
818 if (ofssrc >= buf_end - buf)
823 int16_t
offset = bytestream2_get_be16(&gb);
827 unsigned data = bytestream2_get_be16(&gb);
830 noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
832 bytestream2_put_be16(&pb, data);
834 uint16_t
count = bytestream2_get_be16(&gb);
836 pos += 2 * -(offset + 2);
837 for (i = 0; i <
count; i++) {
838 uint16_t
data = bytestream2_get_be16(&gb);
841 noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
843 bytestream2_put_be16(&pb, data);
852 int w,
int xor,
int bpp,
int dst_size)
854 int ncolumns = ((w + 15) / 16) * 2;
855 int dstpitch = ncolumns *
bpp;
856 unsigned ofsdst, ofssrc, opcode, x;
864 for (k = 0; k <
bpp; k++) {
865 ofssrc = bytestream2_get_be32(&ptrs);
870 if (ofssrc >= buf_end - buf)
874 for (j = 0; j < ncolumns; j++) {
875 ofsdst = j + k * ncolumns;
877 i = bytestream2_get_byte(&gb);
879 opcode = bytestream2_get_byte(&gb);
882 opcode = bytestream2_get_byte(&gb);
883 x = bytestream2_get_byte(&gb);
887 if (xor && ofsdst < dst_size) {
888 bytestream2_put_byte(&pb, dst[ofsdst] ^ x);
890 bytestream2_put_byte(&pb, x);
895 }
else if (opcode < 0x80) {
896 ofsdst += opcode * dstpitch;
902 if (xor && ofsdst < dst_size) {
903 bytestream2_put_byte(&pb, dst[ofsdst] ^ bytestream2_get_byte(&gb));
905 bytestream2_put_byte(&pb, bytestream2_get_byte(&gb));
919 int w,
int h,
int bpp,
int dst_size)
925 int planepitch_byte = (w + 7) / 8;
926 int planepitch = ((w + 15) / 16) * 2;
927 int kludge_j,
b,
g,
r, d;
930 pitch = planepitch *
bpp;
931 kludge_j = w < 320 ? (320 -
w) / 8 / 2 : 0;
936 type = bytestream2_get_be16(&gb);
942 flag = bytestream2_get_be16(&gb);
943 cols = bytestream2_get_be16(&gb);
944 groups = bytestream2_get_be16(&gb);
946 for (g = 0; g <
groups; g++) {
947 offset = bytestream2_get_be16(&gb);
955 offset = ((offset / (320 / 8)) * pitch) + (offset % (320 / 8)) - kludge_j;
957 offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
959 for (b = 0; b < cols; b++) {
960 for (d = 0; d <
bpp; d++) {
963 if (offset >= dst_size)
972 offset += planepitch;
975 if ((cols * bpp) & 1)
980 flag = bytestream2_get_be16(&gb);
981 rows = bytestream2_get_be16(&gb);
982 bytes = bytestream2_get_be16(&gb);
983 groups = bytestream2_get_be16(&gb);
985 for (g = 0; g <
groups; g++) {
986 offset = bytestream2_get_be16(&gb);
989 offset = ((offset / (320 / 8)) * pitch) + (offset % (320/ 8)) - kludge_j;
991 offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
993 for (r = 0; r < rows; r++) {
994 for (d = 0; d <
bpp; d++) {
995 unsigned noffset = offset + (r * pitch) + d * planepitch;
1002 for (b = 0; b < bytes; b++) {
1005 if (noffset >= dst_size)
1007 ptr = dst + noffset;
1018 if ((rows * bytes * bpp) & 1)
1030 int w,
int bpp,
int dst_size)
1032 int ncolumns = (w + 15) >> 4;
1033 int dstpitch = ncolumns * bpp * 2;
1034 unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1039 if (buf_end - buf <= 64)
1046 for (k = 0; k <
bpp; k++) {
1047 ofssrc = bytestream2_get_be32(&ptrs);
1048 ofsdata = bytestream2_get_be32(&dptrs);
1053 if (ofssrc >= buf_end - buf)
1056 if (ofsdata >= buf_end - buf)
1061 for (j = 0; j < ncolumns; j++) {
1062 ofsdst = (j + k * ncolumns) * 2;
1064 i = bytestream2_get_byte(&gb);
1066 opcode = bytestream2_get_byte(&gb);
1069 opcode = bytestream2_get_byte(&gb);
1070 x = bytestream2_get_be16(&dgb);
1074 bytestream2_put_be16(&pb, x);
1078 }
else if (opcode < 0x80) {
1079 ofsdst += opcode * dstpitch;
1085 bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1098 int w,
int bpp,
int dst_size)
1100 int ncolumns = (w + 31) >> 5;
1101 int dstpitch = ((w + 15) / 16 * 2) *
bpp;
1102 unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1107 if (buf_end - buf <= 64)
1110 h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1115 for (k = 0; k <
bpp; k++) {
1116 ofssrc = bytestream2_get_be32(&ptrs);
1117 ofsdata = bytestream2_get_be32(&dptrs);
1122 if (ofssrc >= buf_end - buf)
1125 if (ofsdata >= buf_end - buf)
1130 for (j = 0; j < ncolumns; j++) {
1131 ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1133 i = bytestream2_get_byte(&gb);
1135 opcode = bytestream2_get_byte(&gb);
1138 opcode = bytestream2_get_byte(&gb);
1139 if (h && (j == (ncolumns - 1))) {
1140 x = bytestream2_get_be16(&dgb);
1143 x = bytestream2_get_be32(&dgb);
1148 if (h && (j == (ncolumns - 1))) {
1149 bytestream2_put_be16(&pb, x);
1151 bytestream2_put_be32(&pb, x);
1156 }
else if (opcode < 0x80) {
1157 ofsdst += opcode * dstpitch;
1163 if (h && (j == (ncolumns - 1))) {
1164 bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1167 bytestream2_put_be32(&pb, bytestream2_get_be32(&dgb));
1181 int w,
int bpp,
int dst_size)
1183 int ncolumns = (w + 15) >> 4;
1184 int dstpitch = ncolumns * bpp * 2;
1185 unsigned ofsdst, ofssrc, opcode, x;
1193 for (k = 0; k <
bpp; k++) {
1194 ofssrc = bytestream2_get_be32(&ptrs);
1199 if (ofssrc >= buf_end - buf)
1203 for (j = 0; j < ncolumns; j++) {
1204 ofsdst = (j + k * ncolumns) * 2;
1206 i = bytestream2_get_be16(&gb);
1208 opcode = bytestream2_get_be16(&gb);
1211 opcode = bytestream2_get_be16(&gb);
1212 x = bytestream2_get_be16(&gb);
1216 bytestream2_put_be16(&pb, x);
1220 }
else if (opcode < 0x8000) {
1221 ofsdst += opcode * dstpitch;
1228 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1241 int w,
int bpp,
int dst_size)
1243 int ncolumns = (w + 31) >> 5;
1244 int dstpitch = ((w + 15) / 16 * 2) *
bpp;
1245 unsigned ofsdst, ofssrc, opcode, x;
1246 unsigned skip = 0x80000000,
mask = skip - 1;
1251 h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1255 for (k = 0; k <
bpp; k++) {
1256 ofssrc = bytestream2_get_be32(&ptrs);
1261 if (ofssrc >= buf_end - buf)
1265 for (j = 0; j < ncolumns; j++) {
1266 ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1268 if (h && (j == (ncolumns - 1))) {
1273 i = bytestream2_get_be32(&gb);
1275 opcode = bytestream2_get_be32(&gb);
1278 if (h && (j == ncolumns - 1)) {
1279 opcode = bytestream2_get_be16(&gb);
1280 x = bytestream2_get_be16(&gb);
1282 opcode = bytestream2_get_be32(&gb);
1283 x = bytestream2_get_be32(&gb);
1288 if (h && (j == ncolumns - 1))
1289 bytestream2_put_be16(&pb, x);
1291 bytestream2_put_be32(&pb, x);
1295 }
else if (opcode < skip) {
1296 ofsdst += opcode * dstpitch;
1303 if (h && (j == ncolumns - 1)) {
1304 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1306 bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1320 int w,
int flag,
int bpp,
int dst_size)
1322 int planepitch =
FFALIGN(w, 16) >> 3;
1323 int pitch = planepitch *
bpp;
1324 int planepitch_byte = (w + 7) / 8;
1325 unsigned entries, ofssrc;
1330 if (buf_end - buf <= 4 * bpp)
1336 for (k = 0; k <
bpp; k++) {
1337 ofssrc = bytestream2_get_be32(&ptrs);
1342 if (ofssrc >= buf_end - buf)
1347 entries = bytestream2_get_be32(&gb);
1349 int32_t opcode = bytestream2_get_be32(&gb);
1350 unsigned offset = bytestream2_get_be32(&gb);
1352 bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1354 uint32_t x = bytestream2_get_be32(&gb);
1356 bytestream2_put_be32(&pb, x);
1363 bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1375 int w,
int flag,
int bpp,
int dst_size)
1377 int planepitch =
FFALIGN(w, 16) >> 3;
1378 int pitch = planepitch *
bpp;
1379 int planepitch_byte = (w + 7) / 8;
1380 unsigned entries, ofssrc;
1385 if (buf_end - buf <= 4 * bpp)
1391 for (k = 0; k <
bpp; k++) {
1392 ofssrc = bytestream2_get_be32(&ptrs);
1397 if (ofssrc >= buf_end - buf)
1402 entries = bytestream2_get_be16(&gb);
1404 int16_t opcode = bytestream2_get_be16(&gb);
1405 unsigned offset = bytestream2_get_be32(&gb);
1407 bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1409 uint16_t x = bytestream2_get_be16(&gb);
1411 bytestream2_put_be16(&pb, x);
1418 bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1430 int w,
int flag,
int bpp,
int dst_size)
1434 unsigned poff0, poff1;
1436 int planepitch_byte = (w + 7) / 8;
1437 int planepitch = ((w + 15) / 16) * 2;
1438 int pitch = planepitch *
bpp;
1440 if (buf_end - buf <= 64)
1447 dstpitch = flag ? (((w + 7) / 8) *
bpp): 2;
1449 for (k = 0; k <
bpp; k++) {
1450 poff0 = bytestream2_get_be32(&off0);
1451 poff1 = bytestream2_get_be32(&off1);
1456 if (2LL * poff0 >= buf_end - buf)
1459 if (2LL * poff1 >= buf_end - buf)
1466 uint32_t
offset = bytestream2_get_be16(&ogb);
1467 int16_t cnt = bytestream2_get_be16(&ogb);
1470 offset = ((2 *
offset) / planepitch_byte) * pitch + ((2 *
offset) % planepitch_byte) + k * planepitch;
1476 data = bytestream2_get_be16(&dgb);
1477 for (i = 0; i < cnt; i++) {
1478 bytestream2_put_be16(&pb, data);
1485 for (i = 0; i < cnt; i++) {
1486 data = bytestream2_get_be16(&dgb);
1487 bytestream2_put_be16(&pb, data);
1503 void *
data,
int *got_frame,
1509 int buf_size = avpkt->
size;
1510 const uint8_t *buf_end = buf + buf_size;
1549 for (plane = 0; plane < s->
bpp; plane++) {
1550 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1556 }
else if (s->
ham) {
1558 for (y = 0; y < avctx->
height; y++) {
1561 for (plane = 0; plane < s->
bpp; plane++) {
1563 if (start >= buf_end)
1574 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1576 memcpy(row, buf,
FFMIN(raw_width, buf_end - buf));
1579 for (x = 0; x < avctx->
width; x++)
1580 row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
1588 for (y = 0; y < avctx->
height; y++) {
1590 memset(row, 0, avctx->
width);
1591 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1596 }
else if (s->
ham) {
1597 for (y = 0; y < avctx->
height; y++) {
1600 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1607 for (y = 0; y < avctx->
height; y++) {
1609 memset(row, 0, avctx->
width << 2);
1610 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
1619 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
1621 memcpy(row, buf,
FFMIN(avctx->
width, buf_end - buf));
1624 }
else if (s->
ham) {
1625 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
1643 for (y = 0; y < avctx->
height; y++) {
1645 memset(row, 0, avctx->
width);
1646 for (plane = 0; plane < s->
bpp; plane++) {
1656 for (y = 0; y < avctx->
height; y++) {
1659 for (plane = 0; plane < s->
bpp; plane++) {
1665 }
else if (s->
ham) {
1667 for (y = 0; y < avctx->
height; y++) {
1670 for (plane = 0; plane < s->
bpp; plane++) {
1681 for (y = 0; y < avctx->
height; y++) {
1683 memset(row, 0, avctx->
width << 2);
1684 for (plane = 0; plane < s->
bpp; plane++) {
1692 for (y = 0; y < avctx->
height; y++) {
1696 }
else if (s->
ham) {
1697 for (y = 0; y < avctx->
height; y++) {
1712 for (plane = 0; plane < s->
bpp; plane++) {
1713 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
1719 }
else if (s->
ham) {
1721 for (y = 0; y < avctx->
height; y++) {
1724 for (plane = 0; plane < s->
bpp; plane++) {
1726 if (start >= buf_end)
1741 for (plane = 0; plane < s->
bpp; plane++) {
1743 for (y = 0; y < avctx->
height; y++) {
1822 for (y = 0; y < avctx->
height; y++) {
1824 memset(row, 0, avctx->
width);
1825 for (plane = 0; plane < s->
bpp; plane++) {
1830 memcpy(frame->
data[1], s->
pal, 256 * 4);
1831 }
else if (s->
ham) {
1835 memset(s->
ham_palbuf, 0, (1 << s->
ham) * 2 *
sizeof(uint32_t));
1836 for (i = 0; i <
count; i++) {
1839 for (i = 0; i <
count; i++) {
1840 uint32_t
tmp = i << (8 - s->
ham);
1841 tmp |= tmp >> s->
ham;
1846 s->
ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
1847 s->
ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
1850 for (i = 0; i < 8 * (1 << s->
ham); i++)
1853 for (y = 0; y < avctx->
height; y++) {
1856 for (plane = 0; plane < s->
bpp; plane++) {
1884 #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.
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.