FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/psd.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 166 321 51.7%
Branches: 99 180 55.0%

Line Branch Exec Source
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 30 static int decode_header(PSDContext * s)
68 {
69 int signature, version, color_mode;
70 int64_t len_section;
71 30 int ret = 0;
72
73
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 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 30 signature = bytestream2_get_le32(&s->gb);
79
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
30 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 30 version = bytestream2_get_be16(&s->gb);
85
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
30 if (version != 1) {
86 av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
87 return AVERROR_INVALIDDATA;
88 }
89
90 30 bytestream2_skip(&s->gb, 6);/* reserved */
91
92 30 s->channel_count = bytestream2_get_be16(&s->gb);
93
2/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 30 times.
30 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 30 s->height = bytestream2_get_be32(&s->gb);
99
100
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
30 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 30 s->width = bytestream2_get_be32(&s->gb);
109
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
30 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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
118 return ret;
119
120 30 s->channel_depth = bytestream2_get_be16(&s->gb);
121
122 30 color_mode = bytestream2_get_be16(&s->gb);
123
5/9
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 16 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
30 switch (color_mode) {
124 2 case 0:
125 2 s->color_mode = PSD_BITMAP;
126 2 break;
127 8 case 1:
128 8 s->color_mode = PSD_GRAYSCALE;
129 8 break;
130 2 case 2:
131 2 s->color_mode = PSD_INDEXED;
132 2 break;
133 16 case 3:
134 16 s->color_mode = PSD_RGB;
135 16 break;
136 case 4:
137 s->color_mode = PSD_CMYK;
138 break;
139 case 7:
140 s->color_mode = PSD_MULTICHANNEL;
141 break;
142 2 case 8:
143 2 s->color_mode = PSD_DUOTONE;
144 2 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 30 len_section = bytestream2_get_be32(&s->gb);
155
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
30 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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 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
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 26 times.
30 if (len_section) {
165 int i,j;
166 4 memset(s->palette, 0xff, AVPALETTE_SIZE);
167
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
16 for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
168
4/4
✓ Branch 0 taken 1050 times.
✓ Branch 1 taken 1542 times.
✓ Branch 2 taken 2580 times.
✓ Branch 3 taken 12 times.
2592 for (i = 0; i < FFMIN(256, len_section / 3); i++)
169 2580 s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
170 4 len_section -= i * 3;
171 }
172 30 bytestream2_skip(&s->gb, len_section);
173
174 /* image ressources */
175 30 len_section = bytestream2_get_be32(&s->gb);
176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
30 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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 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 30 bytestream2_skip(&s->gb, len_section);
186
187 /* layers and masks */
188 30 len_section = bytestream2_get_be32(&s->gb);
189
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
30 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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 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 30 bytestream2_skip(&s->gb, len_section);
199
200 /* image section */
201
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 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 30 s->compression = bytestream2_get_be16(&s->gb);
207
1/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
30 switch (s->compression) {
208 30 case 0:
209 case 1:
210 30 break;
211 case 2:
212 avpriv_request_sample(s->avctx, "ZIP without predictor compression");
213 return AVERROR_PATCHWELCOME;
214 case 3:
215 avpriv_request_sample(s->avctx, "ZIP with predictor compression");
216 return AVERROR_PATCHWELCOME;
217 default:
218 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
219 return AVERROR_INVALIDDATA;
220 }
221
222 30 return ret;
223 }
224
225 8 static int decode_rle(PSDContext * s){
226 unsigned int scanline_count;
227 unsigned int sl, count;
228 8 unsigned long target_index = 0;
229 unsigned int p;
230 int8_t rle_char;
231 unsigned int repeat_count;
232 uint8_t v;
233
234 8 scanline_count = s->height * s->channel_count;
235
236 /* scanline table */
237
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
8 if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) {
238 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n");
239 return AVERROR_INVALIDDATA;
240 }
241 8 bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
242
243 /* decode rle data scanline by scanline */
244
2/2
✓ Branch 0 taken 2804 times.
✓ Branch 1 taken 8 times.
2812 for (sl = 0; sl < scanline_count; sl++) {
245 2804 count = 0;
246
247
2/2
✓ Branch 0 taken 18540 times.
✓ Branch 1 taken 2804 times.
21344 while (count < s->line_size) {
248 18540 rle_char = bytestream2_get_byte(&s->gb);
249
250
2/2
✓ Branch 0 taken 12340 times.
✓ Branch 1 taken 6200 times.
18540 if (rle_char <= 0) {/* byte repeat */
251 12340 repeat_count = rle_char * -1;
252
253
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12340 times.
12340 if (bytestream2_get_bytes_left(&s->gb) < 1) {
254 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
255 return AVERROR_INVALIDDATA;
256 }
257
258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12340 times.
12340 if (target_index + repeat_count >= s->uncompressed_size) {
259 av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
260 return AVERROR_INVALIDDATA;
261 }
262
263 12340 v = bytestream2_get_byte(&s->gb);
264
2/2
✓ Branch 0 taken 210352 times.
✓ Branch 1 taken 12340 times.
222692 for (p = 0; p <= repeat_count; p++) {
265 210352 s->tmp[target_index++] = v;
266 }
267 12340 count += repeat_count + 1;
268 } else {
269
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6200 times.
6200 if (bytestream2_get_bytes_left(&s->gb) < rle_char) {
270 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
271 return AVERROR_INVALIDDATA;
272 }
273
274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6200 times.
6200 if (target_index + rle_char >= s->uncompressed_size) {
275 av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
276 return AVERROR_INVALIDDATA;
277 }
278
279
2/2
✓ Branch 0 taken 243810 times.
✓ Branch 1 taken 6200 times.
250010 for (p = 0; p <= rle_char; p++) {
280 243810 v = bytestream2_get_byte(&s->gb);
281 243810 s->tmp[target_index++] = v;
282 }
283 6200 count += rle_char + 1;
284 }
285 }
286 }
287
288 8 return 0;
289 }
290
291 30 static int decode_frame(AVCodecContext *avctx, void *data,
292 int *got_frame, AVPacket *avpkt)
293 {
294 int ret;
295 uint8_t *ptr;
296 const uint8_t *ptr_data;
297 int index_out, c, y, x, p;
298 30 uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
299 uint8_t plane_number;
300
301 30 AVFrame *picture = data;
302
303 30 PSDContext *s = avctx->priv_data;
304 30 s->avctx = avctx;
305 30 s->channel_count = 0;
306 30 s->channel_depth = 0;
307 30 s->tmp = NULL;
308 30 s->line_size = 0;
309
310 30 bytestream2_init(&s->gb, avpkt->data, avpkt->size);
311
312
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 if ((ret = decode_header(s)) < 0)
313 return ret;
314
315 30 s->pixel_size = s->channel_depth >> 3;/* in byte */
316 30 s->line_size = s->width * s->pixel_size;
317
318
5/7
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 8 times.
✗ Branch 6 not taken.
30 switch (s->color_mode) {
319 2 case PSD_BITMAP:
320
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
2 if (s->channel_depth != 1 || s->channel_count != 1) {
321 av_log(s->avctx, AV_LOG_ERROR,
322 "Invalid bitmap file (channel_depth %d, channel_count %d)\n",
323 s->channel_depth, s->channel_count);
324 return AVERROR_INVALIDDATA;
325 }
326 2 s->line_size = s->width + 7 >> 3;
327 2 avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
328 2 break;
329 2 case PSD_INDEXED:
330
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
2 if (s->channel_depth != 8 || s->channel_count != 1) {
331 av_log(s->avctx, AV_LOG_ERROR,
332 "Invalid indexed file (channel_depth %d, channel_count %d)\n",
333 s->channel_depth, s->channel_count);
334 return AVERROR_INVALIDDATA;
335 }
336 2 avctx->pix_fmt = AV_PIX_FMT_PAL8;
337 2 break;
338 case PSD_CMYK:
339 if (s->channel_count == 4) {
340 if (s->channel_depth == 8) {
341 avctx->pix_fmt = AV_PIX_FMT_GBRP;
342 } else if (s->channel_depth == 16) {
343 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
344 } else {
345 avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
346 return AVERROR_PATCHWELCOME;
347 }
348 } else if (s->channel_count == 5) {
349 if (s->channel_depth == 8) {
350 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
351 } else if (s->channel_depth == 16) {
352 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
353 } else {
354 avpriv_report_missing_feature(avctx, "channel depth %d for cmyk", s->channel_depth);
355 return AVERROR_PATCHWELCOME;
356 }
357 } else {
358 avpriv_report_missing_feature(avctx, "channel count %d for cmyk", s->channel_count);
359 return AVERROR_PATCHWELCOME;
360 }
361 break;
362 16 case PSD_RGB:
363
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6 times.
16 if (s->channel_count == 3) {
364
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
10 if (s->channel_depth == 8) {
365 6 avctx->pix_fmt = AV_PIX_FMT_GBRP;
366
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 } else if (s->channel_depth == 16) {
367 4 avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
368 } else {
369 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
370 return AVERROR_PATCHWELCOME;
371 }
372
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 } else if (s->channel_count == 4) {
373
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
6 if (s->channel_depth == 8) {
374 4 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
375
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 } else if (s->channel_depth == 16) {
376 2 avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
377 } else {
378 avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
379 return AVERROR_PATCHWELCOME;
380 }
381 } else {
382 avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
383 return AVERROR_PATCHWELCOME;
384 }
385 16 break;
386 2 case PSD_DUOTONE:
387 2 av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
388 10 case PSD_GRAYSCALE:
389
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
10 if (s->channel_count == 1) {
390
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
6 if (s->channel_depth == 8) {
391 4 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
392
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 } else if (s->channel_depth == 16) {
393 2 avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
394 } else if (s->channel_depth == 32) {
395 avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
396 } else {
397 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
398 return AVERROR_PATCHWELCOME;
399 }
400
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 } else if (s->channel_count == 2) {
401
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
4 if (s->channel_depth == 8) {
402 2 avctx->pix_fmt = AV_PIX_FMT_YA8;
403
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 } else if (s->channel_depth == 16) {
404 2 avctx->pix_fmt = AV_PIX_FMT_YA16BE;
405 } else {
406 avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
407 return AVERROR_PATCHWELCOME;
408 }
409 } else {
410 avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
411 return AVERROR_PATCHWELCOME;
412 }
413 10 break;
414 default:
415 avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
416 return AVERROR_PATCHWELCOME;
417 }
418
419 30 s->uncompressed_size = s->line_size * s->height * s->channel_count;
420
421
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
30 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
422 return ret;
423
424 /* decode picture if need */
425
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 22 times.
30 if (s->compression == PSD_RLE) {
426 8 s->tmp = av_malloc(s->uncompressed_size);
427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (!s->tmp)
428 return AVERROR(ENOMEM);
429
430 8 ret = decode_rle(s);
431
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (ret < 0) {
433 av_freep(&s->tmp);
434 return ret;
435 }
436
437 8 ptr_data = s->tmp;
438 } else {
439
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
22 if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
440 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
441 return AVERROR_INVALIDDATA;
442 }
443 22 ptr_data = s->gb.buffer;
444 }
445
446 /* Store data */
447
4/4
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 26 times.
30 if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
448 4 ptr = picture->data[0];
449
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4 times.
12 for (c = 0; c < s->channel_count; c++) {
450
2/2
✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 8 times.
1032 for (y = 0; y < s->height; y++) {
451
2/2
✓ Branch 0 taken 131072 times.
✓ Branch 1 taken 1024 times.
132096 for (x = 0; x < s->width; x++) {
452 131072 index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
453
2/2
✓ Branch 0 taken 196608 times.
✓ Branch 1 taken 131072 times.
327680 for (p = 0; p < s->pixel_size; p++) {
454 196608 ptr[index_out + p] = *ptr_data;
455 196608 ptr_data ++;
456 }
457 }
458 }
459 }
460
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
26 } else if (s->color_mode == PSD_CMYK) {
461 uint8_t *dst[4] = { picture->data[0], picture->data[1], picture->data[2], picture->data[3] };
462 const uint8_t *src[5] = { ptr_data };
463 src[1] = src[0] + s->line_size * s->height;
464 src[2] = src[1] + s->line_size * s->height;
465 src[3] = src[2] + s->line_size * s->height;
466 src[4] = src[3] + s->line_size * s->height;
467 if (s->channel_depth == 8) {
468 for (y = 0; y < s->height; y++) {
469 for (x = 0; x < s->width; x++) {
470 int k = src[3][x];
471 int r = src[0][x] * k;
472 int g = src[1][x] * k;
473 int b = src[2][x] * k;
474 dst[0][x] = g * 257 >> 16;
475 dst[1][x] = b * 257 >> 16;
476 dst[2][x] = r * 257 >> 16;
477 }
478 dst[0] += picture->linesize[0];
479 dst[1] += picture->linesize[1];
480 dst[2] += picture->linesize[2];
481 src[0] += s->line_size;
482 src[1] += s->line_size;
483 src[2] += s->line_size;
484 src[3] += s->line_size;
485 }
486 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
487 for (y = 0; y < s->height; y++) {
488 memcpy(dst[3], src[4], s->line_size);
489 src[4] += s->line_size;
490 dst[3] += picture->linesize[3];
491 }
492 }
493 } else {
494 for (y = 0; y < s->height; y++) {
495 for (x = 0; x < s->width; x++) {
496 int64_t k = AV_RB16(&src[3][x * 2]);
497 int64_t r = AV_RB16(&src[0][x * 2]) * k;
498 int64_t g = AV_RB16(&src[1][x * 2]) * k;
499 int64_t b = AV_RB16(&src[2][x * 2]) * k;
500 AV_WB16(&dst[0][x * 2], g * 65537 >> 32);
501 AV_WB16(&dst[1][x * 2], b * 65537 >> 32);
502 AV_WB16(&dst[2][x * 2], r * 65537 >> 32);
503 }
504 dst[0] += picture->linesize[0];
505 dst[1] += picture->linesize[1];
506 dst[2] += picture->linesize[2];
507 src[0] += s->line_size;
508 src[1] += s->line_size;
509 src[2] += s->line_size;
510 src[3] += s->line_size;
511 }
512 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) {
513 for (y = 0; y < s->height; y++) {
514 memcpy(dst[3], src[4], s->line_size);
515 src[4] += s->line_size;
516 dst[3] += picture->linesize[3];
517 }
518 }
519 }
520 } else {/* Planar */
521
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 16 times.
26 if (s->channel_count == 1)/* gray 8 or gray 16be */
522 10 eq_channel[0] = 0;/* assign first channel, to first plane */
523
524
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 26 times.
90 for (c = 0; c < s->channel_count; c++) {
525 64 plane_number = eq_channel[c];
526 64 ptr = picture->data[plane_number];/* get the right plane */
527
2/2
✓ Branch 0 taken 8174 times.
✓ Branch 1 taken 64 times.
8238 for (y = 0; y < s->height; y++) {
528 8174 memcpy(ptr, ptr_data, s->line_size);
529 8174 ptr += picture->linesize[plane_number];
530 8174 ptr_data += s->line_size;
531 }
532 }
533 }
534
535
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 28 times.
30 if (s->color_mode == PSD_INDEXED) {
536 2 picture->palette_has_changed = 1;
537 2 memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
538 }
539
540 30 av_freep(&s->tmp);
541
542 30 picture->pict_type = AV_PICTURE_TYPE_I;
543 30 *got_frame = 1;
544
545 30 return avpkt->size;
546 }
547
548 const AVCodec ff_psd_decoder = {
549 .name = "psd",
550 .long_name = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
551 .type = AVMEDIA_TYPE_VIDEO,
552 .id = AV_CODEC_ID_PSD,
553 .priv_data_size = sizeof(PSDContext),
554 .decode = decode_frame,
555 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
556 };
557