iff decoder: DEEP TVDC 32-bit decoder
[ffmpeg.git] / libavcodec / iff.c
1 /*
2  * IFF ACBM/DEEP/ILBM/PBM bitmap decoder
3  * Copyright (c) 2010 Peter Ross <pross@xvid.org>
4  * Copyright (c) 2010 Sebastian Vater <cdgs.basty@googlemail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * IFF ACBM/DEEP/ILBM/PBM bitmap decoder
26  */
27
28 #include "libavutil/imgutils.h"
29 #include "bytestream.h"
30 #include "avcodec.h"
31 #include "get_bits.h"
32
33 // TODO: masking bits
34 typedef enum {
35     MASK_NONE,
36     MASK_HAS_MASK,
37     MASK_HAS_TRANSPARENT_COLOR,
38     MASK_LASSO
39 } mask_type;
40
41 typedef struct {
42     AVFrame frame;
43     int planesize;
44     uint8_t * planebuf;
45     uint8_t * ham_buf;      ///< temporary buffer for planar to chunky conversation
46     uint32_t *ham_palbuf;   ///< HAM decode table
47     uint32_t *mask_buf;     ///< temporary buffer for palette indices
48     uint32_t *mask_palbuf;  ///< masking palette table
49     unsigned  compression;  ///< delta compression method used
50     unsigned  bpp;          ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
51     unsigned  ham;          ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
52     unsigned  flags;        ///< 1 for EHB, 0 is no extra half darkening
53     unsigned  transparency; ///< TODO: transparency color index in palette
54     unsigned  masking;      ///< TODO: masking method used
55     int init; // 1 if buffer and palette data already initialized, 0 otherwise
56     int16_t   tvdc[16];     ///< TVDC lookup table
57 } IffContext;
58
59 #define LUT8_PART(plane, v)                             \
60     AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
61     AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
62     AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
63     AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
64     AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
65     AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
66     AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
67     AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
68     AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
69     AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
70     AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
71     AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
72     AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
73     AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
74     AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
75     AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
76
77 #define LUT8(plane) {                           \
78     LUT8_PART(plane, 0x0000000),                \
79     LUT8_PART(plane, 0x1000000),                \
80     LUT8_PART(plane, 0x0010000),                \
81     LUT8_PART(plane, 0x1010000),                \
82     LUT8_PART(plane, 0x0000100),                \
83     LUT8_PART(plane, 0x1000100),                \
84     LUT8_PART(plane, 0x0010100),                \
85     LUT8_PART(plane, 0x1010100),                \
86     LUT8_PART(plane, 0x0000001),                \
87     LUT8_PART(plane, 0x1000001),                \
88     LUT8_PART(plane, 0x0010001),                \
89     LUT8_PART(plane, 0x1010001),                \
90     LUT8_PART(plane, 0x0000101),                \
91     LUT8_PART(plane, 0x1000101),                \
92     LUT8_PART(plane, 0x0010101),                \
93     LUT8_PART(plane, 0x1010101),                \
94 }
95
96 // 8 planes * 8-bit mask
97 static const uint64_t plane8_lut[8][256] = {
98     LUT8(0), LUT8(1), LUT8(2), LUT8(3),
99     LUT8(4), LUT8(5), LUT8(6), LUT8(7),
100 };
101
102 #define LUT32(plane) {                                \
103              0,          0,          0,          0,   \
104              0,          0,          0, 1 << plane,   \
105              0,          0, 1 << plane,          0,   \
106              0,          0, 1 << plane, 1 << plane,   \
107              0, 1 << plane,          0,          0,   \
108              0, 1 << plane,          0, 1 << plane,   \
109              0, 1 << plane, 1 << plane,          0,   \
110              0, 1 << plane, 1 << plane, 1 << plane,   \
111     1 << plane,          0,          0,          0,   \
112     1 << plane,          0,          0, 1 << plane,   \
113     1 << plane,          0, 1 << plane,          0,   \
114     1 << plane,          0, 1 << plane, 1 << plane,   \
115     1 << plane, 1 << plane,          0,          0,   \
116     1 << plane, 1 << plane,          0, 1 << plane,   \
117     1 << plane, 1 << plane, 1 << plane,          0,   \
118     1 << plane, 1 << plane, 1 << plane, 1 << plane,   \
119 }
120
121 // 32 planes * 4-bit mask * 4 lookup tables each
122 static const uint32_t plane32_lut[32][16*4] = {
123     LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
124     LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
125     LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
126     LUT32(12), LUT32(13), LUT32(14), LUT32(15),
127     LUT32(16), LUT32(17), LUT32(18), LUT32(19),
128     LUT32(20), LUT32(21), LUT32(22), LUT32(23),
129     LUT32(24), LUT32(25), LUT32(26), LUT32(27),
130     LUT32(28), LUT32(29), LUT32(30), LUT32(31),
131 };
132
133 // Gray to RGB, required for palette table of grayscale images with bpp < 8
134 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
135     return x << 16 | x << 8 | x;
136 }
137
138 /**
139  * Convert CMAP buffer (stored in extradata) to lavc palette format
140  */
141 static int ff_cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
142 {
143     IffContext *s = avctx->priv_data;
144     int count, i;
145     const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
146     int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
147
148     if (avctx->bits_per_coded_sample > 8) {
149         av_log(avctx, AV_LOG_ERROR, "bits_per_coded_sample > 8 not supported\n");
150         return AVERROR_INVALIDDATA;
151     }
152
153     count = 1 << avctx->bits_per_coded_sample;
154     // If extradata is smaller than actually needed, fill the remaining with black.
155     count = FFMIN(palette_size / 3, count);
156     if (count) {
157         for (i=0; i < count; i++) {
158             pal[i] = 0xFF000000 | AV_RB24(palette + i*3);
159         }
160         if (s->flags && count >= 32) { // EHB
161             for (i = 0; i < 32; i++)
162                 pal[i + 32] = 0xFF000000 | (AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
163             count = FFMAX(count, 64);
164         }
165     } else { // Create gray-scale color palette for bps < 8
166         count = 1 << avctx->bits_per_coded_sample;
167
168         for (i=0; i < count; i++) {
169             pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
170         }
171     }
172     if (s->masking == MASK_HAS_MASK) {
173         memcpy(pal + (1 << avctx->bits_per_coded_sample), pal, count * 4);
174         for (i = 0; i < count; i++)
175             pal[i] &= 0xFFFFFF;
176     } else if (s->masking == MASK_HAS_TRANSPARENT_COLOR &&
177         s->transparency < 1 << avctx->bits_per_coded_sample)
178         pal[s->transparency] &= 0xFFFFFF;
179     return 0;
180 }
181
182 /**
183  * Extracts the IFF extra context and updates internal
184  * decoder structures.
185  *
186  * @param avctx the AVCodecContext where to extract extra context to
187  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
188  * @return 0 in case of success, a negative error code otherwise
189  */
190 static int extract_header(AVCodecContext *const avctx,
191                           const AVPacket *const avpkt) {
192     const uint8_t *buf;
193     unsigned buf_size;
194     IffContext *s = avctx->priv_data;
195     int i, palette_size;
196
197     if (avctx->extradata_size < 2) {
198         av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
199         return AVERROR_INVALIDDATA;
200     }
201     palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
202
203     if (avpkt) {
204         int image_size;
205         if (avpkt->size < 2)
206             return AVERROR_INVALIDDATA;
207         image_size = avpkt->size - AV_RB16(avpkt->data);
208         buf = avpkt->data;
209         buf_size = bytestream_get_be16(&buf);
210         if (buf_size <= 1 || image_size <= 1) {
211             av_log(avctx, AV_LOG_ERROR,
212                    "Invalid image size received: %u -> image data offset: %d\n",
213                    buf_size, image_size);
214             return AVERROR_INVALIDDATA;
215         }
216     } else {
217         buf = avctx->extradata;
218         buf_size = bytestream_get_be16(&buf);
219         if (buf_size <= 1 || palette_size < 0) {
220             av_log(avctx, AV_LOG_ERROR,
221                    "Invalid palette size received: %u -> palette data offset: %d\n",
222                    buf_size, palette_size);
223             return AVERROR_INVALIDDATA;
224         }
225     }
226
227     if (buf_size >= 41) {
228         s->compression  = bytestream_get_byte(&buf);
229         s->bpp          = bytestream_get_byte(&buf);
230         s->ham          = bytestream_get_byte(&buf);
231         s->flags        = bytestream_get_byte(&buf);
232         s->transparency = bytestream_get_be16(&buf);
233         s->masking      = bytestream_get_byte(&buf);
234         for (i = 0; i < 16; i++)
235             s->tvdc[i] = bytestream_get_be16(&buf);
236
237         if (s->masking == MASK_HAS_MASK) {
238             if (s->bpp >= 8 && !s->ham) {
239                 avctx->pix_fmt = AV_PIX_FMT_RGB32;
240                 av_freep(&s->mask_buf);
241                 av_freep(&s->mask_palbuf);
242                 s->mask_buf = av_malloc((s->planesize * 32) + FF_INPUT_BUFFER_PADDING_SIZE);
243                 if (!s->mask_buf)
244                     return AVERROR(ENOMEM);
245                 if (s->bpp > 16) {
246                     av_log(avctx, AV_LOG_ERROR, "bpp %d too large for palette\n", s->bpp);
247                     av_freep(&s->mask_buf);
248                     return AVERROR(ENOMEM);
249                 }
250                 s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
251                 if (!s->mask_palbuf) {
252                     av_freep(&s->mask_buf);
253                     return AVERROR(ENOMEM);
254                 }
255             }
256             s->bpp++;
257         } else if (s->masking != MASK_NONE && s->masking != MASK_HAS_TRANSPARENT_COLOR) {
258             av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
259             return AVERROR_PATCHWELCOME;
260         }
261         if (!s->bpp || s->bpp > 32) {
262             av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
263             return AVERROR_INVALIDDATA;
264         } else if (s->ham >= 8) {
265             av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
266             return AVERROR_INVALIDDATA;
267         }
268
269         av_freep(&s->ham_buf);
270         av_freep(&s->ham_palbuf);
271
272         if (s->ham) {
273             int i, count = FFMIN(palette_size / 3, 1 << s->ham);
274             int ham_count;
275             const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
276
277             s->ham_buf = av_malloc((s->planesize * 8) + FF_INPUT_BUFFER_PADDING_SIZE);
278             if (!s->ham_buf)
279                 return AVERROR(ENOMEM);
280
281             ham_count = 8 * (1 << s->ham);
282             s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
283             if (!s->ham_palbuf) {
284                 av_freep(&s->ham_buf);
285                 return AVERROR(ENOMEM);
286             }
287
288             if (count) { // HAM with color palette attached
289                 // prefill with black and palette and set HAM take direct value mask to zero
290                 memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
291                 for (i=0; i < count; i++) {
292                     s->ham_palbuf[i*2+1] = 0xFF000000 | AV_RL24(palette + i*3);
293                 }
294                 count = 1 << s->ham;
295             } else { // HAM with grayscale color palette
296                 count = 1 << s->ham;
297                 for (i=0; i < count; i++) {
298                     s->ham_palbuf[i*2]   = 0xFF000000; // take direct color value from palette
299                     s->ham_palbuf[i*2+1] = 0xFF000000 | av_le2ne32(gray2rgb((i * 255) >> s->ham));
300                 }
301             }
302             for (i=0; i < count; i++) {
303                 uint32_t tmp = i << (8 - s->ham);
304                 tmp |= tmp >> s->ham;
305                 s->ham_palbuf[(i+count)*2]     = 0xFF00FFFF; // just modify blue color component
306                 s->ham_palbuf[(i+count*2)*2]   = 0xFFFFFF00; // just modify red color component
307                 s->ham_palbuf[(i+count*3)*2]   = 0xFFFF00FF; // just modify green color component
308                 s->ham_palbuf[(i+count)*2+1]   = 0xFF000000 | tmp << 16;
309                 s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
310                 s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
311             }
312             if (s->masking == MASK_HAS_MASK) {
313                 for (i = 0; i < ham_count; i++)
314                     s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
315             }
316         }
317     }
318
319     return 0;
320 }
321
322 static av_cold int decode_init(AVCodecContext *avctx)
323 {
324     IffContext *s = avctx->priv_data;
325     int err;
326
327     if (avctx->bits_per_coded_sample <= 8) {
328         int palette_size;
329
330         if (avctx->extradata_size >= 2)
331             palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
332         else
333             palette_size = 0;
334         avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
335                          (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
336     } else if (avctx->bits_per_coded_sample <= 32) {
337         if (avctx->codec_tag != MKTAG('D','E','E','P')) {
338             if (avctx->bits_per_coded_sample == 24) {
339                 avctx->pix_fmt = AV_PIX_FMT_RGB0;
340             } else if (avctx->bits_per_coded_sample == 32) {
341                 avctx->pix_fmt = AV_PIX_FMT_BGR32;
342             } else {
343                 av_log_ask_for_sample(avctx, "unknown bits_per_coded_sample\n");
344                 return AVERROR_PATCHWELCOME;
345             }
346         }
347     } else {
348         return AVERROR_INVALIDDATA;
349     }
350
351     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
352         return err;
353     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
354     s->planebuf = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);
355     if (!s->planebuf)
356         return AVERROR(ENOMEM);
357
358     s->bpp = avctx->bits_per_coded_sample;
359     avcodec_get_frame_defaults(&s->frame);
360
361     if ((err = extract_header(avctx, NULL)) < 0)
362         return err;
363     s->frame.reference = 3;
364
365     return 0;
366 }
367
368 /**
369  * Decode interleaved plane buffer up to 8bpp
370  * @param dst Destination buffer
371  * @param buf Source buffer
372  * @param buf_size
373  * @param plane plane number to decode as
374  */
375 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
376 {
377     const uint64_t *lut = plane8_lut[plane];
378     if (plane >= 8) {
379         av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
380         return;
381     }
382     do {
383         uint64_t v = AV_RN64A(dst) | lut[*buf++];
384         AV_WN64A(dst, v);
385         dst += 8;
386     } while (--buf_size);
387 }
388
389 /**
390  * Decode interleaved plane buffer up to 24bpp
391  * @param dst Destination buffer
392  * @param buf Source buffer
393  * @param buf_size
394  * @param plane plane number to decode as
395  */
396 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
397 {
398     const uint32_t *lut = plane32_lut[plane];
399     do {
400         unsigned mask = (*buf >> 2) & ~3;
401         dst[0] |= lut[mask++];
402         dst[1] |= lut[mask++];
403         dst[2] |= lut[mask++];
404         dst[3] |= lut[mask];
405         mask = (*buf++ << 2) & 0x3F;
406         dst[4] |= lut[mask++];
407         dst[5] |= lut[mask++];
408         dst[6] |= lut[mask++];
409         dst[7] |= lut[mask];
410         dst += 8;
411     } while (--buf_size);
412 }
413
414 #define DECODE_HAM_PLANE32(x)       \
415     first       = buf[x] << 1;      \
416     second      = buf[(x)+1] << 1;  \
417     delta      &= pal[first++];     \
418     delta      |= pal[first];       \
419     dst[x]      = delta;            \
420     delta      &= pal[second++];    \
421     delta      |= pal[second];      \
422     dst[(x)+1]  = delta
423
424 /**
425  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
426  *
427  * @param dst the destination 24bpp buffer
428  * @param buf the source 8bpp chunky buffer
429  * @param pal the HAM decode table
430  * @param buf_size the plane size in bytes
431  */
432 static void decode_ham_plane32(uint32_t *dst, const uint8_t  *buf,
433                                const uint32_t *const pal, unsigned buf_size)
434 {
435     uint32_t delta = pal[1]; /* first palette entry */
436     do {
437         uint32_t first, second;
438         DECODE_HAM_PLANE32(0);
439         DECODE_HAM_PLANE32(2);
440         DECODE_HAM_PLANE32(4);
441         DECODE_HAM_PLANE32(6);
442         buf += 8;
443         dst += 8;
444     } while (--buf_size);
445 }
446
447 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
448                          const uint32_t *const pal, unsigned width)
449 {
450     do {
451         *dst++ = pal[*buf++];
452     } while (--width);
453 }
454
455 /**
456  * Decode one complete byterun1 encoded line.
457  *
458  * @param dst the destination buffer where to store decompressed bitstream
459  * @param dst_size the destination plane size in bytes
460  * @param buf the source byterun1 compressed bitstream
461  * @param buf_end the EOF of source byterun1 compressed bitstream
462  * @return number of consumed bytes in byterun1 compressed bitstream
463 */
464 static int decode_byterun(uint8_t *dst, int dst_size,
465                           const uint8_t *buf, const uint8_t *const buf_end) {
466     const uint8_t *const buf_start = buf;
467     unsigned x;
468     for (x = 0; x < dst_size && buf < buf_end;) {
469         unsigned length;
470         const int8_t value = *buf++;
471         if (value >= 0) {
472             length = value + 1;
473             memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
474             buf += length;
475         } else if (value > -128) {
476             length = -value + 1;
477             memset(dst + x, *buf++, FFMIN(length, dst_size - x));
478         } else { // noop
479             continue;
480         }
481         x += length;
482     }
483     return buf - buf_start;
484 }
485
486 /**
487  * Decode DEEP RLE 32-bit buffer
488  * @param[out] dst Destination buffer
489  * @param[in] src Source buffer
490  * @param src_size Source buffer size (bytes)
491  * @param width Width of destination buffer (pixels)
492  * @param height Height of destination buffer (pixels)
493  * @param linesize Line size of destination buffer (bytes)
494  */
495 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
496 {
497     const uint8_t *src_end = src + src_size;
498     int x = 0, y = 0, i;
499     while (src + 5 <= src_end) {
500         int opcode;
501         opcode = *(int8_t *)src++;
502         if (opcode >= 0) {
503             int size = opcode + 1;
504             for (i = 0; i < size; i++) {
505                 int length = FFMIN(size - i, width);
506                 memcpy(dst + y*linesize + x * 4, src, length * 4);
507                 src += length * 4;
508                 x += length;
509                 i += length;
510                 if (x >= width) {
511                     x = 0;
512                     y += 1;
513                     if (y >= height)
514                         return;
515                 }
516             }
517         } else {
518             int size = -opcode + 1;
519             uint32_t pixel = AV_RL32(src);
520             for (i = 0; i < size; i++) {
521                 *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
522                 x += 1;
523                 if (x >= width) {
524                     x = 0;
525                     y += 1;
526                     if (y >= height)
527                         return;
528                 }
529             }
530             src += 4;
531         }
532     }
533 }
534
535 /**
536  * Decode DEEP TVDC 32-bit buffer
537  * @param[out] dst Destination buffer
538  * @param[in] src Source buffer
539  * @param src_size Source buffer size (bytes)
540  * @param width Width of destination buffer (pixels)
541  * @param height Height of destination buffer (pixels)
542  * @param linesize Line size of destination buffer (bytes)
543  * @param[int] tvdc TVDC lookup table
544  */
545 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)
546 {
547     int x = 0, y = 0, plane = 0;
548     int8_t pixel = 0;
549     int i, j;
550
551     for (i = 0; i < src_size * 2;) {
552 #define GETNIBBLE ((i & 1) ?  (src[i>>1] & 0xF) : (src[i>>1] >> 4))
553         int d = tvdc[GETNIBBLE];
554         i++;
555         if (d) {
556             pixel += d;
557             dst[y * linesize + x*4 + plane] = pixel;
558             x++;
559         } else {
560             if (i >= src_size * 2)
561                 return;
562             d = GETNIBBLE + 1;
563             i++;
564             d = FFMIN(d, width - x);
565             for (j = 0; j < d; j++) {
566                 dst[y * linesize + x*4 + plane] = pixel;
567                 x++;
568             }
569         }
570         if (x >= width) {
571             plane++;
572             if (plane >= 4) {
573                 y++;
574                 if (y >= height)
575                     return;
576                 plane = 0;
577             }
578             x = 0;
579             pixel = 0;
580             i = (i + 1) & ~1;
581         }
582     }
583 }
584
585 static int unsupported(AVCodecContext *avctx)
586 {
587     IffContext *s = avctx->priv_data;
588     av_log_ask_for_sample(avctx, "unsupported bitmap (compression %i, bpp %i, ham %i)\n", s->compression, s->bpp, s->ham);
589     return AVERROR_INVALIDDATA;
590 }
591
592 static int decode_frame(AVCodecContext *avctx,
593                             void *data, int *data_size,
594                             AVPacket *avpkt)
595 {
596     IffContext *s = avctx->priv_data;
597     const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
598     const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
599     const uint8_t *buf_end = buf+buf_size;
600     int y, plane, res;
601
602     if ((res = extract_header(avctx, avpkt)) < 0)
603         return res;
604     if (s->init) {
605         if ((res = avctx->reget_buffer(avctx, &s->frame)) < 0) {
606             av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
607             return res;
608         }
609     } else if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
610         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
611         return res;
612     } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
613         if ((res = ff_cmap_read_palette(avctx, (uint32_t*)s->frame.data[1])) < 0)
614             return res;
615     } else if (avctx->pix_fmt == AV_PIX_FMT_RGB32 && avctx->bits_per_coded_sample <= 8) {
616         if ((res = ff_cmap_read_palette(avctx, s->mask_palbuf)) < 0)
617             return res;
618     }
619     s->init = 1;
620
621     switch (s->compression) {
622     case 0:
623         if (avctx->codec_tag == MKTAG('A','C','B','M')) {
624             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
625                 memset(s->frame.data[0], 0, avctx->height * s->frame.linesize[0]);
626                 for (plane = 0; plane < s->bpp; plane++) {
627                     for(y = 0; y < avctx->height && buf < buf_end; y++ ) {
628                         uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
629                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
630                         buf += s->planesize;
631                     }
632                 }
633             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
634                 memset(s->frame.data[0], 0, avctx->height * s->frame.linesize[0]);
635                 for(y = 0; y < avctx->height; y++) {
636                     uint8_t *row = &s->frame.data[0][y * s->frame.linesize[0]];
637                     memset(s->ham_buf, 0, s->planesize * 8);
638                     for (plane = 0; plane < s->bpp; plane++) {
639                         const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
640                         if (start >= buf_end)
641                             break;
642                         decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
643                     }
644                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
645                 }
646             } else
647                 return unsupported(avctx);
648         } else if (avctx->codec_tag == MKTAG('D','E','E','P')) {
649             const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
650             int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
651             int x;
652             for(y = 0; y < avctx->height && buf < buf_end; y++ ) {
653                 uint8_t *row = &s->frame.data[0][y * s->frame.linesize[0]];
654                 memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
655                 buf += raw_width;
656                 if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
657                     for(x = 0; x < avctx->width; x++)
658                         row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
659                 }
660             }
661         } else if (avctx->codec_tag == MKTAG('I','L','B','M')) { // interleaved
662             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
663                 for(y = 0; y < avctx->height; y++ ) {
664                     uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
665                     memset(row, 0, avctx->width);
666                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
667                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
668                         buf += s->planesize;
669                     }
670                 }
671             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
672                 for (y = 0; y < avctx->height; y++) {
673                     uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
674                     memset(s->ham_buf, 0, s->planesize * 8);
675                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
676                         decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
677                         buf += s->planesize;
678                     }
679                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
680                 }
681             } else { // AV_PIX_FMT_BGR32
682                 for(y = 0; y < avctx->height; y++ ) {
683                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
684                     memset(row, 0, avctx->width << 2);
685                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
686                         decodeplane32((uint32_t *) row, buf, FFMIN(s->planesize, buf_end - buf), plane);
687                         buf += s->planesize;
688                     }
689                 }
690             }
691         } else if (avctx->codec_tag == MKTAG('P','B','M',' ')) { // IFF-PBM
692             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
693                 for(y = 0; y < avctx->height && buf_end > buf; y++ ) {
694                     uint8_t *row = &s->frame.data[0][y * s->frame.linesize[0]];
695                     memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
696                     buf += avctx->width + (avctx->width % 2); // padding if odd
697                 }
698             } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
699                 for (y = 0; y < avctx->height && buf_end > buf; y++) {
700                     uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
701                     memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
702                     buf += avctx->width + (avctx->width & 1); // padding if odd
703                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
704                 }
705             } else
706                 return unsupported(avctx);
707         }
708         break;
709     case 1:
710         if (avctx->codec_tag == MKTAG('I','L','B','M')) { //interleaved
711             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
712                 for(y = 0; y < avctx->height ; y++ ) {
713                     uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
714                     memset(row, 0, avctx->width);
715                     for (plane = 0; plane < s->bpp; plane++) {
716                         buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
717                         decodeplane8(row, s->planebuf, s->planesize, plane);
718                     }
719                 }
720             } else if (avctx->bits_per_coded_sample <= 8) { //8-bit (+ mask) to AV_PIX_FMT_BGR32
721                 for (y = 0; y < avctx->height ; y++ ) {
722                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
723                     memset(s->mask_buf, 0, avctx->width * sizeof(uint32_t));
724                     for (plane = 0; plane < s->bpp; plane++) {
725                         buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
726                         decodeplane32(s->mask_buf, s->planebuf, s->planesize, plane);
727                     }
728                     lookup_pal_indicies((uint32_t *) row, s->mask_buf, s->mask_palbuf, avctx->width);
729                 }
730             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
731                 for (y = 0; y < avctx->height ; y++) {
732                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
733                     memset(s->ham_buf, 0, s->planesize * 8);
734                     for (plane = 0; plane < s->bpp; plane++) {
735                         buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
736                         decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
737                     }
738                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
739                 }
740             } else { //AV_PIX_FMT_BGR32
741                 for(y = 0; y < avctx->height ; y++ ) {
742                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
743                     memset(row, 0, avctx->width << 2);
744                     for (plane = 0; plane < s->bpp; plane++) {
745                         buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
746                         decodeplane32((uint32_t *) row, s->planebuf, s->planesize, plane);
747                     }
748                 }
749             }
750         } else if (avctx->codec_tag == MKTAG('P','B','M',' ')) { // IFF-PBM
751             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
752                 for(y = 0; y < avctx->height ; y++ ) {
753                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
754                     buf += decode_byterun(row, avctx->width, buf, buf_end);
755                 }
756             } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
757                 for (y = 0; y < avctx->height ; y++) {
758                     uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
759                     buf += decode_byterun(s->ham_buf, avctx->width, buf, buf_end);
760                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
761                 }
762             } else
763                 return unsupported(avctx);
764         } else if (avctx->codec_tag == MKTAG('D','E','E','P')) { // IFF-DEEP
765             const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
766             if (av_get_bits_per_pixel(desc) == 32)
767                 decode_deep_rle32(s->frame.data[0], buf, buf_size, avctx->width, avctx->height, s->frame.linesize[0]);
768             else
769                 return unsupported(avctx);
770         }
771         break;
772     case 5:
773         if (avctx->codec_tag == MKTAG('D','E','E','P')) {
774             const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
775             if (av_get_bits_per_pixel(desc) == 32)
776                 decode_deep_tvdc32(s->frame.data[0], buf, buf_size, avctx->width, avctx->height, s->frame.linesize[0], s->tvdc);
777             else
778                 return unsupported(avctx);
779         } else
780             return unsupported(avctx);
781         break;
782     default:
783         return unsupported(avctx);
784     }
785
786     *data_size = sizeof(AVFrame);
787     *(AVFrame*)data = s->frame;
788     return buf_size;
789 }
790
791 static av_cold int decode_end(AVCodecContext *avctx)
792 {
793     IffContext *s = avctx->priv_data;
794     if (s->frame.data[0])
795         avctx->release_buffer(avctx, &s->frame);
796     av_freep(&s->planebuf);
797     av_freep(&s->ham_buf);
798     av_freep(&s->ham_palbuf);
799     return 0;
800 }
801
802 #if CONFIG_IFF_ILBM_DECODER
803 AVCodec ff_iff_ilbm_decoder = {
804     .name           = "iff",
805     .type           = AVMEDIA_TYPE_VIDEO,
806     .id             = AV_CODEC_ID_IFF_ILBM,
807     .priv_data_size = sizeof(IffContext),
808     .init           = decode_init,
809     .close          = decode_end,
810     .decode         = decode_frame,
811     .capabilities   = CODEC_CAP_DR1,
812     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
813 };
814 #endif
815 #if CONFIG_IFF_BYTERUN1_DECODER
816 AVCodec ff_iff_byterun1_decoder = {
817     .name           = "iff",
818     .type           = AVMEDIA_TYPE_VIDEO,
819     .id             = AV_CODEC_ID_IFF_BYTERUN1,
820     .priv_data_size = sizeof(IffContext),
821     .init           = decode_init,
822     .close          = decode_end,
823     .decode         = decode_frame,
824     .capabilities   = CODEC_CAP_DR1,
825     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
826 };
827 #endif