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/imgutils.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/stereo3d.h"
33 
34 #include "avcodec.h"
35 #include "bytestream.h"
36 #include "codec_internal.h"
37 #include "decode.h"
38 #include "apng.h"
39 #include "png.h"
40 #include "pngdsp.h"
41 #include "thread.h"
42 #include "threadframe.h"
43 #include "zlib_wrapper.h"
44 
45 #include <zlib.h>
46 
48  PNG_IHDR = 1 << 0,
49  PNG_PLTE = 1 << 1,
50 };
51 
53  PNG_IDAT = 1 << 0,
54  PNG_ALLIMAGE = 1 << 1,
55 };
56 
57 typedef struct PNGDecContext {
60 
64 
66 
67  uint8_t iccp_name[82];
68  uint8_t *iccp_data;
69  size_t iccp_data_len;
70 
72 
73  int have_chrm;
74  uint32_t white_point[2];
75  uint32_t display_primaries[3][2];
76 
79  int width, height;
80  int cur_w, cur_h;
82  uint8_t dispose_op, blend_op;
83  int bit_depth;
88  int channels;
90  int bpp;
91  int has_trns;
93 
94  uint32_t palette[256];
95  uint8_t *crow_buf;
96  uint8_t *last_row;
97  unsigned int last_row_size;
98  uint8_t *tmp_row;
99  unsigned int tmp_row_size;
100  uint8_t *buffer;
102  int pass;
103  int crow_size; /* compressed row size (include filter type) */
104  int row_size; /* decompressed row size */
105  int pass_row_size; /* decompress row size of the current pass */
106  int y;
108 } PNGDecContext;
109 
110 /* Mask to determine which pixels are valid in a pass */
111 static const uint8_t png_pass_mask[NB_PASSES] = {
112  0x01, 0x01, 0x11, 0x11, 0x55, 0x55, 0xff,
113 };
114 
115 /* Mask to determine which y pixels can be written in a pass */
116 static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {
117  0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
118 };
119 
120 /* Mask to determine which pixels to overwrite while displaying */
121 static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
122  0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
123 };
124 
125 /* NOTE: we try to construct a good looking image at each pass. width
126  * is the original image width. We also do pixel format conversion at
127  * this stage */
128 static void png_put_interlaced_row(uint8_t *dst, int width,
129  int bits_per_pixel, int pass,
130  int color_type, const uint8_t *src)
131 {
132  int x, mask, dsp_mask, j, src_x, b, bpp;
133  uint8_t *d;
134  const uint8_t *s;
135 
137  dsp_mask = png_pass_dsp_mask[pass];
138 
139  switch (bits_per_pixel) {
140  case 1:
141  src_x = 0;
142  for (x = 0; x < width; x++) {
143  j = (x & 7);
144  if ((dsp_mask << j) & 0x80) {
145  b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;
146  dst[x >> 3] &= 0xFF7F>>j;
147  dst[x >> 3] |= b << (7 - j);
148  }
149  if ((mask << j) & 0x80)
150  src_x++;
151  }
152  break;
153  case 2:
154  src_x = 0;
155  for (x = 0; x < width; x++) {
156  int j2 = 2 * (x & 3);
157  j = (x & 7);
158  if ((dsp_mask << j) & 0x80) {
159  b = (src[src_x >> 2] >> (6 - 2*(src_x & 3))) & 3;
160  dst[x >> 2] &= 0xFF3F>>j2;
161  dst[x >> 2] |= b << (6 - j2);
162  }
163  if ((mask << j) & 0x80)
164  src_x++;
165  }
166  break;
167  case 4:
168  src_x = 0;
169  for (x = 0; x < width; x++) {
170  int j2 = 4*(x&1);
171  j = (x & 7);
172  if ((dsp_mask << j) & 0x80) {
173  b = (src[src_x >> 1] >> (4 - 4*(src_x & 1))) & 15;
174  dst[x >> 1] &= 0xFF0F>>j2;
175  dst[x >> 1] |= b << (4 - j2);
176  }
177  if ((mask << j) & 0x80)
178  src_x++;
179  }
180  break;
181  default:
182  bpp = bits_per_pixel >> 3;
183  d = dst;
184  s = src;
185  for (x = 0; x < width; x++) {
186  j = x & 7;
187  if ((dsp_mask << j) & 0x80) {
188  memcpy(d, s, bpp);
189  }
190  d += bpp;
191  if ((mask << j) & 0x80)
192  s += bpp;
193  }
194  break;
195  }
196 }
197 
198 void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top,
199  int w, int bpp)
200 {
201  int i;
202  for (i = 0; i < w; i++) {
203  int a, b, c, p, pa, pb, pc;
204 
205  a = dst[i - bpp];
206  b = top[i];
207  c = top[i - bpp];
208 
209  p = b - c;
210  pc = a - c;
211 
212  pa = abs(p);
213  pb = abs(pc);
214  pc = abs(p + pc);
215 
216  if (pa <= pb && pa <= pc)
217  p = a;
218  else if (pb <= pc)
219  p = b;
220  else
221  p = c;
222  dst[i] = p + src[i];
223  }
224 }
225 
226 #define UNROLL1(bpp, op) \
227  { \
228  r = dst[0]; \
229  if (bpp >= 2) \
230  g = dst[1]; \
231  if (bpp >= 3) \
232  b = dst[2]; \
233  if (bpp >= 4) \
234  a = dst[3]; \
235  for (; i <= size - bpp; i += bpp) { \
236  dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \
237  if (bpp == 1) \
238  continue; \
239  dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \
240  if (bpp == 2) \
241  continue; \
242  dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \
243  if (bpp == 3) \
244  continue; \
245  dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \
246  } \
247  }
248 
249 #define UNROLL_FILTER(op) \
250  if (bpp == 1) { \
251  UNROLL1(1, op) \
252  } else if (bpp == 2) { \
253  UNROLL1(2, op) \
254  } else if (bpp == 3) { \
255  UNROLL1(3, op) \
256  } else if (bpp == 4) { \
257  UNROLL1(4, op) \
258  } \
259  for (; i < size; i++) { \
260  dst[i] = op(dst[i - bpp], src[i], last[i]); \
261  }
262 
263 /* NOTE: 'dst' can be equal to 'last' */
264 void ff_png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type,
265  uint8_t *src, uint8_t *last, int size, int bpp)
266 {
267  int i, p, r, g, b, a;
268 
269  switch (filter_type) {
271  memcpy(dst, src, size);
272  break;
274  for (i = 0; i < bpp; i++)
275  dst[i] = src[i];
276  if (bpp == 4) {
277  p = *(int *)dst;
278  for (; i < size; i += bpp) {
279  unsigned s = *(int *)(src + i);
280  p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080);
281  *(int *)(dst + i) = p;
282  }
283  } else {
284 #define OP_SUB(x, s, l) ((x) + (s))
286  }
287  break;
288  case PNG_FILTER_VALUE_UP:
289  dsp->add_bytes_l2(dst, src, last, size);
290  break;
292  for (i = 0; i < bpp; i++) {
293  p = (last[i] >> 1);
294  dst[i] = p + src[i];
295  }
296 #define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff)
298  break;
300  for (i = 0; i < bpp; i++) {
301  p = last[i];
302  dst[i] = p + src[i];
303  }
304  if (bpp > 2 && size > 4) {
305  /* would write off the end of the array if we let it process
306  * the last pixel with bpp=3 */
307  int w = (bpp & 3) ? size - 3 : size;
308 
309  if (w > i) {
310  dsp->add_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
311  i = w;
312  }
313  }
314  ff_add_png_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
315  break;
316  }
317 }
318 
319 /* This used to be called "deloco" in FFmpeg
320  * and is actually an inverse reversible colorspace transformation */
321 #define YUV2RGB(NAME, TYPE) \
322 static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \
323 { \
324  int i; \
325  for (i = 0; i < size; i += 3 + alpha) { \
326  int g = dst [i + 1]; \
327  dst[i + 0] += g; \
328  dst[i + 2] += g; \
329  } \
330 }
331 
332 YUV2RGB(rgb8, uint8_t)
333 YUV2RGB(rgb16, uint16_t)
334 
336 {
337  if (s->interlace_type) {
338  return 100 - 100 * s->pass / (NB_PASSES - 1);
339  } else {
340  return 100 - 100 * s->y / s->cur_h;
341  }
342 }
343 
344 /* process exactly one decompressed row */
345 static void png_handle_row(PNGDecContext *s, uint8_t *dst, ptrdiff_t dst_stride)
346 {
347  uint8_t *ptr, *last_row;
348  int got_line;
349 
350  if (!s->interlace_type) {
351  ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
352  if (s->y == 0)
353  last_row = s->last_row;
354  else
355  last_row = ptr - dst_stride;
356 
357  ff_png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,
358  last_row, s->row_size, s->bpp);
359  /* loco lags by 1 row so that it doesn't interfere with top prediction */
360  if (s->filter_type == PNG_FILTER_TYPE_LOCO && s->y > 0) {
361  if (s->bit_depth == 16) {
362  deloco_rgb16((uint16_t *)(ptr - dst_stride), s->row_size / 2,
363  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
364  } else {
365  deloco_rgb8(ptr - dst_stride, s->row_size,
366  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
367  }
368  }
369  s->y++;
370  if (s->y == s->cur_h) {
371  s->pic_state |= PNG_ALLIMAGE;
372  if (s->filter_type == PNG_FILTER_TYPE_LOCO) {
373  if (s->bit_depth == 16) {
374  deloco_rgb16((uint16_t *)ptr, s->row_size / 2,
375  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
376  } else {
377  deloco_rgb8(ptr, s->row_size,
378  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA);
379  }
380  }
381  }
382  } else {
383  got_line = 0;
384  for (;;) {
385  ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
386  if ((ff_png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
387  /* if we already read one row, it is time to stop to
388  * wait for the next one */
389  if (got_line)
390  break;
391  ff_png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
392  s->last_row, s->pass_row_size, s->bpp);
393  FFSWAP(uint8_t *, s->last_row, s->tmp_row);
394  FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size);
395  got_line = 1;
396  }
397  if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
398  png_put_interlaced_row(ptr, s->cur_w, s->bits_per_pixel, s->pass,
399  s->color_type, s->last_row);
400  }
401  s->y++;
402  if (s->y == s->cur_h) {
403  memset(s->last_row, 0, s->row_size);
404  for (;;) {
405  if (s->pass == NB_PASSES - 1) {
406  s->pic_state |= PNG_ALLIMAGE;
407  goto the_end;
408  } else {
409  s->pass++;
410  s->y = 0;
411  s->pass_row_size = ff_png_pass_row_size(s->pass,
412  s->bits_per_pixel,
413  s->cur_w);
414  s->crow_size = s->pass_row_size + 1;
415  if (s->pass_row_size != 0)
416  break;
417  /* skip pass if empty row */
418  }
419  }
420  }
421  }
422 the_end:;
423  }
424 }
425 
427  uint8_t *dst, ptrdiff_t dst_stride)
428 {
429  z_stream *const zstream = &s->zstream.zstream;
430  int ret;
431  zstream->avail_in = bytestream2_get_bytes_left(gb);
432  zstream->next_in = gb->buffer;
433 
434  /* decode one line if possible */
435  while (zstream->avail_in > 0) {
436  ret = inflate(zstream, Z_PARTIAL_FLUSH);
437  if (ret != Z_OK && ret != Z_STREAM_END) {
438  av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
439  return AVERROR_EXTERNAL;
440  }
441  if (zstream->avail_out == 0) {
442  if (!(s->pic_state & PNG_ALLIMAGE)) {
443  png_handle_row(s, dst, dst_stride);
444  }
445  zstream->avail_out = s->crow_size;
446  zstream->next_out = s->crow_buf;
447  }
448  if (ret == Z_STREAM_END && zstream->avail_in > 0) {
449  av_log(s->avctx, AV_LOG_WARNING,
450  "%d undecompressed bytes left in buffer\n", zstream->avail_in);
451  return 0;
452  }
453  }
454  return 0;
455 }
456 
457 static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
458  const uint8_t *data_end, void *logctx)
459 {
460  FFZStream z;
461  z_stream *const zstream = &z.zstream;
462  unsigned char *buf;
463  unsigned buf_size;
464  int ret = ff_inflate_init(&z, logctx);
465  if (ret < 0)
466  return ret;
467 
468  zstream->next_in = data;
469  zstream->avail_in = data_end - data;
471 
472  while (zstream->avail_in > 0) {
473  av_bprint_get_buffer(bp, 2, &buf, &buf_size);
474  if (buf_size < 2) {
475  ret = AVERROR(ENOMEM);
476  goto fail;
477  }
478  zstream->next_out = buf;
479  zstream->avail_out = buf_size - 1;
480  ret = inflate(zstream, Z_PARTIAL_FLUSH);
481  if (ret != Z_OK && ret != Z_STREAM_END) {
483  goto fail;
484  }
485  bp->len += zstream->next_out - buf;
486  if (ret == Z_STREAM_END)
487  break;
488  }
489  ff_inflate_end(&z);
490  bp->str[bp->len] = 0;
491  return 0;
492 
493 fail:
494  ff_inflate_end(&z);
496  return ret;
497 }
498 
499 static char *iso88591_to_utf8(const char *in, size_t size_in)
500 {
501  size_t extra = 0, i;
502  char *out, *q;
503 
504  for (i = 0; i < size_in; i++)
505  extra += !!(in[i] & 0x80);
506  if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
507  return NULL;
508  q = out = av_malloc(size_in + extra + 1);
509  if (!out)
510  return NULL;
511  for (i = 0; i < size_in; i++) {
512  if (in[i] & 0x80) {
513  *(q++) = 0xC0 | (in[i] >> 6);
514  *(q++) = 0x80 | (in[i] & 0x3F);
515  } else {
516  *(q++) = in[i];
517  }
518  }
519  *(q++) = 0;
520  return out;
521 }
522 
523 static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
524 {
525  int ret, method;
526  const uint8_t *data = gb->buffer;
527  const uint8_t *data_end = gb->buffer_end;
528  const char *keyword = data;
529  const char *keyword_end = memchr(keyword, 0, data_end - data);
530  char *kw_utf8 = NULL, *txt_utf8 = NULL;
531  const char *text;
532  unsigned text_len;
533  AVBPrint bp;
534 
535  if (!keyword_end)
536  return AVERROR_INVALIDDATA;
537  data = keyword_end + 1;
538 
539  if (compressed) {
540  if (data == data_end)
541  return AVERROR_INVALIDDATA;
542  method = *(data++);
543  if (method)
544  return AVERROR_INVALIDDATA;
545  if ((ret = decode_zbuf(&bp, data, data_end, s->avctx)) < 0)
546  return ret;
547  text = bp.str;
548  text_len = bp.len;
549  } else {
550  text = data;
551  text_len = data_end - data;
552  }
553 
554  txt_utf8 = iso88591_to_utf8(text, text_len);
555  if (compressed)
556  av_bprint_finalize(&bp, NULL);
557  if (!txt_utf8)
558  return AVERROR(ENOMEM);
559  kw_utf8 = iso88591_to_utf8(keyword, keyword_end - keyword);
560  if (!kw_utf8) {
561  av_free(txt_utf8);
562  return AVERROR(ENOMEM);
563  }
564 
565  av_dict_set(&s->frame_metadata, kw_utf8, txt_utf8,
567  return 0;
568 }
569 
571  GetByteContext *gb)
572 {
573  if (bytestream2_get_bytes_left(gb) != 13)
574  return AVERROR_INVALIDDATA;
575 
576  if (s->pic_state & PNG_IDAT) {
577  av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
578  return AVERROR_INVALIDDATA;
579  }
580 
581  if (s->hdr_state & PNG_IHDR) {
582  av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
583  return AVERROR_INVALIDDATA;
584  }
585 
586  s->width = s->cur_w = bytestream2_get_be32(gb);
587  s->height = s->cur_h = bytestream2_get_be32(gb);
588  if (av_image_check_size(s->width, s->height, 0, avctx)) {
589  s->cur_w = s->cur_h = s->width = s->height = 0;
590  av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
591  return AVERROR_INVALIDDATA;
592  }
593  s->bit_depth = bytestream2_get_byte(gb);
594  if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
595  s->bit_depth != 8 && s->bit_depth != 16) {
596  av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
597  goto error;
598  }
599  s->color_type = bytestream2_get_byte(gb);
600  s->compression_type = bytestream2_get_byte(gb);
601  if (s->compression_type) {
602  av_log(avctx, AV_LOG_ERROR, "Invalid compression method %d\n", s->compression_type);
603  goto error;
604  }
605  s->filter_type = bytestream2_get_byte(gb);
606  s->interlace_type = bytestream2_get_byte(gb);
607  s->hdr_state |= PNG_IHDR;
608  if (avctx->debug & FF_DEBUG_PICT_INFO)
609  av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
610  "compression_type=%d filter_type=%d interlace_type=%d\n",
611  s->width, s->height, s->bit_depth, s->color_type,
612  s->compression_type, s->filter_type, s->interlace_type);
613 
614  return 0;
615 error:
616  s->cur_w = s->cur_h = s->width = s->height = 0;
617  s->bit_depth = 8;
618  return AVERROR_INVALIDDATA;
619 }
620 
622  GetByteContext *gb)
623 {
624  if (s->pic_state & PNG_IDAT) {
625  av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
626  return AVERROR_INVALIDDATA;
627  }
628  avctx->sample_aspect_ratio.num = bytestream2_get_be32(gb);
629  avctx->sample_aspect_ratio.den = bytestream2_get_be32(gb);
630  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
631  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
632  bytestream2_skip(gb, 1); /* unit specifier */
633 
634  return 0;
635 }
636 
638  GetByteContext *gb, AVFrame *p)
639 {
640  int ret;
641  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
642 
643  if (!(s->hdr_state & PNG_IHDR)) {
644  av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
645  return AVERROR_INVALIDDATA;
646  }
647  if (!(s->pic_state & PNG_IDAT)) {
648  /* init image info */
649  ret = ff_set_dimensions(avctx, s->width, s->height);
650  if (ret < 0)
651  return ret;
652 
653  s->channels = ff_png_get_nb_channels(s->color_type);
654  s->bits_per_pixel = s->bit_depth * s->channels;
655  s->bpp = (s->bits_per_pixel + 7) >> 3;
656  s->row_size = (s->cur_w * s->bits_per_pixel + 7) >> 3;
657 
658  if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
659  s->color_type == PNG_COLOR_TYPE_RGB) {
660  avctx->pix_fmt = AV_PIX_FMT_RGB24;
661  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
662  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
663  avctx->pix_fmt = AV_PIX_FMT_RGBA;
664  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
665  s->color_type == PNG_COLOR_TYPE_GRAY) {
666  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
667  } else if (s->bit_depth == 16 &&
668  s->color_type == PNG_COLOR_TYPE_GRAY) {
669  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
670  } else if (s->bit_depth == 16 &&
671  s->color_type == PNG_COLOR_TYPE_RGB) {
672  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
673  } else if (s->bit_depth == 16 &&
674  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
675  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
676  } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
677  s->color_type == PNG_COLOR_TYPE_PALETTE) {
679  } else if (s->bit_depth == 1 && s->bits_per_pixel == 1 && avctx->codec_id != AV_CODEC_ID_APNG) {
680  avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
681  } else if (s->bit_depth == 8 &&
682  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
683  avctx->pix_fmt = AV_PIX_FMT_YA8;
684  } else if (s->bit_depth == 16 &&
685  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
686  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
687  } else {
689  "Bit depth %d color type %d",
690  s->bit_depth, s->color_type);
691  return AVERROR_PATCHWELCOME;
692  }
693 
694  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
695  switch (avctx->pix_fmt) {
696  case AV_PIX_FMT_RGB24:
697  avctx->pix_fmt = AV_PIX_FMT_RGBA;
698  break;
699 
700  case AV_PIX_FMT_RGB48BE:
701  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
702  break;
703 
704  case AV_PIX_FMT_GRAY8:
705  avctx->pix_fmt = AV_PIX_FMT_YA8;
706  break;
707 
708  case AV_PIX_FMT_GRAY16BE:
709  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
710  break;
711 
712  default:
713  avpriv_request_sample(avctx, "bit depth %d "
714  "and color type %d with TRNS",
715  s->bit_depth, s->color_type);
716  return AVERROR_INVALIDDATA;
717  }
718 
719  s->bpp += byte_depth;
720  }
721 
722  ff_thread_release_ext_buffer(avctx, &s->picture);
723  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
724  /* We only need a buffer for the current picture. */
725  ret = ff_thread_get_buffer(avctx, p, 0);
726  if (ret < 0)
727  return ret;
728  } else if (s->dispose_op == APNG_DISPOSE_OP_BACKGROUND) {
729  /* We need a buffer for the current picture as well as
730  * a buffer for the reference to retain. */
731  ret = ff_thread_get_ext_buffer(avctx, &s->picture,
733  if (ret < 0)
734  return ret;
735  ret = ff_thread_get_buffer(avctx, p, 0);
736  if (ret < 0)
737  return ret;
738  } else {
739  /* The picture output this time and the reference to retain coincide. */
740  if ((ret = ff_thread_get_ext_buffer(avctx, &s->picture,
742  return ret;
743  ret = av_frame_ref(p, s->picture.f);
744  if (ret < 0)
745  return ret;
746  }
747 
749  p->key_frame = 1;
750  p->interlaced_frame = !!s->interlace_type;
751 
752  ff_thread_finish_setup(avctx);
753 
754  /* compute the compressed row size */
755  if (!s->interlace_type) {
756  s->crow_size = s->row_size + 1;
757  } else {
758  s->pass = 0;
759  s->pass_row_size = ff_png_pass_row_size(s->pass,
760  s->bits_per_pixel,
761  s->cur_w);
762  s->crow_size = s->pass_row_size + 1;
763  }
764  ff_dlog(avctx, "row_size=%d crow_size =%d\n",
765  s->row_size, s->crow_size);
766 
767  /* copy the palette if needed */
768  if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
769  memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
770  /* empty row is used if differencing to the first row */
771  av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
772  if (!s->last_row)
773  return AVERROR_INVALIDDATA;
774  if (s->interlace_type ||
775  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
776  av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
777  if (!s->tmp_row)
778  return AVERROR_INVALIDDATA;
779  }
780  /* compressed row */
781  av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
782  if (!s->buffer)
783  return AVERROR(ENOMEM);
784 
785  /* we want crow_buf+1 to be 16-byte aligned */
786  s->crow_buf = s->buffer + 15;
787  s->zstream.zstream.avail_out = s->crow_size;
788  s->zstream.zstream.next_out = s->crow_buf;
789  }
790 
791  s->pic_state |= PNG_IDAT;
792 
793  /* set image to non-transparent bpp while decompressing */
794  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
795  s->bpp -= byte_depth;
796 
797  ret = png_decode_idat(s, gb, p->data[0], p->linesize[0]);
798 
799  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
800  s->bpp += byte_depth;
801 
802  if (ret < 0)
803  return ret;
804 
805  return 0;
806 }
807 
809  GetByteContext *gb)
810 {
811  int length = bytestream2_get_bytes_left(gb);
812  int n, i, r, g, b;
813 
814  if ((length % 3) != 0 || length > 256 * 3)
815  return AVERROR_INVALIDDATA;
816  /* read the palette */
817  n = length / 3;
818  for (i = 0; i < n; i++) {
819  r = bytestream2_get_byte(gb);
820  g = bytestream2_get_byte(gb);
821  b = bytestream2_get_byte(gb);
822  s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
823  }
824  for (; i < 256; i++)
825  s->palette[i] = (0xFFU << 24);
826  s->hdr_state |= PNG_PLTE;
827 
828  return 0;
829 }
830 
832  GetByteContext *gb)
833 {
834  int length = bytestream2_get_bytes_left(gb);
835  int v, i;
836 
837  if (!(s->hdr_state & PNG_IHDR)) {
838  av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
839  return AVERROR_INVALIDDATA;
840  }
841 
842  if (s->pic_state & PNG_IDAT) {
843  av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
844  return AVERROR_INVALIDDATA;
845  }
846 
847  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
848  if (length > 256 || !(s->hdr_state & PNG_PLTE))
849  return AVERROR_INVALIDDATA;
850 
851  for (i = 0; i < length; i++) {
852  unsigned v = bytestream2_get_byte(gb);
853  s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
854  }
855  } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
856  if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
857  (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
858  s->bit_depth == 1)
859  return AVERROR_INVALIDDATA;
860 
861  for (i = 0; i < length / 2; i++) {
862  /* only use the least significant bits */
863  v = av_mod_uintp2(bytestream2_get_be16(gb), s->bit_depth);
864 
865  if (s->bit_depth > 8)
866  AV_WB16(&s->transparent_color_be[2 * i], v);
867  else
868  s->transparent_color_be[i] = v;
869  }
870  } else {
871  return AVERROR_INVALIDDATA;
872  }
873 
874  s->has_trns = 1;
875 
876  return 0;
877 }
878 
880 {
881  int ret, cnt = 0;
882  AVBPrint bp;
883 
884  while ((s->iccp_name[cnt++] = bytestream2_get_byte(gb)) && cnt < 81);
885  if (cnt > 80) {
886  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
888  goto fail;
889  }
890 
891  if (bytestream2_get_byte(gb) != 0) {
892  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
894  goto fail;
895  }
896 
897  if ((ret = decode_zbuf(&bp, gb->buffer, gb->buffer_end, s->avctx)) < 0)
898  return ret;
899 
900  av_freep(&s->iccp_data);
901  ret = av_bprint_finalize(&bp, (char **)&s->iccp_data);
902  if (ret < 0)
903  return ret;
904  s->iccp_data_len = bp.len;
905 
906  return 0;
907 fail:
908  s->iccp_name[0] = 0;
909  return ret;
910 }
911 
913 {
914  if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
915  int i, j, k;
916  uint8_t *pd = p->data[0];
917  for (j = 0; j < s->height; j++) {
918  i = s->width / 8;
919  for (k = 7; k >= 1; k--)
920  if ((s->width&7) >= k)
921  pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
922  for (i--; i >= 0; i--) {
923  pd[8*i + 7]= pd[i] & 1;
924  pd[8*i + 6]= (pd[i]>>1) & 1;
925  pd[8*i + 5]= (pd[i]>>2) & 1;
926  pd[8*i + 4]= (pd[i]>>3) & 1;
927  pd[8*i + 3]= (pd[i]>>4) & 1;
928  pd[8*i + 2]= (pd[i]>>5) & 1;
929  pd[8*i + 1]= (pd[i]>>6) & 1;
930  pd[8*i + 0]= pd[i]>>7;
931  }
932  pd += p->linesize[0];
933  }
934  } else if (s->bits_per_pixel == 2) {
935  int i, j;
936  uint8_t *pd = p->data[0];
937  for (j = 0; j < s->height; j++) {
938  i = s->width / 4;
939  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
940  if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
941  if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
942  if ((s->width&3) >= 1) pd[4*i + 0]= pd[i] >> 6;
943  for (i--; i >= 0; i--) {
944  pd[4*i + 3]= pd[i] & 3;
945  pd[4*i + 2]= (pd[i]>>2) & 3;
946  pd[4*i + 1]= (pd[i]>>4) & 3;
947  pd[4*i + 0]= pd[i]>>6;
948  }
949  } else {
950  if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
951  if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
952  if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6 )*0x55;
953  for (i--; i >= 0; i--) {
954  pd[4*i + 3]= ( pd[i] & 3)*0x55;
955  pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
956  pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
957  pd[4*i + 0]= ( pd[i]>>6 )*0x55;
958  }
959  }
960  pd += p->linesize[0];
961  }
962  } else if (s->bits_per_pixel == 4) {
963  int i, j;
964  uint8_t *pd = p->data[0];
965  for (j = 0; j < s->height; j++) {
966  i = s->width/2;
967  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
968  if (s->width&1) pd[2*i+0]= pd[i]>>4;
969  for (i--; i >= 0; i--) {
970  pd[2*i + 1] = pd[i] & 15;
971  pd[2*i + 0] = pd[i] >> 4;
972  }
973  } else {
974  if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
975  for (i--; i >= 0; i--) {
976  pd[2*i + 1] = (pd[i] & 15) * 0x11;
977  pd[2*i + 0] = (pd[i] >> 4) * 0x11;
978  }
979  }
980  pd += p->linesize[0];
981  }
982  }
983 }
984 
986  GetByteContext *gb)
987 {
988  uint32_t sequence_number;
989  int cur_w, cur_h, x_offset, y_offset, dispose_op, blend_op;
990 
992  return AVERROR_INVALIDDATA;
993 
994  if (!(s->hdr_state & PNG_IHDR)) {
995  av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
996  return AVERROR_INVALIDDATA;
997  }
998 
999  if (s->pic_state & PNG_IDAT) {
1000  av_log(avctx, AV_LOG_ERROR, "fctl after IDAT\n");
1001  return AVERROR_INVALIDDATA;
1002  }
1003 
1004  sequence_number = bytestream2_get_be32(gb);
1005  cur_w = bytestream2_get_be32(gb);
1006  cur_h = bytestream2_get_be32(gb);
1007  x_offset = bytestream2_get_be32(gb);
1008  y_offset = bytestream2_get_be32(gb);
1009  bytestream2_skip(gb, 4); /* delay_num (2), delay_den (2) */
1010  dispose_op = bytestream2_get_byte(gb);
1011  blend_op = bytestream2_get_byte(gb);
1012 
1013  if (sequence_number == 0 &&
1014  (cur_w != s->width ||
1015  cur_h != s->height ||
1016  x_offset != 0 ||
1017  y_offset != 0) ||
1018  cur_w <= 0 || cur_h <= 0 ||
1019  x_offset < 0 || y_offset < 0 ||
1020  cur_w > s->width - x_offset|| cur_h > s->height - y_offset)
1021  return AVERROR_INVALIDDATA;
1022 
1023  if (blend_op != APNG_BLEND_OP_OVER && blend_op != APNG_BLEND_OP_SOURCE) {
1024  av_log(avctx, AV_LOG_ERROR, "Invalid blend_op %d\n", blend_op);
1025  return AVERROR_INVALIDDATA;
1026  }
1027 
1028  if ((sequence_number == 0 || !s->last_picture.f->data[0]) &&
1029  dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1030  // No previous frame to revert to for the first frame
1031  // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
1032  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
1033  }
1034 
1035  if (blend_op == APNG_BLEND_OP_OVER && !s->has_trns && (
1036  avctx->pix_fmt == AV_PIX_FMT_RGB24 ||
1037  avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1038  avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
1039  avctx->pix_fmt == AV_PIX_FMT_GRAY16BE ||
1040  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK
1041  )) {
1042  // APNG_BLEND_OP_OVER is the same as APNG_BLEND_OP_SOURCE when there is no alpha channel
1043  blend_op = APNG_BLEND_OP_SOURCE;
1044  }
1045 
1046  s->cur_w = cur_w;
1047  s->cur_h = cur_h;
1048  s->x_offset = x_offset;
1049  s->y_offset = y_offset;
1050  s->dispose_op = dispose_op;
1051  s->blend_op = blend_op;
1052 
1053  return 0;
1054 }
1055 
1057 {
1058  int i, j;
1059  uint8_t *pd = p->data[0];
1060  uint8_t *pd_last = s->last_picture.f->data[0];
1061  int ls = av_image_get_linesize(p->format, s->width, 0);
1062 
1063  ls = FFMIN(ls, s->width * s->bpp);
1064 
1065  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1066  for (j = 0; j < s->height; j++) {
1067  for (i = 0; i < ls; i++)
1068  pd[i] += pd_last[i];
1069  pd += p->linesize[0];
1070  pd_last += s->last_picture.f->linesize[0];
1071  }
1072 }
1073 
1074 // divide by 255 and round to nearest
1075 // apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
1076 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
1077 
1079  AVFrame *p)
1080 {
1081  uint8_t *dst = p->data[0];
1082  ptrdiff_t dst_stride = p->linesize[0];
1083  const uint8_t *src = s->last_picture.f->data[0];
1084  ptrdiff_t src_stride = s->last_picture.f->linesize[0];
1085  const int bpp = s->color_type == PNG_COLOR_TYPE_PALETTE ? 4 : s->bpp;
1086 
1087  size_t x, y;
1088 
1089  if (s->blend_op == APNG_BLEND_OP_OVER &&
1090  avctx->pix_fmt != AV_PIX_FMT_RGBA &&
1091  avctx->pix_fmt != AV_PIX_FMT_GRAY8A) {
1092  avpriv_request_sample(avctx, "Blending with pixel format %s",
1093  av_get_pix_fmt_name(avctx->pix_fmt));
1094  return AVERROR_PATCHWELCOME;
1095  }
1096 
1097  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1098 
1099  // copy unchanged rectangles from the last frame
1100  for (y = 0; y < s->y_offset; y++)
1101  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * bpp);
1102  for (y = s->y_offset; y < s->y_offset + s->cur_h; y++) {
1103  memcpy(dst + y * dst_stride, src + y * src_stride, s->x_offset * bpp);
1104  memcpy(dst + y * dst_stride + (s->x_offset + s->cur_w) * bpp,
1105  src + y * src_stride + (s->x_offset + s->cur_w) * bpp,
1106  (p->width - s->cur_w - s->x_offset) * bpp);
1107  }
1108  for (y = s->y_offset + s->cur_h; y < p->height; y++)
1109  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * bpp);
1110 
1111  if (s->blend_op == APNG_BLEND_OP_OVER) {
1112  // Perform blending
1113  for (y = s->y_offset; y < s->y_offset + s->cur_h; ++y) {
1114  uint8_t *foreground = dst + dst_stride * y + bpp * s->x_offset;
1115  const uint8_t *background = src + src_stride * y + bpp * s->x_offset;
1116  for (x = s->x_offset; x < s->x_offset + s->cur_w; ++x, foreground += bpp, background += bpp) {
1117  size_t b;
1118  uint8_t foreground_alpha, background_alpha, output_alpha;
1119  uint8_t output[10];
1120 
1121  // Since we might be blending alpha onto alpha, we use the following equations:
1122  // output_alpha = foreground_alpha + (1 - foreground_alpha) * background_alpha
1123  // output = (foreground_alpha * foreground + (1 - foreground_alpha) * background_alpha * background) / output_alpha
1124 
1125  switch (avctx->pix_fmt) {
1126  case AV_PIX_FMT_RGBA:
1127  foreground_alpha = foreground[3];
1128  background_alpha = background[3];
1129  break;
1130 
1131  case AV_PIX_FMT_GRAY8A:
1132  foreground_alpha = foreground[1];
1133  background_alpha = background[1];
1134  break;
1135  }
1136 
1137  if (foreground_alpha == 255)
1138  continue;
1139 
1140  if (foreground_alpha == 0) {
1141  memcpy(foreground, background, bpp);
1142  continue;
1143  }
1144 
1145  output_alpha = foreground_alpha + FAST_DIV255((255 - foreground_alpha) * background_alpha);
1146 
1147  av_assert0(bpp <= 10);
1148 
1149  for (b = 0; b < bpp - 1; ++b) {
1150  if (output_alpha == 0) {
1151  output[b] = 0;
1152  } else if (background_alpha == 255) {
1153  output[b] = FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1154  } else {
1155  output[b] = (255 * foreground_alpha * foreground[b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1156  }
1157  }
1158  output[b] = output_alpha;
1159  memcpy(foreground, output, bpp);
1160  }
1161  }
1162  }
1163 
1164  return 0;
1165 }
1166 
1168 {
1169  // need to reset a rectangle to black
1170  av_unused int ret = av_frame_copy(s->picture.f, p);
1171  const int bpp = s->color_type == PNG_COLOR_TYPE_PALETTE ? 4 : s->bpp;
1172  const ptrdiff_t dst_stride = s->picture.f->linesize[0];
1173  uint8_t *dst = s->picture.f->data[0] + s->y_offset * dst_stride + bpp * s->x_offset;
1174 
1175  av_assert1(ret >= 0);
1176 
1177  for (size_t y = 0; y < s->cur_h; y++) {
1178  memset(dst, 0, bpp * s->cur_w);
1179  dst += dst_stride;
1180  }
1181 }
1182 
1184  AVFrame *p, const AVPacket *avpkt)
1185 {
1186  const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1187  uint32_t tag, length;
1188  int decode_next_dat = 0;
1189  int i, ret;
1190 
1191  for (;;) {
1192  GetByteContext gb_chunk;
1193 
1194  length = bytestream2_get_bytes_left(&s->gb);
1195  if (length <= 0) {
1196 
1197  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1198  avctx->skip_frame == AVDISCARD_ALL) {
1199  return 0;
1200  }
1201 
1202  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
1203  if (!(s->pic_state & PNG_IDAT))
1204  return 0;
1205  else
1206  goto exit_loop;
1207  }
1208  av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
1209  if ( s->pic_state & PNG_ALLIMAGE
1211  goto exit_loop;
1213  goto fail;
1214  }
1215 
1216  length = bytestream2_get_be32(&s->gb);
1217  if (length > 0x7fffffff || length + 8 > bytestream2_get_bytes_left(&s->gb)) {
1218  av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
1220  goto fail;
1221  }
1222  if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_IGNORE_ERR)) {
1223  uint32_t crc_sig = AV_RB32(s->gb.buffer + length + 4);
1224  uint32_t crc_cal = ~av_crc(crc_tab, UINT32_MAX, s->gb.buffer, length + 4);
1225  if (crc_sig ^ crc_cal) {
1226  av_log(avctx, AV_LOG_ERROR, "CRC mismatch in chunk");
1227  if (avctx->err_recognition & AV_EF_EXPLODE) {
1228  av_log(avctx, AV_LOG_ERROR, ", quitting\n");
1230  goto fail;
1231  }
1232  av_log(avctx, AV_LOG_ERROR, ", skipping\n");
1233  bytestream2_skip(&s->gb, length + 8); /* tag */
1234  }
1235  }
1236  tag = bytestream2_get_le32(&s->gb);
1237  if (avctx->debug & FF_DEBUG_STARTCODE)
1238  av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
1239  av_fourcc2str(tag), length);
1240 
1241  bytestream2_init(&gb_chunk, s->gb.buffer, length);
1242  bytestream2_skip(&s->gb, length + 4);
1243 
1244  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1245  avctx->skip_frame == AVDISCARD_ALL) {
1246  switch(tag) {
1247  case MKTAG('I', 'H', 'D', 'R'):
1248  case MKTAG('p', 'H', 'Y', 's'):
1249  case MKTAG('t', 'E', 'X', 't'):
1250  case MKTAG('I', 'D', 'A', 'T'):
1251  case MKTAG('t', 'R', 'N', 'S'):
1252  break;
1253  default:
1254  continue;
1255  }
1256  }
1257 
1258  switch (tag) {
1259  case MKTAG('I', 'H', 'D', 'R'):
1260  if ((ret = decode_ihdr_chunk(avctx, s, &gb_chunk)) < 0)
1261  goto fail;
1262  break;
1263  case MKTAG('p', 'H', 'Y', 's'):
1264  if ((ret = decode_phys_chunk(avctx, s, &gb_chunk)) < 0)
1265  goto fail;
1266  break;
1267  case MKTAG('f', 'c', 'T', 'L'):
1268  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1269  continue;
1270  if ((ret = decode_fctl_chunk(avctx, s, &gb_chunk)) < 0)
1271  goto fail;
1272  decode_next_dat = 1;
1273  break;
1274  case MKTAG('f', 'd', 'A', 'T'):
1275  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1276  continue;
1277  if (!decode_next_dat || bytestream2_get_bytes_left(&gb_chunk) < 4) {
1279  goto fail;
1280  }
1281  bytestream2_get_be32(&gb_chunk);
1282  /* fallthrough */
1283  case MKTAG('I', 'D', 'A', 'T'):
1284  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && !decode_next_dat)
1285  continue;
1286  if ((ret = decode_idat_chunk(avctx, s, &gb_chunk, p)) < 0)
1287  goto fail;
1288  break;
1289  case MKTAG('P', 'L', 'T', 'E'):
1290  decode_plte_chunk(avctx, s, &gb_chunk);
1291  break;
1292  case MKTAG('t', 'R', 'N', 'S'):
1293  decode_trns_chunk(avctx, s, &gb_chunk);
1294  break;
1295  case MKTAG('t', 'E', 'X', 't'):
1296  if (decode_text_chunk(s, &gb_chunk, 0) < 0)
1297  av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
1298  break;
1299  case MKTAG('z', 'T', 'X', 't'):
1300  if (decode_text_chunk(s, &gb_chunk, 1) < 0)
1301  av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
1302  break;
1303  case MKTAG('s', 'T', 'E', 'R'): {
1304  int mode = bytestream2_get_byte(&gb_chunk);
1305 
1306  if (mode == 0 || mode == 1) {
1307  s->stereo_mode = mode;
1308  } else {
1309  av_log(avctx, AV_LOG_WARNING,
1310  "Unknown value in sTER chunk (%d)\n", mode);
1311  }
1312  break;
1313  }
1314  case MKTAG('i', 'C', 'C', 'P'): {
1315  if ((ret = decode_iccp_chunk(s, &gb_chunk, p)) < 0)
1316  goto fail;
1317  break;
1318  }
1319  case MKTAG('c', 'H', 'R', 'M'): {
1320  s->have_chrm = 1;
1321 
1322  s->white_point[0] = bytestream2_get_be32(&gb_chunk);
1323  s->white_point[1] = bytestream2_get_be32(&gb_chunk);
1324 
1325  /* RGB Primaries */
1326  for (i = 0; i < 3; i++) {
1327  s->display_primaries[i][0] = bytestream2_get_be32(&gb_chunk);
1328  s->display_primaries[i][1] = bytestream2_get_be32(&gb_chunk);
1329  }
1330 
1331  break;
1332  }
1333  case MKTAG('g', 'A', 'M', 'A'): {
1334  AVBPrint bp;
1335  char *gamma_str;
1336  int num = bytestream2_get_be32(&gb_chunk);
1337 
1339  av_bprintf(&bp, "%i/%i", num, 100000);
1340  ret = av_bprint_finalize(&bp, &gamma_str);
1341  if (ret < 0)
1342  return ret;
1343 
1344  av_dict_set(&s->frame_metadata, "gamma", gamma_str, AV_DICT_DONT_STRDUP_VAL);
1345 
1346  break;
1347  }
1348  case MKTAG('I', 'E', 'N', 'D'):
1349  if (!(s->pic_state & PNG_ALLIMAGE))
1350  av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
1351  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1353  goto fail;
1354  }
1355  goto exit_loop;
1356  }
1357  }
1358 exit_loop:
1359 
1360  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1361  avctx->skip_frame == AVDISCARD_ALL) {
1362  return 0;
1363  }
1364 
1366  return AVERROR_INVALIDDATA;
1367 
1368  if (s->bits_per_pixel <= 4)
1369  handle_small_bpp(s, p);
1370 
1371  if (s->color_type == PNG_COLOR_TYPE_PALETTE && avctx->codec_id == AV_CODEC_ID_APNG) {
1372  for (int y = 0; y < s->height; y++) {
1373  uint8_t *row = &p->data[0][p->linesize[0] * y];
1374 
1375  for (int x = s->width - 1; x >= 0; x--) {
1376  const uint8_t idx = row[x];
1377 
1378  row[4*x+2] = s->palette[idx] & 0xFF;
1379  row[4*x+1] = (s->palette[idx] >> 8 ) & 0xFF;
1380  row[4*x+0] = (s->palette[idx] >> 16) & 0xFF;
1381  row[4*x+3] = s->palette[idx] >> 24;
1382  }
1383  }
1384  }
1385 
1386  /* apply transparency if needed */
1387  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
1388  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
1389  size_t raw_bpp = s->bpp - byte_depth;
1390  unsigned x, y;
1391 
1392  av_assert0(s->bit_depth > 1);
1393 
1394  for (y = 0; y < s->height; ++y) {
1395  uint8_t *row = &p->data[0][p->linesize[0] * y];
1396 
1397  if (s->bpp == 2 && byte_depth == 1) {
1398  uint8_t *pixel = &row[2 * s->width - 1];
1399  uint8_t *rowp = &row[1 * s->width - 1];
1400  int tcolor = s->transparent_color_be[0];
1401  for (x = s->width; x > 0; --x) {
1402  *pixel-- = *rowp == tcolor ? 0 : 0xff;
1403  *pixel-- = *rowp--;
1404  }
1405  } else if (s->bpp == 4 && byte_depth == 1) {
1406  uint8_t *pixel = &row[4 * s->width - 1];
1407  uint8_t *rowp = &row[3 * s->width - 1];
1408  int tcolor = AV_RL24(s->transparent_color_be);
1409  for (x = s->width; x > 0; --x) {
1410  *pixel-- = AV_RL24(rowp-2) == tcolor ? 0 : 0xff;
1411  *pixel-- = *rowp--;
1412  *pixel-- = *rowp--;
1413  *pixel-- = *rowp--;
1414  }
1415  } else {
1416  /* since we're updating in-place, we have to go from right to left */
1417  for (x = s->width; x > 0; --x) {
1418  uint8_t *pixel = &row[s->bpp * (x - 1)];
1419  memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1420 
1421  if (!memcmp(pixel, s->transparent_color_be, raw_bpp)) {
1422  memset(&pixel[raw_bpp], 0, byte_depth);
1423  } else {
1424  memset(&pixel[raw_bpp], 0xff, byte_depth);
1425  }
1426  }
1427  }
1428  }
1429  }
1430 
1431  /* handle P-frames only if a predecessor frame is available */
1432  if (s->last_picture.f->data[0]) {
1433  if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
1434  && s->last_picture.f->width == p->width
1435  && s->last_picture.f->height== p->height
1436  && s->last_picture.f->format== p->format
1437  ) {
1438  if (CONFIG_PNG_DECODER && avctx->codec_id != AV_CODEC_ID_APNG)
1439  handle_p_frame_png(s, p);
1440  else if (CONFIG_APNG_DECODER &&
1441  avctx->codec_id == AV_CODEC_ID_APNG &&
1442  (ret = handle_p_frame_apng(avctx, s, p)) < 0)
1443  goto fail;
1444  }
1445  }
1446  if (CONFIG_APNG_DECODER && s->dispose_op == APNG_DISPOSE_OP_BACKGROUND)
1448 
1449  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1450 
1451  return 0;
1452 
1453 fail:
1454  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1455  return ret;
1456 }
1457 
1459 {
1460  av_freep(&s->iccp_data);
1461  s->iccp_data_len = 0;
1462  s->iccp_name[0] = 0;
1463 
1464  s->stereo_mode = -1;
1465 
1466  s->have_chrm = 0;
1467 
1468  av_dict_free(&s->frame_metadata);
1469 }
1470 
1472 {
1473  int ret;
1474 
1475  if (s->iccp_data) {
1477  if (!sd) {
1478  ret = AVERROR(ENOMEM);
1479  goto fail;
1480  }
1481  memcpy(sd->data, s->iccp_data, s->iccp_data_len);
1482 
1483  av_dict_set(&sd->metadata, "name", s->iccp_name, 0);
1484  }
1485 
1486  if (s->stereo_mode >= 0) {
1488  if (!stereo3d) {
1489  ret = AVERROR(ENOMEM);
1490  goto fail;
1491  }
1492 
1493  stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1494  stereo3d->flags = s->stereo_mode ? 0 : AV_STEREO3D_FLAG_INVERT;
1495  }
1496 
1497  if (s->have_chrm) {
1499  if (!mdm) {
1500  ret = AVERROR(ENOMEM);
1501  goto fail;
1502  }
1503 
1504  mdm->white_point[0] = av_make_q(s->white_point[0], 100000);
1505  mdm->white_point[1] = av_make_q(s->white_point[1], 100000);
1506 
1507  /* RGB Primaries */
1508  for (int i = 0; i < 3; i++) {
1509  mdm->display_primaries[i][0] = av_make_q(s->display_primaries[i][0], 100000);
1510  mdm->display_primaries[i][1] = av_make_q(s->display_primaries[i][1], 100000);
1511  }
1512 
1513  mdm->has_primaries = 1;
1514  }
1515 
1516  FFSWAP(AVDictionary*, f->metadata, s->frame_metadata);
1517 
1518  return 0;
1519 fail:
1520  av_frame_unref(f);
1521  return ret;
1522 }
1523 
1524 #if CONFIG_PNG_DECODER
1525 static int decode_frame_png(AVCodecContext *avctx, AVFrame *p,
1526  int *got_frame, AVPacket *avpkt)
1527 {
1528  PNGDecContext *const s = avctx->priv_data;
1529  const uint8_t *buf = avpkt->data;
1530  int buf_size = avpkt->size;
1531  int64_t sig;
1532  int ret;
1533 
1535 
1536  bytestream2_init(&s->gb, buf, buf_size);
1537 
1538  /* check signature */
1539  sig = bytestream2_get_be64(&s->gb);
1540  if (sig != PNGSIG &&
1541  sig != MNGSIG) {
1542  av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature 0x%08"PRIX64".\n", sig);
1543  return AVERROR_INVALIDDATA;
1544  }
1545 
1546  s->y = s->has_trns = 0;
1547  s->hdr_state = 0;
1548  s->pic_state = 0;
1549 
1550  /* Reset z_stream */
1551  ret = inflateReset(&s->zstream.zstream);
1552  if (ret != Z_OK)
1553  return AVERROR_EXTERNAL;
1554 
1555  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1556  goto the_end;
1557 
1558  if (avctx->skip_frame == AVDISCARD_ALL) {
1559  *got_frame = 0;
1560  ret = bytestream2_tell(&s->gb);
1561  goto the_end;
1562  }
1563 
1564  ret = output_frame(s, p);
1565  if (ret < 0)
1566  goto the_end;
1567 
1568  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1569  ff_thread_release_ext_buffer(avctx, &s->last_picture);
1570  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1571  }
1572 
1573  *got_frame = 1;
1574 
1575  ret = bytestream2_tell(&s->gb);
1576 the_end:
1577  s->crow_buf = NULL;
1578  return ret;
1579 }
1580 #endif
1581 
1582 #if CONFIG_APNG_DECODER
1583 static int decode_frame_apng(AVCodecContext *avctx, AVFrame *p,
1584  int *got_frame, AVPacket *avpkt)
1585 {
1586  PNGDecContext *const s = avctx->priv_data;
1587  int ret;
1588 
1590 
1591  if (!(s->hdr_state & PNG_IHDR)) {
1592  if (!avctx->extradata_size)
1593  return AVERROR_INVALIDDATA;
1594 
1595  if ((ret = inflateReset(&s->zstream.zstream)) != Z_OK)
1596  return AVERROR_EXTERNAL;
1597  bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
1598  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1599  return ret;
1600  }
1601 
1602  /* reset state for a new frame */
1603  if ((ret = inflateReset(&s->zstream.zstream)) != Z_OK)
1604  return AVERROR_EXTERNAL;
1605  s->y = 0;
1606  s->pic_state = 0;
1607  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1608  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1609  return ret;
1610 
1611  if (!(s->pic_state & PNG_ALLIMAGE))
1612  av_log(avctx, AV_LOG_WARNING, "Frame did not contain a complete image\n");
1613  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT)))
1614  return AVERROR_INVALIDDATA;
1615 
1616  ret = output_frame(s, p);
1617  if (ret < 0)
1618  return ret;
1619 
1620  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1621  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1622  ff_thread_release_ext_buffer(avctx, &s->picture);
1623  } else {
1624  ff_thread_release_ext_buffer(avctx, &s->last_picture);
1625  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1626  }
1627  }
1628 
1629  *got_frame = 1;
1630  return bytestream2_tell(&s->gb);
1631 }
1632 #endif
1633 
1634 #if HAVE_THREADS
1635 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1636 {
1637  PNGDecContext *psrc = src->priv_data;
1638  PNGDecContext *pdst = dst->priv_data;
1639  ThreadFrame *src_frame = NULL;
1640  int ret;
1641 
1642  if (dst == src)
1643  return 0;
1644 
1645  if (CONFIG_APNG_DECODER && dst->codec_id == AV_CODEC_ID_APNG) {
1646 
1647  pdst->width = psrc->width;
1648  pdst->height = psrc->height;
1649  pdst->bit_depth = psrc->bit_depth;
1650  pdst->color_type = psrc->color_type;
1651  pdst->compression_type = psrc->compression_type;
1652  pdst->interlace_type = psrc->interlace_type;
1653  pdst->filter_type = psrc->filter_type;
1654  pdst->has_trns = psrc->has_trns;
1655  memcpy(pdst->transparent_color_be, psrc->transparent_color_be, sizeof(pdst->transparent_color_be));
1656 
1657  memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
1658 
1659  pdst->hdr_state |= psrc->hdr_state;
1660  }
1661 
1662  src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ?
1663  &psrc->last_picture : &psrc->picture;
1664 
1666  if (src_frame && src_frame->f->data[0]) {
1667  ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
1668  if (ret < 0)
1669  return ret;
1670  }
1671 
1672  return 0;
1673 }
1674 #endif
1675 
1677 {
1678  PNGDecContext *s = avctx->priv_data;
1679 
1680  avctx->color_range = AVCOL_RANGE_JPEG;
1681 
1682  s->avctx = avctx;
1683  s->last_picture.f = av_frame_alloc();
1684  s->picture.f = av_frame_alloc();
1685  if (!s->last_picture.f || !s->picture.f)
1686  return AVERROR(ENOMEM);
1687 
1688  ff_pngdsp_init(&s->dsp);
1689 
1690  return ff_inflate_init(&s->zstream, avctx);
1691 }
1692 
1694 {
1695  PNGDecContext *s = avctx->priv_data;
1696 
1697  ff_thread_release_ext_buffer(avctx, &s->last_picture);
1698  av_frame_free(&s->last_picture.f);
1699  ff_thread_release_ext_buffer(avctx, &s->picture);
1700  av_frame_free(&s->picture.f);
1701  av_freep(&s->buffer);
1702  s->buffer_size = 0;
1703  av_freep(&s->last_row);
1704  s->last_row_size = 0;
1705  av_freep(&s->tmp_row);
1706  s->tmp_row_size = 0;
1707 
1708  av_freep(&s->iccp_data);
1709  av_dict_free(&s->frame_metadata);
1710  ff_inflate_end(&s->zstream);
1711 
1712  return 0;
1713 }
1714 
1715 #if CONFIG_APNG_DECODER
1716 const FFCodec ff_apng_decoder = {
1717  .p.name = "apng",
1718  CODEC_LONG_NAME("APNG (Animated Portable Network Graphics) image"),
1719  .p.type = AVMEDIA_TYPE_VIDEO,
1720  .p.id = AV_CODEC_ID_APNG,
1721  .priv_data_size = sizeof(PNGDecContext),
1722  .init = png_dec_init,
1723  .close = png_dec_end,
1724  FF_CODEC_DECODE_CB(decode_frame_apng),
1726  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1727  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1730 };
1731 #endif
1732 
1733 #if CONFIG_PNG_DECODER
1734 const FFCodec ff_png_decoder = {
1735  .p.name = "png",
1736  CODEC_LONG_NAME("PNG (Portable Network Graphics) image"),
1737  .p.type = AVMEDIA_TYPE_VIDEO,
1738  .p.id = AV_CODEC_ID_PNG,
1739  .priv_data_size = sizeof(PNGDecContext),
1740  .init = png_dec_init,
1741  .close = png_dec_end,
1742  FF_CODEC_DECODE_CB(decode_frame_png),
1744  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1745  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
1748 };
1749 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
PNG_PLTE
@ PNG_PLTE
Definition: pngdec.c:49
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
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:1458
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:198
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
r
const char * r
Definition: vf_curves.c:116
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:133
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1165
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
out
FILE * out
Definition: movenc.c:54
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:679
GetByteContext
Definition: bytestream.h:33
PNG_ALLIMAGE
@ PNG_ALLIMAGE
Definition: pngdec.c:54
AVCRC
uint32_t AVCRC
Definition: crc.h:46
PNGDecContext::last_row_size
unsigned int last_row_size
Definition: pngdec.c:97
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:621
PNGDecContext::bit_depth
int bit_depth
Definition: pngdec.c:83
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
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1351
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:103
av_unused
#define av_unused
Definition: attributes.h:131
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:122
decode_text_chunk
static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
Definition: pngdec.c:523
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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:195
AVFrame::width
int width
Definition: frame.h:397
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:630
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:146
FFCodec
Definition: codec_internal.h:119
PNGDecContext::row_size
int row_size
Definition: pngdec.c:104
FFZStream::zstream
z_stream zstream
Definition: zlib_wrapper.h:28
PNGDecContext::width
int width
Definition: pngdec.c:79
AVDictionary
Definition: dict.c:31
AV_CODEC_ID_APNG
@ AV_CODEC_ID_APNG
Definition: codec_id.h:268
PNGDecContext::tmp_row_size
unsigned int tmp_row_size
Definition: pngdec.c:99
PNGDecContext::color_type
int color_type
Definition: pngdec.c:84
PNGDecContext::cur_h
int cur_h
Definition: pngdec.c:80
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
PNGDecContext::bits_per_pixel
int bits_per_pixel
Definition: pngdec.c:89
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
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
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1328
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
NB_PASSES
#define NB_PASSES
Definition: png.h:47
PNGDecContext::blend_op
uint8_t blend_op
Definition: pngdec.c:82
init
static int init
Definition: av_tx.c:47
crc.h
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:67
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:1076
PNGImageState
PNGImageState
Definition: pngdec.c:52
PNG_FILTER_TYPE_LOCO
#define PNG_FILTER_TYPE_LOCO
Definition: png.h:39
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
PNGDecContext::pass_row_size
int pass_row_size
Definition: pngdec.c:105
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:1698
fail
#define fail()
Definition: checkasm.h:133
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:195
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 AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). 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
png_dec_end
static av_cold int png_dec_end(AVCodecContext *avctx)
Definition: pngdec.c:1693
OP_AVG
#define OP_AVG(x, s, l)
PNGDecContext::pic_state
enum PNGImageState pic_state
Definition: pngdec.c:78
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
decode_idat_chunk
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb, AVFrame *p)
Definition: pngdec.c:637
png_pass_dsp_ymask
static const uint8_t png_pass_dsp_ymask[NB_PASSES]
Definition: pngdec.c:116
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:95
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:72
PNGDecContext::last_row
uint8_t * last_row
Definition: pngdec.c:96
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
PNGDecContext::height
int height
Definition: pngdec.c:79
APNG_DISPOSE_OP_BACKGROUND
@ APNG_DISPOSE_OP_BACKGROUND
Definition: apng.h:32
avassert.h
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
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:611
YUV2RGB
#define YUV2RGB(NAME, TYPE)
Definition: pngdec.c:321
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:279
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:98
s
#define s(width, name)
Definition: cbs_vp9.c:256
ff_apng_decoder
const FFCodec ff_apng_decoder
PNGDecContext::y_offset
int y_offset
Definition: pngdec.c:81
PNGDecContext::palette
uint32_t palette[256]
Definition: pngdec.c:94
g
const char * g
Definition: vf_curves.c:117
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:376
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
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:37
PNGDecContext::hdr_state
enum PNGHeaderState hdr_state
Definition: pngdec.c:77
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:68
decode.h
percent_missing
static int percent_missing(PNGDecContext *s)
Definition: pngdec.c:335
pass
#define pass
Definition: fft_template.c:608
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:885
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
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:57
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:76
threadframe.h
AV_PIX_FMT_GRAY8A
@ AV_PIX_FMT_GRAY8A
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:136
NULL
#define NULL
Definition: coverity.c:32
PNGDecContext::filter_type
int filter_type
Definition: pngdec.c:87
png_decode_idat
static int png_decode_idat(PNGDecContext *s, GetByteContext *gb, uint8_t *dst, ptrdiff_t dst_stride)
Definition: pngdec.c:426
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:1676
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
apng.h
pixel
uint8_t pixel
Definition: tiny_ssim.c:41
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
APNG_BLEND_OP_SOURCE
@ APNG_BLEND_OP_SOURCE
Definition: apng.h:37
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:76
PNGDecContext::channels
int channels
Definition: pngdec.c:88
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
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
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:273
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
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:1167
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:1471
png_pass_mask
static const uint8_t png_pass_mask[NB_PASSES]
Definition: pngdec.c:111
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:102
PNGDecContext::iccp_name
uint8_t iccp_name[82]
Definition: pngdec.c:67
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:912
PNG_FILTER_VALUE_NONE
#define PNG_FILTER_VALUE_NONE
Definition: png.h:40
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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:61
AVPacket::size
int size
Definition: packet.h:375
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:218
handle_p_frame_png
static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1056
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:353
codec_internal.h
PNGDecContext::white_point
uint32_t white_point[2]
Definition: pngdec.c:74
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:771
PNGDecContext::picture
ThreadFrame picture
Definition: pngdec.c:63
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:128
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:202
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
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:233
APNG_BLEND_OP_OVER
@ APNG_BLEND_OP_OVER
Definition: apng.h:38
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:412
PNGDecContext::buffer
uint8_t * buffer
Definition: pngdec.c:100
PNGDecContext::zstream
FFZStream zstream
Definition: pngdec.c:107
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:82
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:380
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:208
decode_trns_chunk
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:831
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
PNGSIG
#define PNGSIG
Definition: png.h:49
PNGDecContext::buffer_size
int buffer_size
Definition: pngdec.c:101
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1477
PNGDecContext::stereo_mode
int stereo_mode
Definition: pngdec.c:71
ff_pngdsp_init
av_cold void ff_pngdsp_init(PNGDSPContext *dsp)
Definition: pngdsp.c:43
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:65
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:477
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:102
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
PNGDecContext::x_offset
int x_offset
Definition: pngdec.c:81
PNGDecContext::display_primaries
uint32_t display_primaries[3][2]
Definition: pngdec.c:75
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
png_handle_row
static void png_handle_row(PNGDecContext *s, uint8_t *dst, ptrdiff_t dst_stride)
Definition: pngdec.c:345
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:49
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1335
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
decode_iccp_chunk
static int decode_iccp_chunk(PNGDecContext *s, GetByteContext *gb, AVFrame *f)
Definition: pngdec.c:879
decode_fctl_chunk
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:985
decode_plte_chunk
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:808
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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:608
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:1067
PNGDecContext::avctx
AVCodecContext * avctx
Definition: pngdec.c:59
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:47
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
tag
uint32_t tag
Definition: movenc.c:1646
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
PNGDecContext::iccp_data_len
size_t iccp_data_len
Definition: pngdec.c:69
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1310
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
PNGDecContext::last_picture
ThreadFrame last_picture
Definition: pngdec.c:62
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
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:85
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:499
PNG_IHDR
@ PNG_IHDR
Definition: pngdec.c:48
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:264
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::height
int height
Definition: frame.h:397
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1485
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:1183
av_mastering_display_metadata_create_side_data
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
Definition: mastering_display_metadata.c:32
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:249
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:92
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:62
PNGDecContext::have_chrm
int have_chrm
Definition: pngdec.c:73
png_pass_dsp_mask
static const uint8_t png_pass_dsp_mask[NB_PASSES]
Definition: pngdec.c:121
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1991
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1327
PNG_IDAT
@ PNG_IDAT
Definition: pngdec.c:53
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:53
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFZStream
Definition: zlib_wrapper.h:27
mastering_display_metadata.h
decode_ihdr_chunk
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:570
PNGDecContext::dsp
PNGDSPContext dsp
Definition: pngdec.c:58
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:231
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:423
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:71
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:156
bytestream.h
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:370
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:37
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:235
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
MNGSIG
#define MNGSIG
Definition: png.h:50
PNGDecContext::interlace_type
int interlace_type
Definition: pngdec.c:86
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:176
handle_p_frame_apng
static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1078
PNGDecContext::y
int y
Definition: pngdec.c:106
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)
decode_zbuf
static int decode_zbuf(AVBPrint *bp, const uint8_t *data, const uint8_t *data_end, void *logctx)
Definition: pngdec.c:457
APNG_DISPOSE_OP_PREVIOUS
@ APNG_DISPOSE_OP_PREVIOUS
Definition: apng.h:33
PNGDecContext::cur_w
int cur_w
Definition: pngdec.c:80
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:768
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:70
PNGDecContext::bpp
int bpp
Definition: pngdec.c:90
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:2780
PNGDecContext::has_trns
int has_trns
Definition: pngdec.c:91
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:354