lavc/psd: Support indexed files.
[ffmpeg.git] / 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     s->uncompressed_size = s->line_size * s->height * s->channel_count;
320
321     switch (s->color_mode) {
322     case PSD_INDEXED:
323         if (s->channel_depth != 8 || s->channel_count != 1) {
324             av_log(s->avctx, AV_LOG_ERROR,
325                    "Invalid indexed file (channel_depth %d, channel_count %d)\n",
326                    s->channel_depth, s->channel_count);
327             return AVERROR_INVALIDDATA;
328         }
329         avctx->pix_fmt = AV_PIX_FMT_PAL8;
330         break;
331     case PSD_RGB:
332         if (s->channel_count == 3) {
333             if (s->channel_depth == 8) {
334                 avctx->pix_fmt = AV_PIX_FMT_GBRP;
335             } else if (s->channel_depth == 16) {
336                 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
337             } else {
338                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
339                 return AVERROR_PATCHWELCOME;
340             }
341         } else if (s->channel_count == 4) {
342             if (s->channel_depth == 8) {
343                 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
344             } else if (s->channel_depth == 16) {
345                 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
346             } else {
347                 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
348                 return AVERROR_PATCHWELCOME;
349             }
350         } else {
351             avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
352             return AVERROR_PATCHWELCOME;
353         }
354         break;
355     case PSD_GRAYSCALE:
356         if (s->channel_count == 1) {
357             if (s->channel_depth == 8) {
358                 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
359             } else if (s->channel_depth == 16) {
360                 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
361             } else {
362                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
363                 return AVERROR_PATCHWELCOME;
364             }
365         } else if (s->channel_count == 2) {
366             if (s->channel_depth == 8) {
367                 avctx->pix_fmt = AV_PIX_FMT_YA8;
368             } else if (s->channel_depth == 16) {
369                 avctx->pix_fmt = AV_PIX_FMT_YA16BE;
370             } else {
371                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
372                 return AVERROR_PATCHWELCOME;
373             }
374         } else {
375             avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
376             return AVERROR_PATCHWELCOME;
377         }
378         break;
379     default:
380         avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
381         return AVERROR_PATCHWELCOME;
382     }
383
384     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
385         return ret;
386
387     /* decode picture if need */
388     if (s->compression == PSD_RLE) {
389         s->tmp = av_malloc(s->uncompressed_size);
390         if (!s->tmp)
391             return AVERROR(ENOMEM);
392
393         ret = decode_rle(s);
394
395         if (ret < 0) {
396             av_freep(&s->tmp);
397             return ret;
398         }
399
400         ptr_data = s->tmp;
401     } else {
402         if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
403             av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
404             return AVERROR_INVALIDDATA;
405         }
406         ptr_data = s->gb.buffer;
407     }
408
409     /* Store data */
410     if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
411         ptr = picture->data[0];
412         for (c = 0; c < s->channel_count; c++) {
413             for (y = 0; y < s->height; y++) {
414                 for (x = 0; x < s->width; x++) {
415                     index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
416                     for (p = 0; p < s->pixel_size; p++) {
417                         ptr[index_out + p] = *ptr_data;
418                         ptr_data ++;
419                     }
420                 }
421             }
422         }
423     } else {/* Planar */
424         if (s->channel_count == 1)/* gray 8 or gray 16be */
425             eq_channel[0] = 0;/* assign first channel, to first plane */
426
427         for (c = 0; c < s->channel_count; c++) {
428             plane_number = eq_channel[c];
429             ptr = picture->data[plane_number];/* get the right plane */
430             for (y = 0; y < s->height; y++) {
431                 memcpy(ptr, ptr_data, s->width * s->pixel_size);
432                 ptr += picture->linesize[plane_number];
433                 ptr_data += s->width * s->pixel_size;
434             }
435         }
436     }
437
438     if (s->color_mode == PSD_INDEXED) {
439         picture->palette_has_changed = 1;
440         memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
441     }
442
443     av_freep(&s->tmp);
444
445     picture->pict_type = AV_PICTURE_TYPE_I;
446     *got_frame = 1;
447
448     return avpkt->size;
449 }
450
451 AVCodec ff_psd_decoder = {
452     .name             = "psd",
453     .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
454     .type             = AVMEDIA_TYPE_VIDEO,
455     .id               = AV_CODEC_ID_PSD,
456     .priv_data_size   = sizeof(PSDContext),
457     .decode           = decode_frame,
458     .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
459 };