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 "libavutil/avassert.h"
25 #include "libavutil/bprint.h"
26 #include "libavutil/crc.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/stereo3d.h"
31 
32 #include "avcodec.h"
33 #include "bytestream.h"
34 #include "internal.h"
35 #include "apng.h"
36 #include "png.h"
37 #include "pngdsp.h"
38 #include "thread.h"
39 
40 #include <zlib.h>
41 
43  PNG_IHDR = 1 << 0,
44  PNG_PLTE = 1 << 1,
45 };
46 
48  PNG_IDAT = 1 << 0,
49  PNG_ALLIMAGE = 1 << 1,
50 };
51 
52 typedef struct PNGDecContext {
55 
59 
61 
62  uint8_t iccp_name[82];
63  uint8_t *iccp_data;
64  size_t iccp_data_len;
65 
67 
68  int have_chrm;
69  uint32_t white_point[2];
70  uint32_t display_primaries[3][2];
71 
74  int width, height;
75  int cur_w, cur_h;
76  int last_w, last_h;
79  uint8_t dispose_op, blend_op;
80  uint8_t last_dispose_op;
81  int bit_depth;
86  int channels;
88  int bpp;
89  int has_trns;
91 
92  uint8_t *background_buf;
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;
107  z_stream zstream;
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  int ret;
430  s->zstream.avail_in = bytestream2_get_bytes_left(gb);
431  s->zstream.next_in = gb->buffer;
432 
433  /* decode one line if possible */
434  while (s->zstream.avail_in > 0) {
435  ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
436  if (ret != Z_OK && ret != Z_STREAM_END) {
437  av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
438  return AVERROR_EXTERNAL;
439  }
440  if (s->zstream.avail_out == 0) {
441  if (!(s->pic_state & PNG_ALLIMAGE)) {
442  png_handle_row(s, dst, dst_stride);
443  }
444  s->zstream.avail_out = s->crow_size;
445  s->zstream.next_out = s->crow_buf;
446  }
447  if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
448  av_log(s->avctx, AV_LOG_WARNING,
449  "%d undecompressed bytes left in buffer\n", s->zstream.avail_in);
450  return 0;
451  }
452  }
453  return 0;
454 }
455 
456 static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
457  const uint8_t *data_end)
458 {
459  z_stream zstream;
460  unsigned char *buf;
461  unsigned buf_size;
462  int ret;
463 
464  zstream.zalloc = ff_png_zalloc;
465  zstream.zfree = ff_png_zfree;
466  zstream.opaque = NULL;
467  if (inflateInit(&zstream) != Z_OK)
468  return AVERROR_EXTERNAL;
469  zstream.next_in = data;
470  zstream.avail_in = data_end - data;
472 
473  while (zstream.avail_in > 0) {
474  av_bprint_get_buffer(bp, 2, &buf, &buf_size);
475  if (buf_size < 2) {
476  ret = AVERROR(ENOMEM);
477  goto fail;
478  }
479  zstream.next_out = buf;
480  zstream.avail_out = buf_size - 1;
481  ret = inflate(&zstream, Z_PARTIAL_FLUSH);
482  if (ret != Z_OK && ret != Z_STREAM_END) {
484  goto fail;
485  }
486  bp->len += zstream.next_out - buf;
487  if (ret == Z_STREAM_END)
488  break;
489  }
490  inflateEnd(&zstream);
491  bp->str[bp->len] = 0;
492  return 0;
493 
494 fail:
495  inflateEnd(&zstream);
497  return ret;
498 }
499 
500 static uint8_t *iso88591_to_utf8(const uint8_t *in, size_t size_in)
501 {
502  size_t extra = 0, i;
503  uint8_t *out, *q;
504 
505  for (i = 0; i < size_in; i++)
506  extra += in[i] >= 0x80;
507  if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
508  return NULL;
509  q = out = av_malloc(size_in + extra + 1);
510  if (!out)
511  return NULL;
512  for (i = 0; i < size_in; i++) {
513  if (in[i] >= 0x80) {
514  *(q++) = 0xC0 | (in[i] >> 6);
515  *(q++) = 0x80 | (in[i] & 0x3F);
516  } else {
517  *(q++) = in[i];
518  }
519  }
520  *(q++) = 0;
521  return out;
522 }
523 
524 static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
525 {
526  int ret, method;
527  const uint8_t *data = gb->buffer;
528  const uint8_t *data_end = gb->buffer_end;
529  const uint8_t *keyword = data;
530  const uint8_t *keyword_end = memchr(keyword, 0, data_end - keyword);
531  uint8_t *kw_utf8 = NULL, *text, *txt_utf8 = NULL;
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)) < 0)
546  return ret;
547  text_len = bp.len;
548  ret = av_bprint_finalize(&bp, (char **)&text);
549  if (ret < 0)
550  return ret;
551  } else {
552  text = (uint8_t *)data;
553  text_len = data_end - text;
554  }
555 
556  kw_utf8 = iso88591_to_utf8(keyword, keyword_end - keyword);
557  txt_utf8 = iso88591_to_utf8(text, text_len);
558  if (text != data)
559  av_free(text);
560  if (!(kw_utf8 && txt_utf8)) {
561  av_free(kw_utf8);
562  av_free(txt_utf8);
563  return AVERROR(ENOMEM);
564  }
565 
566  av_dict_set(&s->frame_metadata, kw_utf8, txt_utf8,
568  return 0;
569 }
570 
572  GetByteContext *gb)
573 {
574  if (bytestream2_get_bytes_left(gb) != 13)
575  return AVERROR_INVALIDDATA;
576 
577  if (s->pic_state & PNG_IDAT) {
578  av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
579  return AVERROR_INVALIDDATA;
580  }
581 
582  if (s->hdr_state & PNG_IHDR) {
583  av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
584  return AVERROR_INVALIDDATA;
585  }
586 
587  s->width = s->cur_w = bytestream2_get_be32(gb);
588  s->height = s->cur_h = bytestream2_get_be32(gb);
589  if (av_image_check_size(s->width, s->height, 0, avctx)) {
590  s->cur_w = s->cur_h = s->width = s->height = 0;
591  av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
592  return AVERROR_INVALIDDATA;
593  }
594  s->bit_depth = bytestream2_get_byte(gb);
595  if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
596  s->bit_depth != 8 && s->bit_depth != 16) {
597  av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
598  goto error;
599  }
600  s->color_type = bytestream2_get_byte(gb);
601  s->compression_type = bytestream2_get_byte(gb);
602  if (s->compression_type) {
603  av_log(avctx, AV_LOG_ERROR, "Invalid compression method %d\n", s->compression_type);
604  goto error;
605  }
606  s->filter_type = bytestream2_get_byte(gb);
607  s->interlace_type = bytestream2_get_byte(gb);
608  s->hdr_state |= PNG_IHDR;
609  if (avctx->debug & FF_DEBUG_PICT_INFO)
610  av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
611  "compression_type=%d filter_type=%d interlace_type=%d\n",
612  s->width, s->height, s->bit_depth, s->color_type,
613  s->compression_type, s->filter_type, s->interlace_type);
614 
615  return 0;
616 error:
617  s->cur_w = s->cur_h = s->width = s->height = 0;
618  s->bit_depth = 8;
619  return AVERROR_INVALIDDATA;
620 }
621 
623  GetByteContext *gb)
624 {
625  if (s->pic_state & PNG_IDAT) {
626  av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
627  return AVERROR_INVALIDDATA;
628  }
629  avctx->sample_aspect_ratio.num = bytestream2_get_be32(gb);
630  avctx->sample_aspect_ratio.den = bytestream2_get_be32(gb);
631  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
632  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
633  bytestream2_skip(gb, 1); /* unit specifier */
634 
635  return 0;
636 }
637 
639  GetByteContext *gb, AVFrame *p)
640 {
641  int ret;
642  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
643 
644  if (!(s->hdr_state & PNG_IHDR)) {
645  av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
646  return AVERROR_INVALIDDATA;
647  }
648  if (!(s->pic_state & PNG_IDAT)) {
649  /* init image info */
650  ret = ff_set_dimensions(avctx, s->width, s->height);
651  if (ret < 0)
652  return ret;
653 
654  s->channels = ff_png_get_nb_channels(s->color_type);
655  s->bits_per_pixel = s->bit_depth * s->channels;
656  s->bpp = (s->bits_per_pixel + 7) >> 3;
657  s->row_size = (s->cur_w * s->bits_per_pixel + 7) >> 3;
658 
659  if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
660  s->color_type == PNG_COLOR_TYPE_RGB) {
661  avctx->pix_fmt = AV_PIX_FMT_RGB24;
662  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
663  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
664  avctx->pix_fmt = AV_PIX_FMT_RGBA;
665  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
666  s->color_type == PNG_COLOR_TYPE_GRAY) {
667  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
668  } else if (s->bit_depth == 16 &&
669  s->color_type == PNG_COLOR_TYPE_GRAY) {
670  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
671  } else if (s->bit_depth == 16 &&
672  s->color_type == PNG_COLOR_TYPE_RGB) {
673  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
674  } else if (s->bit_depth == 16 &&
675  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
676  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
677  } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
678  s->color_type == PNG_COLOR_TYPE_PALETTE) {
679  avctx->pix_fmt = AV_PIX_FMT_PAL8;
680  } else if (s->bit_depth == 1 && s->bits_per_pixel == 1 && avctx->codec_id != AV_CODEC_ID_APNG) {
681  avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
682  } else if (s->bit_depth == 8 &&
683  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
684  avctx->pix_fmt = AV_PIX_FMT_YA8;
685  } else if (s->bit_depth == 16 &&
686  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
687  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
688  } else {
690  "Bit depth %d color type %d",
691  s->bit_depth, s->color_type);
692  return AVERROR_PATCHWELCOME;
693  }
694 
695  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
696  switch (avctx->pix_fmt) {
697  case AV_PIX_FMT_RGB24:
698  avctx->pix_fmt = AV_PIX_FMT_RGBA;
699  break;
700 
701  case AV_PIX_FMT_RGB48BE:
702  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
703  break;
704 
705  case AV_PIX_FMT_GRAY8:
706  avctx->pix_fmt = AV_PIX_FMT_YA8;
707  break;
708 
709  case AV_PIX_FMT_GRAY16BE:
710  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
711  break;
712 
713  default:
714  avpriv_request_sample(avctx, "bit depth %d "
715  "and color type %d with TRNS",
716  s->bit_depth, s->color_type);
717  return AVERROR_INVALIDDATA;
718  }
719 
720  s->bpp += byte_depth;
721  }
722 
723  ff_thread_release_buffer(avctx, &s->picture);
724  if ((ret = ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
725  return ret;
726 
728  p->key_frame = 1;
729  p->interlaced_frame = !!s->interlace_type;
730 
731  ff_thread_finish_setup(avctx);
732 
733  /* compute the compressed row size */
734  if (!s->interlace_type) {
735  s->crow_size = s->row_size + 1;
736  } else {
737  s->pass = 0;
738  s->pass_row_size = ff_png_pass_row_size(s->pass,
739  s->bits_per_pixel,
740  s->cur_w);
741  s->crow_size = s->pass_row_size + 1;
742  }
743  ff_dlog(avctx, "row_size=%d crow_size =%d\n",
744  s->row_size, s->crow_size);
745 
746  /* copy the palette if needed */
747  if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
748  memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
749  /* empty row is used if differencing to the first row */
750  av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
751  if (!s->last_row)
752  return AVERROR_INVALIDDATA;
753  if (s->interlace_type ||
754  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
755  av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
756  if (!s->tmp_row)
757  return AVERROR_INVALIDDATA;
758  }
759  /* compressed row */
760  av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
761  if (!s->buffer)
762  return AVERROR(ENOMEM);
763 
764  /* we want crow_buf+1 to be 16-byte aligned */
765  s->crow_buf = s->buffer + 15;
766  s->zstream.avail_out = s->crow_size;
767  s->zstream.next_out = s->crow_buf;
768  }
769 
770  s->pic_state |= PNG_IDAT;
771 
772  /* set image to non-transparent bpp while decompressing */
773  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
774  s->bpp -= byte_depth;
775 
776  ret = png_decode_idat(s, gb, p->data[0], p->linesize[0]);
777 
778  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
779  s->bpp += byte_depth;
780 
781  if (ret < 0)
782  return ret;
783 
784  return 0;
785 }
786 
788  GetByteContext *gb)
789 {
790  int length = bytestream2_get_bytes_left(gb);
791  int n, i, r, g, b;
792 
793  if ((length % 3) != 0 || length > 256 * 3)
794  return AVERROR_INVALIDDATA;
795  /* read the palette */
796  n = length / 3;
797  for (i = 0; i < n; i++) {
798  r = bytestream2_get_byte(gb);
799  g = bytestream2_get_byte(gb);
800  b = bytestream2_get_byte(gb);
801  s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
802  }
803  for (; i < 256; i++)
804  s->palette[i] = (0xFFU << 24);
805  s->hdr_state |= PNG_PLTE;
806 
807  return 0;
808 }
809 
811  GetByteContext *gb)
812 {
813  int length = bytestream2_get_bytes_left(gb);
814  int v, i;
815 
816  if (!(s->hdr_state & PNG_IHDR)) {
817  av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
818  return AVERROR_INVALIDDATA;
819  }
820 
821  if (s->pic_state & PNG_IDAT) {
822  av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
823  return AVERROR_INVALIDDATA;
824  }
825 
826  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
827  if (length > 256 || !(s->hdr_state & PNG_PLTE))
828  return AVERROR_INVALIDDATA;
829 
830  for (i = 0; i < length; i++) {
831  unsigned v = bytestream2_get_byte(gb);
832  s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
833  }
834  } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
835  if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
836  (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
837  s->bit_depth == 1)
838  return AVERROR_INVALIDDATA;
839 
840  for (i = 0; i < length / 2; i++) {
841  /* only use the least significant bits */
842  v = av_mod_uintp2(bytestream2_get_be16(gb), s->bit_depth);
843 
844  if (s->bit_depth > 8)
845  AV_WB16(&s->transparent_color_be[2 * i], v);
846  else
847  s->transparent_color_be[i] = v;
848  }
849  } else {
850  return AVERROR_INVALIDDATA;
851  }
852 
853  s->has_trns = 1;
854 
855  return 0;
856 }
857 
859 {
860  int ret, cnt = 0;
861  AVBPrint bp;
862 
863  while ((s->iccp_name[cnt++] = bytestream2_get_byte(gb)) && cnt < 81);
864  if (cnt > 80) {
865  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
867  goto fail;
868  }
869 
870  if (bytestream2_get_byte(gb) != 0) {
871  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
873  goto fail;
874  }
875 
876  if ((ret = decode_zbuf(&bp, gb->buffer, gb->buffer_end)) < 0)
877  return ret;
878 
879  av_freep(&s->iccp_data);
880  ret = av_bprint_finalize(&bp, (char **)&s->iccp_data);
881  if (ret < 0)
882  return ret;
883  s->iccp_data_len = bp.len;
884 
885  return 0;
886 fail:
887  s->iccp_name[0] = 0;
888  return ret;
889 }
890 
892 {
893  if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
894  int i, j, k;
895  uint8_t *pd = p->data[0];
896  for (j = 0; j < s->height; j++) {
897  i = s->width / 8;
898  for (k = 7; k >= 1; k--)
899  if ((s->width&7) >= k)
900  pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
901  for (i--; i >= 0; i--) {
902  pd[8*i + 7]= pd[i] & 1;
903  pd[8*i + 6]= (pd[i]>>1) & 1;
904  pd[8*i + 5]= (pd[i]>>2) & 1;
905  pd[8*i + 4]= (pd[i]>>3) & 1;
906  pd[8*i + 3]= (pd[i]>>4) & 1;
907  pd[8*i + 2]= (pd[i]>>5) & 1;
908  pd[8*i + 1]= (pd[i]>>6) & 1;
909  pd[8*i + 0]= pd[i]>>7;
910  }
911  pd += p->linesize[0];
912  }
913  } else if (s->bits_per_pixel == 2) {
914  int i, j;
915  uint8_t *pd = p->data[0];
916  for (j = 0; j < s->height; j++) {
917  i = s->width / 4;
918  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
919  if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
920  if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
921  if ((s->width&3) >= 1) pd[4*i + 0]= pd[i] >> 6;
922  for (i--; i >= 0; i--) {
923  pd[4*i + 3]= pd[i] & 3;
924  pd[4*i + 2]= (pd[i]>>2) & 3;
925  pd[4*i + 1]= (pd[i]>>4) & 3;
926  pd[4*i + 0]= pd[i]>>6;
927  }
928  } else {
929  if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
930  if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
931  if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6 )*0x55;
932  for (i--; i >= 0; i--) {
933  pd[4*i + 3]= ( pd[i] & 3)*0x55;
934  pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
935  pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
936  pd[4*i + 0]= ( pd[i]>>6 )*0x55;
937  }
938  }
939  pd += p->linesize[0];
940  }
941  } else if (s->bits_per_pixel == 4) {
942  int i, j;
943  uint8_t *pd = p->data[0];
944  for (j = 0; j < s->height; j++) {
945  i = s->width/2;
946  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
947  if (s->width&1) pd[2*i+0]= pd[i]>>4;
948  for (i--; i >= 0; i--) {
949  pd[2*i + 1] = pd[i] & 15;
950  pd[2*i + 0] = pd[i] >> 4;
951  }
952  } else {
953  if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
954  for (i--; i >= 0; i--) {
955  pd[2*i + 1] = (pd[i] & 15) * 0x11;
956  pd[2*i + 0] = (pd[i] >> 4) * 0x11;
957  }
958  }
959  pd += p->linesize[0];
960  }
961  }
962 }
963 
965  GetByteContext *gb)
966 {
967  uint32_t sequence_number;
968  int cur_w, cur_h, x_offset, y_offset, dispose_op, blend_op;
969 
970  if (bytestream2_get_bytes_left(gb) != 26)
971  return AVERROR_INVALIDDATA;
972 
973  if (!(s->hdr_state & PNG_IHDR)) {
974  av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
975  return AVERROR_INVALIDDATA;
976  }
977 
978  if (s->pic_state & PNG_IDAT) {
979  av_log(avctx, AV_LOG_ERROR, "fctl after IDAT\n");
980  return AVERROR_INVALIDDATA;
981  }
982 
983  s->last_w = s->cur_w;
984  s->last_h = s->cur_h;
985  s->last_x_offset = s->x_offset;
986  s->last_y_offset = s->y_offset;
987  s->last_dispose_op = s->dispose_op;
988 
989  sequence_number = bytestream2_get_be32(gb);
990  cur_w = bytestream2_get_be32(gb);
991  cur_h = bytestream2_get_be32(gb);
992  x_offset = bytestream2_get_be32(gb);
993  y_offset = bytestream2_get_be32(gb);
994  bytestream2_skip(gb, 4); /* delay_num (2), delay_den (2) */
995  dispose_op = bytestream2_get_byte(gb);
996  blend_op = bytestream2_get_byte(gb);
997 
998  if (sequence_number == 0 &&
999  (cur_w != s->width ||
1000  cur_h != s->height ||
1001  x_offset != 0 ||
1002  y_offset != 0) ||
1003  cur_w <= 0 || cur_h <= 0 ||
1004  x_offset < 0 || y_offset < 0 ||
1005  cur_w > s->width - x_offset|| cur_h > s->height - y_offset)
1006  return AVERROR_INVALIDDATA;
1007 
1008  if (blend_op != APNG_BLEND_OP_OVER && blend_op != APNG_BLEND_OP_SOURCE) {
1009  av_log(avctx, AV_LOG_ERROR, "Invalid blend_op %d\n", blend_op);
1010  return AVERROR_INVALIDDATA;
1011  }
1012 
1013  if ((sequence_number == 0 || !s->last_picture.f->data[0]) &&
1014  dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1015  // No previous frame to revert to for the first frame
1016  // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
1017  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
1018  }
1019 
1020  if (blend_op == APNG_BLEND_OP_OVER && !s->has_trns && (
1021  avctx->pix_fmt == AV_PIX_FMT_RGB24 ||
1022  avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1023  avctx->pix_fmt == AV_PIX_FMT_PAL8 ||
1024  avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
1025  avctx->pix_fmt == AV_PIX_FMT_GRAY16BE ||
1026  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK
1027  )) {
1028  // APNG_BLEND_OP_OVER is the same as APNG_BLEND_OP_SOURCE when there is no alpha channel
1029  blend_op = APNG_BLEND_OP_SOURCE;
1030  }
1031 
1032  s->cur_w = cur_w;
1033  s->cur_h = cur_h;
1034  s->x_offset = x_offset;
1035  s->y_offset = y_offset;
1036  s->dispose_op = dispose_op;
1037  s->blend_op = blend_op;
1038 
1039  return 0;
1040 }
1041 
1043 {
1044  int i, j;
1045  uint8_t *pd = p->data[0];
1046  uint8_t *pd_last = s->last_picture.f->data[0];
1047  int ls = FFMIN(av_image_get_linesize(p->format, s->width, 0), s->width * s->bpp);
1048 
1049  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1050  for (j = 0; j < s->height; j++) {
1051  for (i = 0; i < ls; i++)
1052  pd[i] += pd_last[i];
1053  pd += p->linesize[0];
1054  pd_last += s->last_picture.f->linesize[0];
1055  }
1056 }
1057 
1058 // divide by 255 and round to nearest
1059 // apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
1060 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
1061 
1063  AVFrame *p)
1064 {
1065  uint8_t *dst = p->data[0];
1066  ptrdiff_t dst_stride = p->linesize[0];
1067  const uint8_t *src = s->last_picture.f->data[0];
1068  ptrdiff_t src_stride = s->last_picture.f->linesize[0];
1069 
1070  size_t x, y;
1071 
1072  if (s->blend_op == APNG_BLEND_OP_OVER &&
1073  avctx->pix_fmt != AV_PIX_FMT_RGBA &&
1074  avctx->pix_fmt != AV_PIX_FMT_GRAY8A &&
1075  avctx->pix_fmt != AV_PIX_FMT_PAL8) {
1076  avpriv_request_sample(avctx, "Blending with pixel format %s",
1077  av_get_pix_fmt_name(avctx->pix_fmt));
1078  return AVERROR_PATCHWELCOME;
1079  }
1080 
1081  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1082 
1083  // need to reset a rectangle to background:
1084  if (s->last_dispose_op == APNG_DISPOSE_OP_BACKGROUND) {
1085  av_fast_malloc(&s->background_buf, &s->background_buf_allocated,
1086  src_stride * p->height);
1087  if (!s->background_buf)
1088  return AVERROR(ENOMEM);
1089 
1090  memcpy(s->background_buf, src, src_stride * p->height);
1091 
1092  for (y = s->last_y_offset; y < s->last_y_offset + s->last_h; y++) {
1093  memset(s->background_buf + src_stride * y +
1094  s->bpp * s->last_x_offset, 0, s->bpp * s->last_w);
1095  }
1096 
1097  src = s->background_buf;
1098  }
1099 
1100  // copy unchanged rectangles from the last frame
1101  for (y = 0; y < s->y_offset; y++)
1102  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1103  for (y = s->y_offset; y < s->y_offset + s->cur_h; y++) {
1104  memcpy(dst + y * dst_stride, src + y * src_stride, s->x_offset * s->bpp);
1105  memcpy(dst + y * dst_stride + (s->x_offset + s->cur_w) * s->bpp,
1106  src + y * src_stride + (s->x_offset + s->cur_w) * s->bpp,
1107  (p->width - s->cur_w - s->x_offset) * s->bpp);
1108  }
1109  for (y = s->y_offset + s->cur_h; y < p->height; y++)
1110  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1111 
1112  if (s->blend_op == APNG_BLEND_OP_OVER) {
1113  // Perform blending
1114  for (y = s->y_offset; y < s->y_offset + s->cur_h; ++y) {
1115  uint8_t *foreground = dst + dst_stride * y + s->bpp * s->x_offset;
1116  const uint8_t *background = src + src_stride * y + s->bpp * s->x_offset;
1117  for (x = s->x_offset; x < s->x_offset + s->cur_w; ++x, foreground += s->bpp, background += s->bpp) {
1118  size_t b;
1119  uint8_t foreground_alpha, background_alpha, output_alpha;
1120  uint8_t output[10];
1121 
1122  // Since we might be blending alpha onto alpha, we use the following equations:
1123  // output_alpha = foreground_alpha + (1 - foreground_alpha) * background_alpha
1124  // output = (foreground_alpha * foreground + (1 - foreground_alpha) * background_alpha * background) / output_alpha
1125 
1126  switch (avctx->pix_fmt) {
1127  case AV_PIX_FMT_RGBA:
1128  foreground_alpha = foreground[3];
1129  background_alpha = background[3];
1130  break;
1131 
1132  case AV_PIX_FMT_GRAY8A:
1133  foreground_alpha = foreground[1];
1134  background_alpha = background[1];
1135  break;
1136 
1137  case AV_PIX_FMT_PAL8:
1138  foreground_alpha = s->palette[foreground[0]] >> 24;
1139  background_alpha = s->palette[background[0]] >> 24;
1140  break;
1141  }
1142 
1143  if (foreground_alpha == 255)
1144  continue;
1145 
1146  if (foreground_alpha == 0) {
1147  memcpy(foreground, background, s->bpp);
1148  continue;
1149  }
1150 
1151  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1152  // TODO: Alpha blending with PAL8 will likely need the entire image converted over to RGBA first
1153  avpriv_request_sample(avctx, "Alpha blending palette samples");
1154  continue;
1155  }
1156 
1157  output_alpha = foreground_alpha + FAST_DIV255((255 - foreground_alpha) * background_alpha);
1158 
1159  av_assert0(s->bpp <= 10);
1160 
1161  for (b = 0; b < s->bpp - 1; ++b) {
1162  if (output_alpha == 0) {
1163  output[b] = 0;
1164  } else if (background_alpha == 255) {
1165  output[b] = FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1166  } else {
1167  output[b] = (255 * foreground_alpha * foreground[b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1168  }
1169  }
1170  output[b] = output_alpha;
1171  memcpy(foreground, output, s->bpp);
1172  }
1173  }
1174  }
1175 
1176  return 0;
1177 }
1178 
1180  AVFrame *p, const AVPacket *avpkt)
1181 {
1182  const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1183  uint32_t tag, length;
1184  int decode_next_dat = 0;
1185  int i, ret;
1186 
1187  for (;;) {
1188  GetByteContext gb_chunk;
1189 
1190  length = bytestream2_get_bytes_left(&s->gb);
1191  if (length <= 0) {
1192 
1193  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1194  avctx->skip_frame == AVDISCARD_ALL) {
1195  return 0;
1196  }
1197 
1198  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
1199  if (!(s->pic_state & PNG_IDAT))
1200  return 0;
1201  else
1202  goto exit_loop;
1203  }
1204  av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
1205  if ( s->pic_state & PNG_ALLIMAGE
1207  goto exit_loop;
1209  goto fail;
1210  }
1211 
1212  length = bytestream2_get_be32(&s->gb);
1213  if (length > 0x7fffffff || length + 8 > bytestream2_get_bytes_left(&s->gb)) {
1214  av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
1216  goto fail;
1217  }
1218  if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_IGNORE_ERR)) {
1219  uint32_t crc_sig = AV_RB32(s->gb.buffer + length + 4);
1220  uint32_t crc_cal = ~av_crc(crc_tab, UINT32_MAX, s->gb.buffer, length + 4);
1221  if (crc_sig ^ crc_cal) {
1222  av_log(avctx, AV_LOG_ERROR, "CRC mismatch in chunk");
1223  if (avctx->err_recognition & AV_EF_EXPLODE) {
1224  av_log(avctx, AV_LOG_ERROR, ", quitting\n");
1226  goto fail;
1227  }
1228  av_log(avctx, AV_LOG_ERROR, ", skipping\n");
1229  bytestream2_skip(&s->gb, length + 8); /* tag */
1230  }
1231  }
1232  tag = bytestream2_get_le32(&s->gb);
1233  if (avctx->debug & FF_DEBUG_STARTCODE)
1234  av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
1235  av_fourcc2str(tag), length);
1236 
1237  bytestream2_init(&gb_chunk, s->gb.buffer, length);
1238  bytestream2_skip(&s->gb, length + 4);
1239 
1240  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1241  avctx->skip_frame == AVDISCARD_ALL) {
1242  switch(tag) {
1243  case MKTAG('I', 'H', 'D', 'R'):
1244  case MKTAG('p', 'H', 'Y', 's'):
1245  case MKTAG('t', 'E', 'X', 't'):
1246  case MKTAG('I', 'D', 'A', 'T'):
1247  case MKTAG('t', 'R', 'N', 'S'):
1248  break;
1249  default:
1250  continue;
1251  }
1252  }
1253 
1254  switch (tag) {
1255  case MKTAG('I', 'H', 'D', 'R'):
1256  if ((ret = decode_ihdr_chunk(avctx, s, &gb_chunk)) < 0)
1257  goto fail;
1258  break;
1259  case MKTAG('p', 'H', 'Y', 's'):
1260  if ((ret = decode_phys_chunk(avctx, s, &gb_chunk)) < 0)
1261  goto fail;
1262  break;
1263  case MKTAG('f', 'c', 'T', 'L'):
1264  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1265  continue;
1266  if ((ret = decode_fctl_chunk(avctx, s, &gb_chunk)) < 0)
1267  goto fail;
1268  decode_next_dat = 1;
1269  break;
1270  case MKTAG('f', 'd', 'A', 'T'):
1271  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1272  continue;
1273  if (!decode_next_dat || bytestream2_get_bytes_left(&gb_chunk) < 4) {
1275  goto fail;
1276  }
1277  bytestream2_get_be32(&gb_chunk);
1278  /* fallthrough */
1279  case MKTAG('I', 'D', 'A', 'T'):
1280  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && !decode_next_dat)
1281  continue;
1282  if ((ret = decode_idat_chunk(avctx, s, &gb_chunk, p)) < 0)
1283  goto fail;
1284  break;
1285  case MKTAG('P', 'L', 'T', 'E'):
1286  decode_plte_chunk(avctx, s, &gb_chunk);
1287  break;
1288  case MKTAG('t', 'R', 'N', 'S'):
1289  decode_trns_chunk(avctx, s, &gb_chunk);
1290  break;
1291  case MKTAG('t', 'E', 'X', 't'):
1292  if (decode_text_chunk(s, &gb_chunk, 0) < 0)
1293  av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
1294  break;
1295  case MKTAG('z', 'T', 'X', 't'):
1296  if (decode_text_chunk(s, &gb_chunk, 1) < 0)
1297  av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
1298  break;
1299  case MKTAG('s', 'T', 'E', 'R'): {
1300  int mode = bytestream2_get_byte(&gb_chunk);
1301 
1302  if (mode == 0 || mode == 1) {
1303  s->stereo_mode = mode;
1304  } else {
1305  av_log(avctx, AV_LOG_WARNING,
1306  "Unknown value in sTER chunk (%d)\n", mode);
1307  }
1308  break;
1309  }
1310  case MKTAG('i', 'C', 'C', 'P'): {
1311  if ((ret = decode_iccp_chunk(s, &gb_chunk, p)) < 0)
1312  goto fail;
1313  break;
1314  }
1315  case MKTAG('c', 'H', 'R', 'M'): {
1316  s->have_chrm = 1;
1317 
1318  s->white_point[0] = bytestream2_get_be32(&gb_chunk);
1319  s->white_point[1] = bytestream2_get_be32(&gb_chunk);
1320 
1321  /* RGB Primaries */
1322  for (i = 0; i < 3; i++) {
1323  s->display_primaries[i][0] = bytestream2_get_be32(&gb_chunk);
1324  s->display_primaries[i][1] = bytestream2_get_be32(&gb_chunk);
1325  }
1326 
1327  break;
1328  }
1329  case MKTAG('g', 'A', 'M', 'A'): {
1330  AVBPrint bp;
1331  char *gamma_str;
1332  int num = bytestream2_get_be32(&gb_chunk);
1333 
1335  av_bprintf(&bp, "%i/%i", num, 100000);
1336  ret = av_bprint_finalize(&bp, &gamma_str);
1337  if (ret < 0)
1338  return ret;
1339 
1340  av_dict_set(&s->frame_metadata, "gamma", gamma_str, AV_DICT_DONT_STRDUP_VAL);
1341 
1342  break;
1343  }
1344  case MKTAG('I', 'E', 'N', 'D'):
1345  if (!(s->pic_state & PNG_ALLIMAGE))
1346  av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
1347  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1349  goto fail;
1350  }
1351  goto exit_loop;
1352  }
1353  }
1354 exit_loop:
1355 
1356  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1357  avctx->skip_frame == AVDISCARD_ALL) {
1358  return 0;
1359  }
1360 
1362  return AVERROR_INVALIDDATA;
1363 
1364  if (s->bits_per_pixel <= 4)
1365  handle_small_bpp(s, p);
1366 
1367  /* apply transparency if needed */
1368  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
1369  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
1370  size_t raw_bpp = s->bpp - byte_depth;
1371  unsigned x, y;
1372 
1373  av_assert0(s->bit_depth > 1);
1374 
1375  for (y = 0; y < s->height; ++y) {
1376  uint8_t *row = &p->data[0][p->linesize[0] * y];
1377 
1378  if (s->bpp == 2 && byte_depth == 1) {
1379  uint8_t *pixel = &row[2 * s->width - 1];
1380  uint8_t *rowp = &row[1 * s->width - 1];
1381  int tcolor = s->transparent_color_be[0];
1382  for (x = s->width; x > 0; --x) {
1383  *pixel-- = *rowp == tcolor ? 0 : 0xff;
1384  *pixel-- = *rowp--;
1385  }
1386  } else if (s->bpp == 4 && byte_depth == 1) {
1387  uint8_t *pixel = &row[4 * s->width - 1];
1388  uint8_t *rowp = &row[3 * s->width - 1];
1389  int tcolor = AV_RL24(s->transparent_color_be);
1390  for (x = s->width; x > 0; --x) {
1391  *pixel-- = AV_RL24(rowp-2) == tcolor ? 0 : 0xff;
1392  *pixel-- = *rowp--;
1393  *pixel-- = *rowp--;
1394  *pixel-- = *rowp--;
1395  }
1396  } else {
1397  /* since we're updating in-place, we have to go from right to left */
1398  for (x = s->width; x > 0; --x) {
1399  uint8_t *pixel = &row[s->bpp * (x - 1)];
1400  memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1401 
1402  if (!memcmp(pixel, s->transparent_color_be, raw_bpp)) {
1403  memset(&pixel[raw_bpp], 0, byte_depth);
1404  } else {
1405  memset(&pixel[raw_bpp], 0xff, byte_depth);
1406  }
1407  }
1408  }
1409  }
1410  }
1411 
1412  /* handle P-frames only if a predecessor frame is available */
1413  if (s->last_picture.f->data[0]) {
1414  if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
1415  && s->last_picture.f->width == p->width
1416  && s->last_picture.f->height== p->height
1417  && s->last_picture.f->format== p->format
1418  ) {
1419  if (CONFIG_PNG_DECODER && avctx->codec_id != AV_CODEC_ID_APNG)
1420  handle_p_frame_png(s, p);
1421  else if (CONFIG_APNG_DECODER &&
1422  avctx->codec_id == AV_CODEC_ID_APNG &&
1423  (ret = handle_p_frame_apng(avctx, s, p)) < 0)
1424  goto fail;
1425  }
1426  }
1427  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1428 
1429  return 0;
1430 
1431 fail:
1432  ff_thread_report_progress(&s->picture, INT_MAX, 0);
1433  return ret;
1434 }
1435 
1437 {
1438  av_freep(&s->iccp_data);
1439  s->iccp_data_len = 0;
1440  s->iccp_name[0] = 0;
1441 
1442  s->stereo_mode = -1;
1443 
1444  s->have_chrm = 0;
1445 
1446  av_dict_free(&s->frame_metadata);
1447 }
1448 
1450  const AVFrame *src)
1451 {
1452  int ret;
1453 
1454  ret = av_frame_ref(f, src);
1455  if (ret < 0)
1456  return ret;
1457 
1458  if (s->iccp_data) {
1460  if (!sd) {
1461  ret = AVERROR(ENOMEM);
1462  goto fail;
1463  }
1464  memcpy(sd->data, s->iccp_data, s->iccp_data_len);
1465 
1466  av_dict_set(&sd->metadata, "name", s->iccp_name, 0);
1467  }
1468 
1469  if (s->stereo_mode >= 0) {
1471  if (!stereo3d) {
1472  ret = AVERROR(ENOMEM);
1473  goto fail;
1474  }
1475 
1476  stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1477  stereo3d->flags = s->stereo_mode ? 0 : AV_STEREO3D_FLAG_INVERT;
1478  }
1479 
1480  if (s->have_chrm) {
1482  if (!mdm) {
1483  ret = AVERROR(ENOMEM);
1484  goto fail;
1485  }
1486 
1487  mdm->white_point[0] = av_make_q(s->white_point[0], 100000);
1488  mdm->white_point[1] = av_make_q(s->white_point[1], 100000);
1489 
1490  /* RGB Primaries */
1491  for (int i = 0; i < 3; i++) {
1492  mdm->display_primaries[i][0] = av_make_q(s->display_primaries[i][0], 100000);
1493  mdm->display_primaries[i][1] = av_make_q(s->display_primaries[i][1], 100000);
1494  }
1495 
1496  mdm->has_primaries = 1;
1497  }
1498 
1499  FFSWAP(AVDictionary*, f->metadata, s->frame_metadata);
1500 
1501  return 0;
1502 fail:
1503  av_frame_unref(f);
1504  return ret;
1505 }
1506 
1507 #if CONFIG_PNG_DECODER
1508 static int decode_frame_png(AVCodecContext *avctx,
1509  void *data, int *got_frame,
1510  AVPacket *avpkt)
1511 {
1512  PNGDecContext *const s = avctx->priv_data;
1513  const uint8_t *buf = avpkt->data;
1514  int buf_size = avpkt->size;
1515  AVFrame *dst_frame = data;
1516  AVFrame *p = s->picture.f;
1517  int64_t sig;
1518  int ret;
1519 
1521 
1522  bytestream2_init(&s->gb, buf, buf_size);
1523 
1524  /* check signature */
1525  sig = bytestream2_get_be64(&s->gb);
1526  if (sig != PNGSIG &&
1527  sig != MNGSIG) {
1528  av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature 0x%08"PRIX64".\n", sig);
1529  return AVERROR_INVALIDDATA;
1530  }
1531 
1532  s->y = s->has_trns = 0;
1533  s->hdr_state = 0;
1534  s->pic_state = 0;
1535 
1536  /* init the zlib */
1537  s->zstream.zalloc = ff_png_zalloc;
1538  s->zstream.zfree = ff_png_zfree;
1539  s->zstream.opaque = NULL;
1540  ret = inflateInit(&s->zstream);
1541  if (ret != Z_OK) {
1542  av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1543  return AVERROR_EXTERNAL;
1544  }
1545 
1546  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1547  goto the_end;
1548 
1549  if (avctx->skip_frame == AVDISCARD_ALL) {
1550  *got_frame = 0;
1551  ret = bytestream2_tell(&s->gb);
1552  goto the_end;
1553  }
1554 
1555  ret = output_frame(s, dst_frame, s->picture.f);
1556  if (ret < 0)
1557  goto the_end;
1558 
1559  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1560  ff_thread_release_buffer(avctx, &s->last_picture);
1561  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1562  }
1563 
1564  *got_frame = 1;
1565 
1566  ret = bytestream2_tell(&s->gb);
1567 the_end:
1568  inflateEnd(&s->zstream);
1569  s->crow_buf = NULL;
1570  return ret;
1571 }
1572 #endif
1573 
1574 #if CONFIG_APNG_DECODER
1575 static int decode_frame_apng(AVCodecContext *avctx,
1576  void *data, int *got_frame,
1577  AVPacket *avpkt)
1578 {
1579  PNGDecContext *const s = avctx->priv_data;
1580  AVFrame *dst_frame = data;
1581  int ret;
1582  AVFrame *p = s->picture.f;
1583 
1585 
1586  if (!(s->hdr_state & PNG_IHDR)) {
1587  if (!avctx->extradata_size)
1588  return AVERROR_INVALIDDATA;
1589 
1590  /* only init fields, there is no zlib use in extradata */
1591  s->zstream.zalloc = ff_png_zalloc;
1592  s->zstream.zfree = ff_png_zfree;
1593 
1594  bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
1595  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1596  goto end;
1597  }
1598 
1599  /* reset state for a new frame */
1600  if ((ret = inflateInit(&s->zstream)) != Z_OK) {
1601  av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1603  goto end;
1604  }
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  goto end;
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))) {
1615  goto end;
1616  }
1617 
1618  ret = output_frame(s, dst_frame, s->picture.f);
1619  if (ret < 0)
1620  goto end;
1621 
1622  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1623  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1624  ff_thread_release_buffer(avctx, &s->picture);
1625  } else if (s->dispose_op == APNG_DISPOSE_OP_NONE) {
1626  ff_thread_release_buffer(avctx, &s->last_picture);
1627  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1628  }
1629  }
1630 
1631  *got_frame = 1;
1632  ret = bytestream2_tell(&s->gb);
1633 
1634 end:
1635  inflateEnd(&s->zstream);
1636  return ret;
1637 }
1638 #endif
1639 
1640 #if HAVE_THREADS
1641 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1642 {
1643  PNGDecContext *psrc = src->priv_data;
1644  PNGDecContext *pdst = dst->priv_data;
1645  ThreadFrame *src_frame = NULL;
1646  int ret;
1647 
1648  if (dst == src)
1649  return 0;
1650 
1651  if (CONFIG_APNG_DECODER && dst->codec_id == AV_CODEC_ID_APNG) {
1652 
1653  pdst->width = psrc->width;
1654  pdst->height = psrc->height;
1655  pdst->bit_depth = psrc->bit_depth;
1656  pdst->color_type = psrc->color_type;
1657  pdst->compression_type = psrc->compression_type;
1658  pdst->interlace_type = psrc->interlace_type;
1659  pdst->filter_type = psrc->filter_type;
1660  pdst->cur_w = psrc->cur_w;
1661  pdst->cur_h = psrc->cur_h;
1662  pdst->x_offset = psrc->x_offset;
1663  pdst->y_offset = psrc->y_offset;
1664  pdst->has_trns = psrc->has_trns;
1665  memcpy(pdst->transparent_color_be, psrc->transparent_color_be, sizeof(pdst->transparent_color_be));
1666 
1667  pdst->dispose_op = psrc->dispose_op;
1668 
1669  memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
1670 
1671  pdst->hdr_state |= psrc->hdr_state;
1672  }
1673 
1674  src_frame = psrc->dispose_op == APNG_DISPOSE_OP_NONE ?
1675  &psrc->picture : &psrc->last_picture;
1676 
1678  if (src_frame && src_frame->f->data[0]) {
1679  ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
1680  if (ret < 0)
1681  return ret;
1682  }
1683 
1684  return 0;
1685 }
1686 #endif
1687 
1689 {
1690  PNGDecContext *s = avctx->priv_data;
1691 
1692  avctx->color_range = AVCOL_RANGE_JPEG;
1693 
1694  s->avctx = avctx;
1695  s->last_picture.f = av_frame_alloc();
1696  s->picture.f = av_frame_alloc();
1697  if (!s->last_picture.f || !s->picture.f) {
1698  av_frame_free(&s->last_picture.f);
1699  av_frame_free(&s->picture.f);
1700  return AVERROR(ENOMEM);
1701  }
1702 
1703  ff_pngdsp_init(&s->dsp);
1704 
1705  return 0;
1706 }
1707 
1709 {
1710  PNGDecContext *s = avctx->priv_data;
1711 
1712  ff_thread_release_buffer(avctx, &s->last_picture);
1713  av_frame_free(&s->last_picture.f);
1714  ff_thread_release_buffer(avctx, &s->picture);
1715  av_frame_free(&s->picture.f);
1716  av_freep(&s->buffer);
1717  s->buffer_size = 0;
1718  av_freep(&s->last_row);
1719  s->last_row_size = 0;
1720  av_freep(&s->tmp_row);
1721  s->tmp_row_size = 0;
1722  av_freep(&s->background_buf);
1723 
1724  av_freep(&s->iccp_data);
1725  av_dict_free(&s->frame_metadata);
1726 
1727  return 0;
1728 }
1729 
1730 #if CONFIG_APNG_DECODER
1731 const AVCodec ff_apng_decoder = {
1732  .name = "apng",
1733  .long_name = NULL_IF_CONFIG_SMALL("APNG (Animated Portable Network Graphics) image"),
1734  .type = AVMEDIA_TYPE_VIDEO,
1735  .id = AV_CODEC_ID_APNG,
1736  .priv_data_size = sizeof(PNGDecContext),
1737  .init = png_dec_init,
1738  .close = png_dec_end,
1739  .decode = decode_frame_apng,
1741  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1742  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1744 };
1745 #endif
1746 
1747 #if CONFIG_PNG_DECODER
1748 const AVCodec ff_png_decoder = {
1749  .name = "png",
1750  .long_name = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
1751  .type = AVMEDIA_TYPE_VIDEO,
1752  .id = AV_CODEC_ID_PNG,
1753  .priv_data_size = sizeof(PNGDecContext),
1754  .init = png_dec_init,
1755  .close = png_dec_end,
1756  .decode = decode_frame_png,
1758  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1761 };
1762 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
PNG_PLTE
@ PNG_PLTE
Definition: pngdec.c:44
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
AVCodec
AVCodec.
Definition: codec.h:197
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
PNGDecContext::last_h
int last_h
Definition: pngdec.c:76
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
clear_frame_metadata
static void clear_frame_metadata(PNGDecContext *s)
Definition: pngdec.c:1436
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
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:867
out
FILE * out
Definition: movenc.c:54
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
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:604
GetByteContext
Definition: bytestream.h:33
PNG_ALLIMAGE
@ PNG_ALLIMAGE
Definition: pngdec.c:49
AVCRC
uint32_t AVCRC
Definition: crc.h:47
PNGDecContext::last_row_size
unsigned int last_row_size
Definition: pngdec.c:97
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
decode_phys_chunk
static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:622
PNGDecContext::bit_depth
int bit_depth
Definition: pngdec.c:81
ff_png_get_nb_channels
int ff_png_get_nb_channels(int color_type)
Definition: png.c:49
APNG_DISPOSE_OP_BACKGROUND
@ APNG_DISPOSE_OP_BACKGROUND
Definition: apng.h:32
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:1430
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_mod_uintp2
#define av_mod_uintp2
Definition: common.h:149
decode_text_chunk
static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
Definition: pngdec.c:524
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
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:361
w
uint8_t w
Definition: llviddspenc.c:39
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:576
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
decode_zbuf
static int decode_zbuf(AVBPrint *bp, const uint8_t *data, const uint8_t *data_end)
Definition: pngdec.c:456
b
#define b
Definition: input.c:41
PNGDecContext::last_y_offset
int last_y_offset
Definition: pngdec.c:78
data
const char data[16]
Definition: mxf.c:142
output_frame
static int output_frame(PNGDecContext *s, AVFrame *f, const AVFrame *src)
Definition: pngdec.c:1449
PNGDecContext::row_size
int row_size
Definition: pngdec.c:104
iso88591_to_utf8
static uint8_t * iso88591_to_utf8(const uint8_t *in, size_t size_in)
Definition: pngdec.c:500
PNGDecContext::width
int width
Definition: pngdec.c:74
AVDictionary
Definition: dict.c:30
PNGDecContext::background_buf
uint8_t * background_buf
Definition: pngdec.c:92
AV_CODEC_ID_APNG
@ AV_CODEC_ID_APNG
Definition: codec_id.h:263
PNGDecContext::tmp_row_size
unsigned int tmp_row_size
Definition: pngdec.c:99
PNGDecContext::color_type
int color_type
Definition: pngdec.c:82
PNGDecContext::cur_h
int cur_h
Definition: pngdec.c:75
ff_png_zfree
void ff_png_zfree(void *opaque, void *ptr)
Definition: png.c:44
PNGDecContext::bits_per_pixel
int bits_per_pixel
Definition: pngdec.c:87
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
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: thread.h:35
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1409
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
NB_PASSES
#define NB_PASSES
Definition: png.h:47
PNGDecContext::blend_op
uint8_t blend_op
Definition: pngdec.c:79
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
PNGDecContext::zstream
z_stream zstream
Definition: pngdec.c:107
FAST_DIV255
#define FAST_DIV255(x)
Definition: pngdec.c:1060
PNGImageState
PNGImageState
Definition: pngdec.c:47
PNG_FILTER_TYPE_LOCO
#define PNG_FILTER_TYPE_LOCO
Definition: png.h:39
U
#define U(x)
Definition: vp56_arith.h:37
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:62
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1779
fail
#define fail()
Definition: checkasm.h:134
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:198
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:1708
OP_AVG
#define OP_AVG(x, s, l)
PNGDecContext::pic_state
enum PNGImageState pic_state
Definition: pngdec.c:73
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
decode_idat_chunk
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb, AVFrame *p)
Definition: pngdec.c:638
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:74
PNGDecContext::last_row
uint8_t * last_row
Definition: pngdec.c: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: internal.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
PNGDecContext::height
int height
Definition: pngdec.c:74
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
pngdsp.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:587
YUV2RGB
#define YUV2RGB(NAME, TYPE)
Definition: pngdec.c:321
mask
static const uint16_t mask[17]
Definition: lzw.c:38
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:603
width
#define width
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:257
PNGDecContext::y_offset
int y_offset
Definition: pngdec.c:77
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:479
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
PNG_COLOR_TYPE_RGB
#define PNG_COLOR_TYPE_RGB
Definition: png.h:35
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:72
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
PNGDecContext::iccp_data
uint8_t * iccp_data
Definition: pngdec.c:63
percent_missing
static int percent_missing(PNGDecContext *s)
Definition: pngdec.c:335
APNG_DISPOSE_OP_PREVIOUS
@ APNG_DISPOSE_OP_PREVIOUS
Definition: apng.h:33
APNG_DISPOSE_OP_NONE
@ APNG_DISPOSE_OP_NONE
Definition: apng.h:31
f
#define f(width, name)
Definition: cbs_vp9.c:255
pass
#define pass
Definition: fft_template.c:603
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:511
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:110
if
if(ret)
Definition: filter_design.txt:179
PNGDecContext
Definition: pngdec.c:52
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:213
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:85
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:62
png_dec_init
static av_cold int png_dec_init(AVCodecContext *avctx)
Definition: pngdec.c:1688
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1073
apng.h
pixel
uint8_t pixel
Definition: tiny_ssim.c:42
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
PNGDecContext::background_buf_allocated
unsigned background_buf_allocated
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:76
PNGDecContext::channels
int channels
Definition: pngdec.c:86
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
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:143
PNG_COLOR_TYPE_GRAY
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:33
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
abs
#define abs(x)
Definition: cuda_runtime.h:35
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1441
ff_apng_decoder
const AVCodec ff_apng_decoder
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:25
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
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1097
PNGDecContext::iccp_name
uint8_t iccp_name[82]
Definition: pngdec.c:62
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
handle_small_bpp
static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:891
PNG_FILTER_VALUE_NONE
#define PNG_FILTER_VALUE_NONE
Definition: png.h:40
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
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
AV_EF_IGNORE_ERR
#define AV_EF_IGNORE_ERR
ignore errors and continue
Definition: avcodec.h:1443
PNGDecContext::gb
GetByteContext gb
Definition: pngdec.c:56
AVPacket::size
int size
Definition: packet.h:366
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
handle_p_frame_png
static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
Definition: pngdec.c:1042
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:326
PNGDecContext::white_point
uint32_t white_point[2]
Definition: pngdec.c:69
PNGDecContext::last_w
int last_w
Definition: pngdec.c:76
PNGDecContext::picture
ThreadFrame picture
Definition: pngdec.c:58
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
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
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:211
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:376
PNGDecContext::buffer
uint8_t * buffer
Definition: pngdec.c:100
PNG_FILTER_VALUE_UP
#define PNG_FILTER_VALUE_UP
Definition: png.h:42
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
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:79
ff_png_decoder
const AVCodec ff_png_decoder
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:57
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
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:203
decode_trns_chunk
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:810
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1389
PNGSIG
#define PNGSIG
Definition: png.h:49
PNGDecContext::last_x_offset
int last_x_offset
Definition: pngdec.c:78
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:1557
PNGDecContext::stereo_mode
int stereo_mode
Definition: pngdec.c:66
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:60
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:433
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
i
int i
Definition: input.c:407
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
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:602
PNGDecContext::x_offset
int x_offset
Definition: pngdec.c:77
PNGDecContext::display_primaries
uint32_t display_primaries[3][2]
Definition: pngdec.c:70
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:50
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1416
decode_iccp_chunk
static int decode_iccp_chunk(PNGDecContext *s, GetByteContext *gb, AVFrame *f)
Definition: pngdec.c:858
decode_fctl_chunk
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:964
decode_plte_chunk
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:787
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:436
ff_png_zalloc
void * ff_png_zalloc(void *opaque, unsigned int items, unsigned int size)
Definition: png.c:39
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
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
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:711
PNGDecContext::avctx
AVCodecContext * avctx
Definition: pngdec.c:54
avcodec.h
PNGHeaderState
PNGHeaderState
Definition: pngdec.c:42
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:1594
ret
ret
Definition: filter_design.txt:187
PNGDecContext::iccp_data_len
size_t iccp_data_len
Definition: pngdec.c:64
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1386
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1438
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:57
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:83
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
PNG_IHDR
@ PNG_IHDR
Definition: pngdec.c:43
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:501
AVFrame::height
int height
Definition: frame.h:361
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1565
PNGDecContext::last_dispose_op
uint8_t last_dispose_op
Definition: pngdec.c:80
ThreadFrame
Definition: thread.h:34
decode_frame_common
static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p, const AVPacket *avpkt)
Definition: pngdec.c:1179
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:90
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:68
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:2070
APNG_BLEND_OP_SOURCE
@ APNG_BLEND_OP_SOURCE
Definition: apng.h:37
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1408
PNG_IDAT
@ PNG_IDAT
Definition: pngdec.c:48
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:54
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:84
mastering_display_metadata.h
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:76
decode_ihdr_chunk
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s, GetByteContext *gb)
Definition: pngdec.c:571
PNGDecContext::dsp
PNGDSPContext dsp
Definition: pngdec.c:53
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:33
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:526
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
AVPacket
This structure stores compressed data.
Definition: packet.h:342
png.h
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:70
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:508
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, size in bytes of each picture line.
Definition: frame.h:334
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:37
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:213
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
MNGSIG
#define MNGSIG
Definition: png.h:50
PNGDecContext::interlace_type
int interlace_type
Definition: pngdec.c:84
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:1062
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:315
OP_SUB
#define OP_SUB(x, s, l)
PNGDecContext::cur_w
int cur_w
Definition: pngdec.c:75
APNG_BLEND_OP_OVER
@ APNG_BLEND_OP_OVER
Definition: apng.h:38
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:859
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:72
PNGDecContext::bpp
int bpp
Definition: pngdec.c:88
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:2461
PNGDecContext::has_trns
int has_trns
Definition: pngdec.c:89
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348