git.sesse.net Git - ffmpeg/blob - libavcodec/iff.c

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