GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/pngdec.c Lines: 630 1007 62.6 %
Date: 2021-04-18 21:26:34 Branches: 398 732 54.4 %

Line Branch Exec Source
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"
30
#include "libavutil/mastering_display_metadata.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
42
enum PNGHeaderState {
43
    PNG_IHDR = 1 << 0,
44
    PNG_PLTE = 1 << 1,
45
};
46
47
enum PNGImageState {
48
    PNG_IDAT     = 1 << 0,
49
    PNG_ALLIMAGE = 1 << 1,
50
};
51
52
typedef struct PNGDecContext {
53
    PNGDSPContext dsp;
54
    AVCodecContext *avctx;
55
56
    GetByteContext gb;
57
    ThreadFrame last_picture;
58
    ThreadFrame picture;
59
60
    AVDictionary *frame_metadata;
61
62
    uint8_t  iccp_name[82];
63
    uint8_t *iccp_data;
64
    size_t   iccp_data_len;
65
66
    int stereo_mode;
67
68
    int have_chrm;
69
    uint32_t white_point[2];
70
    uint32_t display_primaries[3][2];
71
72
    enum PNGHeaderState hdr_state;
73
    enum PNGImageState pic_state;
74
    int width, height;
75
    int cur_w, cur_h;
76
    int last_w, last_h;
77
    int x_offset, y_offset;
78
    int last_x_offset, last_y_offset;
79
    uint8_t dispose_op, blend_op;
80
    uint8_t last_dispose_op;
81
    int bit_depth;
82
    int color_type;
83
    int compression_type;
84
    int interlace_type;
85
    int filter_type;
86
    int channels;
87
    int bits_per_pixel;
88
    int bpp;
89
    int has_trns;
90
    uint8_t transparent_color_be[6];
91
92
    uint8_t *background_buf;
93
    unsigned background_buf_allocated;
94
    uint32_t palette[256];
95
    uint8_t *crow_buf;
96
    uint8_t *last_row;
97
    unsigned int last_row_size;
98
    uint8_t *tmp_row;
99
    unsigned int tmp_row_size;
100
    uint8_t *buffer;
101
    int buffer_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 */
116
static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {
117
    0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
118
};
119
120
/* Mask to determine which pixels to overwrite while displaying */
121
static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
122
    0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
123
};
124
125
/* NOTE: we try to construct a good looking image at each pass. width
126
 * is the original image width. We also do pixel format conversion at
127
 * this stage */
128
2816
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
136
2816
    mask     = png_pass_mask[pass];
137
2816
    dsp_mask = png_pass_dsp_mask[pass];
138
139

2816
    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
2816
    default:
182
2816
        bpp = bits_per_pixel >> 3;
183
2816
        d   = dst;
184
2816
        s   = src;
185
363264
            for (x = 0; x < width; x++) {
186
360448
                j = x & 7;
187
360448
                if ((dsp_mask << j) & 0x80) {
188
262144
                    memcpy(d, s, bpp);
189
                }
190
360448
                d += bpp;
191
360448
                if ((mask << j) & 0x80)
192
122880
                    s += bpp;
193
            }
194
2816
        break;
195
    }
196
2816
}
197
198
50396
void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top,
199
                                 int w, int bpp)
200
{
201
    int i;
202
12213290
    for (i = 0; i < w; i++) {
203
        int a, b, c, p, pa, pb, pc;
204
205
12162894
        a = dst[i - bpp];
206
12162894
        b = top[i];
207
12162894
        c = top[i - bpp];
208
209
12162894
        p  = b - c;
210
12162894
        pc = a - c;
211
212
12162894
        pa = abs(p);
213
12162894
        pb = abs(pc);
214
12162894
        pc = abs(p + pc);
215
216

12162894
        if (pa <= pb && pa <= pc)
217
7014401
            p = a;
218
5148493
        else if (pb <= pc)
219
4186956
            p = b;
220
        else
221
961537
            p = c;
222
12162894
        dst[i] = p + src[i];
223
    }
224
50396
}
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
118690
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

118690
    switch (filter_type) {
270
80032
    case PNG_FILTER_VALUE_NONE:
271
80032
        memcpy(dst, src, size);
272
80032
        break;
273
3329
    case PNG_FILTER_VALUE_SUB:
274
15121
        for (i = 0; i < bpp; i++)
275
11792
            dst[i] = src[i];
276
3329
        if (bpp == 4) {
277
1775
            p = *(int *)dst;
278
310888
            for (; i < size; i += bpp) {
279
309113
                unsigned s = *(int *)(src + i);
280
309113
                p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080);
281
309113
                *(int *)(dst + i) = p;
282
            }
283
        } else {
284
#define OP_SUB(x, s, l) ((x) + (s))
285




293599
            UNROLL_FILTER(OP_SUB);
286
        }
287
3329
        break;
288
8279
    case PNG_FILTER_VALUE_UP:
289
8279
        dsp->add_bytes_l2(dst, src, last, size);
290
8279
        break;
291
1634
    case PNG_FILTER_VALUE_AVG:
292
6838
        for (i = 0; i < bpp; i++) {
293
5204
            p      = (last[i] >> 1);
294
5204
            dst[i] = p + src[i];
295
        }
296
#define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff)
297




230218
        UNROLL_FILTER(OP_AVG);
298
1634
        break;
299
25416
    case PNG_FILTER_VALUE_PAETH:
300
103928
        for (i = 0; i < bpp; i++) {
301
78512
            p      = last[i];
302
78512
            dst[i] = p + src[i];
303
        }
304

25416
        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
25346
            int w = (bpp & 3) ? size - 3 : size;
308
309
25346
            if (w > i) {
310
25346
                dsp->add_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
311
25346
                i = w;
312
            }
313
        }
314
25416
        ff_add_png_paeth_prediction(dst + i, src + i, last + i, size - i, bpp);
315
25416
        break;
316
    }
317
118690
}
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
335
540
static int percent_missing(PNGDecContext *s)
336
{
337
540
    if (s->interlace_type) {
338
2
        return 100 - 100 * s->pass / (NB_PASSES - 1);
339
    } else {
340
538
        return 100 - 100 * s->y / s->cur_h;
341
    }
342
}
343
344
/* process exactly one decompressed row */
345
114449
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
114449
    if (!s->interlace_type) {
351
113489
        ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
352
113489
        if (s->y == 0)
353
589
            last_row = s->last_row;
354
        else
355
112900
            last_row = ptr - dst_stride;
356
357
113489
        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

113489
        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
113489
        s->y++;
370
113489
        if (s->y == s->cur_h) {
371
589
            s->pic_state |= PNG_ALLIMAGE;
372
589
            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
960
        got_line = 0;
384
        for (;;) {
385
4540
            ptr = dst + dst_stride * (s->y + s->y_offset) + s->x_offset * s->bpp;
386
4540
            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
1916
                if (got_line)
390
956
                    break;
391
960
                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
960
                FFSWAP(uint8_t *, s->last_row, s->tmp_row);
394
960
                FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size);
395
960
                got_line = 1;
396
            }
397
3584
            if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
398
2816
                png_put_interlaced_row(ptr, s->cur_w, s->bits_per_pixel, s->pass,
399
2816
                                       s->color_type, s->last_row);
400
            }
401
3584
            s->y++;
402
3584
            if (s->y == s->cur_h) {
403
28
                memset(s->last_row, 0, s->row_size);
404
                for (;;) {
405
28
                    if (s->pass == NB_PASSES - 1) {
406
4
                        s->pic_state |= PNG_ALLIMAGE;
407
4
                        goto the_end;
408
                    } else {
409
24
                        s->pass++;
410
24
                        s->y = 0;
411
24
                        s->pass_row_size = ff_png_pass_row_size(s->pass,
412
                                                                s->bits_per_pixel,
413
                                                                s->cur_w);
414
24
                        s->crow_size = s->pass_row_size + 1;
415
24
                        if (s->pass_row_size != 0)
416
24
                            break;
417
                        /* skip pass if empty row */
418
                    }
419
                }
420
            }
421
        }
422
960
the_end:;
423
    }
424
114449
}
425
426
15930
static int png_decode_idat(PNGDecContext *s, GetByteContext *gb,
427
                           uint8_t *dst, ptrdiff_t dst_stride)
428
{
429
    int ret;
430
15930
    s->zstream.avail_in = bytestream2_get_bytes_left(gb);
431
15930
    s->zstream.next_in  = gb->buffer;
432
433
    /* decode one line if possible */
434
145691
    while (s->zstream.avail_in > 0) {
435
129761
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
436

129761
        if (ret != Z_OK && ret != Z_STREAM_END) {
437
            av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
438
            return AVERROR_EXTERNAL;
439
        }
440
129761
        if (s->zstream.avail_out == 0) {
441
114449
            if (!(s->pic_state & PNG_ALLIMAGE)) {
442
114449
                png_handle_row(s, dst, dst_stride);
443
            }
444
114449
            s->zstream.avail_out = s->crow_size;
445
114449
            s->zstream.next_out  = s->crow_buf;
446
        }
447

129761
        if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
448
            av_log(s->avctx, AV_LOG_WARNING,
449
                   "%d undecompressed bytes left in buffer\n", s->zstream.avail_in);
450
            return 0;
451
        }
452
    }
453
15930
    return 0;
454
}
455
456
2
static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
457
                       const uint8_t *data_end)
458
{
459
    z_stream zstream;
460
    unsigned char *buf;
461
    unsigned buf_size;
462
    int ret;
463
464
2
    zstream.zalloc = ff_png_zalloc;
465
2
    zstream.zfree  = ff_png_zfree;
466
2
    zstream.opaque = NULL;
467
2
    if (inflateInit(&zstream) != Z_OK)
468
        return AVERROR_EXTERNAL;
469
2
    zstream.next_in  = data;
470
2
    zstream.avail_in = data_end - data;
471
2
    av_bprint_init(bp, 0, AV_BPRINT_SIZE_UNLIMITED);
472
473
6
    while (zstream.avail_in > 0) {
474
6
        av_bprint_get_buffer(bp, 2, &buf, &buf_size);
475
6
        if (buf_size < 2) {
476
            ret = AVERROR(ENOMEM);
477
            goto fail;
478
        }
479
6
        zstream.next_out  = buf;
480
6
        zstream.avail_out = buf_size - 1;
481
6
        ret = inflate(&zstream, Z_PARTIAL_FLUSH);
482

6
        if (ret != Z_OK && ret != Z_STREAM_END) {
483
            ret = AVERROR_EXTERNAL;
484
            goto fail;
485
        }
486
6
        bp->len += zstream.next_out - buf;
487
6
        if (ret == Z_STREAM_END)
488
2
            break;
489
    }
490
2
    inflateEnd(&zstream);
491
2
    bp->str[bp->len] = 0;
492
2
    return 0;
493
494
fail:
495
    inflateEnd(&zstream);
496
    av_bprint_finalize(bp, NULL);
497
    return ret;
498
}
499
500
234
static uint8_t *iso88591_to_utf8(const uint8_t *in, size_t size_in)
501
{
502
234
    size_t extra = 0, i;
503
    uint8_t *out, *q;
504
505
4049
    for (i = 0; i < size_in; i++)
506
3815
        extra += in[i] >= 0x80;
507

234
    if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
508
        return NULL;
509
234
    q = out = av_malloc(size_in + extra + 1);
510
234
    if (!out)
511
        return NULL;
512
4049
    for (i = 0; i < size_in; i++) {
513
3815
        if (in[i] >= 0x80) {
514
            *(q++) = 0xC0 | (in[i] >> 6);
515
            *(q++) = 0x80 | (in[i] & 0x3F);
516
        } else {
517
3815
            *(q++) = in[i];
518
        }
519
    }
520
234
    *(q++) = 0;
521
234
    return out;
522
}
523
524
117
static int decode_text_chunk(PNGDecContext *s, GetByteContext *gb, int compressed)
525
{
526
    int ret, method;
527
117
    const uint8_t *data        = gb->buffer;
528
117
    const uint8_t *data_end    = gb->buffer_end;
529
117
    const uint8_t *keyword     = data;
530
117
    const uint8_t *keyword_end = memchr(keyword, 0, data_end - keyword);
531
117
    uint8_t *kw_utf8 = NULL, *text, *txt_utf8 = NULL;
532
    unsigned text_len;
533
    AVBPrint bp;
534
535
117
    if (!keyword_end)
536
        return AVERROR_INVALIDDATA;
537
117
    data = keyword_end + 1;
538
539
117
    if (compressed) {
540
        if (data == data_end)
541
            return AVERROR_INVALIDDATA;
542
        method = *(data++);
543
        if (method)
544
            return AVERROR_INVALIDDATA;
545
        if ((ret = decode_zbuf(&bp, data, data_end)) < 0)
546
            return ret;
547
        text_len = bp.len;
548
        ret = av_bprint_finalize(&bp, (char **)&text);
549
        if (ret < 0)
550
            return ret;
551
    } else {
552
117
        text = (uint8_t *)data;
553
117
        text_len = data_end - text;
554
    }
555
556
117
    kw_utf8  = iso88591_to_utf8(keyword, keyword_end - keyword);
557
117
    txt_utf8 = iso88591_to_utf8(text, text_len);
558
117
    if (text != data)
559
        av_free(text);
560

117
    if (!(kw_utf8 && txt_utf8)) {
561
        av_free(kw_utf8);
562
        av_free(txt_utf8);
563
        return AVERROR(ENOMEM);
564
    }
565
566
117
    av_dict_set(&s->frame_metadata, kw_utf8, txt_utf8,
567
                AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
568
117
    return 0;
569
}
570
571
369
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s,
572
                             GetByteContext *gb)
573
{
574
369
    if (bytestream2_get_bytes_left(gb) != 13)
575
        return AVERROR_INVALIDDATA;
576
577
369
    if (s->pic_state & PNG_IDAT) {
578
        av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
579
        return AVERROR_INVALIDDATA;
580
    }
581
582
369
    if (s->hdr_state & PNG_IHDR) {
583
        av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
584
        return AVERROR_INVALIDDATA;
585
    }
586
587
369
    s->width  = s->cur_w = bytestream2_get_be32(gb);
588
369
    s->height = s->cur_h = bytestream2_get_be32(gb);
589
369
    if (av_image_check_size(s->width, s->height, 0, avctx)) {
590
        s->cur_w = s->cur_h = s->width = s->height = 0;
591
        av_log(avctx, AV_LOG_ERROR, "Invalid image size\n");
592
        return AVERROR_INVALIDDATA;
593
    }
594
369
    s->bit_depth        = bytestream2_get_byte(gb);
595

369
    if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
596

369
        s->bit_depth != 8 && s->bit_depth != 16) {
597
        av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
598
        goto error;
599
    }
600
369
    s->color_type       = bytestream2_get_byte(gb);
601
369
    s->compression_type = bytestream2_get_byte(gb);
602
369
    if (s->compression_type) {
603
        av_log(avctx, AV_LOG_ERROR, "Invalid compression method %d\n", s->compression_type);
604
        goto error;
605
    }
606
369
    s->filter_type      = bytestream2_get_byte(gb);
607
369
    s->interlace_type   = bytestream2_get_byte(gb);
608
369
    s->hdr_state |= PNG_IHDR;
609
369
    if (avctx->debug & FF_DEBUG_PICT_INFO)
610
        av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
611
                "compression_type=%d filter_type=%d interlace_type=%d\n",
612
                s->width, s->height, s->bit_depth, s->color_type,
613
                s->compression_type, s->filter_type, s->interlace_type);
614
615
369
    return 0;
616
error:
617
    s->cur_w = s->cur_h = s->width = s->height = 0;
618
    s->bit_depth = 8;
619
    return AVERROR_INVALIDDATA;
620
}
621
622
341
static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s,
623
                             GetByteContext *gb)
624
{
625
341
    if (s->pic_state & PNG_IDAT) {
626
        av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
627
        return AVERROR_INVALIDDATA;
628
    }
629
341
    avctx->sample_aspect_ratio.num = bytestream2_get_be32(gb);
630
341
    avctx->sample_aspect_ratio.den = bytestream2_get_be32(gb);
631

341
    if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.den < 0)
632
        avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
633
341
    bytestream2_skip(gb, 1); /* unit specifier */
634
635
341
    return 0;
636
}
637
638
15930
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
639
                             GetByteContext *gb, AVFrame *p)
640
{
641
    int ret;
642
15930
    size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
643
644
15930
    if (!(s->hdr_state & PNG_IHDR)) {
645
        av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
646
        return AVERROR_INVALIDDATA;
647
    }
648
15930
    if (!(s->pic_state & PNG_IDAT)) {
649
        /* init image info */
650
593
        ret = ff_set_dimensions(avctx, s->width, s->height);
651
593
        if (ret < 0)
652
            return ret;
653
654
593
        s->channels       = ff_png_get_nb_channels(s->color_type);
655
593
        s->bits_per_pixel = s->bit_depth * s->channels;
656
593
        s->bpp            = (s->bits_per_pixel + 7) >> 3;
657
593
        s->row_size       = (s->cur_w * s->bits_per_pixel + 7) >> 3;
658
659

593
        if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
660
553
                s->color_type == PNG_COLOR_TYPE_RGB) {
661
452
            avctx->pix_fmt = AV_PIX_FMT_RGB24;
662

141
        } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
663
101
                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
664
54
            avctx->pix_fmt = AV_PIX_FMT_RGBA;
665

87
        } else if ((s->bit_depth == 2 || s->bit_depth == 4 || s->bit_depth == 8) &&
666
47
                s->color_type == PNG_COLOR_TYPE_GRAY) {
667
4
            avctx->pix_fmt = AV_PIX_FMT_GRAY8;
668
83
        } else if (s->bit_depth == 16 &&
669
40
                s->color_type == PNG_COLOR_TYPE_GRAY) {
670
16
            avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
671
67
        } else if (s->bit_depth == 16 &&
672
24
                s->color_type == PNG_COLOR_TYPE_RGB) {
673
18
            avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
674
49
        } else if (s->bit_depth == 16 &&
675
6
                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
676
4
            avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
677


45
        } else if ((s->bits_per_pixel == 1 || s->bits_per_pixel == 2 || s->bits_per_pixel == 4 || s->bits_per_pixel == 8) &&
678
41
                s->color_type == PNG_COLOR_TYPE_PALETTE) {
679
41
            avctx->pix_fmt = AV_PIX_FMT_PAL8;
680

4
        } else if (s->bit_depth == 1 && s->bits_per_pixel == 1 && avctx->codec_id != AV_CODEC_ID_APNG) {
681
            avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
682
4
        } else if (s->bit_depth == 8 &&
683
2
                s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
684
2
            avctx->pix_fmt = AV_PIX_FMT_YA8;
685
2
        } else if (s->bit_depth == 16 &&
686
2
                s->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
687
2
            avctx->pix_fmt = AV_PIX_FMT_YA16BE;
688
        } else {
689
            avpriv_report_missing_feature(avctx,
690
                                          "Bit depth %d color type %d",
691
                                          s->bit_depth, s->color_type);
692
            return AVERROR_PATCHWELCOME;
693
        }
694
695

593
        if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
696

137
            switch (avctx->pix_fmt) {
697
137
            case AV_PIX_FMT_RGB24:
698
137
                avctx->pix_fmt = AV_PIX_FMT_RGBA;
699
137
                break;
700
701
            case AV_PIX_FMT_RGB48BE:
702
                avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
703
                break;
704
705
            case AV_PIX_FMT_GRAY8:
706
                avctx->pix_fmt = AV_PIX_FMT_YA8;
707
                break;
708
709
            case AV_PIX_FMT_GRAY16BE:
710
                avctx->pix_fmt = AV_PIX_FMT_YA16BE;
711
                break;
712
713
            default:
714
                avpriv_request_sample(avctx, "bit depth %d "
715
                        "and color type %d with TRNS",
716
                        s->bit_depth, s->color_type);
717
                return AVERROR_INVALIDDATA;
718
            }
719
720
137
            s->bpp += byte_depth;
721
        }
722
723
593
        ff_thread_release_buffer(avctx, &s->picture);
724
593
        if ((ret = ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
725
            return ret;
726
727
593
        p->pict_type        = AV_PICTURE_TYPE_I;
728
593
        p->key_frame        = 1;
729
593
        p->interlaced_frame = !!s->interlace_type;
730
731
593
        ff_thread_finish_setup(avctx);
732
733
        /* compute the compressed row size */
734
593
        if (!s->interlace_type) {
735
589
            s->crow_size = s->row_size + 1;
736
        } else {
737
4
            s->pass          = 0;
738
4
            s->pass_row_size = ff_png_pass_row_size(s->pass,
739
                    s->bits_per_pixel,
740
                    s->cur_w);
741
4
            s->crow_size = s->pass_row_size + 1;
742
        }
743
        ff_dlog(avctx, "row_size=%d crow_size =%d\n",
744
                s->row_size, s->crow_size);
745
746
        /* copy the palette if needed */
747
593
        if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
748
41
            memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
749
        /* empty row is used if differencing to the first row */
750
593
        av_fast_padded_mallocz(&s->last_row, &s->last_row_size, s->row_size);
751
593
        if (!s->last_row)
752
            return AVERROR_INVALIDDATA;
753
593
        if (s->interlace_type ||
754
589
                s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
755
62
            av_fast_padded_malloc(&s->tmp_row, &s->tmp_row_size, s->row_size);
756
62
            if (!s->tmp_row)
757
                return AVERROR_INVALIDDATA;
758
        }
759
        /* compressed row */
760
593
        av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
761
593
        if (!s->buffer)
762
            return AVERROR(ENOMEM);
763
764
        /* we want crow_buf+1 to be 16-byte aligned */
765
593
        s->crow_buf          = s->buffer + 15;
766
593
        s->zstream.avail_out = s->crow_size;
767
593
        s->zstream.next_out  = s->crow_buf;
768
    }
769
770
15930
    s->pic_state |= PNG_IDAT;
771
772
    /* set image to non-transparent bpp while decompressing */
773

15930
    if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
774
147
        s->bpp -= byte_depth;
775
776
15930
    ret = png_decode_idat(s, gb, p->data[0], p->linesize[0]);
777
778

15930
    if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
779
147
        s->bpp += byte_depth;
780
781
15930
    if (ret < 0)
782
        return ret;
783
784
15930
    return 0;
785
}
786
787
2
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s,
788
                             GetByteContext *gb)
789
{
790
2
    int length = bytestream2_get_bytes_left(gb);
791
    int n, i, r, g, b;
792
793

2
    if ((length % 3) != 0 || length > 256 * 3)
794
        return AVERROR_INVALIDDATA;
795
    /* read the palette */
796
2
    n = length / 3;
797
474
    for (i = 0; i < n; i++) {
798
472
        r = bytestream2_get_byte(gb);
799
472
        g = bytestream2_get_byte(gb);
800
472
        b = bytestream2_get_byte(gb);
801
472
        s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
802
    }
803
42
    for (; i < 256; i++)
804
40
        s->palette[i] = (0xFFU << 24);
805
2
    s->hdr_state |= PNG_PLTE;
806
807
2
    return 0;
808
}
809
810
6
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s,
811
                             GetByteContext *gb)
812
{
813
6
    int length = bytestream2_get_bytes_left(gb);
814
    int v, i;
815
816
6
    if (!(s->hdr_state & PNG_IHDR)) {
817
        av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
818
        return AVERROR_INVALIDDATA;
819
    }
820
821
6
    if (s->pic_state & PNG_IDAT) {
822
        av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
823
        return AVERROR_INVALIDDATA;
824
    }
825
826
6
    if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
827

2
        if (length > 256 || !(s->hdr_state & PNG_PLTE))
828
            return AVERROR_INVALIDDATA;
829
830
36
        for (i = 0; i < length; i++) {
831
34
            unsigned v = bytestream2_get_byte(gb);
832
34
            s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
833
        }
834

4
    } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
835

4
        if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
836

4
            (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
837
4
            s->bit_depth == 1)
838
            return AVERROR_INVALIDDATA;
839
840
16
        for (i = 0; i < length / 2; i++) {
841
            /* only use the least significant bits */
842
12
            v = av_mod_uintp2(bytestream2_get_be16(gb), s->bit_depth);
843
844
12
            if (s->bit_depth > 8)
845
                AV_WB16(&s->transparent_color_be[2 * i], v);
846
            else
847
12
                s->transparent_color_be[i] = v;
848
        }
849
    } else {
850
        return AVERROR_INVALIDDATA;
851
    }
852
853
6
    s->has_trns = 1;
854
855
6
    return 0;
856
}
857
858
2
static int decode_iccp_chunk(PNGDecContext *s, GetByteContext *gb, AVFrame *f)
859
{
860
2
    int ret, cnt = 0;
861
    AVBPrint bp;
862
863

44
    while ((s->iccp_name[cnt++] = bytestream2_get_byte(gb)) && cnt < 81);
864
2
    if (cnt > 80) {
865
        av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
866
        ret = AVERROR_INVALIDDATA;
867
        goto fail;
868
    }
869
870
2
    if (bytestream2_get_byte(gb) != 0) {
871
        av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
872
        ret =  AVERROR_INVALIDDATA;
873
        goto fail;
874
    }
875
876
2
    if ((ret = decode_zbuf(&bp, gb->buffer, gb->buffer_end)) < 0)
877
        return ret;
878
879
2
    av_freep(&s->iccp_data);
880
2
    ret = av_bprint_finalize(&bp, (char **)&s->iccp_data);
881
2
    if (ret < 0)
882
        return ret;
883
2
    s->iccp_data_len = bp.len;
884
885
2
    return 0;
886
fail:
887
    s->iccp_name[0] = 0;
888
    return ret;
889
}
890
891
static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
892
{
893
    if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
894
        int i, j, k;
895
        uint8_t *pd = p->data[0];
896
        for (j = 0; j < s->height; j++) {
897
            i = s->width / 8;
898
            for (k = 7; k >= 1; k--)
899
                if ((s->width&7) >= k)
900
                    pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
901
            for (i--; i >= 0; i--) {
902
                pd[8*i + 7]=  pd[i]     & 1;
903
                pd[8*i + 6]= (pd[i]>>1) & 1;
904
                pd[8*i + 5]= (pd[i]>>2) & 1;
905
                pd[8*i + 4]= (pd[i]>>3) & 1;
906
                pd[8*i + 3]= (pd[i]>>4) & 1;
907
                pd[8*i + 2]= (pd[i]>>5) & 1;
908
                pd[8*i + 1]= (pd[i]>>6) & 1;
909
                pd[8*i + 0]=  pd[i]>>7;
910
            }
911
            pd += p->linesize[0];
912
        }
913
    } else if (s->bits_per_pixel == 2) {
914
        int i, j;
915
        uint8_t *pd = p->data[0];
916
        for (j = 0; j < s->height; j++) {
917
            i = s->width / 4;
918
            if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
919
                if ((s->width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
920
                if ((s->width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
921
                if ((s->width&3) >= 1) pd[4*i + 0]=  pd[i] >> 6;
922
                for (i--; i >= 0; i--) {
923
                    pd[4*i + 3]=  pd[i]     & 3;
924
                    pd[4*i + 2]= (pd[i]>>2) & 3;
925
                    pd[4*i + 1]= (pd[i]>>4) & 3;
926
                    pd[4*i + 0]=  pd[i]>>6;
927
                }
928
            } else {
929
                if ((s->width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
930
                if ((s->width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
931
                if ((s->width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6     )*0x55;
932
                for (i--; i >= 0; i--) {
933
                    pd[4*i + 3]= ( pd[i]     & 3)*0x55;
934
                    pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
935
                    pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
936
                    pd[4*i + 0]= ( pd[i]>>6     )*0x55;
937
                }
938
            }
939
            pd += p->linesize[0];
940
        }
941
    } else if (s->bits_per_pixel == 4) {
942
        int i, j;
943
        uint8_t *pd = p->data[0];
944
        for (j = 0; j < s->height; j++) {
945
            i = s->width/2;
946
            if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
947
                if (s->width&1) pd[2*i+0]= pd[i]>>4;
948
                for (i--; i >= 0; i--) {
949
                    pd[2*i + 1] = pd[i] & 15;
950
                    pd[2*i + 0] = pd[i] >> 4;
951
                }
952
            } else {
953
                if (s->width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
954
                for (i--; i >= 0; i--) {
955
                    pd[2*i + 1] = (pd[i] & 15) * 0x11;
956
                    pd[2*i + 0] = (pd[i] >> 4) * 0x11;
957
                }
958
            }
959
            pd += p->linesize[0];
960
        }
961
    }
962
}
963
964
236
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s,
965
                             GetByteContext *gb)
966
{
967
    uint32_t sequence_number;
968
    int cur_w, cur_h, x_offset, y_offset, dispose_op, blend_op;
969
970
236
    if (bytestream2_get_bytes_left(gb) != 26)
971
        return AVERROR_INVALIDDATA;
972
973
236
    if (!(s->hdr_state & PNG_IHDR)) {
974
        av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
975
        return AVERROR_INVALIDDATA;
976
    }
977
978
236
    if (s->pic_state & PNG_IDAT) {
979
        av_log(avctx, AV_LOG_ERROR, "fctl after IDAT\n");
980
        return AVERROR_INVALIDDATA;
981
    }
982
983
236
    s->last_w = s->cur_w;
984
236
    s->last_h = s->cur_h;
985
236
    s->last_x_offset = s->x_offset;
986
236
    s->last_y_offset = s->y_offset;
987
236
    s->last_dispose_op = s->dispose_op;
988
989
236
    sequence_number = bytestream2_get_be32(gb);
990
236
    cur_w           = bytestream2_get_be32(gb);
991
236
    cur_h           = bytestream2_get_be32(gb);
992
236
    x_offset        = bytestream2_get_be32(gb);
993
236
    y_offset        = bytestream2_get_be32(gb);
994
236
    bytestream2_skip(gb, 4); /* delay_num (2), delay_den (2) */
995
236
    dispose_op      = bytestream2_get_byte(gb);
996
236
    blend_op        = bytestream2_get_byte(gb);
997
998
236
    if (sequence_number == 0 &&
999
11
        (cur_w != s->width ||
1000

11
         cur_h != s->height ||
1001
11
         x_offset != 0 ||
1002
236
         y_offset != 0) ||
1003

236
        cur_w <= 0 || cur_h <= 0 ||
1004
236
        x_offset < 0 || y_offset < 0 ||
1005

236
        cur_w > s->width - x_offset|| cur_h > s->height - y_offset)
1006
            return AVERROR_INVALIDDATA;
1007
1008

236
    if (blend_op != APNG_BLEND_OP_OVER && blend_op != APNG_BLEND_OP_SOURCE) {
1009
        av_log(avctx, AV_LOG_ERROR, "Invalid blend_op %d\n", blend_op);
1010
        return AVERROR_INVALIDDATA;
1011
    }
1012
1013

236
    if ((sequence_number == 0 || !s->last_picture.f->data[0]) &&
1014
        dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1015
        // No previous frame to revert to for the first frame
1016
        // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
1017
        dispose_op = APNG_DISPOSE_OP_BACKGROUND;
1018
    }
1019
1020

236
    if (blend_op == APNG_BLEND_OP_OVER && !s->has_trns && (
1021
            avctx->pix_fmt == AV_PIX_FMT_RGB24 ||
1022
            avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1023
            avctx->pix_fmt == AV_PIX_FMT_PAL8 ||
1024
            avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
1025
            avctx->pix_fmt == AV_PIX_FMT_GRAY16BE ||
1026
            avctx->pix_fmt == AV_PIX_FMT_MONOBLACK
1027
        )) {
1028
        // APNG_BLEND_OP_OVER is the same as APNG_BLEND_OP_SOURCE when there is no alpha channel
1029
        blend_op = APNG_BLEND_OP_SOURCE;
1030
    }
1031
1032
236
    s->cur_w      = cur_w;
1033
236
    s->cur_h      = cur_h;
1034
236
    s->x_offset   = x_offset;
1035
236
    s->y_offset   = y_offset;
1036
236
    s->dispose_op = dispose_op;
1037
236
    s->blend_op   = blend_op;
1038
1039
236
    return 0;
1040
}
1041
1042
static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
1043
{
1044
    int i, j;
1045
    uint8_t *pd      = p->data[0];
1046
    uint8_t *pd_last = s->last_picture.f->data[0];
1047
    int ls = FFMIN(av_image_get_linesize(p->format, s->width, 0), s->width * s->bpp);
1048
1049
    ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1050
    for (j = 0; j < s->height; j++) {
1051
        for (i = 0; i < ls; i++)
1052
            pd[i] += pd_last[i];
1053
        pd      += p->linesize[0];
1054
        pd_last += s->last_picture.f->linesize[0];
1055
    }
1056
}
1057
1058
// divide by 255 and round to nearest
1059
// apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
1060
#define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
1061
1062
40
static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s,
1063
                               AVFrame *p)
1064
{
1065
40
    uint8_t       *dst        = p->data[0];
1066
40
    ptrdiff_t      dst_stride = p->linesize[0];
1067
40
    const uint8_t *src        = s->last_picture.f->data[0];
1068
40
    ptrdiff_t      src_stride = s->last_picture.f->linesize[0];
1069
1070
    size_t x, y;
1071
1072
40
    if (s->blend_op == APNG_BLEND_OP_OVER &&
1073
39
        avctx->pix_fmt != AV_PIX_FMT_RGBA &&
1074
39
        avctx->pix_fmt != AV_PIX_FMT_GRAY8A &&
1075
39
        avctx->pix_fmt != AV_PIX_FMT_PAL8) {
1076
        avpriv_request_sample(avctx, "Blending with pixel format %s",
1077
                              av_get_pix_fmt_name(avctx->pix_fmt));
1078
        return AVERROR_PATCHWELCOME;
1079
    }
1080
1081
40
    ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
1082
1083
    // need to reset a rectangle to background:
1084
40
    if (s->last_dispose_op == APNG_DISPOSE_OP_BACKGROUND) {
1085
        av_fast_malloc(&s->background_buf, &s->background_buf_allocated,
1086
                       src_stride * p->height);
1087
        if (!s->background_buf)
1088
            return AVERROR(ENOMEM);
1089
1090
        memcpy(s->background_buf, src, src_stride * p->height);
1091
1092
        for (y = s->last_y_offset; y < s->last_y_offset + s->last_h; y++) {
1093
            memset(s->background_buf + src_stride * y +
1094
                   s->bpp * s->last_x_offset, 0, s->bpp * s->last_w);
1095
        }
1096
1097
        src = s->background_buf;
1098
    }
1099
1100
    // copy unchanged rectangles from the last frame
1101
1920
    for (y = 0; y < s->y_offset; y++)
1102
1880
        memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1103
1920
    for (y = s->y_offset; y < s->y_offset + s->cur_h; y++) {
1104
1880
        memcpy(dst + y * dst_stride, src + y * src_stride, s->x_offset * s->bpp);
1105
1880
        memcpy(dst + y * dst_stride + (s->x_offset + s->cur_w) * s->bpp,
1106
1880
               src + y * src_stride + (s->x_offset + s->cur_w) * s->bpp,
1107
1880
               (p->width - s->cur_w - s->x_offset) * s->bpp);
1108
    }
1109
2258
    for (y = s->y_offset + s->cur_h; y < p->height; y++)
1110
2218
        memcpy(dst + y * dst_stride, src + y * src_stride, p->width * s->bpp);
1111
1112
40
    if (s->blend_op == APNG_BLEND_OP_OVER) {
1113
        // Perform blending
1114
1918
        for (y = s->y_offset; y < s->y_offset + s->cur_h; ++y) {
1115
1879
            uint8_t       *foreground = dst + dst_stride * y + s->bpp * s->x_offset;
1116
1879
            const uint8_t *background = src + src_stride * y + s->bpp * s->x_offset;
1117
143095
            for (x = s->x_offset; x < s->x_offset + s->cur_w; ++x, foreground += s->bpp, background += s->bpp) {
1118
                size_t b;
1119
                uint8_t foreground_alpha, background_alpha, output_alpha;
1120
                uint8_t output[10];
1121
1122
                // Since we might be blending alpha onto alpha, we use the following equations:
1123
                // output_alpha = foreground_alpha + (1 - foreground_alpha) * background_alpha
1124
                // output = (foreground_alpha * foreground + (1 - foreground_alpha) * background_alpha * background) / output_alpha
1125
1126

141216
                switch (avctx->pix_fmt) {
1127
                case AV_PIX_FMT_RGBA:
1128
                    foreground_alpha = foreground[3];
1129
                    background_alpha = background[3];
1130
                    break;
1131
1132
                case AV_PIX_FMT_GRAY8A:
1133
                    foreground_alpha = foreground[1];
1134
                    background_alpha = background[1];
1135
                    break;
1136
1137
141216
                case AV_PIX_FMT_PAL8:
1138
141216
                    foreground_alpha = s->palette[foreground[0]] >> 24;
1139
141216
                    background_alpha = s->palette[background[0]] >> 24;
1140
141216
                    break;
1141
                }
1142
1143
141216
                if (foreground_alpha == 255)
1144
141216
                    continue;
1145
1146
121582
                if (foreground_alpha == 0) {
1147
121582
                    memcpy(foreground, background, s->bpp);
1148
121582
                    continue;
1149
                }
1150
1151
                if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1152
                    // TODO: Alpha blending with PAL8 will likely need the entire image converted over to RGBA first
1153
                    avpriv_request_sample(avctx, "Alpha blending palette samples");
1154
                    continue;
1155
                }
1156
1157
                output_alpha = foreground_alpha + FAST_DIV255((255 - foreground_alpha) * background_alpha);
1158
1159
                av_assert0(s->bpp <= 10);
1160
1161
                for (b = 0; b < s->bpp - 1; ++b) {
1162
                    if (output_alpha == 0) {
1163
                        output[b] = 0;
1164
                    } else if (background_alpha == 255) {
1165
                        output[b] = FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1166
                    } else {
1167
                        output[b] = (255 * foreground_alpha * foreground[b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1168
                    }
1169
                }
1170
                output[b] = output_alpha;
1171
                memcpy(foreground, output, s->bpp);
1172
            }
1173
        }
1174
    }
1175
1176
40
    return 0;
1177
}
1178
1179
605
static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
1180
                               AVFrame *p, const AVPacket *avpkt)
1181
{
1182
605
    const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1183
    uint32_t tag, length;
1184
605
    int decode_next_dat = 0;
1185
    int i, ret;
1186
1187
17200
    for (;;) {
1188
        GetByteContext gb_chunk;
1189
1190
17805
        length = bytestream2_get_bytes_left(&s->gb);
1191
17805
        if (length <= 0) {
1192
1193
300
            if (avctx->codec_id == AV_CODEC_ID_PNG &&
1194
53
                avctx->skip_frame == AVDISCARD_ALL) {
1195
64
                return 0;
1196
            }
1197
1198

247
            if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
1199
247
                if (!(s->pic_state & PNG_IDAT))
1200
11
                    return 0;
1201
                else
1202
540
                    goto exit_loop;
1203
            }
1204
            av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
1205
            if (   s->pic_state & PNG_ALLIMAGE
1206
                && avctx->strict_std_compliance <= FF_COMPLIANCE_NORMAL)
1207
                goto exit_loop;
1208
            ret = AVERROR_INVALIDDATA;
1209
1
            goto fail;
1210
        }
1211
1212
17505
        length = bytestream2_get_be32(&s->gb);
1213

17505
        if (length > 0x7fffffff || length + 8 > bytestream2_get_bytes_left(&s->gb)) {
1214
1
            av_log(avctx, AV_LOG_ERROR, "chunk too big\n");
1215
1
            ret = AVERROR_INVALIDDATA;
1216
1
            goto fail;
1217
        }
1218
17504
        if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_IGNORE_ERR)) {
1219
            uint32_t crc_sig = AV_RB32(s->gb.buffer + length + 4);
1220
            uint32_t crc_cal = ~av_crc(crc_tab, UINT32_MAX, s->gb.buffer, length + 4);
1221
            if (crc_sig ^ crc_cal) {
1222
                av_log(avctx, AV_LOG_ERROR, "CRC mismatch in chunk");
1223
                if (avctx->err_recognition & AV_EF_EXPLODE) {
1224
                    av_log(avctx, AV_LOG_ERROR, ", quitting\n");
1225
                    ret = AVERROR_INVALIDDATA;
1226
                    goto fail;
1227
                }
1228
                av_log(avctx, AV_LOG_ERROR, ", skipping\n");
1229
                bytestream2_skip(&s->gb, length + 8); /* tag */
1230
            }
1231
        }
1232
17504
        tag = bytestream2_get_le32(&s->gb);
1233
17504
        if (avctx->debug & FF_DEBUG_STARTCODE)
1234
            av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
1235
                   av_fourcc2str(tag), length);
1236
1237
17504
        bytestream2_init(&gb_chunk, s->gb.buffer, length);
1238
17504
        bytestream2_skip(&s->gb, length + 4);
1239
1240
17504
        if (avctx->codec_id == AV_CODEC_ID_PNG &&
1241
13823
            avctx->skip_frame == AVDISCARD_ALL) {
1242
1003
            switch(tag) {
1243
892
            case MKTAG('I', 'H', 'D', 'R'):
1244
            case MKTAG('p', 'H', 'Y', 's'):
1245
            case MKTAG('t', 'E', 'X', 't'):
1246
            case MKTAG('I', 'D', 'A', 'T'):
1247
            case MKTAG('t', 'R', 'N', 'S'):
1248
892
                break;
1249
111
            default:
1250
111
                continue;
1251
            }
1252
16501
        }
1253
1254



17393
        switch (tag) {
1255
369
        case MKTAG('I', 'H', 'D', 'R'):
1256
369
            if ((ret = decode_ihdr_chunk(avctx, s, &gb_chunk)) < 0)
1257
                goto fail;
1258
369
            break;
1259
341
        case MKTAG('p', 'H', 'Y', 's'):
1260
341
            if ((ret = decode_phys_chunk(avctx, s, &gb_chunk)) < 0)
1261
                goto fail;
1262
341
            break;
1263
236
        case MKTAG('f', 'c', 'T', 'L'):
1264
236
            if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1265
                continue;
1266
236
            if ((ret = decode_fctl_chunk(avctx, s, &gb_chunk)) < 0)
1267
                goto fail;
1268
236
            decode_next_dat = 1;
1269
236
            break;
1270
3099
        case MKTAG('f', 'd', 'A', 'T'):
1271
3099
            if (!CONFIG_APNG_DECODER || avctx->codec_id != AV_CODEC_ID_APNG)
1272
                continue;
1273

3099
            if (!decode_next_dat || bytestream2_get_bytes_left(&gb_chunk) < 4) {
1274
                ret = AVERROR_INVALIDDATA;
1275
                goto fail;
1276
            }
1277
3099
            bytestream2_get_be32(&gb_chunk);
1278
            /* fallthrough */
1279
15930
        case MKTAG('I', 'D', 'A', 'T'):
1280

15930
            if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && !decode_next_dat)
1281
                continue;
1282
15930
            if ((ret = decode_idat_chunk(avctx, s, &gb_chunk, p)) < 0)
1283
                goto fail;
1284
15930
            break;
1285
2
        case MKTAG('P', 'L', 'T', 'E'):
1286
2
            decode_plte_chunk(avctx, s, &gb_chunk);
1287
2
            break;
1288
6
        case MKTAG('t', 'R', 'N', 'S'):
1289
6
            decode_trns_chunk(avctx, s, &gb_chunk);
1290
6
            break;
1291
117
        case MKTAG('t', 'E', 'X', 't'):
1292
117
            if (decode_text_chunk(s, &gb_chunk, 0) < 0)
1293
                av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
1294
117
            break;
1295
        case MKTAG('z', 'T', 'X', 't'):
1296
            if (decode_text_chunk(s, &gb_chunk, 1) < 0)
1297
                av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
1298
            break;
1299
        case MKTAG('s', 'T', 'E', 'R'): {
1300
            int mode = bytestream2_get_byte(&gb_chunk);
1301
1302
            if (mode == 0 || mode == 1) {
1303
                s->stereo_mode = mode;
1304
            } else {
1305
                 av_log(avctx, AV_LOG_WARNING,
1306
                        "Unknown value in sTER chunk (%d)\n", mode);
1307
            }
1308
            break;
1309
        }
1310
2
        case MKTAG('i', 'C', 'C', 'P'): {
1311
2
            if ((ret = decode_iccp_chunk(s, &gb_chunk, p)) < 0)
1312
                goto fail;
1313
2
            break;
1314
        }
1315
2
        case MKTAG('c', 'H', 'R', 'M'): {
1316
2
            s->have_chrm = 1;
1317
1318
2
            s->white_point[0] = bytestream2_get_be32(&gb_chunk);
1319
2
            s->white_point[1] = bytestream2_get_be32(&gb_chunk);
1320
1321
            /* RGB Primaries */
1322
8
            for (i = 0; i < 3; i++) {
1323
6
                s->display_primaries[i][0] = bytestream2_get_be32(&gb_chunk);
1324
6
                s->display_primaries[i][1] = bytestream2_get_be32(&gb_chunk);
1325
            }
1326
1327
2
            break;
1328
        }
1329
14
        case MKTAG('g', 'A', 'M', 'A'): {
1330
            AVBPrint bp;
1331
            char *gamma_str;
1332
14
            int num = bytestream2_get_be32(&gb_chunk);
1333
1334
14
            av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
1335
14
            av_bprintf(&bp, "%i/%i", num, 100000);
1336
14
            ret = av_bprint_finalize(&bp, &gamma_str);
1337
14
            if (ret < 0)
1338
                return ret;
1339
1340
14
            av_dict_set(&s->frame_metadata, "gamma", gamma_str, AV_DICT_DONT_STRDUP_VAL);
1341
1342
14
            break;
1343
        }
1344
304
        case MKTAG('I', 'E', 'N', 'D'):
1345
304
            if (!(s->pic_state & PNG_ALLIMAGE))
1346
                av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
1347
304
            if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1348
                ret = AVERROR_INVALIDDATA;
1349
                goto fail;
1350
            }
1351
304
            goto exit_loop;
1352
        }
1353
17089
    }
1354
540
exit_loop:
1355
1356
540
    if (avctx->codec_id == AV_CODEC_ID_PNG &&
1357
304
        avctx->skip_frame == AVDISCARD_ALL) {
1358
        return 0;
1359
    }
1360
1361
540
    if (percent_missing(s) > avctx->discard_damaged_percentage)
1362
        return AVERROR_INVALIDDATA;
1363
1364
540
    if (s->bits_per_pixel <= 4)
1365
        handle_small_bpp(s, p);
1366
1367
    /* apply transparency if needed */
1368

540
    if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE) {
1369
136
        size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
1370
136
        size_t raw_bpp = s->bpp - byte_depth;
1371
        unsigned x, y;
1372
1373
136
        av_assert0(s->bit_depth > 1);
1374
1375
17746
        for (y = 0; y < s->height; ++y) {
1376
17610
            uint8_t *row = &p->data[0][p->linesize[0] * y];
1377
1378

17610
            if (s->bpp == 2 && byte_depth == 1) {
1379
                uint8_t *pixel = &row[2 * s->width - 1];
1380
                uint8_t *rowp  = &row[1 * s->width - 1];
1381
                int tcolor = s->transparent_color_be[0];
1382
                for (x = s->width; x > 0; --x) {
1383
                    *pixel-- = *rowp == tcolor ? 0 : 0xff;
1384
                    *pixel-- = *rowp--;
1385
                }
1386

35220
            } else if (s->bpp == 4 && byte_depth == 1) {
1387
17610
                uint8_t *pixel = &row[4 * s->width - 1];
1388
17610
                uint8_t *rowp  = &row[3 * s->width - 1];
1389
17610
                int tcolor = AV_RL24(s->transparent_color_be);
1390
1595310
                for (x = s->width; x > 0; --x) {
1391
1577700
                    *pixel-- = AV_RL24(rowp-2) == tcolor ? 0 : 0xff;
1392
1577700
                    *pixel-- = *rowp--;
1393
1577700
                    *pixel-- = *rowp--;
1394
1577700
                    *pixel-- = *rowp--;
1395
                }
1396
            } else {
1397
                /* since we're updating in-place, we have to go from right to left */
1398
                for (x = s->width; x > 0; --x) {
1399
                    uint8_t *pixel = &row[s->bpp * (x - 1)];
1400
                    memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1401
1402
                    if (!memcmp(pixel, s->transparent_color_be, raw_bpp)) {
1403
                        memset(&pixel[raw_bpp], 0, byte_depth);
1404
                    } else {
1405
                        memset(&pixel[raw_bpp], 0xff, byte_depth);
1406
                    }
1407
                }
1408
            }
1409
        }
1410
    }
1411
1412
    /* handle P-frames only if a predecessor frame is available */
1413
540
    if (s->last_picture.f->data[0]) {
1414

483
        if (   !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
1415
40
            && s->last_picture.f->width == p->width
1416
40
            && s->last_picture.f->height== p->height
1417
40
            && s->last_picture.f->format== p->format
1418
         ) {
1419
40
            if (CONFIG_PNG_DECODER && avctx->codec_id != AV_CODEC_ID_APNG)
1420
                handle_p_frame_png(s, p);
1421
40
            else if (CONFIG_APNG_DECODER &&
1422

80
                     avctx->codec_id == AV_CODEC_ID_APNG &&
1423
40
                     (ret = handle_p_frame_apng(avctx, s, p)) < 0)
1424
                goto fail;
1425
        }
1426
    }
1427
540
    ff_thread_report_progress(&s->picture, INT_MAX, 0);
1428
1429
540
    return 0;
1430
1431
1
fail:
1432
1
    ff_thread_report_progress(&s->picture, INT_MAX, 0);
1433
1
    return ret;
1434
}
1435
1436
594
static void clear_frame_metadata(PNGDecContext *s)
1437
{
1438
594
    av_freep(&s->iccp_data);
1439
594
    s->iccp_data_len = 0;
1440
594
    s->iccp_name[0]  = 0;
1441
1442
594
    s->stereo_mode = -1;
1443
1444
594
    s->have_chrm = 0;
1445
1446
594
    av_dict_free(&s->frame_metadata);
1447
594
}
1448
1449
540
static int output_frame(PNGDecContext *s, AVFrame *f,
1450
                        const AVFrame *src)
1451
{
1452
    int ret;
1453
1454
540
    ret = av_frame_ref(f, src);
1455
540
    if (ret < 0)
1456
        return ret;
1457
1458
540
    if (s->iccp_data) {
1459
2
        AVFrameSideData *sd = av_frame_new_side_data(f, AV_FRAME_DATA_ICC_PROFILE, s->iccp_data_len);
1460
2
        if (!sd) {
1461
            ret = AVERROR(ENOMEM);
1462
            goto fail;
1463
        }
1464
2
        memcpy(sd->data, s->iccp_data, s->iccp_data_len);
1465
1466
2
        av_dict_set(&sd->metadata, "name", s->iccp_name, 0);
1467
    }
1468
1469
540
    if (s->stereo_mode >= 0) {
1470
        AVStereo3D *stereo3d = av_stereo3d_create_side_data(f);
1471
        if (!stereo3d) {
1472
            ret = AVERROR(ENOMEM);
1473
            goto fail;
1474
        }
1475
1476
        stereo3d->type  = AV_STEREO3D_SIDEBYSIDE;
1477
        stereo3d->flags = s->stereo_mode ? 0 : AV_STEREO3D_FLAG_INVERT;
1478
    }
1479
1480
540
    if (s->have_chrm) {
1481
2
        AVMasteringDisplayMetadata *mdm = av_mastering_display_metadata_create_side_data(f);
1482
2
        if (!mdm) {
1483
            ret = AVERROR(ENOMEM);
1484
            goto fail;
1485
        }
1486
1487
2
        mdm->white_point[0] = av_make_q(s->white_point[0], 100000);
1488
2
        mdm->white_point[1] = av_make_q(s->white_point[1], 100000);
1489
1490
        /* RGB Primaries */
1491
8
        for (int i = 0; i < 3; i++) {
1492
6
            mdm->display_primaries[i][0] = av_make_q(s->display_primaries[i][0], 100000);
1493
6
            mdm->display_primaries[i][1] = av_make_q(s->display_primaries[i][1], 100000);
1494
        }
1495
1496
2
        mdm->has_primaries = 1;
1497
    }
1498
1499
540
    FFSWAP(AVDictionary*, f->metadata, s->frame_metadata);
1500
1501
540
    return 0;
1502
fail:
1503
    av_frame_unref(f);
1504
    return ret;
1505
}
1506
1507
#if CONFIG_PNG_DECODER
1508
358
static int decode_frame_png(AVCodecContext *avctx,
1509
                        void *data, int *got_frame,
1510
                        AVPacket *avpkt)
1511
{
1512
358
    PNGDecContext *const s = avctx->priv_data;
1513
358
    const uint8_t *buf     = avpkt->data;
1514
358
    int buf_size           = avpkt->size;
1515
358
    AVFrame     *dst_frame = data;
1516
358
    AVFrame *p = s->picture.f;
1517
    int64_t sig;
1518
    int ret;
1519
1520
358
    clear_frame_metadata(s);
1521
1522
358
    bytestream2_init(&s->gb, buf, buf_size);
1523
1524
    /* check signature */
1525
358
    sig = bytestream2_get_be64(&s->gb);
1526

358
    if (sig != PNGSIG &&
1527
        sig != MNGSIG) {
1528
        av_log(avctx, AV_LOG_ERROR, "Invalid PNG signature 0x%08"PRIX64".\n", sig);
1529
        return AVERROR_INVALIDDATA;
1530
    }
1531
1532
358
    s->y = s->has_trns = 0;
1533
358
    s->hdr_state = 0;
1534
358
    s->pic_state = 0;
1535
1536
    /* init the zlib */
1537
358
    s->zstream.zalloc = ff_png_zalloc;
1538
358
    s->zstream.zfree  = ff_png_zfree;
1539
358
    s->zstream.opaque = NULL;
1540
358
    ret = inflateInit(&s->zstream);
1541
358
    if (ret != Z_OK) {
1542
        av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1543
        return AVERROR_EXTERNAL;
1544
    }
1545
1546
358
    if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1547
1
        goto the_end;
1548
1549
357
    if (avctx->skip_frame == AVDISCARD_ALL) {
1550
53
        *got_frame = 0;
1551
53
        ret = bytestream2_tell(&s->gb);
1552
53
        goto the_end;
1553
    }
1554
1555
304
    ret = output_frame(s, dst_frame, s->picture.f);
1556
304
    if (ret < 0)
1557
        goto the_end;
1558
1559
304
    if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1560
300
        ff_thread_release_buffer(avctx, &s->last_picture);
1561
300
        FFSWAP(ThreadFrame, s->picture, s->last_picture);
1562
    }
1563
1564
304
    *got_frame = 1;
1565
1566
304
    ret = bytestream2_tell(&s->gb);
1567
358
the_end:
1568
358
    inflateEnd(&s->zstream);
1569
358
    s->crow_buf = NULL;
1570
358
    return ret;
1571
}
1572
#endif
1573
1574
#if CONFIG_APNG_DECODER
1575
236
static int decode_frame_apng(AVCodecContext *avctx,
1576
                        void *data, int *got_frame,
1577
                        AVPacket *avpkt)
1578
{
1579
236
    PNGDecContext *const s = avctx->priv_data;
1580
236
    AVFrame     *dst_frame = data;
1581
    int ret;
1582
236
    AVFrame *p = s->picture.f;
1583
1584
236
    clear_frame_metadata(s);
1585
1586
236
    if (!(s->hdr_state & PNG_IHDR)) {
1587
11
        if (!avctx->extradata_size)
1588
            return AVERROR_INVALIDDATA;
1589
1590
        /* only init fields, there is no zlib use in extradata */
1591
11
        s->zstream.zalloc = ff_png_zalloc;
1592
11
        s->zstream.zfree  = ff_png_zfree;
1593
1594
11
        bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
1595
11
        if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1596
            goto end;
1597
    }
1598
1599
    /* reset state for a new frame */
1600
236
    if ((ret = inflateInit(&s->zstream)) != Z_OK) {
1601
        av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
1602
        ret = AVERROR_EXTERNAL;
1603
        goto end;
1604
    }
1605
236
    s->y = 0;
1606
236
    s->pic_state = 0;
1607
236
    bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1608
236
    if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
1609
        goto end;
1610
1611
236
    if (!(s->pic_state & PNG_ALLIMAGE))
1612
        av_log(avctx, AV_LOG_WARNING, "Frame did not contain a complete image\n");
1613
236
    if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
1614
        ret = AVERROR_INVALIDDATA;
1615
        goto end;
1616
    }
1617
1618
236
    ret = output_frame(s, dst_frame, s->picture.f);
1619
236
    if (ret < 0)
1620
        goto end;
1621
1622
236
    if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
1623
236
        if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
1624
1
            ff_thread_release_buffer(avctx, &s->picture);
1625
235
        } else if (s->dispose_op == APNG_DISPOSE_OP_NONE) {
1626
235
            ff_thread_release_buffer(avctx, &s->last_picture);
1627
235
            FFSWAP(ThreadFrame, s->picture, s->last_picture);
1628
        }
1629
    }
1630
1631
236
    *got_frame = 1;
1632
236
    ret = bytestream2_tell(&s->gb);
1633
1634
236
end:
1635
236
    inflateEnd(&s->zstream);
1636
236
    return ret;
1637
}
1638
#endif
1639
1640
#if HAVE_THREADS
1641
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1642
{
1643
    PNGDecContext *psrc = src->priv_data;
1644
    PNGDecContext *pdst = dst->priv_data;
1645
    ThreadFrame *src_frame = NULL;
1646
    int ret;
1647
1648
    if (dst == src)
1649
        return 0;
1650
1651
    if (CONFIG_APNG_DECODER && dst->codec_id == AV_CODEC_ID_APNG) {
1652
1653
        pdst->width             = psrc->width;
1654
        pdst->height            = psrc->height;
1655
        pdst->bit_depth         = psrc->bit_depth;
1656
        pdst->color_type        = psrc->color_type;
1657
        pdst->compression_type  = psrc->compression_type;
1658
        pdst->interlace_type    = psrc->interlace_type;
1659
        pdst->filter_type       = psrc->filter_type;
1660
        pdst->cur_w = psrc->cur_w;
1661
        pdst->cur_h = psrc->cur_h;
1662
        pdst->x_offset = psrc->x_offset;
1663
        pdst->y_offset = psrc->y_offset;
1664
        pdst->has_trns = psrc->has_trns;
1665
        memcpy(pdst->transparent_color_be, psrc->transparent_color_be, sizeof(pdst->transparent_color_be));
1666
1667
        pdst->dispose_op = psrc->dispose_op;
1668
1669
        memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
1670
1671
        pdst->hdr_state |= psrc->hdr_state;
1672
    }
1673
1674
    src_frame = psrc->dispose_op == APNG_DISPOSE_OP_NONE ?
1675
                &psrc->picture : &psrc->last_picture;
1676
1677
    ff_thread_release_buffer(dst, &pdst->last_picture);
1678
    if (src_frame && src_frame->f->data[0]) {
1679
        ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
1680
        if (ret < 0)
1681
            return ret;
1682
    }
1683
1684
    return 0;
1685
}
1686
#endif
1687
1688
145
static av_cold int png_dec_init(AVCodecContext *avctx)
1689
{
1690
145
    PNGDecContext *s = avctx->priv_data;
1691
1692
145
    avctx->color_range = AVCOL_RANGE_JPEG;
1693
1694
145
    s->avctx = avctx;
1695
145
    s->last_picture.f = av_frame_alloc();
1696
145
    s->picture.f = av_frame_alloc();
1697

145
    if (!s->last_picture.f || !s->picture.f) {
1698
        av_frame_free(&s->last_picture.f);
1699
        av_frame_free(&s->picture.f);
1700
        return AVERROR(ENOMEM);
1701
    }
1702
1703
145
    ff_pngdsp_init(&s->dsp);
1704
1705
145
    return 0;
1706
}
1707
1708
145
static av_cold int png_dec_end(AVCodecContext *avctx)
1709
{
1710
145
    PNGDecContext *s = avctx->priv_data;
1711
1712
145
    ff_thread_release_buffer(avctx, &s->last_picture);
1713
145
    av_frame_free(&s->last_picture.f);
1714
145
    ff_thread_release_buffer(avctx, &s->picture);
1715
145
    av_frame_free(&s->picture.f);
1716
145
    av_freep(&s->buffer);
1717
145
    s->buffer_size = 0;
1718
145
    av_freep(&s->last_row);
1719
145
    s->last_row_size = 0;
1720
145
    av_freep(&s->tmp_row);
1721
145
    s->tmp_row_size = 0;
1722
145
    av_freep(&s->background_buf);
1723
1724
145
    av_freep(&s->iccp_data);
1725
145
    av_dict_free(&s->frame_metadata);
1726
1727
145
    return 0;
1728
}
1729
1730
#if CONFIG_APNG_DECODER
1731
AVCodec ff_apng_decoder = {
1732
    .name           = "apng",
1733
    .long_name      = NULL_IF_CONFIG_SMALL("APNG (Animated Portable Network Graphics) image"),
1734
    .type           = AVMEDIA_TYPE_VIDEO,
1735
    .id             = AV_CODEC_ID_APNG,
1736
    .priv_data_size = sizeof(PNGDecContext),
1737
    .init           = png_dec_init,
1738
    .close          = png_dec_end,
1739
    .decode         = decode_frame_apng,
1740
    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1741
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1742
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
1743
                      FF_CODEC_CAP_ALLOCATE_PROGRESS,
1744
};
1745
#endif
1746
1747
#if CONFIG_PNG_DECODER
1748
AVCodec ff_png_decoder = {
1749
    .name           = "png",
1750
    .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
1751
    .type           = AVMEDIA_TYPE_VIDEO,
1752
    .id             = AV_CODEC_ID_PNG,
1753
    .priv_data_size = sizeof(PNGDecContext),
1754
    .init           = png_dec_init,
1755
    .close          = png_dec_end,
1756
    .decode         = decode_frame_png,
1757
    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1758
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
1759
    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_INIT_THREADSAFE |
1760
                      FF_CODEC_CAP_ALLOCATE_PROGRESS,
1761
};
1762
#endif