avcodec/jpeg2000dec: Fix h/vden typo
[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
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 {
373                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
374                 return AVERROR_PATCHWELCOME;
375             }
376         } else if (s->channel_count == 2) {
377             if (s->channel_depth == 8) {
378                 avctx->pix_fmt = AV_PIX_FMT_YA8;
379             } else if (s->channel_depth == 16) {
380                 avctx->pix_fmt = AV_PIX_FMT_YA16BE;
381             } else {
382                 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
383                 return AVERROR_PATCHWELCOME;
384             }
385         } else {
386             avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
387             return AVERROR_PATCHWELCOME;
388         }
389         break;
390     default:
391         avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
392         return AVERROR_PATCHWELCOME;
393     }
394
395     s->uncompressed_size = s->line_size * s->height * s->channel_count;
396
397     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
398         return ret;
399
400     /* decode picture if need */
401     if (s->compression == PSD_RLE) {
402         s->tmp = av_malloc(s->uncompressed_size);
403         if (!s->tmp)
404             return AVERROR(ENOMEM);
405
406         ret = decode_rle(s);
407
408         if (ret < 0) {
409             av_freep(&s->tmp);
410             return ret;
411         }
412
413         ptr_data = s->tmp;
414     } else {
415         if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
416             av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
417             return AVERROR_INVALIDDATA;
418         }
419         ptr_data = s->gb.buffer;
420     }
421
422     /* Store data */
423     if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
424         ptr = picture->data[0];
425         for (c = 0; c < s->channel_count; c++) {
426             for (y = 0; y < s->height; y++) {
427                 for (x = 0; x < s->width; x++) {
428                     index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
429                     for (p = 0; p < s->pixel_size; p++) {
430                         ptr[index_out + p] = *ptr_data;
431                         ptr_data ++;
432                     }
433                 }
434             }
435         }
436     } else {/* Planar */
437         if (s->channel_count == 1)/* gray 8 or gray 16be */
438             eq_channel[0] = 0;/* assign first channel, to first plane */
439
440         for (c = 0; c < s->channel_count; c++) {
441             plane_number = eq_channel[c];
442             ptr = picture->data[plane_number];/* get the right plane */
443             for (y = 0; y < s->height; y++) {
444                 memcpy(ptr, ptr_data, s->line_size);
445                 ptr += picture->linesize[plane_number];
446                 ptr_data += s->line_size;
447             }
448         }
449     }
450
451     if (s->color_mode == PSD_INDEXED) {
452         picture->palette_has_changed = 1;
453         memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
454     }
455
456     av_freep(&s->tmp);
457
458     picture->pict_type = AV_PICTURE_TYPE_I;
459     *got_frame = 1;
460
461     return avpkt->size;
462 }
463
464 AVCodec ff_psd_decoder = {
465     .name             = "psd",
466     .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
467     .type             = AVMEDIA_TYPE_VIDEO,
468     .id               = AV_CODEC_ID_PSD,
469     .priv_data_size   = sizeof(PSDContext),
470     .decode           = decode_frame,
471     .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
472 };