FFmpeg
pngdec.c
Go to the documentation of this file.
1 /*
2  * PNG image format
3  * Copyright (c) 2003 Fabrice Bellard
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 //#define DEBUG
23 
24 #include "config_components.h"
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/bprint.h"
28 #include "libavutil/crc.h"
29 #include "libavutil/csp.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/pixfmt.h"
35 #include "libavutil/rational.h"
36 #include "libavutil/stereo3d.h"
37 
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "codec_internal.h"
41 #include "decode.h"
42 #include "apng.h"
43 #include "png.h"
44 #include "pngdsp.h"
45 #include "thread.h"
46 #include "threadframe.h"
47 #include "zlib_wrapper.h"
48 
49 #include <zlib.h>
50 
52  PNG_IHDR = 1 << 0,
53  PNG_PLTE = 1 << 1,
54 };
55 
57  PNG_IDAT = 1 << 0,
58  PNG_ALLIMAGE = 1 << 1,
59 };
60 
61 typedef struct PNGDecContext {
64 
68 
70 
71  uint8_t iccp_name[82];
72  uint8_t *iccp_data;
73  size_t iccp_data_len;
74 
76 
77  int have_chrm;
78  uint32_t white_point[2];
79  uint32_t display_primaries[3][2];
80  int gamma;
81  int have_srgb;
82  int have_cicp;
86  int have_clli;
87  uint32_t clli_max;
88  uint32_t clli_avg;
89  int have_mdvc;
90  uint16_t mdvc_primaries[3][2];
91  uint16_t mdvc_white_point[2];
92  uint32_t mdvc_max_lum;
93  uint32_t mdvc_min_lum;
94 
97  int width, height;
98  int cur_w, cur_h;
106  int channels;
108  int bpp;
109  int has_trns;
112 
113  uint32_t palette[256];
114  uint8_t *crow_buf;
115  uint8_t *last_row;
116  unsigned int last_row_size;
117  uint8_t *tmp_row;
118  unsigned int tmp_row_size;
119  uint8_t *buffer;
121  int pass;
122  int crow_size; /* compressed row size (include filter type) */
123  int row_size; /* decompressed row size */
124  int pass_row_size; /* decompress row size of the current pass */
125  int y;
127 } PNGDecContext;
128 
129 /* Mask to determine which pixels are valid in a pass */
130 static const uint8_t png_pass_mask[NB_PASSES] = {
131  0x01, 0x01, 0x11, 0x11, 0x55, 0x55, 0xff,
132 };
133 
134 /* Mask to determine which y pixels can be written in a pass */
135 static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {
136  0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
137 };
138 
139 /* Mask to determine which pixels to overwrite while displaying */
140 static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
141  0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
142 };
143 
144 /* NOTE: we try to construct a good looking image at each pass. width
145  * is the original image width. We also do pixel format conversion at
146  * this stage */
147 static void png_put_interlaced_row(uint8_t *dst, int width,
148  int bits_per_pixel, int pass,
149  int color_type, const uint8_t *src)
150 {
151  int x, mask, dsp_mask, j, src_x, b, bpp;
152  uint8_t *d;
153  const uint8_t *s;
154 
155  mask = png_pass_mask[pass];
156  dsp_mask = png_pass_dsp_mask[pass];
157 
158  switch (bits_per_pixel) {
159  case 1:
160  src_x = 0;
161  for (x = 0; x < width; x++) {
162  j = (x & 7);
163  if ((dsp_mask << j) & 0x80) {
164  b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;
165  dst[x >> 3] &= 0xFF7F>>j;
166  dst[x >> 3] |= b << (7 - j);
167  }
168  if ((mask << j) & 0x80)
169  src_x++;
170  }
171  break;
172  case 2:
173  src_x = 0;
174  for (x = 0; x < width; x++) {
175  int j2 = 2 * (x & 3);
176  j = (x & 7);
177  if ((dsp_mask << j) & 0x80) {
178  b = (src[src_x >> 2] >> (6 - 2*(src_x & 3))) & 3;
179  dst[x >> 2] &= 0xFF3F>>j2;
180  dst[x >> 2] |= b << (6 - j2);
181  }
182  if ((mask << j) & 0x80)
183  src_x++;
184  }
185  break;
186  case 4:
187  src_x = 0;
188  for (x = 0; x < width; x++) {
189  int j2 = 4*(x&1);
190  j = (x & 7);
191  if ((dsp_mask << j) & 0x80) {
192  b = (src[src_x >> 1] >> (4 - 4*(src_x & 1))) & 15;
193  dst[x >> 1] &= 0xFF0F>>j2;
194  dst[x >> 1] |= b << (4 - j2);
195  }
196  if ((mask << j) & 0x80)
197  src_x++;
198  }
199  break;
200  default:
201  bpp = bits_per_pixel >> 3;
202  d = dst;
203  s = src;
204  for (x = 0; x < width; x++) {
205  j = x & 7;
206  if ((dsp_mask << j) & 0x80) {
207  memcpy(d, s, bpp);
208  }
209  d += bpp;
210  if ((mask << j) & 0x80)
211  s += bpp;
212  }
213  break;
214  }
215 }
216 
217 void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top,
218  int w, int bpp)
219 {
220  int i;
221  for (i = 0; i < w; i++) {
222  int a, b, c, p, pa, pb, pc;
223 
224  a = dst[i - bpp];
225  b = top[i];
226  c = top[i - bpp];
227 
228  p = b - c;
229  pc = a - c;
230 
231  pa = abs(p);
232  pb = abs(pc);
233  pc = abs(p + pc);
234 
235  if (pa <= pb && pa <= pc)
236  p = a;
237  else if (pb <= pc)
238  p = b;
239  else
240  p = c;
241  dst[i] = p + src[i];
242  }
243 }
244 
245 #define UNROLL1(bpp, op) \
246  { \
247  r = dst[0]; \
248  if (bpp >= 2) \
249  g = dst[1]; \
250  if (bpp >= 3) \
251  b = dst[2]; \
252  if (bpp >= 4) \
253  a = dst[3]; \
254  for (; i <= size - bpp; i += bpp) { \
255  dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \
256  if (bpp == 1) \
257  continue; \
258  dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \
259  if (bpp == 2) \
260  continue; \
261  dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \
262  if (bpp == 3) \
263  continue; \
264  dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \
265  } \
266  }
267 
268 #define UNROLL_FILTER(op) \
269  if (bpp == 1) { \
270  UNROLL1(1, op) \
271  } else if (bpp == 2) { \
272  UNROLL1(2, op) \
273  } else if (bpp == 3) { \
274  UNROLL1(3, op) \
275  } else if (bpp == 4) { \
276  UNROLL1(4, op) \
277  } \
278  for (; i < size; i++) { \
279  dst[i] = op(dst[i - bpp], src[i], last[i]); \
280  }
281 
282 /* NOTE: 'dst' can be equal to 'last' */
283 void ff_png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type,
284  uint8_t *src, uint8_t *last, int size, int bpp)
285 {
286  int i, p, r, g, b, a;
287 
288  switch (filter_type) {
290  memcpy(dst, src, size);
291  break;
293  for (i = 0; i < bpp; i++)
294  dst[i] = src[i];
295  if (bpp == 4) {
296  p = *(int *)dst;
297  for (; i < size; i += bpp) {
298  unsigned s = *(int *)(src + i);
299  p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080);
300  *(int *)(dst + i) = p;
301  }
302  } else {
303 #define OP_SUB(x, s, l) ((x) + (s))
305  }
306  break;
307  case PNG_FILTER_VALUE_UP:
308  dsp->add_bytes_l2(dst, src, last, size);
309  break;
311  for (i = 0; i < bpp; i++) {
312  p = (last[i] >> 1);
313  dst[i] = p + src[i];
314  }
315 #define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff)
317  break;
319  for (i = 0; i < bpp; i++) {
320  p = last[i];
321  dst[i] = p + src[i];
322  }
323  if (bpp > 2 && size > 4) {
324  /* would write off the end of the array if we let it process
325  * the last pixel with bpp=3 */
326  int w = (bpp & 3) ? size - 3 : size;
327 
328  if (w > i) {
329  dsp->add_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
330  i = w;
331  }
332  }
333  ff_add_png_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
334  break;
335  }
336 }
337 
338 /* This used to be called "deloco" in FFmpeg
339  * and is actually an inverse reversible colorspace transformation */
340 #define YUV2RGB(NAME, TYPE) \
341 static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \
342 { \
343  int i; \
344  for (i = 0; i < size - 2; i += 3 + alpha) { \
345  int g = dst [i + 1]; \
346  dst[i + 0] += g; \
347  dst[i + 2] += g; \
348  } \
349 }
350 
351 YUV2RGB(rgb8, uint8_t)
352 YUV2RGB(rgb16, uint16_t)
353 
355 {
356  if (s->interlace_type) {
357  return 100 - 100 * s->pass / (NB_PASSES - 1);
358  } else {
359  return 100 - 100 * s->y / s->cur_h;
360  }
361 }
362 
363 /* process exactly one decompressed row */
364 static void png_handle_row(PNGDecContext *s, uint8_t *dst, ptrdiff_t dst_stride)
365 {
366  uint8_t *ptr, *last_row;
367  int got_line;
368 
369  if (!s->interlace_type) {
370  ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
371  if (s->y == 0)
372  last_row = s->last_row;
373  else
374  last_row = ptr - dst_stride;
375 
376  ff_png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,
377  last_row, s->row_size, s->bpp);
378  /* loco lags by 1 row so that it doesn't interfere with top prediction */
379  if (s->filter_type == PNG_FILTER_TYPE_LOCO && s->y > 0) {
380  if (s->bit_depth == 16) {
381  deloco_rgb16((uint16_t *)(ptr - dst_stride), s->row_size / 2,
382  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
383  } else {
384  deloco_rgb8(ptr - dst_stride, s->row_size,
385  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
386  }
387  }
388  s->y++;
389  if (s->y == s->cur_h) {
390  s->pic_state |= PNG_ALLIMAGE;
391  if (s->filter_type == PNG_FILTER_TYPE_LOCO) {
392  if (s->bit_depth == 16) {
393  deloco_rgb16((uint16_t *)ptr, s->row_size / 2,
394  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
395  } else {
396  deloco_rgb8(ptr, s->row_size,
397  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
398  }
399  }
400  }
401  } else {
402  got_line = 0;
403  for (;;) {
404  ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
405  if ((ff_png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
406  /* if we already read one row, it is time to stop to
407  * wait for the next one */
408  if (got_line)
409  break;
410  ff_png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
411  s->last_row, s->pass_row_size, s->bpp);
412  FFSWAP(uint8_t *, s->last_row, s->tmp_row);
413  FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size);
414  got_line = 1;
415  }
416  if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
417  png_put_interlaced_row(ptr, s->cur_w, s->bits_per_pixel, s->pass,
418  s->color_type, s->last_row);
419  }
420  s->y++;
421  if (s->y == s->cur_h) {
422  memset(s->last_row, 0, s->row_size);
423  for (;;) {
424  if (s->pass == NB_PASSES - 1) {
425  s->pic_state |= PNG_ALLIMAGE;
426  goto the_end;
427  } else {
428  s->pass++;
429  s->y = 0;
430  s->pass_row_size = ff_png_pass_row_size(s->pass,
431  s->bits_per_pixel,
432  s->cur_w);
433  s->crow_size = s->pass_row_size + 1;
434  if (s->pass_row_size != 0)
435  break;
436  /* skip pass if empty row */
437  }
438  }
439  }
440  }
441 the_end:;
442  }
443 }
444 
446  uint8_t *dst, ptrdiff_t dst_stride)
447 {
448  z_stream *const zstream = &s->zstream.zstream;
449  int ret;
450  zstream->avail_in = bytestream2_get_bytes_left(gb);
451  zstream->next_in = gb->buffer;
452 
453  /* decode one line if possible */
454  while (zstream->avail_in > 0) {
455  ret = inflate(zstream, Z_PARTIAL_FLUSH);
456  if (ret != Z_OK && ret != Z_STREAM_END) {
457  av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
458  return AVERROR_EXTERNAL;
459  }
460  if (zstream->avail_out == 0) {
461  if (!(s->pic_state & PNG_ALLIMAGE)) {
462  png_handle_row(s, dst, dst_stride);
463  }
464  zstream->avail_out = s->crow_size;
465  zstream->next_out = s->crow_buf;
466  }
467  if (ret == Z_STREAM_END && zstream->avail_in > 0) {
468  av_log(s->avctx, AV_LOG_WARNING,
469  "%d undecompressed bytes left in buffer\n", zstream->avail_in);
470  return 0;
471  }
472  }
473  return 0;
474 }
475 
476 static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
477  const uint8_t *data_end, void *logctx)
478 {
479  FFZStream z;
480  z_stream *const zstream = &z.zstream;
481  unsigned char *buf;
482  unsigned buf_size;
483  int ret = ff_inflate_init(&z, logctx);
484  if (ret < 0)
485  return ret;
486 
487  zstream->next_in = data;
488  zstream->avail_in = data_end - data;
490 
491  while (zstream->avail_in > 0) {
492  av_bprint_get_buffer(bp, 2, &buf, &buf_size);
493  if (buf_size < 2) {
494  ret = AVERROR(ENOMEM);
495  goto fail;
496  }
497  zstream->next_out = buf;
498  zstream->avail_out = buf_size - 1;
499  ret = inflate(zstream, Z_PARTIAL_FLUSH);
500  if (ret != Z_OK && ret != Z_STREAM_END) {
502  goto fail;
503  }
504  bp->len += zstream->next_out - buf;
505  if (ret == Z_STREAM_END)
506  break;
507  }
508  ff_inflate_end(&z);
509  bp->str[bp->len] = 0;
510  return 0;
511 
512 fail:
513  ff_inflate_end(&z);
515  return ret;
516 }
517 
518 static char *iso88591_to_utf8(const char *in, size_t size_in)
519 {
520  size_t extra = 0, i;
521  char *out, *q;
522 
523  for (i = 0; i < size_in; i++)
524  extra += !!(in[i] & 0x80);
525  if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
526  return NULL;
527  q = out = av_malloc(size_in + extra + 1);
528  if (!out)
529  return NULL;
530  for (i = 0; i < size_in; i++) {
531  if (in[i] & 0x80) {
532  *(q++) = 0xC0 | (in[i] >> 6);
533  *(q++) = 0x80 | (in[i] & 0x3F);
534  } else {
535  *(q++) = in[i];
536  }
537  }
538  *(q++) = 0;
539  return out;
540 }
541 
542 static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
543 {
544  int ret, method;
545  const uint8_t *data = gb->buffer;
546  const uint8_t *data_end = gb->buffer_end;
547  const char *keyword = data;
548  const char *keyword_end = memchr(keyword, 0, data_end - data);
549  char *kw_utf8 = NULL, *txt_utf8 = NULL;
550  const char *text;
551  unsigned text_len;
552  AVBPrint bp;
553 
554  if (!keyword_end)
555  return AVERROR_INVALIDDATA;
556  data = keyword_end + 1;
557 
558  if (compressed) {
559  if (data == data_end)
560  return AVERROR_INVALIDDATA;
561  method = *(data++);
562  if (method)
563  return AVERROR_INVALIDDATA;
564  if ((ret = decode_zbuf(&bp, data, data_end, s->avctx)) < 0)
565  return ret;
566  text = bp.str;
567  text_len = bp.len;
568  } else {
569  text = data;
570  text_len = data_end - data;
571  }
572 
573  txt_utf8 = iso88591_to_utf8(text, text_len);
574  if (compressed)
575  av_bprint_finalize(&bp, NULL);
576  if (!txt_utf8)
577  return AVERROR(ENOMEM);
578  kw_utf8 = iso88591_to_utf8(keyword, keyword_end - keyword);
579  if (!kw_utf8) {
580  av_free(txt_utf8);
581  return AVERROR(ENOMEM);
582  }
583 
584  av_dict_set(&s->frame_metadata, kw_utf8, txt_utf8,
586  return 0;
587 }
588 
590  GetByteContext *gb)
591 {
592  if (bytestream2_get_bytes_left(gb) != 13)
593  return AVERROR_INVALIDDATA;
594 
595  if (s->pic_state & PNG_IDAT) {
596  av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
597  return AVERROR_INVALIDDATA;
598  }
599 
600  if (s->hdr_state & PNG_IHDR) {
601  av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
602  return AVERROR_INVALIDDATA;
603  }
604 
605  s->width = s->cur_w = bytestream2_get_be32(gb);
606  s->height = s->cur_h = bytestream2_get_be32(gb);
607  if (av_image_check_size(s->width, s->height, 0, avctx)) {
608  s->cur_w = s->cur_h = s->width = s->height = 0;
609  av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
610  return AVERROR_INVALIDDATA;
611  }
612  s->bit_depth = bytestream2_get_byte(gb);
613  if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
614  s->bit_depth != 8 && s->bit_depth != 16) {
615  av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
616  goto error;
617  }
618  s->color_type = bytestream2_get_byte(gb);
619  s->compression_type = bytestream2_get_byte(gb);
620  if (s->compression_type) {
621  av_log(avctx, AV_LOG_ERROR, "Invalid compression method %d\n", s->compression_type);
622  goto error;
623  }
624  s->filter_type = bytestream2_get_byte(gb);
625  s->interlace_type = bytestream2_get_byte(gb);
626  s->hdr_state |= PNG_IHDR;
627  if (avctx->debug & FF_DEBUG_PICT_INFO)
628  av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
629  "compression_type=%d filter_type=%d interlace_type=%d\n",
630  s->width, s->height, s->bit_depth, s->color_type,
631  s->compression_type, s->filter_type, s->interlace_type);
632 
633  return 0;
634 error:
635  s->cur_w = s->cur_h = s->width = s->height = 0;
636  s->bit_depth = 8;
637  return AVERROR_INVALIDDATA;
638 }
639 
641  GetByteContext *gb)
642 {
643  if (s->pic_state & PNG_IDAT) {
644  av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
645  return AVERROR_INVALIDDATA;
646  }
647  avctx->sample_aspect_ratio.num = bytestream2_get_be32(gb);
648  avctx->sample_aspect_ratio.den = bytestream2_get_be32(gb);
649  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
650  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
651  bytestream2_skip(gb, 1); /* unit specifier */
652 
653  return 0;
654 }
655 
656 /*
657  * This populates AVCodecContext fields so it must be called before
658  * ff_thread_finish_setup() to avoid a race condition with respect to the
659  * generic copying of avctx fields.
660  */
662 {
663  PNGDecContext *s = avctx->priv_data;
664  int ret;
665 
666  if (s->have_cicp) {
667  if (s->cicp_primaries >= AVCOL_PRI_NB)
668  av_log(avctx, AV_LOG_WARNING, "unrecognized cICP primaries\n");
669  else
670  avctx->color_primaries = frame->color_primaries = s->cicp_primaries;
671  if (s->cicp_trc >= AVCOL_TRC_NB)
672  av_log(avctx, AV_LOG_WARNING, "unrecognized cICP transfer\n");
673  else
674  avctx->color_trc = frame->color_trc = s->cicp_trc;
675  if (s->cicp_range == 0) {
676  av_log(avctx, AV_LOG_WARNING, "tv-range cICP tag found. Colors may be wrong\n");
677  avctx->color_range = frame->color_range = AVCOL_RANGE_MPEG;
678  } else if (s->cicp_range != 1) {
679  /* we already printed a warning when parsing the cICP chunk */
680  avctx->color_range = frame->color_range = AVCOL_RANGE_UNSPECIFIED;
681  }
682  } else if (s->iccp_data) {
683  AVFrameSideData *sd;
685  s->iccp_data_len, &sd);
686  if (ret < 0)
687  return ret;
688  if (sd) {
689  memcpy(sd->data, s->iccp_data, s->iccp_data_len);
690  av_dict_set(&sd->metadata, "name", s->iccp_name, 0);
691  }
692  } else if (s->have_srgb) {
693  avctx->color_primaries = frame->color_primaries = AVCOL_PRI_BT709;
694  avctx->color_trc = frame->color_trc = AVCOL_TRC_IEC61966_2_1;
695  } else if (s->have_chrm) {
697  enum AVColorPrimaries prim;
698  desc.wp.x = av_make_q(s->white_point[0], 100000);
699  desc.wp.y = av_make_q(s->white_point[1], 100000);
700  desc.prim.r.x = av_make_q(s->display_primaries[0][0], 100000);
701  desc.prim.r.y = av_make_q(s->display_primaries[0][1], 100000);
702  desc.prim.g.x = av_make_q(s->display_primaries[1][0], 100000);
703  desc.prim.g.y = av_make_q(s->display_primaries[1][1], 100000);
704  desc.prim.b.x = av_make_q(s->display_primaries[2][0], 100000);
705  desc.prim.b.y = av_make_q(s->display_primaries[2][1], 100000);
707  if (prim != AVCOL_PRI_UNSPECIFIED)
708  avctx->color_primaries = frame->color_primaries = prim;
709  else
710  av_log(avctx, AV_LOG_WARNING, "unknown cHRM primaries\n");
711  }
712 
713  /* these chunks override gAMA */
714  if (s->iccp_data || s->have_srgb || s->have_cicp) {
715  av_dict_set(&s->frame_metadata, "gamma", NULL, 0);
716  } else if (s->gamma) {
717  /*
718  * These values are 100000/2.2, 100000/2.8, 100000/2.6, and
719  * 100000/1.0 respectively. 45455, 35714, and 38462, and 100000.
720  * There's a 0.001 gamma tolerance here in case of floating
721  * point issues when the PNG was written.
722  *
723  * None of the other enums have a pure gamma curve so it makes
724  * sense to leave those to sRGB and cICP.
725  */
726  if (s->gamma > 45355 && s->gamma < 45555)
727  avctx->color_trc = frame->color_trc = AVCOL_TRC_GAMMA22;
728  else if (s->gamma > 35614 && s->gamma < 35814)
729  avctx->color_trc = frame->color_trc = AVCOL_TRC_GAMMA28;
730  else if (s->gamma > 38362 && s->gamma < 38562)
731  avctx->color_trc = frame->color_trc = AVCOL_TRC_SMPTE428;
732  else if (s->gamma > 99900 && s->gamma < 100100)
733  avctx->color_trc = frame->color_trc = AVCOL_TRC_LINEAR;
734  }
735 
736  /* PNG only supports RGB */
737  avctx->colorspace = frame->colorspace = AVCOL_SPC_RGB;
738  if (!s->have_cicp || s->cicp_range == 1)
739  avctx->color_range = frame->color_range = AVCOL_RANGE_JPEG;
740 
741  /*
742  * tRNS sets alpha depth to full, so we ignore sBIT if set.
743  * As a result we must wait until now to set
744  * avctx->bits_per_raw_sample in case tRNS appears after sBIT
745  */
746  if (!s->has_trns && s->significant_bits > 0)
747  avctx->bits_per_raw_sample = s->significant_bits;
748 
749  if (s->have_clli) {
751 
752  ret = ff_decode_content_light_new(avctx, frame, &clli);
753  if (ret < 0)
754  return ret;
755 
756  if (clli) {
757  /*
758  * 0.0001 divisor value
759  * see: https://www.w3.org/TR/png-3/#cLLi-chunk
760  */
761  clli->MaxCLL = s->clli_max / 10000;
762  clli->MaxFALL = s->clli_avg / 10000;
763  }
764  }
765 
766  if (s->have_mdvc) {
768 
769  ret = ff_decode_mastering_display_new(avctx, frame, &mdvc);
770  if (ret < 0)
771  return ret;
772 
773  if (mdvc) {
774  mdvc->has_primaries = 1;
775  for (int i = 0; i < 3; i++) {
776  mdvc->display_primaries[i][0] = av_make_q(s->mdvc_primaries[i][0], 50000);
777  mdvc->display_primaries[i][1] = av_make_q(s->mdvc_primaries[i][1], 50000);
778  }
779  mdvc->white_point[0] = av_make_q(s->mdvc_white_point[0], 50000);
780  mdvc->white_point[1] = av_make_q(s->mdvc_white_point[1], 50000);
781  mdvc->has_luminance = 1;
782  mdvc->max_luminance = av_make_q(s->mdvc_max_lum, 10000);
783  mdvc->min_luminance = av_make_q(s->mdvc_min_lum, 10000);
784  }
785  }
786 
787  return 0;
788 }
789 
791  GetByteContext *gb, AVFrame *p)
792 {
793  int ret;
794  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
795 
796  if (!p)
797  return AVERROR_INVALIDDATA;
798  if (!(s->hdr_state & PNG_IHDR)) {
799  av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
800  return AVERROR_INVALIDDATA;
801  }
802  if (!(s->pic_state & PNG_IDAT)) {
803  /* init image info */
804  ret = ff_set_dimensions(avctx, s->width, s->height);
805  if (ret < 0)
806  return ret;
807 
808  s->channels = ff_png_get_nb_channels(s->color_type);
809  s->bits_per_pixel = s->bit_depth * s->channels;
810  s->bpp = (s->bits_per_pixel + 7) >> 3;
811  s->row_size = (s->cur_w * s->bits_per_pixel + 7) >> 3;
812 
813  if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
814  s->color_type == PNG_COLOR_TYPE_RGB) {
815  avctx->pix_fmt = AV_PIX_FMT_RGB24;
816  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
817  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
818  avctx->pix_fmt = AV_PIX_FMT_RGBA;
819  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
820  s->color_type == PNG_COLOR_TYPE_GRAY) {
821  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
822  } else if (s->bit_depth == 16 &&
823  s->color_type == PNG_COLOR_TYPE_GRAY) {
824  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
825  } else if (s->bit_depth == 16 &&
826  s->color_type == PNG_COLOR_TYPE_RGB) {
827  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
828  } else if (s->bit_depth == 16 &&
829  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
830  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
831  } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
832  s->color_type == PNG_COLOR_TYPE_PALETTE) {
834  } else if (s->bit_depth == 1 && s->bits_per_pixel == 1 && avctx->codec_id != AV_CODEC_ID_APNG) {
835  avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
836  } else if (s->bit_depth == 8 &&
837  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
838  avctx->pix_fmt = AV_PIX_FMT_YA8;
839  } else if (s->bit_depth == 16 &&
840  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
841  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
842  } else {
844  "Bit depth %d color type %d",
845  s->bit_depth, s->color_type);
846  return AVERROR_PATCHWELCOME;
847  }
848 
849  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
850  switch (avctx->pix_fmt) {
851  case AV_PIX_FMT_RGB24:
852  avctx->pix_fmt = AV_PIX_FMT_RGBA;
853  break;
854 
855  case AV_PIX_FMT_RGB48BE:
856  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
857  break;
858 
859  case AV_PIX_FMT_GRAY8:
860  avctx->pix_fmt = AV_PIX_FMT_YA8;
861  break;
862 
863  case AV_PIX_FMT_GRAY16BE:
864  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
865  break;
866 
867  default:
868  avpriv_request_sample(avctx, "bit depth %d "
869  "and color type %d with TRNS",
870  s->bit_depth, s->color_type);
871  return AVERROR_INVALIDDATA;
872  }
873 
874  s->bpp += byte_depth;
875  }
876 
877  ff_thread_release_ext_buffer(&s->picture);
878  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
879  /* We only need a buffer for the current picture. */
880  ret = ff_thread_get_buffer(avctx, p, 0);
881  if (ret < 0)
882  return ret;
883  } else if (s->dispose_op == APNG_DISPOSE_OP_BACKGROUND) {
884  /* We need a buffer for the current picture as well as
885  * a buffer for the reference to retain. */
886  ret = ff_thread_get_ext_buffer(avctx, &s->picture,
888  if (ret < 0)
889  return ret;
890  ret = ff_thread_get_buffer(avctx, p, 0);
891  if (ret < 0)
892  return ret;
893  } else {
894  /* The picture output this time and the reference to retain coincide. */
895  if ((ret = ff_thread_get_ext_buffer(avctx, &s->picture,
897  return ret;
898  ret = av_frame_ref(p, s->picture.f);
899  if (ret < 0)
900  return ret;
901  }
902 
904  p->flags |= AV_FRAME_FLAG_KEY;
905  p->flags |= AV_FRAME_FLAG_INTERLACED * !!s->interlace_type;
906 
907  if ((ret = populate_avctx_color_fields(avctx, p)) < 0)
908  return ret;
909  ff_thread_finish_setup(avctx);
910 
911  /* compute the compressed row size */
912  if (!s->interlace_type) {
913  s->crow_size = s->row_size + 1;
914  } else {
915  s->pass = 0;
916  s->pass_row_size = ff_png_pass_row_size(s->pass,
917  s->bits_per_pixel,
918  s->cur_w);
919  s->crow_size = s->pass_row_size + 1;
920  }
921  ff_dlog(avctx, "row_size=%d crow_size =%d\n",
922  s->row_size, s->crow_size);
923 
924  /* copy the palette if needed */
925  if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
926  memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
927  /* empty row is used if differencing to the first row */
928  av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
929  if (!s->last_row)
930  return AVERROR_INVALIDDATA;
931  if (s->interlace_type ||
932  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
933  av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
934  if (!s->tmp_row)
935  return AVERROR_INVALIDDATA;
936  }
937  /* compressed row */
938  av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
939  if (!s->buffer)
940  return AVERROR(ENOMEM);
941 
942  /* we want crow_buf+1 to be 16-byte aligned */
943  s->crow_buf = s->buffer + 15;
944  s->zstream.zstream.avail_out = s->crow_size;
945  s->zstream.zstream.next_out = s->crow_buf;
946  }
947 
948  s->pic_state |= PNG_IDAT;
949 
950  /* set image to non-transparent bpp while decompressing */
951  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
952  s->bpp -= byte_depth;
953 
954  ret = png_decode_idat(s, gb, p->data[0], p->linesize[0]);
955 
956  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
957  s->bpp += byte_depth;
958 
959  if (ret < 0)
960  return ret;
961 
962  return 0;
963 }
964 
966  GetByteContext *gb)
967 {
968  int length = bytestream2_get_bytes_left(gb);
969  int n, i, r, g, b;
970 
971  if ((length % 3) != 0 || length > 256 * 3)
972  return AVERROR_INVALIDDATA;
973  /* read the palette */
974  n = length / 3;
975  for (i = 0; i < n; i++) {
976  r = bytestream2_get_byte(gb);
977  g = bytestream2_get_byte(gb);
978  b = bytestream2_get_byte(gb);
979  s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
980  }
981  for (; i < 256; i++)
982  s->palette[i] = (0xFFU << 24);
983  s->hdr_state |= PNG_PLTE;
984 
985  return 0;
986 }
987 
989  GetByteContext *gb)
990 {
991  int length = bytestream2_get_bytes_left(gb);
992  int v, i;
993 
994  if (!(s->hdr_state & PNG_IHDR)) {
995  av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
996  return AVERROR_INVALIDDATA;
997  }
998 
999  if (s->pic_state & PNG_IDAT) {
1000  av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
1001  return AVERROR_INVALIDDATA;
1002  }
1003 
1004  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
1005  if (length > 256 || !(s->hdr_state & PNG_PLTE))
1006  return AVERROR_INVALIDDATA;
1007 
1008  for (i = 0; i < length; i++) {
1009  unsigned v = bytestream2_get_byte(gb);
1010  s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
1011  }
1012  } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
1013  if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
1014  (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
1015  s->bit_depth == 1)
1016  return AVERROR_INVALIDDATA;
1017 
1018  for (i = 0; i < length / 2; i++) {
1019  /* only use the least significant bits */
1020  v = av_mod_uintp2(bytestream2_get_be16(gb), s->bit_depth);
1021 
1022  if (s->bit_depth > 8)
1023  AV_WB16(&s->transparent_color_be[2 * i], v);
1024  else
1025  s->transparent_color_be[i] = v;
1026  }
1027  } else {
1028  return AVERROR_INVALIDDATA;
1029  }
1030 
1031  s->has_trns = 1;
1032 
1033  return 0;
1034 }
1035 
1037 {
1038  int ret, cnt = 0;
1039  AVBPrint bp;
1040 
1041  while ((s->iccp_name[cnt++] = bytestream2_get_byte(gb)) && cnt < 81);
1042  if (cnt > 80) {
1043  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
1045  goto fail;
1046  }
1047 
1048  if (bytestream2_get_byte(gb) != 0) {
1049  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
1051  goto fail;
1052  }
1053 
1054  if ((ret = decode_zbuf(&bp, gb->buffer, gb->buffer_end, s->avctx)) < 0)
1055  return ret;
1056 
1057  av_freep(&s->iccp_data);
1058  ret = av_bprint_finalize(&bp, (char **)&s->iccp_data);
1059  if (ret < 0)
1060  return ret;
1061  s->iccp_data_len = bp.len;
1062 
1063  return 0;
1064 fail:
1065  s->iccp_name[0] = 0;
1066  return ret;
1067 }
1068 
1070  GetByteContext *gb)
1071 {
1072  int bits = 0;
1073  int channels;
1074 
1075  if (!(s->hdr_state & PNG_IHDR)) {
1076  av_log(avctx, AV_LOG_ERROR, "sBIT before IHDR\n");
1077  return AVERROR_INVALIDDATA;
1078  }
1079 
1080  if (s->pic_state & PNG_IDAT) {
1081  av_log(avctx, AV_LOG_ERROR, "sBIT after IDAT\n");
1082  return AVERROR_INVALIDDATA;
1083  }
1084 
1085  channels = ff_png_get_nb_channels(s->color_type);
1086 
1088  return AVERROR_INVALIDDATA;
1089 
1090  for (int i = 0; i < channels; i++) {
1091  int b = bytestream2_get_byteu(gb);
1092  bits = FFMAX(b, bits);
1093  }
1094 
1095  if (bits < 0 || bits > s->bit_depth) {
1096  av_log(avctx, AV_LOG_ERROR, "Invalid significant bits: %d\n", bits);
1097  return AVERROR_INVALIDDATA;
1098  }
1099  s->significant_bits = bits;
1100 
1101  return 0;
1102 }
1103 
1105 {
1106  if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
1107  int i, j, k;
1108  uint8_t *pd = p->data[0];
1109  for (j = 0; j < s->height; j++) {
1110  i = s->width / 8;
1111  for (k = 7; k >= 1; k--)
1112  if ((s->width&7) >= k)
1113  pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
1114  for (i--; i >= 0; i--) {
1115  pd[8*i + 7]= pd[i] & 1;
1116  pd[8*i + 6]= (pd[i]>>1) & 1;
1117  pd[8*i + 5]= (pd[i]>>2) & 1;
1118  pd[8*i + 4]= (pd[i]>>3) & 1;
1119  pd[8*i + 3]= (pd[i]>>4) & 1;
1120  pd[8*i + 2]= (pd[i]>>5) & 1;
1121  pd[8*i + 1]= (pd[i]>>6) & 1;
1122  pd[8*i + 0]= pd[i]>>7;
1123  }
1124  pd += p->linesize[0];
1125  }
1126  } else if (s->bits_per_pixel == 2) {
1127  int i, j;
1128  uint8_t *pd = p->data[0];
1129  for (j = 0; j < s->height; j++) {
1130  i = s->width / 4;
1131  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
1132  if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
1133  if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
1134  if ((s->width&3) >= 1) pd[4*i + 0]= pd[i] >> 6;
1135  for (i--; i >= 0; i--) {
1136  pd[4*i + 3]= pd[i] & 3;
1137  pd[4*i + 2]= (pd[i]>>2) & 3;
1138  pd[4*i + 1]= (pd[i]>>4) & 3;
1139  pd[4*i + 0]= pd[i]>>6;
1140  }
1141  } else {
1142  if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
1143  if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
1144  if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6 )*0x55;
1145  for (i--; i >= 0; i--) {
1146  pd[4*i + 3]= ( pd[i] & 3)*0x55;
1147  pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
1148  pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
1149  pd[4*i + 0]= ( pd[i]>>6 )*0x55;
1150  }
1151  }
1152  pd += p->linesize[0];
1153  }
1154  } else if (s->bits_per_pixel == 4) {
1155  int i, j;
1156  uint8_t *pd = p->data[0];
1157  for (j = 0; j < s->height; j++) {
1158  i = s->width/2;
1159  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
1160  if (s->width&1) pd[2*i+0]= pd[i]>>4;
1161  for (i--; i >= 0; i--) {
1162  pd[2*i + 1] = pd[i] & 15;
1163  pd[2*i + 0] = pd[i] >> 4;
1164  }
1165  } else {
1166  if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
1167  for (i--; i >= 0; i--) {
1168  pd[2*i + 1] = (pd[i] & 15) * 0x11;
1169  pd[2*i + 0] = (pd[i] >> 4) * 0x11;
1170  }
1171  }
1172  pd += p->linesize[0];
1173  }
1174  }
1175 }
1176 
1178  GetByteContext *gb)
1179 {
1180  uint32_t sequence_number;
1181  int cur_w, cur_h, x_offset, y_offset, dispose_op, blend_op;
1182 
1184  return AVERROR_INVALIDDATA;
1185 
1186  if (!(s->hdr_state & PNG_IHDR)) {
1187  av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
1188  return AVERROR_INVALIDDATA;
1189  }
1190 
1191  if (s->pic_state & PNG_IDAT) {
1192  av_log(avctx, AV_LOG_ERROR, "fctl after IDAT\n");
1193  return AVERROR_INVALIDDATA;
1194  }
1195 
1196  sequence_number = bytestream2_get_be32(gb);
1197  cur_w = bytestream2_get_be32(gb);
1198  cur_h = bytestream2_get_be32(gb);
1199  x_offset = bytestream2_get_be32(gb);
1200  y_offset = bytestream2_get_be32(gb);
1201  bytestream2_skip(gb, 4); /* delay_num (2), delay_den (2) */
1202  dispose_op = bytestream2_get_byte(gb);
1203  blend_op = bytestream2_get_byte(gb);
1204 
1205  if (sequence_number == 0 &&
1206  (cur_w != s->width ||
1207  cur_h != s->height ||
1208  x_offset != 0 ||
1209  y_offset != 0) ||
1210  cur_w <= 0 || cur_h <= 0 ||
1211  x_offset < 0 || y_offset < 0 ||
1212  cur_w > s->width - x_offset|| cur_h > s->height - y_offset)
1213  return AVERROR_INVALIDDATA;
1214 
1215  if (blend_op != APNG_BLEND_OP_OVER && blend_op != APNG_BLEND_OP_SOURCE) {
1216  av_log(avctx, AV_LOG_ERROR, "Invalid blend_op %d\n", blend_op);
1217  return AVERROR_INVALIDDATA;
1218  }
1219 
1220  if ((sequence_number == 0 || !s->last_picture.f->data[0]) &&
1221  dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1222  // No previous frame to revert to for the first frame
1223  // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
1224  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
1225  }
1226 
1227  if (blend_op == APNG_BLEND_OP_OVER && !s->has_trns && (
1228  avctx->pix_fmt == AV_PIX_FMT_RGB24 ||
1229  avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1230  avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
1231  avctx->pix_fmt == AV_PIX_FMT_GRAY16BE ||
1232  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK
1233  )) {
1234  // APNG_BLEND_OP_OVER is the same as APNG_BLEND_OP_SOURCE when there is no alpha channel
1235  blend_op = APNG_BLEND_OP_SOURCE;
1236  }
1237 
1238  s->cur_w = cur_w;
1239  s->cur_h = cur_h;
1240  s->x_offset = x_offset;
1241  s->y_offset = y_offset;
1242  s->dispose_op = dispose_op;
1243  s->blend_op = blend_op;
1244 
1245  return 0;
1246 }
1247 
1249 {
1250  int i, j;
1251  uint8_t *pd = p->data[0];
1252  uint8_t *pd_last = s->last_picture.f->data[0];
1253  int ls = av_image_get_linesize(p->format, s->width, 0);
1254 
1255  ls = FFMIN(ls, s->width * s->bpp);
1256 
1257  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1258  for (j = 0; j < s->height; j++) {
1259  for (i = 0; i < ls; i++)
1260  pd[i] += pd_last[i];
1261  pd += p->linesize[0];
1262  pd_last += s->last_picture.f->linesize[0];
1263  }
1264 }
1265 
1266 // divide by 255 and round to nearest
1267 // apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
1268 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
1269 
1271  AVFrame *p)
1272 {
1273  uint8_t *dst = p->data[0];
1274  ptrdiff_t dst_stride = p->linesize[0];
1275  const uint8_t *src = s->last_picture.f->data[0];
1276  ptrdiff_t src_stride = s->last_picture.f->linesize[0];
1277  const int bpp = s->color_type == PNG_COLOR_TYPE_PALETTE ? 4 : s->bpp;
1278 
1279  size_t x, y;
1280 
1281  if (s->blend_op == APNG_BLEND_OP_OVER &&
1282  avctx->pix_fmt != AV_PIX_FMT_RGBA &&
1283  avctx->pix_fmt != AV_PIX_FMT_GRAY8A) {
1284  avpriv_request_sample(avctx, "Blending with pixel format %s",
1285  av_get_pix_fmt_name(avctx->pix_fmt));
1286  return AVERROR_PATCHWELCOME;
1287  }
1288 
1289  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1290 
1291  // copy unchanged rectangles from the last frame
1292  for (y = 0; y < s->y_offset; y++)
1293  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * bpp);
1294  for (y = s->y_offset; y < s->y_offset + s->cur_h; y++) {
1295  memcpy(dst + y * dst_stride, src + y * src_stride, s->x_offset * bpp);
1296  memcpy(dst + y * dst_stride + (s->x_offset + s->cur_w) * bpp,
1297  src + y * src_stride + (s->x_offset + s->cur_w) * bpp,
1298  (p->width - s->cur_w - s->x_offset) * bpp);
1299  }
1300  for (y = s->y_offset + s->cur_h; y < p->height; y++)
1301  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * bpp);
1302 
1303  if (s->blend_op == APNG_BLEND_OP_OVER) {
1304  // Perform blending
1305  for (y = s->y_offset; y < s->y_offset + s->cur_h; ++y) {
1306  uint8_t *foreground = dst + dst_stride * y + bpp * s->x_offset;
1307  const uint8_t *background = src + src_stride * y + bpp * s->x_offset;
1308  for (x = s->x_offset; x < s->x_offset + s->cur_w; ++x, foreground += bpp, background += bpp) {
1309  size_t b;
1310  uint8_t foreground_alpha, background_alpha, output_alpha;
1311  uint8_t output[10];
1312 
1313  // Since we might be blending alpha onto alpha, we use the following equations:
1314  // output_alpha = foreground_alpha + (1 - foreground_alpha) * background_alpha
1315  // output = (foreground_alpha * foreground + (1 - foreground_alpha) * background_alpha * background) / output_alpha
1316 
1317  switch (avctx->pix_fmt) {
1318  case AV_PIX_FMT_RGBA:
1319  foreground_alpha = foreground[3];
1320  background_alpha = background[3];
1321  break;
1322 
1323  case AV_PIX_FMT_GRAY8A:
1324  foreground_alpha = foreground[1];
1325  background_alpha = background[1];
1326  break;
1327  }
1328 
1329  if (foreground_alpha == 255)
1330  continue;
1331 
1332  if (foreground_alpha == 0) {
1333  memcpy(foreground, background, bpp);
1334  continue;
1335  }
1336 
1337  output_alpha = foreground_alpha + FAST_DIV255((255 - foreground_alpha) * background_alpha);
1338 
1339  av_assert0(bpp <= 10);
1340 
1341  for (b = 0; b < bpp - 1; ++b) {
1342  if (output_alpha == 0) {
1343  output[b] = 0;
1344  } else if (background_alpha == 255) {
1345  output[b] = FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1346  } else {
1347  output[b] = (255 * foreground_alpha * foreground[b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1348  }
1349  }
1350  output[b] = output_alpha;
1351  memcpy(foreground, output, bpp);
1352  }
1353  }
1354  }
1355 
1356  return 0;
1357 }
1358 
1360 {
1361  // need to reset a rectangle to black
1362  av_unused int ret = av_frame_copy(s->picture.f, p);
1363  const int bpp = s->color_type == PNG_COLOR_TYPE_PALETTE ? 4 : s->bpp;
1364  const ptrdiff_t dst_stride = s->picture.f->linesize[0];
1365  uint8_t *dst = s->picture.f->data[0] + s->y_offset * dst_stride + bpp * s->x_offset;
1366 
1367  av_assert1(ret >= 0);
1368 
1369  for (size_t y = 0; y < s->cur_h; y++) {
1370  memset(dst, 0, bpp * s->cur_w);
1371  dst += dst_stride;
1372  }
1373 }
1374 
1376  AVFrame *p, const AVPacket *avpkt)
1377 {
1378  const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1379  uint32_t tag, length;
1380  int decode_next_dat = 0;
1381  int i, ret;
1382 
1383  for (;;) {
1384  GetByteContext gb_chunk;
1385 
1386  length = bytestream2_get_bytes_left(&s->gb);
1387  if (length <= 0) {
1388 
1389  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1390  avctx->skip_frame == AVDISCARD_ALL) {
1391  return 0;
1392  }
1393 
1394  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
1395  if (!(s->pic_state & PNG_IDAT))
1396  return 0;
1397  else
1398  goto exit_loop;
1399  }
1400  av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
1401  if ( s->pic_state & PNG_ALLIMAGE
1403  goto exit_loop;
1405  goto fail;
1406  }
1407 
1408  length = bytestream2_get_be32(&s->gb);
1409  if (length > 0x7fffffff || length + 8 > bytestream2_get_bytes_left(&s->gb)) {
1410  av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
1412  goto fail;
1413  }
1414  if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_IGNORE_ERR)) {
1415  uint32_t crc_sig = AV_RB32(s->gb.buffer + length + 4);
1416  uint32_t crc_cal = ~av_crc(crc_tab, UINT32_MAX, s->gb.buffer, length + 4);
1417  if (crc_sig ^ crc_cal) {
1418  av_log(avctx, AV_LOG_ERROR, "CRC mismatch in chunk");
1419  if (avctx->err_recognition & AV_EF_EXPLODE) {
1420  av_log(avctx, AV_LOG_ERROR, ", quitting\n");
1422  goto fail;
1423  }
1424  av_log(avctx, AV_LOG_ERROR, ", skipping\n");
1425  bytestream2_skip(&s->gb, length + 8); /* tag */
1426  continue;
1427  }
1428  }
1429  tag = bytestream2_get_le32(&s->gb);
1430  if (avctx->debug & FF_DEBUG_STARTCODE)
1431  av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
1432  av_fourcc2str(tag), length);
1433 
1434  bytestream2_init(&gb_chunk, s->gb.buffer, length);
1435  bytestream2_skip(&s->gb, length + 4);
1436 
1437  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1438  avctx->skip_frame == AVDISCARD_ALL) {
1439  switch(tag) {
1440  case MKTAG('I', 'H', 'D', 'R'):
1441  case MKTAG('p', 'H', 'Y', 's'):
1442  case MKTAG('t', 'E', 'X', 't'):
1443  case MKTAG('I', 'D', 'A', 'T'):
1444  case MKTAG('t', 'R', 'N', 'S'):
1445  case MKTAG('s', 'R', 'G', 'B'):
1446  case MKTAG('c', 'I', 'C', 'P'):
1447  case MKTAG('c', 'H', 'R', 'M'):
1448  case MKTAG('g', 'A', 'M', 'A'):
1449  break;
1450  default:
1451  continue;
1452  }
1453  }
1454 
1455  switch (tag) {
1456  case MKTAG('I', 'H', 'D', 'R'):
1457  if ((ret = decode_ihdr_chunk(avctx, s, &gb_chunk)) < 0)
1458  goto fail;
1459  break;
1460  case MKTAG('p', 'H', 'Y', 's'):
1461  if ((ret = decode_phys_chunk(avctx, s, &gb_chunk)) < 0)
1462  goto fail;
1463  break;
1464  case MKTAG('f', 'c', 'T', 'L'):
1465  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1466  continue;
1467  if ((ret = decode_fctl_chunk(avctx, s, &gb_chunk)) < 0)
1468  goto fail;
1469  decode_next_dat = 1;
1470  break;
1471  case MKTAG('f', 'd', 'A', 'T'):
1472  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1473  continue;
1474  if (!decode_next_dat || bytestream2_get_bytes_left(&gb_chunk) < 4) {
1476  goto fail;
1477  }
1478  bytestream2_get_be32(&gb_chunk);
1479  /* fallthrough */
1480  case MKTAG('I', 'D', 'A', 'T'):
1481  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && !decode_next_dat)
1482  continue;
1483  if ((ret = decode_idat_chunk(avctx, s, &gb_chunk, p)) < 0)
1484  goto fail;
1485  break;
1486  case MKTAG('P', 'L', 'T', 'E'):
1487  decode_plte_chunk(avctx, s, &gb_chunk);
1488  break;
1489  case MKTAG('t', 'R', 'N', 'S'):
1490  decode_trns_chunk(avctx, s, &gb_chunk);
1491  break;
1492  case MKTAG('t', 'E', 'X', 't'):
1493  if (decode_text_chunk(s, &gb_chunk, 0) < 0)
1494  av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
1495  break;
1496  case MKTAG('z', 'T', 'X', 't'):
1497  if (decode_text_chunk(s, &gb_chunk, 1) < 0)
1498  av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
1499  break;
1500  case MKTAG('s', 'T', 'E', 'R'): {
1501  int mode = bytestream2_get_byte(&gb_chunk);
1502 
1503  if (mode == 0 || mode == 1) {
1504  s->stereo_mode = mode;
1505  } else {
1506  av_log(avctx, AV_LOG_WARNING,
1507  "Unknown value in sTER chunk (%d)\n", mode);
1508  }
1509  break;
1510  }
1511  case MKTAG('c', 'I', 'C', 'P'):
1512  s->cicp_primaries = bytestream2_get_byte(&gb_chunk);
1513  s->cicp_trc = bytestream2_get_byte(&gb_chunk);
1514  if (bytestream2_get_byte(&gb_chunk) != 0)
1515  av_log(avctx, AV_LOG_WARNING, "nonzero cICP matrix\n");
1516  s->cicp_range = bytestream2_get_byte(&gb_chunk);
1517  if (s->cicp_range != 0 && s->cicp_range != 1)
1518  av_log(avctx, AV_LOG_WARNING, "invalid cICP range: %d\n", s->cicp_range);
1519  s->have_cicp = 1;
1520  break;
1521  case MKTAG('s', 'R', 'G', 'B'):
1522  /* skip rendering intent byte */
1523  bytestream2_skip(&gb_chunk, 1);
1524  s->have_srgb = 1;
1525  break;
1526  case MKTAG('i', 'C', 'C', 'P'): {
1527  if ((ret = decode_iccp_chunk(s, &gb_chunk)) < 0)
1528  goto fail;
1529  break;
1530  }
1531  case MKTAG('c', 'H', 'R', 'M'): {
1532  s->have_chrm = 1;
1533 
1534  s->white_point[0] = bytestream2_get_be32(&gb_chunk);
1535  s->white_point[1] = bytestream2_get_be32(&gb_chunk);
1536 
1537  /* RGB Primaries */
1538  for (i = 0; i < 3; i++) {
1539  s->display_primaries[i][0] = bytestream2_get_be32(&gb_chunk);
1540  s->display_primaries[i][1] = bytestream2_get_be32(&gb_chunk);
1541  }
1542 
1543  break;
1544  }
1545  case MKTAG('s', 'B', 'I', 'T'):
1546  if ((ret = decode_sbit_chunk(avctx, s, &gb_chunk)) < 0)
1547  goto fail;
1548  break;
1549  case MKTAG('g', 'A', 'M', 'A'): {
1550  AVBPrint bp;
1551  char *gamma_str;
1552  s->gamma = bytestream2_get_be32(&gb_chunk);
1553 
1555  av_bprintf(&bp, "%i/%i", s->gamma, 100000);
1556  ret = av_bprint_finalize(&bp, &gamma_str);
1557  if (ret < 0)
1558  return ret;
1559 
1560  av_dict_set(&s->frame_metadata, "gamma", gamma_str, AV_DICT_DONT_STRDUP_VAL);
1561 
1562  break;
1563  }
1564  case MKTAG('c', 'L', 'L', 'i'):
1565  if (bytestream2_get_bytes_left(&gb_chunk) != 8) {
1566  av_log(avctx, AV_LOG_WARNING, "Invalid cLLi chunk size: %d\n", bytestream2_get_bytes_left(&gb_chunk));
1567  break;
1568  }
1569  s->have_clli = 1;
1570  s->clli_max = bytestream2_get_be32u(&gb_chunk);
1571  s->clli_avg = bytestream2_get_be32u(&gb_chunk);
1572  break;
1573  case MKTAG('m', 'D', 'V', 'c'):
1574  if (bytestream2_get_bytes_left(&gb_chunk) != 24) {
1575  av_log(avctx, AV_LOG_WARNING, "Invalid mDVc chunk size: %d\n", bytestream2_get_bytes_left(&gb_chunk));
1576  break;
1577  }
1578  s->have_mdvc = 1;
1579  for (int i = 0; i < 3; i++) {
1580  s->mdvc_primaries[i][0] = bytestream2_get_be16u(&gb_chunk);
1581  s->mdvc_primaries[i][1] = bytestream2_get_be16u(&gb_chunk);
1582  }
1583  s->mdvc_white_point[0] = bytestream2_get_be16u(&gb_chunk);
1584  s->mdvc_white_point[1] = bytestream2_get_be16u(&gb_chunk);
1585  s->mdvc_max_lum = bytestream2_get_be32u(&gb_chunk);
1586  s->mdvc_min_lum = bytestream2_get_be32u(&gb_chunk);
1587  break;
1588  case MKTAG('I', 'E', 'N', 'D'):
1589  if (!(s->pic_state & PNG_ALLIMAGE))
1590  av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
1591  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1593  goto fail;
1594  }
1595  goto exit_loop;
1596  }
1597  }
1598 exit_loop:
1599 
1600  if (!p)
1601  return AVERROR_INVALIDDATA;
1602 
1603  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1604  avctx->skip_frame == AVDISCARD_ALL) {
1605  return 0;
1606  }
1607 
1610  goto fail;
1611  }
1612 
1613  if (s->bits_per_pixel <= 4)
1614  handle_small_bpp(s, p);
1615 
1616  if (s->color_type == PNG_COLOR_TYPE_PALETTE && avctx->codec_id == AV_CODEC_ID_APNG) {
1617  for (int y = 0; y < s->height; y++) {
1618  uint8_t *row = &p->data[0][p->linesize[0] * y];
1619 
1620  for (int x = s->width - 1; x >= 0; x--) {
1621  const uint8_t idx = row[x];
1622 
1623  row[4*x+2] = s->palette[idx] & 0xFF;
1624  row[4*x+1] = (s->palette[idx] >> 8 ) & 0xFF;
1625  row[4*x+0] = (s->palette[idx] >> 16) & 0xFF;
1626  row[4*x+3] = s->palette[idx] >> 24;
1627  }
1628  }
1629  }
1630 
1631  /* apply transparency if needed */
1632  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
1633  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
1634  size_t raw_bpp = s->bpp - byte_depth;
1635  ptrdiff_t x, y;
1636 
1637  av_assert0(s->bit_depth > 1);
1638 
1639  for (y = 0; y < s->height; ++y) {
1640  uint8_t *row = &p->data[0][p->linesize[0] * y];
1641 
1642  if (s->bpp == 2 && byte_depth == 1) {
1643  uint8_t *pixel = &row[2 * s->width - 1];
1644  uint8_t *rowp = &row[1 * s->width - 1];
1645  int tcolor = s->transparent_color_be[0];
1646  for (x = s->width; x > 0; --x) {
1647  *pixel-- = *rowp == tcolor ? 0 : 0xff;
1648  *pixel-- = *rowp--;
1649  }
1650  } else if (s->bpp == 4 && byte_depth == 1) {
1651  uint8_t *pixel = &row[4 * s->width - 1];
1652  uint8_t *rowp = &row[3 * s->width - 1];
1653  int tcolor = AV_RL24(s->transparent_color_be);
1654  for (x = s->width; x > 0; --x) {
1655  *pixel-- = AV_RL24(rowp-2) == tcolor ? 0 : 0xff;
1656  *pixel-- = *rowp--;
1657  *pixel-- = *rowp--;
1658  *pixel-- = *rowp--;
1659  }
1660  } else {
1661  /* since we're updating in-place, we have to go from right to left */
1662  for (x = s->width; x > 0; --x) {
1663  uint8_t *pixel = &row[s->bpp * (x - 1)];
1664  memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1665 
1666  if (!memcmp(pixel, s->transparent_color_be, raw_bpp)) {
1667  memset(&pixel[raw_bpp], 0, byte_depth);
1668  } else {
1669  memset(&pixel[raw_bpp], 0xff, byte_depth);
1670  }
1671  }
1672  }
1673  }
1674  }
1675 
1676  /* handle P-frames only if a predecessor frame is available */
1677  if (s->last_picture.f->data[0]) {
1678  if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
1679  && s->last_picture.f->width == p->width
1680  && s->last_picture.f->height== p->height
1681  && s->last_picture.f->format== p->format
1682  ) {
1683  if (CONFIG_PNG_DECODER && avctx->codec_id != AV_CODEC_ID_APNG)
1684  handle_p_frame_png(s, p);
1685  else if (CONFIG_APNG_DECODER &&
1686  avctx->codec_id == AV_CODEC_ID_APNG &&
1687  (ret = handle_p_frame_apng(avctx, s, p)) < 0)
1688  goto fail;
1689  }
1690  }
1691  if (CONFIG_APNG_DECODER && s->dispose_op == APNG_DISPOSE_OP_BACKGROUND)
1693 
1694  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1695 
1696  return 0;
1697 
1698 fail:
1699  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1700  return ret;
1701 }
1702 
1704 {
1705  av_freep(&s->iccp_data);
1706  s->iccp_data_len = 0;
1707  s->iccp_name[0] = 0;
1708 
1709  s->stereo_mode = -1;
1710 
1711  s->have_chrm = 0;
1712  s->have_srgb = 0;
1713  s->have_cicp = 0;
1714 
1715  av_dict_free(&s->frame_metadata);
1716 }
1717 
1719 {
1720  int ret;
1721 
1722  if (s->stereo_mode >= 0) {
1724  if (!stereo3d) {
1725  ret = AVERROR(ENOMEM);
1726  goto fail;
1727  }
1728 
1729  stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1730  stereo3d->flags = s->stereo_mode ? 0 : AV_STEREO3D_FLAG_INVERT;
1731  }
1732 
1733  FFSWAP(AVDictionary*, f->metadata, s->frame_metadata);
1734 
1735  return 0;
1736 fail:
1737  av_frame_unref(f);
1738  return ret;
1739 }
1740 
1741 #if CONFIG_PNG_DECODER
1742 static int decode_frame_png(AVCodecContext *avctx, AVFrame *p,
1743  int *got_frame, AVPacket *avpkt)
1744 {
1745  PNGDecContext *const s = avctx->priv_data;
1746  const uint8_t *buf = avpkt->data;
1747  int buf_size = avpkt->size;
1748  int64_t sig;
1749  int ret;
1750 
1752 
1753  bytestream2_init(&s->gb, buf, buf_size);
1754 
1755  /* check signature */
1756  sig = bytestream2_get_be64(&s->gb);
1757  if (sig != PNGSIG &&
1758  sig != MNGSIG) {
1759  av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature 0x%08"PRIX64".\n", sig);
1760  return AVERROR_INVALIDDATA;
1761  }
1762 
1763  s->y = s->has_trns = 0;
1764  s->hdr_state = 0;
1765  s->pic_state = 0;
1766 
1767  /* Reset z_stream */
1768  ret = inflateReset(&s->zstream.zstream);
1769  if (ret != Z_OK)
1770  return AVERROR_EXTERNAL;
1771 
1772  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1773  goto the_end;
1774 
1775  if (avctx->skip_frame == AVDISCARD_ALL) {
1776  *got_frame = 0;
1777  ret = bytestream2_tell(&s->gb);
1778  goto the_end;
1779  }
1780 
1781  ret = output_frame(s, p);
1782  if (ret < 0)
1783  goto the_end;
1784 
1785  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1786  ff_thread_release_ext_buffer(&s->last_picture);
1787  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1788  }
1789 
1790  *got_frame = 1;
1791 
1792  ret = bytestream2_tell(&s->gb);
1793 the_end:
1794  s->crow_buf = NULL;
1795  return ret;
1796 }
1797 #endif
1798 
1799 #if CONFIG_APNG_DECODER
1800 static int decode_frame_apng(AVCodecContext *avctx, AVFrame *p,
1801  int *got_frame, AVPacket *avpkt)
1802 {
1803  PNGDecContext *const s = avctx->priv_data;
1804  int ret;
1805 
1807 
1808  if (!(s->hdr_state & PNG_IHDR)) {
1809  if (!avctx->extradata_size)
1810  return AVERROR_INVALIDDATA;
1811 
1812  if ((ret = inflateReset(&s->zstream.zstream)) != Z_OK)
1813  return AVERROR_EXTERNAL;
1814  bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
1815  if ((ret = decode_frame_common(avctx, s, NULL, avpkt)) < 0)
1816  return ret;
1817  }
1818 
1819  /* reset state for a new frame */
1820  if ((ret = inflateReset(&s->zstream.zstream)) != Z_OK)
1821  return AVERROR_EXTERNAL;
1822  s->y = 0;
1823  s->pic_state = 0;
1824  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1825  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1826  return ret;
1827 
1828  if (!(s->pic_state & PNG_ALLIMAGE))
1829  av_log(avctx, AV_LOG_WARNING, "Frame did not contain a complete image\n");
1830  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT)))
1831  return AVERROR_INVALIDDATA;
1832 
1833  ret = output_frame(s, p);
1834  if (ret < 0)
1835  return ret;
1836 
1837  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1838  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1839  ff_thread_release_ext_buffer(&s->picture);
1840  } else {
1841  ff_thread_release_ext_buffer(&s->last_picture);
1842  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1843  }
1844  }
1845 
1846  *got_frame = 1;
1847  return bytestream2_tell(&s->gb);
1848 }
1849 #endif
1850 
1851 #if HAVE_THREADS
1852 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1853 {
1854  PNGDecContext *psrc = src->priv_data;
1855  PNGDecContext *pdst = dst->priv_data;
1856  ThreadFrame *src_frame = NULL;
1857  int ret;
1858 
1859  if (dst == src)
1860  return 0;
1861 
1862  if (CONFIG_APNG_DECODER && dst->codec_id == AV_CODEC_ID_APNG) {
1863 
1864  pdst->width = psrc->width;
1865  pdst->height = psrc->height;
1866  pdst->bit_depth = psrc->bit_depth;
1867  pdst->color_type = psrc->color_type;
1868  pdst->compression_type = psrc->compression_type;
1869  pdst->interlace_type = psrc->interlace_type;
1870  pdst->filter_type = psrc->filter_type;
1871  pdst->has_trns = psrc->has_trns;
1872  memcpy(pdst->transparent_color_be, psrc->transparent_color_be, sizeof(pdst->transparent_color_be));
1873 
1874  memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
1875 
1876  pdst->hdr_state |= psrc->hdr_state;
1877  }
1878 
1879  src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ?
1880  &psrc->last_picture : &psrc->picture;
1881 
1883  if (src_frame && src_frame->f->data[0]) {
1884  ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
1885  if (ret < 0)
1886  return ret;
1887  }
1888 
1889  return 0;
1890 }
1891 #endif
1892 
1894 {
1895  PNGDecContext *s = avctx->priv_data;
1896 
1897  s->avctx = avctx;
1898  s->last_picture.f = av_frame_alloc();
1899  s->picture.f = av_frame_alloc();
1900  if (!s->last_picture.f || !s->picture.f)
1901  return AVERROR(ENOMEM);
1902 
1903  ff_pngdsp_init(&s->dsp);
1904 
1905  return ff_inflate_init(&s->zstream, avctx);
1906 }
1907 
1909 {
1910  PNGDecContext *s = avctx->priv_data;
1911 
1912  ff_thread_release_ext_buffer(&s->last_picture);
1913  av_frame_free(&s->last_picture.f);
1914  ff_thread_release_ext_buffer(&s->picture);
1915  av_frame_free(&s->picture.f);
1916  av_freep(&s->buffer);
1917  s->buffer_size = 0;
1918  av_freep(&s->last_row);
1919  s->last_row_size = 0;
1920  av_freep(&s->tmp_row);
1921  s->tmp_row_size = 0;
1922 
1923  av_freep(&s->iccp_data);
1924  av_dict_free(&s->frame_metadata);
1925  ff_inflate_end(&s->zstream);
1926 
1927  return 0;
1928 }
1929 
1930 #if CONFIG_APNG_DECODER
1931 const FFCodec ff_apng_decoder = {
1932  .p.name = "apng",
1933  CODEC_LONG_NAME("APNG (Animated Portable Network Graphics) image"),
1934  .p.type = AVMEDIA_TYPE_VIDEO,
1935  .p.id = AV_CODEC_ID_APNG,
1936  .priv_data_size = sizeof(PNGDecContext),
1937  .init = png_dec_init,
1938  .close = png_dec_end,
1939  FF_CODEC_DECODE_CB(decode_frame_apng),
1941  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1942  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1945 };
1946 #endif
1947 
1948 #if CONFIG_PNG_DECODER
1949 const FFCodec ff_png_decoder = {
1950  .p.name = "png",
1951  CODEC_LONG_NAME("PNG (Portable Network Graphics) image"),
1952  .p.type = AVMEDIA_TYPE_VIDEO,
1953  .p.id = AV_CODEC_ID_PNG,
1954  .priv_data_size = sizeof(PNGDecContext),
1955  .init = png_dec_init,
1956  .close = png_dec_end,
1957  FF_CODEC_DECODE_CB(decode_frame_png),
1959  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1960  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
1963 };
1964 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
PNG_PLTE
@ PNG_PLTE
Definition: pngdec.c:53
PNGDSPContext
Definition: pngdsp.h:27
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
PNGDecContext::clli_max
uint32_t clli_max
Definition: pngdec.c:87
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
clear_frame_metadata
static void clear_frame_metadata(PNGDecContext *s)
Definition: pngdec.c:1703
ff_add_png_paeth_prediction
void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)
Definition: pngdec.c:217
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
PNGDecContext::have_srgb
int have_srgb
Definition: pngdec.c:81
PNGDecContext::cicp_range
enum AVColorRange cicp_range
Definition: pngdec.c:85
r
const char * r
Definition: vf_curves.c:127
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
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:580
out
FILE * out
Definition: movenc.c:55
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
GetByteContext
Definition: bytestream.h:33
PNG_ALLIMAGE
@ PNG_ALLIMAGE
Definition: pngdec.c:58
AVColorPrimariesDesc
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition: csp.h:78
AVCRC
uint32_t AVCRC
Definition: crc.h:46
PNGDecContext::last_row_size
unsigned int last_row_size
Definition: pngdec.c:116
APNG_FCTL_CHUNK_SIZE
#define APNG_FCTL_CHUNK_SIZE
Definition: apng.h:42
decode_phys_chunk
static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:640
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:589
PNGDecContext::bit_depth
int bit_depth
Definition: pngdec.c:101
ff_png_get_nb_channels
int ff_png_get_nb_channels(int color_type)
Definition: png.c:41
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
PNGDSPContext::add_paeth_prediction
void(* add_paeth_prediction)(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)
Definition: pngdsp.h:33
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
rational.h
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
PNGDecContext::crow_size
int crow_size
Definition: pngdec.c:122
av_unused
#define av_unused
Definition: attributes.h:131
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:126
decode_text_chunk
static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
Definition: pngdec.c:542
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
APNG_BLEND_OP_OVER
@ APNG_BLEND_OP_OVER
Definition: apng.h:38
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:602
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVFrame::width
int width
Definition: frame.h:447
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
AVPacket::data
uint8_t * data
Definition: packet.h:524
PNGDecContext::have_clli
int have_clli
Definition: pngdec.c:86
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:148
PNGDecContext::mdvc_max_lum
uint32_t mdvc_max_lum
Definition: pngdec.c:92
FFCodec
Definition: codec_internal.h:127
PNGDecContext::row_size
int row_size
Definition: pngdec.c:123
FFZStream::zstream
z_stream zstream
Definition: zlib_wrapper.h:28
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:610
PNGDecContext::width
int width
Definition: pngdec.c:97
AVDictionary
Definition: dict.c:34
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:647
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:555
AV_CODEC_ID_APNG
@ AV_CODEC_ID_APNG
Definition: codec_id.h:265
PNGDecContext::tmp_row_size
unsigned int tmp_row_size
Definition: pngdec.c:118
PNGDecContext::color_type
int color_type
Definition: pngdec.c:102
PNGDecContext::cur_h
int cur_h
Definition: pngdec.c:98
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:94
PNGDecContext::bits_per_pixel
int bits_per_pixel
Definition: pngdec.c:107
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
thread.h
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
PNGDecContext::gamma
int gamma
Definition: pngdec.c:80
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1397
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in FFCodec caps_internal and use ff_thread_get_buffer() to allocate frames. Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
NB_PASSES
#define NB_PASSES
Definition: png.h:47
PNGDecContext::blend_op
uint8_t blend_op
Definition: pngdec.c:100
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
crc.h
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:104
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FAST_DIV255
#define FAST_DIV255(x)
Definition: pngdec.c:1268
PNGImageState
PNGImageState
Definition: pngdec.c:56
PNG_FILTER_TYPE_LOCO
#define PNG_FILTER_TYPE_LOCO
Definition: png.h:39
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
PNGDecContext::have_mdvc
int have_mdvc
Definition: pngdec.c:89
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:594
PNGDecContext::pass_row_size
int pass_row_size
Definition: pngdec.c:124
ff_png_pass_row_size
int ff_png_pass_row_size(int pass, int bits_per_pixel, int width)
Definition: png.c:54
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1819
fail
#define fail()
Definition: checkasm.h:179
inflate
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:194
png_dec_end
static av_cold int png_dec_end(AVCodecContext *avctx)
Definition: pngdec.c:1908
OP_AVG
#define OP_AVG(x, s, l)
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:586
PNGDecContext::pic_state
enum PNGImageState pic_state
Definition: pngdec.c:96
decode_idat_chunk
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb, AVFrame *p)
Definition: pngdec.c:790
png_pass_dsp_ymask
static const uint8_t png_pass_dsp_ymask[NB_PASSES]
Definition: pngdec.c:135
AVRational::num
int num
Numerator.
Definition: rational.h:59
PNG_COLOR_TYPE_RGB_ALPHA
#define PNG_COLOR_TYPE_RGB_ALPHA
Definition: png.h:36
PNGDecContext::crow_buf
uint8_t * crow_buf
Definition: pngdec.c:114
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:585
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
PNGDecContext::last_row
uint8_t * last_row
Definition: pngdec.c:115
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
PNGDecContext::height
int height
Definition: pngdec.c:97
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
pngdsp.h
zlib_wrapper.h
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:626
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:573
PNGDecContext::have_cicp
int have_cicp
Definition: pngdec.c:82
YUV2RGB
#define YUV2RGB(NAME, TYPE)
Definition: pngdec.c:340
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
stereo3d.h
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
PNGDecContext::tmp_row
uint8_t * tmp_row
Definition: pngdec.c:117
s
#define s(width, name)
Definition: cbs_vp9.c:198
PNGDecContext::clli_avg
uint32_t clli_avg
Definition: pngdec.c:88
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:573
ff_apng_decoder
const FFCodec ff_apng_decoder
PNGDecContext::y_offset
int y_offset
Definition: pngdec.c:99
PNGDecContext::palette
uint32_t palette[256]
Definition: pngdec.c:113
g
const char * g
Definition: vf_curves.c:128
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
APNG_DISPOSE_OP_PREVIOUS
@ APNG_DISPOSE_OP_PREVIOUS
Definition: apng.h:33
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
PNG_COLOR_TYPE_RGB
#define PNG_COLOR_TYPE_RGB
Definition: png.h:35
ff_png_decoder
const FFCodec ff_png_decoder
bits
uint8_t bits
Definition: vp3data.h:128
AV_EF_IGNORE_ERR
#define AV_EF_IGNORE_ERR
ignore errors and continue
Definition: defs.h:53
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
PNGDecContext::hdr_state
enum PNGHeaderState hdr_state
Definition: pngdec.c:95
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
PNGDecContext::iccp_data
uint8_t * iccp_data
Definition: pngdec.c:72
channels
channels
Definition: aptx.h:31
decode.h
percent_missing
static int percent_missing(PNGDecContext *s)
Definition: pngdec.c:354
av_csp_primaries_id_from_desc
enum AVColorPrimaries av_csp_primaries_id_from_desc(const AVColorPrimariesDesc *prm)
Detects which enum AVColorPrimaries constant corresponds to the given complete gamut description.
Definition: csp.c:110
APNG_DISPOSE_OP_BACKGROUND
@ APNG_DISPOSE_OP_BACKGROUND
Definition: apng.h:32
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
ff_decode_mastering_display_new
int ff_decode_mastering_display_new(const AVCodecContext *avctx, AVFrame *frame, AVMasteringDisplayMetadata **mdm)
Wrapper around av_mastering_display_metadata_create_side_data(), which rejects side data overridden b...
Definition: decode.c:1883
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:850
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:182
AV_CODEC_ID_PNG
@ AV_CODEC_ID_PNG
Definition: codec_id.h:113
if
if(ret)
Definition: filter_design.txt:179
PNGDecContext
Definition: pngdec.c:61
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
threadframe.h
AV_PIX_FMT_GRAY8A
@ AV_PIX_FMT_GRAY8A
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:143
PNGDecContext::cicp_primaries
enum AVColorPrimaries cicp_primaries
Definition: pngdec.c:83
NULL
#define NULL
Definition: coverity.c:32
PNGDecContext::filter_type
int filter_type
Definition: pngdec.c:105
png_decode_idat
static int png_decode_idat(PNGDecContext *s, GetByteContext *gb, uint8_t *dst, ptrdiff_t dst_stride)
Definition: pngdec.c:445
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
png_dec_init
static av_cold int png_dec_init(AVCodecContext *avctx)
Definition: pngdec.c:1893
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
apng.h
pixel
uint8_t pixel
Definition: tiny_ssim.c:41
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:403
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
PNGDecContext::mdvc_min_lum
uint32_t mdvc_min_lum
Definition: pngdec.c:93
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:83
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:557
PNGDecContext::channels
int channels
Definition: pngdec.c:106
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1008
PNG_COLOR_TYPE_GRAY
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:33
abs
#define abs(x)
Definition: cuda_runtime.h:35
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:281
decode_sbit_chunk
static int decode_sbit_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:1069
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
apng_reset_background
static void apng_reset_background(PNGDecContext *s, const AVFrame *p)
Definition: pngdec.c:1359
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
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
ff_png_pass_ymask
const uint8_t ff_png_pass_ymask[NB_PASSES]
Definition: png.c:27
output_frame
static int output_frame(PNGDecContext *s, AVFrame *f)
Definition: pngdec.c:1718
png_pass_mask
static const uint8_t png_pass_mask[NB_PASSES]
Definition: pngdec.c:130
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
PNGDecContext::pass
int pass
Definition: pngdec.c:121
PNGDecContext::iccp_name
uint8_t iccp_name[82]
Definition: pngdec.c:71
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
handle_small_bpp
static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1104
PNG_FILTER_VALUE_NONE
#define PNG_FILTER_VALUE_NONE
Definition: png.h:40
f
f
Definition: af_crystalizer.c:121
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:477
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
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
PNGDecContext::gb
GetByteContext gb
Definition: pngdec.c:65
AVPacket::size
int size
Definition: packet.h:525
handle_p_frame_png
static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1248
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:384
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
codec_internal.h
PNGDecContext::white_point
uint32_t white_point[2]
Definition: pngdec.c:78
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:999
PNGDecContext::picture
ThreadFrame picture
Definition: pngdec.c:67
png_put_interlaced_row
static void png_put_interlaced_row(uint8_t *dst, int width, int bits_per_pixel, int pass, int color_type, const uint8_t *src)
Definition: pngdec.c:147
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
PNG_FILTER_VALUE_AVG
#define PNG_FILTER_VALUE_AVG
Definition: png.h:43
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: codec_internal.h:69
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:1804
AV_RB32
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_RB32
Definition: bytestream.h:96
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
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.
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
PNG_FILTER_VALUE_PAETH
#define PNG_FILTER_VALUE_PAETH
Definition: png.h:44
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:93
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:462
PNGDecContext::buffer
uint8_t * buffer
Definition: pngdec.c:119
PNGDecContext::zstream
FFZStream zstream
Definition: pngdec.c:126
PNG_FILTER_VALUE_UP
#define PNG_FILTER_VALUE_UP
Definition: png.h:42
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
height
#define height
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
PNGDecContext::dispose_op
uint8_t dispose_op
Definition: pngdec.c:100
csp.h
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
decode_trns_chunk
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:988
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:164
PNGSIG
#define PNGSIG
Definition: png.h:49
PNGDecContext::buffer_size
int buffer_size
Definition: pngdec.c:120
populate_avctx_color_fields
static int populate_avctx_color_fields(AVCodecContext *avctx, AVFrame *frame)
Definition: pngdec.c:661
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1593
PNGDecContext::stereo_mode
int stereo_mode
Definition: pngdec.c:75
ff_pngdsp_init
av_cold void ff_pngdsp_init(PNGDSPContext *dsp)
Definition: pngdsp.c:56
av_image_get_linesize
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane.
Definition: imgutils.c:76
PNGDecContext::frame_metadata
AVDictionary * frame_metadata
Definition: pngdec.c:69
PNGDecContext::significant_bits
int significant_bits
Definition: pngdec.c:111
PNGDSPContext::add_bytes_l2
void(* add_bytes_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w)
Definition: pngdsp.h:28
PNG_FILTER_VALUE_SUB
#define PNG_FILTER_VALUE_SUB
Definition: png.h:41
bprint.h
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:109
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
PNGDecContext::mdvc_primaries
uint16_t mdvc_primaries[3][2]
Definition: pngdec.c:90
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
PNGDecContext::x_offset
int x_offset
Definition: pngdec.c:99
PNGDecContext::display_primaries
uint32_t display_primaries[3][2]
Definition: pngdec.c:79
av_bprint_get_buffer
void av_bprint_get_buffer(AVBPrint *buf, unsigned size, unsigned char **mem, unsigned *actual_size)
Allocate bytes in the buffer for external use.
Definition: bprint.c:223
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
png_handle_row
static void png_handle_row(PNGDecContext *s, uint8_t *dst, ptrdiff_t dst_stride)
Definition: pngdec.c:364
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1404
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
decode_fctl_chunk
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:1177
decode_plte_chunk
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:965
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
ff_inflate_end
void ff_inflate_end(FFZStream *zstream)
Wrapper around inflateEnd().
GetByteContext::buffer_end
const uint8_t * buffer_end
Definition: bytestream.h:34
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:980
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:634
PNGDecContext::avctx
AVCodecContext * avctx
Definition: pngdec.c:63
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
FF_CODEC_CAP_ICC_PROFILES
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
Definition: codec_internal.h:82
avcodec.h
PNGHeaderState
PNGHeaderState
Definition: pngdec.c:51
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
tag
uint32_t tag
Definition: movenc.c:1787
ret
ret
Definition: filter_design.txt:187
pixfmt.h
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
PNGDecContext::iccp_data_len
size_t iccp_data_len
Definition: pngdec.c:73
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:177
PNGDecContext::last_picture
ThreadFrame last_picture
Definition: pngdec.c:66
ff_decode_content_light_new
int ff_decode_content_light_new(const AVCodecContext *avctx, AVFrame *frame, AVContentLightMetadata **clm)
Wrapper around av_content_light_metadata_create_side_data(), which rejects side data overridden by th...
Definition: decode.c:1928
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
PNGDecContext::compression_type
int compression_type
Definition: pngdec.c:103
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
iso88591_to_utf8
static char * iso88591_to_utf8(const char *in, size_t size_in)
Definition: pngdec.c:518
PNG_IHDR
@ PNG_IHDR
Definition: pngdec.c:52
ff_png_filter_row
void ff_png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type, uint8_t *src, uint8_t *last, int size, int bpp)
Definition: pngdec.c:283
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:447
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1601
ThreadFrame
Definition: threadframe.h:27
decode_frame_common
static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p, const AVPacket *avpkt)
Definition: pngdec.c:1375
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
UNROLL_FILTER
#define UNROLL_FILTER(op)
Definition: pngdec.c:268
AVRational::den
int den
Denominator.
Definition: rational.h:60
mode
mode
Definition: ebur128.h:83
PNGDecContext::transparent_color_be
uint8_t transparent_color_be[6]
Definition: pngdec.c:110
av_fast_padded_mallocz
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call.
Definition: utils.c:65
PNGDecContext::have_chrm
int have_chrm
Definition: pngdec.c:77
png_pass_dsp_mask
static const uint8_t png_pass_dsp_mask[NB_PASSES]
Definition: pngdec.c:140
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1969
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1396
PNG_IDAT
@ PNG_IDAT
Definition: pngdec.c:57
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:53
decode_iccp_chunk
static int decode_iccp_chunk(PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:1036
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFZStream
Definition: zlib_wrapper.h:27
mem.h
PNGDecContext::mdvc_white_point
uint16_t mdvc_white_point[2]
Definition: pngdec.c:91
mastering_display_metadata.h
decode_ihdr_chunk
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:589
PNGDecContext::dsp
PNGDSPContext dsp
Definition: pngdec.c:62
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:34
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
png.h
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ff_inflate_init
int ff_inflate_init(FFZStream *zstream, void *logctx)
Wrapper around inflateInit().
d
d
Definition: ffmpeg_filter.c:424
bytestream.h
APNG_BLEND_OP_SOURCE
@ APNG_BLEND_OP_SOURCE
Definition: apng.h:37
imgutils.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:420
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:37
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:254
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
AVCOL_TRC_SMPTE428
@ AVCOL_TRC_SMPTE428
SMPTE ST 428-1.
Definition: pixfmt.h:599
MNGSIG
#define MNGSIG
Definition: png.h:50
PNGDecContext::cicp_trc
enum AVColorTransferCharacteristic cicp_trc
Definition: pngdec.c:84
PNGDecContext::interlace_type
int interlace_type
Definition: pngdec.c:104
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:173
handle_p_frame_apng
static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1270
PNGDecContext::y
int y
Definition: pngdec.c:125
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
OP_SUB
#define OP_SUB(x, s, l)
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:651
decode_zbuf
static int decode_zbuf(AVBPrint *bp, const uint8_t *data, const uint8_t *data_end, void *logctx)
Definition: pngdec.c:476
PNGDecContext::cur_w
int cur_w
Definition: pngdec.c:98
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:642
PNG_COLOR_TYPE_PALETTE
#define PNG_COLOR_TYPE_PALETTE
Definition: png.h:34
AV_DICT_DONT_STRDUP_KEY
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition: dict.h:77
PNGDecContext::bpp
int bpp
Definition: pngdec.c:108
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2885
PNGDecContext::has_trns
int has_trns
Definition: pngdec.c:109
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:345