3 * Copyright (c) 2003 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
24 #include "libavutil/bprint.h"
25 #include "libavutil/imgutils.h"
27 #include "bytestream.h"
35 typedef struct PNGDecContext
{
37 AVCodecContext
*avctx
;
40 ThreadFrame last_picture
;
56 uint32_t palette
[256];
59 unsigned int last_row_size
;
61 unsigned int tmp_row_size
;
65 int crow_size
; /* compressed row size (include filter type) */
66 int row_size
; /* decompressed row size */
67 int pass_row_size
; /* decompress row size of the current pass */
72 /* Mask to determine which pixels are valid in a pass */
73 static const uint8_t png_pass_mask
[NB_PASSES
] = {
74 0x01, 0x01, 0x11, 0x11, 0x55, 0x55, 0xff,
77 /* Mask to determine which y pixels can be written in a pass */
78 static const uint8_t png_pass_dsp_ymask
[NB_PASSES
] = {
79 0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
82 /* Mask to determine which pixels to overwrite while displaying */
83 static const uint8_t png_pass_dsp_mask
[NB_PASSES
] = {
84 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
87 /* NOTE: we try to construct a good looking image at each pass. width
88 * is the original image width. We also do pixel format conversion at
90 static void png_put_interlaced_row(uint8_t *dst
, int width
,
91 int bits_per_pixel
, int pass
,
92 int color_type
, const uint8_t *src
)
94 int x
, mask
, dsp_mask
, j
, src_x
, b
, bpp
;
98 mask
= png_pass_mask
[pass
];
99 dsp_mask
= png_pass_dsp_mask
[pass
];
101 switch (bits_per_pixel
) {
104 for (x
= 0; x
< width
; x
++) {
106 if ((dsp_mask
<< j
) & 0x80) {
107 b
= (src
[src_x
>> 3] >> (7 - (src_x
& 7))) & 1;
108 dst
[x
>> 3] &= 0xFF7F>>j
;
109 dst
[x
>> 3] |= b
<< (7 - j
);
111 if ((mask
<< j
) & 0x80)
117 for (x
= 0; x
< width
; x
++) {
118 int j2
= 2 * (x
& 3);
120 if ((dsp_mask
<< j
) & 0x80) {
121 b
= (src
[src_x
>> 2] >> (6 - 2*(src_x
& 3))) & 3;
122 dst
[x
>> 2] &= 0xFF3F>>j2
;
123 dst
[x
>> 2] |= b
<< (6 - j2
);
125 if ((mask
<< j
) & 0x80)
131 for (x
= 0; x
< width
; x
++) {
134 if ((dsp_mask
<< j
) & 0x80) {
135 b
= (src
[src_x
>> 1] >> (4 - 4*(src_x
& 1))) & 15;
136 dst
[x
>> 1] &= 0xFF0F>>j2
;
137 dst
[x
>> 1] |= b
<< (4 - j2
);
139 if ((mask
<< j
) & 0x80)
144 bpp
= bits_per_pixel
>> 3;
147 for (x
= 0; x
< width
; x
++) {
149 if ((dsp_mask
<< j
) & 0x80) {
153 if ((mask
<< j
) & 0x80)
160 void ff_add_png_paeth_prediction(uint8_t *dst
, uint8_t *src
, uint8_t *top
,
164 for (i
= 0; i
< w
; i
++) {
165 int a
, b
, c
, p
, pa
, pb
, pc
;
178 if (pa
<= pb
&& pa
<= pc
)
188 #define UNROLL1(bpp, op) \
197 for (; i <= size - bpp; i += bpp) { \
198 dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \
201 dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \
204 dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \
207 dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \
211 #define UNROLL_FILTER(op) \
214 } else if (bpp == 2) { \
216 } else if (bpp == 3) { \
218 } else if (bpp == 4) { \
221 for (; i < size; i++) { \
222 dst[i] = op(dst[i - bpp], src[i], last[i]); \
225 /* NOTE: 'dst' can be equal to 'last' */
226 static void png_filter_row(PNGDSPContext
*dsp
, uint8_t *dst
, int filter_type
,
227 uint8_t *src
, uint8_t *last
, int size
, int bpp
)
229 int i
, p
, r
, g
, b
, a
;
231 switch (filter_type
) {
232 case PNG_FILTER_VALUE_NONE
:
233 memcpy(dst
, src
, size
);
235 case PNG_FILTER_VALUE_SUB
:
236 for (i
= 0; i
< bpp
; i
++)
240 for (; i
< size
; i
+= bpp
) {
241 unsigned s
= *(int *)(src
+ i
);
242 p
= ((s
& 0x7f7f7f7f) + (p
& 0x7f7f7f7f)) ^ ((s
^ p
) & 0x80808080);
243 *(int *)(dst
+ i
) = p
;
246 #define OP_SUB(x, s, l) ((x) + (s))
247 UNROLL_FILTER(OP_SUB
);
250 case PNG_FILTER_VALUE_UP
:
251 dsp
->add_bytes_l2(dst
, src
, last
, size
);
253 case PNG_FILTER_VALUE_AVG
:
254 for (i
= 0; i
< bpp
; i
++) {
258 #define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff)
259 UNROLL_FILTER(OP_AVG
);
261 case PNG_FILTER_VALUE_PAETH
:
262 for (i
= 0; i
< bpp
; i
++) {
266 if (bpp
> 2 && size
> 4) {
267 /* would write off the end of the array if we let it process
268 * the last pixel with bpp=3 */
269 int w
= bpp
== 4 ? size
: size
- 3;
270 dsp
->add_paeth_prediction(dst
+ i
, src
+ i
, last
+ i
, w
- i
, bpp
);
273 ff_add_png_paeth_prediction(dst
+ i
, src
+ i
, last
+ i
, size
- i
, bpp
);
278 /* This used to be called "deloco" in FFmpeg
279 * and is actually an inverse reversible colorspace transformation */
280 #define YUV2RGB(NAME, TYPE) \
281 static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \
284 for (i = 0; i < size; i += 3 + alpha) { \
285 int g = dst [i + 1]; \
291 YUV2RGB(rgb8
, uint8_t)
292 YUV2RGB(rgb16
, uint16_t)
294 /* process exactly one decompressed row */
295 static void png_handle_row(PNGDecContext
*s
)
297 uint8_t *ptr
, *last_row
;
300 if (!s
->interlace_type
) {
301 ptr
= s
->image_buf
+ s
->image_linesize
* s
->y
;
303 last_row
= s
->last_row
;
305 last_row
= ptr
- s
->image_linesize
;
307 png_filter_row(&s
->dsp
, ptr
, s
->crow_buf
[0], s
->crow_buf
+ 1,
308 last_row
, s
->row_size
, s
->bpp
);
309 /* loco lags by 1 row so that it doesn't interfere with top prediction */
310 if (s
->filter_type
== PNG_FILTER_TYPE_LOCO
&& s
->y
> 0) {
311 if (s
->bit_depth
== 16) {
312 deloco_rgb16((uint16_t *)(ptr
- s
->image_linesize
), s
->row_size
/ 2,
313 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
);
315 deloco_rgb8(ptr
- s
->image_linesize
, s
->row_size
,
316 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
);
320 if (s
->y
== s
->height
) {
321 s
->state
|= PNG_ALLIMAGE
;
322 if (s
->filter_type
== PNG_FILTER_TYPE_LOCO
) {
323 if (s
->bit_depth
== 16) {
324 deloco_rgb16((uint16_t *)ptr
, s
->row_size
/ 2,
325 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
);
327 deloco_rgb8(ptr
, s
->row_size
,
328 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
);
335 ptr
= s
->image_buf
+ s
->image_linesize
* s
->y
;
336 if ((ff_png_pass_ymask
[s
->pass
] << (s
->y
& 7)) & 0x80) {
337 /* if we already read one row, it is time to stop to
338 * wait for the next one */
341 png_filter_row(&s
->dsp
, s
->tmp_row
, s
->crow_buf
[0], s
->crow_buf
+ 1,
342 s
->last_row
, s
->pass_row_size
, s
->bpp
);
343 FFSWAP(uint8_t *, s
->last_row
, s
->tmp_row
);
344 FFSWAP(unsigned int, s
->last_row_size
, s
->tmp_row_size
);
347 if ((png_pass_dsp_ymask
[s
->pass
] << (s
->y
& 7)) & 0x80) {
348 png_put_interlaced_row(ptr
, s
->width
, s
->bits_per_pixel
, s
->pass
,
349 s
->color_type
, s
->last_row
);
352 if (s
->y
== s
->height
) {
353 memset(s
->last_row
, 0, s
->row_size
);
355 if (s
->pass
== NB_PASSES
- 1) {
356 s
->state
|= PNG_ALLIMAGE
;
361 s
->pass_row_size
= ff_png_pass_row_size(s
->pass
,
364 s
->crow_size
= s
->pass_row_size
+ 1;
365 if (s
->pass_row_size
!= 0)
367 /* skip pass if empty row */
376 static int png_decode_idat(PNGDecContext
*s
, int length
)
379 s
->zstream
.avail_in
= FFMIN(length
, bytestream2_get_bytes_left(&s
->gb
));
380 s
->zstream
.next_in
= (unsigned char *)s
->gb
.buffer
;
381 bytestream2_skip(&s
->gb
, length
);
383 /* decode one line if possible */
384 while (s
->zstream
.avail_in
> 0) {
385 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
386 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
387 av_log(s
->avctx
, AV_LOG_ERROR
, "inflate returned error %d\n", ret
);
388 return AVERROR_EXTERNAL
;
390 if (s
->zstream
.avail_out
== 0) {
391 if (!(s
->state
& PNG_ALLIMAGE
)) {
394 s
->zstream
.avail_out
= s
->crow_size
;
395 s
->zstream
.next_out
= s
->crow_buf
;
397 if (ret
== Z_STREAM_END
&& s
->zstream
.avail_in
> 0) {
398 av_log(NULL
, AV_LOG_WARNING
,
399 "%d undecompressed bytes left in buffer\n", s
->zstream
.avail_in
);
406 static int decode_zbuf(AVBPrint
*bp
, const uint8_t *data
,
407 const uint8_t *data_end
)
414 zstream
.zalloc
= ff_png_zalloc
;
415 zstream
.zfree
= ff_png_zfree
;
416 zstream
.opaque
= NULL
;
417 if (inflateInit(&zstream
) != Z_OK
)
418 return AVERROR_EXTERNAL
;
419 zstream
.next_in
= (unsigned char *)data
;
420 zstream
.avail_in
= data_end
- data
;
421 av_bprint_init(bp
, 0, -1);
423 while (zstream
.avail_in
> 0) {
424 av_bprint_get_buffer(bp
, 1, &buf
, &buf_size
);
426 ret
= AVERROR(ENOMEM
);
429 zstream
.next_out
= buf
;
430 zstream
.avail_out
= buf_size
;
431 ret
= inflate(&zstream
, Z_PARTIAL_FLUSH
);
432 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
433 ret
= AVERROR_EXTERNAL
;
436 bp
->len
+= zstream
.next_out
- buf
;
437 if (ret
== Z_STREAM_END
)
440 inflateEnd(&zstream
);
441 bp
->str
[bp
->len
] = 0;
445 inflateEnd(&zstream
);
446 av_bprint_finalize(bp
, NULL
);
450 static uint8_t *iso88591_to_utf8(const uint8_t *in
, size_t size_in
)
455 for (i
= 0; i
< size_in
; i
++)
456 extra
+= in
[i
] >= 0x80;
457 if (size_in
== SIZE_MAX
|| extra
> SIZE_MAX
- size_in
- 1)
459 q
= out
= av_malloc(size_in
+ extra
+ 1);
462 for (i
= 0; i
< size_in
; i
++) {
464 *(q
++) = 0xC0 | (in
[i
] >> 6);
465 *(q
++) = 0x80 | (in
[i
] & 0x3F);
474 static int decode_text_chunk(PNGDecContext
*s
, uint32_t length
, int compressed
,
478 const uint8_t *data
= s
->gb
.buffer
;
479 const uint8_t *data_end
= data
+ length
;
480 const uint8_t *keyword
= data
;
481 const uint8_t *keyword_end
= memchr(keyword
, 0, data_end
- keyword
);
482 uint8_t *kw_utf8
= NULL
, *text
, *txt_utf8
= NULL
;
487 return AVERROR_INVALIDDATA
;
488 data
= keyword_end
+ 1;
491 if (data
== data_end
)
492 return AVERROR_INVALIDDATA
;
495 return AVERROR_INVALIDDATA
;
496 if ((ret
= decode_zbuf(&bp
, data
, data_end
)) < 0)
499 av_bprint_finalize(&bp
, (char **)&text
);
501 return AVERROR(ENOMEM
);
503 text
= (uint8_t *)data
;
504 text_len
= data_end
- text
;
507 kw_utf8
= iso88591_to_utf8(keyword
, keyword_end
- keyword
);
508 txt_utf8
= iso88591_to_utf8(text
, text_len
);
511 if (!(kw_utf8
&& txt_utf8
)) {
514 return AVERROR(ENOMEM
);
517 av_dict_set(dict
, kw_utf8
, txt_utf8
,
518 AV_DICT_DONT_STRDUP_KEY
| AV_DICT_DONT_STRDUP_VAL
);
522 static int decode_frame(AVCodecContext
*avctx
,
523 void *data
, int *got_frame
,
526 PNGDecContext
*const s
= avctx
->priv_data
;
527 const uint8_t *buf
= avpkt
->data
;
528 int buf_size
= avpkt
->size
;
530 AVDictionary
*metadata
= NULL
;
531 uint32_t tag
, length
;
535 ff_thread_release_buffer(avctx
, &s
->last_picture
);
536 FFSWAP(ThreadFrame
, s
->picture
, s
->last_picture
);
539 bytestream2_init(&s
->gb
, buf
, buf_size
);
541 /* check signature */
542 sig
= bytestream2_get_be64(&s
->gb
);
545 av_log(avctx
, AV_LOG_ERROR
, "Missing png signature\n");
546 return AVERROR_INVALIDDATA
;
552 s
->zstream
.zalloc
= ff_png_zalloc
;
553 s
->zstream
.zfree
= ff_png_zfree
;
554 s
->zstream
.opaque
= NULL
;
555 ret
= inflateInit(&s
->zstream
);
557 av_log(avctx
, AV_LOG_ERROR
, "inflateInit returned error %d\n", ret
);
558 return AVERROR_EXTERNAL
;
561 if (bytestream2_get_bytes_left(&s
->gb
) <= 0) {
562 av_log(avctx
, AV_LOG_ERROR
, "%d bytes left\n", bytestream2_get_bytes_left(&s
->gb
));
563 if ( s
->state
& PNG_ALLIMAGE
564 && avctx
->strict_std_compliance
<= FF_COMPLIANCE_NORMAL
)
569 length
= bytestream2_get_be32(&s
->gb
);
570 if (length
> 0x7fffffff || length
> bytestream2_get_bytes_left(&s
->gb
)) {
571 av_log(avctx
, AV_LOG_ERROR
, "chunk too big\n");
574 tag
= bytestream2_get_le32(&s
->gb
);
575 if (avctx
->debug
& FF_DEBUG_STARTCODE
)
576 av_log(avctx
, AV_LOG_DEBUG
, "png: tag=%c%c%c%c length=%u\n",
579 ((tag
>> 16) & 0xff),
580 ((tag
>> 24) & 0xff), length
);
582 case MKTAG('I', 'H', 'D', 'R'):
585 s
->width
= bytestream2_get_be32(&s
->gb
);
586 s
->height
= bytestream2_get_be32(&s
->gb
);
587 if (av_image_check_size(s
->width
, s
->height
, 0, avctx
)) {
588 s
->width
= s
->height
= 0;
589 av_log(avctx
, AV_LOG_ERROR
, "Invalid image size\n");
592 s
->bit_depth
= bytestream2_get_byte(&s
->gb
);
593 s
->color_type
= bytestream2_get_byte(&s
->gb
);
594 s
->compression_type
= bytestream2_get_byte(&s
->gb
);
595 s
->filter_type
= bytestream2_get_byte(&s
->gb
);
596 s
->interlace_type
= bytestream2_get_byte(&s
->gb
);
597 bytestream2_skip(&s
->gb
, 4); /* crc */
598 s
->state
|= PNG_IHDR
;
599 if (avctx
->debug
& FF_DEBUG_PICT_INFO
)
600 av_log(avctx
, AV_LOG_DEBUG
, "width=%d height=%d depth=%d color_type=%d "
601 "compression_type=%d filter_type=%d interlace_type=%d\n",
602 s
->width
, s
->height
, s
->bit_depth
, s
->color_type
,
603 s
->compression_type
, s
->filter_type
, s
->interlace_type
);
605 case MKTAG('p', 'H', 'Y', 's'):
606 if (s
->state
& PNG_IDAT
) {
607 av_log(avctx
, AV_LOG_ERROR
, "pHYs after IDAT\n");
610 avctx
->sample_aspect_ratio
.num
= bytestream2_get_be32(&s
->gb
);
611 avctx
->sample_aspect_ratio
.den
= bytestream2_get_be32(&s
->gb
);
612 if (avctx
->sample_aspect_ratio
.num
< 0 || avctx
->sample_aspect_ratio
.den
< 0)
613 avctx
->sample_aspect_ratio
= (AVRational
){ 0, 1 };
614 bytestream2_skip(&s
->gb
, 1); /* unit specifier */
615 bytestream2_skip(&s
->gb
, 4); /* crc */
617 case MKTAG('I', 'D', 'A', 'T'):
618 if (!(s
->state
& PNG_IHDR
)) {
619 av_log(avctx
, AV_LOG_ERROR
, "IDAT without IHDR\n");
622 if (!(s
->state
& PNG_IDAT
)) {
623 /* init image info */
624 avctx
->width
= s
->width
;
625 avctx
->height
= s
->height
;
627 s
->channels
= ff_png_get_nb_channels(s
->color_type
);
628 s
->bits_per_pixel
= s
->bit_depth
* s
->channels
;
629 s
->bpp
= (s
->bits_per_pixel
+ 7) >> 3;
630 s
->row_size
= (avctx
->width
* s
->bits_per_pixel
+ 7) >> 3;
632 if ((s
->bit_depth
== 2 || s
->bit_depth
== 4 || s
->bit_depth
== 8) &&
633 s
->color_type
== PNG_COLOR_TYPE_RGB
) {
634 avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
635 } else if ((s
->bit_depth
== 2 || s
->bit_depth
== 4 || s
->bit_depth
== 8) &&
636 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) {
637 avctx
->pix_fmt
= AV_PIX_FMT_RGBA
;
638 } else if ((s
->bit_depth
== 2 || s
->bit_depth
== 4 || s
->bit_depth
== 8) &&
639 s
->color_type
== PNG_COLOR_TYPE_GRAY
) {
640 avctx
->pix_fmt
= AV_PIX_FMT_GRAY8
;
641 } else if (s
->bit_depth
== 16 &&
642 s
->color_type
== PNG_COLOR_TYPE_GRAY
) {
643 avctx
->pix_fmt
= AV_PIX_FMT_GRAY16BE
;
644 } else if (s
->bit_depth
== 16 &&
645 s
->color_type
== PNG_COLOR_TYPE_RGB
) {
646 avctx
->pix_fmt
= AV_PIX_FMT_RGB48BE
;
647 } else if (s
->bit_depth
== 16 &&
648 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) {
649 avctx
->pix_fmt
= AV_PIX_FMT_RGBA64BE
;
650 } else if ((s
->bits_per_pixel
== 1 || s
->bits_per_pixel
== 2 || s
->bits_per_pixel
== 4 || s
->bits_per_pixel
== 8) &&
651 s
->color_type
== PNG_COLOR_TYPE_PALETTE
) {
652 avctx
->pix_fmt
= AV_PIX_FMT_PAL8
;
653 } else if (s
->bit_depth
== 1 && s
->bits_per_pixel
== 1) {
654 avctx
->pix_fmt
= AV_PIX_FMT_MONOBLACK
;
655 } else if (s
->bit_depth
== 8 &&
656 s
->color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
) {
657 avctx
->pix_fmt
= AV_PIX_FMT_YA8
;
658 } else if (s
->bit_depth
== 16 &&
659 s
->color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
) {
660 avctx
->pix_fmt
= AV_PIX_FMT_YA16BE
;
662 av_log(avctx
, AV_LOG_ERROR
, "unsupported bit depth %d "
663 "and color type %d\n",
664 s
->bit_depth
, s
->color_type
);
668 if (ff_thread_get_buffer(avctx
, &s
->picture
, AV_GET_BUFFER_FLAG_REF
) < 0)
670 ff_thread_finish_setup(avctx
);
672 p
->pict_type
= AV_PICTURE_TYPE_I
;
674 p
->interlaced_frame
= !!s
->interlace_type
;
676 /* compute the compressed row size */
677 if (!s
->interlace_type
) {
678 s
->crow_size
= s
->row_size
+ 1;
681 s
->pass_row_size
= ff_png_pass_row_size(s
->pass
,
684 s
->crow_size
= s
->pass_row_size
+ 1;
686 av_dlog(avctx
, "row_size=%d crow_size =%d\n",
687 s
->row_size
, s
->crow_size
);
688 s
->image_buf
= p
->data
[0];
689 s
->image_linesize
= p
->linesize
[0];
690 /* copy the palette if needed */
691 if (avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
692 memcpy(p
->data
[1], s
->palette
, 256 * sizeof(uint32_t));
693 /* empty row is used if differencing to the first row */
694 av_fast_padded_mallocz(&s
->last_row
, &s
->last_row_size
, s
->row_size
);
697 if (s
->interlace_type
||
698 s
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) {
699 av_fast_padded_malloc(&s
->tmp_row
, &s
->tmp_row_size
, s
->row_size
);
704 av_fast_padded_malloc(&s
->buffer
, &s
->buffer_size
, s
->row_size
+ 16);
708 /* we want crow_buf+1 to be 16-byte aligned */
709 s
->crow_buf
= s
->buffer
+ 15;
710 s
->zstream
.avail_out
= s
->crow_size
;
711 s
->zstream
.next_out
= s
->crow_buf
;
713 s
->state
|= PNG_IDAT
;
714 if (png_decode_idat(s
, length
) < 0)
716 bytestream2_skip(&s
->gb
, 4); /* crc */
718 case MKTAG('P', 'L', 'T', 'E'):
722 if ((length
% 3) != 0 || length
> 256 * 3)
724 /* read the palette */
726 for (i
= 0; i
< n
; i
++) {
727 r
= bytestream2_get_byte(&s
->gb
);
728 g
= bytestream2_get_byte(&s
->gb
);
729 b
= bytestream2_get_byte(&s
->gb
);
730 s
->palette
[i
] = (0xFFU
<< 24) | (r
<< 16) | (g
<< 8) | b
;
733 s
->palette
[i
] = (0xFFU
<< 24);
734 s
->state
|= PNG_PLTE
;
735 bytestream2_skip(&s
->gb
, 4); /* crc */
738 case MKTAG('t', 'R', 'N', 'S'):
742 /* read the transparency. XXX: Only palette mode supported */
743 if (s
->color_type
!= PNG_COLOR_TYPE_PALETTE
||
745 !(s
->state
& PNG_PLTE
))
747 for (i
= 0; i
< length
; i
++) {
748 v
= bytestream2_get_byte(&s
->gb
);
749 s
->palette
[i
] = (s
->palette
[i
] & 0x00ffffff) | (v
<< 24);
751 bytestream2_skip(&s
->gb
, 4); /* crc */
754 case MKTAG('t', 'E', 'X', 't'):
755 if (decode_text_chunk(s
, length
, 0, &metadata
) < 0)
756 av_log(avctx
, AV_LOG_WARNING
, "Broken tEXt chunk\n");
757 bytestream2_skip(&s
->gb
, length
+ 4);
759 case MKTAG('z', 'T', 'X', 't'):
760 if (decode_text_chunk(s
, length
, 1, &metadata
) < 0)
761 av_log(avctx
, AV_LOG_WARNING
, "Broken zTXt chunk\n");
762 bytestream2_skip(&s
->gb
, length
+ 4);
764 case MKTAG('I', 'E', 'N', 'D'):
765 if (!(s
->state
& PNG_ALLIMAGE
))
766 av_log(avctx
, AV_LOG_ERROR
, "IEND without all image\n");
767 if (!(s
->state
& (PNG_ALLIMAGE
|PNG_IDAT
))) {
770 bytestream2_skip(&s
->gb
, 4); /* crc */
775 bytestream2_skip(&s
->gb
, length
+ 4);
781 if (s
->bits_per_pixel
== 1 && s
->color_type
== PNG_COLOR_TYPE_PALETTE
){
783 uint8_t *pd
= p
->data
[0];
784 for (j
= 0; j
< s
->height
; j
++) {
786 for (k
= 7; k
>= 1; k
--)
787 if ((s
->width
&7) >= k
)
788 pd
[8*i
+ k
- 1] = (pd
[i
]>>8-k
) & 1;
789 for (i
--; i
>= 0; i
--) {
790 pd
[8*i
+ 7]= pd
[i
] & 1;
791 pd
[8*i
+ 6]= (pd
[i
]>>1) & 1;
792 pd
[8*i
+ 5]= (pd
[i
]>>2) & 1;
793 pd
[8*i
+ 4]= (pd
[i
]>>3) & 1;
794 pd
[8*i
+ 3]= (pd
[i
]>>4) & 1;
795 pd
[8*i
+ 2]= (pd
[i
]>>5) & 1;
796 pd
[8*i
+ 1]= (pd
[i
]>>6) & 1;
797 pd
[8*i
+ 0]= pd
[i
]>>7;
799 pd
+= s
->image_linesize
;
802 if (s
->bits_per_pixel
== 2){
804 uint8_t *pd
= p
->data
[0];
805 for (j
= 0; j
< s
->height
; j
++) {
807 if (s
->color_type
== PNG_COLOR_TYPE_PALETTE
){
808 if ((s
->width
&3) >= 3) pd
[4*i
+ 2]= (pd
[i
] >> 2) & 3;
809 if ((s
->width
&3) >= 2) pd
[4*i
+ 1]= (pd
[i
] >> 4) & 3;
810 if ((s
->width
&3) >= 1) pd
[4*i
+ 0]= pd
[i
] >> 6;
811 for (i
--; i
>= 0; i
--) {
812 pd
[4*i
+ 3]= pd
[i
] & 3;
813 pd
[4*i
+ 2]= (pd
[i
]>>2) & 3;
814 pd
[4*i
+ 1]= (pd
[i
]>>4) & 3;
815 pd
[4*i
+ 0]= pd
[i
]>>6;
818 if ((s
->width
&3) >= 3) pd
[4*i
+ 2]= ((pd
[i
]>>2) & 3)*0x55;
819 if ((s
->width
&3) >= 2) pd
[4*i
+ 1]= ((pd
[i
]>>4) & 3)*0x55;
820 if ((s
->width
&3) >= 1) pd
[4*i
+ 0]= ( pd
[i
]>>6 )*0x55;
821 for (i
--; i
>= 0; i
--) {
822 pd
[4*i
+ 3]= ( pd
[i
] & 3)*0x55;
823 pd
[4*i
+ 2]= ((pd
[i
]>>2) & 3)*0x55;
824 pd
[4*i
+ 1]= ((pd
[i
]>>4) & 3)*0x55;
825 pd
[4*i
+ 0]= ( pd
[i
]>>6 )*0x55;
828 pd
+= s
->image_linesize
;
831 if (s
->bits_per_pixel
== 4){
833 uint8_t *pd
= p
->data
[0];
834 for (j
= 0; j
< s
->height
; j
++) {
836 if (s
->color_type
== PNG_COLOR_TYPE_PALETTE
){
837 if (s
->width
&1) pd
[2*i
+0]= pd
[i
]>>4;
838 for (i
--; i
>= 0; i
--) {
839 pd
[2*i
+ 1] = pd
[i
] & 15;
840 pd
[2*i
+ 0] = pd
[i
] >> 4;
843 if (s
->width
& 1) pd
[2*i
+ 0]= (pd
[i
] >> 4) * 0x11;
844 for (i
--; i
>= 0; i
--) {
845 pd
[2*i
+ 1] = (pd
[i
] & 15) * 0x11;
846 pd
[2*i
+ 0] = (pd
[i
] >> 4) * 0x11;
849 pd
+= s
->image_linesize
;
853 /* handle p-frames only if a predecessor frame is available */
854 if (s
->last_picture
.f
->data
[0]) {
855 if ( !(avpkt
->flags
& AV_PKT_FLAG_KEY
) && avctx
->codec_tag
!= AV_RL32("MPNG")
856 && s
->last_picture
.f
->width
== p
->width
857 && s
->last_picture
.f
->height
== p
->height
858 && s
->last_picture
.f
->format
== p
->format
861 uint8_t *pd
= p
->data
[0];
862 uint8_t *pd_last
= s
->last_picture
.f
->data
[0];
863 int ls
= FFMIN(av_image_get_linesize(p
->format
, s
->width
, 0), s
->width
* s
->bpp
);
865 ff_thread_await_progress(&s
->last_picture
, INT_MAX
, 0);
866 for (j
= 0; j
< s
->height
; j
++) {
867 for (i
= 0; i
< ls
; i
++)
869 pd
+= s
->image_linesize
;
870 pd_last
+= s
->image_linesize
;
874 ff_thread_report_progress(&s
->picture
, INT_MAX
, 0);
876 av_frame_set_metadata(p
, metadata
);
879 if ((ret
= av_frame_ref(data
, s
->picture
.f
)) < 0)
884 ret
= bytestream2_tell(&s
->gb
);
886 inflateEnd(&s
->zstream
);
890 av_dict_free(&metadata
);
891 ff_thread_report_progress(&s
->picture
, INT_MAX
, 0);
892 ret
= AVERROR_INVALIDDATA
;
896 static int update_thread_context(AVCodecContext
*dst
, const AVCodecContext
*src
)
898 PNGDecContext
*psrc
= src
->priv_data
;
899 PNGDecContext
*pdst
= dst
->priv_data
;
904 ff_thread_release_buffer(dst
, &pdst
->picture
);
905 if (psrc
->picture
.f
->data
[0])
906 return ff_thread_ref_frame(&pdst
->picture
, &psrc
->picture
);
911 static av_cold
int png_dec_init(AVCodecContext
*avctx
)
913 PNGDecContext
*s
= avctx
->priv_data
;
916 s
->last_picture
.f
= av_frame_alloc();
917 s
->picture
.f
= av_frame_alloc();
918 if (!s
->last_picture
.f
|| !s
->picture
.f
)
919 return AVERROR(ENOMEM
);
921 if (!avctx
->internal
->is_copy
) {
922 avctx
->internal
->allocate_progress
= 1;
923 ff_pngdsp_init(&s
->dsp
);
929 static av_cold
int png_dec_end(AVCodecContext
*avctx
)
931 PNGDecContext
*s
= avctx
->priv_data
;
933 ff_thread_release_buffer(avctx
, &s
->last_picture
);
934 av_frame_free(&s
->last_picture
.f
);
935 ff_thread_release_buffer(avctx
, &s
->picture
);
936 av_frame_free(&s
->picture
.f
);
937 av_freep(&s
->buffer
);
939 av_freep(&s
->last_row
);
940 s
->last_row_size
= 0;
941 av_freep(&s
->tmp_row
);
947 AVCodec ff_png_decoder
= {
949 .long_name
= NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
950 .type
= AVMEDIA_TYPE_VIDEO
,
951 .id
= AV_CODEC_ID_PNG
,
952 .priv_data_size
= sizeof(PNGDecContext
),
953 .init
= png_dec_init
,
954 .close
= png_dec_end
,
955 .decode
= decode_frame
,
956 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(png_dec_init
),
957 .update_thread_context
= ONLY_IF_THREADS_ENABLED(update_thread_context
),
958 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
/*| CODEC_CAP_DRAW_HORIZ_BAND*/,