iff: remove get_image_data() and get_image_size() wrappers
[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 = 1;
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('I','L','B','M')) { // interleaved
444         if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) {
445             for(y = 0; y < avctx->height; y++ ) {
446                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
447                 memset(row, 0, avctx->width);
448                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
449                     decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
450                     buf += s->planesize;
451                 }
452             }
453         } else if (s->ham) { // HAM to PIX_FMT_BGR32
454             for (y = 0; y < avctx->height; y++) {
455                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
456                 memset(s->ham_buf, 0, avctx->width);
457                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
458                     decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
459                     buf += s->planesize;
460                 }
461                 decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
462             }
463         } else { // PIX_FMT_BGR32
464             for(y = 0; y < avctx->height; y++ ) {
465                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
466                 memset(row, 0, avctx->width << 2);
467                 for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
468                     decodeplane32((uint32_t *) row, buf, FFMIN(s->planesize, buf_end - buf), plane);
469                     buf += s->planesize;
470                 }
471             }
472         }
473     } else if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) { // IFF-PBM
474         for(y = 0; y < avctx->height; y++ ) {
475             uint8_t *row = &s->frame.data[0][y * s->frame.linesize[0]];
476             memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
477             buf += avctx->width + (avctx->width % 2); // padding if odd
478         }
479     } else { // IFF-PBM: HAM to PIX_FMT_BGR32
480         for (y = 0; y < avctx->height; y++) {
481             uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
482             memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
483             buf += avctx->width + (avctx->width & 1); // padding if odd
484             decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, avctx->width);
485         }
486     }
487
488     *data_size = sizeof(AVFrame);
489     *(AVFrame*)data = s->frame;
490     return buf_size;
491 }
492
493 static int decode_frame_byterun1(AVCodecContext *avctx,
494                             void *data, int *data_size,
495                             AVPacket *avpkt)
496 {
497     IffContext *s = avctx->priv_data;
498     const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
499     const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
500     const uint8_t *buf_end = buf+buf_size;
501     int y, plane, res;
502
503     if ((res = extract_header(avctx, avpkt)) < 0)
504         return res;
505     if (s->init) {
506         if ((res = avctx->reget_buffer(avctx, &s->frame)) < 0) {
507             av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
508             return res;
509         }
510     } else if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
511         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
512         return res;
513     } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt != PIX_FMT_GRAY8) {
514         if ((res = ff_cmap_read_palette(avctx, (uint32_t*)s->frame.data[1])) < 0)
515             return res;
516     }
517     s->init = 1;
518
519     if (avctx->codec_tag == MKTAG('I','L','B','M')) { //interleaved
520         if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) {
521             for(y = 0; y < avctx->height ; y++ ) {
522                 uint8_t *row = &s->frame.data[0][ y*s->frame.linesize[0] ];
523                 memset(row, 0, avctx->width);
524                 for (plane = 0; plane < s->bpp; plane++) {
525                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
526                     decodeplane8(row, s->planebuf, s->planesize, plane);
527                 }
528             }
529         } else if (s->ham) { // HAM to PIX_FMT_BGR32
530             for (y = 0; y < avctx->height ; y++) {
531                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
532                 memset(s->ham_buf, 0, avctx->width);
533                 for (plane = 0; plane < s->bpp; plane++) {
534                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
535                     decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
536                 }
537                 decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, s->planesize);
538             }
539         } else { //PIX_FMT_BGR32
540             for(y = 0; y < avctx->height ; y++ ) {
541                 uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
542                 memset(row, 0, avctx->width << 2);
543                 for (plane = 0; plane < s->bpp; plane++) {
544                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
545                     decodeplane32((uint32_t *) row, s->planebuf, s->planesize, plane);
546                 }
547             }
548         }
549     } else if (avctx->pix_fmt == PIX_FMT_PAL8 || avctx->pix_fmt == PIX_FMT_GRAY8) { // IFF-PBM
550         for(y = 0; y < avctx->height ; y++ ) {
551             uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
552             buf += decode_byterun(row, avctx->width, buf, buf_end);
553         }
554     } else { // IFF-PBM: HAM to PIX_FMT_BGR32
555         for (y = 0; y < avctx->height ; y++) {
556             uint8_t *row = &s->frame.data[0][y*s->frame.linesize[0]];
557             buf += decode_byterun(s->ham_buf, avctx->width, buf, buf_end);
558             decode_ham_plane32((uint32_t *) row, s->ham_buf, s->ham_palbuf, avctx->width);
559         }
560     }
561
562     *data_size = sizeof(AVFrame);
563     *(AVFrame*)data = s->frame;
564     return buf_size;
565 }
566
567 static av_cold int decode_end(AVCodecContext *avctx)
568 {
569     IffContext *s = avctx->priv_data;
570     if (s->frame.data[0])
571         avctx->release_buffer(avctx, &s->frame);
572     av_freep(&s->planebuf);
573     av_freep(&s->ham_buf);
574     av_freep(&s->ham_palbuf);
575     return 0;
576 }
577
578 AVCodec ff_iff_ilbm_decoder = {
579     "iff_ilbm",
580     AVMEDIA_TYPE_VIDEO,
581     CODEC_ID_IFF_ILBM,
582     sizeof(IffContext),
583     decode_init,
584     NULL,
585     decode_end,
586     decode_frame_ilbm,
587     CODEC_CAP_DR1,
588     .long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
589 };
590
591 AVCodec ff_iff_byterun1_decoder = {
592     "iff_byterun1",
593     AVMEDIA_TYPE_VIDEO,
594     CODEC_ID_IFF_BYTERUN1,
595     sizeof(IffContext),
596     decode_init,
597     NULL,
598     decode_end,
599     decode_frame_byterun1,
600     CODEC_CAP_DR1,
601     .long_name = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
602 };