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 "codec_internal.h" 24#include "internal.h" 25 26enum PsdCompr { 27 PSD_RAW, 28 PSD_RLE, 29 PSD_ZIP_WITHOUT_P, 30 PSD_ZIP_WITH_P, 31}; 32 33enum PsdColorMode { 34 PSD_BITMAP, 35 PSD_GRAYSCALE, 36 PSD_INDEXED, 37 PSD_RGB, 38 PSD_CMYK, 39 PSD_MULTICHANNEL, 40 PSD_DUOTONE, 41 PSD_LAB, 42}; 43 44typedef struct PSDContext { 45 AVClass *class; 46 AVFrame *picture; 47 AVCodecContext *avctx; 48 GetByteContext gb; 49 50 uint8_t * tmp; 51 52 uint16_t channel_count; 53 uint16_t channel_depth; 54 55 uint64_t uncompressed_size; 56 unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */ 57 uint64_t line_size;/* length of src data (even width) */ 58 59 int width; 60 int height; 61 62 enum PsdCompr compression; 63 enum PsdColorMode color_mode; 64 65 uint8_t palette[AVPALETTE_SIZE]; 66} PSDContext; 67 68static int decode_header(PSDContext * s) 69{ 70 int signature, version, color_mode; 71 int64_t len_section; 72 int ret = 0; 73 74 if (bytestream2_get_bytes_left(&s->gb) < 30) {/* File header section + color map data section length */ 75 av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n"); 76 return AVERROR_INVALIDDATA; 77 } 78 79 signature = bytestream2_get_le32(&s->gb); 80 if (signature != MKTAG('8','B','P','S')) { 81 av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature); 82 return AVERROR_INVALIDDATA; 83 } 84 85 version = bytestream2_get_be16(&s->gb); 86 if (version != 1) { 87 av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version); 88 return AVERROR_INVALIDDATA; 89 } 90 91 bytestream2_skip(&s->gb, 6);/* reserved */ 92 93 s->channel_count = bytestream2_get_be16(&s->gb); 94 if ((s->channel_count < 1) || (s->channel_count > 56)) { 95 av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count); 96 return AVERROR_INVALIDDATA; 97 } 98 99 s->height = bytestream2_get_be32(&s->gb); 100 101 if ((s->height > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) { 102 av_log(s->avctx, AV_LOG_ERROR, 103 "Height > 30000 is experimental, add " 104 "'-strict %d' if you want to try to decode the picture.\n", 105 FF_COMPLIANCE_EXPERIMENTAL); 106 return AVERROR_EXPERIMENTAL; 107 } 108 109 s->width = bytestream2_get_be32(&s->gb); 110 if ((s->width > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) { 111 av_log(s->avctx, AV_LOG_ERROR, 112 "Width > 30000 is experimental, add " 113 "'-strict %d' if you want to try to decode the picture.\n", 114 FF_COMPLIANCE_EXPERIMENTAL); 115 return AVERROR_EXPERIMENTAL; 116 } 117 118 if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0) 119 return ret; 120 121 s->channel_depth = bytestream2_get_be16(&s->gb); 122 123 color_mode = bytestream2_get_be16(&s->gb); 124 switch (color_mode) { 125 case 0: 126 s->color_mode = PSD_BITMAP; 127 break; 128 case 1: 129 s->color_mode = PSD_GRAYSCALE; 130 break; 131 case 2: 132 s->color_mode = PSD_INDEXED; 133 break; 134 case 3: 135 s->color_mode = PSD_RGB; 136 break; 137 case 4: 138 s->color_mode = PSD_CMYK; 139 break; 140 case 7: 141 s->color_mode = PSD_MULTICHANNEL; 142 break; 143 case 8: 144 s->color_mode = PSD_DUOTONE; 145 break; 146 case 9: 147 s->color_mode = PSD_LAB; 148 break; 149 default: 150 av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode); 151 return AVERROR_INVALIDDATA; 152 } 153 154 /* color map data */ 155 len_section = bytestream2_get_be32(&s->gb); 156 if (len_section < 0) { 157 av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n"); 158 return AVERROR_INVALIDDATA; 159 } 160 161 if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */ 162 av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n"); 163 return AVERROR_INVALIDDATA; 164 } 165 if (len_section) { 166 int i,j; 167 memset(s->palette, 0xff, AVPALETTE_SIZE); 168 for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++) 169 for (i = 0; i < FFMIN(256, len_section / 3); i++) 170 s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb); 171 len_section -= i * 3; 172 } 173 bytestream2_skip(&s->gb, len_section); 174 175 /* image ressources */ 176 len_section = bytestream2_get_be32(&s->gb); 177 if (len_section < 0) { 178 av_log(s->avctx, AV_LOG_ERROR, "Negative size for image ressources section.\n"); 179 return AVERROR_INVALIDDATA; 180 } 181 182 if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */ 183 av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n"); 184 return AVERROR_INVALIDDATA; 185 } 186 bytestream2_skip(&s->gb, len_section); 187 188 /* layers and masks */ 189 len_section = bytestream2_get_be32(&s->gb); 190 if (len_section < 0) { 191 av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n"); 192 return AVERROR_INVALIDDATA; 193 } 194 195 if (bytestream2_get_bytes_left(&s->gb) < len_section) { 196 av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n"); 197 return AVERROR_INVALIDDATA; 198 } 199 bytestream2_skip(&s->gb, len_section); 200 201 /* image section */ 202 if (bytestream2_get_bytes_left(&s->gb) < 2) { 203 av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n"); 204 return AVERROR_INVALIDDATA; 205 } 206 207 s->compression = bytestream2_get_be16(&s->gb); 208 switch (s->compression) { 209 case 0: 210 case 1: 211 break; 212 case 2: 213 avpriv_request_sample(s->avctx, "ZIP without predictor compression"); 214 return AVERROR_PATCHWELCOME; 215 case 3: 216 avpriv_request_sample(s->avctx, "ZIP with predictor compression"); 217 return AVERROR_PATCHWELCOME; 218 default: 219 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression); 220 return AVERROR_INVALIDDATA; 221 } 222 223 return ret; 224} 225 226static int decode_rle(PSDContext * s){ 227 unsigned int scanline_count; 228 unsigned int sl, count; 229 unsigned long target_index = 0; 230 unsigned int p; 231 int8_t rle_char; 232 unsigned int repeat_count; 233 uint8_t v; 234 235 scanline_count = s->height * s->channel_count; 236 237 /* scanline table */ 238 if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) { 239 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n"); 240 return AVERROR_INVALIDDATA; 241 } 242 bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */ 243 244 /* decode rle data scanline by scanline */ 245 for (sl = 0; sl < scanline_count; sl++) { 246 count = 0; 247 248 while (count < s->line_size) { 249 rle_char = bytestream2_get_byte(&s->gb); 250 251 if (rle_char <= 0) {/* byte repeat */ 252 repeat_count = rle_char * -1; 253 254 if (bytestream2_get_bytes_left(&s->gb) < 1) { 255 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n"); 256 return AVERROR_INVALIDDATA; 257 } 258 259 if (target_index + repeat_count >= s->uncompressed_size) { 260 av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n"); 261 return AVERROR_INVALIDDATA; 262 } 263 264 v = bytestream2_get_byte(&s->gb); 265 for (p = 0; p <= repeat_count; p++) { 266 s->tmp[target_index++] = v; 267 } 268 count += repeat_count + 1; 269 } else { 270 if (bytestream2_get_bytes_left(&s->gb) < rle_char) { 271 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n"); 272 return AVERROR_INVALIDDATA; 273 } 274 275 if (target_index + rle_char >= s->uncompressed_size) { 276 av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n"); 277 return AVERROR_INVALIDDATA; 278 } 279 280 for (p = 0; p <= rle_char; p++) { 281 v = bytestream2_get_byte(&s->gb); 282 s->tmp[target_index++] = v; 283 } 284 count += rle_char + 1; 285 } 286 } 287 } 288 289 return 0; 290} 291 292static int decode_frame(AVCodecContext *avctx, AVFrame *picture, 293 int *got_frame, AVPacket *avpkt) 294{ 295 int ret; 296 uint8_t *ptr; 297 const uint8_t *ptr_data; 298 int index_out, c, y, x, p; 299 uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */ 300 uint8_t plane_number; 301 302 PSDContext *s = avctx->priv_data; 303 s->avctx = avctx; 304 s->channel_count = 0; 305 s->channel_depth = 0; 306 s->tmp = NULL; 307 s->line_size = 0; 308 309 bytestream2_init(&s->gb, avpkt->data, avpkt->size); 310 311 if ((ret = decode_header(s)) < 0) 312 return ret; 313 314 s->pixel_size = s->channel_depth >> 3;/* in byte */ 315 s->line_size = s->width * s->pixel_size; 316 317 switch (s->color_mode) { 318 case PSD_BITMAP: 319 if (s->channel_depth != 1 || s->channel_count != 1) { 320 av_log(s->avctx, AV_LOG_ERROR, 321 "Invalid bitmap file (channel_depth %d, channel_count %d)\n", 322 s->channel_depth, s->channel_count); 323 return AVERROR_INVALIDDATA; 324 } 325 s->line_size = s->width + 7 >> 3; 326 avctx->pix_fmt = AV_PIX_FMT_MONOWHITE; 327 break; 328 case PSD_INDEXED: 329 if (s->channel_depth != 8 || s->channel_count != 1) { 330 av_log(s->avctx, AV_LOG_ERROR, 331 "Invalid indexed file (channel_depth %d, channel_count %d)\n", 332 s->channel_depth, s->channel_count); 333 return AVERROR_INVALIDDATA; 334 } 335 avctx->pix_fmt = AV_PIX_FMT_PAL8; 336 break; 337 case PSD_CMYK: 338 if (s->channel_count == 4) { 339 if (s->channel_depth == 8) { 340 avctx->pix_fmt = AV_PIX_FMT_GBRP; 341 } else if (s->channel_depth == 16) { 342 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE; 343 } else { 344 avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth); 345 return AVERROR_PATCHWELCOME; 346 } 347 } else if (s->channel_count == 5) { 348 if (s->channel_depth == 8) { 349 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 350 } else if (s->channel_depth == 16) { 351 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE; 352 } else { 353 avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth); 354 return AVERROR_PATCHWELCOME; 355 } 356 } else { 357 avpriv_report_missing_feature(avctx, "channel count %d for cmyk", s->channel_count); 358 return AVERROR_PATCHWELCOME; 359 } 360 break; 361 case PSD_RGB: 362 if (s->channel_count == 3) { 363 if (s->channel_depth == 8) { 364 avctx->pix_fmt = AV_PIX_FMT_GBRP; 365 } else if (s->channel_depth == 16) { 366 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE; 367 } else { 368 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth); 369 return AVERROR_PATCHWELCOME; 370 } 371 } else if (s->channel_count == 4) { 372 if (s->channel_depth == 8) { 373 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 374 } else if (s->channel_depth == 16) { 375 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE; 376 } else { 377 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth); 378 return AVERROR_PATCHWELCOME; 379 } 380 } else { 381 avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count); 382 return AVERROR_PATCHWELCOME; 383 } 384 break; 385 case PSD_DUOTONE: 386 av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n"); 387 case PSD_GRAYSCALE: 388 if (s->channel_count == 1) { 389 if (s->channel_depth == 8) { 390 avctx->pix_fmt = AV_PIX_FMT_GRAY8; 391 } else if (s->channel_depth == 16) { 392 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE; 393 } else if (s->channel_depth == 32) { 394 avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE; 395 } else { 396 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth); 397 return AVERROR_PATCHWELCOME; 398 } 399 } else if (s->channel_count == 2) { 400 if (s->channel_depth == 8) { 401 avctx->pix_fmt = AV_PIX_FMT_YA8; 402 } else if (s->channel_depth == 16) { 403 avctx->pix_fmt = AV_PIX_FMT_YA16BE; 404 } else { 405 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth); 406 return AVERROR_PATCHWELCOME; 407 } 408 } else { 409 avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count); 410 return AVERROR_PATCHWELCOME; 411 } 412 break; 413 default: 414 avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode); 415 return AVERROR_PATCHWELCOME; 416 } 417 418 s->uncompressed_size = s->line_size * s->height * s->channel_count; 419 420 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) 421 return ret; 422 423 /* decode picture if need */ 424 if (s->compression == PSD_RLE) { 425 s->tmp = av_malloc(s->uncompressed_size); 426 if (!s->tmp) 427 return AVERROR(ENOMEM); 428 429 ret = decode_rle(s); 430 431 if (ret < 0) { 432 av_freep(&s->tmp); 433 return ret; 434 } 435 436 ptr_data = s->tmp; 437 } else { 438 if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) { 439 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n"); 440 return AVERROR_INVALIDDATA; 441 } 442 ptr_data = s->gb.buffer; 443 } 444 445 /* Store data */ 446 if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */ 447 ptr = picture->data[0]; 448 for (c = 0; c < s->channel_count; c++) { 449 for (y = 0; y < s->height; y++) { 450 for (x = 0; x < s->width; x++) { 451 index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size; 452 for (p = 0; p < s->pixel_size; p++) { 453 ptr[index_out + p] = *ptr_data; 454 ptr_data ++; 455 } 456 } 457 } 458 } 459 } else if (s->color_mode == PSD_CMYK) { 460 uint8_t *dst[4] = { picture->data[0], picture->data[1], picture->data[2], picture->data[3] }; 461 const uint8_t *src[5] = { ptr_data }; 462 src[1] = src[0] + s->line_size * s->height; 463 src[2] = src[1] + s->line_size * s->height; 464 src[3] = src[2] + s->line_size * s->height; 465 src[4] = src[3] + s->line_size * s->height; 466 if (s->channel_depth == 8) { 467 for (y = 0; y < s->height; y++) { 468 for (x = 0; x < s->width; x++) { 469 int k = src[3][x]; 470 int r = src[0][x] * k; 471 int g = src[1][x] * k; 472 int b = src[2][x] * k; 473 dst[0][x] = g * 257 >> 16; 474 dst[1][x] = b * 257 >> 16; 475 dst[2][x] = r * 257 >> 16; 476 } 477 dst[0] += picture->linesize[0]; 478 dst[1] += picture->linesize[1]; 479 dst[2] += picture->linesize[2]; 480 src[0] += s->line_size; 481 src[1] += s->line_size; 482 src[2] += s->line_size; 483 src[3] += s->line_size; 484 } 485 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) { 486 for (y = 0; y < s->height; y++) { 487 memcpy(dst[3], src[4], s->line_size); 488 src[4] += s->line_size; 489 dst[3] += picture->linesize[3]; 490 } 491 } 492 } else { 493 for (y = 0; y < s->height; y++) { 494 for (x = 0; x < s->width; x++) { 495 int64_t k = AV_RB16(&src[3][x * 2]); 496 int64_t r = AV_RB16(&src[0][x * 2]) * k; 497 int64_t g = AV_RB16(&src[1][x * 2]) * k; 498 int64_t b = AV_RB16(&src[2][x * 2]) * k; 499 AV_WB16(&dst[0][x * 2], g * 65537 >> 32); 500 AV_WB16(&dst[1][x * 2], b * 65537 >> 32); 501 AV_WB16(&dst[2][x * 2], r * 65537 >> 32); 502 } 503 dst[0] += picture->linesize[0]; 504 dst[1] += picture->linesize[1]; 505 dst[2] += picture->linesize[2]; 506 src[0] += s->line_size; 507 src[1] += s->line_size; 508 src[2] += s->line_size; 509 src[3] += s->line_size; 510 } 511 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) { 512 for (y = 0; y < s->height; y++) { 513 memcpy(dst[3], src[4], s->line_size); 514 src[4] += s->line_size; 515 dst[3] += picture->linesize[3]; 516 } 517 } 518 } 519 } else {/* Planar */ 520 if (s->channel_count == 1)/* gray 8 or gray 16be */ 521 eq_channel[0] = 0;/* assign first channel, to first plane */ 522 523 for (c = 0; c < s->channel_count; c++) { 524 plane_number = eq_channel[c]; 525 ptr = picture->data[plane_number];/* get the right plane */ 526 for (y = 0; y < s->height; y++) { 527 memcpy(ptr, ptr_data, s->line_size); 528 ptr += picture->linesize[plane_number]; 529 ptr_data += s->line_size; 530 } 531 } 532 } 533 534 if (s->color_mode == PSD_INDEXED) { 535 picture->palette_has_changed = 1; 536 memcpy(picture->data[1], s->palette, AVPALETTE_SIZE); 537 } 538 539 av_freep(&s->tmp); 540 541 picture->pict_type = AV_PICTURE_TYPE_I; 542 *got_frame = 1; 543 544 return avpkt->size; 545} 546 547const FFCodec ff_psd_decoder = { 548 .p.name = "psd", 549 .p.long_name = NULL_IF_CONFIG_SMALL("Photoshop PSD file"), 550 .p.type = AVMEDIA_TYPE_VIDEO, 551 .p.id = AV_CODEC_ID_PSD, 552 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, 553 .priv_data_size = sizeof(PSDContext), 554 FF_CODEC_DECODE_CB(decode_frame), 555}; 556