[PATCH] IFF Amiga Continuous Bitmap (ACBM)decoder
[ffmpeg.git] / libavcodec / iff.c
1 /*
2  * IFF PBM/ILBM 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 PBM/ILBM bitmap decoder
26  */
27
28 #include "libavutil/imgutils.h"
29 #include "bytestream.h"
30 #include "avcodec.h"
31 #include "get_bits.h"
32
33 // TODO: masking bits
34 typedef enum {
35     MASK_NONE,
36     MASK_HAS_MASK,
37     MASK_HAS_TRANSPARENT_COLOR,
38     MASK_LASSO
39 } mask_type;
40
41 typedef struct {
42     AVFrame frame;
43     int planesize;
44     uint8_t * planebuf;
45     uint8_t * ham_buf;      ///< temporary buffer for planar to chunky conversation
46     uint32_t *ham_palbuf;   ///< HAM decode table
47     unsigned  compression;  ///< delta compression method used
48     unsigned  bpp;          ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
49     unsigned  ham;          ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
50     unsigned  flags;        ///< 1 for EHB, 0 is no extra half darkening
51     unsigned  transparency; ///< TODO: transparency color index in palette
52     unsigned  masking;      ///< TODO: masking method used
53     int init; // 1 if buffer and palette data already initialized, 0 otherwise
54 } IffContext;
55
56 #define LUT8_PART(plane, v)                             \
57     AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
58     AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
59     AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
60     AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
61     AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
62     AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
63     AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
64     AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
65     AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
66     AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
67     AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
68     AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
69     AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
70     AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
71     AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
72     AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
73
74 #define LUT8(plane) {                           \
75     LUT8_PART(plane, 0x0000000),                \
76     LUT8_PART(plane, 0x1000000),                \
77     LUT8_PART(plane, 0x0010000),                \
78     LUT8_PART(plane, 0x1010000),                \
79     LUT8_PART(plane, 0x0000100),                \
80     LUT8_PART(plane, 0x1000100),                \
81     LUT8_PART(plane, 0x0010100),                \
82     LUT8_PART(plane, 0x1010100),                \
83     LUT8_PART(plane, 0x0000001),                \
84     LUT8_PART(plane, 0x1000001),                \
85     LUT8_PART(plane, 0x0010001),                \
86     LUT8_PART(plane, 0x1010001),                \
87     LUT8_PART(plane, 0x0000101),                \
88     LUT8_PART(plane, 0x1000101),                \
89     LUT8_PART(plane, 0x0010101),                \
90     LUT8_PART(plane, 0x1010101),                \
91 }
92
93 // 8 planes * 8-bit mask
94 static const uint64_t plane8_lut[8][256] = {
95     LUT8(0), LUT8(1), LUT8(2), LUT8(3),
96     LUT8(4), LUT8(5), LUT8(6), LUT8(7),
97 };
98
99 #define LUT32(plane) {                                \
100              0,          0,          0,          0,   \
101              0,          0,          0, 1 << plane,   \
102              0,          0, 1 << plane,          0,   \
103              0,          0, 1 << plane, 1 << plane,   \
104              0, 1 << plane,          0,          0,   \
105              0, 1 << plane,          0, 1 << plane,   \
106              0, 1 << plane, 1 << plane,          0,   \
107              0, 1 << plane, 1 << plane, 1 << plane,   \
108     1 << plane,          0,          0,          0,   \
109     1 << plane,          0,          0, 1 << plane,   \
110     1 << plane,          0, 1 << plane,          0,   \
111     1 << plane,          0, 1 << plane, 1 << plane,   \
112     1 << plane, 1 << plane,          0,          0,   \
113     1 << plane, 1 << plane,          0, 1 << plane,   \
114     1 << plane, 1 << plane, 1 << plane,          0,   \
115     1 << plane, 1 << plane, 1 << plane, 1 << plane,   \
116 }
117
118 // 32 planes * 4-bit mask * 4 lookup tables each
119 static const uint32_t plane32_lut[32][16*4] = {
120     LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
121     LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
122     LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
123     LUT32(12), LUT32(13), LUT32(14), LUT32(15),
124     LUT32(16), LUT32(17), LUT32(18), LUT32(19),
125     LUT32(20), LUT32(21), LUT32(22), LUT32(23),
126     LUT32(24), LUT32(25), LUT32(26), LUT32(27),
127     LUT32(28), LUT32(29), LUT32(30), LUT32(31),
128 };
129
130 // Gray to RGB, required for palette table of grayscale images with bpp < 8
131 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
132     return x << 16 | x << 8 | x;
133 }
134
135 /**
136  * Convert CMAP buffer (stored in extradata) to lavc palette format
137  */
138 static int ff_cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
139 {
140     int count, i;
141     const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
142     int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
143
144     if (avctx->bits_per_coded_sample > 8) {
145         av_log(avctx, AV_LOG_ERROR, "bit_per_coded_sample > 8 not supported\n");
146         return AVERROR_INVALIDDATA;
147     }
148
149     count = 1 << avctx->bits_per_coded_sample;
150     // If extradata is smaller than actually needed, fill the remaining with black.
151     count = FFMIN(palette_size / 3, count);
152     if (count) {
153         for (i=0; i < count; i++) {
154             pal[i] = 0xFF000000 | AV_RB24(palette + i*3);
155         }
156     } else { // Create gray-scale color palette for bps < 8
157         count = 1 << avctx->bits_per_coded_sample;
158
159         for (i=0; i < count; i++) {
160             pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
161         }
162     }
163     return 0;
164 }
165
166 /**
167  * Extracts the IFF extra context and updates internal
168  * decoder structures.
169  *
170  * @param avctx the AVCodecContext where to extract extra context to
171  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
172  * @return 0 in case of success, a negative error code otherwise
173  */
174 static int extract_header(AVCodecContext *const avctx,
175                           const AVPacket *const avpkt) {
176     const uint8_t *buf;
177     unsigned buf_size;
178     IffContext *s = avctx->priv_data;
179     int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
180
181     if (avpkt) {
182         int image_size;
183         if (avpkt->size < 2)
184             return AVERROR_INVALIDDATA;
185         image_size = avpkt->size - AV_RB16(avpkt->data);
186         buf = avpkt->data;
187         buf_size = bytestream_get_be16(&buf);
188         if (buf_size <= 1 || image_size <= 1) {
189             av_log(avctx, AV_LOG_ERROR,
190                    "Invalid image size received: %u -> image data offset: %d\n",
191                    buf_size, image_size);
192             return AVERROR_INVALIDDATA;
193         }
194     } else {
195         if (avctx->extradata_size < 2)
196             return AVERROR_INVALIDDATA;
197         buf = avctx->extradata;
198         buf_size = bytestream_get_be16(&buf);
199         if (buf_size <= 1 || palette_size < 0) {
200             av_log(avctx, AV_LOG_ERROR,
201                    "Invalid palette size received: %u -> palette data offset: %d\n",
202                    buf_size, palette_size);
203             return AVERROR_INVALIDDATA;
204         }
205     }
206
207     if (buf_size > 8) {
208         s->compression  = bytestream_get_byte(&buf);
209         s->bpp          = bytestream_get_byte(&buf);
210         s->ham          = bytestream_get_byte(&buf);
211         s->flags        = bytestream_get_byte(&buf);
212         s->transparency = bytestream_get_be16(&buf);
213         s->masking      = bytestream_get_byte(&buf);
214         if (s->masking == MASK_HAS_TRANSPARENT_COLOR) {
215             av_log(avctx, AV_LOG_ERROR, "Transparency not supported\n");
216             return AVERROR_PATCHWELCOME;
217         } else if (s->masking != MASK_NONE) {
218             av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
219             return AVERROR_PATCHWELCOME;
220         }
221         if (!s->bpp || s->bpp > 32) {
222             av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
223             return AVERROR_INVALIDDATA;
224         } else if (s->ham >= 8) {
225             av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
226             return AVERROR_INVALIDDATA;
227         }
228
229         av_freep(&s->ham_buf);
230         av_freep(&s->ham_palbuf);
231
232         if (s->ham) {
233             int i, count = FFMIN(palette_size / 3, 1 << s->ham);
234             const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
235             s->ham_buf = av_malloc((s->planesize * 8) + FF_INPUT_BUFFER_PADDING_SIZE);
236             if (!s->ham_buf)
237                 return AVERROR(ENOMEM);
238
239             s->ham_palbuf = av_malloc((8 * (1 << s->ham) * sizeof (uint32_t)) + FF_INPUT_BUFFER_PADDING_SIZE);
240             if (!s->ham_palbuf) {
241                 av_freep(&s->ham_buf);
242                 return AVERROR(ENOMEM);
243             }
244
245             if (count) { // HAM with color palette attached
246                 // prefill with black and palette and set HAM take direct value mask to zero
247                 memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
248                 for (i=0; i < count; i++) {
249                     s->ham_palbuf[i*2+1] = AV_RL24(palette + i*3);
250                 }
251                 count = 1 << s->ham;
252             } else { // HAM with grayscale color palette
253                 count = 1 << s->ham;
254                 for (i=0; i < count; i++) {
255                     s->ham_palbuf[i*2]   = 0; // take direct color value from palette
256                     s->ham_palbuf[i*2+1] = av_le2ne32(gray2rgb((i * 255) >> s->ham));
257                 }
258             }
259             for (i=0; i < count; i++) {
260                 uint32_t tmp = i << (8 - s->ham);
261                 tmp |= tmp >> s->ham;
262                 s->ham_palbuf[(i+count)*2]     = 0x00FFFF; // just modify blue color component
263                 s->ham_palbuf[(i+count*2)*2]   = 0xFFFF00; // just modify red color component
264                 s->ham_palbuf[(i+count*3)*2]   = 0xFF00FF; // just modify green color component
265                 s->ham_palbuf[(i+count)*2+1]   = tmp << 16;
266                 s->ham_palbuf[(i+count*2)*2+1] = tmp;
267                 s->ham_palbuf[(i+count*3)*2+1] = tmp << 8;
268             }
269         } else if (s->flags & 1) { // EHB (ExtraHalfBrite) color palette
270             av_log(avctx, AV_LOG_ERROR, "ExtraHalfBrite (EHB) mode not supported\n");
271             return AVERROR_PATCHWELCOME;
272         }
273     }
274
275     return 0;
276 }
277
278 static av_cold int decode_init(AVCodecContext *avctx)
279 {
280     IffContext *s = avctx->priv_data;
281     int err;
282
283     if (avctx->bits_per_coded_sample <= 8) {
284         int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
285         avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
286                          (avctx->extradata_size >= 2 && palette_size) ? PIX_FMT_PAL8 : PIX_FMT_GRAY8;
287     } else if (avctx->bits_per_coded_sample <= 32) {
288         avctx->pix_fmt = PIX_FMT_BGR32;
289     } else {
290         return AVERROR_INVALIDDATA;
291     }
292
293     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
294         return err;
295     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
296     s->planebuf = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);
297     if (!s->planebuf)
298         return AVERROR(ENOMEM);
299
300     s->bpp = avctx->bits_per_coded_sample;
301     avcodec_get_frame_defaults(&s->frame);
302
303     if ((err = extract_header(avctx, NULL)) < 0)
304         return err;
305     s->frame.reference = 3;
306
307     return 0;
308 }
309
310 /**
311  * Decode interleaved plane buffer up to 8bpp
312  * @param dst Destination buffer
313  * @param buf Source buffer
314  * @param buf_size
315  * @param plane plane number to decode as
316  */
317 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
318 {
319     const uint64_t *lut = plane8_lut[plane];
320     do {
321         uint64_t v = AV_RN64A(dst) | lut[*buf++];
322         AV_WN64A(dst, v);
323         dst += 8;
324     } while (--buf_size);
325 }
326
327 /**
328  * Decode interleaved plane buffer up to 24bpp
329  * @param dst Destination buffer
330  * @param buf Source buffer
331  * @param buf_size
332  * @param plane plane number to decode as
333  */
334 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
335 {
336     const uint32_t *lut = plane32_lut[plane];
337     do {
338         unsigned mask = (*buf >> 2) & ~3;
339         dst[0] |= lut[mask++];
340         dst[1] |= lut[mask++];
341         dst[2] |= lut[mask++];
342         dst[3] |= lut[mask];
343         mask = (*buf++ << 2) & 0x3F;
344         dst[4] |= lut[mask++];
345         dst[5] |= lut[mask++];
346         dst[6] |= lut[mask++];
347         dst[7] |= lut[mask];
348         dst += 8;
349     } while (--buf_size);
350 }
351
352 #define DECODE_HAM_PLANE32(x)       \
353     first       = buf[x] << 1;      \
354     second      = buf[(x)+1] << 1;  \
355     delta      &= pal[first++];     \
356     delta      |= pal[first];       \
357     dst[x]      = delta;            \
358     delta      &= pal[second++];    \
359     delta      |= pal[second];      \
360     dst[(x)+1]  = delta
361
362 /**
363  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
364  *
365  * @param dst the destination 24bpp buffer
366  * @param buf the source 8bpp chunky buffer
367  * @param pal the HAM decode table
368  * @param buf_size the plane size in bytes
369  */
370 static void decode_ham_plane32(uint32_t *dst, const uint8_t  *buf,
371                                const uint32_t *const pal, unsigned buf_size)
372 {
373     uint32_t delta = 0;
374     do {
375         uint32_t first, second;
376         DECODE_HAM_PLANE32(0);
377         DECODE_HAM_PLANE32(2);
378         DECODE_HAM_PLANE32(4);
379         DECODE_HAM_PLANE32(6);
380         buf += 8;
381         dst += 8;
382     } while (--buf_size);
383 }
384
385 /**
386  * Decode one complete byterun1 encoded line.
387  *
388  * @param dst the destination buffer where to store decompressed bitstream
389  * @param dst_size the destination plane size in bytes
390  * @param buf the source byterun1 compressed bitstream
391  * @param buf_end the EOF of source byterun1 compressed bitstream
392  * @return number of consumed bytes in byterun1 compressed bitstream
393 */
394 static int decode_byterun(uint8_t *dst, int dst_size,
395                           const uint8_t *buf, const uint8_t *const buf_end) {
396     const uint8_t *const buf_start = buf;
397     unsigned x;
398     for (x = 0; x < dst_size && buf < buf_end;) {
399         unsigned length;
400         const int8_t value = *buf++;
401         if (value >= 0) {
402             length = value + 1;
403             memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
404             buf += length;
405         } else if (value > -128) {
406             length = -value + 1;
407             memset(dst + x, *buf++, FFMIN(length, dst_size - x));
408         } else { // noop
409             continue;
410         }
411         x += length;
412     }
413     return buf - buf_start;
414 }
415
416 static int decode_frame_ilbm(AVCodecContext *avctx,
417                             void *data, int *data_size,
418                             AVPacket *avpkt)
419 {
420     IffContext *s = avctx->priv_data;
421     const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
422     const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
423     const uint8_t *buf_end = buf+buf_size;
424     int y, plane, res;
425
426     if ((res = extract_header(avctx, avpkt)) < 0)
427         return res;
428
429     if (s->init) {
430         if ((res = avctx->reget_buffer(avctx, &s->frame)) < 0) {
431             av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
432             return res;
433         }
434     } else if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
435         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
436         return res;
437     } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt != PIX_FMT_GRAY8) {
438         if ((res = ff_cmap_read_palette(avctx, (uint32_t*)s->frame.data[1])) < 0)
439             return res;
440     }
441     s->init = 1;
442
443     if (avctx->codec_tag == MKTAG('A','C','B','M')) {
444         if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) {
445             memset(s->frame.data[0], 0, avctx->height * s->frame.linesize[0]);
446             for (plane = 0; plane < s->bpp; plane++) {
447                 for(y = 0; y < avctx->height && buf < buf_end; y++ ) {
448                     uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
449                     decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
450                     buf += s->planesize;
451                 }
452             }
453         }
454     } else if (avctx->codec_tag == MKTAG('I','L','B','M')) { // interleaved
455         if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) {
456             for(y = 0; y < avctx->height; y++ ) {
457                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
458                 memset(row, 0, avctx->width);
459                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
460                     decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
461                     buf += s->planesize;
462                 }
463             }
464         } else if (s->ham) { // HAM to PIX_FMT_BGR32
465             for (y = 0; y < avctx->height; y++) {
466                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
467                 memset(s->ham_buf, 0, avctx->width);
468                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
469                     decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
470                     buf += s->planesize;
471                 }
472                 decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
473             }
474         } else { // PIX_FMT_BGR32
475             for(y = 0; y < avctx->height; y++ ) {
476                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
477                 memset(row, 0, avctx->width << 2);
478                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
479                     decodeplane32((uint32_t *) row, buf, FFMIN(s->planesize, buf_end - buf), plane);
480                     buf += s->planesize;
481                 }
482             }
483         }
484     } else if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) { // IFF-PBM
485         for(y = 0; y < avctx->height; y++ ) {
486             uint8_t *row = &s->frame.data[0][y * s->frame.linesize[0]];
487             memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
488             buf += avctx->width + (avctx->width % 2); // padding if odd
489         }
490     } else { // IFF-PBM: HAM to PIX_FMT_BGR32
491         for (y = 0; y < avctx->height; y++) {
492             uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
493             memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
494             buf += avctx->width + (avctx->width & 1); // padding if odd
495             decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, avctx->width);
496         }
497     }
498
499     *data_size = sizeof(AVFrame);
500     *(AVFrame*)data = s->frame;
501     return buf_size;
502 }
503
504 static int decode_frame_byterun1(AVCodecContext *avctx,
505                             void *data, int *data_size,
506                             AVPacket *avpkt)
507 {
508     IffContext *s = avctx->priv_data;
509     const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
510     const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
511     const uint8_t *buf_end = buf+buf_size;
512     int y, plane, res;
513
514     if ((res = extract_header(avctx, avpkt)) < 0)
515         return res;
516     if (s->init) {
517         if ((res = avctx->reget_buffer(avctx, &s->frame)) < 0) {
518             av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
519             return res;
520         }
521     } else if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
522         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
523         return res;
524     } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt != PIX_FMT_GRAY8) {
525         if ((res = ff_cmap_read_palette(avctx, (uint32_t*)s->frame.data[1])) < 0)
526             return res;
527     }
528     s->init = 1;
529
530     if (avctx->codec_tag == MKTAG('I','L','B','M')) { //interleaved
531         if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) {
532             for(y = 0; y < avctx->height ; y++ ) {
533                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
534                 memset(row, 0, avctx->width);
535                 for (plane = 0; plane < s->bpp; plane++) {
536                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
537                     decodeplane8(row, s->planebuf, s->planesize, plane);
538                 }
539             }
540         } else if (s->ham) { // HAM to PIX_FMT_BGR32
541             for (y = 0; y < avctx->height ; y++) {
542                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
543                 memset(s->ham_buf, 0, avctx->width);
544                 for (plane = 0; plane < s->bpp; plane++) {
545                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
546                     decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
547                 }
548                 decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
549             }
550         } else { //PIX_FMT_BGR32
551             for(y = 0; y < avctx->height ; y++ ) {
552                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
553                 memset(row, 0, avctx->width << 2);
554                 for (plane = 0; plane < s->bpp; plane++) {
555                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
556                     decodeplane32((uint32_t *) row, s->planebuf, s->planesize, plane);
557                 }
558             }
559         }
560     } else if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) { // IFF-PBM
561         for(y = 0; y < avctx->height ; y++ ) {
562             uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
563             buf += decode_byterun(row, avctx->width, buf, buf_end);
564         }
565     } else { // IFF-PBM: HAM to PIX_FMT_BGR32
566         for (y = 0; y < avctx->height ; y++) {
567             uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
568             buf += decode_byterun(s->ham_buf, avctx->width, buf, buf_end);
569             decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, avctx->width);
570         }
571     }
572
573     *data_size = sizeof(AVFrame);
574     *(AVFrame*)data = s->frame;
575     return buf_size;
576 }
577
578 static av_cold int decode_end(AVCodecContext *avctx)
579 {
580     IffContext *s = avctx->priv_data;
581     if (s->frame.data[0])
582         avctx->release_buffer(avctx, &s->frame);
583     av_freep(&s->planebuf);
584     av_freep(&s->ham_buf);
585     av_freep(&s->ham_palbuf);
586     return 0;
587 }
588
589 AVCodec ff_iff_ilbm_decoder = {
590     .name           = "iff_ilbm",
591     .type           = AVMEDIA_TYPE_VIDEO,
592     .id             = CODEC_ID_IFF_ILBM,
593     .priv_data_size = sizeof(IffContext),
594     .init           = decode_init,
595     .close          = decode_end,
596     .decode         = decode_frame_ilbm,
597     .capabilities   = CODEC_CAP_DR1,
598     .long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
599 };
600
601 AVCodec ff_iff_byterun1_decoder = {
602     .name           = "iff_byterun1",
603     .type           = AVMEDIA_TYPE_VIDEO,
604     .id             = CODEC_ID_IFF_BYTERUN1,
605     .priv_data_size = sizeof(IffContext),
606     .init           = decode_init,
607     .close          = decode_end,
608     .decode         = decode_frame_byterun1,
609     .capabilities   = CODEC_CAP_DR1,
610     .long_name = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
611 };