62 #define LUT8_PART(plane, v) \
63 AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane, \
64 AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane, \
65 AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane, \
66 AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane, \
67 AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane, \
68 AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane, \
69 AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane, \
70 AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane, \
71 AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane, \
72 AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane, \
73 AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane, \
74 AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane, \
75 AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane, \
76 AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane, \
77 AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane, \
78 AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
80 #define LUT8(plane) { \
81 LUT8_PART(plane, 0x0000000), \
82 LUT8_PART(plane, 0x1000000), \
83 LUT8_PART(plane, 0x0010000), \
84 LUT8_PART(plane, 0x1010000), \
85 LUT8_PART(plane, 0x0000100), \
86 LUT8_PART(plane, 0x1000100), \
87 LUT8_PART(plane, 0x0010100), \
88 LUT8_PART(plane, 0x1010100), \
89 LUT8_PART(plane, 0x0000001), \
90 LUT8_PART(plane, 0x1000001), \
91 LUT8_PART(plane, 0x0010001), \
92 LUT8_PART(plane, 0x1010001), \
93 LUT8_PART(plane, 0x0000101), \
94 LUT8_PART(plane, 0x1000101), \
95 LUT8_PART(plane, 0x0010101), \
96 LUT8_PART(plane, 0x1010101), \
105 #define LUT32(plane) { \
107 0, 0, 0, 1 << plane, \
108 0, 0, 1 << plane, 0, \
109 0, 0, 1 << plane, 1 << plane, \
110 0, 1 << plane, 0, 0, \
111 0, 1 << plane, 0, 1 << plane, \
112 0, 1 << plane, 1 << plane, 0, \
113 0, 1 << plane, 1 << plane, 1 << plane, \
114 1 << plane, 0, 0, 0, \
115 1 << plane, 0, 0, 1 << plane, \
116 1 << plane, 0, 1 << plane, 0, \
117 1 << plane, 0, 1 << plane, 1 << plane, \
118 1 << plane, 1 << plane, 0, 0, \
119 1 << plane, 1 << plane, 0, 1 << plane, \
120 1 << plane, 1 << plane, 1 << plane, 0, \
121 1 << plane, 1 << plane, 1 << plane, 1 << plane, \
138 return x << 16 | x << 8 | x;
158 count =
FFMIN(palette_size / 3, count);
160 for (i = 0; i <
count; i++)
161 pal[i] = 0xFF000000 |
AV_RB24(palette + i*3);
162 if (s->
flags && count >= 32) {
163 for (i = 0; i < 32; i++)
164 pal[i + 32] = 0xFF000000 | (
AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
165 count =
FFMAX(count, 64);
170 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++)
401 uint64_t
v =
AV_RN64A(dst) | lut[*buf++];
404 }
while (--buf_size);
418 unsigned mask = (*buf >> 2) & ~3;
419 dst[0] |= lut[mask++];
420 dst[1] |= lut[mask++];
421 dst[2] |= lut[mask++];
423 mask = (*buf++ << 2) & 0x3F;
424 dst[4] |= lut[mask++];
425 dst[5] |= lut[mask++];
426 dst[6] |= lut[mask++];
429 }
while (--buf_size);
432 #define DECODE_HAM_PLANE32(x) \
433 first = buf[x] << 1; \
434 second = buf[(x)+1] << 1; \
435 delta &= pal[first++]; \
436 delta |= pal[first]; \
438 delta &= pal[second++]; \
439 delta |= pal[second]; \
451 const uint32_t *
const pal,
unsigned buf_size)
453 uint32_t
delta = pal[1];
455 uint32_t first, second;
462 }
while (--buf_size);
466 const uint32_t *
const pal,
unsigned width)
469 *dst++ = pal[*buf++];
487 for (x = 0; x < dst_size && buf < buf_end;) {
489 const int8_t
value = *buf++;
491 length =
FFMIN3(value + 1, dst_size - x, buf_end - buf);
492 memcpy(dst + x, buf, length);
494 }
else if (value > -128) {
495 length =
FFMIN(-value + 1, dst_size - x);
496 memset(dst + x, *buf++, length);
504 memset(dst+x, 0, dst_size - x);
506 return buf - buf_start;
509 #define DECODE_RGBX_COMMON(type) \
511 length = bytestream2_get_byte(gb); \
513 length = bytestream2_get_be16(gb); \
518 for (i = 0; i < length; i++) { \
519 *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
540 uint32_t
pixel = 0xFF000000 | bytestream2_get_be24(gb);
541 length = bytestream2_get_byte(gb) & 0x7F;
557 uint32_t
pixel = bytestream2_get_be16u(gb);
558 length = pixel & 0x7;
575 const uint8_t *src_end = src + src_size;
577 while (src + 5 <= src_end) {
579 opcode = *(int8_t *)src++;
581 int size = opcode + 1;
582 for (i = 0; i <
size; i++) {
584 memcpy(dst +
y*linesize + x * 4, src, length * 4);
596 int size = -opcode + 1;
598 for (i = 0; i <
size; i++) {
599 *(uint32_t *)(dst +
y*linesize + x * 4) =
pixel;
625 int x = 0,
y = 0,
plane = 0;
629 for (i = 0; i < src_size * 2;) {
630 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4))
638 if (i >= src_size * 2)
642 d =
FFMIN(d, width - x);
643 for (j = 0; j < d; j++) {
671 void *
data,
int *got_frame,
677 const uint8_t *buf_end = buf + buf_size;
705 for (plane = 0; plane < s->
bpp; plane++) {
706 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
714 for (y = 0; y < avctx->
height; y++) {
717 for (plane = 0; plane < s->
bpp; plane++) {
719 if (start >= buf_end)
730 for (y = 0; y < avctx->
height && buf < buf_end; y++) {
732 memcpy(row, buf,
FFMIN(raw_width, buf_end - buf));
735 for (x = 0; x < avctx->
width; x++)
736 row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
741 for (y = 0; y < avctx->
height; y++) {
743 memset(row, 0, avctx->
width);
744 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
750 for (y = 0; y < avctx->
height; y++) {
753 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
760 for (y = 0; y < avctx->
height; y++) {
762 memset(row, 0, avctx->
width << 2);
763 for (plane = 0; plane < s->
bpp && buf < buf_end; plane++) {
772 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
774 memcpy(row, buf,
FFMIN(avctx->
width, buf_end - buf));
778 for (y = 0; y < avctx->
height && buf_end >
buf; y++) {
791 for (y = 0; y < avctx->
height; y++) {
793 memset(row, 0, avctx->
width);
794 for (plane = 0; plane < s->
bpp; plane++) {
800 for (y = 0; y < avctx->
height; y++) {
803 for (plane = 0; plane < s->
bpp; plane++) {
810 for (y = 0; y < avctx->
height; y++) {
813 for (plane = 0; plane < s->
bpp; plane++) {
820 for (y = 0; y < avctx->
height; y++) {
822 memset(row, 0, avctx->
width << 2);
823 for (plane = 0; plane < s->
bpp; plane++) {
831 for (y = 0; y < avctx->
height; y++) {
836 for (y = 0; y < avctx->
height; y++) {
880 #if CONFIG_IFF_ILBM_DECODER
881 AVCodec ff_iff_ilbm_decoder = {
893 #if CONFIG_IFF_BYTERUN1_DECODER
894 AVCodec ff_iff_byterun1_decoder = {
#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.
ptrdiff_t const GLvoid * data
uint32_t * mask_palbuf
masking palette table
#define AV_LOG_WARNING
Something somehow does not look correct.
unsigned masking
TODO: masking method used.
static av_cold int init(AVCodecContext *avctx)
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
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.
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)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
#define AV_PIX_FMT_RGB444
unsigned flags
1 for EHB, 0 is no extra half darkening
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
#define DECODE_HAM_PLANE32(x)
static av_cold int decode_end(AVCodecContext *avctx)
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
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 bit with AV_PIX_FMT_RGB32 palette
uint8_t * ham_buf
temporary buffer for planar to chunky conversation
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
bitstream reader API header.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint16_t mask[17]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#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_bytes_left(GetByteContext *g)
#define AV_PIX_FMT_0BGR32
const char * name
Name of the codec implementation.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Libavcodec external API header.
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
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...
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
int width
picture width / height.
GLsizei GLboolean const GLfloat * value
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
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.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
BYTE int const BYTE int int int height
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.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
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_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.
static av_cold int decode_init(AVCodecContext *avctx)
static const uint64_t plane8_lut[8][256]
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 decode_byterun(uint8_t *dst, int dst_size, const uint8_t *buf, const uint8_t *const buf_end)
Decode one complete byterun1 encoded line.
static int unsupported(AVCodecContext *avctx)
#define MKTAG(a, b, c, d)
This structure stores compressed data.
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.