lavc: factorize ff_{thread_,re,}get_buffer error messages.
[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         }
161         if (s->flags && count >= 32) { // EHB
162             for (i = 0; i < 32; i++)
163                 pal[i + 32] = 0xFF000000 | (AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
164             count = FFMAX(count, 64);
165         }
166     } else { // Create gray-scale color palette for bps < 8
167         count = 1 << avctx->bits_per_coded_sample;
168
169         for (i=0; i < count; i++) {
170             pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
171         }
172     }
173     if (s->masking == MASK_HAS_MASK) {
174         memcpy(pal + (1 << avctx->bits_per_coded_sample), pal, count * 4);
175         for (i = 0; i < count; i++)
176             pal[i] &= 0xFFFFFF;
177     } else if (s->masking == MASK_HAS_TRANSPARENT_COLOR &&
178         s->transparency < 1 << avctx->bits_per_coded_sample)
179         pal[s->transparency] &= 0xFFFFFF;
180     return 0;
181 }
182
183 /**
184  * Extracts the IFF extra context and updates internal
185  * decoder structures.
186  *
187  * @param avctx the AVCodecContext where to extract extra context to
188  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
189  * @return 0 in case of success, a negative error code otherwise
190  */
191 static int extract_header(AVCodecContext *const avctx,
192                           const AVPacket *const avpkt) {
193     const uint8_t *buf;
194     unsigned buf_size;
195     IffContext *s = avctx->priv_data;
196     int i, palette_size;
197
198     if (avctx->extradata_size < 2) {
199         av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
200         return AVERROR_INVALIDDATA;
201     }
202     palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
203
204     if (avpkt) {
205         int image_size;
206         if (avpkt->size < 2)
207             return AVERROR_INVALIDDATA;
208         image_size = avpkt->size - AV_RB16(avpkt->data);
209         buf = avpkt->data;
210         buf_size = bytestream_get_be16(&buf);
211         if (buf_size <= 1 || image_size <= 1) {
212             av_log(avctx, AV_LOG_ERROR,
213                    "Invalid image size received: %u -> image data offset: %d\n",
214                    buf_size, image_size);
215             return AVERROR_INVALIDDATA;
216         }
217     } else {
218         buf = avctx->extradata;
219         buf_size = bytestream_get_be16(&buf);
220         if (buf_size <= 1 || palette_size < 0) {
221             av_log(avctx, AV_LOG_ERROR,
222                    "Invalid palette size received: %u -> palette data offset: %d\n",
223                    buf_size, palette_size);
224             return AVERROR_INVALIDDATA;
225         }
226     }
227
228     if (buf_size >= 41) {
229         s->compression  = bytestream_get_byte(&buf);
230         s->bpp          = bytestream_get_byte(&buf);
231         s->ham          = bytestream_get_byte(&buf);
232         s->flags        = bytestream_get_byte(&buf);
233         s->transparency = bytestream_get_be16(&buf);
234         s->masking      = bytestream_get_byte(&buf);
235         for (i = 0; i < 16; i++)
236             s->tvdc[i] = bytestream_get_be16(&buf);
237
238         if (s->masking == MASK_HAS_MASK) {
239             if (s->bpp >= 8 && !s->ham) {
240                 avctx->pix_fmt = AV_PIX_FMT_RGB32;
241                 av_freep(&s->mask_buf);
242                 av_freep(&s->mask_palbuf);
243                 s->mask_buf = av_malloc((s->planesize * 32) + FF_INPUT_BUFFER_PADDING_SIZE);
244                 if (!s->mask_buf)
245                     return AVERROR(ENOMEM);
246                 if (s->bpp > 16) {
247                     av_log(avctx, AV_LOG_ERROR, "bpp %d too large for palette\n", s->bpp);
248                     av_freep(&s->mask_buf);
249                     return AVERROR(ENOMEM);
250                 }
251                 s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
252                 if (!s->mask_palbuf) {
253                     av_freep(&s->mask_buf);
254                     return AVERROR(ENOMEM);
255                 }
256             }
257             s->bpp++;
258         } else if (s->masking != MASK_NONE && s->masking != MASK_HAS_TRANSPARENT_COLOR) {
259             av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
260             return AVERROR_PATCHWELCOME;
261         }
262         if (!s->bpp || s->bpp > 32) {
263             av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
264             return AVERROR_INVALIDDATA;
265         } else if (s->ham >= 8) {
266             av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
267             return AVERROR_INVALIDDATA;
268         }
269
270         av_freep(&s->ham_buf);
271         av_freep(&s->ham_palbuf);
272
273         if (s->ham) {
274             int i, count = FFMIN(palette_size / 3, 1 << s->ham);
275             int ham_count;
276             const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
277
278             s->ham_buf = av_malloc((s->planesize * 8) + FF_INPUT_BUFFER_PADDING_SIZE);
279             if (!s->ham_buf)
280                 return AVERROR(ENOMEM);
281
282             ham_count = 8 * (1 << s->ham);
283             s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
284             if (!s->ham_palbuf) {
285                 av_freep(&s->ham_buf);
286                 return AVERROR(ENOMEM);
287             }
288
289             if (count) { // HAM with color palette attached
290                 // prefill with black and palette and set HAM take direct value mask to zero
291                 memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
292                 for (i=0; i < count; i++) {
293                     s->ham_palbuf[i*2+1] = 0xFF000000 | AV_RL24(palette + i*3);
294                 }
295                 count = 1 << s->ham;
296             } else { // HAM with grayscale color palette
297                 count = 1 << s->ham;
298                 for (i=0; i < count; i++) {
299                     s->ham_palbuf[i*2]   = 0xFF000000; // take direct color value from palette
300                     s->ham_palbuf[i*2+1] = 0xFF000000 | av_le2ne32(gray2rgb((i * 255) >> s->ham));
301                 }
302             }
303             for (i=0; i < count; i++) {
304                 uint32_t tmp = i << (8 - s->ham);
305                 tmp |= tmp >> s->ham;
306                 s->ham_palbuf[(i+count)*2]     = 0xFF00FFFF; // just modify blue color component
307                 s->ham_palbuf[(i+count*2)*2]   = 0xFFFFFF00; // just modify red color component
308                 s->ham_palbuf[(i+count*3)*2]   = 0xFFFF00FF; // just modify green color component
309                 s->ham_palbuf[(i+count)*2+1]   = 0xFF000000 | tmp << 16;
310                 s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
311                 s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
312             }
313             if (s->masking == MASK_HAS_MASK) {
314                 for (i = 0; i < ham_count; i++)
315                     s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
316             }
317         }
318     }
319
320     return 0;
321 }
322
323 static av_cold int decode_init(AVCodecContext *avctx)
324 {
325     IffContext *s = avctx->priv_data;
326     int err;
327
328     if (avctx->bits_per_coded_sample <= 8) {
329         int palette_size;
330
331         if (avctx->extradata_size >= 2)
332             palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
333         else
334             palette_size = 0;
335         avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
336                          (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
337     } else if (avctx->bits_per_coded_sample <= 32) {
338         if (avctx->codec_tag == MKTAG('R','G','B','8')) {
339             avctx->pix_fmt = AV_PIX_FMT_RGB32;
340         } else if (avctx->codec_tag == MKTAG('R','G','B','N')) {
341             avctx->pix_fmt = AV_PIX_FMT_RGB444;
342         } else if (avctx->codec_tag != MKTAG('D','E','E','P')) {
343             if (avctx->bits_per_coded_sample == 24) {
344                 avctx->pix_fmt = AV_PIX_FMT_0BGR32;
345             } else if (avctx->bits_per_coded_sample == 32) {
346                 avctx->pix_fmt = AV_PIX_FMT_BGR32;
347             } else {
348                 av_log_ask_for_sample(avctx, "unknown bits_per_coded_sample\n");
349                 return AVERROR_PATCHWELCOME;
350             }
351         }
352     } else {
353         return AVERROR_INVALIDDATA;
354     }
355
356     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
357         return err;
358     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
359     s->planebuf = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);
360     if (!s->planebuf)
361         return AVERROR(ENOMEM);
362
363     s->bpp = avctx->bits_per_coded_sample;
364     s->frame = av_frame_alloc();
365     if (!s->frame)
366         return AVERROR(ENOMEM);
367
368     if ((err = extract_header(avctx, NULL)) < 0)
369         return err;
370
371     return 0;
372 }
373
374 /**
375  * Decode interleaved plane buffer up to 8bpp
376  * @param dst Destination buffer
377  * @param buf Source buffer
378  * @param buf_size
379  * @param plane plane number to decode as
380  */
381 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
382 {
383     const uint64_t *lut = plane8_lut[plane];
384     if (plane >= 8) {
385         av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
386         return;
387     }
388     do {
389         uint64_t v = AV_RN64A(dst) | lut[*buf++];
390         AV_WN64A(dst, v);
391         dst += 8;
392     } while (--buf_size);
393 }
394
395 /**
396  * Decode interleaved plane buffer up to 24bpp
397  * @param dst Destination buffer
398  * @param buf Source buffer
399  * @param buf_size
400  * @param plane plane number to decode as
401  */
402 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
403 {
404     const uint32_t *lut = plane32_lut[plane];
405     do {
406         unsigned mask = (*buf >> 2) & ~3;
407         dst[0] |= lut[mask++];
408         dst[1] |= lut[mask++];
409         dst[2] |= lut[mask++];
410         dst[3] |= lut[mask];
411         mask = (*buf++ << 2) & 0x3F;
412         dst[4] |= lut[mask++];
413         dst[5] |= lut[mask++];
414         dst[6] |= lut[mask++];
415         dst[7] |= lut[mask];
416         dst += 8;
417     } while (--buf_size);
418 }
419
420 #define DECODE_HAM_PLANE32(x)       \
421     first       = buf[x] << 1;      \
422     second      = buf[(x)+1] << 1;  \
423     delta      &= pal[first++];     \
424     delta      |= pal[first];       \
425     dst[x]      = delta;            \
426     delta      &= pal[second++];    \
427     delta      |= pal[second];      \
428     dst[(x)+1]  = delta
429
430 /**
431  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
432  *
433  * @param dst the destination 24bpp buffer
434  * @param buf the source 8bpp chunky buffer
435  * @param pal the HAM decode table
436  * @param buf_size the plane size in bytes
437  */
438 static void decode_ham_plane32(uint32_t *dst, const uint8_t  *buf,
439                                const uint32_t *const pal, unsigned buf_size)
440 {
441     uint32_t delta = pal[1]; /* first palette entry */
442     do {
443         uint32_t first, second;
444         DECODE_HAM_PLANE32(0);
445         DECODE_HAM_PLANE32(2);
446         DECODE_HAM_PLANE32(4);
447         DECODE_HAM_PLANE32(6);
448         buf += 8;
449         dst += 8;
450     } while (--buf_size);
451 }
452
453 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
454                          const uint32_t *const pal, unsigned width)
455 {
456     do {
457         *dst++ = pal[*buf++];
458     } while (--width);
459 }
460
461 /**
462  * Decode one complete byterun1 encoded line.
463  *
464  * @param dst the destination buffer where to store decompressed bitstream
465  * @param dst_size the destination plane size in bytes
466  * @param buf the source byterun1 compressed bitstream
467  * @param buf_end the EOF of source byterun1 compressed bitstream
468  * @return number of consumed bytes in byterun1 compressed bitstream
469 */
470 static int decode_byterun(uint8_t *dst, int dst_size,
471                           const uint8_t *buf, const uint8_t *const buf_end) {
472     const uint8_t *const buf_start = buf;
473     unsigned x;
474     for (x = 0; x < dst_size && buf < buf_end;) {
475         unsigned length;
476         const int8_t value = *buf++;
477         if (value >= 0) {
478             length = value + 1;
479             memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
480             buf += length;
481         } else if (value > -128) {
482             length = -value + 1;
483             memset(dst + x, *buf++, FFMIN(length, dst_size - x));
484         } else { // noop
485             continue;
486         }
487         x += length;
488     }
489     return buf - buf_start;
490 }
491
492 #define DECODE_RGBX_COMMON(type) \
493     if (!length) { \
494         length = bytestream2_get_byte(gb); \
495         if (!length) { \
496             length = bytestream2_get_be16(gb); \
497             if (!length) \
498                 return; \
499         } \
500     } \
501     for (i = 0; i < length; i++) { \
502         *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
503         x += 1; \
504         if (x >= width) { \
505             y += 1; \
506             if (y >= height) \
507                 return; \
508             x = 0; \
509         } \
510     }
511
512 /**
513  * Decode RGB8 buffer
514  * @param[out] dst Destination buffer
515  * @param width Width of destination buffer (pixels)
516  * @param height Height of destination buffer (pixels)
517  * @param linesize Line size of destination buffer (bytes)
518  */
519 static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
520 {
521     int x = 0, y = 0, i, length;
522     while (bytestream2_get_bytes_left(gb) >= 4) {
523         uint32_t pixel = 0xFF000000 | bytestream2_get_be24(gb);
524         length = bytestream2_get_byte(gb) & 0x7F;
525         DECODE_RGBX_COMMON(uint32_t)
526     }
527 }
528
529 /**
530  * Decode RGBN buffer
531  * @param[out] dst Destination buffer
532  * @param width Width of destination buffer (pixels)
533  * @param height Height of destination buffer (pixels)
534  * @param linesize Line size of destination buffer (bytes)
535  */
536 static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
537 {
538     int x = 0, y = 0, i, length;
539     while (bytestream2_get_bytes_left(gb) >= 2) {
540         uint32_t pixel = bytestream2_get_be16u(gb);
541         length = pixel & 0x7;
542         pixel >>= 4;
543         DECODE_RGBX_COMMON(uint16_t)
544     }
545 }
546
547 /**
548  * Decode DEEP RLE 32-bit buffer
549  * @param[out] dst Destination buffer
550  * @param[in] src Source buffer
551  * @param src_size Source buffer size (bytes)
552  * @param width Width of destination buffer (pixels)
553  * @param height Height of destination buffer (pixels)
554  * @param linesize Line size of destination buffer (bytes)
555  */
556 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
557 {
558     const uint8_t *src_end = src + src_size;
559     int x = 0, y = 0, i;
560     while (src + 5 <= src_end) {
561         int opcode;
562         opcode = *(int8_t *)src++;
563         if (opcode >= 0) {
564             int size = opcode + 1;
565             for (i = 0; i < size; i++) {
566                 int length = FFMIN(size - i, width);
567                 memcpy(dst + y*linesize + x * 4, src, length * 4);
568                 src += length * 4;
569                 x += length;
570                 i += length;
571                 if (x >= width) {
572                     x = 0;
573                     y += 1;
574                     if (y >= height)
575                         return;
576                 }
577             }
578         } else {
579             int size = -opcode + 1;
580             uint32_t pixel = AV_RN32(src);
581             for (i = 0; i < size; i++) {
582                 *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
583                 x += 1;
584                 if (x >= width) {
585                     x = 0;
586                     y += 1;
587                     if (y >= height)
588                         return;
589                 }
590             }
591             src += 4;
592         }
593     }
594 }
595
596 /**
597  * Decode DEEP TVDC 32-bit buffer
598  * @param[out] dst Destination buffer
599  * @param[in] src Source buffer
600  * @param src_size Source buffer size (bytes)
601  * @param width Width of destination buffer (pixels)
602  * @param height Height of destination buffer (pixels)
603  * @param linesize Line size of destination buffer (bytes)
604  * @param[int] tvdc TVDC lookup table
605  */
606 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)
607 {
608     int x = 0, y = 0, plane = 0;
609     int8_t pixel = 0;
610     int i, j;
611
612     for (i = 0; i < src_size * 2;) {
613 #define GETNIBBLE ((i & 1) ?  (src[i>>1] & 0xF) : (src[i>>1] >> 4))
614         int d = tvdc[GETNIBBLE];
615         i++;
616         if (d) {
617             pixel += d;
618             dst[y * linesize + x*4 + plane] = pixel;
619             x++;
620         } else {
621             if (i >= src_size * 2)
622                 return;
623             d = GETNIBBLE + 1;
624             i++;
625             d = FFMIN(d, width - x);
626             for (j = 0; j < d; j++) {
627                 dst[y * linesize + x*4 + plane] = pixel;
628                 x++;
629             }
630         }
631         if (x >= width) {
632             plane++;
633             if (plane >= 4) {
634                 y++;
635                 if (y >= height)
636                     return;
637                 plane = 0;
638             }
639             x = 0;
640             pixel = 0;
641             i = (i + 1) & ~1;
642         }
643     }
644 }
645
646 static int unsupported(AVCodecContext *avctx)
647 {
648     IffContext *s = avctx->priv_data;
649     av_log_ask_for_sample(avctx, "unsupported bitmap (compression %i, bpp %i, ham %i)\n", s->compression, s->bpp, s->ham);
650     return AVERROR_INVALIDDATA;
651 }
652
653 static int decode_frame(AVCodecContext *avctx,
654                             void *data, int *got_frame,
655                             AVPacket *avpkt)
656 {
657     IffContext *s = avctx->priv_data;
658     const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
659     const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
660     const uint8_t *buf_end = buf+buf_size;
661     int y, plane, res;
662     GetByteContext gb;
663
664     if ((res = extract_header(avctx, avpkt)) < 0)
665         return res;
666     if ((res = ff_reget_buffer(avctx, s->frame)) < 0)
667         return res;
668     if (!s->init && avctx->bits_per_coded_sample <= 8 &&
669         avctx->pix_fmt == AV_PIX_FMT_PAL8) {
670         if ((res = cmap_read_palette(avctx, (uint32_t*)s->frame->data[1])) < 0)
671             return res;
672     } else if (!s->init && avctx->bits_per_coded_sample <= 8 &&
673                avctx->pix_fmt == AV_PIX_FMT_RGB32) {
674         if ((res = cmap_read_palette(avctx, s->mask_palbuf)) < 0)
675             return res;
676     }
677     s->init = 1;
678
679     switch (s->compression) {
680     case 0:
681         if (avctx->codec_tag == MKTAG('A','C','B','M')) {
682             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
683                 memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
684                 for (plane = 0; plane < s->bpp; plane++) {
685                     for(y = 0; y < avctx->height && buf < buf_end; y++ ) {
686                         uint8_t *row = &s->frame->data[0][ y*s->frame->linesize[0] ];
687                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
688                         buf += s->planesize;
689                     }
690                 }
691             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
692                 memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
693                 for(y = 0; y < avctx->height; y++) {
694                     uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
695                     memset(s->ham_buf, 0, s->planesize * 8);
696                     for (plane = 0; plane < s->bpp; plane++) {
697                         const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
698                         if (start >= buf_end)
699                             break;
700                         decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
701                     }
702                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
703                 }
704             } else
705                 return unsupported(avctx);
706         } else if (avctx->codec_tag == MKTAG('D','E','E','P')) {
707             const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
708             int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
709             int x;
710             for(y = 0; y < avctx->height && buf < buf_end; y++ ) {
711                 uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
712                 memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
713                 buf += raw_width;
714                 if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
715                     for(x = 0; x < avctx->width; x++)
716                         row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
717                 }
718             }
719         } else if (avctx->codec_tag == MKTAG('I','L','B','M')) { // interleaved
720             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
721                 for(y = 0; y < avctx->height; y++ ) {
722                     uint8_t *row = &s->frame->data[0][ y*s->frame->linesize[0] ];
723                     memset(row, 0, avctx->width);
724                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
725                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
726                         buf += s->planesize;
727                     }
728                 }
729             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
730                 for (y = 0; y < avctx->height; y++) {
731                     uint8_t *row = &s->frame->data[0][ y*s->frame->linesize[0] ];
732                     memset(s->ham_buf, 0, s->planesize * 8);
733                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
734                         decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
735                         buf += s->planesize;
736                     }
737                     decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
738                 }
739             } else { // AV_PIX_FMT_BGR32
740                 for(y = 0; y < avctx->height; y++ ) {
741                     uint8_t *row = &s->frame->data[0][y*s->frame->linesize[0]];
742                     memset(row, 0, avctx->width << 2);
743                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
744                         decodeplane32((uint32_t *) row, buf, 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     .type           = AVMEDIA_TYPE_VIDEO,
875     .id             = AV_CODEC_ID_IFF_ILBM,
876     .priv_data_size = sizeof(IffContext),
877     .init           = decode_init,
878     .close          = decode_end,
879     .decode         = decode_frame,
880     .capabilities   = CODEC_CAP_DR1,
881     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
882 };
883 #endif
884 #if CONFIG_IFF_BYTERUN1_DECODER
885 AVCodec ff_iff_byterun1_decoder = {
886     .name           = "iff",
887     .type           = AVMEDIA_TYPE_VIDEO,
888     .id             = AV_CODEC_ID_IFF_BYTERUN1,
889     .priv_data_size = sizeof(IffContext),
890     .init           = decode_init,
891     .close          = decode_end,
892     .decode         = decode_frame,
893     .capabilities   = CODEC_CAP_DR1,
894     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
895 };
896 #endif