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/ANIM/DEEP/ILBM/PBM/RGB8/RGBN bitmap decoder
3  * Copyright (c) 2010 Peter Ross <pross@xvid.org>
4  * Copyright (c) 2010 Sebastian Vater <cdgs.basty@googlemail.com>
5  * Copyright (c) 2016 Paul B Mahol
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN bitmap decoder
27  */
28 
29 #include <stdint.h>
30 
31 #include "libavutil/imgutils.h"
32 #include "bytestream.h"
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "mathops.h"
36 
37 // TODO: masking bits
38 typedef enum {
43 } mask_type;
44 
45 typedef struct IffContext {
47  int planesize;
49  uint8_t * ham_buf; ///< temporary buffer for planar to chunky conversation
50  uint32_t *ham_palbuf; ///< HAM decode table
51  uint32_t *mask_buf; ///< temporary buffer for palette indices
52  uint32_t *mask_palbuf; ///< masking palette table
53  unsigned compression; ///< delta compression method used
54  unsigned is_short; ///< short compression method used
55  unsigned is_interlaced;///< video is interlaced
56  unsigned is_brush; ///< video is in ANBR format
57  unsigned bpp; ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
58  unsigned ham; ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
59  unsigned flags; ///< 1 for EHB, 0 is no extra half darkening
60  unsigned transparency; ///< TODO: transparency color index in palette
61  unsigned masking; ///< TODO: masking method used
62  int init; // 1 if buffer and palette data already initialized, 0 otherwise
63  int16_t tvdc[16]; ///< TVDC lookup table
66  unsigned video_size;
67  uint32_t *pal[2];
68 } IffContext;
69 
70 #define LUT8_PART(plane, v) \
71  AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane, \
72  AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane, \
73  AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane, \
74  AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane, \
75  AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane, \
76  AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane, \
77  AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane, \
78  AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane, \
79  AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane, \
80  AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane, \
81  AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane, \
82  AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane, \
83  AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane, \
84  AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane, \
85  AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane, \
86  AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
87 
88 #define LUT8(plane) { \
89  LUT8_PART(plane, 0x0000000), \
90  LUT8_PART(plane, 0x1000000), \
91  LUT8_PART(plane, 0x0010000), \
92  LUT8_PART(plane, 0x1010000), \
93  LUT8_PART(plane, 0x0000100), \
94  LUT8_PART(plane, 0x1000100), \
95  LUT8_PART(plane, 0x0010100), \
96  LUT8_PART(plane, 0x1010100), \
97  LUT8_PART(plane, 0x0000001), \
98  LUT8_PART(plane, 0x1000001), \
99  LUT8_PART(plane, 0x0010001), \
100  LUT8_PART(plane, 0x1010001), \
101  LUT8_PART(plane, 0x0000101), \
102  LUT8_PART(plane, 0x1000101), \
103  LUT8_PART(plane, 0x0010101), \
104  LUT8_PART(plane, 0x1010101), \
105 }
106 
107 // 8 planes * 8-bit mask
108 static const uint64_t plane8_lut[8][256] = {
109  LUT8(0), LUT8(1), LUT8(2), LUT8(3),
110  LUT8(4), LUT8(5), LUT8(6), LUT8(7),
111 };
112 
113 #define LUT32(plane) { \
114  0, 0, 0, 0, \
115  0, 0, 0, 1 << plane, \
116  0, 0, 1 << plane, 0, \
117  0, 0, 1 << plane, 1 << plane, \
118  0, 1 << plane, 0, 0, \
119  0, 1 << plane, 0, 1 << plane, \
120  0, 1 << plane, 1 << plane, 0, \
121  0, 1 << plane, 1 << plane, 1 << plane, \
122  1 << plane, 0, 0, 0, \
123  1 << plane, 0, 0, 1 << plane, \
124  1 << plane, 0, 1 << plane, 0, \
125  1 << plane, 0, 1 << plane, 1 << plane, \
126  1 << plane, 1 << plane, 0, 0, \
127  1 << plane, 1 << plane, 0, 1 << plane, \
128  1 << plane, 1 << plane, 1 << plane, 0, \
129  1 << plane, 1 << plane, 1 << plane, 1 << plane, \
130 }
131 
132 // 32 planes * 4-bit mask * 4 lookup tables each
133 static const uint32_t plane32_lut[32][16*4] = {
134  LUT32( 0), LUT32( 1), LUT32( 2), LUT32( 3),
135  LUT32( 4), LUT32( 5), LUT32( 6), LUT32( 7),
136  LUT32( 8), LUT32( 9), LUT32(10), LUT32(11),
137  LUT32(12), LUT32(13), LUT32(14), LUT32(15),
138  LUT32(16), LUT32(17), LUT32(18), LUT32(19),
139  LUT32(20), LUT32(21), LUT32(22), LUT32(23),
140  LUT32(24), LUT32(25), LUT32(26), LUT32(27),
141  LUT32(28), LUT32(29), LUT32(30), LUT32(31),
142 };
143 
144 // Gray to RGB, required for palette table of grayscale images with bpp < 8
145 static av_always_inline uint32_t gray2rgb(const uint32_t x) {
146  return x << 16 | x << 8 | x;
147 }
148 
149 /**
150  * Convert CMAP buffer (stored in extradata) to lavc palette format
151  */
152 static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
153 {
154  IffContext *s = avctx->priv_data;
155  int count, i;
156  const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
157  int palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
158 
159  if (avctx->bits_per_coded_sample > 8) {
160  av_log(avctx, AV_LOG_ERROR, "bits_per_coded_sample > 8 not supported\n");
161  return AVERROR_INVALIDDATA;
162  }
163 
164  count = 1 << avctx->bits_per_coded_sample;
165  // If extradata is smaller than actually needed, fill the remaining with black.
166  count = FFMIN(palette_size / 3, count);
167  if (count) {
168  for (i = 0; i < count; i++)
169  pal[i] = 0xFF000000 | AV_RB24(palette + i*3);
170  if (s->flags && count >= 32) { // EHB
171  for (i = 0; i < 32; i++)
172  pal[i + 32] = 0xFF000000 | (AV_RB24(palette + i*3) & 0xFEFEFE) >> 1;
173  count = FFMAX(count, 64);
174  }
175  } else { // Create gray-scale color palette for bps < 8
176  count = 1 << avctx->bits_per_coded_sample;
177 
178  for (i = 0; i < count; i++)
179  pal[i] = 0xFF000000 | gray2rgb((i * 255) >> avctx->bits_per_coded_sample);
180  }
181  if (s->masking == MASK_HAS_MASK) {
182  memcpy(pal + (1 << avctx->bits_per_coded_sample), pal, count * 4);
183  for (i = 0; i < count; i++)
184  pal[i] &= 0xFFFFFF;
185  } else if (s->masking == MASK_HAS_TRANSPARENT_COLOR &&
186  s->transparency < 1 << avctx->bits_per_coded_sample)
187  pal[s->transparency] &= 0xFFFFFF;
188  return 0;
189 }
190 
191 /**
192  * Extracts the IFF extra context and updates internal
193  * decoder structures.
194  *
195  * @param avctx the AVCodecContext where to extract extra context to
196  * @param avpkt the AVPacket to extract extra context from or NULL to use avctx
197  * @return >= 0 in case of success, a negative error code otherwise
198  */
199 static int extract_header(AVCodecContext *const avctx,
200  const AVPacket *const avpkt)
201 {
202  IffContext *s = avctx->priv_data;
203  const uint8_t *buf;
204  unsigned buf_size = 0;
205  int i, palette_size;
206 
207  if (avctx->extradata_size < 2) {
208  av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
209  return AVERROR_INVALIDDATA;
210  }
211  palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
212 
213  if (avpkt && avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
214  uint32_t chunk_id;
215  uint64_t data_size;
216  GetByteContext *gb = &s->gb;
217 
218  bytestream2_skip(gb, 4);
219  while (bytestream2_get_bytes_left(gb) >= 1) {
220  chunk_id = bytestream2_get_le32(gb);
221  data_size = bytestream2_get_be32(gb);
222 
223  if (chunk_id == MKTAG('B', 'M', 'H', 'D')) {
224  bytestream2_skip(gb, data_size + (data_size & 1));
225  } else if (chunk_id == MKTAG('A', 'N', 'H', 'D')) {
226  unsigned extra;
227  if (data_size < 40)
228  return AVERROR_INVALIDDATA;
229 
230  s->compression = (bytestream2_get_byte(gb) << 8) | (s->compression & 0xFF);
231  bytestream2_skip(gb, 19);
232  extra = bytestream2_get_be32(gb);
233  s->is_short = !(extra & 1);
234  s->is_brush = extra == 2;
235  s->is_interlaced = !!(extra & 0x40);
236  data_size -= 24;
237  bytestream2_skip(gb, data_size + (data_size & 1));
238  } else if (chunk_id == MKTAG('D', 'L', 'T', 'A') ||
239  chunk_id == MKTAG('B', 'O', 'D', 'Y')) {
240  if (chunk_id == MKTAG('B','O','D','Y'))
241  s->compression &= 0xFF;
242  break;
243  } else if (chunk_id == MKTAG('C', 'M', 'A', 'P')) {
244  int count = data_size / 3;
245  uint32_t *pal = s->pal[0];
246 
247  if (count > 256)
248  return AVERROR_INVALIDDATA;
249  if (s->ham) {
250  for (i = 0; i < count; i++)
251  pal[i] = 0xFF000000 | bytestream2_get_le24(gb);
252  } else {
253  for (i = 0; i < count; i++)
254  pal[i] = 0xFF000000 | bytestream2_get_be24(gb);
255  }
256  bytestream2_skip(gb, data_size & 1);
257  } else {
258  bytestream2_skip(gb, data_size + (data_size&1));
259  }
260  }
261  } else if (!avpkt) {
262  buf = avctx->extradata;
263  buf_size = bytestream_get_be16(&buf);
264  if (buf_size <= 1 || palette_size < 0) {
265  av_log(avctx, AV_LOG_ERROR,
266  "Invalid palette size received: %u -> palette data offset: %d\n",
267  buf_size, palette_size);
268  return AVERROR_INVALIDDATA;
269  }
270  }
271 
272  if (buf_size >= 41) {
273  s->compression = bytestream_get_byte(&buf);
274  s->bpp = bytestream_get_byte(&buf);
275  s->ham = bytestream_get_byte(&buf);
276  s->flags = bytestream_get_byte(&buf);
277  s->transparency = bytestream_get_be16(&buf);
278  s->masking = bytestream_get_byte(&buf);
279  for (i = 0; i < 16; i++)
280  s->tvdc[i] = bytestream_get_be16(&buf);
281 
282  if (s->masking == MASK_HAS_MASK) {
283  if (s->bpp >= 8 && !s->ham) {
284  avctx->pix_fmt = AV_PIX_FMT_RGB32;
285  av_freep(&s->mask_buf);
286  av_freep(&s->mask_palbuf);
288  if (!s->mask_buf)
289  return AVERROR(ENOMEM);
290  if (s->bpp > 16) {
291  av_log(avctx, AV_LOG_ERROR, "bpp %d too large for palette\n", s->bpp);
292  av_freep(&s->mask_buf);
293  return AVERROR(ENOMEM);
294  }
295  s->mask_palbuf = av_malloc((2 << s->bpp) * sizeof(uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);
296  if (!s->mask_palbuf) {
297  av_freep(&s->mask_buf);
298  return AVERROR(ENOMEM);
299  }
300  }
301  s->bpp++;
302  } else if (s->masking != MASK_NONE && s->masking != MASK_HAS_TRANSPARENT_COLOR) {
303  av_log(avctx, AV_LOG_ERROR, "Masking not supported\n");
304  return AVERROR_PATCHWELCOME;
305  }
306  if (!s->bpp || s->bpp > 32) {
307  av_log(avctx, AV_LOG_ERROR, "Invalid number of bitplanes: %u\n", s->bpp);
308  return AVERROR_INVALIDDATA;
309  } else if (s->ham >= 8) {
310  av_log(avctx, AV_LOG_ERROR, "Invalid number of hold bits for HAM: %u\n", s->ham);
311  return AVERROR_INVALIDDATA;
312  }
313 
314  av_freep(&s->ham_buf);
315  av_freep(&s->ham_palbuf);
316 
317  if (s->ham) {
318  int i, count = FFMIN(palette_size / 3, 1 << s->ham);
319  int ham_count;
320  const uint8_t *const palette = avctx->extradata + AV_RB16(avctx->extradata);
321 
323  if (!s->ham_buf)
324  return AVERROR(ENOMEM);
325 
326  ham_count = 8 * (1 << s->ham);
327  s->ham_palbuf = av_malloc((ham_count << !!(s->masking == MASK_HAS_MASK)) * sizeof (uint32_t) + AV_INPUT_BUFFER_PADDING_SIZE);
328  if (!s->ham_palbuf) {
329  av_freep(&s->ham_buf);
330  return AVERROR(ENOMEM);
331  }
332 
333  if (count) { // HAM with color palette attached
334  // prefill with black and palette and set HAM take direct value mask to zero
335  memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof (uint32_t));
336  for (i=0; i < count; i++) {
337  s->ham_palbuf[i*2+1] = 0xFF000000 | AV_RL24(palette + i*3);
338  }
339  count = 1 << s->ham;
340  } else { // HAM with grayscale color palette
341  count = 1 << s->ham;
342  for (i=0; i < count; i++) {
343  s->ham_palbuf[i*2] = 0xFF000000; // take direct color value from palette
344  s->ham_palbuf[i*2+1] = 0xFF000000 | av_le2ne32(gray2rgb((i * 255) >> s->ham));
345  }
346  }
347  for (i=0; i < count; i++) {
348  uint32_t tmp = i << (8 - s->ham);
349  tmp |= tmp >> s->ham;
350  s->ham_palbuf[(i+count)*2] = 0xFF00FFFF; // just modify blue color component
351  s->ham_palbuf[(i+count*2)*2] = 0xFFFFFF00; // just modify red color component
352  s->ham_palbuf[(i+count*3)*2] = 0xFFFF00FF; // just modify green color component
353  s->ham_palbuf[(i+count)*2+1] = 0xFF000000 | tmp << 16;
354  s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
355  s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
356  }
357  if (s->masking == MASK_HAS_MASK) {
358  for (i = 0; i < ham_count; i++)
359  s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
360  }
361  }
362  }
363 
364  return 0;
365 }
366 
368 {
369  IffContext *s = avctx->priv_data;
370  av_freep(&s->planebuf);
371  av_freep(&s->ham_buf);
372  av_freep(&s->ham_palbuf);
373  av_freep(&s->video[0]);
374  av_freep(&s->video[1]);
375  av_freep(&s->pal[0]);
376  av_freep(&s->pal[1]);
377  return 0;
378 }
379 
381 {
382  IffContext *s = avctx->priv_data;
383  int err;
384 
385  if (avctx->bits_per_coded_sample <= 8) {
386  int palette_size;
387 
388  if (avctx->extradata_size >= 2)
389  palette_size = avctx->extradata_size - AV_RB16(avctx->extradata);
390  else
391  palette_size = 0;
392  avctx->pix_fmt = (avctx->bits_per_coded_sample < 8) ||
393  (avctx->extradata_size >= 2 && palette_size) ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8;
394  } else if (avctx->bits_per_coded_sample <= 32) {
395  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8')) {
396  avctx->pix_fmt = AV_PIX_FMT_RGB32;
397  } else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N')) {
398  avctx->pix_fmt = AV_PIX_FMT_RGB444;
399  } else if (avctx->codec_tag != MKTAG('D', 'E', 'E', 'P')) {
400  if (avctx->bits_per_coded_sample == 24) {
401  avctx->pix_fmt = AV_PIX_FMT_0BGR32;
402  } else if (avctx->bits_per_coded_sample == 32) {
403  avctx->pix_fmt = AV_PIX_FMT_BGR32;
404  } else {
405  avpriv_request_sample(avctx, "unknown bits_per_coded_sample");
406  return AVERROR_PATCHWELCOME;
407  }
408  }
409  } else {
410  return AVERROR_INVALIDDATA;
411  }
412 
413  if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
414  return err;
415  s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
417  if (!s->planebuf)
418  return AVERROR(ENOMEM);
419 
420  s->bpp = avctx->bits_per_coded_sample;
421 
422  if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
423  s->video_size = FFALIGN(avctx->width, 2) * avctx->height * s->bpp;
424  s->video[0] = av_calloc(FFALIGN(avctx->width, 2) * avctx->height, s->bpp);
425  s->video[1] = av_calloc(FFALIGN(avctx->width, 2) * avctx->height, s->bpp);
426  s->pal[0] = av_calloc(256, sizeof(*s->pal[0]));
427  s->pal[1] = av_calloc(256, sizeof(*s->pal[1]));
428  if (!s->video[0] || !s->video[1] || !s->pal[0] || !s->pal[1])
429  return AVERROR(ENOMEM);
430  }
431 
432  if ((err = extract_header(avctx, NULL)) < 0)
433  return err;
434 
435  return 0;
436 }
437 
438 /**
439  * Decode interleaved plane buffer up to 8bpp
440  * @param dst Destination buffer
441  * @param buf Source buffer
442  * @param buf_size
443  * @param plane plane number to decode as
444  */
445 static void decodeplane8(uint8_t *dst, const uint8_t *buf, int buf_size, int plane)
446 {
447  const uint64_t *lut = plane8_lut[plane];
448  if (plane >= 8) {
449  av_log(NULL, AV_LOG_WARNING, "Ignoring extra planes beyond 8\n");
450  return;
451  }
452  do {
453  uint64_t v = AV_RN64A(dst) | lut[*buf++];
454  AV_WN64A(dst, v);
455  dst += 8;
456  } while (--buf_size);
457 }
458 
459 /**
460  * Decode interleaved plane buffer up to 24bpp
461  * @param dst Destination buffer
462  * @param buf Source buffer
463  * @param buf_size
464  * @param plane plane number to decode as
465  */
466 static void decodeplane32(uint32_t *dst, const uint8_t *buf, int buf_size, int plane)
467 {
468  const uint32_t *lut = plane32_lut[plane];
469  do {
470  unsigned mask = (*buf >> 2) & ~3;
471  dst[0] |= lut[mask++];
472  dst[1] |= lut[mask++];
473  dst[2] |= lut[mask++];
474  dst[3] |= lut[mask];
475  mask = (*buf++ << 2) & 0x3F;
476  dst[4] |= lut[mask++];
477  dst[5] |= lut[mask++];
478  dst[6] |= lut[mask++];
479  dst[7] |= lut[mask];
480  dst += 8;
481  } while (--buf_size);
482 }
483 
484 #define DECODE_HAM_PLANE32(x) \
485  first = buf[x] << 1; \
486  second = buf[(x)+1] << 1; \
487  delta &= pal[first++]; \
488  delta |= pal[first]; \
489  dst[x] = delta; \
490  delta &= pal[second++]; \
491  delta |= pal[second]; \
492  dst[(x)+1] = delta
493 
494 /**
495  * Converts one line of HAM6/8-encoded chunky buffer to 24bpp.
496  *
497  * @param dst the destination 24bpp buffer
498  * @param buf the source 8bpp chunky buffer
499  * @param pal the HAM decode table
500  * @param buf_size the plane size in bytes
501  */
502 static void decode_ham_plane32(uint32_t *dst, const uint8_t *buf,
503  const uint32_t *const pal, unsigned buf_size)
504 {
505  uint32_t delta = pal[1]; /* first palette entry */
506  do {
507  uint32_t first, second;
512  buf += 8;
513  dst += 8;
514  } while (--buf_size);
515 }
516 
517 static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf,
518  const uint32_t *const pal, unsigned width)
519 {
520  do {
521  *dst++ = pal[*buf++];
522  } while (--width);
523 }
524 
525 /**
526  * Decode one complete byterun1 encoded line.
527  *
528  * @param dst the destination buffer where to store decompressed bitstream
529  * @param dst_size the destination plane size in bytes
530  * @param buf the source byterun1 compressed bitstream
531  * @param buf_end the EOF of source byterun1 compressed bitstream
532  * @return number of consumed bytes in byterun1 compressed bitstream
533  */
534 static int decode_byterun(uint8_t *dst, int dst_size,
535  GetByteContext *gb)
536 {
537  unsigned x;
538  for (x = 0; x < dst_size && bytestream2_get_bytes_left(gb) > 0;) {
539  unsigned length;
540  const int8_t value = bytestream2_get_byte(gb);
541  if (value >= 0) {
542  length = FFMIN3(value + 1, dst_size - x, bytestream2_get_bytes_left(gb));
543  bytestream2_get_buffer(gb, dst + x, length);
544  } else if (value > -128) {
545  length = FFMIN(-value + 1, dst_size - x);
546  memset(dst + x, bytestream2_get_byte(gb), length);
547  } else { // noop
548  continue;
549  }
550  x += length;
551  }
552  if (x < dst_size) {
553  av_log(NULL, AV_LOG_WARNING, "decode_byterun ended before plane size\n");
554  memset(dst+x, 0, dst_size - x);
555  }
556  return bytestream2_tell(gb);
557 }
558 
559 #define DECODE_RGBX_COMMON(type) \
560  if (!length) { \
561  length = bytestream2_get_byte(gb); \
562  if (!length) { \
563  length = bytestream2_get_be16(gb); \
564  if (!length) \
565  return; \
566  } \
567  } \
568  for (i = 0; i < length; i++) { \
569  *(type *)(dst + y*linesize + x * sizeof(type)) = pixel; \
570  x += 1; \
571  if (x >= width) { \
572  y += 1; \
573  if (y >= height) \
574  return; \
575  x = 0; \
576  } \
577  }
578 
579 /**
580  * Decode RGB8 buffer
581  * @param[out] dst Destination buffer
582  * @param width Width of destination buffer (pixels)
583  * @param height Height of destination buffer (pixels)
584  * @param linesize Line size of destination buffer (bytes)
585  */
586 static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
587 {
588  int x = 0, y = 0, i, length;
589  while (bytestream2_get_bytes_left(gb) >= 4) {
590  uint32_t pixel = 0xFF000000 | bytestream2_get_be24(gb);
591  length = bytestream2_get_byte(gb) & 0x7F;
592  DECODE_RGBX_COMMON(uint32_t)
593  }
594 }
595 
596 /**
597  * Decode RGBN buffer
598  * @param[out] dst Destination buffer
599  * @param width Width of destination buffer (pixels)
600  * @param height Height of destination buffer (pixels)
601  * @param linesize Line size of destination buffer (bytes)
602  */
603 static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
604 {
605  int x = 0, y = 0, i, length;
606  while (bytestream2_get_bytes_left(gb) >= 2) {
607  uint32_t pixel = bytestream2_get_be16u(gb);
608  length = pixel & 0x7;
609  pixel >>= 4;
610  DECODE_RGBX_COMMON(uint16_t)
611  }
612 }
613 
614 /**
615  * Decode DEEP RLE 32-bit buffer
616  * @param[out] dst Destination buffer
617  * @param[in] src Source buffer
618  * @param src_size Source buffer size (bytes)
619  * @param width Width of destination buffer (pixels)
620  * @param height Height of destination buffer (pixels)
621  * @param linesize Line size of destination buffer (bytes)
622  */
623 static void decode_deep_rle32(uint8_t *dst, const uint8_t *src, int src_size, int width, int height, int linesize)
624 {
625  const uint8_t *src_end = src + src_size;
626  int x = 0, y = 0, i;
627  while (src + 5 <= src_end) {
628  int opcode;
629  opcode = *(int8_t *)src++;
630  if (opcode >= 0) {
631  int size = opcode + 1;
632  for (i = 0; i < size; i++) {
633  int length = FFMIN(size - i, width);
634  memcpy(dst + y*linesize + x * 4, src, length * 4);
635  src += length * 4;
636  x += length;
637  i += length;
638  if (x >= width) {
639  x = 0;
640  y += 1;
641  if (y >= height)
642  return;
643  }
644  }
645  } else {
646  int size = -opcode + 1;
647  uint32_t pixel = AV_RN32(src);
648  for (i = 0; i < size; i++) {
649  *(uint32_t *)(dst + y*linesize + x * 4) = pixel;
650  x += 1;
651  if (x >= width) {
652  x = 0;
653  y += 1;
654  if (y >= height)
655  return;
656  }
657  }
658  src += 4;
659  }
660  }
661 }
662 
663 /**
664  * Decode DEEP TVDC 32-bit buffer
665  * @param[out] dst Destination buffer
666  * @param[in] src Source buffer
667  * @param src_size Source buffer size (bytes)
668  * @param width Width of destination buffer (pixels)
669  * @param height Height of destination buffer (pixels)
670  * @param linesize Line size of destination buffer (bytes)
671  * @param[int] tvdc TVDC lookup table
672  */
673 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)
674 {
675  int x = 0, y = 0, plane = 0;
676  int8_t pixel = 0;
677  int i, j;
678 
679  for (i = 0; i < src_size * 2;) {
680 #define GETNIBBLE ((i & 1) ? (src[i>>1] & 0xF) : (src[i>>1] >> 4))
681  int d = tvdc[GETNIBBLE];
682  i++;
683  if (d) {
684  pixel += d;
685  dst[y * linesize + x*4 + plane] = pixel;
686  x++;
687  } else {
688  if (i >= src_size * 2)
689  return;
690  d = GETNIBBLE + 1;
691  i++;
692  d = FFMIN(d, width - x);
693  for (j = 0; j < d; j++) {
694  dst[y * linesize + x*4 + plane] = pixel;
695  x++;
696  }
697  }
698  if (x >= width) {
699  plane++;
700  if (plane >= 4) {
701  y++;
702  if (y >= height)
703  return;
704  plane = 0;
705  }
706  x = 0;
707  pixel = 0;
708  i = (i + 1) & ~1;
709  }
710  }
711 }
712 
714  const uint8_t *buf, const uint8_t *buf_end,
715  int w, int bpp, int dst_size)
716 {
717  int planepitch = FFALIGN(w, 16) >> 3;
718  int pitch = planepitch * bpp;
719  GetByteContext ptrs, gb;
720  PutByteContext pb;
721  unsigned ofssrc, pos;
722  int i, k;
723 
724  bytestream2_init(&ptrs, buf, buf_end - buf);
725  bytestream2_init_writer(&pb, dst, dst_size);
726 
727  for (k = 0; k < bpp; k++) {
728  ofssrc = bytestream2_get_be32(&ptrs);
729  pos = 0;
730 
731  if (!ofssrc)
732  continue;
733 
734  if (ofssrc >= buf_end - buf)
735  continue;
736 
737  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
738  while (bytestream2_peek_be16(&gb) != 0xFFFF && bytestream2_get_bytes_left(&gb) > 3) {
739  int16_t offset = bytestream2_get_be16(&gb);
740  unsigned noffset;
741 
742  if (offset >= 0) {
743  unsigned data = bytestream2_get_be16(&gb);
744 
745  pos += offset * 2;
746  noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
747  bytestream2_seek_p(&pb, noffset, SEEK_SET);
748  bytestream2_put_be16(&pb, data);
749  } else {
750  uint16_t count = bytestream2_get_be16(&gb);
751 
752  pos += 2 * -(offset + 2);
753  for (i = 0; i < count; i++) {
754  uint16_t data = bytestream2_get_be16(&gb);
755 
756  pos += 2;
757  noffset = (pos / planepitch) * pitch + (pos % planepitch) + k * planepitch;
758  bytestream2_seek_p(&pb, noffset, SEEK_SET);
759  bytestream2_put_be16(&pb, data);
760  }
761  }
762  }
763  }
764 }
765 
767  const uint8_t *buf, const uint8_t *buf_end,
768  int w, int xor, int bpp, int dst_size)
769 {
770  int ncolumns = ((w + 15) / 16) * 2;
771  int dstpitch = ncolumns * bpp;
772  unsigned ofsdst, ofssrc, opcode, x;
773  GetByteContext ptrs, gb;
774  PutByteContext pb;
775  int i, j, k;
776 
777  bytestream2_init(&ptrs, buf, buf_end - buf);
778  bytestream2_init_writer(&pb, dst, dst_size);
779 
780  for (k = 0; k < bpp; k++) {
781  ofssrc = bytestream2_get_be32(&ptrs);
782 
783  if (!ofssrc)
784  continue;
785 
786  if (ofssrc >= buf_end - buf)
787  continue;
788 
789  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
790  for (j = 0; j < ncolumns; j++) {
791  ofsdst = j + k * ncolumns;
792 
793  i = bytestream2_get_byte(&gb);
794  while (i > 0) {
795  opcode = bytestream2_get_byte(&gb);
796 
797  if (opcode == 0) {
798  opcode = bytestream2_get_byte(&gb);
799  x = bytestream2_get_byte(&gb);
800 
801  while (opcode) {
802  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
803  if (xor && ofsdst < dst_size) {
804  bytestream2_put_byte(&pb, dst[ofsdst] ^ x);
805  } else {
806  bytestream2_put_byte(&pb, x);
807  }
808  ofsdst += dstpitch;
809  opcode--;
810  }
811  } else if (opcode < 0x80) {
812  ofsdst += opcode * dstpitch;
813  } else {
814  opcode &= 0x7f;
815 
816  while (opcode) {
817  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
818  if (xor && ofsdst < dst_size) {
819  bytestream2_put_byte(&pb, dst[ofsdst] ^ bytestream2_get_byte(&gb));
820  } else {
821  bytestream2_put_byte(&pb, bytestream2_get_byte(&gb));
822  }
823  ofsdst += dstpitch;
824  opcode--;
825  }
826  }
827  i--;
828  }
829  }
830  }
831 }
832 
833 static void decode_delta_j(uint8_t *dst,
834  const uint8_t *buf, const uint8_t *buf_end,
835  int w, int h, int bpp, int dst_size)
836 {
837  int32_t pitch;
838  uint8_t *ptr;
839  uint32_t type, flag, cols, groups, rows, bytes;
840  uint32_t offset;
841  int planepitch_byte = (w + 7) / 8;
842  int planepitch = ((w + 15) / 16) * 2;
843  int kludge_j, b, g, r, d;
844  GetByteContext gb;
845 
846  pitch = planepitch * bpp;
847  kludge_j = w < 320 ? (320 - w) / 8 / 2 : 0;
848 
849  bytestream2_init(&gb, buf, buf_end - buf);
850 
851  while (bytestream2_get_bytes_left(&gb) >= 2) {
852  type = bytestream2_get_be16(&gb);
853 
854  switch (type) {
855  case 0:
856  return;
857  case 1:
858  flag = bytestream2_get_be16(&gb);
859  cols = bytestream2_get_be16(&gb);
860  groups = bytestream2_get_be16(&gb);
861 
862  for (g = 0; g < groups; g++) {
863  offset = bytestream2_get_be16(&gb);
864 
865  if (bytestream2_get_bytes_left(&gb) < 1)
866  return;
867 
868  if (kludge_j)
869  offset = ((offset / (320 / 8)) * pitch) + (offset % (320 / 8)) - kludge_j;
870  else
871  offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
872 
873  for (b = 0; b < cols; b++) {
874  for (d = 0; d < bpp; d++) {
875  uint8_t value = bytestream2_get_byte(&gb);
876 
877  if (offset >= dst_size)
878  return;
879  ptr = dst + offset;
880 
881  if (flag)
882  ptr[0] ^= value;
883  else
884  ptr[0] = value;
885 
886  offset += planepitch;
887  }
888  }
889  if ((cols * bpp) & 1)
890  bytestream2_skip(&gb, 1);
891  }
892  break;
893  case 2:
894  flag = bytestream2_get_be16(&gb);
895  rows = bytestream2_get_be16(&gb);
896  bytes = bytestream2_get_be16(&gb);
897  groups = bytestream2_get_be16(&gb);
898 
899  for (g = 0; g < groups; g++) {
900  offset = bytestream2_get_be16(&gb);
901 
902  if (kludge_j)
903  offset = ((offset / (320 / 8)) * pitch) + (offset % (320/ 8)) - kludge_j;
904  else
905  offset = ((offset / planepitch_byte) * pitch) + (offset % planepitch_byte);
906 
907  for (r = 0; r < rows; r++) {
908  for (d = 0; d < bpp; d++) {
909  unsigned noffset = offset + (r * pitch) + d * planepitch;
910 
911  if (bytestream2_get_bytes_left(&gb) < 1)
912  return;
913 
914  for (b = 0; b < bytes; b++) {
915  uint8_t value = bytestream2_get_byte(&gb);
916 
917  if (noffset >= dst_size)
918  return;
919  ptr = dst + noffset;
920 
921  if (flag)
922  ptr[0] ^= value;
923  else
924  ptr[0] = value;
925 
926  noffset++;
927  }
928  }
929  }
930  if ((rows * bytes * bpp) & 1)
931  bytestream2_skip(&gb, 1);
932  }
933  break;
934  default:
935  return;
936  }
937  }
938 }
939 
941  const uint8_t *buf, const uint8_t *buf_end,
942  int w, int bpp, int dst_size)
943 {
944  int ncolumns = (w + 15) >> 4;
945  int dstpitch = ncolumns * bpp * 2;
946  unsigned ofsdst, ofssrc, ofsdata, opcode, x;
947  GetByteContext ptrs, gb, dptrs, dgb;
948  PutByteContext pb;
949  int i, j, k;
950 
951  if (buf_end - buf <= 64)
952  return;
953 
954  bytestream2_init(&ptrs, buf, buf_end - buf);
955  bytestream2_init(&dptrs, buf + 32, (buf_end - buf) - 32);
956  bytestream2_init_writer(&pb, dst, dst_size);
957 
958  for (k = 0; k < bpp; k++) {
959  ofssrc = bytestream2_get_be32(&ptrs);
960  ofsdata = bytestream2_get_be32(&dptrs);
961 
962  if (!ofssrc)
963  continue;
964 
965  if (ofssrc >= buf_end - buf)
966  return;
967 
968  if (ofsdata >= buf_end - buf)
969  return;
970 
971  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
972  bytestream2_init(&dgb, buf + ofsdata, buf_end - (buf + ofsdata));
973  for (j = 0; j < ncolumns; j++) {
974  ofsdst = (j + k * ncolumns) * 2;
975 
976  i = bytestream2_get_byte(&gb);
977  while (i > 0) {
978  opcode = bytestream2_get_byte(&gb);
979 
980  if (opcode == 0) {
981  opcode = bytestream2_get_byte(&gb);
982  x = bytestream2_get_be16(&dgb);
983 
984  while (opcode) {
985  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
986  bytestream2_put_be16(&pb, x);
987  ofsdst += dstpitch;
988  opcode--;
989  }
990  } else if (opcode < 0x80) {
991  ofsdst += opcode * dstpitch;
992  } else {
993  opcode &= 0x7f;
994 
995  while (opcode) {
996  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
997  bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
998  ofsdst += dstpitch;
999  opcode--;
1000  }
1001  }
1002  i--;
1003  }
1004  }
1005  }
1006 }
1007 
1009  const uint8_t *buf, const uint8_t *buf_end,
1010  int w, int bpp, int dst_size)
1011 {
1012  int ncolumns = (w + 31) >> 5;
1013  int dstpitch = ((w + 15) / 16 * 2) * bpp;
1014  unsigned ofsdst, ofssrc, ofsdata, opcode, x;
1015  GetByteContext ptrs, gb, dptrs, dgb;
1016  PutByteContext pb;
1017  int i, j, k, h;
1018 
1019  if (buf_end - buf <= 64)
1020  return;
1021 
1022  h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1023  bytestream2_init(&ptrs, buf, buf_end - buf);
1024  bytestream2_init(&dptrs, buf + 32, (buf_end - buf) - 32);
1025  bytestream2_init_writer(&pb, dst, dst_size);
1026 
1027  for (k = 0; k < bpp; k++) {
1028  ofssrc = bytestream2_get_be32(&ptrs);
1029  ofsdata = bytestream2_get_be32(&dptrs);
1030 
1031  if (!ofssrc)
1032  continue;
1033 
1034  if (ofssrc >= buf_end - buf)
1035  return;
1036 
1037  if (ofsdata >= buf_end - buf)
1038  return;
1039 
1040  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1041  bytestream2_init(&dgb, buf + ofsdata, buf_end - (buf + ofsdata));
1042  for (j = 0; j < ncolumns; j++) {
1043  ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1044 
1045  i = bytestream2_get_byte(&gb);
1046  while (i > 0) {
1047  opcode = bytestream2_get_byte(&gb);
1048 
1049  if (opcode == 0) {
1050  opcode = bytestream2_get_byte(&gb);
1051  if (h && (j == (ncolumns - 1))) {
1052  x = bytestream2_get_be16(&dgb);
1053  bytestream2_skip(&dgb, 2);
1054  } else {
1055  x = bytestream2_get_be32(&dgb);
1056  }
1057 
1058  while (opcode) {
1059  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1060  if (h && (j == (ncolumns - 1))) {
1061  bytestream2_put_be16(&pb, x);
1062  } else {
1063  bytestream2_put_be32(&pb, x);
1064  }
1065  ofsdst += dstpitch;
1066  opcode--;
1067  }
1068  } else if (opcode < 0x80) {
1069  ofsdst += opcode * dstpitch;
1070  } else {
1071  opcode &= 0x7f;
1072 
1073  while (opcode) {
1074  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1075  if (h && (j == (ncolumns - 1))) {
1076  bytestream2_put_be16(&pb, bytestream2_get_be16(&dgb));
1077  bytestream2_skip(&dgb, 2);
1078  } else {
1079  bytestream2_put_be32(&pb, bytestream2_get_be32(&dgb));
1080  }
1081  ofsdst += dstpitch;
1082  opcode--;
1083  }
1084  }
1085  i--;
1086  }
1087  }
1088  }
1089 }
1090 
1092  const uint8_t *buf, const uint8_t *buf_end,
1093  int w, int bpp, int dst_size)
1094 {
1095  int ncolumns = (w + 15) >> 4;
1096  int dstpitch = ncolumns * bpp * 2;
1097  unsigned ofsdst, ofssrc, opcode, x;
1098  GetByteContext ptrs, gb;
1099  PutByteContext pb;
1100  int i, j, k;
1101 
1102  bytestream2_init(&ptrs, buf, buf_end - buf);
1103  bytestream2_init_writer(&pb, dst, dst_size);
1104 
1105  for (k = 0; k < bpp; k++) {
1106  ofssrc = bytestream2_get_be32(&ptrs);
1107 
1108  if (!ofssrc)
1109  continue;
1110 
1111  if (ofssrc >= buf_end - buf)
1112  continue;
1113 
1114  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1115  for (j = 0; j < ncolumns; j++) {
1116  ofsdst = (j + k * ncolumns) * 2;
1117 
1118  i = bytestream2_get_be16(&gb);
1119  while (i > 0 && bytestream2_get_bytes_left(&gb) > 4) {
1120  opcode = bytestream2_get_be16(&gb);
1121 
1122  if (opcode == 0) {
1123  opcode = bytestream2_get_be16(&gb);
1124  x = bytestream2_get_be16(&gb);
1125 
1126  while (opcode && bytestream2_get_bytes_left_p(&pb) > 1) {
1127  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1128  bytestream2_put_be16(&pb, x);
1129  ofsdst += dstpitch;
1130  opcode--;
1131  }
1132  } else if (opcode < 0x8000) {
1133  ofsdst += opcode * dstpitch;
1134  } else {
1135  opcode &= 0x7fff;
1136 
1137  while (opcode && bytestream2_get_bytes_left(&gb) > 1 &&
1138  bytestream2_get_bytes_left_p(&pb) > 1) {
1139  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1140  bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1141  ofsdst += dstpitch;
1142  opcode--;
1143  }
1144  }
1145  i--;
1146  }
1147  }
1148  }
1149 }
1150 
1152  const uint8_t *buf, const uint8_t *buf_end,
1153  int w, int bpp, int dst_size)
1154 {
1155  int ncolumns = (w + 31) >> 5;
1156  int dstpitch = ((w + 15) / 16 * 2) * bpp;
1157  unsigned ofsdst, ofssrc, opcode, x;
1158  unsigned skip = 0x80000000, mask = skip - 1;
1159  GetByteContext ptrs, gb;
1160  PutByteContext pb;
1161  int i, j, k, h;
1162 
1163  h = (((w + 15) / 16 * 2) != ((w + 31) / 32 * 4)) ? 1 : 0;
1164  bytestream2_init(&ptrs, buf, buf_end - buf);
1165  bytestream2_init_writer(&pb, dst, dst_size);
1166 
1167  for (k = 0; k < bpp; k++) {
1168  ofssrc = bytestream2_get_be32(&ptrs);
1169 
1170  if (!ofssrc)
1171  continue;
1172 
1173  if (ofssrc >= buf_end - buf)
1174  continue;
1175 
1176  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1177  for (j = 0; j < ncolumns; j++) {
1178  ofsdst = (j + k * ncolumns) * 4 - h * (2 * k);
1179 
1180  if (h && (j == (ncolumns - 1))) {
1181  skip = 0x8000;
1182  mask = skip - 1;
1183  }
1184 
1185  i = bytestream2_get_be32(&gb);
1186  while (i > 0 && bytestream2_get_bytes_left(&gb) > 4) {
1187  opcode = bytestream2_get_be32(&gb);
1188 
1189  if (opcode == 0) {
1190  if (h && (j == ncolumns - 1)) {
1191  opcode = bytestream2_get_be16(&gb);
1192  x = bytestream2_get_be16(&gb);
1193  } else {
1194  opcode = bytestream2_get_be32(&gb);
1195  x = bytestream2_get_be32(&gb);
1196  }
1197 
1198  while (opcode && bytestream2_get_bytes_left_p(&pb) > 1) {
1199  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1200  if (h && (j == ncolumns - 1))
1201  bytestream2_put_be16(&pb, x);
1202  else
1203  bytestream2_put_be32(&pb, x);
1204  ofsdst += dstpitch;
1205  opcode--;
1206  }
1207  } else if (opcode < skip) {
1208  ofsdst += opcode * dstpitch;
1209  } else {
1210  opcode &= mask;
1211 
1212  while (opcode && bytestream2_get_bytes_left(&gb) > 1 &&
1213  bytestream2_get_bytes_left_p(&pb) > 1) {
1214  bytestream2_seek_p(&pb, ofsdst, SEEK_SET);
1215  if (h && (j == ncolumns - 1)) {
1216  bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1217  } else {
1218  bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1219  }
1220  ofsdst += dstpitch;
1221  opcode--;
1222  }
1223  }
1224  i--;
1225  }
1226  }
1227  }
1228 }
1229 
1230 static void decode_delta_d(uint8_t *dst,
1231  const uint8_t *buf, const uint8_t *buf_end,
1232  int w, int flag, int bpp, int dst_size)
1233 {
1234  int planepitch = FFALIGN(w, 16) >> 3;
1235  int pitch = planepitch * bpp;
1236  int planepitch_byte = (w + 7) / 8;
1237  unsigned entries, ofssrc;
1238  GetByteContext gb, ptrs;
1239  PutByteContext pb;
1240  int k;
1241 
1242  if (buf_end - buf <= 4 * bpp)
1243  return;
1244 
1245  bytestream2_init_writer(&pb, dst, dst_size);
1246  bytestream2_init(&ptrs, buf, bpp * 4);
1247 
1248  for (k = 0; k < bpp; k++) {
1249  ofssrc = bytestream2_get_be32(&ptrs);
1250 
1251  if (!ofssrc)
1252  continue;
1253 
1254  if (ofssrc >= buf_end - buf)
1255  continue;
1256 
1257  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1258 
1259  entries = bytestream2_get_be32(&gb);
1260  while (entries && bytestream2_get_bytes_left(&gb) >= 8) {
1261  int32_t opcode = bytestream2_get_be32(&gb);
1262  unsigned offset = bytestream2_get_be32(&gb);
1263 
1264  bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1265  if (opcode >= 0) {
1266  uint32_t x = bytestream2_get_be32(&gb);
1267  while (opcode && bytestream2_get_bytes_left_p(&pb) > 0) {
1268  bytestream2_put_be32(&pb, x);
1269  bytestream2_skip_p(&pb, pitch - 4);
1270  opcode--;
1271  }
1272  } else {
1273  opcode = -opcode;
1274  while (opcode && bytestream2_get_bytes_left(&gb) > 0) {
1275  bytestream2_put_be32(&pb, bytestream2_get_be32(&gb));
1276  bytestream2_skip_p(&pb, pitch - 4);
1277  opcode--;
1278  }
1279  }
1280  entries--;
1281  }
1282  }
1283 }
1284 
1285 static void decode_delta_e(uint8_t *dst,
1286  const uint8_t *buf, const uint8_t *buf_end,
1287  int w, int flag, int bpp, int dst_size)
1288 {
1289  int planepitch = FFALIGN(w, 16) >> 3;
1290  int pitch = planepitch * bpp;
1291  int planepitch_byte = (w + 7) / 8;
1292  unsigned entries, ofssrc;
1293  GetByteContext gb, ptrs;
1294  PutByteContext pb;
1295  int k;
1296 
1297  if (buf_end - buf <= 4 * bpp)
1298  return;
1299 
1300  bytestream2_init_writer(&pb, dst, dst_size);
1301  bytestream2_init(&ptrs, buf, bpp * 4);
1302 
1303  for (k = 0; k < bpp; k++) {
1304  ofssrc = bytestream2_get_be32(&ptrs);
1305 
1306  if (!ofssrc)
1307  continue;
1308 
1309  if (ofssrc >= buf_end - buf)
1310  continue;
1311 
1312  bytestream2_init(&gb, buf + ofssrc, buf_end - (buf + ofssrc));
1313 
1314  entries = bytestream2_get_be16(&gb);
1315  while (entries && bytestream2_get_bytes_left(&gb) >= 6) {
1316  int16_t opcode = bytestream2_get_be16(&gb);
1317  unsigned offset = bytestream2_get_be32(&gb);
1318 
1319  bytestream2_seek_p(&pb, (offset / planepitch_byte) * pitch + (offset % planepitch_byte) + k * planepitch, SEEK_SET);
1320  if (opcode >= 0) {
1321  uint16_t x = bytestream2_get_be16(&gb);
1322  while (opcode && bytestream2_get_bytes_left_p(&pb) > 0) {
1323  bytestream2_put_be16(&pb, x);
1324  bytestream2_skip_p(&pb, pitch - 2);
1325  opcode--;
1326  }
1327  } else {
1328  opcode = -opcode;
1329  while (opcode && bytestream2_get_bytes_left(&gb) > 0) {
1330  bytestream2_put_be16(&pb, bytestream2_get_be16(&gb));
1331  bytestream2_skip_p(&pb, pitch - 2);
1332  opcode--;
1333  }
1334  }
1335  entries--;
1336  }
1337  }
1338 }
1339 
1340 static void decode_delta_l(uint8_t *dst,
1341  const uint8_t *buf, const uint8_t *buf_end,
1342  int w, int flag, int bpp, int dst_size)
1343 {
1344  GetByteContext off0, off1, dgb, ogb;
1345  PutByteContext pb;
1346  unsigned poff0, poff1;
1347  int i, k, dstpitch;
1348  int planepitch_byte = (w + 7) / 8;
1349  int planepitch = ((w + 15) / 16) * 2;
1350  int pitch = planepitch * bpp;
1351 
1352  if (buf_end - buf <= 64)
1353  return;
1354 
1355  bytestream2_init(&off0, buf, buf_end - buf);
1356  bytestream2_init(&off1, buf + 32, buf_end - (buf + 32));
1357  bytestream2_init_writer(&pb, dst, dst_size);
1358 
1359  dstpitch = flag ? (((w + 7) / 8) * bpp): 2;
1360 
1361  for (k = 0; k < bpp; k++) {
1362  poff0 = bytestream2_get_be32(&off0);
1363  poff1 = bytestream2_get_be32(&off1);
1364 
1365  if (!poff0)
1366  continue;
1367 
1368  if (2LL * poff0 >= buf_end - buf)
1369  return;
1370 
1371  if (2LL * poff1 >= buf_end - buf)
1372  return;
1373 
1374  bytestream2_init(&dgb, buf + 2 * poff0, buf_end - (buf + 2 * poff0));
1375  bytestream2_init(&ogb, buf + 2 * poff1, buf_end - (buf + 2 * poff1));
1376 
1377  while ((bytestream2_peek_be16(&ogb)) != 0xFFFF && bytestream2_get_bytes_left(&ogb) >= 4) {
1378  uint32_t offset = bytestream2_get_be16(&ogb);
1379  int16_t cnt = bytestream2_get_be16(&ogb);
1380  uint16_t data;
1381 
1382  offset = ((2 * offset) / planepitch_byte) * pitch + ((2 * offset) % planepitch_byte) + k * planepitch;
1383  if (cnt < 0) {
1384  bytestream2_seek_p(&pb, offset, SEEK_SET);
1385  cnt = -cnt;
1386  data = bytestream2_get_be16(&dgb);
1387  for (i = 0; i < cnt; i++) {
1388  bytestream2_put_be16(&pb, data);
1389  bytestream2_skip_p(&pb, dstpitch - 2);
1390  }
1391  } else {
1392  bytestream2_seek_p(&pb, offset, SEEK_SET);
1393  for (i = 0; i < cnt; i++) {
1394  data = bytestream2_get_be16(&dgb);
1395  bytestream2_put_be16(&pb, data);
1396  bytestream2_skip_p(&pb, dstpitch - 2);
1397  }
1398  }
1399  }
1400  }
1401 }
1402 
1403 static int unsupported(AVCodecContext *avctx)
1404 {
1405  IffContext *s = avctx->priv_data;
1406  avpriv_request_sample(avctx, "bitmap (compression 0x%0x, bpp %i, ham %i, interlaced %i)", s->compression, s->bpp, s->ham, s->is_interlaced);
1407  return AVERROR_INVALIDDATA;
1408 }
1409 
1410 static int decode_frame(AVCodecContext *avctx,
1411  void *data, int *got_frame,
1412  AVPacket *avpkt)
1413 {
1414  IffContext *s = avctx->priv_data;
1415  AVFrame *frame = data;
1416  const uint8_t *buf = avpkt->data;
1417  int buf_size = avpkt->size;
1418  const uint8_t *buf_end = buf + buf_size;
1419  int y, plane, res;
1420  GetByteContext *gb = &s->gb;
1421  const AVPixFmtDescriptor *desc;
1422 
1423  bytestream2_init(gb, avpkt->data, avpkt->size);
1424 
1425  if ((res = extract_header(avctx, avpkt)) < 0)
1426  return res;
1427 
1428  if ((res = ff_get_buffer(avctx, frame, 0)) < 0)
1429  return res;
1430  s->frame = frame;
1431 
1432  buf += bytestream2_tell(gb);
1433  buf_size -= bytestream2_tell(gb);
1434  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1435 
1436  if (!s->init && avctx->bits_per_coded_sample <= 8 &&
1437  avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1438  if ((res = cmap_read_palette(avctx, (uint32_t *)frame->data[1])) < 0)
1439  return res;
1440  } else if (!s->init && avctx->bits_per_coded_sample <= 8 &&
1441  avctx->pix_fmt == AV_PIX_FMT_RGB32) {
1442  if ((res = cmap_read_palette(avctx, s->mask_palbuf)) < 0)
1443  return res;
1444  }
1445  s->init = 1;
1446 
1447  if (s->compression <= 0xff && (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))) {
1448  if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
1449  memcpy(s->pal[0], s->frame->data[1], 256 * 4);
1450  }
1451 
1452  switch (s->compression) {
1453  case 0x0:
1454  if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
1455  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1456  memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1457  for (plane = 0; plane < s->bpp; plane++) {
1458  for (y = 0; y < avctx->height && buf < buf_end; y++) {
1459  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1460  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
1461  buf += s->planesize;
1462  }
1463  }
1464  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1465  memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
1466  for (y = 0; y < avctx->height; y++) {
1467  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1468  memset(s->ham_buf, 0, s->planesize * 8);
1469  for (plane = 0; plane < s->bpp; plane++) {
1470  const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
1471  if (start >= buf_end)
1472  break;
1473  decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
1474  }
1475  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1476  }
1477  } else
1478  return unsupported(avctx);
1479  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
1480  int raw_width = avctx->width * (av_get_bits_per_pixel(desc) >> 3);
1481  int x;
1482  for (y = 0; y < avctx->height && buf < buf_end; y++) {
1483  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1484  memcpy(row, buf, FFMIN(raw_width, buf_end - buf));
1485  buf += raw_width;
1486  if (avctx->pix_fmt == AV_PIX_FMT_BGR32) {
1487  for (x = 0; x < avctx->width; x++)
1488  row[4 * x + 3] = row[4 * x + 3] & 0xF0 | (row[4 * x + 3] >> 4);
1489  }
1490  }
1491  } else if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') || // interleaved
1492  avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1493  if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))
1494  memcpy(s->video[0], buf, FFMIN(buf_end - buf, s->video_size));
1495  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1496  for (y = 0; y < avctx->height; y++) {
1497  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1498  memset(row, 0, avctx->width);
1499  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1500  decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
1501  buf += s->planesize;
1502  }
1503  }
1504  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1505  for (y = 0; y < avctx->height; y++) {
1506  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1507  memset(s->ham_buf, 0, s->planesize * 8);
1508  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1509  decodeplane8(s->ham_buf, buf, FFMIN(s->planesize, buf_end - buf), plane);
1510  buf += s->planesize;
1511  }
1512  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1513  }
1514  } else { // AV_PIX_FMT_BGR32
1515  for (y = 0; y < avctx->height; y++) {
1516  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1517  memset(row, 0, avctx->width << 2);
1518  for (plane = 0; plane < s->bpp && buf < buf_end; plane++) {
1519  decodeplane32((uint32_t *)row, buf,
1520  FFMIN(s->planesize, buf_end - buf), plane);
1521  buf += s->planesize;
1522  }
1523  }
1524  }
1525  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
1526  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1527  for (y = 0; y < avctx->height && buf_end > buf; y++) {
1528  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1529  memcpy(row, buf, FFMIN(avctx->width, buf_end - buf));
1530  buf += avctx->width + (avctx->width % 2); // padding if odd
1531  }
1532  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
1533  for (y = 0; y < avctx->height && buf_end > buf; y++) {
1534  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1535  memcpy(s->ham_buf, buf, FFMIN(avctx->width, buf_end - buf));
1536  buf += avctx->width + (avctx->width & 1); // padding if odd
1537  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1538  }
1539  } else
1540  return unsupported(avctx);
1541  }
1542  break;
1543  case 0x1:
1544  if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') || // interleaved
1545  avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1546  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1547  uint8_t *video = s->video[0];
1548 
1549  for (y = 0; y < avctx->height; y++) {
1550  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1551  memset(row, 0, avctx->width);
1552  for (plane = 0; plane < s->bpp; plane++) {
1553  buf += decode_byterun(s->planebuf, s->planesize, gb);
1554  if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1555  memcpy(video, s->planebuf, s->planesize);
1556  video += s->planesize;
1557  }
1558  decodeplane8(row, s->planebuf, s->planesize, plane);
1559  }
1560  }
1561  } else if (avctx->bits_per_coded_sample <= 8) { //8-bit (+ mask) to AV_PIX_FMT_BGR32
1562  for (y = 0; y < avctx->height; y++) {
1563  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1564  memset(s->mask_buf, 0, avctx->width * sizeof(uint32_t));
1565  for (plane = 0; plane < s->bpp; plane++) {
1566  buf += decode_byterun(s->planebuf, s->planesize, gb);
1567  decodeplane32(s->mask_buf, s->planebuf, s->planesize, plane);
1568  }
1569  lookup_pal_indicies((uint32_t *)row, s->mask_buf, s->mask_palbuf, avctx->width);
1570  }
1571  } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
1572  uint8_t *video = s->video[0];
1573  for (y = 0; y < avctx->height; y++) {
1574  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1575  memset(s->ham_buf, 0, s->planesize * 8);
1576  for (plane = 0; plane < s->bpp; plane++) {
1577  buf += decode_byterun(s->planebuf, s->planesize, gb);
1578  if (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M')) {
1579  memcpy(video, s->planebuf, s->planesize);
1580  video += s->planesize;
1581  }
1582  decodeplane8(s->ham_buf, s->planebuf, s->planesize, plane);
1583  }
1584  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1585  }
1586  } else { // AV_PIX_FMT_BGR32
1587  for (y = 0; y < avctx->height; y++) {
1588  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1589  memset(row, 0, avctx->width << 2);
1590  for (plane = 0; plane < s->bpp; plane++) {
1591  buf += decode_byterun(s->planebuf, s->planesize, gb);
1592  decodeplane32((uint32_t *)row, s->planebuf, s->planesize, plane);
1593  }
1594  }
1595  }
1596  } else if (avctx->codec_tag == MKTAG('P', 'B', 'M', ' ')) { // IFF-PBM
1597  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1598  for (y = 0; y < avctx->height; y++) {
1599  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1600  buf += decode_byterun(row, avctx->width, gb);
1601  }
1602  } else if (s->ham) { // IFF-PBM: HAM to AV_PIX_FMT_BGR32
1603  for (y = 0; y < avctx->height; y++) {
1604  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1605  buf += decode_byterun(s->ham_buf, avctx->width, gb);
1606  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1607  }
1608  } else
1609  return unsupported(avctx);
1610  } else if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) { // IFF-DEEP
1611  if (av_get_bits_per_pixel(desc) == 32)
1612  decode_deep_rle32(frame->data[0], buf, buf_size, avctx->width, avctx->height, frame->linesize[0]);
1613  else
1614  return unsupported(avctx);
1615  }
1616  break;
1617  case 0x4:
1618  if (avctx->codec_tag == MKTAG('R', 'G', 'B', '8') && avctx->pix_fmt == AV_PIX_FMT_RGB32)
1619  decode_rgb8(gb, frame->data[0], avctx->width, avctx->height, frame->linesize[0]);
1620  else if (avctx->codec_tag == MKTAG('R', 'G', 'B', 'N') && avctx->pix_fmt == AV_PIX_FMT_RGB444)
1621  decode_rgbn(gb, frame->data[0], avctx->width, avctx->height, frame->linesize[0]);
1622  else
1623  return unsupported(avctx);
1624  break;
1625  case 0x5:
1626  if (avctx->codec_tag == MKTAG('D', 'E', 'E', 'P')) {
1627  if (av_get_bits_per_pixel(desc) == 32)
1628  decode_deep_tvdc32(frame->data[0], buf, buf_size, avctx->width, avctx->height, frame->linesize[0], s->tvdc);
1629  else
1630  return unsupported(avctx);
1631  } else
1632  return unsupported(avctx);
1633  break;
1634  case 0x300:
1635  case 0x301:
1636  decode_short_horizontal_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1637  break;
1638  case 0x500:
1639  case 0x501:
1640  decode_byte_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->is_brush, s->bpp, s->video_size);
1641  break;
1642  case 0x700:
1643  case 0x701:
1644  if (s->is_short)
1645  decode_short_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1646  else
1647  decode_long_vertical_delta(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1648  break;
1649  case 0x800:
1650  case 0x801:
1651  if (s->is_short)
1652  decode_short_vertical_delta2(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1653  else
1654  decode_long_vertical_delta2(s->video[0], buf, buf_end, avctx->width, s->bpp, s->video_size);
1655  break;
1656  case 0x4a00:
1657  case 0x4a01:
1658  decode_delta_j(s->video[0], buf, buf_end, avctx->width, avctx->height, s->bpp, s->video_size);
1659  break;
1660  case 0x6400:
1661  case 0x6401:
1662  if (s->is_interlaced)
1663  return unsupported(avctx);
1664  decode_delta_d(s->video[0], buf, buf_end, avctx->width, s->is_interlaced, s->bpp, s->video_size);
1665  break;
1666  case 0x6500:
1667  case 0x6501:
1668  if (s->is_interlaced)
1669  return unsupported(avctx);
1670  decode_delta_e(s->video[0], buf, buf_end, avctx->width, s->is_interlaced, s->bpp, s->video_size);
1671  break;
1672  case 0x6c00:
1673  case 0x6c01:
1674  decode_delta_l(s->video[0], buf, buf_end, avctx->width, s->is_short, s->bpp, s->video_size);
1675  break;
1676  default:
1677  return unsupported(avctx);
1678  }
1679 
1680  if (s->compression <= 0xff && (avctx->codec_tag == MKTAG('A', 'N', 'I', 'M'))) {
1681  memcpy(s->pal[1], s->pal[0], 256 * 4);
1682  memcpy(s->video[1], s->video[0], s->video_size);
1683  }
1684 
1685  if (s->compression > 0xff) {
1686  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
1687  buf = s->video[0];
1688  for (y = 0; y < avctx->height; y++) {
1689  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1690  memset(row, 0, avctx->width);
1691  for (plane = 0; plane < s->bpp; plane++) {
1692  decodeplane8(row, buf, s->planesize, plane);
1693  buf += s->planesize;
1694  }
1695  }
1696  memcpy(frame->data[1], s->pal[0], 256 * 4);
1697  } else if (s->ham) {
1698  int i, count = 1 << s->ham;
1699 
1700  buf = s->video[0];
1701  memset(s->ham_palbuf, 0, (1 << s->ham) * 2 * sizeof(uint32_t));
1702  for (i = 0; i < count; i++) {
1703  s->ham_palbuf[i*2+1] = s->pal[0][i];
1704  }
1705  for (i = 0; i < count; i++) {
1706  uint32_t tmp = i << (8 - s->ham);
1707  tmp |= tmp >> s->ham;
1708  s->ham_palbuf[(i+count)*2] = 0xFF00FFFF;
1709  s->ham_palbuf[(i+count*2)*2] = 0xFFFFFF00;
1710  s->ham_palbuf[(i+count*3)*2] = 0xFFFF00FF;
1711  s->ham_palbuf[(i+count)*2+1] = 0xFF000000 | tmp << 16;
1712  s->ham_palbuf[(i+count*2)*2+1] = 0xFF000000 | tmp;
1713  s->ham_palbuf[(i+count*3)*2+1] = 0xFF000000 | tmp << 8;
1714  }
1715  if (s->masking == MASK_HAS_MASK) {
1716  for (i = 0; i < 8 * (1 << s->ham); i++)
1717  s->ham_palbuf[(1 << s->bpp) + i] = s->ham_palbuf[i] | 0xFF000000;
1718  }
1719  for (y = 0; y < avctx->height; y++) {
1720  uint8_t *row = &frame->data[0][y * frame->linesize[0]];
1721  memset(s->ham_buf, 0, s->planesize * 8);
1722  for (plane = 0; plane < s->bpp; plane++) {
1723  decodeplane8(s->ham_buf, buf, s->planesize, plane);
1724  buf += s->planesize;
1725  }
1726  decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
1727  }
1728  } else {
1729  return unsupported(avctx);
1730  }
1731 
1732  if (!s->is_brush) {
1733  FFSWAP(uint8_t *, s->video[0], s->video[1]);
1734  FFSWAP(uint32_t *, s->pal[0], s->pal[1]);
1735  }
1736  }
1737 
1738  if (avpkt->flags & AV_PKT_FLAG_KEY) {
1739  frame->key_frame = 1;
1740  frame->pict_type = AV_PICTURE_TYPE_I;
1741  } else {
1742  frame->key_frame = 0;
1743  frame->pict_type = AV_PICTURE_TYPE_P;
1744  }
1745 
1746  *got_frame = 1;
1747 
1748  return buf_size;
1749 }
1750 
1751 #if CONFIG_IFF_ILBM_DECODER
1752 AVCodec ff_iff_ilbm_decoder = {
1753  .name = "iff",
1754  .long_name = NULL_IF_CONFIG_SMALL("IFF ACBM/ANIM/DEEP/ILBM/PBM/RGB8/RGBN"),
1755  .type = AVMEDIA_TYPE_VIDEO,
1756  .id = AV_CODEC_ID_IFF_ILBM,
1757  .priv_data_size = sizeof(IffContext),
1758  .init = decode_init,
1759  .close = decode_end,
1760  .decode = decode_frame,
1761  .capabilities = AV_CODEC_CAP_DR1,
1762 };
1763 #endif
int plane
Definition: avisynth_c.h:291
Definition: iff.c:42
#define NULL
Definition: coverity.c:32
unsigned is_brush
video is in ANBR format
Definition: iff.c:56
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:466
unsigned compression
delta compression method used
Definition: iff.c:53
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2193
This structure describes decoded (raw) audio or video data.
Definition: frame.h:180
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint32_t * mask_palbuf
masking palette table
Definition: iff.c:52
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
unsigned masking
TODO: masking method used.
Definition: iff.c:61
const char * g
Definition: vf_curves.c:108
const char * desc
Definition: nvenc.c:237
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:2145
unsigned transparency
TODO: transparency color index in palette.
Definition: iff.c:60
static int cmap_read_palette(AVCodecContext *avctx, uint32_t *pal)
Convert CMAP buffer (stored in extradata) to lavc palette format.
Definition: iff.c:152
GetByteContext gb
Definition: iff.c:64
int size
Definition: avcodec.h:1578
const char * b
Definition: vf_curves.c:109
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:143
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1870
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define av_le2ne32(x)
Definition: bswap.h:96
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:327
unsigned flags
1 for EHB, 0 is no extra half darkening
Definition: iff.c:59
unsigned is_short
short compression method used
Definition: iff.c:54
AVCodec.
Definition: avcodec.h:3535
static void decode_delta_e(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
Definition: iff.c:1285
uint8_t * video[2]
Definition: iff.c:65
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:445
uint32_t * mask_buf
temporary buffer for palette indices
Definition: iff.c:51
#define DECODE_HAM_PLANE32(x)
Definition: iff.c:484
static av_cold int decode_end(AVCodecContext *avctx)
Definition: iff.c:367
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:48
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
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:673
float delta
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
uint8_t * ham_buf
temporary buffer for planar to chunky conversation
Definition: iff.c:49
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3008
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1757
static AVFrame * frame
Definition: iff.c:39
uint8_t * data
Definition: avcodec.h:1577
#define FFMIN3(a, b, c)
Definition: common.h:97
mask_type
Definition: iff.c:38
ptrdiff_t size
Definition: opengl_enc.c:101
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3035
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1609
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:159
static const uint16_t mask[17]
Definition: lzw.c:38
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
const char * r
Definition: vf_curves.c:107
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
GLsizei GLsizei * length
Definition: opengl_enc.c:115
#define AV_PIX_FMT_0BGR32
Definition: pixfmt.h:320
const char * name
Name of the codec implementation.
Definition: avcodec.h:3542
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:94
unsigned is_interlaced
video is interlaced
Definition: iff.c:55
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1583
#define GETNIBBLE
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
Definition: bytestream.h:176
#define LUT32(plane)
Definition: iff.c:113
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:251
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:254
int flag
Definition: cpu-test.c:33
#define FFMIN(a, b)
Definition: common.h:96
Definition: iff.c:45
static void decode_short_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Definition: iff.c:940
int width
picture width / height.
Definition: avcodec.h:1829
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static uint8_t tmp[8]
Definition: des-test.c:38
#define width
int32_t
static void decode_short_horizontal_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Definition: iff.c:713
static int decode_byterun(uint8_t *dst, int dst_size, GetByteContext *gb)
Decode one complete byterun1 encoded line.
Definition: iff.c:534
#define AV_WN64A(p, v)
Definition: intreadwrite.h:542
AVFrame * frame
Definition: iff.c:46
#define src
Definition: vp9dsp.c:530
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset, int whence)
Definition: bytestream.h:232
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:317
int init
Definition: iff.c:62
static void decode_long_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Definition: iff.c:1008
Libavcodec external API header.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:211
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define DECODE_RGBX_COMMON(type)
Definition: iff.c:559
main external API structure.
Definition: avcodec.h:1642
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:315
int planesize
Definition: iff.c:47
static void decode_short_vertical_delta2(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Definition: iff.c:1091
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:928
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1674
void * buf
Definition: avisynth_c.h:553
GLint GLenum type
Definition: opengl_enc.c:105
int extradata_size
Definition: avcodec.h:1758
static void decode_delta_j(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int h, int bpp, int dst_size)
Definition: iff.c:833
static av_always_inline uint32_t gray2rgb(const uint32_t x)
Definition: iff.c:145
static void decode_rgbn(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGBN buffer.
Definition: iff.c:603
#define AV_RN32(p)
Definition: intreadwrite.h:364
static void decode_long_vertical_delta2(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int bpp, int dst_size)
Definition: iff.c:1151
static void decode_delta_l(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
Definition: iff.c:1340
uint8_t pixel
Definition: tiny_ssim.c:42
void * av_calloc(size_t nmemb, size_t size)
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
Definition: mem.c:260
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:194
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:722
int palette
Definition: v4l.c:61
static void decode_byte_vertical_delta(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int xor, int bpp, int dst_size)
Definition: iff.c:766
Y , 8bpp.
Definition: pixfmt.h:70
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:282
unsigned ham
0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
Definition: iff.c:58
static const uint32_t plane32_lut[32][16 *4]
Definition: iff.c:133
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: iff.c:1410
static void decode_delta_d(uint8_t *dst, const uint8_t *buf, const uint8_t *buf_end, int w, int flag, int bpp, int dst_size)
Definition: iff.c:1230
uint32_t * pal[2]
Definition: iff.c:67
static void decode_rgb8(GetByteContext *gb, uint8_t *dst, int width, int height, int linesize)
Decode RGB8 buffer.
Definition: iff.c:586
#define LUT8(plane)
Definition: iff.c:88
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:502
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:728
static av_cold int decode_init(AVCodecContext *avctx)
Definition: iff.c:380
void * priv_data
Definition: avcodec.h:1684
static const uint64_t plane8_lut[8][256]
Definition: iff.c:108
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:249
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:553
#define av_always_inline
Definition: attributes.h:39
unsigned video_size
Definition: iff.c:66
#define FFSWAP(type, a, b)
Definition: common.h:99
static int extract_header(AVCodecContext *const avctx, const AVPacket *const avpkt)
Extracts the IFF extra context and updates internal decoder structures.
Definition: iff.c:199
#define height
static void lookup_pal_indicies(uint32_t *dst, const uint32_t *buf, const uint32_t *const pal, unsigned width)
Definition: iff.c:517
int16_t tvdc[16]
TVDC lookup table.
Definition: iff.c:63
static int unsupported(AVCodecContext *avctx)
Definition: iff.c:1403
#define AV_RN64A(p)
Definition: intreadwrite.h:530
#define MKTAG(a, b, c, d)
Definition: common.h:342
This structure stores compressed data.
Definition: avcodec.h:1554
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:953
uint32_t * ham_palbuf
HAM decode table.
Definition: iff.c:50
Predicted.
Definition: avutil.h:267
unsigned bpp
bits per plane to decode (differs from bits_per_coded_sample if HAM)
Definition: iff.c:57
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:623