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