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