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 
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;
81  int bit_depth;
86  int channels;
88  int bpp;
89  int has_trns;
91 
94  uint32_t palette[256];
97  unsigned int last_row_size;
99  unsigned int tmp_row_size;
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 */
117  0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
118 };
119 
120 /* Mask to determine which pixels to overwrite while displaying */
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 
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 
426 static int png_decode_idat(PNGDecContext *s, int length,
427  uint8_t *dst, ptrdiff_t dst_stride)
428 {
429  int ret;
430  s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb));
431  s->zstream.next_in = s->gb.buffer;
432  bytestream2_skip(&s->gb, length);
433 
434  /* decode one line if possible */
435  while (s->zstream.avail_in > 0) {
436  ret = inflate(&s->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 (s->zstream.avail_out == 0) {
442  if (!(s->pic_state & PNG_ALLIMAGE)) {
443  png_handle_row(s, dst, dst_stride);
444  }
445  s->zstream.avail_out = s->crow_size;
446  s->zstream.next_out = s->crow_buf;
447  }
448  if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
449  av_log(s->avctx, AV_LOG_WARNING,
450  "%d undecompressed bytes left in buffer\n", s->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)
459 {
460  z_stream zstream;
461  unsigned char *buf;
462  unsigned buf_size;
463  int ret;
464 
465  zstream.zalloc = ff_png_zalloc;
466  zstream.zfree = ff_png_zfree;
467  zstream.opaque = NULL;
468  if (inflateInit(&zstream) != Z_OK)
469  return AVERROR_EXTERNAL;
470  zstream.next_in = data;
471  zstream.avail_in = data_end - data;
473 
474  while (zstream.avail_in > 0) {
475  av_bprint_get_buffer(bp, 2, &buf, &buf_size);
476  if (buf_size < 2) {
477  ret = AVERROR(ENOMEM);
478  goto fail;
479  }
480  zstream.next_out = buf;
481  zstream.avail_out = buf_size - 1;
482  ret = inflate(&zstream, Z_PARTIAL_FLUSH);
483  if (ret != Z_OK && ret != Z_STREAM_END) {
485  goto fail;
486  }
487  bp->len += zstream.next_out - buf;
488  if (ret == Z_STREAM_END)
489  break;
490  }
491  inflateEnd(&zstream);
492  bp->str[bp->len] = 0;
493  return 0;
494 
495 fail:
496  inflateEnd(&zstream);
498  return ret;
499 }
500 
501 static uint8_t *iso88591_to_utf8(const uint8_t *in, size_t size_in)
502 {
503  size_t extra = 0, i;
504  uint8_t *out, *q;
505 
506  for (i = 0; i < size_in; i++)
507  extra += in[i] >= 0x80;
508  if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
509  return NULL;
510  q = out = av_malloc(size_in + extra + 1);
511  if (!out)
512  return NULL;
513  for (i = 0; i < size_in; i++) {
514  if (in[i] >= 0x80) {
515  *(q++) = 0xC0 | (in[i] >> 6);
516  *(q++) = 0x80 | (in[i] & 0x3F);
517  } else {
518  *(q++) = in[i];
519  }
520  }
521  *(q++) = 0;
522  return out;
523 }
524 
525 static int decode_text_chunk(PNGDecContext *s, uint32_t length, int compressed)
526 {
527  int ret, method;
528  const uint8_t *data = s->gb.buffer;
529  const uint8_t *data_end = data + length;
530  const uint8_t *keyword = data;
531  const uint8_t *keyword_end = memchr(keyword, 0, data_end - keyword);
532  uint8_t *kw_utf8 = NULL, *text, *txt_utf8 = NULL;
533  unsigned text_len;
534  AVBPrint bp;
535 
536  if (!keyword_end)
537  return AVERROR_INVALIDDATA;
538  data = keyword_end + 1;
539 
540  if (compressed) {
541  if (data == data_end)
542  return AVERROR_INVALIDDATA;
543  method = *(data++);
544  if (method)
545  return AVERROR_INVALIDDATA;
546  if ((ret = decode_zbuf(&bp, data, data_end)) < 0)
547  return ret;
548  text_len = bp.len;
549  ret = av_bprint_finalize(&bp, (char **)&text);
550  if (ret < 0)
551  return ret;
552  } else {
553  text = (uint8_t *)data;
554  text_len = data_end - text;
555  }
556 
557  kw_utf8 = iso88591_to_utf8(keyword, keyword_end - keyword);
558  txt_utf8 = iso88591_to_utf8(text, text_len);
559  if (text != data)
560  av_free(text);
561  if (!(kw_utf8 && txt_utf8)) {
562  av_free(kw_utf8);
563  av_free(txt_utf8);
564  return AVERROR(ENOMEM);
565  }
566 
567  av_dict_set(&s->frame_metadata, kw_utf8, txt_utf8,
569  return 0;
570 }
571 
573  uint32_t length)
574 {
575  if (length != 13)
576  return AVERROR_INVALIDDATA;
577 
578  if (s->pic_state & PNG_IDAT) {
579  av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
580  return AVERROR_INVALIDDATA;
581  }
582 
583  if (s->hdr_state & PNG_IHDR) {
584  av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
585  return AVERROR_INVALIDDATA;
586  }
587 
588  s->width = s->cur_w = bytestream2_get_be32(&s->gb);
589  s->height = s->cur_h = bytestream2_get_be32(&s->gb);
590  if (av_image_check_size(s->width, s->height, 0, avctx)) {
591  s->cur_w = s->cur_h = s->width = s->height = 0;
592  av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
593  return AVERROR_INVALIDDATA;
594  }
595  s->bit_depth = bytestream2_get_byte(&s->gb);
596  if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
597  s->bit_depth != 8 && s->bit_depth != 16) {
598  av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
599  goto error;
600  }
601  s->color_type = bytestream2_get_byte(&s->gb);
602  s->compression_type = bytestream2_get_byte(&s->gb);
603  if (s->compression_type) {
604  av_log(avctx, AV_LOG_ERROR, "Invalid compression method %d\n", s->compression_type);
605  goto error;
606  }
607  s->filter_type = bytestream2_get_byte(&s->gb);
608  s->interlace_type = bytestream2_get_byte(&s->gb);
609  bytestream2_skip(&s->gb, 4); /* crc */
610  s->hdr_state |= PNG_IHDR;
611  if (avctx->debug & FF_DEBUG_PICT_INFO)
612  av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
613  "compression_type=%d filter_type=%d interlace_type=%d\n",
614  s->width, s->height, s->bit_depth, s->color_type,
615  s->compression_type, s->filter_type, s->interlace_type);
616 
617  return 0;
618 error:
619  s->cur_w = s->cur_h = s->width = s->height = 0;
620  s->bit_depth = 8;
621  return AVERROR_INVALIDDATA;
622 }
623 
625 {
626  if (s->pic_state & PNG_IDAT) {
627  av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
628  return AVERROR_INVALIDDATA;
629  }
630  avctx->sample_aspect_ratio.num = bytestream2_get_be32(&s->gb);
631  avctx->sample_aspect_ratio.den = bytestream2_get_be32(&s->gb);
632  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
633  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
634  bytestream2_skip(&s->gb, 1); /* unit specifier */
635  bytestream2_skip(&s->gb, 4); /* crc */
636 
637  return 0;
638 }
639 
641  uint32_t length, AVFrame *p)
642 {
643  int ret;
644  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
645 
646  if (!(s->hdr_state & PNG_IHDR)) {
647  av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
648  return AVERROR_INVALIDDATA;
649  }
650  if (!(s->pic_state & PNG_IDAT)) {
651  /* init image info */
652  ret = ff_set_dimensions(avctx, s->width, s->height);
653  if (ret < 0)
654  return ret;
655 
656  s->channels = ff_png_get_nb_channels(s->color_type);
657  s->bits_per_pixel = s->bit_depth * s->channels;
658  s->bpp = (s->bits_per_pixel + 7) >> 3;
659  s->row_size = (s->cur_w * s->bits_per_pixel + 7) >> 3;
660 
661  if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
662  s->color_type == PNG_COLOR_TYPE_RGB) {
663  avctx->pix_fmt = AV_PIX_FMT_RGB24;
664  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
665  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
666  avctx->pix_fmt = AV_PIX_FMT_RGBA;
667  } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
668  s->color_type == PNG_COLOR_TYPE_GRAY) {
669  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
670  } else if (s->bit_depth == 16 &&
671  s->color_type == PNG_COLOR_TYPE_GRAY) {
672  avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
673  } else if (s->bit_depth == 16 &&
674  s->color_type == PNG_COLOR_TYPE_RGB) {
675  avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
676  } else if (s->bit_depth == 16 &&
677  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
678  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
679  } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
680  s->color_type == PNG_COLOR_TYPE_PALETTE) {
681  avctx->pix_fmt = AV_PIX_FMT_PAL8;
682  } else if (s->bit_depth == 1 && s->bits_per_pixel == 1 && avctx->codec_id != AV_CODEC_ID_APNG) {
683  avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
684  } else if (s->bit_depth == 8 &&
685  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
686  avctx->pix_fmt = AV_PIX_FMT_YA8;
687  } else if (s->bit_depth == 16 &&
688  s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
689  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
690  } else {
692  "Bit depth %d color type %d",
693  s->bit_depth, s->color_type);
694  return AVERROR_PATCHWELCOME;
695  }
696 
697  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
698  switch (avctx->pix_fmt) {
699  case AV_PIX_FMT_RGB24:
700  avctx->pix_fmt = AV_PIX_FMT_RGBA;
701  break;
702 
703  case AV_PIX_FMT_RGB48BE:
704  avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
705  break;
706 
707  case AV_PIX_FMT_GRAY8:
708  avctx->pix_fmt = AV_PIX_FMT_YA8;
709  break;
710 
711  case AV_PIX_FMT_GRAY16BE:
712  avctx->pix_fmt = AV_PIX_FMT_YA16BE;
713  break;
714 
715  default:
716  avpriv_request_sample(avctx, "bit depth %d "
717  "and color type %d with TRNS",
718  s->bit_depth, s->color_type);
719  return AVERROR_INVALIDDATA;
720  }
721 
722  s->bpp += byte_depth;
723  }
724 
725  ff_thread_release_buffer(avctx, &s->picture);
726  if ((ret = ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
727  return ret;
728 
730  p->key_frame = 1;
731  p->interlaced_frame = !!s->interlace_type;
732 
733  ff_thread_finish_setup(avctx);
734 
735  /* compute the compressed row size */
736  if (!s->interlace_type) {
737  s->crow_size = s->row_size + 1;
738  } else {
739  s->pass = 0;
740  s->pass_row_size = ff_png_pass_row_size(s->pass,
741  s->bits_per_pixel,
742  s->cur_w);
743  s->crow_size = s->pass_row_size + 1;
744  }
745  ff_dlog(avctx, "row_size=%d crow_size =%d\n",
746  s->row_size, s->crow_size);
747 
748  /* copy the palette if needed */
749  if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
750  memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
751  /* empty row is used if differencing to the first row */
752  av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
753  if (!s->last_row)
754  return AVERROR_INVALIDDATA;
755  if (s->interlace_type ||
756  s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
757  av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
758  if (!s->tmp_row)
759  return AVERROR_INVALIDDATA;
760  }
761  /* compressed row */
762  av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
763  if (!s->buffer)
764  return AVERROR(ENOMEM);
765 
766  /* we want crow_buf+1 to be 16-byte aligned */
767  s->crow_buf = s->buffer + 15;
768  s->zstream.avail_out = s->crow_size;
769  s->zstream.next_out = s->crow_buf;
770  }
771 
772  s->pic_state |= PNG_IDAT;
773 
774  /* set image to non-transparent bpp while decompressing */
775  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
776  s->bpp -= byte_depth;
777 
778  ret = png_decode_idat(s, length, p->data[0], p->linesize[0]);
779 
780  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
781  s->bpp += byte_depth;
782 
783  if (ret < 0)
784  return ret;
785 
786  bytestream2_skip(&s->gb, 4); /* crc */
787 
788  return 0;
789 }
790 
792  uint32_t length)
793 {
794  int n, i, r, g, b;
795 
796  if ((length % 3) != 0 || length > 256 * 3)
797  return AVERROR_INVALIDDATA;
798  /* read the palette */
799  n = length / 3;
800  for (i = 0; i < n; i++) {
801  r = bytestream2_get_byte(&s->gb);
802  g = bytestream2_get_byte(&s->gb);
803  b = bytestream2_get_byte(&s->gb);
804  s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
805  }
806  for (; i < 256; i++)
807  s->palette[i] = (0xFFU << 24);
808  s->hdr_state |= PNG_PLTE;
809  bytestream2_skip(&s->gb, 4); /* crc */
810 
811  return 0;
812 }
813 
815  uint32_t length)
816 {
817  int v, i;
818 
819  if (!(s->hdr_state & PNG_IHDR)) {
820  av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
821  return AVERROR_INVALIDDATA;
822  }
823 
824  if (s->pic_state & PNG_IDAT) {
825  av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
826  return AVERROR_INVALIDDATA;
827  }
828 
829  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
830  if (length > 256 || !(s->hdr_state & PNG_PLTE))
831  return AVERROR_INVALIDDATA;
832 
833  for (i = 0; i < length; i++) {
834  unsigned v = bytestream2_get_byte(&s->gb);
835  s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
836  }
837  } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
838  if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
839  (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
840  s->bit_depth == 1)
841  return AVERROR_INVALIDDATA;
842 
843  for (i = 0; i < length / 2; i++) {
844  /* only use the least significant bits */
845  v = av_mod_uintp2(bytestream2_get_be16(&s->gb), s->bit_depth);
846 
847  if (s->bit_depth > 8)
848  AV_WB16(&s->transparent_color_be[2 * i], v);
849  else
850  s->transparent_color_be[i] = v;
851  }
852  } else {
853  return AVERROR_INVALIDDATA;
854  }
855 
856  bytestream2_skip(&s->gb, 4); /* crc */
857  s->has_trns = 1;
858 
859  return 0;
860 }
861 
862 static int decode_iccp_chunk(PNGDecContext *s, int length, AVFrame *f)
863 {
864  int ret, cnt = 0;
865  AVBPrint bp;
866 
867  while ((s->iccp_name[cnt++] = bytestream2_get_byte(&s->gb)) && cnt < 81);
868  if (cnt > 80) {
869  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
871  goto fail;
872  }
873 
874  length = FFMAX(length - cnt, 0);
875 
876  if (bytestream2_get_byte(&s->gb) != 0) {
877  av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
879  goto fail;
880  }
881 
882  length = FFMAX(length - 1, 0);
883 
884  if ((ret = decode_zbuf(&bp, s->gb.buffer, s->gb.buffer + length)) < 0)
885  return ret;
886 
887  av_freep(&s->iccp_data);
888  ret = av_bprint_finalize(&bp, (char **)&s->iccp_data);
889  if (ret < 0)
890  return ret;
891  s->iccp_data_len = bp.len;
892 
893  /* ICC compressed data and CRC */
894  bytestream2_skip(&s->gb, length + 4);
895 
896  return 0;
897 fail:
898  s->iccp_name[0] = 0;
899  return ret;
900 }
901 
903 {
904  if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
905  int i, j, k;
906  uint8_t *pd = p->data[0];
907  for (j = 0; j < s->height; j++) {
908  i = s->width / 8;
909  for (k = 7; k >= 1; k--)
910  if ((s->width&7) >= k)
911  pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
912  for (i--; i >= 0; i--) {
913  pd[8*i + 7]= pd[i] & 1;
914  pd[8*i + 6]= (pd[i]>>1) & 1;
915  pd[8*i + 5]= (pd[i]>>2) & 1;
916  pd[8*i + 4]= (pd[i]>>3) & 1;
917  pd[8*i + 3]= (pd[i]>>4) & 1;
918  pd[8*i + 2]= (pd[i]>>5) & 1;
919  pd[8*i + 1]= (pd[i]>>6) & 1;
920  pd[8*i + 0]= pd[i]>>7;
921  }
922  pd += p->linesize[0];
923  }
924  } else if (s->bits_per_pixel == 2) {
925  int i, j;
926  uint8_t *pd = p->data[0];
927  for (j = 0; j < s->height; j++) {
928  i = s->width / 4;
929  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
930  if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
931  if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
932  if ((s->width&3) >= 1) pd[4*i + 0]= pd[i] >> 6;
933  for (i--; i >= 0; i--) {
934  pd[4*i + 3]= pd[i] & 3;
935  pd[4*i + 2]= (pd[i]>>2) & 3;
936  pd[4*i + 1]= (pd[i]>>4) & 3;
937  pd[4*i + 0]= pd[i]>>6;
938  }
939  } else {
940  if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
941  if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
942  if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6 )*0x55;
943  for (i--; i >= 0; i--) {
944  pd[4*i + 3]= ( pd[i] & 3)*0x55;
945  pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
946  pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
947  pd[4*i + 0]= ( pd[i]>>6 )*0x55;
948  }
949  }
950  pd += p->linesize[0];
951  }
952  } else if (s->bits_per_pixel == 4) {
953  int i, j;
954  uint8_t *pd = p->data[0];
955  for (j = 0; j < s->height; j++) {
956  i = s->width/2;
957  if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
958  if (s->width&1) pd[2*i+0]= pd[i]>>4;
959  for (i--; i >= 0; i--) {
960  pd[2*i + 1] = pd[i] & 15;
961  pd[2*i + 0] = pd[i] >> 4;
962  }
963  } else {
964  if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
965  for (i--; i >= 0; i--) {
966  pd[2*i + 1] = (pd[i] & 15) * 0x11;
967  pd[2*i + 0] = (pd[i] >> 4) * 0x11;
968  }
969  }
970  pd += p->linesize[0];
971  }
972  }
973 }
974 
976  uint32_t length)
977 {
978  uint32_t sequence_number;
979  int cur_w, cur_h, x_offset, y_offset, dispose_op, blend_op;
980 
981  if (length != 26)
982  return AVERROR_INVALIDDATA;
983 
984  if (!(s->hdr_state & PNG_IHDR)) {
985  av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
986  return AVERROR_INVALIDDATA;
987  }
988 
989  if (s->pic_state & PNG_IDAT) {
990  av_log(avctx, AV_LOG_ERROR, "fctl after IDAT\n");
991  return AVERROR_INVALIDDATA;
992  }
993 
994  s->last_w = s->cur_w;
995  s->last_h = s->cur_h;
996  s->last_x_offset = s->x_offset;
997  s->last_y_offset = s->y_offset;
998  s->last_dispose_op = s->dispose_op;
999 
1000  sequence_number = bytestream2_get_be32(&s->gb);
1001  cur_w = bytestream2_get_be32(&s->gb);
1002  cur_h = bytestream2_get_be32(&s->gb);
1003  x_offset = bytestream2_get_be32(&s->gb);
1004  y_offset = bytestream2_get_be32(&s->gb);
1005  bytestream2_skip(&s->gb, 4); /* delay_num (2), delay_den (2) */
1006  dispose_op = bytestream2_get_byte(&s->gb);
1007  blend_op = bytestream2_get_byte(&s->gb);
1008  bytestream2_skip(&s->gb, 4); /* crc */
1009 
1010  if (sequence_number == 0 &&
1011  (cur_w != s->width ||
1012  cur_h != s->height ||
1013  x_offset != 0 ||
1014  y_offset != 0) ||
1015  cur_w <= 0 || cur_h <= 0 ||
1016  x_offset < 0 || y_offset < 0 ||
1017  cur_w > s->width - x_offset|| cur_h > s->height - y_offset)
1018  return AVERROR_INVALIDDATA;
1019 
1020  if (blend_op != APNG_BLEND_OP_OVER && blend_op != APNG_BLEND_OP_SOURCE) {
1021  av_log(avctx, AV_LOG_ERROR, "Invalid blend_op %d\n", blend_op);
1022  return AVERROR_INVALIDDATA;
1023  }
1024 
1025  if ((sequence_number == 0 || !s->last_picture.f->data[0]) &&
1026  dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1027  // No previous frame to revert to for the first frame
1028  // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
1029  dispose_op = APNG_DISPOSE_OP_BACKGROUND;
1030  }
1031 
1032  if (blend_op == APNG_BLEND_OP_OVER && !s->has_trns && (
1033  avctx->pix_fmt == AV_PIX_FMT_RGB24 ||
1034  avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1035  avctx->pix_fmt == AV_PIX_FMT_PAL8 ||
1036  avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
1037  avctx->pix_fmt == AV_PIX_FMT_GRAY16BE ||
1038  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK
1039  )) {
1040  // APNG_BLEND_OP_OVER is the same as APNG_BLEND_OP_SOURCE when there is no alpha channel
1041  blend_op = APNG_BLEND_OP_SOURCE;
1042  }
1043 
1044  s->cur_w = cur_w;
1045  s->cur_h = cur_h;
1046  s->x_offset = x_offset;
1047  s->y_offset = y_offset;
1048  s->dispose_op = dispose_op;
1049  s->blend_op = blend_op;
1050 
1051  return 0;
1052 }
1053 
1055 {
1056  int i, j;
1057  uint8_t *pd = p->data[0];
1058  uint8_t *pd_last = s->last_picture.f->data[0];
1059  int ls = FFMIN(av_image_get_linesize(p->format, s->width, 0), s->width * s->bpp);
1060 
1061  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1062  for (j = 0; j < s->height; j++) {
1063  for (i = 0; i < ls; i++)
1064  pd[i] += pd_last[i];
1065  pd += p->linesize[0];
1066  pd_last += s->last_picture.f->linesize[0];
1067  }
1068 }
1069 
1070 // divide by 255 and round to nearest
1071 // apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
1072 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
1073 
1075  AVFrame *p)
1076 {
1077  uint8_t *dst = p->data[0];
1078  ptrdiff_t dst_stride = p->linesize[0];
1079  const uint8_t *src = s->last_picture.f->data[0];
1080  ptrdiff_t src_stride = s->last_picture.f->linesize[0];
1081 
1082  size_t x, y;
1083 
1084  if (s->blend_op == APNG_BLEND_OP_OVER &&
1085  avctx->pix_fmt != AV_PIX_FMT_RGBA &&
1086  avctx->pix_fmt != AV_PIX_FMT_GRAY8A &&
1087  avctx->pix_fmt != AV_PIX_FMT_PAL8) {
1088  avpriv_request_sample(avctx, "Blending with pixel format %s",
1089  av_get_pix_fmt_name(avctx->pix_fmt));
1090  return AVERROR_PATCHWELCOME;
1091  }
1092 
1093  ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1094 
1095  // need to reset a rectangle to background:
1096  if (s->last_dispose_op == APNG_DISPOSE_OP_BACKGROUND) {
1097  av_fast_malloc(&s->background_buf, &s->background_buf_allocated,
1098  src_stride * p->height);
1099  if (!s->background_buf)
1100  return AVERROR(ENOMEM);
1101 
1102  memcpy(s->background_buf, src, src_stride * p->height);
1103 
1104  for (y = s->last_y_offset; y < s->last_y_offset + s->last_h; y++) {
1105  memset(s->background_buf + src_stride * y +
1106  s->bpp * s->last_x_offset, 0, s->bpp * s->last_w);
1107  }
1108 
1109  src = s->background_buf;
1110  }
1111 
1112  // copy unchanged rectangles from the last frame
1113  for (y = 0; y < s->y_offset; y++)
1114  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1115  for (y = s->y_offset; y < s->y_offset + s->cur_h; y++) {
1116  memcpy(dst + y * dst_stride, src + y * src_stride, s->x_offset * s->bpp);
1117  memcpy(dst + y * dst_stride + (s->x_offset + s->cur_w) * s->bpp,
1118  src + y * src_stride + (s->x_offset + s->cur_w) * s->bpp,
1119  (p->width - s->cur_w - s->x_offset) * s->bpp);
1120  }
1121  for (y = s->y_offset + s->cur_h; y < p->height; y++)
1122  memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1123 
1124  if (s->blend_op == APNG_BLEND_OP_OVER) {
1125  // Perform blending
1126  for (y = s->y_offset; y < s->y_offset + s->cur_h; ++y) {
1127  uint8_t *foreground = dst + dst_stride * y + s->bpp * s->x_offset;
1128  const uint8_t *background = src + src_stride * y + s->bpp * s->x_offset;
1129  for (x = s->x_offset; x < s->x_offset + s->cur_w; ++x, foreground += s->bpp, background += s->bpp) {
1130  size_t b;
1131  uint8_t foreground_alpha, background_alpha, output_alpha;
1132  uint8_t output[10];
1133 
1134  // Since we might be blending alpha onto alpha, we use the following equations:
1135  // output_alpha = foreground_alpha + (1 - foreground_alpha) * background_alpha
1136  // output = (foreground_alpha * foreground + (1 - foreground_alpha) * background_alpha * background) / output_alpha
1137 
1138  switch (avctx->pix_fmt) {
1139  case AV_PIX_FMT_RGBA:
1140  foreground_alpha = foreground[3];
1141  background_alpha = background[3];
1142  break;
1143 
1144  case AV_PIX_FMT_GRAY8A:
1145  foreground_alpha = foreground[1];
1146  background_alpha = background[1];
1147  break;
1148 
1149  case AV_PIX_FMT_PAL8:
1150  foreground_alpha = s->palette[foreground[0]] >> 24;
1151  background_alpha = s->palette[background[0]] >> 24;
1152  break;
1153  }
1154 
1155  if (foreground_alpha == 255)
1156  continue;
1157 
1158  if (foreground_alpha == 0) {
1159  memcpy(foreground, background, s->bpp);
1160  continue;
1161  }
1162 
1163  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1164  // TODO: Alpha blending with PAL8 will likely need the entire image converted over to RGBA first
1165  avpriv_request_sample(avctx, "Alpha blending palette samples");
1166  continue;
1167  }
1168 
1169  output_alpha = foreground_alpha + FAST_DIV255((255 - foreground_alpha) * background_alpha);
1170 
1171  av_assert0(s->bpp <= 10);
1172 
1173  for (b = 0; b < s->bpp - 1; ++b) {
1174  if (output_alpha == 0) {
1175  output[b] = 0;
1176  } else if (background_alpha == 255) {
1177  output[b] = FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1178  } else {
1179  output[b] = (255 * foreground_alpha * foreground[b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1180  }
1181  }
1182  output[b] = output_alpha;
1183  memcpy(foreground, output, s->bpp);
1184  }
1185  }
1186  }
1187 
1188  return 0;
1189 }
1190 
1192  AVFrame *p, const AVPacket *avpkt)
1193 {
1194  const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1195  uint32_t tag, length;
1196  int decode_next_dat = 0;
1197  int i, ret;
1198 
1199  for (;;) {
1200  length = bytestream2_get_bytes_left(&s->gb);
1201  if (length <= 0) {
1202 
1203  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1204  avctx->skip_frame == AVDISCARD_ALL) {
1205  return 0;
1206  }
1207 
1208  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
1209  if (!(s->pic_state & PNG_IDAT))
1210  return 0;
1211  else
1212  goto exit_loop;
1213  }
1214  av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
1215  if ( s->pic_state & PNG_ALLIMAGE
1217  goto exit_loop;
1219  goto fail;
1220  }
1221 
1222  length = bytestream2_get_be32(&s->gb);
1223  if (length > 0x7fffffff || length + 8 > bytestream2_get_bytes_left(&s->gb)) {
1224  av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
1226  goto fail;
1227  }
1228  if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_IGNORE_ERR)) {
1229  uint32_t crc_sig = AV_RB32(s->gb.buffer + length + 4);
1230  uint32_t crc_cal = ~av_crc(crc_tab, UINT32_MAX, s->gb.buffer, length + 4);
1231  if (crc_sig ^ crc_cal) {
1232  av_log(avctx, AV_LOG_ERROR, "CRC mismatch in chunk");
1233  if (avctx->err_recognition & AV_EF_EXPLODE) {
1234  av_log(avctx, AV_LOG_ERROR, ", quitting\n");
1236  goto fail;
1237  }
1238  av_log(avctx, AV_LOG_ERROR, ", skipping\n");
1239  bytestream2_skip(&s->gb, 4); /* tag */
1240  goto skip_tag;
1241  }
1242  }
1243  tag = bytestream2_get_le32(&s->gb);
1244  if (avctx->debug & FF_DEBUG_STARTCODE)
1245  av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
1246  av_fourcc2str(tag), length);
1247 
1248  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1249  avctx->skip_frame == AVDISCARD_ALL) {
1250  switch(tag) {
1251  case MKTAG('I', 'H', 'D', 'R'):
1252  case MKTAG('p', 'H', 'Y', 's'):
1253  case MKTAG('t', 'E', 'X', 't'):
1254  case MKTAG('I', 'D', 'A', 'T'):
1255  case MKTAG('t', 'R', 'N', 'S'):
1256  break;
1257  default:
1258  goto skip_tag;
1259  }
1260  }
1261 
1262  switch (tag) {
1263  case MKTAG('I', 'H', 'D', 'R'):
1264  if ((ret = decode_ihdr_chunk(avctx, s, length)) < 0)
1265  goto fail;
1266  break;
1267  case MKTAG('p', 'H', 'Y', 's'):
1268  if ((ret = decode_phys_chunk(avctx, s)) < 0)
1269  goto fail;
1270  break;
1271  case MKTAG('f', 'c', 'T', 'L'):
1272  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1273  goto skip_tag;
1274  if ((ret = decode_fctl_chunk(avctx, s, length)) < 0)
1275  goto fail;
1276  decode_next_dat = 1;
1277  break;
1278  case MKTAG('f', 'd', 'A', 'T'):
1279  if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1280  goto skip_tag;
1281  if (!decode_next_dat || length < 4) {
1283  goto fail;
1284  }
1285  bytestream2_get_be32(&s->gb);
1286  length -= 4;
1287  /* fallthrough */
1288  case MKTAG('I', 'D', 'A', 'T'):
1289  if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && !decode_next_dat)
1290  goto skip_tag;
1291  if ((ret = decode_idat_chunk(avctx, s, length, p)) < 0)
1292  goto fail;
1293  break;
1294  case MKTAG('P', 'L', 'T', 'E'):
1295  if (decode_plte_chunk(avctx, s, length) < 0)
1296  goto skip_tag;
1297  break;
1298  case MKTAG('t', 'R', 'N', 'S'):
1299  if (decode_trns_chunk(avctx, s, length) < 0)
1300  goto skip_tag;
1301  break;
1302  case MKTAG('t', 'E', 'X', 't'):
1303  if (decode_text_chunk(s, length, 0) < 0)
1304  av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
1305  bytestream2_skip(&s->gb, length + 4);
1306  break;
1307  case MKTAG('z', 'T', 'X', 't'):
1308  if (decode_text_chunk(s, length, 1) < 0)
1309  av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
1310  bytestream2_skip(&s->gb, length + 4);
1311  break;
1312  case MKTAG('s', 'T', 'E', 'R'): {
1313  int mode = bytestream2_get_byte(&s->gb);
1314 
1315  if (mode == 0 || mode == 1) {
1316  s->stereo_mode = mode;
1317  } else {
1318  av_log(avctx, AV_LOG_WARNING,
1319  "Unknown value in sTER chunk (%d)\n", mode);
1320  }
1321  bytestream2_skip(&s->gb, 4); /* crc */
1322  break;
1323  }
1324  case MKTAG('i', 'C', 'C', 'P'): {
1325  if ((ret = decode_iccp_chunk(s, length, p)) < 0)
1326  goto fail;
1327  break;
1328  }
1329  case MKTAG('c', 'H', 'R', 'M'): {
1330  s->have_chrm = 1;
1331 
1332  s->white_point[0] = bytestream2_get_be32(&s->gb);
1333  s->white_point[1] = bytestream2_get_be32(&s->gb);
1334 
1335  /* RGB Primaries */
1336  for (i = 0; i < 3; i++) {
1337  s->display_primaries[i][0] = bytestream2_get_be32(&s->gb);
1338  s->display_primaries[i][1] = bytestream2_get_be32(&s->gb);
1339  }
1340 
1341  bytestream2_skip(&s->gb, 4); /* crc */
1342  break;
1343  }
1344  case MKTAG('g', 'A', 'M', 'A'): {
1345  AVBPrint bp;
1346  char *gamma_str;
1347  int num = bytestream2_get_be32(&s->gb);
1348 
1350  av_bprintf(&bp, "%i/%i", num, 100000);
1351  ret = av_bprint_finalize(&bp, &gamma_str);
1352  if (ret < 0)
1353  return ret;
1354 
1355  av_dict_set(&s->frame_metadata, "gamma", gamma_str, AV_DICT_DONT_STRDUP_VAL);
1356 
1357  bytestream2_skip(&s->gb, 4); /* crc */
1358  break;
1359  }
1360  case MKTAG('I', 'E', 'N', 'D'):
1361  if (!(s->pic_state & PNG_ALLIMAGE))
1362  av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
1363  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1365  goto fail;
1366  }
1367  bytestream2_skip(&s->gb, 4); /* crc */
1368  goto exit_loop;
1369  default:
1370  /* skip tag */
1371 skip_tag:
1372  bytestream2_skip(&s->gb, length + 4);
1373  break;
1374  }
1375  }
1376 exit_loop:
1377 
1378  if (avctx->codec_id == AV_CODEC_ID_PNG &&
1379  avctx->skip_frame == AVDISCARD_ALL) {
1380  return 0;
1381  }
1382 
1384  return AVERROR_INVALIDDATA;
1385 
1386  if (s->bits_per_pixel <= 4)
1387  handle_small_bpp(s, p);
1388 
1389  /* apply transparency if needed */
1390  if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
1391  size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
1392  size_t raw_bpp = s->bpp - byte_depth;
1393  unsigned x, y;
1394 
1395  av_assert0(s->bit_depth > 1);
1396 
1397  for (y = 0; y < s->height; ++y) {
1398  uint8_t *row = &p->data[0][p->linesize[0] * y];
1399 
1400  if (s->bpp == 2 && byte_depth == 1) {
1401  uint8_t *pixel = &row[2 * s->width - 1];
1402  uint8_t *rowp = &row[1 * s->width - 1];
1403  int tcolor = s->transparent_color_be[0];
1404  for (x = s->width; x > 0; --x) {
1405  *pixel-- = *rowp == tcolor ? 0 : 0xff;
1406  *pixel-- = *rowp--;
1407  }
1408  } else if (s->bpp == 4 && byte_depth == 1) {
1409  uint8_t *pixel = &row[4 * s->width - 1];
1410  uint8_t *rowp = &row[3 * s->width - 1];
1411  int tcolor = AV_RL24(s->transparent_color_be);
1412  for (x = s->width; x > 0; --x) {
1413  *pixel-- = AV_RL24(rowp-2) == tcolor ? 0 : 0xff;
1414  *pixel-- = *rowp--;
1415  *pixel-- = *rowp--;
1416  *pixel-- = *rowp--;
1417  }
1418  } else {
1419  /* since we're updating in-place, we have to go from right to left */
1420  for (x = s->width; x > 0; --x) {
1421  uint8_t *pixel = &row[s->bpp * (x - 1)];
1422  memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1423 
1424  if (!memcmp(pixel, s->transparent_color_be, raw_bpp)) {
1425  memset(&pixel[raw_bpp], 0, byte_depth);
1426  } else {
1427  memset(&pixel[raw_bpp], 0xff, byte_depth);
1428  }
1429  }
1430  }
1431  }
1432  }
1433 
1434  /* handle P-frames only if a predecessor frame is available */
1435  if (s->last_picture.f->data[0]) {
1436  if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
1437  && s->last_picture.f->width == p->width
1438  && s->last_picture.f->height== p->height
1439  && s->last_picture.f->format== p->format
1440  ) {
1441  if (CONFIG_PNG_DECODER && avctx->codec_id != AV_CODEC_ID_APNG)
1442  handle_p_frame_png(s, p);
1443  else if (CONFIG_APNG_DECODER &&
1444  avctx->codec_id == AV_CODEC_ID_APNG &&
1445  (ret = handle_p_frame_apng(avctx, s, p)) < 0)
1446  goto fail;
1447  }
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  const AVFrame *src)
1473 {
1474  int ret;
1475 
1476  ret = av_frame_ref(f, src);
1477  if (ret < 0)
1478  return ret;
1479 
1480  if (s->iccp_data) {
1482  if (!sd) {
1483  ret = AVERROR(ENOMEM);
1484  goto fail;
1485  }
1486  memcpy(sd->data, s->iccp_data, s->iccp_data_len);
1487 
1488  av_dict_set(&sd->metadata, "name", s->iccp_name, 0);
1489  }
1490 
1491  if (s->stereo_mode >= 0) {
1493  if (!stereo3d) {
1494  ret = AVERROR(ENOMEM);
1495  goto fail;
1496  }
1497 
1498  stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1499  stereo3d->flags = s->stereo_mode ? 0 : AV_STEREO3D_FLAG_INVERT;
1500  }
1501 
1502  if (s->have_chrm) {
1504  if (!mdm) {
1505  ret = AVERROR(ENOMEM);
1506  goto fail;
1507  }
1508 
1509  mdm->white_point[0] = av_make_q(s->white_point[0], 100000);
1510  mdm->white_point[1] = av_make_q(s->white_point[1], 100000);
1511 
1512  /* RGB Primaries */
1513  for (int i = 0; i < 3; i++) {
1514  mdm->display_primaries[i][0] = av_make_q(s->display_primaries[i][0], 100000);
1515  mdm->display_primaries[i][1] = av_make_q(s->display_primaries[i][1], 100000);
1516  }
1517 
1518  mdm->has_primaries = 1;
1519  }
1520 
1521  FFSWAP(AVDictionary*, f->metadata, s->frame_metadata);
1522 
1523  return 0;
1524 fail:
1525  av_frame_unref(f);
1526  return ret;
1527 }
1528 
1529 #if CONFIG_PNG_DECODER
1530 static int decode_frame_png(AVCodecContext *avctx,
1531  void *data, int *got_frame,
1532  AVPacket *avpkt)
1533 {
1534  PNGDecContext *const s = avctx->priv_data;
1535  const uint8_t *buf = avpkt->data;
1536  int buf_size = avpkt->size;
1537  AVFrame *dst_frame = data;
1538  AVFrame *p = s->picture.f;
1539  int64_t sig;
1540  int ret;
1541 
1543 
1544  bytestream2_init(&s->gb, buf, buf_size);
1545 
1546  /* check signature */
1547  sig = bytestream2_get_be64(&s->gb);
1548  if (sig != PNGSIG &&
1549  sig != MNGSIG) {
1550  av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature 0x%08"PRIX64".\n", sig);
1551  return AVERROR_INVALIDDATA;
1552  }
1553 
1554  s->y = s->has_trns = 0;
1555  s->hdr_state = 0;
1556  s->pic_state = 0;
1557 
1558  /* init the zlib */
1559  s->zstream.zalloc = ff_png_zalloc;
1560  s->zstream.zfree = ff_png_zfree;
1561  s->zstream.opaque = NULL;
1562  ret = inflateInit(&s->zstream);
1563  if (ret != Z_OK) {
1564  av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1565  return AVERROR_EXTERNAL;
1566  }
1567 
1568  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1569  goto the_end;
1570 
1571  if (avctx->skip_frame == AVDISCARD_ALL) {
1572  *got_frame = 0;
1573  ret = bytestream2_tell(&s->gb);
1574  goto the_end;
1575  }
1576 
1577  ret = output_frame(s, dst_frame, s->picture.f);
1578  if (ret < 0)
1579  goto the_end;
1580 
1581  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1582  ff_thread_release_buffer(avctx, &s->last_picture);
1583  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1584  }
1585 
1586  *got_frame = 1;
1587 
1588  ret = bytestream2_tell(&s->gb);
1589 the_end:
1590  inflateEnd(&s->zstream);
1591  s->crow_buf = NULL;
1592  return ret;
1593 }
1594 #endif
1595 
1596 #if CONFIG_APNG_DECODER
1597 static int decode_frame_apng(AVCodecContext *avctx,
1598  void *data, int *got_frame,
1599  AVPacket *avpkt)
1600 {
1601  PNGDecContext *const s = avctx->priv_data;
1602  AVFrame *dst_frame = data;
1603  int ret;
1604  AVFrame *p = s->picture.f;
1605 
1607 
1608  if (!(s->hdr_state & PNG_IHDR)) {
1609  if (!avctx->extradata_size)
1610  return AVERROR_INVALIDDATA;
1611 
1612  /* only init fields, there is no zlib use in extradata */
1613  s->zstream.zalloc = ff_png_zalloc;
1614  s->zstream.zfree = ff_png_zfree;
1615 
1616  bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
1617  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1618  goto end;
1619  }
1620 
1621  /* reset state for a new frame */
1622  if ((ret = inflateInit(&s->zstream)) != Z_OK) {
1623  av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1625  goto end;
1626  }
1627  s->y = 0;
1628  s->pic_state = 0;
1629  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1630  if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1631  goto end;
1632 
1633  if (!(s->pic_state & PNG_ALLIMAGE))
1634  av_log(avctx, AV_LOG_WARNING, "Frame did not contain a complete image\n");
1635  if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1637  goto end;
1638  }
1639 
1640  ret = output_frame(s, dst_frame, s->picture.f);
1641  if (ret < 0)
1642  goto end;
1643 
1644  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1645  if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1646  ff_thread_release_buffer(avctx, &s->picture);
1647  } else {
1648  ff_thread_release_buffer(avctx, &s->last_picture);
1649  FFSWAP(ThreadFrame, s->picture, s->last_picture);
1650  }
1651  }
1652 
1653  *got_frame = 1;
1654  ret = bytestream2_tell(&s->gb);
1655 
1656 end:
1657  inflateEnd(&s->zstream);
1658  return ret;
1659 }
1660 #endif
1661 
1662 #if HAVE_THREADS
1663 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1664 {
1665  PNGDecContext *psrc = src->priv_data;
1666  PNGDecContext *pdst = dst->priv_data;
1667  ThreadFrame *src_frame = NULL;
1668  int ret;
1669 
1670  if (dst == src)
1671  return 0;
1672 
1673  if (CONFIG_APNG_DECODER && dst->codec_id == AV_CODEC_ID_APNG) {
1674 
1675  pdst->width = psrc->width;
1676  pdst->height = psrc->height;
1677  pdst->bit_depth = psrc->bit_depth;
1678  pdst->color_type = psrc->color_type;
1679  pdst->compression_type = psrc->compression_type;
1680  pdst->interlace_type = psrc->interlace_type;
1681  pdst->filter_type = psrc->filter_type;
1682  pdst->cur_w = psrc->cur_w;
1683  pdst->cur_h = psrc->cur_h;
1684  pdst->x_offset = psrc->x_offset;
1685  pdst->y_offset = psrc->y_offset;
1686  pdst->has_trns = psrc->has_trns;
1687  memcpy(pdst->transparent_color_be, psrc->transparent_color_be, sizeof(pdst->transparent_color_be));
1688 
1689  pdst->dispose_op = psrc->dispose_op;
1690 
1691  memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
1692 
1693  pdst->hdr_state |= psrc->hdr_state;
1694  }
1695 
1696  src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ?
1697  &psrc->last_picture : &psrc->picture;
1698 
1700  if (src_frame && src_frame->f->data[0]) {
1701  ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
1702  if (ret < 0)
1703  return ret;
1704  }
1705 
1706  return 0;
1707 }
1708 #endif
1709 
1711 {
1712  PNGDecContext *s = avctx->priv_data;
1713 
1714  avctx->color_range = AVCOL_RANGE_JPEG;
1715 
1716  s->avctx = avctx;
1717  s->last_picture.f = av_frame_alloc();
1718  s->picture.f = av_frame_alloc();
1719  if (!s->last_picture.f || !s->picture.f) {
1720  av_frame_free(&s->last_picture.f);
1721  av_frame_free(&s->picture.f);
1722  return AVERROR(ENOMEM);
1723  }
1724 
1725  ff_pngdsp_init(&s->dsp);
1726 
1727  return 0;
1728 }
1729 
1731 {
1732  PNGDecContext *s = avctx->priv_data;
1733 
1734  ff_thread_release_buffer(avctx, &s->last_picture);
1735  av_frame_free(&s->last_picture.f);
1736  ff_thread_release_buffer(avctx, &s->picture);
1737  av_frame_free(&s->picture.f);
1738  av_freep(&s->buffer);
1739  s->buffer_size = 0;
1740  av_freep(&s->last_row);
1741  s->last_row_size = 0;
1742  av_freep(&s->tmp_row);
1743  s->tmp_row_size = 0;
1744  av_freep(&s->background_buf);
1745 
1746  av_freep(&s->iccp_data);
1747  av_dict_free(&s->frame_metadata);
1748 
1749  return 0;
1750 }
1751 
1752 #if CONFIG_APNG_DECODER
1754  .name = "apng",
1755  .long_name = NULL_IF_CONFIG_SMALL("APNG (Animated Portable Network Graphics) image"),
1756  .type = AVMEDIA_TYPE_VIDEO,
1757  .id = AV_CODEC_ID_APNG,
1758  .priv_data_size = sizeof(PNGDecContext),
1759  .init = png_dec_init,
1760  .close = png_dec_end,
1761  .decode = decode_frame_apng,
1763  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1764  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1766 };
1767 #endif
1768 
1769 #if CONFIG_PNG_DECODER
1771  .name = "png",
1772  .long_name = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
1773  .type = AVMEDIA_TYPE_VIDEO,
1774  .id = AV_CODEC_ID_PNG,
1775  .priv_data_size = sizeof(PNGDecContext),
1776  .init = png_dec_init,
1777  .close = png_dec_end,
1778  .decode = decode_frame_png,
1780  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1783 };
1784 #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:200
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: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
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:143
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:934
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
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
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:1645
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:726
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
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:205
AVFrame::width
int width
Definition: frame.h:376
w
uint8_t w
Definition: llviddspenc.c:39
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
decode_zbuf
static int decode_zbuf(AVBPrint *bp, const uint8_t *data, const uint8_t *data_end)
Definition: pngdec.c:457
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:1471
decode_ihdr_chunk
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
Definition: pngdec.c:572
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:501
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:264
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:410
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:1624
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
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:1072
PNGImageState
PNGImageState
Definition: pngdec.c:47
PNG_FILTER_TYPE_LOCO
#define PNG_FILTER_TYPE_LOCO
Definition: png.h:39
decode_text_chunk
static int decode_text_chunk(PNGDecContext *s, uint32_t length, int compressed)
Definition: pngdec.c:525
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:2006
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: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:1730
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:396
decode_trns_chunk
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
Definition: pngdec.c:814
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:190
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:194
pngdsp.h
av_cold
#define av_cold
Definition: attributes.h:90
skip_tag
static int skip_tag(AVIOContext *in, int32_t tag_name)
Definition: ismindex.c:132
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:590
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:638
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
png_decode_idat
static int png_decode_idat(PNGDecContext *s, int length, uint8_t *dst, ptrdiff_t dst_stride)
Definition: pngdec.c:426
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:514
decode_fctl_chunk
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
Definition: pngdec.c:975
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:215
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
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:546
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:236
AV_PIX_FMT_GRAY8A
@ AV_PIX_FMT_GRAY8A
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:146
NULL
#define NULL
Definition: coverity.c:32
PNGDecContext::filter_type
int filter_type
Definition: pngdec.c:85
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:1710
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
apng.h
ff_png_decoder
AVCodec ff_png_decoder
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:1656
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:1104
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:902
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:401
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
decode_idat_chunk
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length, AVFrame *p)
Definition: pngdec.c:640
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:1658
PNGDecContext::gb
GetByteContext gb
Definition: pngdec.c:56
AVPacket::size
int size
Definition: packet.h:370
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:1054
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:443
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
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
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:212
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:222
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:391
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
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:375
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
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:1604
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:1784
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
decode_iccp_chunk
static int decode_iccp_chunk(PNGDecContext *s, int length, AVFrame *f)
Definition: pngdec.c:862
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
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:637
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:1631
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
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:1611
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:1601
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1653
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:536
AVFrame::height
int height
Definition: frame.h:376
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
PNGDecContext::last_dispose_op
uint8_t last_dispose_op
Definition: pngdec.c:80
decode_plte_chunk
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
Definition: pngdec.c:791
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:1191
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:2328
decode_phys_chunk
static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s)
Definition: pngdec.c:624
APNG_BLEND_OP_SOURCE
@ APNG_BLEND_OP_SOURCE
Definition: apng.h:37
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1623
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
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:220
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:561
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
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:502
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:349
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:37
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:228
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:1074
PNGDecContext::y
int y
Definition: pngdec.c:106
ff_apng_decoder
AVCodec ff_apng_decoder
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:317
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:915
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:2489
PNGDecContext::has_trns
int has_trns
Definition: pngdec.c:89
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348