| 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/bprint.h" |
| 25 | #include "libavutil/imgutils.h" |
| 26 | #include "avcodec.h" |
| 27 | #include "bytestream.h" |
| 28 | #include "internal.h" |
| 29 | #include "png.h" |
| 30 | #include "pngdsp.h" |
| 31 | #include "thread.h" |
| 32 | |
| 33 | #include <zlib.h> |
| 34 | |
| 35 | typedef struct PNGDecContext { |
| 36 | PNGDSPContext dsp; |
| 37 | AVCodecContext *avctx; |
| 38 | |
| 39 | GetByteContext gb; |
| 40 | ThreadFrame last_picture; |
| 41 | ThreadFrame picture; |
| 42 | |
| 43 | int state; |
| 44 | int width, height; |
| 45 | int bit_depth; |
| 46 | int color_type; |
| 47 | int compression_type; |
| 48 | int interlace_type; |
| 49 | int filter_type; |
| 50 | int channels; |
| 51 | int bits_per_pixel; |
| 52 | int bpp; |
| 53 | |
| 54 | uint8_t *image_buf; |
| 55 | int image_linesize; |
| 56 | uint32_t palette[256]; |
| 57 | uint8_t *crow_buf; |
| 58 | uint8_t *last_row; |
| 59 | unsigned int last_row_size; |
| 60 | uint8_t *tmp_row; |
| 61 | unsigned int tmp_row_size; |
| 62 | uint8_t *buffer; |
| 63 | int buffer_size; |
| 64 | int pass; |
| 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 */ |
| 68 | int y; |
| 69 | z_stream zstream; |
| 70 | } PNGDecContext; |
| 71 | |
| 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, |
| 75 | }; |
| 76 | |
| 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, |
| 80 | }; |
| 81 | |
| 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 |
| 85 | }; |
| 86 | |
| 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 |
| 89 | * this stage */ |
| 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) |
| 93 | { |
| 94 | int x, mask, dsp_mask, j, src_x, b, bpp; |
| 95 | uint8_t *d; |
| 96 | const uint8_t *s; |
| 97 | |
| 98 | mask = png_pass_mask[pass]; |
| 99 | dsp_mask = png_pass_dsp_mask[pass]; |
| 100 | |
| 101 | switch (bits_per_pixel) { |
| 102 | case 1: |
| 103 | src_x = 0; |
| 104 | for (x = 0; x < width; x++) { |
| 105 | j = (x & 7); |
| 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); |
| 110 | } |
| 111 | if ((mask << j) & 0x80) |
| 112 | src_x++; |
| 113 | } |
| 114 | break; |
| 115 | case 2: |
| 116 | src_x = 0; |
| 117 | for (x = 0; x < width; x++) { |
| 118 | int j2 = 2 * (x & 3); |
| 119 | j = (x & 7); |
| 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); |
| 124 | } |
| 125 | if ((mask << j) & 0x80) |
| 126 | src_x++; |
| 127 | } |
| 128 | break; |
| 129 | case 4: |
| 130 | src_x = 0; |
| 131 | for (x = 0; x < width; x++) { |
| 132 | int j2 = 4*(x&1); |
| 133 | j = (x & 7); |
| 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); |
| 138 | } |
| 139 | if ((mask << j) & 0x80) |
| 140 | src_x++; |
| 141 | } |
| 142 | break; |
| 143 | default: |
| 144 | bpp = bits_per_pixel >> 3; |
| 145 | d = dst; |
| 146 | s = src; |
| 147 | for (x = 0; x < width; x++) { |
| 148 | j = x & 7; |
| 149 | if ((dsp_mask << j) & 0x80) { |
| 150 | memcpy(d, s, bpp); |
| 151 | } |
| 152 | d += bpp; |
| 153 | if ((mask << j) & 0x80) |
| 154 | s += bpp; |
| 155 | } |
| 156 | break; |
| 157 | } |
| 158 | } |
| 159 | |
| 160 | void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, |
| 161 | int w, int bpp) |
| 162 | { |
| 163 | int i; |
| 164 | for (i = 0; i < w; i++) { |
| 165 | int a, b, c, p, pa, pb, pc; |
| 166 | |
| 167 | a = dst[i - bpp]; |
| 168 | b = top[i]; |
| 169 | c = top[i - bpp]; |
| 170 | |
| 171 | p = b - c; |
| 172 | pc = a - c; |
| 173 | |
| 174 | pa = abs(p); |
| 175 | pb = abs(pc); |
| 176 | pc = abs(p + pc); |
| 177 | |
| 178 | if (pa <= pb && pa <= pc) |
| 179 | p = a; |
| 180 | else if (pb <= pc) |
| 181 | p = b; |
| 182 | else |
| 183 | p = c; |
| 184 | dst[i] = p + src[i]; |
| 185 | } |
| 186 | } |
| 187 | |
| 188 | #define UNROLL1(bpp, op) \ |
| 189 | { \ |
| 190 | r = dst[0]; \ |
| 191 | if (bpp >= 2) \ |
| 192 | g = dst[1]; \ |
| 193 | if (bpp >= 3) \ |
| 194 | b = dst[2]; \ |
| 195 | if (bpp >= 4) \ |
| 196 | a = dst[3]; \ |
| 197 | for (; i <= size - bpp; i += bpp) { \ |
| 198 | dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \ |
| 199 | if (bpp == 1) \ |
| 200 | continue; \ |
| 201 | dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \ |
| 202 | if (bpp == 2) \ |
| 203 | continue; \ |
| 204 | dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \ |
| 205 | if (bpp == 3) \ |
| 206 | continue; \ |
| 207 | dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \ |
| 208 | } \ |
| 209 | } |
| 210 | |
| 211 | #define UNROLL_FILTER(op) \ |
| 212 | if (bpp == 1) { \ |
| 213 | UNROLL1(1, op) \ |
| 214 | } else if (bpp == 2) { \ |
| 215 | UNROLL1(2, op) \ |
| 216 | } else if (bpp == 3) { \ |
| 217 | UNROLL1(3, op) \ |
| 218 | } else if (bpp == 4) { \ |
| 219 | UNROLL1(4, op) \ |
| 220 | } \ |
| 221 | for (; i < size; i++) { \ |
| 222 | dst[i] = op(dst[i - bpp], src[i], last[i]); \ |
| 223 | } |
| 224 | |
| 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) |
| 228 | { |
| 229 | int i, p, r, g, b, a; |
| 230 | |
| 231 | switch (filter_type) { |
| 232 | case PNG_FILTER_VALUE_NONE: |
| 233 | memcpy(dst, src, size); |
| 234 | break; |
| 235 | case PNG_FILTER_VALUE_SUB: |
| 236 | for (i = 0; i < bpp; i++) |
| 237 | dst[i] = src[i]; |
| 238 | if (bpp == 4) { |
| 239 | p = *(int *)dst; |
| 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; |
| 244 | } |
| 245 | } else { |
| 246 | #define OP_SUB(x, s, l) ((x) + (s)) |
| 247 | UNROLL_FILTER(OP_SUB); |
| 248 | } |
| 249 | break; |
| 250 | case PNG_FILTER_VALUE_UP: |
| 251 | dsp->add_bytes_l2(dst, src, last, size); |
| 252 | break; |
| 253 | case PNG_FILTER_VALUE_AVG: |
| 254 | for (i = 0; i < bpp; i++) { |
| 255 | p = (last[i] >> 1); |
| 256 | dst[i] = p + src[i]; |
| 257 | } |
| 258 | #define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff) |
| 259 | UNROLL_FILTER(OP_AVG); |
| 260 | break; |
| 261 | case PNG_FILTER_VALUE_PAETH: |
| 262 | for (i = 0; i < bpp; i++) { |
| 263 | p = last[i]; |
| 264 | dst[i] = p + src[i]; |
| 265 | } |
| 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); |
| 271 | i = w; |
| 272 | } |
| 273 | ff_add_png_paeth_prediction(dst + i, src + i, last + i, size - i, bpp); |
| 274 | break; |
| 275 | } |
| 276 | } |
| 277 | |
| 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) \ |
| 282 | { \ |
| 283 | int i; \ |
| 284 | for (i = 0; i < size; i += 3 + alpha) { \ |
| 285 | int g = dst [i + 1]; \ |
| 286 | dst[i + 0] += g; \ |
| 287 | dst[i + 2] += g; \ |
| 288 | } \ |
| 289 | } |
| 290 | |
| 291 | YUV2RGB(rgb8, uint8_t) |
| 292 | YUV2RGB(rgb16, uint16_t) |
| 293 | |
| 294 | /* process exactly one decompressed row */ |
| 295 | static void png_handle_row(PNGDecContext *s) |
| 296 | { |
| 297 | uint8_t *ptr, *last_row; |
| 298 | int got_line; |
| 299 | |
| 300 | if (!s->interlace_type) { |
| 301 | ptr = s->image_buf + s->image_linesize * s->y; |
| 302 | if (s->y == 0) |
| 303 | last_row = s->last_row; |
| 304 | else |
| 305 | last_row = ptr - s->image_linesize; |
| 306 | |
| 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); |
| 314 | } else { |
| 315 | deloco_rgb8(ptr - s->image_linesize, s->row_size, |
| 316 | s->color_type == PNG_COLOR_TYPE_RGB_ALPHA); |
| 317 | } |
| 318 | } |
| 319 | s->y++; |
| 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); |
| 326 | } else { |
| 327 | deloco_rgb8(ptr, s->row_size, |
| 328 | s->color_type == PNG_COLOR_TYPE_RGB_ALPHA); |
| 329 | } |
| 330 | } |
| 331 | } |
| 332 | } else { |
| 333 | got_line = 0; |
| 334 | for (;;) { |
| 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 */ |
| 339 | if (got_line) |
| 340 | break; |
| 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); |
| 345 | got_line = 1; |
| 346 | } |
| 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); |
| 350 | } |
| 351 | s->y++; |
| 352 | if (s->y == s->height) { |
| 353 | memset(s->last_row, 0, s->row_size); |
| 354 | for (;;) { |
| 355 | if (s->pass == NB_PASSES - 1) { |
| 356 | s->state |= PNG_ALLIMAGE; |
| 357 | goto the_end; |
| 358 | } else { |
| 359 | s->pass++; |
| 360 | s->y = 0; |
| 361 | s->pass_row_size = ff_png_pass_row_size(s->pass, |
| 362 | s->bits_per_pixel, |
| 363 | s->width); |
| 364 | s->crow_size = s->pass_row_size + 1; |
| 365 | if (s->pass_row_size != 0) |
| 366 | break; |
| 367 | /* skip pass if empty row */ |
| 368 | } |
| 369 | } |
| 370 | } |
| 371 | } |
| 372 | the_end:; |
| 373 | } |
| 374 | } |
| 375 | |
| 376 | static int png_decode_idat(PNGDecContext *s, int length) |
| 377 | { |
| 378 | int ret; |
| 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); |
| 382 | |
| 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; |
| 389 | } |
| 390 | if (s->zstream.avail_out == 0) { |
| 391 | if (!(s->state & PNG_ALLIMAGE)) { |
| 392 | png_handle_row(s); |
| 393 | } |
| 394 | s->zstream.avail_out = s->crow_size; |
| 395 | s->zstream.next_out = s->crow_buf; |
| 396 | } |
| 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); |
| 400 | return 0; |
| 401 | } |
| 402 | } |
| 403 | return 0; |
| 404 | } |
| 405 | |
| 406 | static int decode_zbuf(AVBPrint *bp, const uint8_t *data, |
| 407 | const uint8_t *data_end) |
| 408 | { |
| 409 | z_stream zstream; |
| 410 | unsigned char *buf; |
| 411 | unsigned buf_size; |
| 412 | int ret; |
| 413 | |
| 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); |
| 422 | |
| 423 | while (zstream.avail_in > 0) { |
| 424 | av_bprint_get_buffer(bp, 1, &buf, &buf_size); |
| 425 | if (!buf_size) { |
| 426 | ret = AVERROR(ENOMEM); |
| 427 | goto fail; |
| 428 | } |
| 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; |
| 434 | goto fail; |
| 435 | } |
| 436 | bp->len += zstream.next_out - buf; |
| 437 | if (ret == Z_STREAM_END) |
| 438 | break; |
| 439 | } |
| 440 | inflateEnd(&zstream); |
| 441 | bp->str[bp->len] = 0; |
| 442 | return 0; |
| 443 | |
| 444 | fail: |
| 445 | inflateEnd(&zstream); |
| 446 | av_bprint_finalize(bp, NULL); |
| 447 | return ret; |
| 448 | } |
| 449 | |
| 450 | static uint8_t *iso88591_to_utf8(const uint8_t *in, size_t size_in) |
| 451 | { |
| 452 | size_t extra = 0, i; |
| 453 | uint8_t *out, *q; |
| 454 | |
| 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) |
| 458 | return NULL; |
| 459 | q = out = av_malloc(size_in + extra + 1); |
| 460 | if (!out) |
| 461 | return NULL; |
| 462 | for (i = 0; i < size_in; i++) { |
| 463 | if (in[i] >= 0x80) { |
| 464 | *(q++) = 0xC0 | (in[i] >> 6); |
| 465 | *(q++) = 0x80 | (in[i] & 0x3F); |
| 466 | } else { |
| 467 | *(q++) = in[i]; |
| 468 | } |
| 469 | } |
| 470 | *(q++) = 0; |
| 471 | return out; |
| 472 | } |
| 473 | |
| 474 | static int decode_text_chunk(PNGDecContext *s, uint32_t length, int compressed, |
| 475 | AVDictionary **dict) |
| 476 | { |
| 477 | int ret, method; |
| 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; |
| 483 | unsigned text_len; |
| 484 | AVBPrint bp; |
| 485 | |
| 486 | if (!keyword_end) |
| 487 | return AVERROR_INVALIDDATA; |
| 488 | data = keyword_end + 1; |
| 489 | |
| 490 | if (compressed) { |
| 491 | if (data == data_end) |
| 492 | return AVERROR_INVALIDDATA; |
| 493 | method = *(data++); |
| 494 | if (method) |
| 495 | return AVERROR_INVALIDDATA; |
| 496 | if ((ret = decode_zbuf(&bp, data, data_end)) < 0) |
| 497 | return ret; |
| 498 | text_len = bp.len; |
| 499 | av_bprint_finalize(&bp, (char **)&text); |
| 500 | if (!text) |
| 501 | return AVERROR(ENOMEM); |
| 502 | } else { |
| 503 | text = (uint8_t *)data; |
| 504 | text_len = data_end - text; |
| 505 | } |
| 506 | |
| 507 | kw_utf8 = iso88591_to_utf8(keyword, keyword_end - keyword); |
| 508 | txt_utf8 = iso88591_to_utf8(text, text_len); |
| 509 | if (text != data) |
| 510 | av_free(text); |
| 511 | if (!(kw_utf8 && txt_utf8)) { |
| 512 | av_free(kw_utf8); |
| 513 | av_free(txt_utf8); |
| 514 | return AVERROR(ENOMEM); |
| 515 | } |
| 516 | |
| 517 | av_dict_set(dict, kw_utf8, txt_utf8, |
| 518 | AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); |
| 519 | return 0; |
| 520 | } |
| 521 | |
| 522 | static int decode_frame(AVCodecContext *avctx, |
| 523 | void *data, int *got_frame, |
| 524 | AVPacket *avpkt) |
| 525 | { |
| 526 | PNGDecContext *const s = avctx->priv_data; |
| 527 | const uint8_t *buf = avpkt->data; |
| 528 | int buf_size = avpkt->size; |
| 529 | AVFrame *p; |
| 530 | AVDictionary *metadata = NULL; |
| 531 | uint32_t tag, length; |
| 532 | int64_t sig; |
| 533 | int ret; |
| 534 | |
| 535 | ff_thread_release_buffer(avctx, &s->last_picture); |
| 536 | FFSWAP(ThreadFrame, s->picture, s->last_picture); |
| 537 | p = s->picture.f; |
| 538 | |
| 539 | bytestream2_init(&s->gb, buf, buf_size); |
| 540 | |
| 541 | /* check signature */ |
| 542 | sig = bytestream2_get_be64(&s->gb); |
| 543 | if (sig != PNGSIG && |
| 544 | sig != MNGSIG) { |
| 545 | av_log(avctx, AV_LOG_ERROR, "Missing png signature\n"); |
| 546 | return AVERROR_INVALIDDATA; |
| 547 | } |
| 548 | |
| 549 | s->y = s->state = 0; |
| 550 | |
| 551 | /* init the zlib */ |
| 552 | s->zstream.zalloc = ff_png_zalloc; |
| 553 | s->zstream.zfree = ff_png_zfree; |
| 554 | s->zstream.opaque = NULL; |
| 555 | ret = inflateInit(&s->zstream); |
| 556 | if (ret != Z_OK) { |
| 557 | av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret); |
| 558 | return AVERROR_EXTERNAL; |
| 559 | } |
| 560 | for (;;) { |
| 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) |
| 565 | goto exit_loop; |
| 566 | goto fail; |
| 567 | } |
| 568 | |
| 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"); |
| 572 | goto fail; |
| 573 | } |
| 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", |
| 577 | (tag & 0xff), |
| 578 | ((tag >> 8) & 0xff), |
| 579 | ((tag >> 16) & 0xff), |
| 580 | ((tag >> 24) & 0xff), length); |
| 581 | switch (tag) { |
| 582 | case MKTAG('I', 'H', 'D', 'R'): |
| 583 | if (length != 13) |
| 584 | goto fail; |
| 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"); |
| 590 | goto fail; |
| 591 | } |
| 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); |
| 604 | break; |
| 605 | case MKTAG('p', 'H', 'Y', 's'): |
| 606 | if (s->state & PNG_IDAT) { |
| 607 | av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n"); |
| 608 | goto fail; |
| 609 | } |
| 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 */ |
| 616 | break; |
| 617 | case MKTAG('I', 'D', 'A', 'T'): |
| 618 | if (!(s->state & PNG_IHDR)) { |
| 619 | av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n"); |
| 620 | goto fail; |
| 621 | } |
| 622 | if (!(s->state & PNG_IDAT)) { |
| 623 | /* init image info */ |
| 624 | avctx->width = s->width; |
| 625 | avctx->height = s->height; |
| 626 | |
| 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; |
| 631 | |
| 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; |
| 661 | } else { |
| 662 | av_log(avctx, AV_LOG_ERROR, "unsupported bit depth %d " |
| 663 | "and color type %d\n", |
| 664 | s->bit_depth, s->color_type); |
| 665 | goto fail; |
| 666 | } |
| 667 | |
| 668 | if (ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF) < 0) |
| 669 | goto fail; |
| 670 | ff_thread_finish_setup(avctx); |
| 671 | |
| 672 | p->pict_type = AV_PICTURE_TYPE_I; |
| 673 | p->key_frame = 1; |
| 674 | p->interlaced_frame = !!s->interlace_type; |
| 675 | |
| 676 | /* compute the compressed row size */ |
| 677 | if (!s->interlace_type) { |
| 678 | s->crow_size = s->row_size + 1; |
| 679 | } else { |
| 680 | s->pass = 0; |
| 681 | s->pass_row_size = ff_png_pass_row_size(s->pass, |
| 682 | s->bits_per_pixel, |
| 683 | s->width); |
| 684 | s->crow_size = s->pass_row_size + 1; |
| 685 | } |
| 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); |
| 695 | if (!s->last_row) |
| 696 | goto fail; |
| 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); |
| 700 | if (!s->tmp_row) |
| 701 | goto fail; |
| 702 | } |
| 703 | /* compressed row */ |
| 704 | av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16); |
| 705 | if (!s->buffer) |
| 706 | goto fail; |
| 707 | |
| 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; |
| 712 | } |
| 713 | s->state |= PNG_IDAT; |
| 714 | if (png_decode_idat(s, length) < 0) |
| 715 | goto fail; |
| 716 | bytestream2_skip(&s->gb, 4); /* crc */ |
| 717 | break; |
| 718 | case MKTAG('P', 'L', 'T', 'E'): |
| 719 | { |
| 720 | int n, i, r, g, b; |
| 721 | |
| 722 | if ((length % 3) != 0 || length > 256 * 3) |
| 723 | goto skip_tag; |
| 724 | /* read the palette */ |
| 725 | n = length / 3; |
| 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; |
| 731 | } |
| 732 | for (; i < 256; i++) |
| 733 | s->palette[i] = (0xFFU << 24); |
| 734 | s->state |= PNG_PLTE; |
| 735 | bytestream2_skip(&s->gb, 4); /* crc */ |
| 736 | } |
| 737 | break; |
| 738 | case MKTAG('t', 'R', 'N', 'S'): |
| 739 | { |
| 740 | int v, i; |
| 741 | |
| 742 | /* read the transparency. XXX: Only palette mode supported */ |
| 743 | if (s->color_type != PNG_COLOR_TYPE_PALETTE || |
| 744 | length > 256 || |
| 745 | !(s->state & PNG_PLTE)) |
| 746 | goto skip_tag; |
| 747 | for (i = 0; i < length; i++) { |
| 748 | v = bytestream2_get_byte(&s->gb); |
| 749 | s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24); |
| 750 | } |
| 751 | bytestream2_skip(&s->gb, 4); /* crc */ |
| 752 | } |
| 753 | break; |
| 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); |
| 758 | break; |
| 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); |
| 763 | break; |
| 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))) { |
| 768 | goto fail; |
| 769 | } |
| 770 | bytestream2_skip(&s->gb, 4); /* crc */ |
| 771 | goto exit_loop; |
| 772 | default: |
| 773 | /* skip tag */ |
| 774 | skip_tag: |
| 775 | bytestream2_skip(&s->gb, length + 4); |
| 776 | break; |
| 777 | } |
| 778 | } |
| 779 | exit_loop: |
| 780 | |
| 781 | if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE){ |
| 782 | int i, j, k; |
| 783 | uint8_t *pd = p->data[0]; |
| 784 | for (j = 0; j < s->height; j++) { |
| 785 | i = s->width / 8; |
| 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; |
| 798 | } |
| 799 | pd += s->image_linesize; |
| 800 | } |
| 801 | } |
| 802 | if (s->bits_per_pixel == 2){ |
| 803 | int i, j; |
| 804 | uint8_t *pd = p->data[0]; |
| 805 | for (j = 0; j < s->height; j++) { |
| 806 | i = s->width / 4; |
| 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; |
| 816 | } |
| 817 | } else { |
| 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; |
| 826 | } |
| 827 | } |
| 828 | pd += s->image_linesize; |
| 829 | } |
| 830 | } |
| 831 | if (s->bits_per_pixel == 4){ |
| 832 | int i, j; |
| 833 | uint8_t *pd = p->data[0]; |
| 834 | for (j = 0; j < s->height; j++) { |
| 835 | i = s->width/2; |
| 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; |
| 841 | } |
| 842 | } else { |
| 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; |
| 847 | } |
| 848 | } |
| 849 | pd += s->image_linesize; |
| 850 | } |
| 851 | } |
| 852 | |
| 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 |
| 859 | ) { |
| 860 | int i, j; |
| 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); |
| 864 | |
| 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++) |
| 868 | pd[i] += pd_last[i]; |
| 869 | pd += s->image_linesize; |
| 870 | pd_last += s->image_linesize; |
| 871 | } |
| 872 | } |
| 873 | } |
| 874 | ff_thread_report_progress(&s->picture, INT_MAX, 0); |
| 875 | |
| 876 | av_frame_set_metadata(p, metadata); |
| 877 | metadata = NULL; |
| 878 | |
| 879 | if ((ret = av_frame_ref(data, s->picture.f)) < 0) |
| 880 | return ret; |
| 881 | |
| 882 | *got_frame = 1; |
| 883 | |
| 884 | ret = bytestream2_tell(&s->gb); |
| 885 | the_end: |
| 886 | inflateEnd(&s->zstream); |
| 887 | s->crow_buf = NULL; |
| 888 | return ret; |
| 889 | fail: |
| 890 | av_dict_free(&metadata); |
| 891 | ff_thread_report_progress(&s->picture, INT_MAX, 0); |
| 892 | ret = AVERROR_INVALIDDATA; |
| 893 | goto the_end; |
| 894 | } |
| 895 | |
| 896 | static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) |
| 897 | { |
| 898 | PNGDecContext *psrc = src->priv_data; |
| 899 | PNGDecContext *pdst = dst->priv_data; |
| 900 | |
| 901 | if (dst == src) |
| 902 | return 0; |
| 903 | |
| 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); |
| 907 | |
| 908 | return 0; |
| 909 | } |
| 910 | |
| 911 | static av_cold int png_dec_init(AVCodecContext *avctx) |
| 912 | { |
| 913 | PNGDecContext *s = avctx->priv_data; |
| 914 | |
| 915 | s->avctx = avctx; |
| 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); |
| 920 | |
| 921 | if (!avctx->internal->is_copy) { |
| 922 | avctx->internal->allocate_progress = 1; |
| 923 | ff_pngdsp_init(&s->dsp); |
| 924 | } |
| 925 | |
| 926 | return 0; |
| 927 | } |
| 928 | |
| 929 | static av_cold int png_dec_end(AVCodecContext *avctx) |
| 930 | { |
| 931 | PNGDecContext *s = avctx->priv_data; |
| 932 | |
| 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); |
| 938 | s->buffer_size = 0; |
| 939 | av_freep(&s->last_row); |
| 940 | s->last_row_size = 0; |
| 941 | av_freep(&s->tmp_row); |
| 942 | s->tmp_row_size = 0; |
| 943 | |
| 944 | return 0; |
| 945 | } |
| 946 | |
| 947 | AVCodec ff_png_decoder = { |
| 948 | .name = "png", |
| 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*/, |
| 959 | }; |