FFmpeg  2.1.1
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 {
40 } mask_type;
41 
42 typedef struct {
44  int planesize;
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);
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 
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 
322 {
323  IffContext *s = avctx->priv_data;
324  int err;
325 
326  if (avctx->bits_per_coded_sample <= 8) {
327  int palette_size;
328 
329  if (avctx->extradata_size >= 2)
330  palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
331  else
332  palette_size = 0;
333  avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
334  (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
335  } else if (avctx->bits_per_coded_sample <= 32) {
336  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8')) {
337  avctx->pix_fmt = AV_PIX_FMT_RGB32;
338  } else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N')) {
339  avctx->pix_fmt = AV_PIX_FMT_RGB444;
340  } else if (avctx->codec_tag != MKTAG('D', 'E', 'E', 'P')) {
341  if (avctx->bits_per_coded_sample == 24) {
342  avctx->pix_fmt = AV_PIX_FMT_0BGR32;
343  } else if (avctx->bits_per_coded_sample == 32) {
344  avctx->pix_fmt = AV_PIX_FMT_BGR32;
345  } else {
346  avpriv_request_sample(avctx, "unknown bits_per_coded_sample");
347  return AVERROR_PATCHWELCOME;
348  }
349  }
350  } else {
351  return AVERROR_INVALIDDATA;
352  }
353 
354  if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
355  return err;
356  s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
358  if (!s->planebuf)
359  return AVERROR(ENOMEM);
360 
361  s->bpp = avctx->bits_per_coded_sample;
362  s->frame = av_frame_alloc();
363  if (!s->frame)
364  return AVERROR(ENOMEM);
365 
366  if ((err = extract_header(avctx, NULL)) < 0)
367  return err;
368 
369  return 0;
370 }
371 
372 /**
373  * Decode interleaved plane buffer up to 8bpp
374  * @param dst Destination buffer
375  * @param buf Source buffer
376  * @param buf_size
377  * @param plane plane number to decode as
378  */
379 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
380 {
381  const uint64_t *lut = plane8_lut[plane];
382  if (plane >= 8) {
383  av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
384  return;
385  }
386  do {
387  uint64_t v = AV_RN64A(dst) | lut[*buf++];
388  AV_WN64A(dst, v);
389  dst += 8;
390  } while (--buf_size);
391 }
392 
393 /**
394  * Decode interleaved plane buffer up to 24bpp
395  * @param dst Destination buffer
396  * @param buf Source buffer
397  * @param buf_size
398  * @param plane plane number to decode as
399  */
400 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
401 {
402  const uint32_t *lut = plane32_lut[plane];
403  do {
404  unsigned mask = (*buf >> 2) & ~3;
405  dst[0] |= lut[mask++];
406  dst[1] |= lut[mask++];
407  dst[2] |= lut[mask++];
408  dst[3] |= lut[mask];
409  mask = (*buf++ << 2) & 0x3F;
410  dst[4] |= lut[mask++];
411  dst[5] |= lut[mask++];
412  dst[6] |= lut[mask++];
413  dst[7] |= lut[mask];
414  dst += 8;
415  } while (--buf_size);
416 }
417 
418 #define DECODE_HAM_PLANE32(x) \
419  first = buf[x] << 1; \
420  second = buf[(x)+1] << 1; \
421  delta &= pal[first++]; \
422  delta |= pal[first]; \
423  dst[x] = delta; \
424  delta &= pal[second++]; \
425  delta |= pal[second]; \
426  dst[(x)+1] = delta
427 
428 /**
429  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
430  *
431  * @param dst the destination 24bpp buffer
432  * @param buf the source 8bpp chunky buffer
433  * @param pal the HAM decode table
434  * @param buf_size the plane size in bytes
435  */
436 static void decode_ham_plane32(uint32_t *dst, const uint8_t *buf,
437  const uint32_t *const pal, unsigned buf_size)
438 {
439  uint32_t delta = pal[1]; /* first palette entry */
440  do {
441  uint32_t first, second;
446  buf += 8;
447  dst += 8;
448  } while (--buf_size);
449 }
450 
451 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
452  const uint32_t *const pal, unsigned width)
453 {
454  do {
455  *dst++ = pal[*buf++];
456  } while (--width);
457 }
458 
459 /**
460  * Decode one complete byterun1 encoded line.
461  *
462  * @param dst the destination buffer where to store decompressed bitstream
463  * @param dst_size the destination plane size in bytes
464  * @param buf the source byterun1 compressed bitstream
465  * @param buf_end the EOF of source byterun1 compressed bitstream
466  * @return number of consumed bytes in byterun1 compressed bitstream
467  */
468 static int decode_byterun(uint8_t *dst, int dst_size,
469  const uint8_t *buf, const uint8_t *const buf_end)
470 {
471  const uint8_t *const buf_start = buf;
472  unsigned x;
473  for (x = 0; x < dst_size && buf < buf_end;) {
474  unsigned length;
475  const int8_t value = *buf++;
476  if (value >= 0) {
477  length = value + 1;
478  memcpy(dst + x, buf, FFMIN3(length, dst_size - x, buf_end - buf));
479  buf += length;
480  } else if (value > -128) {
481  length = -value + 1;
482  memset(dst + x, *buf++, FFMIN(length, dst_size - x));
483  } else { // noop
484  continue;
485  }
486  x += length;
487  }
488  return buf - buf_start;
489 }
490 
491 #define DECODE_RGBX_COMMON(type) \
492  if (!length) { \
493  length = bytestream2_get_byte(gb); \
494  if (!length) { \
495  length = bytestream2_get_be16(gb); \
496  if (!length) \
497  return; \
498  } \
499  } \
500  for (i = 0; i < length; i++) { \
501  *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
502  x += 1; \
503  if (x >= width) { \
504  y += 1; \
505  if (y >= height) \
506  return; \
507  x = 0; \
508  } \
509  }
510 
511 /**
512  * Decode RGB8 buffer
513  * @param[out] dst Destination buffer
514  * @param width Width of destination buffer (pixels)
515  * @param height Height of destination buffer (pixels)
516  * @param linesize Line size of destination buffer (bytes)
517  */
518 static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
519 {
520  int x = 0, y = 0, i, length;
521  while (bytestream2_get_bytes_left(gb) >= 4) {
522  uint32_t pixel = 0xFF000000 | bytestream2_get_be24(gb);
523  length = bytestream2_get_byte(gb) & 0x7F;
524  DECODE_RGBX_COMMON(uint32_t)
525  }
526 }
527 
528 /**
529  * Decode RGBN buffer
530  * @param[out] dst Destination buffer
531  * @param width Width of destination buffer (pixels)
532  * @param height Height of destination buffer (pixels)
533  * @param linesize Line size of destination buffer (bytes)
534  */
535 static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
536 {
537  int x = 0, y = 0, i, length;
538  while (bytestream2_get_bytes_left(gb) >= 2) {
539  uint32_t pixel = bytestream2_get_be16u(gb);
540  length = pixel & 0x7;
541  pixel >>= 4;
542  DECODE_RGBX_COMMON(uint16_t)
543  }
544 }
545 
546 /**
547  * Decode DEEP RLE 32-bit buffer
548  * @param[out] dst Destination buffer
549  * @param[in] src Source buffer
550  * @param src_size Source buffer size (bytes)
551  * @param width Width of destination buffer (pixels)
552  * @param height Height of destination buffer (pixels)
553  * @param linesize Line size of destination buffer (bytes)
554  */
555 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
556 {
557  const uint8_t *src_end = src + src_size;
558  int x = 0, y = 0, i;
559  while (src + 5 <= src_end) {
560  int opcode;
561  opcode = *(int8_t *)src++;
562  if (opcode >= 0) {
563  int size = opcode + 1;
564  for (i = 0; i < size; i++) {
565  int length = FFMIN(size - i, width);
566  memcpy(dst + y*linesize + x * 4, src, length * 4);
567  src += length * 4;
568  x += length;
569  i += length;
570  if (x >= width) {
571  x = 0;
572  y += 1;
573  if (y >= height)
574  return;
575  }
576  }
577  } else {
578  int size = -opcode + 1;
579  uint32_t pixel = AV_RN32(src);
580  for (i = 0; i < size; i++) {
581  *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
582  x += 1;
583  if (x >= width) {
584  x = 0;
585  y += 1;
586  if (y >= height)
587  return;
588  }
589  }
590  src += 4;
591  }
592  }
593 }
594 
595 /**
596  * Decode DEEP TVDC 32-bit buffer
597  * @param[out] dst Destination buffer
598  * @param[in] src Source buffer
599  * @param src_size Source buffer size (bytes)
600  * @param width Width of destination buffer (pixels)
601  * @param height Height of destination buffer (pixels)
602  * @param linesize Line size of destination buffer (bytes)
603  * @param[int] tvdc TVDC lookup table
604  */
605 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)
606 {
607  int x = 0, y = 0, plane = 0;
608  int8_t pixel = 0;
609  int i, j;
610 
611  for (i = 0; i < src_size * 2;) {
612 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4))
613  int d = tvdc[GETNIBBLE];
614  i++;
615  if (d) {
616  pixel += d;
617  dst[y * linesize + x*4 + plane] = pixel;
618  x++;
619  } else {
620  if (i >= src_size * 2)
621  return;
622  d = GETNIBBLE + 1;
623  i++;
624  d = FFMIN(d, width - x);
625  for (j = 0; j < d; j++) {
626  dst[y * linesize + x*4 + plane] = pixel;
627  x++;
628  }
629  }
630  if (x >= width) {
631  plane++;
632  if (plane >= 4) {
633  y++;
634  if (y >= height)
635  return;
636  plane = 0;
637  }
638  x = 0;
639  pixel = 0;
640  i = (i + 1) & ~1;
641  }
642  }
643 }
644 
645 static int unsupported(AVCodecContext *avctx)
646 {
647  IffContext *s = avctx->priv_data;
648  avpriv_request_sample(avctx, "bitmap (compression %i, bpp %i, ham %i)", s->compression, s->bpp, s->ham);
649  return AVERROR_INVALIDDATA;
650 }
651 
652 static int decode_frame(AVCodecContext *avctx,
653  void *data, int *got_frame,
654  AVPacket *avpkt)
655 {
656  IffContext *s = avctx->priv_data;
657  const uint8_t *buf = avpkt->size >= 2 ? avpkt->data + AV_RB16(avpkt->data) : NULL;
658  const int buf_size = avpkt->size >= 2 ? avpkt->size - AV_RB16(avpkt->data) : 0;
659  const uint8_t *buf_end = buf + buf_size;
660  int y, plane, res;
661  GetByteContext gb;
662 
663  if ((res = extract_header(avctx, avpkt)) < 0)
664  return res;
665  if ((res = ff_reget_buffer(avctx, s->frame)) < 0)
666  return res;
667  if (!s->init && avctx->bits_per_coded_sample <= 8 &&
668  avctx->pix_fmt == AV_PIX_FMT_PAL8) {
669  if ((res = cmap_read_palette(avctx, (uint32_t *)s->frame->data[1])) < 0)
670  return res;
671  } else if (!s->init && avctx->bits_per_coded_sample <= 8 &&
672  avctx->pix_fmt == AV_PIX_FMT_RGB32) {
673  if ((res = cmap_read_palette(avctx, s->mask_palbuf)) < 0)
674  return res;
675  }
676  s->init = 1;
677 
678  switch (s->compression) {
679  case 0:
680  if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
681  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
682  memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
683  for (plane = 0; plane < s->bpp; plane++) {
684  for (y = 0; y < avctx->height && buf < buf_end; y++) {
685  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
686  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
687  buf += s->planesize;
688  }
689  }
690  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
691  memset(s->frame->data[0], 0, avctx->height * s->frame->linesize[0]);
692  for (y = 0; y < avctx->height; y++) {
693  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
694  memset(s->ham_buf, 0, s->planesize * 8);
695  for (plane = 0; plane < s->bpp; plane++) {
696  const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
697  if (start >= buf_end)
698  break;
699  decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
700  }
701  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
702  }
703  } else
704  return unsupported(avctx);
705  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
706  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
707  int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
708  int x;
709  for (y = 0; y < avctx->height && buf < buf_end; y++) {
710  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
711  memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
712  buf += raw_width;
713  if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
714  for (x = 0; x < avctx->width; x++)
715  row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
716  }
717  }
718  } else if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
719  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
720  for (y = 0; y < avctx->height; y++) {
721  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
722  memset(row, 0, avctx->width);
723  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
724  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
725  buf += s->planesize;
726  }
727  }
728  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
729  for (y = 0; y < avctx->height; y++) {
730  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
731  memset(s->ham_buf, 0, s->planesize * 8);
732  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
733  decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
734  buf += s->planesize;
735  }
736  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
737  }
738  } else { // AV_PIX_FMT_BGR32
739  for (y = 0; y < avctx->height; y++) {
740  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
741  memset(row, 0, avctx->width << 2);
742  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
743  decodeplane32((uint32_t *)row, buf,
744  FFMIN(s->planesize, buf_end - buf), plane);
745  buf += s->planesize;
746  }
747  }
748  }
749  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
750  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
751  for (y = 0; y < avctx->height && buf_end > buf; y++) {
752  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
753  memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
754  buf += avctx->width + (avctx->width % 2); // padding if odd
755  }
756  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
757  for (y = 0; y < avctx->height && buf_end > buf; y++) {
758  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
759  memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
760  buf += avctx->width + (avctx->width & 1); // padding if odd
761  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
762  }
763  } else
764  return unsupported(avctx);
765  }
766  break;
767  case 1:
768  if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M')) { // interleaved
769  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
770  for (y = 0; y < avctx->height; y++) {
771  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
772  memset(row, 0, avctx->width);
773  for (plane = 0; plane < s->bpp; plane++) {
774  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
775  decodeplane8(row, s->planebuf, s->planesize, plane);
776  }
777  }
778  } else if (avctx->bits_per_coded_sample <= 8) { //8-bit (+ mask) to AV_PIX_FMT_BGR32
779  for (y = 0; y < avctx->height; y++) {
780  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
781  memset(s->mask_buf, 0, avctx->width * sizeof(uint32_t));
782  for (plane = 0; plane < s->bpp; plane++) {
783  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
784  decodeplane32(s->mask_buf, s->planebuf, s->planesize, plane);
785  }
786  lookup_pal_indicies((uint32_t *)row, s->mask_buf, s->mask_palbuf, avctx->width);
787  }
788  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
789  for (y = 0; y < avctx->height; y++) {
790  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
791  memset(s->ham_buf, 0, s->planesize * 8);
792  for (plane = 0; plane < s->bpp; plane++) {
793  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
794  decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
795  }
796  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
797  }
798  } else { // AV_PIX_FMT_BGR32
799  for (y = 0; y < avctx->height; y++) {
800  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
801  memset(row, 0, avctx->width << 2);
802  for (plane = 0; plane < s->bpp; plane++) {
803  buf += decode_byterun(s->planebuf, s->planesize, buf, buf_end);
804  decodeplane32((uint32_t *)row, s->planebuf, s->planesize, plane);
805  }
806  }
807  }
808  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
809  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
810  for (y = 0; y < avctx->height; y++) {
811  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
812  buf += decode_byterun(row, avctx->width, buf, buf_end);
813  }
814  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
815  for (y = 0; y < avctx->height; y++) {
816  uint8_t *row = &s->frame->data[0][y * s->frame->linesize[0]];
817  buf += decode_byterun(s->ham_buf, avctx->width, buf, buf_end);
818  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
819  }
820  } else
821  return unsupported(avctx);
822  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) { // IFF-DEEP
823  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
824  if (av_get_bits_per_pixel(desc) == 32)
825  decode_deep_rle32(s->frame->data[0], buf, buf_size, avctx->width, avctx->height, s->frame->linesize[0]);
826  else
827  return unsupported(avctx);
828  }
829  break;
830  case 4:
831  bytestream2_init(&gb, buf, buf_size);
832  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8'))
833  decode_rgb8(&gb, s->frame->data[0], avctx->width, avctx->height, s->frame->linesize[0]);
834  else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N'))
835  decode_rgbn(&gb, s->frame->data[0], avctx->width, avctx->height, s->frame->linesize[0]);
836  else
837  return unsupported(avctx);
838  break;
839  case 5:
840  if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
841  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
842  if (av_get_bits_per_pixel(desc) == 32)
843  decode_deep_tvdc32(s->frame->data[0], buf, buf_size, avctx->width, avctx->height, s->frame->linesize[0], s->tvdc);
844  else
845  return unsupported(avctx);
846  } else
847  return unsupported(avctx);
848  break;
849  default:
850  return unsupported(avctx);
851  }
852 
853  if ((res = av_frame_ref(data, s->frame)) < 0)
854  return res;
855 
856  *got_frame = 1;
857 
858  return buf_size;
859 }
860 
862 {
863  IffContext *s = avctx->priv_data;
864  av_frame_free(&s->frame);
865  av_freep(&s->planebuf);
866  av_freep(&s->ham_buf);
867  av_freep(&s->ham_palbuf);
868  return 0;
869 }
870 
871 #if CONFIG_IFF_ILBM_DECODER
872 AVCodec ff_iff_ilbm_decoder = {
873  .name = "iff",
874  .long_name = NULL_IF_CONFIG_SMALL("IFF"),
875  .type = AVMEDIA_TYPE_VIDEO,
876  .id = AV_CODEC_ID_IFF_ILBM,
877  .priv_data_size = sizeof(IffContext),
878  .init = decode_init,
879  .close = decode_end,
880  .decode = decode_frame,
881  .capabilities = CODEC_CAP_DR1,
882 };
883 #endif
884 #if CONFIG_IFF_BYTERUN1_DECODER
885 AVCodec ff_iff_byterun1_decoder = {
886  .name = "iff",
887  .long_name = NULL_IF_CONFIG_SMALL("IFF"),
888  .type = AVMEDIA_TYPE_VIDEO,
890  .priv_data_size = sizeof(IffContext),
891  .init = decode_init,
892  .close = decode_end,
893  .decode = decode_frame,
894  .capabilities = CODEC_CAP_DR1,
895 };
896 #endif
Definition: iff.c:39
float v
const char * s
Definition: avisynth_c.h:668
static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
Decode interleaved plane buffer up to 24bpp.
Definition: iff.c:400
#define AVERROR_PATCHWELCOME
int size
unsigned compression
delta compression method used
Definition: iff.c:50
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
#define AV_RN32(p)
Definition: intreadwrite.h:356
#define av_always_inline
Definition: attributes.h:41
uint32_t * mask_palbuf
masking palette table
Definition: iff.c:49
#define AV_RL24(x)
Definition: intreadwrite.h:450
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
unsigned masking
TODO: masking method used.
Definition: iff.c:55
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
unsigned transparency
TODO: transparency color index in palette.
Definition: iff.c:54
#define AV_PIX_FMT_BGR32
Definition: avcodec.h:4930
static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
Convert CMAP buffer (stored in extradata) to lavc palette format.
Definition: iff.c:142
int size
Definition: avcodec.h:1064
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:131
unsigned flags
1 for EHB, 0 is no extra half darkening
Definition: iff.c:53
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
Y , 8bpp.
Definition: avcodec.h:4542
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1254
static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
Decode interleaved plane buffer up to 8bpp.
Definition: iff.c:379
uint32_t * mask_buf
temporary buffer for palette indices
Definition: iff.c:48
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
#define DECODE_HAM_PLANE32(x)
Definition: iff.c:418
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
Definition: avfilter.c:965
static av_cold int decode_end(AVCodecContext *avctx)
Definition: iff.c:861
static uint8_t * res
Definition: ffhash.c:43
#define AV_WN64A(p, v)
Definition: intreadwrite.h:534
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * planebuf
Definition: iff.c:45
#define AV_RB16(x)
Definition: intreadwrite.h:232
uint8_t
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)
Decode DEEP TVDC 32-bit buffer.
Definition: iff.c:605
float delta
uint8_t * ham_buf
temporary buffer for planar to chunky conversation
Definition: iff.c:46
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by a given frame.
Definition: frame.c:247
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:742
Definition: iff.c:36
const char data[16]
Definition: mxf.c:68
bitstream reader API header.
mask_type
Definition: iff.c:35
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2563
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
static const uint16_t mask[17]
Definition: lzw.c:37
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:110
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:152
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:123
Libavcodec external API header.
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:1891
#define GETNIBBLE
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:580
#define LUT32(plane)
Definition: iff.c:103
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:231
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: utils.c:986
float y
Definition: iff.c:42
int width
picture width / height.
Definition: avcodec.h:1314
#define FFMIN3(a, b, c)
Definition: avcodec.h:926
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
#define FFMIN(a, b)
Definition: avcodec.h:925
#define AV_PIX_FMT_RGB32
Definition: avcodec.h:4928
AVFrame * frame
Definition: iff.c:43
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1938
int init
Definition: iff.c:56
static int width
Definition: utils.c:158
AVS_Value src
Definition: avisynth_c.h:523
#define FFMAX(a, b)
Definition: avcodec.h:923
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
#define DECODE_RGBX_COMMON(type)
Definition: iff.c:491
main external API structure.
Definition: avcodec.h:1146
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:538
int planesize
Definition: iff.c:44
unsigned int codec_tag
fourcc (LSB first, so &quot;ABCD&quot; -&gt; (&#39;D&#39;&lt;&lt;24) + (&#39;C&#39;&lt;&lt;16) + (&#39;B&#39;&lt;&lt;8) + &#39;A&#39;).
Definition: avcodec.h:1172
void * buf
Definition: avisynth_c.h:594
int extradata_size
Definition: avcodec.h:1255
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
double value
Definition: eval.c:83
#define MKTAG(a, b, c, d)
uint8_t * data
Definition: avcodec.h:1063
static av_always_inline uint32_t gray2rgb(const uint32_t x)
Definition: iff.c:135
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
#define AV_PIX_FMT_RGB444
Definition: avcodec.h:4939
#define AV_RB24(x)
Definition: intreadwrite.h:436
static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGBN buffer.
Definition: iff.c:535
uint8_t pixel
Definition: tiny_ssim.c:40
void * priv_data
Definition: avcodec.h:1182
int palette
Definition: v4l.c:60
common internal api header.
unsigned ham
0 if non-HAM or number of hold bits (6 for bpp &gt; 6, 4 otherwise)
Definition: iff.c:52
static const uint32_t plane32_lut[32][16 *4]
Definition: iff.c:123
#define FFALIGN(x, a)
Definition: avcodec.h:930
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: iff.c:652
static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGB8 buffer.
Definition: iff.c:518
#define LUT8(plane)
Definition: iff.c:78
static void decode_ham_plane32(uint32_t *dst, const uint8_t *buf, const uint32_t *const pal, unsigned buf_size)
Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
Definition: iff.c:436
static av_cold int decode_init(AVCodecContext *avctx)
Definition: iff.c:321
static const uint64_t plane8_lut[8][256]
Definition: iff.c:98
#define AVERROR_INVALIDDATA
#define av_le2ne32(x)
Definition: bswap.h:96
#define AVERROR(e)
void INT64 INT64 count
Definition: avisynth_c.h:594
void INT64 start
Definition: avisynth_c.h:594
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
const char int length
Definition: avisynth_c.h:668
static int extract_header(AVCodecContext *const avctx, const AVPacket *const avpkt)
Extracts the IFF extra context and updates internal decoder structures.
Definition: iff.c:189
8 bit with PIX_FMT_RGB32 palette
Definition: avcodec.h:4545
static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf, const uint32_t *const pal, unsigned width)
Definition: iff.c:451
int16_t tvdc[16]
TVDC lookup table.
Definition: iff.c:57
static int decode_byterun(uint8_t *dst, int dst_size, const uint8_t *buf, const uint8_t *const buf_end)
Decode one complete byterun1 encoded line.
Definition: iff.c:468
static int unsupported(AVCodecContext *avctx)
Definition: iff.c:645
#define AV_PIX_FMT_0BGR32
Definition: avcodec.h:4933
This structure stores compressed data.
Definition: avcodec.h:1040
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
uint32_t * ham_palbuf
HAM decode table.
Definition: iff.c:47
#define AV_RN64A(p)
Definition: intreadwrite.h:522
unsigned bpp
bits per plane to decode (differs from bits_per_coded_sample if HAM)
Definition: iff.c:51
static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
Decode DEEP RLE 32-bit buffer.
Definition: iff.c:555