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

   1 /*
   2  * Photoshop (PSD) image decoder
   3  * Copyright (c) 2016 Jokyo Images
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "bytestream.h"
  23 #include "internal.h"
  24
  25 enum PsdCompr {
  26     PSD_RAW,
  27     PSD_RLE,
  28     PSD_ZIP_WITHOUT_P,
  29     PSD_ZIP_WITH_P,
  30 };
  31
  32 enum PsdColorMode {
  33     PSD_BITMAP,
  34     PSD_GRAYSCALE,
  35     PSD_INDEXED,
  36     PSD_RGB,
  37     PSD_CMYK,
  38     PSD_MULTICHANNEL,
  39     PSD_DUOTONE,
  40     PSD_LAB,
  41 };
  42
  43 typedef struct PSDContext {
  44     AVClass *class;
  45     AVFrame *picture;
  46     AVCodecContext *avctx;
  47     GetByteContext gb;
  48
  49     uint8_t * tmp;
  50
  51     uint16_t channel_count;
  52     uint16_t channel_depth;
  53
  54     uint64_t uncompressed_size;
  55     unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */
  56     uint64_t line_size;/* length of src data (even width) */
  57
  58     int width;
  59     int height;
  60
  61     enum PsdCompr compression;
  62     enum PsdColorMode color_mode;
  63
  64     uint8_t palette[AVPALETTE_SIZE];
  65 } PSDContext;
  66
  67 static int decode_header(PSDContext * s)
  68 {
  69     int signature, version, color_mode;
  70     int64_t len_section;
  71     int ret = 0;
  72
  73     if (bytestream2_get_bytes_left(&s->gb) < 30) {/* File header section + color map data section length */
  74         av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
  75         return AVERROR_INVALIDDATA;
  76     }
  77
  78     signature = bytestream2_get_le32(&s->gb);
  79     if (signature != MKTAG('8','B','P','S')) {
  80         av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature);
  81         return AVERROR_INVALIDDATA;
  82     }
  83
  84     version = bytestream2_get_be16(&s->gb);
  85     if (version != 1) {
  86         av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
  87         return AVERROR_INVALIDDATA;
  88     }
  89
  90     bytestream2_skip(&s->gb, 6);/* reserved */
  91
  92     s->channel_count = bytestream2_get_be16(&s->gb);
  93     if ((s->channel_count < 1) || (s->channel_count > 56)) {
  94         av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count);
  95         return AVERROR_INVALIDDATA;
  96     }
  97
  98     s->height = bytestream2_get_be32(&s->gb);
  99
 100     if ((s->height > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
 101         av_log(s->avctx, AV_LOG_ERROR,
 102                "Height > 30000 is experimental, add "
 103                "'-strict %d' if you want to try to decode the picture.\n",
 104                FF_COMPLIANCE_EXPERIMENTAL);
 105         return AVERROR_EXPERIMENTAL;
 106     }
 107
 108     s->width = bytestream2_get_be32(&s->gb);
 109     if ((s->width > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
 110         av_log(s->avctx, AV_LOG_ERROR,
 111                "Width > 30000 is experimental, add "
 112                "'-strict %d' if you want to try to decode the picture.\n",
 113                FF_COMPLIANCE_EXPERIMENTAL);
 114         return AVERROR_EXPERIMENTAL;
 115     }
 116
 117     if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
 118         return ret;
 119
 120     s->channel_depth = bytestream2_get_be16(&s->gb);
 121
 122     color_mode = bytestream2_get_be16(&s->gb);
 123     switch (color_mode) {
 124     case 0:
 125         s->color_mode = PSD_BITMAP;
 126         break;
 127     case 1:
 128         s->color_mode = PSD_GRAYSCALE;
 129         break;
 130     case 2:
 131         s->color_mode = PSD_INDEXED;
 132         break;
 133     case 3:
 134         s->color_mode = PSD_RGB;
 135         break;
 136     case 4:
 137         s->color_mode = PSD_CMYK;
 138         break;
 139     case 7:
 140         s->color_mode = PSD_MULTICHANNEL;
 141         break;
 142     case 8:
 143         s->color_mode = PSD_DUOTONE;
 144         break;
 145     case 9:
 146         s->color_mode = PSD_LAB;
 147         break;
 148     default:
 149         av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode);
 150         return AVERROR_INVALIDDATA;
 151     }
 152
 153     /* color map data */
 154     len_section = bytestream2_get_be32(&s->gb);
 155     if (len_section < 0) {
 156         av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n");
 157         return AVERROR_INVALIDDATA;
 158     }
 159
 160     if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
 161         av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
 162         return AVERROR_INVALIDDATA;
 163     }
 164     if (len_section) {
 165         int i,j;
 166         memset(s->palette, 0xff, AVPALETTE_SIZE);
 167         for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
 168             for (i = 0; i < FFMIN(256, len_section / 3); i++)
 169                 s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
 170         len_section -= i * 3;
 171     }
 172     bytestream2_skip(&s->gb, len_section);
 173
 174     /* image ressources */
 175     len_section = bytestream2_get_be32(&s->gb);
 176     if (len_section < 0) {
 177         av_log(s->avctx, AV_LOG_ERROR, "Negative size for image ressources section.\n");
 178         return AVERROR_INVALIDDATA;
 179     }
 180
 181     if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
 182         av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
 183         return AVERROR_INVALIDDATA;
 184     }
 185     bytestream2_skip(&s->gb, len_section);
 186
 187     /* layers and masks */
 188     len_section = bytestream2_get_be32(&s->gb);
 189     if (len_section < 0) {
 190         av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n");
 191         return AVERROR_INVALIDDATA;
 192     }
 193
 194     if (bytestream2_get_bytes_left(&s->gb) < len_section) {
 195         av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
 196         return AVERROR_INVALIDDATA;
 197     }
 198     bytestream2_skip(&s->gb, len_section);
 199
 200     /* image section */
 201     if (bytestream2_get_bytes_left(&s->gb) < 2) {
 202         av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n");
 203         return AVERROR_INVALIDDATA;
 204     }
 205
 206     s->compression = bytestream2_get_be16(&s->gb);
 207     switch (s->compression) {
 208     case 0:
 209     case 1:
 210         break;
 211     case 2:
 212         avpriv_request_sample(s->avctx, "ZIP without predictor compression");
 213         return AVERROR_PATCHWELCOME;
 214         break;
 215     case 3:
 216         avpriv_request_sample(s->avctx, "ZIP with predictor compression");
 217         return AVERROR_PATCHWELCOME;
 218         break;
 219     default:
 220         av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
 221         return AVERROR_INVALIDDATA;
 222     }
 223
 224     return ret;
 225 }
 226
 227 static int decode_rle(PSDContext * s){
 228     unsigned int scanline_count;
 229     unsigned int sl, count;
 230     unsigned long target_index = 0;
 231     unsigned int p;
 232     int8_t rle_char;
 233     unsigned int repeat_count;
 234     uint8_t v;
 235
 236     scanline_count = s->height * s->channel_count;
 237
 238     /* scanline table */
 239     if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) {
 240         av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n");
 241         return AVERROR_INVALIDDATA;
 242     }
 243     bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
 244
 245     /* decode rle data scanline by scanline */
 246     for (sl = 0; sl < scanline_count; sl++) {
 247         count = 0;
 248
 249         while (count < s->line_size) {
 250             rle_char = bytestream2_get_byte(&s->gb);
 251
 252             if (rle_char <= 0) {/* byte repeat */
 253                 repeat_count = rle_char * -1;
 254
 255                 if (bytestream2_get_bytes_left(&s->gb) < 1) {
 256                     av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
 257                     return AVERROR_INVALIDDATA;
 258                 }
 259
 260                 if (target_index + repeat_count >= s->uncompressed_size) {
 261                     av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
 262                     return AVERROR_INVALIDDATA;
 263                 }
 264
 265                 v = bytestream2_get_byte(&s->gb);
 266                 for (p = 0; p <= repeat_count; p++) {
 267                     s->tmp[target_index++] = v;
 268                 }
 269                 count += repeat_count + 1;
 270             } else {
 271                 if (bytestream2_get_bytes_left(&s->gb) < rle_char) {
 272                     av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
 273                     return AVERROR_INVALIDDATA;
 274                 }
 275
 276                 if (target_index + rle_char >= s->uncompressed_size) {
 277                     av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
 278                     return AVERROR_INVALIDDATA;
 279                 }
 280
 281                 for (p = 0; p <= rle_char; p++) {
 282                     v = bytestream2_get_byte(&s->gb);
 283                     s->tmp[target_index++] = v;
 284                 }
 285                 count += rle_char + 1;
 286             }
 287         }
 288     }
 289
 290     return 0;
 291 }
 292
 293 static int decode_frame(AVCodecContext *avctx, void *data,
 294                         int *got_frame, AVPacket *avpkt)
 295 {
 296     int ret;
 297     uint8_t *ptr;
 298     const uint8_t *ptr_data;
 299     int index_out, c, y, x, p;
 300     uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
 301     uint8_t plane_number;
 302
 303     AVFrame *picture = data;
 304
 305     PSDContext *s = avctx->priv_data;
 306     s->avctx     = avctx;
 307     s->channel_count = 0;
 308     s->channel_depth = 0;
 309     s->tmp           = NULL;
 310     s->line_size     = 0;
 311
 312     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
 313
 314     if ((ret = decode_header(s)) < 0)
 315         return ret;
 316
 317     s->pixel_size = s->channel_depth >> 3;/* in byte */
 318     s->line_size = s->width * s->pixel_size;
 319
 320     switch (s->color_mode) {
 321     case PSD_BITMAP:
 322         if (s->channel_depth != 1 || s->channel_count != 1) {
 323             av_log(s->avctx, AV_LOG_ERROR,
 324                     "Invalid bitmap file (channel_depth %d, channel_count %d)\n",
 325                     s->channel_depth, s->channel_count);
 326             return AVERROR_INVALIDDATA;
 327         }
 328         s->line_size = s->width + 7 >> 3;
 329         avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
 330         break;
 331     case PSD_INDEXED:
 332         if (s->channel_depth != 8 || s->channel_count != 1) {
 333             av_log(s->avctx, AV_LOG_ERROR,
 334                    "Invalid indexed file (channel_depth %d, channel_count %d)\n",
 335                    s->channel_depth, s->channel_count);
 336             return AVERROR_INVALIDDATA;
 337         }
 338         avctx->pix_fmt = AV_PIX_FMT_PAL8;
 339         break;
 340     case PSD_RGB:
 341         if (s->channel_count == 3) {
 342             if (s->channel_depth == 8) {
 343                 avctx->pix_fmt = AV_PIX_FMT_GBRP;
 344             } else if (s->channel_depth == 16) {
 345                 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
 346             } else {
 347                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
 348                 return AVERROR_PATCHWELCOME;
 349             }
 350         } else if (s->channel_count == 4) {
 351             if (s->channel_depth == 8) {
 352                 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 353             } else if (s->channel_depth == 16) {
 354                 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
 355             } else {
 356                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
 357                 return AVERROR_PATCHWELCOME;
 358             }
 359         } else {
 360             avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
 361             return AVERROR_PATCHWELCOME;
 362         }
 363         break;
 364     case PSD_DUOTONE:
 365         av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
 366     case PSD_GRAYSCALE:
 367         if (s->channel_count == 1) {
 368             if (s->channel_depth == 8) {
 369                 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 370             } else if (s->channel_depth == 16) {
 371                 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 372             } else if (s->channel_depth == 32) {
 373                 avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
 374             } else {
 375                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
 376                 return AVERROR_PATCHWELCOME;
 377             }
 378         } else if (s->channel_count == 2) {
 379             if (s->channel_depth == 8) {
 380                 avctx->pix_fmt = AV_PIX_FMT_YA8;
 381             } else if (s->channel_depth == 16) {
 382                 avctx->pix_fmt = AV_PIX_FMT_YA16BE;
 383             } else {
 384                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
 385                 return AVERROR_PATCHWELCOME;
 386             }
 387         } else {
 388             avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
 389             return AVERROR_PATCHWELCOME;
 390         }
 391         break;
 392     default:
 393         avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
 394         return AVERROR_PATCHWELCOME;
 395     }
 396
 397     s->uncompressed_size = s->line_size * s->height * s->channel_count;
 398
 399     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
 400         return ret;
 401
 402     /* decode picture if need */
 403     if (s->compression == PSD_RLE) {
 404         s->tmp = av_malloc(s->uncompressed_size);
 405         if (!s->tmp)
 406             return AVERROR(ENOMEM);
 407
 408         ret = decode_rle(s);
 409
 410         if (ret < 0) {
 411             av_freep(&s->tmp);
 412             return ret;
 413         }
 414
 415         ptr_data = s->tmp;
 416     } else {
 417         if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
 418             av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
 419             return AVERROR_INVALIDDATA;
 420         }
 421         ptr_data = s->gb.buffer;
 422     }
 423
 424     /* Store data */
 425     if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
 426         ptr = picture->data[0];
 427         for (c = 0; c < s->channel_count; c++) {
 428             for (y = 0; y < s->height; y++) {
 429                 for (x = 0; x < s->width; x++) {
 430                     index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
 431                     for (p = 0; p < s->pixel_size; p++) {
 432                         ptr[index_out + p] = *ptr_data;
 433                         ptr_data ++;
 434                     }
 435                 }
 436             }
 437         }
 438     } else {/* Planar */
 439         if (s->channel_count == 1)/* gray 8 or gray 16be */
 440             eq_channel[0] = 0;/* assign first channel, to first plane */
 441
 442         for (c = 0; c < s->channel_count; c++) {
 443             plane_number = eq_channel[c];
 444             ptr = picture->data[plane_number];/* get the right plane */
 445             for (y = 0; y < s->height; y++) {
 446                 memcpy(ptr, ptr_data, s->line_size);
 447                 ptr += picture->linesize[plane_number];
 448                 ptr_data += s->line_size;
 449             }
 450         }
 451     }
 452
 453     if (s->color_mode == PSD_INDEXED) {
 454         picture->palette_has_changed = 1;
 455         memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
 456     }
 457
 458     av_freep(&s->tmp);
 459
 460     picture->pict_type = AV_PICTURE_TYPE_I;
 461     *got_frame = 1;
 462
 463     return avpkt->size;
 464 }
 465
 466 AVCodec ff_psd_decoder = {
 467     .name             = "psd",
 468     .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
 469     .type             = AVMEDIA_TYPE_VIDEO,
 470     .id               = AV_CODEC_ID_PSD,
 471     .priv_data_size   = sizeof(PSDContext),
 472     .decode           = decode_frame,
 473     .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
 474 };