FFmpeg  4.3
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 "internal.h"
24 
25 enum PsdCompr {
30 };
31 
41 };
42 
43 typedef struct PSDContext {
44  AVClass *class;
48 
50 
51  uint16_t channel_count;
52  uint16_t channel_depth;
53 
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 
63 
65 } PSDContext;
66 
67 static int decode_header(PSDContext * s)
68 {
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)) {
102  "Height > 30000 is experimental, add "
103  "'-strict %d' if you want to try to decode the picture.\n",
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)) {
111  "Width > 30000 is experimental, add "
112  "'-strict %d' if you want to try to decode the picture.\n",
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:
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:
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  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  return ret;
223 }
224 
225 static int decode_rle(PSDContext * s){
226  unsigned int scanline_count;
227  unsigned int sl, count;
228  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  scanline_count = s->height * s->channel_count;
235 
236  /* scanline table */
237  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  bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
242 
243  /* decode rle data scanline by scanline */
244  for (sl = 0; sl < scanline_count; sl++) {
245  count = 0;
246 
247  while (count < s->line_size) {
248  rle_char = bytestream2_get_byte(&s->gb);
249 
250  if (rle_char <= 0) {/* byte repeat */
251  repeat_count = rle_char * -1;
252 
253  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  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  v = bytestream2_get_byte(&s->gb);
264  for (p = 0; p <= repeat_count; p++) {
265  s->tmp[target_index++] = v;
266  }
267  count += repeat_count + 1;
268  } else {
269  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  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  for (p = 0; p <= rle_char; p++) {
280  v = bytestream2_get_byte(&s->gb);
281  s->tmp[target_index++] = v;
282  }
283  count += rle_char + 1;
284  }
285  }
286  }
287 
288  return 0;
289 }
290 
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  uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
299  uint8_t plane_number;
300 
301  AVFrame *picture = data;
302 
303  PSDContext *s = avctx->priv_data;
304  s->avctx = avctx;
305  s->channel_count = 0;
306  s->channel_depth = 0;
307  s->tmp = NULL;
308  s->line_size = 0;
309 
310  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
311 
312  if ((ret = decode_header(s)) < 0)
313  return ret;
314 
315  s->pixel_size = s->channel_depth >> 3;/* in byte */
316  s->line_size = s->width * s->pixel_size;
317 
318  switch (s->color_mode) {
319  case PSD_BITMAP:
320  if (s->channel_depth != 1 || s->channel_count != 1) {
322  "Invalid bitmap file (channel_depth %d, channel_count %d)\n",
324  return AVERROR_INVALIDDATA;
325  }
326  s->line_size = s->width + 7 >> 3;
327  avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
328  break;
329  case PSD_INDEXED:
330  if (s->channel_depth != 8 || s->channel_count != 1) {
332  "Invalid indexed file (channel_depth %d, channel_count %d)\n",
334  return AVERROR_INVALIDDATA;
335  }
336  avctx->pix_fmt = AV_PIX_FMT_PAL8;
337  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  case PSD_RGB:
363  if (s->channel_count == 3) {
364  if (s->channel_depth == 8) {
365  avctx->pix_fmt = AV_PIX_FMT_GBRP;
366  } else if (s->channel_depth == 16) {
367  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  } else if (s->channel_count == 4) {
373  if (s->channel_depth == 8) {
374  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
375  } else if (s->channel_depth == 16) {
376  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  break;
386  case PSD_DUOTONE:
387  av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
388  case PSD_GRAYSCALE:
389  if (s->channel_count == 1) {
390  if (s->channel_depth == 8) {
391  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
392  } else if (s->channel_depth == 16) {
393  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  } else if (s->channel_count == 2) {
401  if (s->channel_depth == 8) {
402  avctx->pix_fmt = AV_PIX_FMT_YA8;
403  } else if (s->channel_depth == 16) {
404  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  break;
414  default:
415  avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
416  return AVERROR_PATCHWELCOME;
417  }
418 
420 
421  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
422  return ret;
423 
424  /* decode picture if need */
425  if (s->compression == PSD_RLE) {
427  if (!s->tmp)
428  return AVERROR(ENOMEM);
429 
430  ret = decode_rle(s);
431 
432  if (ret < 0) {
433  av_freep(&s->tmp);
434  return ret;
435  }
436 
437  ptr_data = s->tmp;
438  } else {
440  av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
441  return AVERROR_INVALIDDATA;
442  }
443  ptr_data = s->gb.buffer;
444  }
445 
446  /* Store data */
447  if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
448  ptr = picture->data[0];
449  for (c = 0; c < s->channel_count; c++) {
450  for (y = 0; y < s->height; y++) {
451  for (x = 0; x < s->width; x++) {
452  index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
453  for (p = 0; p < s->pixel_size; p++) {
454  ptr[index_out + p] = *ptr_data;
455  ptr_data ++;
456  }
457  }
458  }
459  }
460  } 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  if (s->channel_count == 1)/* gray 8 or gray 16be */
522  eq_channel[0] = 0;/* assign first channel, to first plane */
523 
524  for (c = 0; c < s->channel_count; c++) {
525  plane_number = eq_channel[c];
526  ptr = picture->data[plane_number];/* get the right plane */
527  for (y = 0; y < s->height; y++) {
528  memcpy(ptr, ptr_data, s->line_size);
529  ptr += picture->linesize[plane_number];
530  ptr_data += s->line_size;
531  }
532  }
533  }
534 
535  if (s->color_mode == PSD_INDEXED) {
536  picture->palette_has_changed = 1;
537  memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
538  }
539 
540  av_freep(&s->tmp);
541 
542  picture->pict_type = AV_PICTURE_TYPE_I;
543  *got_frame = 1;
544 
545  return avpkt->size;
546 }
547 
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,
556 };
Definition: psd.c:33
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1594
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:340
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
version
Definition: libkvazaar.c:292
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
8 bits gray, 8 bits alpha
Definition: pixfmt.h:143
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:104
uint16_t channel_count
Definition: psd.c:51
const char * g
Definition: vf_curves.c:115
static int decode_rle(PSDContext *s)
Definition: psd.c:225
uint16_t channel_depth
Definition: psd.c:52
#define avpriv_request_sample(...)
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int size
Definition: packet.h:356
Definition: psd.c:37
const char * b
Definition: vf_curves.c:116
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
uint64_t line_size
Definition: psd.c:56
Definition: psd.c:27
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:216
static const char signature[]
Definition: ipmovie.c:615
uint8_t
#define av_malloc(s)
GetByteContext gb
Definition: psd.c:47
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
static int decode_header(PSDContext *s)
Definition: psd.c:67
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
Definition: psd.c:26
PsdCompr
Definition: psd.c:25
const char data[16]
Definition: mxf.c:91
uint8_t * data
Definition: packet.h:355
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
const uint8_t * buffer
Definition: bytestream.h:34
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVFrame * picture
Definition: psd.c:45
#define av_log(a,...)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
enum PsdCompr compression
Definition: psd.c:61
#define src
Definition: vp8dsp.c:254
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:212
PsdColorMode
Definition: psd.c:32
#define AV_RB16
Definition: intreadwrite.h:53
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
uint64_t uncompressed_size
Definition: psd.c:54
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
const char * name
Name of the codec implementation.
Definition: codec.h:197
AVCodec ff_psd_decoder
Definition: psd.c:548
Definition: psd.c:43
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:383
#define FFMIN(a, b)
Definition: common.h:96
enum PsdColorMode color_mode
Definition: psd.c:62
#define s(width, name)
Definition: cbs_vp9.c:257
unsigned int pixel_size
Definition: psd.c:55
Definition: psd.c:36
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:72
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVCodecContext * avctx
Definition: psd.c:46
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
uint8_t palette[AVPALETTE_SIZE]
Definition: psd.c:64
main external API structure.
Definition: avcodec.h:526
int height
Definition: psd.c:59
uint8_t * tmp
Definition: psd.c:49
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
Describe the class of an AVClass context structure.
Definition: log.h:67
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:457
int width
Definition: psd.c:58
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:75
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: psd.c:291
static double c[64]
void * priv_data
Definition: avcodec.h:553
Definition: psd.c:40
#define av_freep(p)
#define HAVE_BIGENDIAN
Definition: config.h:199
#define MKTAG(a, b, c, d)
Definition: common.h:406
This structure stores compressed data.
Definition: packet.h:332
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1589