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 "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:2636
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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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: avcodec.h:1481
Definition: psd.c:37
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int version
Definition: avisynth_c.h:858
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:87
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3492
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
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
Definition: psd.c:26
PsdCompr
Definition: psd.c:25
uint8_t * data
Definition: avcodec.h:1480
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,...)
enum PsdCompr compression
Definition: psd.c:61
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#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
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
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
GLsizei count
Definition: opengl_enc.c:108
AVCodec ff_psd_decoder
Definition: psd.c:548
Definition: psd.c:43
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1040
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#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:326
uint8_t palette[AVPALETTE_SIZE]
Definition: psd.c:64
main external API structure.
Definition: avcodec.h:1568
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:1968
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:452
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:309
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
void * priv_data
Definition: avcodec.h:1595
Definition: psd.c:40
#define av_freep(p)
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2631