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