FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/psd.c
Date: 2026-01-16 07:34:38
Exec Total Coverage
Lines: 164 319 51.4%
Functions: 3 3 100.0%
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 "libavutil/mem.h"
23 #include "bytestream.h"
24 #include "codec_internal.h"
25 #include "decode.h"
26
27 enum PsdCompr {
28 PSD_RAW,
29 PSD_RLE,
30 PSD_ZIP_WITHOUT_P,
31 PSD_ZIP_WITH_P,
32 };
33
34 enum PsdColorMode {
35 PSD_BITMAP,
36 PSD_GRAYSCALE,
37 PSD_INDEXED,
38 PSD_RGB,
39 PSD_CMYK,
40 PSD_MULTICHANNEL,
41 PSD_DUOTONE,
42 PSD_LAB,
43 };
44
45 typedef struct PSDContext {
46 AVClass *class;
47 AVFrame *picture;
48 AVCodecContext *avctx;
49 GetByteContext gb;
50
51 uint8_t * tmp;
52
53 uint16_t channel_count;
54 uint16_t channel_depth;
55
56 uint64_t uncompressed_size;
57 unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */
58 uint64_t line_size;/* length of src data (even width) */
59
60 int width;
61 int height;
62
63 enum PsdCompr compression;
64 enum PsdColorMode color_mode;
65
66 uint8_t palette[AVPALETTE_SIZE];
67 } PSDContext;
68
69 30 static int decode_header(PSDContext * s)
70 {
71 int signature, version, color_mode;
72 int64_t len_section;
73 30 int ret = 0;
74
75
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 */
76 ✗ av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
77 ✗ return AVERROR_INVALIDDATA;
78 }
79
80 30 signature = bytestream2_get_le32(&s->gb);
81
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (signature != MKTAG('8','B','P','S')) {
82 ✗ av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature);
83 ✗ return AVERROR_INVALIDDATA;
84 }
85
86 30 version = bytestream2_get_be16(&s->gb);
87
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (version != 1) {
88 ✗ av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
89 ✗ return AVERROR_INVALIDDATA;
90 }
91
92 30 bytestream2_skip(&s->gb, 6);/* reserved */
93
94 30 s->channel_count = bytestream2_get_be16(&s->gb);
95
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)) {
96 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count);
97 ✗ return AVERROR_INVALIDDATA;
98 }
99
100 30 s->height = bytestream2_get_be32(&s->gb);
101
102
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)) {
103 ✗ av_log(s->avctx, AV_LOG_ERROR,
104 "Height > 30000 is experimental, add "
105 "'-strict %d' if you want to try to decode the picture.\n",
106 FF_COMPLIANCE_EXPERIMENTAL);
107 ✗ return AVERROR_EXPERIMENTAL;
108 }
109
110 30 s->width = bytestream2_get_be32(&s->gb);
111
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)) {
112 ✗ av_log(s->avctx, AV_LOG_ERROR,
113 "Width > 30000 is experimental, add "
114 "'-strict %d' if you want to try to decode the picture.\n",
115 FF_COMPLIANCE_EXPERIMENTAL);
116 ✗ return AVERROR_EXPERIMENTAL;
117 }
118
119
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
 30 if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
120 ✗ return ret;
121
122 30 s->channel_depth = bytestream2_get_be16(&s->gb);
123
124 30 color_mode = bytestream2_get_be16(&s->gb);
125
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) {
126 2 case 0:
127 2 s->color_mode = PSD_BITMAP;
128 2 break;
129 8 case 1:
130 8 s->color_mode = PSD_GRAYSCALE;
131 8 break;
132 2 case 2:
133 2 s->color_mode = PSD_INDEXED;
134 2 break;
135 16 case 3:
136 16 s->color_mode = PSD_RGB;
137 16 break;
138 ✗ case 4:
139 ✗ s->color_mode = PSD_CMYK;
140 ✗ break;
141 ✗ case 7:
142 ✗ s->color_mode = PSD_MULTICHANNEL;
143 ✗ break;
144 2 case 8:
145 2 s->color_mode = PSD_DUOTONE;
146 2 break;
147 ✗ case 9:
148 ✗ s->color_mode = PSD_LAB;
149 ✗ break;
150 ✗ default:
151 ✗ av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode);
152 ✗ return AVERROR_INVALIDDATA;
153 }
154
155 /* color map data */
156 30 len_section = bytestream2_get_be32(&s->gb);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (len_section < 0) {
158 ✗ av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n");
159 ✗ return AVERROR_INVALIDDATA;
160 }
161
162
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 */
163 ✗ av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
164 ✗ return AVERROR_INVALIDDATA;
165 }
166
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 26 times.
 30 if (len_section) {
167 int i,j;
168 4 memset(s->palette, 0xff, AVPALETTE_SIZE);
169
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
 16 for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
170
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++)
171 2580 s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
172 4 len_section -= i * 3;
173 }
174 30 bytestream2_skip(&s->gb, len_section);
175
176 /* image resources */
177 30 len_section = bytestream2_get_be32(&s->gb);
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (len_section < 0) {
179 ✗ av_log(s->avctx, AV_LOG_ERROR, "Negative size for image resources section.\n");
180 ✗ return AVERROR_INVALIDDATA;
181 }
182
183
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 */
184 ✗ av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
185 ✗ return AVERROR_INVALIDDATA;
186 }
187 30 bytestream2_skip(&s->gb, len_section);
188
189 /* layers and masks */
190 30 len_section = bytestream2_get_be32(&s->gb);
191
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (len_section < 0) {
192 ✗ av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n");
193 ✗ return AVERROR_INVALIDDATA;
194 }
195
196
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
 30 if (bytestream2_get_bytes_left(&s->gb) < len_section) {
197 ✗ av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
198 ✗ return AVERROR_INVALIDDATA;
199 }
200 30 bytestream2_skip(&s->gb, len_section);
201
202 /* image section */
203
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
 30 if (bytestream2_get_bytes_left(&s->gb) < 2) {
204 ✗ av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n");
205 ✗ return AVERROR_INVALIDDATA;
206 }
207
208 30 s->compression = bytestream2_get_be16(&s->gb);
209
1/4
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 30 switch (s->compression) {
210 30 case 0:
211 case 1:
212 30 break;
213 ✗ case 2:
214 ✗ avpriv_request_sample(s->avctx, "ZIP without predictor compression");
215 ✗ return AVERROR_PATCHWELCOME;
216 ✗ case 3:
217 ✗ avpriv_request_sample(s->avctx, "ZIP with predictor compression");
218 ✗ return AVERROR_PATCHWELCOME;
219 ✗ default:
220 ✗ av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
221 ✗ return AVERROR_INVALIDDATA;
222 }
223
224 30 return ret;
225 }
226
227 8 static int decode_rle(PSDContext * s){
228 unsigned int scanline_count;
229 unsigned int sl, count;
230 8 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 8 scanline_count = s->height * s->channel_count;
237
238 /* scanline table */
239
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
 8 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 8 bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
244
245 /* decode rle data scanline by scanline */
246
2/2
✓ Branch 0 taken 2804 times.
✓ Branch 1 taken 8 times.
 2812 for (sl = 0; sl < scanline_count; sl++) {
247 2804 count = 0;
248
249
2/2
✓ Branch 0 taken 18540 times.
✓ Branch 1 taken 2804 times.
 21344 while (count < s->line_size) {
250 18540 rle_char = bytestream2_get_byte(&s->gb);
251
252
2/2
✓ Branch 0 taken 12340 times.
✓ Branch 1 taken 6200 times.
 18540 if (rle_char <= 0) {/* byte repeat */
253 12340 repeat_count = rle_char * -1;
254
255
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12340 times.
 12340 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12340 times.
 12340 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 12340 v = bytestream2_get_byte(&s->gb);
266
2/2
✓ Branch 0 taken 210352 times.
✓ Branch 1 taken 12340 times.
 222692 for (p = 0; p <= repeat_count; p++) {
267 210352 s->tmp[target_index++] = v;
268 }
269 12340 count += repeat_count + 1;
270 } else {
271
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6200 times.
 6200 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6200 times.
 6200 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
2/2
✓ Branch 0 taken 243810 times.
✓ Branch 1 taken 6200 times.
 250010 for (p = 0; p <= rle_char; p++) {
282 243810 v = bytestream2_get_byte(&s->gb);
283 243810 s->tmp[target_index++] = v;
284 }
285 6200 count += rle_char + 1;
286 }
287 }
288 }
289
290 8 return 0;
291 }
292
293 30 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
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 30 uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
301 uint8_t plane_number;
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 /* decode picture if need */
422
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 22 times.
 30 if (s->compression == PSD_RLE) {
423 8 s->tmp = av_malloc(s->uncompressed_size);
424
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (!s->tmp)
425 ✗ return AVERROR(ENOMEM);
426
427 8 ret = decode_rle(s);
428
429
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (ret < 0) {
430 ✗ av_freep(&s->tmp);
431 ✗ return ret;
432 }
433
434 8 ptr_data = s->tmp;
435 } else {
436
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 22 if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
437 ✗ av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
438 ✗ return AVERROR_INVALIDDATA;
439 }
440 22 ptr_data = s->gb.buffer;
441 }
442
443
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
 30 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
444 ✗ return ret;
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 memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
537 }
538
539 30 av_freep(&s->tmp);
540
541 30 picture->pict_type = AV_PICTURE_TYPE_I;
542 30 *got_frame = 1;
543
544 30 return avpkt->size;
545 }
546
547 const FFCodec ff_psd_decoder = {
548 .p.name = "psd",
549 CODEC_LONG_NAME("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