FFmpeg
psd.c
Go to the documentation of this file.
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 "decode.h"
25 
26 enum PsdCompr {
31 };
32 
42 };
43 
44 typedef struct PSDContext {
45  AVClass *class;
49 
50  uint8_t * tmp;
51 
52  uint16_t channel_count;
53  uint16_t channel_depth;
54 
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 
64 
66 } PSDContext;
67 
68 static 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",
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",
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 
226 static 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 
292 static 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 
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),
555 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
PSDContext::height
int height
Definition: psd.c:60
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:133
GetByteContext
Definition: bytestream.h:33
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:164
PSDContext::channel_depth
uint16_t channel_depth
Definition: psd.c:53
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:41
PsdColorMode
PsdColorMode
Definition: psd.c:33
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
PSD_RGB
@ PSD_RGB
Definition: psd.c:37
FFCodec
Definition: codec_internal.h:119
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
PSDContext::line_size
uint64_t line_size
Definition: psd.c:57
signature
static const char signature[]
Definition: ipmovie.c:591
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:206
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
PSD_LAB
@ PSD_LAB
Definition: psd.c:41
g
const char * g
Definition: vf_curves.c:127
PSD_GRAYSCALE
@ PSD_GRAYSCALE
Definition: psd.c:35
decode.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
PsdCompr
PsdCompr
Definition: psd.c:26
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
PSDContext
Definition: psd.c:44
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
decode_header
static int decode_header(PSDContext *s)
Definition: psd.c:68
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
PSD_ZIP_WITHOUT_P
@ PSD_ZIP_WITHOUT_P
Definition: psd.c:29
PSD_DUOTONE
@ PSD_DUOTONE
Definition: psd.c:40
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
PSD_INDEXED
@ PSD_INDEXED
Definition: psd.c:36
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1450
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
PSD_BITMAP
@ PSD_BITMAP
Definition: psd.c:34
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
PSD_CMYK
@ PSD_CMYK
Definition: psd.c:38
PSDContext::compression
enum PsdCompr compression
Definition: psd.c:62
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:202
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
version
version
Definition: libkvazaar.c:313
PSDContext::width
int width
Definition: psd.c:59
PSDContext::avctx
AVCodecContext * avctx
Definition: psd.c:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
PSD_RAW
@ PSD_RAW
Definition: psd.c:27
PSDContext::gb
GetByteContext gb
Definition: psd.c:48
PSD_RLE
@ PSD_RLE
Definition: psd.c:28
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
PSDContext::palette
uint8_t palette[AVPALETTE_SIZE]
Definition: psd.c:65
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:360
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::palette_has_changed
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:487
PSD_ZIP_WITH_P
@ PSD_ZIP_WITH_P
Definition: psd.c:30
AV_CODEC_ID_PSD
@ AV_CODEC_ID_PSD
Definition: codec_id.h:276
ff_psd_decoder
const FFCodec ff_psd_decoder
Definition: psd.c:547
PSDContext::color_mode
enum PsdColorMode color_mode
Definition: psd.c:63
decode_rle
static int decode_rle(PSDContext *s)
Definition: psd.c:226
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
PSDContext::channel_count
uint16_t channel_count
Definition: psd.c:52
PSDContext::picture
AVFrame * picture
Definition: psd.c:46
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
PSDContext::pixel_size
unsigned int pixel_size
Definition: psd.c:56
PSDContext::uncompressed_size
uint64_t uncompressed_size
Definition: psd.c:55
PSD_MULTICHANNEL
@ PSD_MULTICHANNEL
Definition: psd.c:39
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
PSDContext::tmp
uint8_t * tmp
Definition: psd.c:50
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: psd.c:292
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98