FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
iff.c
Go to the documentation of this file.
1 /*
2  * IFF ACBM/DEEP/ILBM/PBM 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 ACBM/DEEP/ILBM/PBM bitmap decoder
26  */
27 
28 #include "libavutil/imgutils.h"
29 #include "bytestream.h"
30 #include "avcodec.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 
34 // TODO: masking bits
35 typedef enum {
36  MASK_NONE,
37  MASK_HAS_MASK,
38  MASK_HAS_TRANSPARENT_COLOR,
39  MASK_LASSO
40 } mask_type;
41 
42 typedef struct {
43  AVFrame *frame;
44  int planesize;
45  uint8_t * planebuf;
46  uint8_t * ham_buf; ///< temporary buffer for planar to chunky conversation
47  uint32_t *ham_palbuf; ///< HAM decode table
48  uint32_t *mask_buf; ///< temporary buffer for palette indices
49  uint32_t *mask_palbuf; ///< masking palette table
50  unsigned compression; ///< delta compression method used
51  unsigned bpp; ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
52  unsigned ham; ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
53  unsigned flags; ///< 1 for EHB, 0 is no extra half darkening
54  unsigned transparency; ///< TODO: transparency color index in palette
55  unsigned masking; ///< TODO: masking method used
56  int init; // 1 if buffer and palette data already initialized, 0 otherwise
57  int16_t tvdc[16]; ///< TVDC lookup table
58 } IffContext;
59 
60 #define LUT8_PART(plane, v) \
61  AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane, \
62  AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane, \
63  AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane, \
64  AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane, \
65  AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane, \
66  AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane, \
67  AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane, \
68  AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane, \
69  AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane, \
70  AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane, \
71  AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane, \
72  AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane, \
73  AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane, \
74  AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane, \
75  AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane, \
76  AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
77 
78 #define LUT8(plane) { \
79  LUT8_PART(plane, 0x0000000), \
80  LUT8_PART(plane, 0x1000000), \
81  LUT8_PART(plane, 0x0010000), \
82  LUT8_PART(plane, 0x1010000), \
83  LUT8_PART(plane, 0x0000100), \
84  LUT8_PART(plane, 0x1000100), \
85  LUT8_PART(plane, 0x0010100), \
86  LUT8_PART(plane, 0x1010100), \
87  LUT8_PART(plane, 0x0000001), \
88  LUT8_PART(plane, 0x1000001), \
89  LUT8_PART(plane, 0x0010001), \
90  LUT8_PART(plane, 0x1010001), \
91  LUT8_PART(plane, 0x0000101), \
92  LUT8_PART(plane, 0x1000101), \
93  LUT8_PART(plane, 0x0010101), \
94  LUT8_PART(plane, 0x1010101), \
95 }
96 
97 // 8 planes * 8-bit mask
98 static const uint64_t plane8_lut[8][256] = {
99  LUT8(0), LUT8(1), LUT8(2), LUT8(3),
100  LUT8(4), LUT8(5), LUT8(6), LUT8(7),
101 };
102 
103 #define LUT32(plane) { \
104  0, 0, 0, 0, \
105  0, 0, 0, 1 << plane, \
106  0, 0, 1 << plane, 0, \
107  0, 0, 1 << plane, 1 << plane, \
108  0, 1 << plane, 0, 0, \
109  0, 1 << plane, 0, 1 << plane, \
110  0, 1 << plane, 1 << plane, 0, \
111  0, 1 << plane, 1 << plane, 1 << plane, \
112  1 << plane, 0, 0, 0, \
113  1 << plane, 0, 0, 1 << plane, \
114  1 << plane, 0, 1 << plane, 0, \
115  1 << plane, 0, 1 << plane, 1 << plane, \
116  1 << plane, 1 << plane, 0, 0, \
117  1 << plane, 1 << plane, 0, 1 << plane, \
118  1 << plane, 1 << plane, 1 << plane, 0, \
119  1 << plane, 1 << plane, 1 << plane, 1 << plane, \
120 }
121 
122 // 32 planes * 4-bit mask * 4 lookup tables each
123 static const uint32_t plane32_lut[32][16*4] = {
124  LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
125  LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
126  LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
127  LUT32(12), LUT32(13), LUT32(14), LUT32(15),
128  LUT32(16), LUT32(17), LUT32(18), LUT32(19),
129  LUT32(20), LUT32(21), LUT32(22), LUT32(23),
130  LUT32(24), LUT32(25), LUT32(26), LUT32(27),
131  LUT32(28), LUT32(29), LUT32(30), LUT32(31),
132 };
133 
134 // Gray to RGB, required for palette table of grayscale images with bpp < 8
135 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
136  return x << 16 | x << 8 | x;
137 }
138 
139 /**
140  * Convert CMAP buffer (stored in extradata) to lavc palette format
141  */
142 static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
143 {
144  IffContext *s = avctx->priv_data;
145  int count, i;
146  const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
147  int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
148 
149  if (avctx->bits_per_coded_sample > 8) {
150  av_log(avctx, AV_LOG_ERROR, "bits_per_coded_sample > 8 not supported\n");
151  return AVERROR_INVALIDDATA;
152  }
153 
154  count = 1 << avctx->bits_per_coded_sample;
155  // If extradata is smaller than actually needed, fill the remaining with black.
156  count = FFMIN(palette_size / 3, count);
157  if (count) {
158  for (i = 0; i < count; i++)
159  pal[i] = 0xFF000000 | AV_RB24(palette + i*3);
160  if (s->flags && count >= 32) { // EHB
161  for (i = 0; i < 32; i++)
162  pal[i + 32] = 0xFF000000 | (AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
163  count = FFMAX(count, 64);
164  }
165  } else { // Create gray-scale color palette for bps < 8
166  count = 1 << avctx->bits_per_coded_sample;
167 
168  for (i = 0; i < count; i++)
169  pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
170  }
171  if (s->masking == MASK_HAS_MASK) {
172  memcpy(pal + (1 << avctx->bits_per_coded_sample), pal, count * 4);
173  for (i = 0; i < count; i++)
174  pal[i] &= 0xFFFFFF;
175  } else if (s->masking == MASK_HAS_TRANSPARENT_COLOR &&
176  s->transparency < 1 << avctx->bits_per_coded_sample)
177  pal[s->transparency] &= 0xFFFFFF;
178  return 0;
179 }
180 
181 /**
182  * Extracts the IFF extra context and updates internal
183  * decoder structures.
184  *
185  * @param avctx the AVCodecContext where to extract extra context to
186  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
187  * @return >= 0 in case of success, a negative error code otherwise
188  */
189 static int extract_header(AVCodecContext *const avctx,
190  const AVPacket *const avpkt) {
191  const uint8_t *buf;
192  unsigned buf_size;
193  IffContext *s = avctx->priv_data;
194  int i, palette_size;
195 
196  if (avctx->extradata_size < 2) {
197  av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
198  return AVERROR_INVALIDDATA;
199  }
200  palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
201 
202  if (avpkt) {
203  int image_size;
204  if (avpkt->size < 2)
205  return AVERROR_INVALIDDATA;
206  image_size = avpkt->size - AV_RB16(avpkt->data);
207  buf = avpkt->data;
208  buf_size = bytestream_get_be16(&buf);
209  if (buf_size <= 1 || image_size <= 1) {
210  av_log(avctx, AV_LOG_ERROR,
211  "Invalid image size received: %u -> image data offset: %d\n",
212  buf_size, image_size);
213  return AVERROR_INVALIDDATA;
214  }
215  } else {
216  buf = avctx->extradata;
217  buf_size = bytestream_get_be16(&buf);
218  if (buf_size <= 1 || palette_size < 0) {
219  av_log(avctx, AV_LOG_ERROR,
220  "Invalid palette size received: %u -> palette data offset: %d\n",
221  buf_size, palette_size);
222  return AVERROR_INVALIDDATA;
223  }
224  }
225 
226  if (buf_size >= 41) {
227  s->compression = bytestream_get_byte(&buf);
228  s->bpp = bytestream_get_byte(&buf);
229  s->ham = bytestream_get_byte(&buf);
230  s->flags = bytestream_get_byte(&buf);
231  s->transparency = bytestream_get_be16(&buf);
232  s->masking = bytestream_get_byte(&buf);
233  for (i = 0; i < 16; i++)
234  s->tvdc[i] = bytestream_get_be16(&buf);
235 
236  if (s->masking == MASK_HAS_MASK) {
237  if (s->bpp >= 8 && !s->ham) {
238  avctx->pix_fmt = AV_PIX_FMT_RGB32;
239  av_freep(&s->mask_buf);
240  av_freep(&s->mask_palbuf);
241  s->mask_buf = av_malloc((s->planesize * 32) + FF_INPUT_BUFFER_PADDING_SIZE);
242  if (!s->mask_buf)
243  return AVERROR(ENOMEM);
244  if (s->bpp > 16) {
245  av_log(avctx, AV_LOG_ERROR, "bpp %d too large for palette\n", s->bpp);
246  av_freep(&s->mask_buf);
247  return AVERROR(ENOMEM);
248  }
249  s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
250  if (!s->mask_palbuf) {
251  av_freep(&s->mask_buf);
252  return AVERROR(ENOMEM);
253  }
254  }
255  s->bpp++;
256  } else if (s->masking != MASK_NONE && s->masking != MASK_HAS_TRANSPARENT_COLOR) {
257  av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
258  return AVERROR_PATCHWELCOME;
259  }
260  if (!s->bpp || s->bpp > 32) {
261  av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
262  return AVERROR_INVALIDDATA;
263  } else if (s->ham >= 8) {
264  av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
265  return AVERROR_INVALIDDATA;
266  }
267 
268  av_freep(&s->ham_buf);
269  av_freep(&s->ham_palbuf);
270 
271  if (s->ham) {
272  int i, count = FFMIN(palette_size / 3, 1 << s->ham);
273  int ham_count;
274  const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
275 
276  s->ham_buf = av_malloc((s->planesize * 8) + FF_INPUT_BUFFER_PADDING_SIZE);
277  if (!s->ham_buf)
278  return AVERROR(ENOMEM);
279 
280  ham_count = 8 * (1 << s->ham);
281  s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + FF_INPUT_BUFFER_PADDING_SIZE);
282  if (!s->ham_palbuf) {
283  av_freep(&s->ham_buf);
284  return AVERROR(ENOMEM);
285  }
286 
287  if (count) { // HAM with color palette attached
288  // prefill with black and palette and set HAM take direct value mask to zero
289  memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
290  for (i=0; i < count; i++) {
291  s->ham_palbuf[i*2+1] = 0xFF000000 | AV_RL24(palette + i*3);
292  }
293  count = 1 << s->ham;
294  } else { // HAM with grayscale color palette
295  count = 1 << s->ham;
296  for (i=0; i < count; i++) {
297  s->ham_palbuf[i*2] = 0xFF000000; // take direct color value from palette
298  s->ham_palbuf[i*2+1] = 0xFF000000 | av_le2ne32(gray2rgb((i * 255) >> s->ham));
299  }
300  }
301  for (i=0; i < count; i++) {
302  uint32_t tmp = i << (8 - s->ham);
303  tmp |= tmp >> s->ham;
304  s->ham_palbuf[(i+count)*2] = 0xFF00FFFF; // just modify blue color component
305  s->ham_palbuf[(i+count*2)*2] = 0xFFFFFF00; // just modify red color component
306  s->ham_palbuf[(i+count*3)*2] = 0xFFFF00FF; // just modify green color component
307  s->ham_palbuf[(i+count)*2+1] = 0xFF000000 | tmp << 16;
308  s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
309  s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
310  }
311  if (s->masking == MASK_HAS_MASK) {
312  for (i = 0; i < ham_count; i++)
313  s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
314  }
315  }
316  }
317 
318  return 0;
319 }
320 
321 static av_cold int decode_end(AVCodecContext *avctx)
322 {
323  IffContext *s = avctx->priv_data;
324  av_frame_free(&s->frame);
325  av_freep(&s->planebuf);
326  av_freep(&s->ham_buf);
327  av_freep(&s->ham_palbuf);
328  return 0;
329 }
330 
331 static av_cold int decode_init(AVCodecContext *avctx)
332 {
333  IffContext *s = avctx->priv_data;
334  int err;
335 
336  if (avctx->bits_per_coded_sample <= 8) {
337  int palette_size;
338 
339  if (avctx->extradata_size >= 2)
340  palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
341  else
342  palette_size = 0;
343  avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
344  (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
345  } else if (avctx->bits_per_coded_sample <= 32) {
346  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8')) {
347  avctx->pix_fmt = AV_PIX_FMT_RGB32;
348  } else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N')) {
349  avctx->pix_fmt = AV_PIX_FMT_RGB444;
350  } else if (avctx->codec_tag != MKTAG('D', 'E', 'E', 'P')) {
351  if (avctx->bits_per_coded_sample == 24) {
352  avctx->pix_fmt = AV_PIX_FMT_0BGR32;
353  } else if (avctx->bits_per_coded_sample == 32) {
354  avctx->pix_fmt = AV_PIX_FMT_BGR32;
355  } else {
356  avpriv_request_sample(avctx, "unknown bits_per_coded_sample");
357  return AVERROR_PATCHWELCOME;
358  }
359  }
360  } else {
361  return AVERROR_INVALIDDATA;
362  }
363 
364  if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
365  return err;
366  s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
367  s->planebuf = av_malloc(s->planesize + FF_INPUT_BUFFER_PADDING_SIZE);
368  if (!s->planebuf)
369  return AVERROR(ENOMEM);
370 
371  s->bpp = avctx->bits_per_coded_sample;
372  s->frame = av_frame_alloc();
373  if (!s->frame) {
374  decode_end(avctx);
375  return AVERROR(ENOMEM);
376  }
377 
378  if ((err = extract_header(avctx, NULL)) < 0)
379  return err;
380 
381  return 0;
382 }
383 
384 /**
385  * Decode interleaved plane buffer up to 8bpp
386  * @param dst Destination buffer
387  * @param buf Source buffer
388  * @param buf_size
389  * @param plane plane number to decode as
390  */
391 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
392 {
393  const uint64_t *lut = plane8_lut[plane];
394  if (plane >= 8) {
395  av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
396  return;
397  }
398  do {
399  uint64_t v = AV_RN64A(dst) | lut[*buf++];
400  AV_WN64A(dst, v);
401  dst += 8;
402  } while (--buf_size);
403 }
404 
405 /**
406  * Decode interleaved plane buffer up to 24bpp
407  * @param dst Destination buffer
408  * @param buf Source buffer
409  * @param buf_size
410  * @param plane plane number to decode as
411  */
412 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
413 {
414  const uint32_t *lut = plane32_lut[plane];
415  do {
416  unsigned mask = (*buf >> 2) & ~3;
417  dst[0] |= lut[mask++];
418  dst[1] |= lut[mask++];
419  dst[2] |= lut[mask++];
420  dst[3] |= lut[mask];
421  mask = (*buf++ << 2) & 0x3F;
422  dst[4] |= lut[mask++];
423  dst[5] |= lut[mask++];
424  dst[6] |= lut[mask++];
425  dst[7] |= lut[mask];
426  dst += 8;
427  } while (--buf_size);
428 }
429 
430 #define DECODE_HAM_PLANE32(x) \
431  first = buf[x] << 1; \
432  second = buf[(x)+1] << 1; \
433  delta &= pal[first++]; \
434  delta |= pal[first]; \
435  dst[x] = delta; \
436  delta &= pal[second++]; \
437  delta |= pal[second]; \
438  dst[(x)+1] = delta
439 
440 /**
441  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
442  *
443  * @param dst the destination 24bpp buffer
444  * @param buf the source 8bpp chunky buffer
445  * @param pal the HAM decode table
446  * @param buf_size the plane size in bytes
447  */
448 static void decode_ham_plane32(uint32_t *dst, const uint8_t *buf,
449  const uint32_t *const pal, unsigned buf_size)
450 {
451  uint32_t delta = pal[1]; /* first palette entry */
452  do {
453  uint32_t first, second;
454  DECODE_HAM_PLANE32(0);
455  DECODE_HAM_PLANE32(2);
456  DECODE_HAM_PLANE32(4);
457  DECODE_HAM_PLANE32(6);
458  buf += 8;
459  dst += 8;
460  } while (--buf_size);
461 }
462 
463 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
464  const uint32_t *const pal, unsigned width)
465 {
466  do {
467  *dst++ = pal[*buf++];
468  } while (--width);
469 }
470 
471 /**
472  * Decode one complete byterun1 encoded line.
473  *
474  * @param dst the destination buffer where to store decompressed bitstream
475  * @param dst_size the destination plane size in bytes
476  * @param buf the source byterun1 compressed bitstream
477  * @param buf_end the EOF of source byterun1 compressed bitstream
478  * @return number of consumed bytes in byterun1 compressed bitstream
479  */
480 static int decode_byterun(uint8_t *dst, int dst_size,
481  const uint8_t *buf, const uint8_t *const buf_end)
482 {
483  const uint8_t *const buf_start = buf;
484  unsigned x;
485  for (x = 0; x < dst_size && buf < buf_end;) {
486  unsigned length;
487  const int8_t value = *buf++;
488  if (value >= 0) {
489  length = value + 1;
490  memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
491  buf += length;
492  } else if (value > -128) {
493  length = -value + 1;
494  memset(dst + x, *buf++, FFMIN(length, dst_size - x));
495  } else { // noop
496  continue;
497  }
498  x += length;
499  }
500  return buf - buf_start;
501 }
502 
503 #define DECODE_RGBX_COMMON(type) \
504  if (!length) { \
505  length = bytestream2_get_byte(gb); \
506  if (!length) { \
507  length = bytestream2_get_be16(gb); \
508  if (!length) \
509  return; \
510  } \
511  } \
512  for (i = 0; i < length; i++) { \
513  *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
514  x += 1; \
515  if (x >= width) { \
516  y += 1; \
517  if (y >= height) \
518  return; \
519  x = 0; \
520  } \
521  }
522 
523 /**
524  * Decode RGB8 buffer
525  * @param[out] dst Destination buffer
526  * @param width Width of destination buffer (pixels)
527  * @param height Height of destination buffer (pixels)
528  * @param linesize Line size of destination buffer (bytes)
529  */
530 static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
531 {
532  int x = 0, y = 0, i, length;
533  while (bytestream2_get_bytes_left(gb) >= 4) {
534  uint32_t pixel = 0xFF000000 | bytestream2_get_be24(gb);
535  length = bytestream2_get_byte(gb) & 0x7F;
536  DECODE_RGBX_COMMON(uint32_t)
537  }
538 }
539 
540 /**
541  * Decode RGBN buffer
542  * @param[out] dst Destination buffer
543  * @param width Width of destination buffer (pixels)
544  * @param height Height of destination buffer (pixels)
545  * @param linesize Line size of destination buffer (bytes)
546  */
547 static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
548 {
549  int x = 0, y = 0, i, length;
550  while (bytestream2_get_bytes_left(gb) >= 2) {
551  uint32_t pixel = bytestream2_get_be16u(gb);
552  length = pixel & 0x7;
553  pixel >>= 4;
554  DECODE_RGBX_COMMON(uint16_t)
555  }
556 }
557 
558 /**
559  * Decode DEEP RLE 32-bit buffer
560  * @param[out] dst Destination buffer
561  * @param[in] src Source buffer
562  * @param src_size Source buffer size (bytes)
563  * @param width Width of destination buffer (pixels)
564  * @param height Height of destination buffer (pixels)
565  * @param linesize Line size of destination buffer (bytes)
566  */
567 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
568 {
569  const uint8_t *src_end = src + src_size;
570  int x = 0, y = 0, i;
571  while (src + 5 <= src_end) {
572  int opcode;
573  opcode = *(int8_t *)src++;
574  if (opcode >= 0) {
575  int size = opcode + 1;
576  for (i = 0; i < size; i++) {
577  int length = FFMIN(size - i, width);
578  memcpy(dst + y*linesize + x * 4, src, length * 4);
579  src += length * 4;
580  x += length;
581  i += length;
582  if (x >= width) {
583  x = 0;
584  y += 1;
585  if (y >= height)
586  return;
587  }
588  }
589  } else {
590  int size = -opcode + 1;
591  uint32_t pixel = AV_RN32(src);
592  for (i = 0; i < size; i++) {
593  *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
594  x += 1;
595  if (x >= width) {
596  x = 0;
597  y += 1;
598  if (y >= height)
599  return;
600  }
601  }
602  src += 4;
603  }
604  }
605 }
606 
607 /**
608  * Decode DEEP TVDC 32-bit buffer
609  * @param[out] dst Destination buffer
610  * @param[in] src Source buffer
611  * @param src_size Source buffer size (bytes)
612  * @param width Width of destination buffer (pixels)
613  * @param height Height of destination buffer (pixels)
614  * @param linesize Line size of destination buffer (bytes)
615  * @param[int] tvdc TVDC lookup table
616  */
617 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)
618 {
619  int x = 0, y = 0, plane = 0;
620  int8_t pixel = 0;
621  int i, j;
622 
623  for (i = 0; i < src_size * 2;) {
624 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4))
625  int d = tvdc[GETNIBBLE];
626  i++;
627  if (d) {
628  pixel += d;
629  dst[y * linesize + x*4 + plane] = pixel;
630  x++;
631  } else {
632  if (i >= src_size * 2)
633  return;
634  d = GETNIBBLE + 1;
635  i++;
636  d = FFMIN(d, width - x);
637  for (j = 0; j < d; j++) {
638  dst[y * linesize + x*4 + plane] = pixel;
639  x++;
640  }
641  }
642  if (x >= width) {
643  plane++;
644  if (plane >= 4) {
645  y++;
646  if (y >= height)
647  return;
648  plane = 0;
649  }
650  x = 0;
651  pixel = 0;
652  i = (i + 1) & ~1;
653  }
654  }
655 }
656 
657 static int unsupported(AVCodecContext *avctx)
658 {
659  IffContext *s = avctx->priv_data;
660  avpriv_request_sample(avctx, "bitmap (compression %i, bpp %i, ham %i)", s->compression, s->bpp, s->ham);
661  return AVERROR_INVALIDDATA;
662 }
663 
664 static int decode_frame(AVCodecContext *avctx,
665  void *data, int *got_frame,
666  AVPacket *avpkt)
667 {
668  IffContext *s = avctx->priv_data;
669  const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
670  const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
671  const uint8_t *buf_end = buf + buf_size;
672  int y, plane, res;
673  GetByteContext gb;
674 
675  if ((res = extract_header(avctx, avpkt)) < 0)
676  return res;
677  if ((res = ff_reget_buffer(avctx, s->frame)) < 0)
678  return res;
679  if (!s->init && avctx->bits_per_coded_sample <= 8 &&
680  avctx->pix_fmt == AV_PIX_FMT_PAL8) {
681  if ((res = cmap_read_palette(avctx, (uint32_t *)s->frame->data[1])) < 0)
682  return res;
683  } else if (!s->init && avctx->bits_per_coded_sample <= 8 &&
684  avctx->pix_fmt == AV_PIX_FMT_RGB32) {
685  if ((res = cmap_read_palette(avctx, s->mask_palbuf)) < 0)
686  return res;
687  }
688  s->init = 1;
689 
690  switch (s->compression) {
691  case 0:
692  if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
693  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
694  memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
695  for (plane = 0; plane < s->bpp; plane++) {
696  for (y = 0; y < avctx->height && buf < buf_end; y++) {
697  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
698  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
699  buf += s->planesize;
700  }
701  }
702  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
703  memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
704  for (y = 0; y < avctx->height; y++) {
705  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
706  memset(s->ham_buf, 0, s->planesize * 8);
707  for (plane = 0; plane < s->bpp; plane++) {
708  const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
709  if (start >= buf_end)
710  break;
711  decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
712  }
713  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
714  }
715  } else
716  return unsupported(avctx);
717  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
718  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
719  int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
720  int x;
721  for (y = 0; y < avctx->height && buf < buf_end; y++) {
722  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
723  memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
724  buf += raw_width;
725  if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
726  for (x = 0; x < avctx->width; x++)
727  row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
728  }
729  }
730  } else if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
731  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
732  for (y = 0; y < avctx->height; y++) {
733  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
734  memset(row, 0, avctx->width);
735  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
736  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
737  buf += s->planesize;
738  }
739  }
740  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
741  for (y = 0; y < avctx->height; y++) {
742  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
743  memset(s->ham_buf, 0, s->planesize * 8);
744  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
745  decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
746  buf += s->planesize;
747  }
748  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
749  }
750  } else { // AV_PIX_FMT_BGR32
751  for (y = 0; y < avctx->height; y++) {
752  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
753  memset(row, 0, avctx->width << 2);
754  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
755  decodeplane32((uint32_t *)row, buf,
756  FFMIN(s->planesize, buf_end - buf), plane);
757  buf += s->planesize;
758  }
759  }
760  }
761  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
762  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
763  for (y = 0; y < avctx->height && buf_end > buf; y++) {
764  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
765  memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
766  buf += avctx->width + (avctx->width % 2); // padding if odd
767  }
768  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
769  for (y = 0; y < avctx->height && buf_end > buf; y++) {
770  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
771  memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
772  buf += avctx->width + (avctx->width & 1); // padding if odd
773  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
774  }
775  } else
776  return unsupported(avctx);
777  }
778  break;
779  case 1:
780  if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
781  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
782  for (y = 0; y < avctx->height; y++) {
783  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
784  memset(row, 0, avctx->width);
785  for (plane = 0; plane < s->bpp; plane++) {
786  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
787  decodeplane8(row, s->planebuf, s->planesize, plane);
788  }
789  }
790  } else if (avctx->bits_per_coded_sample <= 8) { //8-bit (+ mask) to AV_PIX_FMT_BGR32
791  for (y = 0; y < avctx->height; y++) {
792  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
793  memset(s->mask_buf, 0, avctx->width * sizeof(uint32_t));
794  for (plane = 0; plane < s->bpp; plane++) {
795  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
796  decodeplane32(s->mask_buf, s->planebuf, s->planesize, plane);
797  }
798  lookup_pal_indicies((uint32_t *)row, s->mask_buf, s->mask_palbuf, avctx->width);
799  }
800  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
801  for (y = 0; y < avctx->height; y++) {
802  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
803  memset(s->ham_buf, 0, s->planesize * 8);
804  for (plane = 0; plane < s->bpp; plane++) {
805  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
806  decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
807  }
808  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
809  }
810  } else { // AV_PIX_FMT_BGR32
811  for (y = 0; y < avctx->height; y++) {
812  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
813  memset(row, 0, avctx->width << 2);
814  for (plane = 0; plane < s->bpp; plane++) {
815  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
816  decodeplane32((uint32_t *)row, s->planebuf, s->planesize, plane);
817  }
818  }
819  }
820  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
821  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
822  for (y = 0; y < avctx->height; y++) {
823  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
824  buf += decode_byterun(row, avctx->width, buf, buf_end);
825  }
826  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
827  for (y = 0; y < avctx->height; y++) {
828  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
829  buf += decode_byterun(s->ham_buf, avctx->width, buf, buf_end);
830  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
831  }
832  } else
833  return unsupported(avctx);
834  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) { // IFF-DEEP
835  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
836  if (av_get_bits_per_pixel(desc) == 32)
837  decode_deep_rle32(s->frame->data[0], buf, buf_size, avctx->width, avctx->height, s->frame->linesize[0]);
838  else
839  return unsupported(avctx);
840  }
841  break;
842  case 4:
843  bytestream2_init(&gb, buf, buf_size);
844  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8'))
845  decode_rgb8(&gb, s->frame->data[0], avctx->width, avctx->height, s->frame->linesize[0]);
846  else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N'))
847  decode_rgbn(&gb, s->frame->data[0], avctx->width, avctx->height, s->frame->linesize[0]);
848  else
849  return unsupported(avctx);
850  break;
851  case 5:
852  if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
853  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
854  if (av_get_bits_per_pixel(desc) == 32)
855  decode_deep_tvdc32(s->frame->data[0], buf, buf_size, avctx->width, avctx->height, s->frame->linesize[0], s->tvdc);
856  else
857  return unsupported(avctx);
858  } else
859  return unsupported(avctx);
860  break;
861  default:
862  return unsupported(avctx);
863  }
864 
865  if ((res = av_frame_ref(data, s->frame)) < 0)
866  return res;
867 
868  *got_frame = 1;
869 
870  return buf_size;
871 }
872 
873 #if CONFIG_IFF_ILBM_DECODER
874 AVCodec ff_iff_ilbm_decoder = {
875  .name = "iff",
876  .long_name = NULL_IF_CONFIG_SMALL("IFF"),
877  .type = AVMEDIA_TYPE_VIDEO,
878  .id = AV_CODEC_ID_IFF_ILBM,
879  .priv_data_size = sizeof(IffContext),
880  .init = decode_init,
881  .close = decode_end,
882  .decode = decode_frame,
883  .capabilities = CODEC_CAP_DR1,
884 };
885 #endif
886 #if CONFIG_IFF_BYTERUN1_DECODER
887 AVCodec ff_iff_byterun1_decoder = {
888  .name = "iff",
889  .long_name = NULL_IF_CONFIG_SMALL("IFF"),
890  .type = AVMEDIA_TYPE_VIDEO,
891  .id = AV_CODEC_ID_IFF_BYTERUN1,
892  .priv_data_size = sizeof(IffContext),
893  .init = decode_init,
894  .close = decode_end,
895  .decode = decode_frame,
896  .capabilities = CODEC_CAP_DR1,
897 };
898 #endif
Generated on Sat Jan 25 2014 19:51:49 for FFmpeg by   doxygen 1.8.2