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_CMYK:
 341         if (s->channel_count == 4) {
 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 cmyk", s->channel_depth);
 348                 return AVERROR_PATCHWELCOME;
 349             }
 350         } else if (s->channel_count == 5) {
 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 cmyk", s->channel_depth);
 357                 return AVERROR_PATCHWELCOME;
 358             }
 359         } else {
 360             avpriv_report_missing_feature(avctx, "channel count %d for cmyk", s->channel_count);
 361             return AVERROR_PATCHWELCOME;
 362         }
 363         break;
 364     case PSD_RGB:
 365         if (s->channel_count == 3) {
 366             if (s->channel_depth == 8) {
 367                 avctx->pix_fmt = AV_PIX_FMT_GBRP;
 368             } else if (s->channel_depth == 16) {
 369                 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
 370             } else {
 371                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
 372                 return AVERROR_PATCHWELCOME;
 373             }
 374         } else if (s->channel_count == 4) {
 375             if (s->channel_depth == 8) {
 376                 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 377             } else if (s->channel_depth == 16) {
 378                 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
 379             } else {
 380                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
 381                 return AVERROR_PATCHWELCOME;
 382             }
 383         } else {
 384             avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
 385             return AVERROR_PATCHWELCOME;
 386         }
 387         break;
 388     case PSD_DUOTONE:
 389         av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
 390     case PSD_GRAYSCALE:
 391         if (s->channel_count == 1) {
 392             if (s->channel_depth == 8) {
 393                 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 394             } else if (s->channel_depth == 16) {
 395                 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 396             } else if (s->channel_depth == 32) {
 397                 avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
 398             } else {
 399                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
 400                 return AVERROR_PATCHWELCOME;
 401             }
 402         } else if (s->channel_count == 2) {
 403             if (s->channel_depth == 8) {
 404                 avctx->pix_fmt = AV_PIX_FMT_YA8;
 405             } else if (s->channel_depth == 16) {
 406                 avctx->pix_fmt = AV_PIX_FMT_YA16BE;
 407             } else {
 408                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
 409                 return AVERROR_PATCHWELCOME;
 410             }
 411         } else {
 412             avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
 413             return AVERROR_PATCHWELCOME;
 414         }
 415         break;
 416     default:
 417         avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
 418         return AVERROR_PATCHWELCOME;
 419     }
 420
 421     s->uncompressed_size = s->line_size * s->height * s->channel_count;
 422
 423     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
 424         return ret;
 425
 426     /* decode picture if need */
 427     if (s->compression == PSD_RLE) {
 428         s->tmp = av_malloc(s->uncompressed_size);
 429         if (!s->tmp)
 430             return AVERROR(ENOMEM);
 431
 432         ret = decode_rle(s);
 433
 434         if (ret < 0) {
 435             av_freep(&s->tmp);
 436             return ret;
 437         }
 438
 439         ptr_data = s->tmp;
 440     } else {
 441         if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
 442             av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
 443             return AVERROR_INVALIDDATA;
 444         }
 445         ptr_data = s->gb.buffer;
 446     }
 447
 448     /* Store data */
 449     if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
 450         ptr = picture->data[0];
 451         for (c = 0; c < s->channel_count; c++) {
 452             for (y = 0; y < s->height; y++) {
 453                 for (x = 0; x < s->width; x++) {
 454                     index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
 455                     for (p = 0; p < s->pixel_size; p++) {
 456                         ptr[index_out + p] = *ptr_data;
 457                         ptr_data ++;
 458                     }
 459                 }
 460             }
 461         }
 462     } else if (s->color_mode == PSD_CMYK) {
 463         uint8_t *dst[4] = { picture->data[0], picture->data[1], picture->data[2], picture->data[3] };
 464         const uint8_t *src[5] = { ptr_data };
 465         src[1] = src[0] + s->line_size * s->height;
 466         src[2] = src[1] + s->line_size * s->height;
 467         src[3] = src[2] + s->line_size * s->height;
 468         src[4] = src[3] + s->line_size * s->height;
 469         if (s->channel_depth == 8) {
 470             for (y = 0; y < s->height; y++) {
 471                 for (x = 0; x < s->width; x++) {
 472                     int k = src[3][x];
 473                     int r = src[0][x] * k;
 474                     int g = src[1][x] * k;
 475                     int b = src[2][x] * k;
 476                     dst[0][x] = g * 257 >> 16;
 477                     dst[1][x] = b * 257 >> 16;
 478                     dst[2][x] = r * 257 >> 16;
 479                 }
 480                 dst[0] += picture->linesize[0];
 481                 dst[1] += picture->linesize[1];
 482                 dst[2] += picture->linesize[2];
 483                 src[0] += s->line_size;
 484                 src[1] += s->line_size;
 485                 src[2] += s->line_size;
 486                 src[3] += s->line_size;
 487             }
 488             if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
 489                 for (y = 0; y < s->height; y++) {
 490                     memcpy(dst[3], src[4], s->line_size);
 491                     src[4] += s->line_size;
 492                     dst[3] += picture->linesize[3];
 493                 }
 494             }
 495         } else {
 496             for (y = 0; y < s->height; y++) {
 497                 for (x = 0; x < s->width; x++) {
 498                     int64_t k = AV_RB16(&src[3][x * 2]);
 499                     int64_t r = AV_RB16(&src[0][x * 2]) * k;
 500                     int64_t g = AV_RB16(&src[1][x * 2]) * k;
 501                     int64_t b = AV_RB16(&src[2][x * 2]) * k;
 502                     AV_WB16(&dst[0][x * 2], g * 65537 >> 32);
 503                     AV_WB16(&dst[1][x * 2], b * 65537 >> 32);
 504                     AV_WB16(&dst[2][x * 2], r * 65537 >> 32);
 505                 }
 506                 dst[0] += picture->linesize[0];
 507                 dst[1] += picture->linesize[1];
 508                 dst[2] += picture->linesize[2];
 509                 src[0] += s->line_size;
 510                 src[1] += s->line_size;
 511                 src[2] += s->line_size;
 512                 src[3] += s->line_size;
 513             }
 514             if (avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) {
 515                 for (y = 0; y < s->height; y++) {
 516                     memcpy(dst[3], src[4], s->line_size);
 517                     src[4] += s->line_size;
 518                     dst[3] += picture->linesize[3];
 519                 }
 520             }
 521         }
 522     } else {/* Planar */
 523         if (s->channel_count == 1)/* gray 8 or gray 16be */
 524             eq_channel[0] = 0;/* assign first channel, to first plane */
 525
 526         for (c = 0; c < s->channel_count; c++) {
 527             plane_number = eq_channel[c];
 528             ptr = picture->data[plane_number];/* get the right plane */
 529             for (y = 0; y < s->height; y++) {
 530                 memcpy(ptr, ptr_data, s->line_size);
 531                 ptr += picture->linesize[plane_number];
 532                 ptr_data += s->line_size;
 533             }
 534         }
 535     }
 536
 537     if (s->color_mode == PSD_INDEXED) {
 538         picture->palette_has_changed = 1;
 539         memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
 540     }
 541
 542     av_freep(&s->tmp);
 543
 544     picture->pict_type = AV_PICTURE_TYPE_I;
 545     *got_frame = 1;
 546
 547     return avpkt->size;
 548 }
 549
 550 AVCodec ff_psd_decoder = {
 551     .name             = "psd",
 552     .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
 553     .type             = AVMEDIA_TYPE_VIDEO,
 554     .id               = AV_CODEC_ID_PSD,
 555     .priv_data_size   = sizeof(PSDContext),
 556     .decode           = decode_frame,
 557     .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
 558 };