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