Add missing #includes for *INT64_MAX and *INT64_C
[ffmpeg: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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 <stdint.h>
29
30 #include "libavutil/imgutils.h"
31 #include "bytestream.h"
32 #include "avcodec.h"
33 #include "get_bits.h"
34 #include "internal.h"
35
36 typedef struct {
37     AVFrame *frame;
38     int planesize;
39     uint8_t * planebuf;
40     int init; // 1 if buffer and palette data already initialized, 0 otherwise
41 } IffContext;
42
43 #define LUT8_PART(plane, v)                             \
44     AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
45     AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
46     AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
47     AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
48     AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
49     AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
50     AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
51     AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
52     AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
53     AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
54     AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
55     AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
56     AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
57     AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
58     AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
59     AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
60
61 #define LUT8(plane) {                           \
62     LUT8_PART(plane, 0x0000000),                \
63     LUT8_PART(plane, 0x1000000),                \
64     LUT8_PART(plane, 0x0010000),                \
65     LUT8_PART(plane, 0x1010000),                \
66     LUT8_PART(plane, 0x0000100),                \
67     LUT8_PART(plane, 0x1000100),                \
68     LUT8_PART(plane, 0x0010100),                \
69     LUT8_PART(plane, 0x1010100),                \
70     LUT8_PART(plane, 0x0000001),                \
71     LUT8_PART(plane, 0x1000001),                \
72     LUT8_PART(plane, 0x0010001),                \
73     LUT8_PART(plane, 0x1010001),                \
74     LUT8_PART(plane, 0x0000101),                \
75     LUT8_PART(plane, 0x1000101),                \
76     LUT8_PART(plane, 0x0010101),                \
77     LUT8_PART(plane, 0x1010101),                \
78 }
79
80 // 8 planes * 8-bit mask
81 static const uint64_t plane8_lut[8][256] = {
82     LUT8(0), LUT8(1), LUT8(2), LUT8(3),
83     LUT8(4), LUT8(5), LUT8(6), LUT8(7),
84 };
85
86 #define LUT32(plane) {                                \
87              0,          0,          0,          0,   \
88              0,          0,          0, 1 << plane,   \
89              0,          0, 1 << plane,          0,   \
90              0,          0, 1 << plane, 1 << plane,   \
91              0, 1 << plane,          0,          0,   \
92              0, 1 << plane,          0, 1 << plane,   \
93              0, 1 << plane, 1 << plane,          0,   \
94              0, 1 << plane, 1 << plane, 1 << plane,   \
95     1 << plane,          0,          0,          0,   \
96     1 << plane,          0,          0, 1 << plane,   \
97     1 << plane,          0, 1 << plane,          0,   \
98     1 << plane,          0, 1 << plane, 1 << plane,   \
99     1 << plane, 1 << plane,          0,          0,   \
100     1 << plane, 1 << plane,          0, 1 << plane,   \
101     1 << plane, 1 << plane, 1 << plane,          0,   \
102     1 << plane, 1 << plane, 1 << plane, 1 << plane,   \
103 }
104
105 // 32 planes * 4-bit mask * 4 lookup tables each
106 static const uint32_t plane32_lut[32][16*4] = {
107     LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
108     LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
109     LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
110     LUT32(12), LUT32(13), LUT32(14), LUT32(15),
111     LUT32(16), LUT32(17), LUT32(18), LUT32(19),
112     LUT32(20), LUT32(21), LUT32(22), LUT32(23),
113     LUT32(24), LUT32(25), LUT32(26), LUT32(27),
114     LUT32(28), LUT32(29), LUT32(30), LUT32(31),
115 };
116
117 // Gray to RGB, required for palette table of grayscale images with bpp < 8
118 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
119     return x << 16 | x << 8 | x;
120 }
121
122 /**
123  * Convert CMAP buffer (stored in extradata) to lavc palette format
124  */
125 static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
126 {
127     int count, i;
128
129     if (avctx->bits_per_coded_sample > 8) {
130         av_log(avctx, AV_LOG_ERROR, "bit_per_coded_sample > 8 not supported\n");
131         return AVERROR_INVALIDDATA;
132     }
133
134     count = 1 << avctx->bits_per_coded_sample;
135     // If extradata is smaller than actually needed, fill the remaining with black.
136     count = FFMIN(avctx->extradata_size / 3, count);
137     if (count) {
138         for (i = 0; i < count; i++)
139             pal[i] = 0xFF000000 | AV_RB24(avctx->extradata + i * 3);
140     } else { // Create gray-scale color palette for bps < 8
141         count = 1 << avctx->bits_per_coded_sample;
142
143         for (i = 0; i < count; i++)
144             pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
145     }
146     return 0;
147 }
148
149 static av_cold int decode_end(AVCodecContext *avctx)
150 {
151     IffContext *s = avctx->priv_data;
152     av_frame_free(&s->frame);
153     av_freep(&s->planebuf);
154     return 0;
155 }
156
157 static av_cold int decode_init(AVCodecContext *avctx)
158 {
159     IffContext *s = avctx->priv_data;
160     int err;
161
162     if (avctx->bits_per_coded_sample <= 8) {
163         avctx->pix_fmt = (avctx->bits_per_coded_sample < 8 ||
164                           avctx->extradata_size) ? AV_PIX_FMT_PAL8
165                                                  : AV_PIX_FMT_GRAY8;
166     } else if (avctx->bits_per_coded_sample <= 32) {
167         avctx->pix_fmt = AV_PIX_FMT_BGR32;
168     } else {
169         return AVERROR_INVALIDDATA;
170     }
171
172     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
173         return err;
174     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
175     s->planebuf  = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);
176     if (!s->planebuf)
177         return AVERROR(ENOMEM);
178
179     s->frame = av_frame_alloc();
180     if (!s->frame) {
181         decode_end(avctx);
182         return AVERROR(ENOMEM);
183     }
184
185     return 0;
186 }
187
188 /**
189  * Decode interleaved plane buffer up to 8bpp
190  * @param dst Destination buffer
191  * @param buf Source buffer
192  * @param buf_size
193  * @param plane plane number to decode as
194  */
195 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
196 {
197     const uint64_t *lut = plane8_lut[plane];
198     do {
199         uint64_t v = AV_RN64A(dst) | lut[*buf++];
200         AV_WN64A(dst, v);
201         dst += 8;
202     } while (--buf_size);
203 }
204
205 /**
206  * Decode interleaved plane buffer up to 24bpp
207  * @param dst Destination buffer
208  * @param buf Source buffer
209  * @param buf_size
210  * @param plane plane number to decode as
211  */
212 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
213 {
214     const uint32_t *lut = plane32_lut[plane];
215     do {
216         unsigned mask = (*buf >> 2) & ~3;
217         dst[0] |= lut[mask++];
218         dst[1] |= lut[mask++];
219         dst[2] |= lut[mask++];
220         dst[3] |= lut[mask];
221         mask    = (*buf++ << 2) & 0x3F;
222         dst[4] |= lut[mask++];
223         dst[5] |= lut[mask++];
224         dst[6] |= lut[mask++];
225         dst[7] |= lut[mask];
226         dst    += 8;
227     } while (--buf_size);
228 }
229
230 /**
231  * Decode one complete byterun1 encoded line.
232  *
233  * @param dst the destination buffer where to store decompressed bitstream
234  * @param dst_size the destination plane size in bytes
235  * @param buf the source byterun1 compressed bitstream
236  * @param buf_end the EOF of source byterun1 compressed bitstream
237  * @return number of consumed bytes in byterun1 compressed bitstream
238  */
239 static int decode_byterun(uint8_t *dst, int dst_size,
240                           const uint8_t *buf, const uint8_t *const buf_end)
241 {
242     const uint8_t *const buf_start = buf;
243     unsigned x;
244     for (x = 0; x < dst_size && buf < buf_end;) {
245         unsigned length;
246         const int8_t value = *buf++;
247         if (value >= 0) {
248             length = value + 1;
249             memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
250             buf += length;
251         } else if (value > -128) {
252             length = -value + 1;
253             memset(dst + x, *buf++, FFMIN(length, dst_size - x));
254         } else { // noop
255             continue;
256         }
257         x += length;
258     }
259     return buf - buf_start;
260 }
261
262 static int decode_frame_ilbm(AVCodecContext *avctx,
263                              void *data, int *got_frame,
264                              AVPacket *avpkt)
265 {
266     IffContext *s          = avctx->priv_data;
267     const uint8_t *buf     = avpkt->data;
268     int buf_size           = avpkt->size;
269     const uint8_t *buf_end = buf + buf_size;
270     int y, plane, res;
271
272     if ((res = ff_reget_buffer(avctx, s->frame)) < 0)
273         return res;
274
275     if (!s->init && avctx->bits_per_coded_sample <= 8 &&
276         avctx->pix_fmt != AV_PIX_FMT_GRAY8) {
277         if ((res = cmap_read_palette(avctx, (uint32_t *)s->frame->data[1])) < 0)
278             return res;
279     }
280     s->init = 1;
281
282     if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
283         if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
284             for (y = 0; y < avctx->height; y++) {
285                 uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
286                 memset(row, 0, avctx->width);
287                 for (plane = 0; plane < avctx->bits_per_coded_sample && buf < buf_end;
288                      plane++) {
289                     decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
290                     buf += s->planesize;
291                 }
292             }
293         } else { // AV_PIX_FMT_BGR32
294             for (y = 0; y < avctx->height; y++) {
295                 uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
296                 memset(row, 0, avctx->width << 2);
297                 for (plane = 0; plane < avctx->bits_per_coded_sample && buf < buf_end;
298                      plane++) {
299                     decodeplane32((uint32_t *)row, buf,
300                                   FFMIN(s->planesize, buf_end - buf), plane);
301                     buf += s->planesize;
302                 }
303             }
304         }
305     } else if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) { // IFF-PBM
306         for (y = 0; y < avctx->height && buf < buf_end; y++) {
307             uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
308             memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
309             buf += avctx->width + (avctx->width % 2); // padding if odd
310         }
311     }
312
313     if ((res = av_frame_ref(data, s->frame)) < 0)
314         return res;
315
316     *got_frame = 1;
317
318     return buf_size;
319 }
320
321 static int decode_frame_byterun1(AVCodecContext *avctx,
322                                  void *data, int *got_frame,
323                                  AVPacket *avpkt)
324 {
325     IffContext *s          = avctx->priv_data;
326     const uint8_t *buf     = avpkt->data;
327     int buf_size           = avpkt->size;
328     const uint8_t *buf_end = buf + buf_size;
329     int y, plane, res;
330
331     if ((res = ff_reget_buffer(avctx, s->frame)) < 0)
332         return res;
333
334     if (!s->init && avctx->bits_per_coded_sample <= 8 &&
335         avctx->pix_fmt != AV_PIX_FMT_GRAY8) {
336         if ((res = cmap_read_palette(avctx, (uint32_t *)s->frame->data[1])) < 0)
337             return res;
338     }
339     s->init = 1;
340
341     if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
342         if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
343             for (y = 0; y < avctx->height; y++) {
344                 uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
345                 memset(row, 0, avctx->width);
346                 for (plane = 0; plane < avctx->bits_per_coded_sample; plane++) {
347                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
348                     decodeplane8(row, s->planebuf, s->planesize, plane);
349                 }
350             }
351         } else { // AV_PIX_FMT_BGR32
352             for (y = 0; y < avctx->height; y++) {
353                 uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
354                 memset(row, 0, avctx->width << 2);
355                 for (plane = 0; plane < avctx->bits_per_coded_sample; plane++) {
356                     buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
357                     decodeplane32((uint32_t *)row, s->planebuf, s->planesize, plane);
358                 }
359             }
360         }
361     } else {
362         for (y = 0; y < avctx->height; y++) {
363             uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
364             buf += decode_byterun(row, avctx->width, buf, buf_end);
365         }
366     }
367
368     if ((res = av_frame_ref(data, s->frame)) < 0)
369         return res;
370
371     *got_frame = 1;
372
373     return buf_size;
374 }
375
376 AVCodec ff_iff_ilbm_decoder = {
377     .name           = "iff_ilbm",
378     .long_name      = NULL_IF_CONFIG_SMALL("IFF ILBM"),
379     .type           = AVMEDIA_TYPE_VIDEO,
380     .id             = AV_CODEC_ID_IFF_ILBM,
381     .priv_data_size = sizeof(IffContext),
382     .init           = decode_init,
383     .close          = decode_end,
384     .decode         = decode_frame_ilbm,
385     .capabilities   = CODEC_CAP_DR1,
386 };
387
388 AVCodec ff_iff_byterun1_decoder = {
389     .name           = "iff_byterun1",
390     .long_name      = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
391     .type           = AVMEDIA_TYPE_VIDEO,
392     .id             = AV_CODEC_ID_IFF_BYTERUN1,
393     .priv_data_size = sizeof(IffContext),
394     .init           = decode_init,
395     .close          = decode_end,
396     .decode         = decode_frame_byterun1,
397     .capabilities   = CODEC_CAP_DR1,
398 };