avcodec/iff: Fix mask_buf / mask_palbuf leak
[ffmpeg.git] / libavcodec / iff.c
1 /*
2  * IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN bitmap decoder
3  * Copyright (c) 2010 Peter Ross <pross@xvid.org>
4  * Copyright (c) 2010 Sebastian Vater <cdgs.basty@googlemail.com>
5  * Copyright (c) 2016 Paul B Mahol
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN bitmap decoder
27  */
28
29 #include <stdint.h>
30
31 #include "libavutil/imgutils.h"
32
33 #include "bytestream.h"
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "mathops.h"
37
38 // TODO: masking bits
39 typedef enum {
40     MASK_NONE,
41     MASK_HAS_MASK,
42     MASK_HAS_TRANSPARENT_COLOR,
43     MASK_LASSO
44 } mask_type;
45
46 typedef struct IffContext {
47     AVFrame *frame;
48     int planesize;
49     uint8_t * planebuf;
50     uint8_t * ham_buf;      ///< temporary buffer for planar to chunky conversation
51     uint32_t *ham_palbuf;   ///< HAM decode table
52     uint32_t *mask_buf;     ///< temporary buffer for palette indices
53     uint32_t *mask_palbuf;  ///< masking palette table
54     unsigned  compression;  ///< delta compression method used
55     unsigned  is_short;     ///< short compression method used
56     unsigned  is_interlaced;///< video is interlaced
57     unsigned  is_brush;     ///< video is in ANBR format
58     unsigned  bpp;          ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
59     unsigned  ham;          ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
60     unsigned  flags;        ///< 1 for EHB, 0 is no extra half darkening
61     unsigned  transparency; ///< TODO: transparency color index in palette
62     unsigned  masking;      ///< TODO: masking method used
63     int init; // 1 if buffer and palette data already initialized, 0 otherwise
64     int16_t   tvdc[16];     ///< TVDC lookup table
65     GetByteContext gb;
66     uint8_t *video[2];
67     unsigned video_size;
68     uint32_t *pal;
69 } IffContext;
70
71 #define LUT8_PART(plane, v)                             \
72     AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
73     AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
74     AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
75     AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
76     AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
77     AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
78     AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
79     AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
80     AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
81     AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
82     AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
83     AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
84     AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
85     AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
86     AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
87     AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
88
89 #define LUT8(plane) {                           \
90     LUT8_PART(plane, 0x0000000),                \
91     LUT8_PART(plane, 0x1000000),                \
92     LUT8_PART(plane, 0x0010000),                \
93     LUT8_PART(plane, 0x1010000),                \
94     LUT8_PART(plane, 0x0000100),                \
95     LUT8_PART(plane, 0x1000100),                \
96     LUT8_PART(plane, 0x0010100),                \
97     LUT8_PART(plane, 0x1010100),                \
98     LUT8_PART(plane, 0x0000001),                \
99     LUT8_PART(plane, 0x1000001),                \
100     LUT8_PART(plane, 0x0010001),                \
101     LUT8_PART(plane, 0x1010001),                \
102     LUT8_PART(plane, 0x0000101),                \
103     LUT8_PART(plane, 0x1000101),                \
104     LUT8_PART(plane, 0x0010101),                \
105     LUT8_PART(plane, 0x1010101),                \
106 }
107
108 // 8 planes * 8-bit mask
109 static const uint64_t plane8_lut[8][256] = {
110     LUT8(0), LUT8(1), LUT8(2), LUT8(3),
111     LUT8(4), LUT8(5), LUT8(6), LUT8(7),
112 };
113
114 #define LUT32(plane) {                                \
115              0,          0,          0,          0,   \
116              0,          0,          0, 1 << plane,   \
117              0,          0, 1 << plane,          0,   \
118              0,          0, 1 << plane, 1 << plane,   \
119              0, 1 << plane,          0,          0,   \
120              0, 1 << plane,          0, 1 << plane,   \
121              0, 1 << plane, 1 << plane,          0,   \
122              0, 1 << plane, 1 << plane, 1 << plane,   \
123     1 << plane,          0,          0,          0,   \
124     1 << plane,          0,          0, 1 << plane,   \
125     1 << plane,          0, 1 << plane,          0,   \
126     1 << plane,          0, 1 << plane, 1 << plane,   \
127     1 << plane, 1 << plane,          0,          0,   \
128     1 << plane, 1 << plane,          0, 1 << plane,   \
129     1 << plane, 1 << plane, 1 << plane,          0,   \
130     1 << plane, 1 << plane, 1 << plane, 1 << plane,   \
131 }
132
133 // 32 planes * 4-bit mask * 4 lookup tables each
134 static const uint32_t plane32_lut[32][16*4] = {
135     LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
136     LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
137     LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
138     LUT32(12), LUT32(13), LUT32(14), LUT32(15),
139     LUT32(16), LUT32(17), LUT32(18), LUT32(19),
140     LUT32(20), LUT32(21), LUT32(22), LUT32(23),
141     LUT32(24), LUT32(25), LUT32(26), LUT32(27),
142     LUT32(28), LUT32(29), LUT32(30), LUT32(31),
143 };
144
145 // Gray to RGB, required for palette table of grayscale images with bpp < 8
146 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
147     return x << 16 | x << 8 | x;
148 }
149
150 /**
151  * Convert CMAP buffer (stored in extradata) to lavc palette format
152  */
153 static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
154 {
155     IffContext *s = avctx->priv_data;
156     int count, i;
157     const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
158     int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
159
160     if (avctx->bits_per_coded_sample > 8) {
161         av_log(avctx, AV_LOG_ERROR, "bits_per_coded_sample > 8 not supported\n");
162         return AVERROR_INVALIDDATA;
163     }
164
165     count = 1 << avctx->bits_per_coded_sample;
166     // If extradata is smaller than actually needed, fill the remaining with black.
167     count = FFMIN(palette_size / 3, count);
168     if (count) {
169         for (i = 0; i < count; i++)
170             pal[i] = 0xFF000000 | AV_RB24(palette + i*3);
171         if (s->flags && count >= 32) { // EHB
172             for (i = 0; i < 32; i++)
173                 pal[i + 32] = 0xFF000000 | (AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
174             count = FFMAX(count, 64);
175         }
176     } else { // Create gray-scale color palette for bps < 8
177         count = 1 << avctx->bits_per_coded_sample;
178
179         for (i = 0; i < count; i++)
180             pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
181     }
182     if (s->masking == MASK_HAS_MASK) {
183         memcpy(pal + (1 << avctx->bits_per_coded_sample), pal, count * 4);
184         for (i = 0; i < count; i++)
185             pal[i] &= 0xFFFFFF;
186     } else if (s->masking == MASK_HAS_TRANSPARENT_COLOR &&
187         s->transparency < 1 << avctx->bits_per_coded_sample)
188         pal[s->transparency] &= 0xFFFFFF;
189     return 0;
190 }
191
192 /**
193  * Extracts the IFF extra context and updates internal
194  * decoder structures.
195  *
196  * @param avctx the AVCodecContext where to extract extra context to
197  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
198  * @return >= 0 in case of success, a negative error code otherwise
199  */
200 static int extract_header(AVCodecContext *const avctx,
201                           const AVPacket *const avpkt)
202 {
203     IffContext *s = avctx->priv_data;
204     const uint8_t *buf;
205     unsigned buf_size = 0;
206     int i, palette_size;
207
208     if (avctx->extradata_size < 2) {
209         av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
210         return AVERROR_INVALIDDATA;
211     }
212     palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
213
214     if (avpkt && avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
215         uint32_t chunk_id;
216         uint64_t data_size;
217         GetByteContext *gb = &s->gb;
218
219         bytestream2_skip(gb, 4);
220         while (bytestream2_get_bytes_left(gb) >= 1) {
221             chunk_id  = bytestream2_get_le32(gb);
222             data_size = bytestream2_get_be32(gb);
223
224             if (chunk_id == MKTAG('B', 'M', 'H', 'D')) {
225                 bytestream2_skip(gb, data_size + (data_size & 1));
226             } else if (chunk_id == MKTAG('A', 'N', 'H', 'D')) {
227                 unsigned extra;
228                 if (data_size < 40)
229                     return AVERROR_INVALIDDATA;
230
231                 s->compression = (bytestream2_get_byte(gb) << 8) | (s->compression & 0xFF);
232                 bytestream2_skip(gb, 19);
233                 extra = bytestream2_get_be32(gb);
234                 s->is_short = !(extra & 1);
235                 s->is_brush = extra == 2;
236                 s->is_interlaced = !!(extra & 0x40);
237                 data_size -= 24;
238                 bytestream2_skip(gb, data_size + (data_size & 1));
239             } else if (chunk_id == MKTAG('D', 'L', 'T', 'A') ||
240                        chunk_id == MKTAG('B', 'O', 'D', 'Y')) {
241                 if (chunk_id == MKTAG('B','O','D','Y'))
242                     s->compression &= 0xFF;
243                 break;
244             } else if (chunk_id == MKTAG('C', 'M', 'A', 'P')) {
245                 int count = data_size / 3;
246                 uint32_t *pal = s->pal;
247
248                 if (count > 256)
249                     return AVERROR_INVALIDDATA;
250                 if (s->ham) {
251                     for (i = 0; i < count; i++)
252                         pal[i] = 0xFF000000 | bytestream2_get_le24(gb);
253                 } else {
254                     for (i = 0; i < count; i++)
255                         pal[i] = 0xFF000000 | bytestream2_get_be24(gb);
256                 }
257                 bytestream2_skip(gb, data_size & 1);
258             } else {
259                 bytestream2_skip(gb, data_size + (data_size&1));
260             }
261         }
262     } else if (!avpkt) {
263         buf = avctx->extradata;
264         buf_size = bytestream_get_be16(&buf);
265         if (buf_size <= 1 || palette_size < 0) {
266             av_log(avctx, AV_LOG_ERROR,
267                    "Invalid palette size received: %u -> palette data offset: %d\n",
268                    buf_size, palette_size);
269             return AVERROR_INVALIDDATA;
270         }
271     }
272
273     if (buf_size >= 41) {
274         s->compression  = bytestream_get_byte(&buf);
275         s->bpp          = bytestream_get_byte(&buf);
276         s->ham          = bytestream_get_byte(&buf);
277         s->flags        = bytestream_get_byte(&buf);
278         s->transparency = bytestream_get_be16(&buf);
279         s->masking      = bytestream_get_byte(&buf);
280         for (i = 0; i < 16; i++)
281             s->tvdc[i] = bytestream_get_be16(&buf);
282
283         if (s->masking == MASK_HAS_MASK) {
284             if (s->bpp >= 8 && !s->ham) {
285                 avctx->pix_fmt = AV_PIX_FMT_RGB32;
286                 av_freep(&s->mask_buf);
287                 av_freep(&s->mask_palbuf);
288                 s->mask_buf = av_malloc((s->planesize * 32) + AV_INPUT_BUFFER_PADDING_SIZE);
289                 if (!s->mask_buf)
290                     return AVERROR(ENOMEM);
291                 if (s->bpp > 16) {
292                     av_log(avctx, AV_LOG_ERROR, "bpp %d too large for palette\n", s->bpp);
293                     av_freep(&s->mask_buf);
294                     return AVERROR(ENOMEM);
295                 }
296                 s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);
297                 if (!s->mask_palbuf) {
298                     av_freep(&s->mask_buf);
299                     return AVERROR(ENOMEM);
300                 }
301             }
302             s->bpp++;
303         } else if (s->masking != MASK_NONE && s->masking != MASK_HAS_TRANSPARENT_COLOR) {
304             av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
305             return AVERROR_PATCHWELCOME;
306         }
307         if (!s->bpp || s->bpp > 32) {
308             av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
309             return AVERROR_INVALIDDATA;
310         } else if (s->ham >= 8) {
311             av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
312             return AVERROR_INVALIDDATA;
313         }
314
315         av_freep(&s->ham_buf);
316         av_freep(&s->ham_palbuf);
317
318         if (s->ham) {
319             int i, count = FFMIN(palette_size / 3, 1 << s->ham);
320             int ham_count;
321             const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
322
323             s->ham_buf = av_malloc((s->planesize * 8) + AV_INPUT_BUFFER_PADDING_SIZE);
324             if (!s->ham_buf)
325                 return AVERROR(ENOMEM);
326
327             ham_count = 8 * (1 << s->ham);
328             s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);
329             if (!s->ham_palbuf) {
330                 av_freep(&s->ham_buf);
331                 return AVERROR(ENOMEM);
332             }
333
334             if (count) { // HAM with color palette attached
335                 // prefill with black and palette and set HAM take direct value mask to zero
336                 memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
337                 for (i=0; i < count; i++) {
338                     s->ham_palbuf[i*2+1] = 0xFF000000 | AV_RL24(palette + i*3);
339                 }
340                 count = 1 << s->ham;
341             } else { // HAM with grayscale color palette
342                 count = 1 << s->ham;
343                 for (i=0; i < count; i++) {
344                     s->ham_palbuf[i*2]   = 0xFF000000; // take direct color value from palette
345                     s->ham_palbuf[i*2+1] = 0xFF000000 | av_le2ne32(gray2rgb((i * 255) >> s->ham));
346                 }
347             }
348             for (i=0; i < count; i++) {
349                 uint32_t tmp = i << (8 - s->ham);
350                 tmp |= tmp >> s->ham;
351                 s->ham_palbuf[(i+count)*2]     = 0xFF00FFFF; // just modify blue color component
352                 s->ham_palbuf[(i+count*2)*2]   = 0xFFFFFF00; // just modify red color component
353                 s->ham_palbuf[(i+count*3)*2]   = 0xFFFF00FF; // just modify green color component
354                 s->ham_palbuf[(i+count)*2+1]   = 0xFF000000 | tmp << 16;
355                 s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
356                 s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
357             }
358             if (s->masking == MASK_HAS_MASK) {
359                 for (i = 0; i < ham_count; i++)
360                     s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
361             }
362         }
363     }
364
365     return 0;
366 }
367
368 static av_cold int decode_end(AVCodecContext *avctx)
369 {
370     IffContext *s = avctx->priv_data;
371     av_freep(&s->planebuf);
372     av_freep(&s->ham_buf);
373     av_freep(&s->ham_palbuf);
374     av_freep(&s->mask_buf);
375     av_freep(&s->mask_palbuf);
376     av_freep(&s->video[0]);
377     av_freep(&s->video[1]);
378     av_freep(&s->pal);
379     return 0;
380 }
381
382 static av_cold int decode_init(AVCodecContext *avctx)
383 {
384     IffContext *s = avctx->priv_data;
385     int err;
386
387     if (avctx->bits_per_coded_sample <= 8) {
388         int palette_size;
389
390         if (avctx->extradata_size >= 2)
391             palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
392         else
393             palette_size = 0;
394         avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
395                          (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
396     } else if (avctx->bits_per_coded_sample <= 32) {
397         if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8')) {
398             avctx->pix_fmt = AV_PIX_FMT_RGB32;
399         } else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N')) {
400             avctx->pix_fmt = AV_PIX_FMT_RGB444;
401         } else if (avctx->codec_tag != MKTAG('D', 'E', 'E', 'P')) {
402             if (avctx->bits_per_coded_sample == 24) {
403                 avctx->pix_fmt = AV_PIX_FMT_0BGR32;
404             } else if (avctx->bits_per_coded_sample == 32) {
405                 avctx->pix_fmt = AV_PIX_FMT_BGR32;
406             } else {
407                 avpriv_request_sample(avctx, "unknown bits_per_coded_sample");
408                 return AVERROR_PATCHWELCOME;
409             }
410         }
411     } else {
412         return AVERROR_INVALIDDATA;
413     }
414
415     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
416         return err;
417     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
418     s->planebuf  = av_malloc(s->planesize * avctx->height + AV_INPUT_BUFFER_PADDING_SIZE);
419     if (!s->planebuf)
420         return AVERROR(ENOMEM);
421
422     s->bpp = avctx->bits_per_coded_sample;
423
424     if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
425         s->video_size = FFALIGN(avctx->width, 2) * avctx->height * s->bpp;
426         s->video[0] = av_calloc(FFALIGN(avctx->width, 2) * avctx->height, s->bpp);
427         s->video[1] = av_calloc(FFALIGN(avctx->width, 2) * avctx->height, s->bpp);
428         s->pal = av_calloc(256, sizeof(*s->pal));
429         if (!s->video[0] || !s->video[1] || !s->pal)
430             return AVERROR(ENOMEM);
431     }
432
433     if ((err = extract_header(avctx, NULL)) < 0)
434         return err;
435
436     return 0;
437 }
438
439 /**
440  * Decode interleaved plane buffer up to 8bpp
441  * @param dst Destination buffer
442  * @param buf Source buffer
443  * @param buf_size
444  * @param plane plane number to decode as
445  */
446 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
447 {
448     const uint64_t *lut = plane8_lut[plane];
449     if (plane >= 8) {
450         av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
451         return;
452     }
453     do {
454         uint64_t v = AV_RN64A(dst) | lut[*buf++];
455         AV_WN64A(dst, v);
456         dst += 8;
457     } while (--buf_size);
458 }
459
460 /**
461  * Decode interleaved plane buffer up to 24bpp
462  * @param dst Destination buffer
463  * @param buf Source buffer
464  * @param buf_size
465  * @param plane plane number to decode as
466  */
467 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
468 {
469     const uint32_t *lut = plane32_lut[plane];
470     do {
471         unsigned mask = (*buf >> 2) & ~3;
472         dst[0] |= lut[mask++];
473         dst[1] |= lut[mask++];
474         dst[2] |= lut[mask++];
475         dst[3] |= lut[mask];
476         mask    = (*buf++ << 2) & 0x3F;
477         dst[4] |= lut[mask++];
478         dst[5] |= lut[mask++];
479         dst[6] |= lut[mask++];
480         dst[7] |= lut[mask];
481         dst    += 8;
482     } while (--buf_size);
483 }
484
485 #define DECODE_HAM_PLANE32(x)       \
486     first       = buf[x] << 1;      \
487     second      = buf[(x)+1] << 1;  \
488     delta      &= pal[first++];     \
489     delta      |= pal[first];       \
490     dst[x]      = delta;            \
491     delta      &= pal[second++];    \
492     delta      |= pal[second];      \
493     dst[(x)+1]  = delta
494
495 /**
496  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
497  *
498  * @param dst the destination 24bpp buffer
499  * @param buf the source 8bpp chunky buffer
500  * @param pal the HAM decode table
501  * @param buf_size the plane size in bytes
502  */
503 static void decode_ham_plane32(uint32_t *dst, const uint8_t  *buf,
504                                const uint32_t *const pal, unsigned buf_size)
505 {
506     uint32_t delta = pal[1]; /* first palette entry */
507     do {
508         uint32_t first, second;
509         DECODE_HAM_PLANE32(0);
510         DECODE_HAM_PLANE32(2);
511         DECODE_HAM_PLANE32(4);
512         DECODE_HAM_PLANE32(6);
513         buf += 8;
514         dst += 8;
515     } while (--buf_size);
516 }
517
518 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
519                          const uint32_t *const pal, unsigned width)
520 {
521     do {
522         *dst++ = pal[*buf++];
523     } while (--width);
524 }
525
526 /**
527  * Decode one complete byterun1 encoded line.
528  *
529  * @param dst the destination buffer where to store decompressed bitstream
530  * @param dst_size the destination plane size in bytes
531  * @param buf the source byterun1 compressed bitstream
532  * @param buf_end the EOF of source byterun1 compressed bitstream
533  * @return number of consumed bytes in byterun1 compressed bitstream
534  */
535 static int decode_byterun(uint8_t *dst, int dst_size,
536                           GetByteContext *gb)
537 {
538     unsigned x;
539     for (x = 0; x < dst_size && bytestream2_get_bytes_left(gb) > 0;) {
540         unsigned length;
541         const int8_t value = bytestream2_get_byte(gb);
542         if (value >= 0) {
543             length = FFMIN3(value + 1, dst_size - x, bytestream2_get_bytes_left(gb));
544             bytestream2_get_buffer(gb, dst + x, length);
545             if (length < value + 1)
546                 bytestream2_skip(gb, value + 1 - length);
547         } else if (value > -128) {
548             length = FFMIN(-value + 1, dst_size - x);
549             memset(dst + x, bytestream2_get_byte(gb), length);
550         } else { // noop
551             continue;
552         }
553         x += length;
554     }
555     if (x < dst_size) {
556         av_log(NULL, AV_LOG_WARNING, "decode_byterun ended before plane size\n");
557         memset(dst+x, 0, dst_size - x);
558     }
559     return bytestream2_tell(gb);
560 }
561
562 static int decode_byterun2(uint8_t *dst, int height, int line_size,
563                            GetByteContext *gb)
564 {
565     GetByteContext cmds;
566     unsigned count;
567     int i, y_pos = 0, x_pos = 0;
568
569     if (bytestream2_get_be32(gb) != MKBETAG('V', 'D', 'A', 'T'))
570         return 0;
571
572     bytestream2_skip(gb, 4);
573     count = bytestream2_get_be16(gb) - 2;
574     if (bytestream2_get_bytes_left(gb) < count)
575         return 0;
576
577     bytestream2_init(&cmds, gb->buffer, count);
578     bytestream2_skip(gb, count);
579
580     for (i = 0; i < count && x_pos < line_size; i++) {
581         int8_t cmd = bytestream2_get_byte(&cmds);
582         int l, r;
583
584         if (cmd == 0) {
585             l = bytestream2_get_be16(gb);
586             while (l-- > 0 && x_pos < line_size) {
587                 dst[x_pos + y_pos   * line_size    ] = bytestream2_get_byte(gb);
588                 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
589                 if (y_pos >= height) {
590                     y_pos  = 0;
591                     x_pos += 2;
592                 }
593             }
594         } else if (cmd < 0) {
595             l = -cmd;
596             while (l-- > 0 && x_pos < line_size) {
597                 dst[x_pos + y_pos   * line_size    ] = bytestream2_get_byte(gb);
598                 dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
599                 if (y_pos >= height) {
600                     y_pos  = 0;
601                     x_pos += 2;
602                 }
603             }
604         } else if (cmd == 1) {
605             l = bytestream2_get_be16(gb);
606             r = bytestream2_get_be16(gb);
607             while (l-- > 0 && x_pos < line_size) {
608                 dst[x_pos + y_pos   * line_size    ] = r >> 8;
609                 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
610                 if (y_pos >= height) {
611                     y_pos  = 0;
612                     x_pos += 2;
613                 }
614             }
615         } else {
616             l = cmd;
617             r = bytestream2_get_be16(gb);
618             while (l-- > 0 && x_pos < line_size) {
619                 dst[x_pos + y_pos   * line_size    ] = r >> 8;
620                 dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
621                 if (y_pos >= height) {
622                     y_pos  = 0;
623                     x_pos += 2;
624                 }
625             }
626         }
627     }
628
629     return bytestream2_tell(gb);
630 }
631
632 #define DECODE_RGBX_COMMON(type) \
633     if (!length) { \
634         length = bytestream2_get_byte(gb); \
635         if (!length) { \
636             length = bytestream2_get_be16(gb); \
637             if (!length) \
638                 return; \
639         } \
640     } \
641     for (i = 0; i < length; i++) { \
642         *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
643         x += 1; \
644         if (x >= width) { \
645             y += 1; \
646             if (y >= height) \
647                 return; \
648             x = 0; \
649         } \
650     }
651
652 /**
653  * Decode RGB8 buffer
654  * @param[out] dst Destination buffer
655  * @param width Width of destination buffer (pixels)
656  * @param height Height of destination buffer (pixels)
657  * @param linesize Line size of destination buffer (bytes)
658  */
659 static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
660 {
661     int x = 0, y = 0, i, length;
662     while (bytestream2_get_bytes_left(gb) >= 4) {
663         uint32_t pixel = 0xFF000000 | bytestream2_get_be24(gb);
664         length = bytestream2_get_byte(gb) & 0x7F;
665         DECODE_RGBX_COMMON(uint32_t)
666     }
667 }
668
669 /**
670  * Decode RGBN buffer
671  * @param[out] dst Destination buffer
672  * @param width Width of destination buffer (pixels)
673  * @param height Height of destination buffer (pixels)
674  * @param linesize Line size of destination buffer (bytes)
675  */
676 static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
677 {
678     int x = 0, y = 0, i, length;
679     while (bytestream2_get_bytes_left(gb) >= 2) {
680         uint32_t pixel = bytestream2_get_be16u(gb);
681         length = pixel & 0x7;
682         pixel >>= 4;
683         DECODE_RGBX_COMMON(uint16_t)
684     }
685 }
686
687 /**
688  * Decode DEEP RLE 32-bit buffer
689  * @param[out] dst Destination buffer
690  * @param[in] src Source buffer
691  * @param src_size Source buffer size (bytes)
692  * @param width Width of destination buffer (pixels)
693  * @param height Height of destination buffer (pixels)
694  * @param linesize Line size of destination buffer (bytes)
695  */
696 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
697 {
698     const uint8_t *src_end = src + src_size;
699     int x = 0, y = 0, i;
700     while (src + 5 <= src_end) {
701         int opcode;
702         opcode = *(int8_t *)src++;
703         if (opcode >= 0) {
704             int size = opcode + 1;
705             for (i = 0; i < size; i++) {
706                 int length = FFMIN(size - i, width);
707                 memcpy(dst + y*linesize + x * 4, src, length * 4);
708                 src += length * 4;
709                 x += length;
710                 i += length;
711                 if (x >= width) {
712                     x = 0;
713                     y += 1;
714                     if (y >= height)
715                         return;
716                 }
717             }
718         } else {
719             int size = -opcode + 1;
720             uint32_t pixel = AV_RN32(src);
721             for (i = 0; i < size; i++) {
722                 *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
723                 x += 1;
724                 if (x >= width) {
725                     x = 0;
726                     y += 1;
727                     if (y >= height)
728                         return;
729                 }
730             }
731             src += 4;
732         }
733     }
734 }
735
736 /**
737  * Decode DEEP TVDC 32-bit buffer
738  * @param[out] dst Destination buffer
739  * @param[in] src Source buffer
740  * @param src_size Source buffer size (bytes)
741  * @param width Width of destination buffer (pixels)
742  * @param height Height of destination buffer (pixels)
743  * @param linesize Line size of destination buffer (bytes)
744  * @param[int] tvdc TVDC lookup table
745  */
746 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)
747 {
748     int x = 0, y = 0, plane = 0;
749     int8_t pixel = 0;
750     int i, j;
751
752     for (i = 0; i < src_size * 2;) {
753 #define GETNIBBLE ((i & 1) ?  (src[i>>1] & 0xF) : (src[i>>1] >> 4))
754         int d = tvdc[GETNIBBLE];
755         i++;
756         if (d) {
757             pixel += d;
758             dst[y * linesize + x*4 + plane] = pixel;
759             x++;
760         } else {
761             if (i >= src_size * 2)
762                 return;
763             d = GETNIBBLE + 1;
764             i++;
765             d = FFMIN(d, width - x);
766             for (j = 0; j < d; j++) {
767                 dst[y * linesize + x*4 + plane] = pixel;
768                 x++;
769             }
770         }
771         if (x >= width) {
772             plane++;
773             if (plane >= 4) {
774                 y++;
775                 if (y >= height)
776                     return;
777                 plane = 0;
778             }
779             x = 0;
780             pixel = 0;
781             i = (i + 1) & ~1;
782         }
783     }
784 }
785
786 static void decode_short_horizontal_delta(uint8_t *dst,
787                                           const uint8_t *buf, const uint8_t *buf_end,
788                                           int w, int bpp, int dst_size)
789 {
790     int planepitch = FFALIGN(w, 16) >> 3;
791     int pitch = planepitch * bpp;
792     GetByteContext ptrs, gb;
793     PutByteContext pb;
794     unsigned ofssrc, pos;
795     int i, k;
796
797     bytestream2_init(&ptrs, buf, buf_end - buf);
798     bytestream2_init_writer(&pb, dst, dst_size);
799
800     for (k = 0; k < bpp; k++) {
801         ofssrc = bytestream2_get_be32(&ptrs);
802         pos = 0;
803
804         if (!ofssrc)
805             continue;
806
807         if (ofssrc >= buf_end - buf)
808             continue;
809
810         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
811         while (bytestream2_peek_be16(&gb) != 0xFFFF && bytestream2_get_bytes_left(&gb) > 3) {
812             int16_t offset = bytestream2_get_be16(&gb);
813             unsigned noffset;
814
815             if (offset >= 0) {
816                 unsigned data = bytestream2_get_be16(&gb);
817
818                 pos += offset * 2;
819                 noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
820                 bytestream2_seek_p(&pb, noffset, SEEK_SET);
821                 bytestream2_put_be16(&pb, data);
822             } else {
823                 uint16_t count = bytestream2_get_be16(&gb);
824
825                 pos += 2 * -(offset + 2);
826                 for (i = 0; i < count; i++) {
827                     uint16_t data = bytestream2_get_be16(&gb);
828
829                     pos += 2;
830                     noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
831                     bytestream2_seek_p(&pb, noffset, SEEK_SET);
832                     bytestream2_put_be16(&pb, data);
833                 }
834             }
835         }
836     }
837 }
838
839 static void decode_byte_vertical_delta(uint8_t *dst,
840                                        const uint8_t *buf, const uint8_t *buf_end,
841                                        int w, int xor, int bpp, int dst_size)
842 {
843     int ncolumns = ((w + 15) / 16) * 2;
844     int dstpitch = ncolumns * bpp;
845     unsigned ofsdst, ofssrc, opcode, x;
846     GetByteContext ptrs, gb;
847     PutByteContext pb;
848     int i, j, k;
849
850     bytestream2_init(&ptrs, buf, buf_end - buf);
851     bytestream2_init_writer(&pb, dst, dst_size);
852
853     for (k = 0; k < bpp; k++) {
854         ofssrc = bytestream2_get_be32(&ptrs);
855
856         if (!ofssrc)
857             continue;
858
859         if (ofssrc >= buf_end - buf)
860             continue;
861
862         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
863         for (j = 0; j < ncolumns; j++) {
864             ofsdst = j + k * ncolumns;
865
866             i = bytestream2_get_byte(&gb);
867             while (i > 0) {
868                 opcode = bytestream2_get_byte(&gb);
869
870                 if (opcode == 0) {
871                     opcode  = bytestream2_get_byte(&gb);
872                     x = bytestream2_get_byte(&gb);
873
874                     while (opcode) {
875                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
876                         if (xor && ofsdst < dst_size) {
877                             bytestream2_put_byte(&pb, dst[ofsdst] ^ x);
878                         } else {
879                             bytestream2_put_byte(&pb, x);
880                         }
881                         ofsdst += dstpitch;
882                         opcode--;
883                     }
884                 } else if (opcode < 0x80) {
885                     ofsdst += opcode * dstpitch;
886                 } else {
887                     opcode &= 0x7f;
888
889                     while (opcode) {
890                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
891                         if (xor && ofsdst < dst_size) {
892                             bytestream2_put_byte(&pb, dst[ofsdst] ^ bytestream2_get_byte(&gb));
893                         } else {
894                             bytestream2_put_byte(&pb, bytestream2_get_byte(&gb));
895                         }
896                         ofsdst += dstpitch;
897                         opcode--;
898                     }
899                 }
900                 i--;
901             }
902         }
903     }
904 }
905
906 static void decode_delta_j(uint8_t *dst,
907                            const uint8_t *buf, const uint8_t *buf_end,
908                            int w, int h, int bpp, int dst_size)
909 {
910     int32_t pitch;
911     uint8_t *ptr;
912     uint32_t type, flag, cols, groups, rows, bytes;
913     uint32_t offset;
914     int planepitch_byte = (w + 7) / 8;
915     int planepitch = ((w + 15) / 16) * 2;
916     int kludge_j, b, g, r, d;
917     GetByteContext gb;
918
919     pitch = planepitch * bpp;
920     kludge_j = w < 320 ? (320 - w) / 8 / 2 : 0;
921
922     bytestream2_init(&gb, buf, buf_end - buf);
923
924     while (bytestream2_get_bytes_left(&gb) >= 2) {
925         type = bytestream2_get_be16(&gb);
926
927         switch (type) {
928         case 0:
929             return;
930         case 1:
931             flag   = bytestream2_get_be16(&gb);
932             cols   = bytestream2_get_be16(&gb);
933             groups = bytestream2_get_be16(&gb);
934
935             for (g = 0; g < groups; g++) {
936                 offset = bytestream2_get_be16(&gb);
937
938                 if (cols * bpp == 0 || bytestream2_get_bytes_left(&gb) < cols * bpp) {
939                     av_log(NULL, AV_LOG_ERROR, "cols*bpp is invalid (%"PRId32"*%d)", cols, bpp);
940                     return;
941                 }
942
943                 if (kludge_j)
944                     offset = ((offset / (320 / 8)) * pitch) + (offset % (320 / 8)) - kludge_j;
945                 else
946                     offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
947
948                 for (b = 0; b < cols; b++) {
949                     for (d = 0; d < bpp; d++) {
950                         uint8_t value = bytestream2_get_byte(&gb);
951
952                         if (offset >= dst_size)
953                             return;
954                         ptr = dst + offset;
955
956                         if (flag)
957                             ptr[0] ^= value;
958                         else
959                             ptr[0]  = value;
960
961                         offset += planepitch;
962                     }
963                 }
964                 if ((cols * bpp) & 1)
965                     bytestream2_skip(&gb, 1);
966             }
967             break;
968         case 2:
969             flag   = bytestream2_get_be16(&gb);
970             rows   = bytestream2_get_be16(&gb);
971             bytes  = bytestream2_get_be16(&gb);
972             groups = bytestream2_get_be16(&gb);
973
974             for (g = 0; g < groups; g++) {
975                 offset = bytestream2_get_be16(&gb);
976
977                 if (kludge_j)
978                     offset = ((offset / (320 / 8)) * pitch) + (offset % (320/ 8)) - kludge_j;
979                 else
980                     offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
981
982                 for (r = 0; r < rows; r++) {
983                     for (d = 0; d < bpp; d++) {
984                         unsigned noffset = offset + (r * pitch) + d * planepitch;
985
986                         if (!bytes || bytestream2_get_bytes_left(&gb) < bytes) {
987                             av_log(NULL, AV_LOG_ERROR, "bytes %"PRId32" is invalid", bytes);
988                             return;
989                         }
990
991                         for (b = 0; b < bytes; b++) {
992                             uint8_t value = bytestream2_get_byte(&gb);
993
994                             if (noffset >= dst_size)
995                                 return;
996                             ptr = dst + noffset;
997
998                             if (flag)
999                                 ptr[0] ^= value;
1000                             else
1001                                 ptr[0]  = value;
1002
1003                             noffset++;
1004                         }
1005                     }
1006                 }
1007                 if ((rows * bytes * bpp) & 1)
1008                     bytestream2_skip(&gb, 1);
1009             }
1010             break;
1011         default:
1012             return;
1013         }
1014     }
1015 }
1016
1017 static void decode_short_vertical_delta(uint8_t *dst,
1018                                         const uint8_t *buf, const uint8_t *buf_end,
1019                                         int w, int bpp, int dst_size)
1020 {
1021     int ncolumns = (w + 15) >> 4;
1022     int dstpitch = ncolumns * bpp * 2;
1023     unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1024     GetByteContext ptrs, gb, dptrs, dgb;
1025     PutByteContext pb;
1026     int i, j, k;
1027
1028     if (buf_end - buf <= 64)
1029         return;
1030
1031     bytestream2_init(&ptrs, buf, buf_end - buf);
1032     bytestream2_init(&dptrs, buf + 32, (buf_end - buf) - 32);
1033     bytestream2_init_writer(&pb, dst, dst_size);
1034
1035     for (k = 0; k < bpp; k++) {
1036         ofssrc = bytestream2_get_be32(&ptrs);
1037         ofsdata = bytestream2_get_be32(&dptrs);
1038
1039         if (!ofssrc)
1040             continue;
1041
1042         if (ofssrc >= buf_end - buf)
1043             return;
1044
1045         if (ofsdata >= buf_end - buf)
1046             return;
1047
1048         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1049         bytestream2_init(&dgb, buf + ofsdata, buf_end - (buf + ofsdata));
1050         for (j = 0; j < ncolumns; j++) {
1051             ofsdst = (j + k * ncolumns) * 2;
1052
1053             i = bytestream2_get_byte(&gb);
1054             while (i > 0) {
1055                 opcode = bytestream2_get_byte(&gb);
1056
1057                 if (opcode == 0) {
1058                     opcode = bytestream2_get_byte(&gb);
1059                     x = bytestream2_get_be16(&dgb);
1060
1061                     while (opcode) {
1062                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1063                         bytestream2_put_be16(&pb, x);
1064                         ofsdst += dstpitch;
1065                         opcode--;
1066                     }
1067                 } else if (opcode < 0x80) {
1068                     ofsdst += opcode * dstpitch;
1069                 } else {
1070                     opcode &= 0x7f;
1071
1072                     while (opcode) {
1073                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1074                         bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1075                         ofsdst += dstpitch;
1076                         opcode--;
1077                     }
1078                 }
1079                 i--;
1080             }
1081         }
1082     }
1083 }
1084
1085 static void decode_long_vertical_delta(uint8_t *dst,
1086                                        const uint8_t *buf, const uint8_t *buf_end,
1087                                        int w, int bpp, int dst_size)
1088 {
1089     int ncolumns = (w + 31) >> 5;
1090     int dstpitch = ((w + 15) / 16 * 2) * bpp;
1091     unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1092     GetByteContext ptrs, gb, dptrs, dgb;
1093     PutByteContext pb;
1094     int i, j, k, h;
1095
1096     if (buf_end - buf <= 64)
1097         return;
1098
1099     h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1100     bytestream2_init(&ptrs, buf, buf_end - buf);
1101     bytestream2_init(&dptrs, buf + 32, (buf_end - buf) - 32);
1102     bytestream2_init_writer(&pb, dst, dst_size);
1103
1104     for (k = 0; k < bpp; k++) {
1105         ofssrc = bytestream2_get_be32(&ptrs);
1106         ofsdata = bytestream2_get_be32(&dptrs);
1107
1108         if (!ofssrc)
1109             continue;
1110
1111         if (ofssrc >= buf_end - buf)
1112             return;
1113
1114         if (ofsdata >= buf_end - buf)
1115             return;
1116
1117         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1118         bytestream2_init(&dgb, buf + ofsdata, buf_end - (buf + ofsdata));
1119         for (j = 0; j < ncolumns; j++) {
1120             ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1121
1122             i = bytestream2_get_byte(&gb);
1123             while (i > 0) {
1124                 opcode = bytestream2_get_byte(&gb);
1125
1126                 if (opcode == 0) {
1127                     opcode = bytestream2_get_byte(&gb);
1128                     if (h && (j == (ncolumns - 1))) {
1129                         x = bytestream2_get_be16(&dgb);
1130                         bytestream2_skip(&dgb, 2);
1131                     } else {
1132                         x = bytestream2_get_be32(&dgb);
1133                     }
1134
1135                     while (opcode) {
1136                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1137                         if (h && (j == (ncolumns - 1))) {
1138                             bytestream2_put_be16(&pb, x);
1139                         } else {
1140                             bytestream2_put_be32(&pb, x);
1141                         }
1142                         ofsdst += dstpitch;
1143                         opcode--;
1144                     }
1145                 } else if (opcode < 0x80) {
1146                     ofsdst += opcode * dstpitch;
1147                 } else {
1148                     opcode &= 0x7f;
1149
1150                     while (opcode) {
1151                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1152                         if (h && (j == (ncolumns - 1))) {
1153                             bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1154                             bytestream2_skip(&dgb, 2);
1155                         } else {
1156                             bytestream2_put_be32(&pb, bytestream2_get_be32(&dgb));
1157                         }
1158                         ofsdst += dstpitch;
1159                         opcode--;
1160                     }
1161                 }
1162                 i--;
1163             }
1164         }
1165     }
1166 }
1167
1168 static void decode_short_vertical_delta2(uint8_t *dst,
1169                                          const uint8_t *buf, const uint8_t *buf_end,
1170                                          int w, int bpp, int dst_size)
1171 {
1172     int ncolumns = (w + 15) >> 4;
1173     int dstpitch = ncolumns * bpp * 2;
1174     unsigned ofsdst, ofssrc, opcode, x;
1175     GetByteContext ptrs, gb;
1176     PutByteContext pb;
1177     int i, j, k;
1178
1179     bytestream2_init(&ptrs, buf, buf_end - buf);
1180     bytestream2_init_writer(&pb, dst, dst_size);
1181
1182     for (k = 0; k < bpp; k++) {
1183         ofssrc = bytestream2_get_be32(&ptrs);
1184
1185         if (!ofssrc)
1186             continue;
1187
1188         if (ofssrc >= buf_end - buf)
1189             continue;
1190
1191         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1192         for (j = 0; j < ncolumns; j++) {
1193             ofsdst = (j + k * ncolumns) * 2;
1194
1195             i = bytestream2_get_be16(&gb);
1196             while (i > 0 && bytestream2_get_bytes_left(&gb) > 4) {
1197                 opcode = bytestream2_get_be16(&gb);
1198
1199                 if (opcode == 0) {
1200                     opcode = bytestream2_get_be16(&gb);
1201                     x = bytestream2_get_be16(&gb);
1202
1203                     while (opcode && bytestream2_get_bytes_left_p(&pb) > 1) {
1204                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1205                         bytestream2_put_be16(&pb, x);
1206                         ofsdst += dstpitch;
1207                         opcode--;
1208                     }
1209                 } else if (opcode < 0x8000) {
1210                     ofsdst += opcode * dstpitch;
1211                 } else {
1212                     opcode &= 0x7fff;
1213
1214                     while (opcode && bytestream2_get_bytes_left(&gb) > 1 &&
1215                            bytestream2_get_bytes_left_p(&pb) > 1) {
1216                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1217                         bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1218                         ofsdst += dstpitch;
1219                         opcode--;
1220                     }
1221                 }
1222                 i--;
1223             }
1224         }
1225     }
1226 }
1227
1228 static void decode_long_vertical_delta2(uint8_t *dst,
1229                                         const uint8_t *buf, const uint8_t *buf_end,
1230                                         int w, int bpp, int dst_size)
1231 {
1232     int ncolumns = (w + 31) >> 5;
1233     int dstpitch = ((w + 15) / 16 * 2) * bpp;
1234     unsigned ofsdst, ofssrc, opcode, x;
1235     unsigned skip = 0x80000000, mask = skip - 1;
1236     GetByteContext ptrs, gb;
1237     PutByteContext pb;
1238     int i, j, k, h;
1239
1240     h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1241     bytestream2_init(&ptrs, buf, buf_end - buf);
1242     bytestream2_init_writer(&pb, dst, dst_size);
1243
1244     for (k = 0; k < bpp; k++) {
1245         ofssrc = bytestream2_get_be32(&ptrs);
1246
1247         if (!ofssrc)
1248             continue;
1249
1250         if (ofssrc >= buf_end - buf)
1251             continue;
1252
1253         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1254         for (j = 0; j < ncolumns; j++) {
1255             ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1256
1257             if (h && (j == (ncolumns - 1))) {
1258                 skip = 0x8000;
1259                 mask = skip - 1;
1260             }
1261
1262             i = bytestream2_get_be32(&gb);
1263             while (i > 0 && bytestream2_get_bytes_left(&gb) > 4) {
1264                 opcode = bytestream2_get_be32(&gb);
1265
1266                 if (opcode == 0) {
1267                     if (h && (j == ncolumns - 1)) {
1268                         opcode = bytestream2_get_be16(&gb);
1269                         x = bytestream2_get_be16(&gb);
1270                     } else {
1271                         opcode = bytestream2_get_be32(&gb);
1272                         x = bytestream2_get_be32(&gb);
1273                     }
1274
1275                     while (opcode && bytestream2_get_bytes_left_p(&pb) > 1) {
1276                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1277                         if (h && (j == ncolumns - 1))
1278                             bytestream2_put_be16(&pb, x);
1279                         else
1280                             bytestream2_put_be32(&pb, x);
1281                         ofsdst += dstpitch;
1282                         opcode--;
1283                     }
1284                 } else if (opcode < skip) {
1285                     ofsdst += opcode * dstpitch;
1286                 } else {
1287                     opcode &= mask;
1288
1289                     while (opcode && bytestream2_get_bytes_left(&gb) > 1 &&
1290                            bytestream2_get_bytes_left_p(&pb) > 1) {
1291                         bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1292                         if (h && (j == ncolumns - 1)) {
1293                             bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1294                         } else {
1295                             bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1296                         }
1297                         ofsdst += dstpitch;
1298                         opcode--;
1299                     }
1300                 }
1301                 i--;
1302             }
1303         }
1304     }
1305 }
1306
1307 static void decode_delta_d(uint8_t *dst,
1308                            const uint8_t *buf, const uint8_t *buf_end,
1309                            int w, int flag, int bpp, int dst_size)
1310 {
1311     int planepitch = FFALIGN(w, 16) >> 3;
1312     int pitch = planepitch * bpp;
1313     int planepitch_byte = (w + 7) / 8;
1314     unsigned entries, ofssrc;
1315     GetByteContext gb, ptrs;
1316     PutByteContext pb;
1317     int k;
1318
1319     if (buf_end - buf <= 4 * bpp)
1320         return;
1321
1322     bytestream2_init_writer(&pb, dst, dst_size);
1323     bytestream2_init(&ptrs, buf, bpp * 4);
1324
1325     for (k = 0; k < bpp; k++) {
1326         ofssrc = bytestream2_get_be32(&ptrs);
1327
1328         if (!ofssrc)
1329             continue;
1330
1331         if (ofssrc >= buf_end - buf)
1332             continue;
1333
1334         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1335
1336         entries = bytestream2_get_be32(&gb);
1337         while (entries && bytestream2_get_bytes_left(&gb) >= 8) {
1338             int32_t opcode  = bytestream2_get_be32(&gb);
1339             unsigned offset = bytestream2_get_be32(&gb);
1340
1341             bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1342             if (opcode >= 0) {
1343                 uint32_t x = bytestream2_get_be32(&gb);
1344                 while (opcode && bytestream2_get_bytes_left_p(&pb) > 0) {
1345                     bytestream2_put_be32(&pb, x);
1346                     bytestream2_skip_p(&pb, pitch - 4);
1347                     opcode--;
1348                 }
1349             } else {
1350                 opcode = -opcode;
1351                 while (opcode && bytestream2_get_bytes_left(&gb) > 0) {
1352                     bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1353                     bytestream2_skip_p(&pb, pitch - 4);
1354                     opcode--;
1355                 }
1356             }
1357             entries--;
1358         }
1359     }
1360 }
1361
1362 static void decode_delta_e(uint8_t *dst,
1363                            const uint8_t *buf, const uint8_t *buf_end,
1364                            int w, int flag, int bpp, int dst_size)
1365 {
1366     int planepitch = FFALIGN(w, 16) >> 3;
1367     int pitch = planepitch * bpp;
1368     int planepitch_byte = (w + 7) / 8;
1369     unsigned entries, ofssrc;
1370     GetByteContext gb, ptrs;
1371     PutByteContext pb;
1372     int k;
1373
1374     if (buf_end - buf <= 4 * bpp)
1375         return;
1376
1377     bytestream2_init_writer(&pb, dst, dst_size);
1378     bytestream2_init(&ptrs, buf, bpp * 4);
1379
1380     for (k = 0; k < bpp; k++) {
1381         ofssrc = bytestream2_get_be32(&ptrs);
1382
1383         if (!ofssrc)
1384             continue;
1385
1386         if (ofssrc >= buf_end - buf)
1387             continue;
1388
1389         bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1390
1391         entries = bytestream2_get_be16(&gb);
1392         while (entries && bytestream2_get_bytes_left(&gb) >= 6) {
1393             int16_t opcode  = bytestream2_get_be16(&gb);
1394             unsigned offset = bytestream2_get_be32(&gb);
1395
1396             bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1397             if (opcode >= 0) {
1398                 uint16_t x = bytestream2_get_be16(&gb);
1399                 while (opcode && bytestream2_get_bytes_left_p(&pb) > 0) {
1400                     bytestream2_put_be16(&pb, x);
1401                     bytestream2_skip_p(&pb, pitch - 2);
1402                     opcode--;
1403                 }
1404             } else {
1405                 opcode = -opcode;
1406                 while (opcode && bytestream2_get_bytes_left(&gb) > 0) {
1407                     bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1408                     bytestream2_skip_p(&pb, pitch - 2);
1409                     opcode--;
1410                 }
1411             }
1412             entries--;
1413         }
1414     }
1415 }
1416
1417 static void decode_delta_l(uint8_t *dst,
1418                            const uint8_t *buf, const uint8_t *buf_end,
1419                            int w, int flag, int bpp, int dst_size)
1420 {
1421     GetByteContext off0, off1, dgb, ogb;
1422     PutByteContext pb;
1423     unsigned poff0, poff1;
1424     int i, k, dstpitch;
1425     int planepitch_byte = (w + 7) / 8;
1426     int planepitch = ((w + 15) / 16) * 2;
1427     int pitch = planepitch * bpp;
1428
1429     if (buf_end - buf <= 64)
1430         return;
1431
1432     bytestream2_init(&off0, buf, buf_end - buf);
1433     bytestream2_init(&off1, buf + 32, buf_end - (buf + 32));
1434     bytestream2_init_writer(&pb, dst, dst_size);
1435
1436     dstpitch = flag ? (((w + 7) / 8) * bpp): 2;
1437
1438     for (k = 0; k < bpp; k++) {
1439         poff0 = bytestream2_get_be32(&off0);
1440         poff1 = bytestream2_get_be32(&off1);
1441
1442         if (!poff0)
1443             continue;
1444
1445         if (2LL * poff0 >= buf_end - buf)
1446             return;
1447
1448         if (2LL * poff1 >= buf_end - buf)
1449             return;
1450
1451         bytestream2_init(&dgb, buf + 2 * poff0, buf_end - (buf + 2 * poff0));
1452         bytestream2_init(&ogb, buf + 2 * poff1, buf_end - (buf + 2 * poff1));
1453
1454         while (bytestream2_peek_be16(&ogb) != 0xFFFF && bytestream2_get_bytes_left(&ogb) >= 4) {
1455             uint32_t offset = bytestream2_get_be16(&ogb);
1456             int16_t cnt = bytestream2_get_be16(&ogb);
1457             uint16_t data;
1458
1459             offset = ((2 * offset) / planepitch_byte) * pitch + ((2 * offset) % planepitch_byte) + k * planepitch;
1460             if (cnt < 0) {
1461                 if (bytestream2_get_bytes_left(&dgb) < 2)
1462                     break;
1463                 bytestream2_seek_p(&pb, offset, SEEK_SET);
1464                 cnt = -cnt;
1465                 data = bytestream2_get_be16(&dgb);
1466                 for (i = 0; i < cnt; i++) {
1467                     bytestream2_put_be16(&pb, data);
1468                     bytestream2_skip_p(&pb, dstpitch - 2);
1469                 }
1470             } else {
1471                 if (bytestream2_get_bytes_left(&dgb) < 2*cnt)
1472                     break;
1473                 bytestream2_seek_p(&pb, offset, SEEK_SET);
1474                 for (i = 0; i < cnt; i++) {
1475                     data = bytestream2_get_be16(&dgb);
1476                     bytestream2_put_be16(&pb, data);
1477                     bytestream2_skip_p(&pb, dstpitch - 2);
1478                 }
1479             }
1480         }
1481     }
1482 }
1483
1484 static int unsupported(AVCodecContext *avctx)
1485 {
1486     IffContext *s = avctx->priv_data;
1487     avpriv_request_sample(avctx, "bitmap (compression 0x%0x, bpp %i, ham %i, interlaced %i)", s->compression, s->bpp, s->ham, s->is_interlaced);
1488     return AVERROR_INVALIDDATA;
1489 }
1490
1491 static int decode_frame(AVCodecContext *avctx,
1492                         void *data, int *got_frame,
1493                         AVPacket *avpkt)
1494 {
1495     IffContext *s          = avctx->priv_data;
1496     AVFrame *frame         = data;
1497     const uint8_t *buf     = avpkt->data;
1498     int buf_size           = avpkt->size;
1499     const uint8_t *buf_end = buf + buf_size;
1500     int y, plane, res;
1501     GetByteContext *gb = &s->gb;
1502     const AVPixFmtDescriptor *desc;
1503
1504     bytestream2_init(gb, avpkt->data, avpkt->size);
1505
1506     if ((res = extract_header(avctx, avpkt)) < 0)
1507         return res;
1508
1509     if ((res = ff_get_buffer(avctx, frame, 0)) < 0)
1510         return res;
1511     s->frame = frame;
1512
1513     buf      += bytestream2_tell(gb);
1514     buf_size -= bytestream2_tell(gb);
1515     desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1516
1517     if (!s->init && avctx->bits_per_coded_sample <= 8 &&
1518         avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1519         if ((res = cmap_read_palette(avctx, (uint32_t *)frame->data[1])) < 0)
1520             return res;
1521     } else if (!s->init && avctx->bits_per_coded_sample <= 8 &&
1522                avctx->pix_fmt == AV_PIX_FMT_RGB32) {
1523         if ((res = cmap_read_palette(avctx, s->mask_palbuf)) < 0)
1524             return res;
1525     }
1526     s->init = 1;
1527
1528     if (s->compression <= 0xff && (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))) {
1529         if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
1530             memcpy(s->pal, s->frame->data[1], 256 * 4);
1531     }
1532
1533     switch (s->compression) {
1534     case 0x0:
1535         if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
1536             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1537                 memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1538                 for (plane = 0; plane < s->bpp; plane++) {
1539                     for (y = 0; y < avctx->height && buf < buf_end; y++) {
1540                         uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1541                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
1542                         buf += s->planesize;
1543                     }
1544                 }
1545             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1546                 memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1547                 for (y = 0; y < avctx->height; y++) {
1548                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1549                     memset(s->ham_buf, 0, s->planesize * 8);
1550                     for (plane = 0; plane < s->bpp; plane++) {
1551                         const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
1552                         if (start >= buf_end)
1553                             break;
1554                         decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
1555                     }
1556                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1557                 }
1558             } else
1559                 return unsupported(avctx);
1560         } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
1561             int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
1562             int x;
1563             for (y = 0; y < avctx->height && buf < buf_end; y++) {
1564                 uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1565                 memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
1566                 buf += raw_width;
1567                 if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
1568                     for (x = 0; x < avctx->width; x++)
1569                         row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
1570                 }
1571             }
1572         } else if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') || // interleaved
1573                    avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1574             if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))
1575                 memcpy(s->video[0], buf, FFMIN(buf_end - buf, s->video_size));
1576             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1577                 for (y = 0; y < avctx->height; y++) {
1578                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1579                     memset(row, 0, avctx->width);
1580                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1581                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
1582                         buf += s->planesize;
1583                     }
1584                 }
1585             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1586                 for (y = 0; y < avctx->height; y++) {
1587                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1588                     memset(s->ham_buf, 0, s->planesize * 8);
1589                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1590                         decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
1591                         buf += s->planesize;
1592                     }
1593                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1594                 }
1595             } else { // AV_PIX_FMT_BGR32
1596                 for (y = 0; y < avctx->height; y++) {
1597                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1598                     memset(row, 0, avctx->width << 2);
1599                     for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1600                         decodeplane32((uint32_t *)row, buf,
1601                                       FFMIN(s->planesize, buf_end - buf), plane);
1602                         buf += s->planesize;
1603                     }
1604                 }
1605             }
1606         } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
1607             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1608                 for (y = 0; y < avctx->height && buf_end > buf; y++) {
1609                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1610                     memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
1611                     buf += avctx->width + (avctx->width % 2); // padding if odd
1612                 }
1613             } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
1614                 for (y = 0; y < avctx->height && buf_end > buf; y++) {
1615                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1616                     memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
1617                     buf += avctx->width + (avctx->width & 1); // padding if odd
1618                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1619                 }
1620             } else
1621                 return unsupported(avctx);
1622         } else {
1623             return unsupported(avctx);
1624         }
1625         break;
1626     case 0x1:
1627         if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') || // interleaved
1628             avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1629             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1630                 uint8_t *video = s->video[0];
1631
1632                 for (y = 0; y < avctx->height; y++) {
1633                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1634                     memset(row, 0, avctx->width);
1635                     for (plane = 0; plane < s->bpp; plane++) {
1636                         buf += decode_byterun(s->planebuf, s->planesize, gb);
1637                         if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1638                             memcpy(video, s->planebuf, s->planesize);
1639                             video += s->planesize;
1640                         }
1641                         decodeplane8(row, s->planebuf, s->planesize, plane);
1642                     }
1643                 }
1644             } else if (avctx->bits_per_coded_sample <= 8) { //8-bit (+ mask) to AV_PIX_FMT_BGR32
1645                 for (y = 0; y < avctx->height; y++) {
1646                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1647                     memset(s->mask_buf, 0, avctx->width * sizeof(uint32_t));
1648                     for (plane = 0; plane < s->bpp; plane++) {
1649                         buf += decode_byterun(s->planebuf, s->planesize, gb);
1650                         decodeplane32(s->mask_buf, s->planebuf, s->planesize, plane);
1651                     }
1652                     lookup_pal_indicies((uint32_t *)row, s->mask_buf, s->mask_palbuf, avctx->width);
1653                 }
1654             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1655                 uint8_t *video = s->video[0];
1656                 for (y = 0; y < avctx->height; y++) {
1657                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1658                     memset(s->ham_buf, 0, s->planesize * 8);
1659                     for (plane = 0; plane < s->bpp; plane++) {
1660                         buf += decode_byterun(s->planebuf, s->planesize, gb);
1661                         if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1662                             memcpy(video, s->planebuf, s->planesize);
1663                             video += s->planesize;
1664                         }
1665                         decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
1666                     }
1667                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1668                 }
1669             } else { // AV_PIX_FMT_BGR32
1670                 for (y = 0; y < avctx->height; y++) {
1671                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1672                     memset(row, 0, avctx->width << 2);
1673                     for (plane = 0; plane < s->bpp; plane++) {
1674                         buf += decode_byterun(s->planebuf, s->planesize, gb);
1675                         decodeplane32((uint32_t *)row, s->planebuf, s->planesize, plane);
1676                     }
1677                 }
1678             }
1679         } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
1680             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1681                 for (y = 0; y < avctx->height; y++) {
1682                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1683                     buf += decode_byterun(row, avctx->width, gb);
1684                 }
1685             } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
1686                 for (y = 0; y < avctx->height; y++) {
1687                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1688                     buf += decode_byterun(s->ham_buf, avctx->width, gb);
1689                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1690                 }
1691             } else
1692                 return unsupported(avctx);
1693         } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) { // IFF-DEEP
1694             if (av_get_bits_per_pixel(desc) == 32)
1695                 decode_deep_rle32(frame->data[0], buf, buf_size, avctx->width, avctx->height, frame->linesize[0]);
1696             else
1697                 return unsupported(avctx);
1698         } else if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
1699             if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1700                 memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1701                 for (plane = 0; plane < s->bpp; plane++) {
1702                     for (y = 0; y < avctx->height && buf < buf_end; y++) {
1703                         uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1704                         decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
1705                         buf += s->planesize;
1706                     }
1707                 }
1708             } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1709                 memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1710                 for (y = 0; y < avctx->height; y++) {
1711                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1712                     memset(s->ham_buf, 0, s->planesize * 8);
1713                     for (plane = 0; plane < s->bpp; plane++) {
1714                         const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
1715                         if (start >= buf_end)
1716                             break;
1717                         decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
1718                     }
1719                     decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1720                 }
1721             } else {
1722                 return unsupported(avctx);
1723             }
1724         } else {
1725             return unsupported(avctx);
1726         }
1727         break;
1728     case 0x2:
1729         if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1730             for (plane = 0; plane < s->bpp; plane++) {
1731                 decode_byterun2(s->planebuf, avctx->height, s->planesize, gb);
1732                 for (y = 0; y < avctx->height; y++) {
1733                     uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1734                     decodeplane8(row, s->planebuf + s->planesize * y, s->planesize, plane);
1735                 }
1736             }
1737         } else {
1738             return unsupported(avctx);
1739         }
1740         break;
1741     case 0x4:
1742         if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8') && avctx->pix_fmt == AV_PIX_FMT_RGB32)
1743             decode_rgb8(gb, frame->data[0], avctx->width, avctx->height, frame->linesize[0]);
1744         else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N') && avctx->pix_fmt == AV_PIX_FMT_RGB444)
1745             decode_rgbn(gb, frame->data[0], avctx->width, avctx->height, frame->linesize[0]);
1746         else
1747             return unsupported(avctx);
1748         break;
1749     case 0x5:
1750         if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
1751             if (av_get_bits_per_pixel(desc) == 32)
1752                 decode_deep_tvdc32(frame->data[0], buf, buf_size, avctx->width, avctx->height, frame->linesize[0], s->tvdc);
1753             else
1754                 return unsupported(avctx);
1755         } else
1756             return unsupported(avctx);
1757         break;
1758     case 0x300:
1759     case 0x301:
1760         decode_short_horizontal_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1761         break;
1762     case 0x500:
1763     case 0x501:
1764         decode_byte_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->is_brush, s->bpp, s->video_size);
1765         break;
1766     case 0x700:
1767     case 0x701:
1768         if (s->is_short)
1769             decode_short_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1770         else
1771             decode_long_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1772         break;
1773     case 0x800:
1774     case 0x801:
1775         if (s->is_short)
1776             decode_short_vertical_delta2(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1777         else
1778             decode_long_vertical_delta2(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1779         break;
1780     case 0x4a00:
1781     case 0x4a01:
1782         decode_delta_j(s->video[0], buf, buf_end, avctx->width, avctx->height, s->bpp, s->video_size);
1783         break;
1784     case 0x6400:
1785     case 0x6401:
1786         if (s->is_interlaced)
1787             return unsupported(avctx);
1788         decode_delta_d(s->video[0], buf, buf_end, avctx->width, s->is_interlaced, s->bpp, s->video_size);
1789         break;
1790     case 0x6500:
1791     case 0x6501:
1792         if (s->is_interlaced)
1793             return unsupported(avctx);
1794         decode_delta_e(s->video[0], buf, buf_end, avctx->width, s->is_interlaced, s->bpp, s->video_size);
1795         break;
1796     case 0x6c00:
1797     case 0x6c01:
1798         decode_delta_l(s->video[0], buf, buf_end, avctx->width, s->is_short, s->bpp, s->video_size);
1799         break;
1800     default:
1801         return unsupported(avctx);
1802     }
1803
1804     if (s->compression <= 0xff && (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))) {
1805         memcpy(s->video[1], s->video[0], s->video_size);
1806     }
1807
1808     if (s->compression > 0xff) {
1809         if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1810             buf = s->video[0];
1811             for (y = 0; y < avctx->height; y++) {
1812                 uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1813                 memset(row, 0, avctx->width);
1814                 for (plane = 0; plane < s->bpp; plane++) {
1815                     decodeplane8(row, buf, s->planesize, plane);
1816                     buf += s->planesize;
1817                 }
1818             }
1819             memcpy(frame->data[1], s->pal, 256 * 4);
1820         } else if (s->ham) {
1821             int i, count = 1 << s->ham;
1822
1823             buf = s->video[0];
1824             memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof(uint32_t));
1825             for (i = 0; i < count; i++) {
1826                 s->ham_palbuf[i*2+1] = s->pal[i];
1827             }
1828             for (i = 0; i < count; i++) {
1829                 uint32_t tmp = i << (8 - s->ham);
1830                 tmp |= tmp >> s->ham;
1831                 s->ham_palbuf[(i+count)*2]     = 0xFF00FFFF;
1832                 s->ham_palbuf[(i+count*2)*2]   = 0xFFFFFF00;
1833                 s->ham_palbuf[(i+count*3)*2]   = 0xFFFF00FF;
1834                 s->ham_palbuf[(i+count)*2+1]   = 0xFF000000 | tmp << 16;
1835                 s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
1836                 s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
1837             }
1838             if (s->masking == MASK_HAS_MASK) {
1839                 for (i = 0; i < 8 * (1 << s->ham); i++)
1840                     s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
1841             }
1842             for (y = 0; y < avctx->height; y++) {
1843                 uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1844                 memset(s->ham_buf, 0, s->planesize * 8);
1845                 for (plane = 0; plane < s->bpp; plane++) {
1846                     decodeplane8(s->ham_buf, buf, s->planesize, plane);
1847                     buf += s->planesize;
1848                 }
1849                 decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1850             }
1851         } else {
1852             return unsupported(avctx);
1853         }
1854
1855         if (!s->is_brush) {
1856             FFSWAP(uint8_t *, s->video[0], s->video[1]);
1857         }
1858     }
1859
1860     if (avpkt->flags & AV_PKT_FLAG_KEY) {
1861         frame->key_frame = 1;
1862         frame->pict_type = AV_PICTURE_TYPE_I;
1863     } else {
1864         frame->key_frame = 0;
1865         frame->pict_type = AV_PICTURE_TYPE_P;
1866     }
1867
1868     *got_frame = 1;
1869
1870     return buf_size;
1871 }
1872
1873 #if CONFIG_IFF_ILBM_DECODER
1874 AVCodec ff_iff_ilbm_decoder = {
1875     .name           = "iff",
1876     .long_name      = NULL_IF_CONFIG_SMALL("IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN"),
1877     .type           = AVMEDIA_TYPE_VIDEO,
1878     .id             = AV_CODEC_ID_IFF_ILBM,
1879     .priv_data_size = sizeof(IffContext),
1880     .init           = decode_init,
1881     .close          = decode_end,
1882     .decode         = decode_frame,
1883     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1884     .capabilities   = AV_CODEC_CAP_DR1,
1885 };
1886 #endif