1 2/* pngwutil.c - utilities to write a PNG file 3 * 4 * Last changed in libpng 1.6.32 [August 24, 2017] 5 * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson 6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 8 * 9 * This code is released under the libpng license. 10 * For conditions of distribution and use, see the disclaimer 11 * and license in png.h 12 */ 13 14#include "pngpriv.h" 15 16#ifdef PNG_WRITE_SUPPORTED 17 18#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED 19/* Place a 32-bit number into a buffer in PNG byte order. We work 20 * with unsigned numbers for convenience, although one supported 21 * ancillary chunk uses signed (two's complement) numbers. 22 */ 23void PNGAPI 24png_save_uint_32(png_bytep buf, png_uint_32 i) 25{ 26 buf[0] = (png_byte)((i >> 24) & 0xffU); 27 buf[1] = (png_byte)((i >> 16) & 0xffU); 28 buf[2] = (png_byte)((i >> 8) & 0xffU); 29 buf[3] = (png_byte)( i & 0xffU); 30} 31 32/* Place a 16-bit number into a buffer in PNG byte order. 33 * The parameter is declared unsigned int, not png_uint_16, 34 * just to avoid potential problems on pre-ANSI C compilers. 35 */ 36void PNGAPI 37png_save_uint_16(png_bytep buf, unsigned int i) 38{ 39 buf[0] = (png_byte)((i >> 8) & 0xffU); 40 buf[1] = (png_byte)( i & 0xffU); 41} 42#endif 43 44/* Simple function to write the signature. If we have already written 45 * the magic bytes of the signature, or more likely, the PNG stream is 46 * being embedded into another stream and doesn't need its own signature, 47 * we should call png_set_sig_bytes() to tell libpng how many of the 48 * bytes have already been written. 49 */ 50void PNGAPI 51png_write_sig(png_structrp png_ptr) 52{ 53 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; 54 55#ifdef PNG_IO_STATE_SUPPORTED 56 /* Inform the I/O callback that the signature is being written */ 57 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE; 58#endif 59 60 /* Write the rest of the 8 byte signature */ 61 png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], 62 (png_size_t)(8 - png_ptr->sig_bytes)); 63 64 if (png_ptr->sig_bytes < 3) 65 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; 66} 67 68/* Write the start of a PNG chunk. The type is the chunk type. 69 * The total_length is the sum of the lengths of all the data you will be 70 * passing in png_write_chunk_data(). 71 */ 72static void 73png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name, 74 png_uint_32 length) 75{ 76 png_byte buf[8]; 77 78#if defined(PNG_DEBUG) && (PNG_DEBUG > 0) 79 PNG_CSTRING_FROM_CHUNK(buf, chunk_name); 80 png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length); 81#endif 82 83 if (png_ptr == NULL) 84 return; 85 86#ifdef PNG_IO_STATE_SUPPORTED 87 /* Inform the I/O callback that the chunk header is being written. 88 * PNG_IO_CHUNK_HDR requires a single I/O call. 89 */ 90 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR; 91#endif 92 93 /* Write the length and the chunk name */ 94 png_save_uint_32(buf, length); 95 png_save_uint_32(buf + 4, chunk_name); 96 png_write_data(png_ptr, buf, 8); 97 98 /* Put the chunk name into png_ptr->chunk_name */ 99 png_ptr->chunk_name = chunk_name; 100 101 /* Reset the crc and run it over the chunk name */ 102 png_reset_crc(png_ptr); 103 104 png_calculate_crc(png_ptr, buf + 4, 4); 105 106#ifdef PNG_IO_STATE_SUPPORTED 107 /* Inform the I/O callback that chunk data will (possibly) be written. 108 * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls. 109 */ 110 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA; 111#endif 112} 113 114void PNGAPI 115png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string, 116 png_uint_32 length) 117{ 118 png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length); 119} 120 121/* Write the data of a PNG chunk started with png_write_chunk_header(). 122 * Note that multiple calls to this function are allowed, and that the 123 * sum of the lengths from these calls *must* add up to the total_length 124 * given to png_write_chunk_header(). 125 */ 126void PNGAPI 127png_write_chunk_data(png_structrp png_ptr, png_const_bytep data, 128 png_size_t length) 129{ 130 /* Write the data, and run the CRC over it */ 131 if (png_ptr == NULL) 132 return; 133 134 if (data != NULL && length > 0) 135 { 136 png_write_data(png_ptr, data, length); 137 138 /* Update the CRC after writing the data, 139 * in case the user I/O routine alters it. 140 */ 141 png_calculate_crc(png_ptr, data, length); 142 } 143} 144 145/* Finish a chunk started with png_write_chunk_header(). */ 146void PNGAPI 147png_write_chunk_end(png_structrp png_ptr) 148{ 149 png_byte buf[4]; 150 151 if (png_ptr == NULL) return; 152 153#ifdef PNG_IO_STATE_SUPPORTED 154 /* Inform the I/O callback that the chunk CRC is being written. 155 * PNG_IO_CHUNK_CRC requires a single I/O function call. 156 */ 157 png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC; 158#endif 159 160 /* Write the crc in a single operation */ 161 png_save_uint_32(buf, png_ptr->crc); 162 163 png_write_data(png_ptr, buf, (png_size_t)4); 164} 165 166/* Write a PNG chunk all at once. The type is an array of ASCII characters 167 * representing the chunk name. The array must be at least 4 bytes in 168 * length, and does not need to be null terminated. To be safe, pass the 169 * pre-defined chunk names here, and if you need a new one, define it 170 * where the others are defined. The length is the length of the data. 171 * All the data must be present. If that is not possible, use the 172 * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() 173 * functions instead. 174 */ 175static void 176png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name, 177 png_const_bytep data, png_size_t length) 178{ 179 if (png_ptr == NULL) 180 return; 181 182 /* On 64-bit architectures 'length' may not fit in a png_uint_32. */ 183 if (length > PNG_UINT_31_MAX) 184 png_error(png_ptr, "length exceeds PNG maximum"); 185 186 png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length); 187 png_write_chunk_data(png_ptr, data, length); 188 png_write_chunk_end(png_ptr); 189} 190 191/* This is the API that calls the internal function above. */ 192void PNGAPI 193png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string, 194 png_const_bytep data, png_size_t length) 195{ 196 png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data, 197 length); 198} 199 200/* This is used below to find the size of an image to pass to png_deflate_claim, 201 * so it only needs to be accurate if the size is less than 16384 bytes (the 202 * point at which a lower LZ window size can be used.) 203 */ 204static png_alloc_size_t 205png_image_size(png_structrp png_ptr) 206{ 207 /* Only return sizes up to the maximum of a png_uint_32; do this by limiting 208 * the width and height used to 15 bits. 209 */ 210 png_uint_32 h = png_ptr->height; 211 212 if (png_ptr->rowbytes < 32768 && h < 32768) 213 { 214 if (png_ptr->interlaced != 0) 215 { 216 /* Interlacing makes the image larger because of the replication of 217 * both the filter byte and the padding to a byte boundary. 218 */ 219 png_uint_32 w = png_ptr->width; 220 unsigned int pd = png_ptr->pixel_depth; 221 png_alloc_size_t cb_base; 222 int pass; 223 224 for (cb_base=0, pass=0; pass<=6; ++pass) 225 { 226 png_uint_32 pw = PNG_PASS_COLS(w, pass); 227 228 if (pw > 0) 229 cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass); 230 } 231 232 return cb_base; 233 } 234 235 else 236 return (png_ptr->rowbytes+1) * h; 237 } 238 239 else 240 return 0xffffffffU; 241} 242 243#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED 244 /* This is the code to hack the first two bytes of the deflate stream (the 245 * deflate header) to correct the windowBits value to match the actual data 246 * size. Note that the second argument is the *uncompressed* size but the 247 * first argument is the *compressed* data (and it must be deflate 248 * compressed.) 249 */ 250static void 251optimize_cmf(png_bytep data, png_alloc_size_t data_size) 252{ 253 /* Optimize the CMF field in the zlib stream. The resultant zlib stream is 254 * still compliant to the stream specification. 255 */ 256 if (data_size <= 16384) /* else windowBits must be 15 */ 257 { 258 unsigned int z_cmf = data[0]; /* zlib compression method and flags */ 259 260 if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) 261 { 262 unsigned int z_cinfo; 263 unsigned int half_z_window_size; 264 265 z_cinfo = z_cmf >> 4; 266 half_z_window_size = 1U << (z_cinfo + 7); 267 268 if (data_size <= half_z_window_size) /* else no change */ 269 { 270 unsigned int tmp; 271 272 do 273 { 274 half_z_window_size >>= 1; 275 --z_cinfo; 276 } 277 while (z_cinfo > 0 && data_size <= half_z_window_size); 278 279 z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); 280 281 data[0] = (png_byte)z_cmf; 282 tmp = data[1] & 0xe0; 283 tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; 284 data[1] = (png_byte)tmp; 285 } 286 } 287 } 288} 289#endif /* WRITE_OPTIMIZE_CMF */ 290 291/* Initialize the compressor for the appropriate type of compression. */ 292static int 293png_deflate_claim(png_structrp png_ptr, png_uint_32 owner, 294 png_alloc_size_t data_size) 295{ 296 if (png_ptr->zowner != 0) 297 { 298#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) 299 char msg[64]; 300 301 PNG_STRING_FROM_CHUNK(msg, owner); 302 msg[4] = ':'; 303 msg[5] = ' '; 304 PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner); 305 /* So the message that results is "<chunk> using zstream"; this is an 306 * internal error, but is very useful for debugging. i18n requirements 307 * are minimal. 308 */ 309 (void)png_safecat(msg, (sizeof msg), 10, " using zstream"); 310#endif 311#if PNG_RELEASE_BUILD 312 png_warning(png_ptr, msg); 313 314 /* Attempt sane error recovery */ 315 if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */ 316 { 317 png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT"); 318 return Z_STREAM_ERROR; 319 } 320 321 png_ptr->zowner = 0; 322#else 323 png_error(png_ptr, msg); 324#endif 325 } 326 327 { 328 int level = png_ptr->zlib_level; 329 int method = png_ptr->zlib_method; 330 int windowBits = png_ptr->zlib_window_bits; 331 int memLevel = png_ptr->zlib_mem_level; 332 int strategy; /* set below */ 333 int ret; /* zlib return code */ 334 335 if (owner == png_IDAT) 336 { 337 if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0) 338 strategy = png_ptr->zlib_strategy; 339 340 else if (png_ptr->do_filter != PNG_FILTER_NONE) 341 strategy = PNG_Z_DEFAULT_STRATEGY; 342 343 else 344 strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY; 345 } 346 347 else 348 { 349#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED 350 level = png_ptr->zlib_text_level; 351 method = png_ptr->zlib_text_method; 352 windowBits = png_ptr->zlib_text_window_bits; 353 memLevel = png_ptr->zlib_text_mem_level; 354 strategy = png_ptr->zlib_text_strategy; 355#else 356 /* If customization is not supported the values all come from the 357 * IDAT values except for the strategy, which is fixed to the 358 * default. (This is the pre-1.6.0 behavior too, although it was 359 * implemented in a very different way.) 360 */ 361 strategy = Z_DEFAULT_STRATEGY; 362#endif 363 } 364 365 /* Adjust 'windowBits' down if larger than 'data_size'; to stop this 366 * happening just pass 32768 as the data_size parameter. Notice that zlib 367 * requires an extra 262 bytes in the window in addition to the data to be 368 * able to see the whole of the data, so if data_size+262 takes us to the 369 * next windowBits size we need to fix up the value later. (Because even 370 * though deflate needs the extra window, inflate does not!) 371 */ 372 if (data_size <= 16384) 373 { 374 /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to 375 * work round a Microsoft Visual C misbehavior which, contrary to C-90, 376 * widens the result of the following shift to 64-bits if (and, 377 * apparently, only if) it is used in a test. 378 */ 379 unsigned int half_window_size = 1U << (windowBits-1); 380 381 while (data_size + 262 <= half_window_size) 382 { 383 half_window_size >>= 1; 384 --windowBits; 385 } 386 } 387 388 /* Check against the previous initialized values, if any. */ 389 if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 && 390 (png_ptr->zlib_set_level != level || 391 png_ptr->zlib_set_method != method || 392 png_ptr->zlib_set_window_bits != windowBits || 393 png_ptr->zlib_set_mem_level != memLevel || 394 png_ptr->zlib_set_strategy != strategy)) 395 { 396 if (deflateEnd(&png_ptr->zstream) != Z_OK) 397 png_warning(png_ptr, "deflateEnd failed (ignored)"); 398 399 png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED; 400 } 401 402 /* For safety clear out the input and output pointers (currently zlib 403 * doesn't use them on Init, but it might in the future). 404 */ 405 png_ptr->zstream.next_in = NULL; 406 png_ptr->zstream.avail_in = 0; 407 png_ptr->zstream.next_out = NULL; 408 png_ptr->zstream.avail_out = 0; 409 410 /* Now initialize if required, setting the new parameters, otherwise just 411 * do a simple reset to the previous parameters. 412 */ 413 if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0) 414 ret = deflateReset(&png_ptr->zstream); 415 416 else 417 { 418 ret = deflateInit2(&png_ptr->zstream, level, method, windowBits, 419 memLevel, strategy); 420 421 if (ret == Z_OK) 422 png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED; 423 } 424 425 /* The return code is from either deflateReset or deflateInit2; they have 426 * pretty much the same set of error codes. 427 */ 428 if (ret == Z_OK) 429 png_ptr->zowner = owner; 430 431 else 432 png_zstream_error(png_ptr, ret); 433 434 return ret; 435 } 436} 437 438/* Clean up (or trim) a linked list of compression buffers. */ 439void /* PRIVATE */ 440png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp) 441{ 442 png_compression_bufferp list = *listp; 443 444 if (list != NULL) 445 { 446 *listp = NULL; 447 448 do 449 { 450 png_compression_bufferp next = list->next; 451 452 png_free(png_ptr, list); 453 list = next; 454 } 455 while (list != NULL); 456 } 457} 458 459#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED 460/* This pair of functions encapsulates the operation of (a) compressing a 461 * text string, and (b) issuing it later as a series of chunk data writes. 462 * The compression_state structure is shared context for these functions 463 * set up by the caller to allow access to the relevant local variables. 464 * 465 * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size 466 * temporary buffers. From 1.6.0 it is retained in png_struct so that it will 467 * be correctly freed in the event of a write error (previous implementations 468 * just leaked memory.) 469 */ 470typedef struct 471{ 472 png_const_bytep input; /* The uncompressed input data */ 473 png_alloc_size_t input_len; /* Its length */ 474 png_uint_32 output_len; /* Final compressed length */ 475 png_byte output[1024]; /* First block of output */ 476} compression_state; 477 478static void 479png_text_compress_init(compression_state *comp, png_const_bytep input, 480 png_alloc_size_t input_len) 481{ 482 comp->input = input; 483 comp->input_len = input_len; 484 comp->output_len = 0; 485} 486 487/* Compress the data in the compression state input */ 488static int 489png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name, 490 compression_state *comp, png_uint_32 prefix_len) 491{ 492 int ret; 493 494 /* To find the length of the output it is necessary to first compress the 495 * input. The result is buffered rather than using the two-pass algorithm 496 * that is used on the inflate side; deflate is assumed to be slower and a 497 * PNG writer is assumed to have more memory available than a PNG reader. 498 * 499 * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an 500 * upper limit on the output size, but it is always bigger than the input 501 * size so it is likely to be more efficient to use this linked-list 502 * approach. 503 */ 504 ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len); 505 506 if (ret != Z_OK) 507 return ret; 508 509 /* Set up the compression buffers, we need a loop here to avoid overflowing a 510 * uInt. Use ZLIB_IO_MAX to limit the input. The output is always limited 511 * by the output buffer size, so there is no need to check that. Since this 512 * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits 513 * in size. 514 */ 515 { 516 png_compression_bufferp *end = &png_ptr->zbuffer_list; 517 png_alloc_size_t input_len = comp->input_len; /* may be zero! */ 518 png_uint_32 output_len; 519 520 /* zlib updates these for us: */ 521 png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input); 522 png_ptr->zstream.avail_in = 0; /* Set below */ 523 png_ptr->zstream.next_out = comp->output; 524 png_ptr->zstream.avail_out = (sizeof comp->output); 525 526 output_len = png_ptr->zstream.avail_out; 527 528 do 529 { 530 uInt avail_in = ZLIB_IO_MAX; 531 532 if (avail_in > input_len) 533 avail_in = (uInt)input_len; 534 535 input_len -= avail_in; 536 537 png_ptr->zstream.avail_in = avail_in; 538 539 if (png_ptr->zstream.avail_out == 0) 540 { 541 png_compression_buffer *next; 542 543 /* Chunk data is limited to 2^31 bytes in length, so the prefix 544 * length must be counted here. 545 */ 546 if (output_len + prefix_len > PNG_UINT_31_MAX) 547 { 548 ret = Z_MEM_ERROR; 549 break; 550 } 551 552 /* Need a new (malloc'ed) buffer, but there may be one present 553 * already. 554 */ 555 next = *end; 556 if (next == NULL) 557 { 558 next = png_voidcast(png_compression_bufferp, png_malloc_base 559 (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); 560 561 if (next == NULL) 562 { 563 ret = Z_MEM_ERROR; 564 break; 565 } 566 567 /* Link in this buffer (so that it will be freed later) */ 568 next->next = NULL; 569 *end = next; 570 } 571 572 png_ptr->zstream.next_out = next->output; 573 png_ptr->zstream.avail_out = png_ptr->zbuffer_size; 574 output_len += png_ptr->zstream.avail_out; 575 576 /* Move 'end' to the next buffer pointer. */ 577 end = &next->next; 578 } 579 580 /* Compress the data */ 581 ret = deflate(&png_ptr->zstream, 582 input_len > 0 ? Z_NO_FLUSH : Z_FINISH); 583 584 /* Claw back input data that was not consumed (because avail_in is 585 * reset above every time round the loop). 586 */ 587 input_len += png_ptr->zstream.avail_in; 588 png_ptr->zstream.avail_in = 0; /* safety */ 589 } 590 while (ret == Z_OK); 591 592 /* There may be some space left in the last output buffer. This needs to 593 * be subtracted from output_len. 594 */ 595 output_len -= png_ptr->zstream.avail_out; 596 png_ptr->zstream.avail_out = 0; /* safety */ 597 comp->output_len = output_len; 598 599 /* Now double check the output length, put in a custom message if it is 600 * too long. Otherwise ensure the z_stream::msg pointer is set to 601 * something. 602 */ 603 if (output_len + prefix_len >= PNG_UINT_31_MAX) 604 { 605 png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long"); 606 ret = Z_MEM_ERROR; 607 } 608 609 else 610 png_zstream_error(png_ptr, ret); 611 612 /* Reset zlib for another zTXt/iTXt or image data */ 613 png_ptr->zowner = 0; 614 615 /* The only success case is Z_STREAM_END, input_len must be 0; if not this 616 * is an internal error. 617 */ 618 if (ret == Z_STREAM_END && input_len == 0) 619 { 620#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED 621 /* Fix up the deflate header, if required */ 622 optimize_cmf(comp->output, comp->input_len); 623#endif 624 /* But Z_OK is returned, not Z_STREAM_END; this allows the claim 625 * function above to return Z_STREAM_END on an error (though it never 626 * does in the current versions of zlib.) 627 */ 628 return Z_OK; 629 } 630 631 else 632 return ret; 633 } 634} 635 636/* Ship the compressed text out via chunk writes */ 637static void 638png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp) 639{ 640 png_uint_32 output_len = comp->output_len; 641 png_const_bytep output = comp->output; 642 png_uint_32 avail = (sizeof comp->output); 643 png_compression_buffer *next = png_ptr->zbuffer_list; 644 645 for (;;) 646 { 647 if (avail > output_len) 648 avail = output_len; 649 650 png_write_chunk_data(png_ptr, output, avail); 651 652 output_len -= avail; 653 654 if (output_len == 0 || next == NULL) 655 break; 656 657 avail = png_ptr->zbuffer_size; 658 output = next->output; 659 next = next->next; 660 } 661 662 /* This is an internal error; 'next' must have been NULL! */ 663 if (output_len > 0) 664 png_error(png_ptr, "error writing ancillary chunked compressed data"); 665} 666#endif /* WRITE_COMPRESSED_TEXT */ 667 668/* Write the IHDR chunk, and update the png_struct with the necessary 669 * information. Note that the rest of this code depends upon this 670 * information being correct. 671 */ 672void /* PRIVATE */ 673png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height, 674 int bit_depth, int color_type, int compression_type, int filter_type, 675 int interlace_type) 676{ 677 png_byte buf[13]; /* Buffer to store the IHDR info */ 678 int is_invalid_depth; 679 680 png_debug(1, "in png_write_IHDR"); 681 682 /* Check that we have valid input data from the application info */ 683 switch (color_type) 684 { 685 case PNG_COLOR_TYPE_GRAY: 686 switch (bit_depth) 687 { 688 case 1: 689 case 2: 690 case 4: 691 case 8: 692#ifdef PNG_WRITE_16BIT_SUPPORTED 693 case 16: 694#endif 695 png_ptr->channels = 1; break; 696 697 default: 698 png_error(png_ptr, 699 "Invalid bit depth for grayscale image"); 700 } 701 break; 702 703 case PNG_COLOR_TYPE_RGB: 704 is_invalid_depth = (bit_depth != 8); 705#ifdef PNG_WRITE_16BIT_SUPPORTED 706 is_invalid_depth = (is_invalid_depth && bit_depth != 16); 707#endif 708 if (is_invalid_depth) 709 png_error(png_ptr, "Invalid bit depth for RGB image"); 710 711 png_ptr->channels = 3; 712 break; 713 714 case PNG_COLOR_TYPE_PALETTE: 715 switch (bit_depth) 716 { 717 case 1: 718 case 2: 719 case 4: 720 case 8: 721 png_ptr->channels = 1; 722 break; 723 724 default: 725 png_error(png_ptr, "Invalid bit depth for paletted image"); 726 } 727 break; 728 729 case PNG_COLOR_TYPE_GRAY_ALPHA: 730 is_invalid_depth = (bit_depth != 8); 731#ifdef PNG_WRITE_16BIT_SUPPORTED 732 is_invalid_depth = (is_invalid_depth && bit_depth != 16); 733#endif 734 if (is_invalid_depth) 735 png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); 736 737 png_ptr->channels = 2; 738 break; 739 740 case PNG_COLOR_TYPE_RGB_ALPHA: 741 is_invalid_depth = (bit_depth != 8); 742#ifdef PNG_WRITE_16BIT_SUPPORTED 743 is_invalid_depth = (is_invalid_depth && bit_depth != 16); 744#endif 745 if (is_invalid_depth) 746 png_error(png_ptr, "Invalid bit depth for RGBA image"); 747 748 png_ptr->channels = 4; 749 break; 750 751 default: 752 png_error(png_ptr, "Invalid image color type specified"); 753 } 754 755 if (compression_type != PNG_COMPRESSION_TYPE_BASE) 756 { 757 png_warning(png_ptr, "Invalid compression type specified"); 758 compression_type = PNG_COMPRESSION_TYPE_BASE; 759 } 760 761 /* Write filter_method 64 (intrapixel differencing) only if 762 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and 763 * 2. Libpng did not write a PNG signature (this filter_method is only 764 * used in PNG datastreams that are embedded in MNG datastreams) and 765 * 3. The application called png_permit_mng_features with a mask that 766 * included PNG_FLAG_MNG_FILTER_64 and 767 * 4. The filter_method is 64 and 768 * 5. The color_type is RGB or RGBA 769 */ 770 if ( 771#ifdef PNG_MNG_FEATURES_SUPPORTED 772 !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 && 773 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) && 774 (color_type == PNG_COLOR_TYPE_RGB || 775 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && 776 (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && 777#endif 778 filter_type != PNG_FILTER_TYPE_BASE) 779 { 780 png_warning(png_ptr, "Invalid filter type specified"); 781 filter_type = PNG_FILTER_TYPE_BASE; 782 } 783 784#ifdef PNG_WRITE_INTERLACING_SUPPORTED 785 if (interlace_type != PNG_INTERLACE_NONE && 786 interlace_type != PNG_INTERLACE_ADAM7) 787 { 788 png_warning(png_ptr, "Invalid interlace type specified"); 789 interlace_type = PNG_INTERLACE_ADAM7; 790 } 791#else 792 interlace_type=PNG_INTERLACE_NONE; 793#endif 794 795 /* Save the relevant information */ 796 png_ptr->bit_depth = (png_byte)bit_depth; 797 png_ptr->color_type = (png_byte)color_type; 798 png_ptr->interlaced = (png_byte)interlace_type; 799#ifdef PNG_MNG_FEATURES_SUPPORTED 800 png_ptr->filter_type = (png_byte)filter_type; 801#endif 802 png_ptr->compression_type = (png_byte)compression_type; 803 png_ptr->width = width; 804 png_ptr->height = height; 805 806 png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); 807 png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); 808 /* Set the usr info, so any transformations can modify it */ 809 png_ptr->usr_width = png_ptr->width; 810 png_ptr->usr_bit_depth = png_ptr->bit_depth; 811 png_ptr->usr_channels = png_ptr->channels; 812 813 /* Pack the header information into the buffer */ 814 png_save_uint_32(buf, width); 815 png_save_uint_32(buf + 4, height); 816 buf[8] = (png_byte)bit_depth; 817 buf[9] = (png_byte)color_type; 818 buf[10] = (png_byte)compression_type; 819 buf[11] = (png_byte)filter_type; 820 buf[12] = (png_byte)interlace_type; 821 822 /* Write the chunk */ 823 png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); 824 825 if ((png_ptr->do_filter) == PNG_NO_FILTERS) 826 { 827 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || 828 png_ptr->bit_depth < 8) 829 png_ptr->do_filter = PNG_FILTER_NONE; 830 831 else 832 png_ptr->do_filter = PNG_ALL_FILTERS; 833 } 834 835 png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */ 836} 837 838/* Write the palette. We are careful not to trust png_color to be in the 839 * correct order for PNG, so people can redefine it to any convenient 840 * structure. 841 */ 842void /* PRIVATE */ 843png_write_PLTE(png_structrp png_ptr, png_const_colorp palette, 844 png_uint_32 num_pal) 845{ 846 png_uint_32 max_palette_length, i; 847 png_const_colorp pal_ptr; 848 png_byte buf[3]; 849 850 png_debug(1, "in png_write_PLTE"); 851 852 max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ? 853 (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH; 854 855 if (( 856#ifdef PNG_MNG_FEATURES_SUPPORTED 857 (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 && 858#endif 859 num_pal == 0) || num_pal > max_palette_length) 860 { 861 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 862 { 863 png_error(png_ptr, "Invalid number of colors in palette"); 864 } 865 866 else 867 { 868 png_warning(png_ptr, "Invalid number of colors in palette"); 869 return; 870 } 871 } 872 873 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) 874 { 875 png_warning(png_ptr, 876 "Ignoring request to write a PLTE chunk in grayscale PNG"); 877 878 return; 879 } 880 881 png_ptr->num_palette = (png_uint_16)num_pal; 882 png_debug1(3, "num_palette = %d", png_ptr->num_palette); 883 884 png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3)); 885#ifdef PNG_POINTER_INDEXING_SUPPORTED 886 887 for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) 888 { 889 buf[0] = pal_ptr->red; 890 buf[1] = pal_ptr->green; 891 buf[2] = pal_ptr->blue; 892 png_write_chunk_data(png_ptr, buf, (png_size_t)3); 893 } 894 895#else 896 /* This is a little slower but some buggy compilers need to do this 897 * instead 898 */ 899 pal_ptr=palette; 900 901 for (i = 0; i < num_pal; i++) 902 { 903 buf[0] = pal_ptr[i].red; 904 buf[1] = pal_ptr[i].green; 905 buf[2] = pal_ptr[i].blue; 906 png_write_chunk_data(png_ptr, buf, (png_size_t)3); 907 } 908 909#endif 910 png_write_chunk_end(png_ptr); 911 png_ptr->mode |= PNG_HAVE_PLTE; 912} 913 914/* This is similar to png_text_compress, above, except that it does not require 915 * all of the data at once and, instead of buffering the compressed result, 916 * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out 917 * because it calls the write interface. As a result it does its own error 918 * reporting and does not return an error code. In the event of error it will 919 * just call png_error. The input data length may exceed 32-bits. The 'flush' 920 * parameter is exactly the same as that to deflate, with the following 921 * meanings: 922 * 923 * Z_NO_FLUSH: normal incremental output of compressed data 924 * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush 925 * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up 926 * 927 * The routine manages the acquire and release of the png_ptr->zstream by 928 * checking and (at the end) clearing png_ptr->zowner; it does some sanity 929 * checks on the 'mode' flags while doing this. 930 */ 931void /* PRIVATE */ 932png_compress_IDAT(png_structrp png_ptr, png_const_bytep input, 933 png_alloc_size_t input_len, int flush) 934{ 935 if (png_ptr->zowner != png_IDAT) 936 { 937 /* First time. Ensure we have a temporary buffer for compression and 938 * trim the buffer list if it has more than one entry to free memory. 939 * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been 940 * created at this point, but the check here is quick and safe. 941 */ 942 if (png_ptr->zbuffer_list == NULL) 943 { 944 png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp, 945 png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); 946 png_ptr->zbuffer_list->next = NULL; 947 } 948 949 else 950 png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next); 951 952 /* It is a terminal error if we can't claim the zstream. */ 953 if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK) 954 png_error(png_ptr, png_ptr->zstream.msg); 955 956 /* The output state is maintained in png_ptr->zstream, so it must be 957 * initialized here after the claim. 958 */ 959 png_ptr->zstream.next_out = png_ptr->zbuffer_list->output; 960 png_ptr->zstream.avail_out = png_ptr->zbuffer_size; 961 } 962 963 /* Now loop reading and writing until all the input is consumed or an error 964 * terminates the operation. The _out values are maintained across calls to 965 * this function, but the input must be reset each time. 966 */ 967 png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input); 968 png_ptr->zstream.avail_in = 0; /* set below */ 969 for (;;) 970 { 971 int ret; 972 973 /* INPUT: from the row data */ 974 uInt avail = ZLIB_IO_MAX; 975 976 if (avail > input_len) 977 avail = (uInt)input_len; /* safe because of the check */ 978 979 png_ptr->zstream.avail_in = avail; 980 input_len -= avail; 981 982 ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush); 983 984 /* Include as-yet unconsumed input */ 985 input_len += png_ptr->zstream.avail_in; 986 png_ptr->zstream.avail_in = 0; 987 988 /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note 989 * that these two zstream fields are preserved across the calls, therefore 990 * there is no need to set these up on entry to the loop. 991 */ 992 if (png_ptr->zstream.avail_out == 0) 993 { 994 png_bytep data = png_ptr->zbuffer_list->output; 995 uInt size = png_ptr->zbuffer_size; 996 997 /* Write an IDAT containing the data then reset the buffer. The 998 * first IDAT may need deflate header optimization. 999 */ 1000#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED 1001 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 && 1002 png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) 1003 optimize_cmf(data, png_image_size(png_ptr)); 1004#endif 1005 1006 if (size > 0) 1007 png_write_complete_chunk(png_ptr, png_IDAT, data, size); 1008 png_ptr->mode |= PNG_HAVE_IDAT; 1009 1010 png_ptr->zstream.next_out = data; 1011 png_ptr->zstream.avail_out = size; 1012 1013 /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with 1014 * the same flush parameter until it has finished output, for NO_FLUSH 1015 * it doesn't matter. 1016 */ 1017 if (ret == Z_OK && flush != Z_NO_FLUSH) 1018 continue; 1019 } 1020 1021 /* The order of these checks doesn't matter much; it just affects which 1022 * possible error might be detected if multiple things go wrong at once. 1023 */ 1024 if (ret == Z_OK) /* most likely return code! */ 1025 { 1026 /* If all the input has been consumed then just return. If Z_FINISH 1027 * was used as the flush parameter something has gone wrong if we get 1028 * here. 1029 */ 1030 if (input_len == 0) 1031 { 1032 if (flush == Z_FINISH) 1033 png_error(png_ptr, "Z_OK on Z_FINISH with output space"); 1034 1035 return; 1036 } 1037 } 1038 1039 else if (ret == Z_STREAM_END && flush == Z_FINISH) 1040 { 1041 /* This is the end of the IDAT data; any pending output must be 1042 * flushed. For small PNG files we may still be at the beginning. 1043 */ 1044 png_bytep data = png_ptr->zbuffer_list->output; 1045 uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out; 1046 1047#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED 1048 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 && 1049 png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) 1050 optimize_cmf(data, png_image_size(png_ptr)); 1051#endif 1052 1053 if (size > 0) 1054 png_write_complete_chunk(png_ptr, png_IDAT, data, size); 1055 png_ptr->zstream.avail_out = 0; 1056 png_ptr->zstream.next_out = NULL; 1057 png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT; 1058 1059 png_ptr->zowner = 0; /* Release the stream */ 1060 return; 1061 } 1062 1063 else 1064 { 1065 /* This is an error condition. */ 1066 png_zstream_error(png_ptr, ret); 1067 png_error(png_ptr, png_ptr->zstream.msg); 1068 } 1069 } 1070} 1071 1072/* Write an IEND chunk */ 1073void /* PRIVATE */ 1074png_write_IEND(png_structrp png_ptr) 1075{ 1076 png_debug(1, "in png_write_IEND"); 1077 1078 png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0); 1079 png_ptr->mode |= PNG_HAVE_IEND; 1080} 1081 1082#ifdef PNG_WRITE_gAMA_SUPPORTED 1083/* Write a gAMA chunk */ 1084void /* PRIVATE */ 1085png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma) 1086{ 1087 png_byte buf[4]; 1088 1089 png_debug(1, "in png_write_gAMA"); 1090 1091 /* file_gamma is saved in 1/100,000ths */ 1092 png_save_uint_32(buf, (png_uint_32)file_gamma); 1093 png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); 1094} 1095#endif 1096 1097#ifdef PNG_WRITE_sRGB_SUPPORTED 1098/* Write a sRGB chunk */ 1099void /* PRIVATE */ 1100png_write_sRGB(png_structrp png_ptr, int srgb_intent) 1101{ 1102 png_byte buf[1]; 1103 1104 png_debug(1, "in png_write_sRGB"); 1105 1106 if (srgb_intent >= PNG_sRGB_INTENT_LAST) 1107 png_warning(png_ptr, 1108 "Invalid sRGB rendering intent specified"); 1109 1110 buf[0]=(png_byte)srgb_intent; 1111 png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); 1112} 1113#endif 1114 1115#ifdef PNG_WRITE_iCCP_SUPPORTED 1116/* Write an iCCP chunk */ 1117void /* PRIVATE */ 1118png_write_iCCP(png_structrp png_ptr, png_const_charp name, 1119 png_const_bytep profile) 1120{ 1121 png_uint_32 name_len; 1122 png_uint_32 profile_len; 1123 png_byte new_name[81]; /* 1 byte for the compression byte */ 1124 compression_state comp; 1125 png_uint_32 temp; 1126 1127 png_debug(1, "in png_write_iCCP"); 1128 1129 /* These are all internal problems: the profile should have been checked 1130 * before when it was stored. 1131 */ 1132 if (profile == NULL) 1133 png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */ 1134 1135 profile_len = png_get_uint_32(profile); 1136 1137 if (profile_len < 132) 1138 png_error(png_ptr, "ICC profile too short"); 1139 1140 temp = (png_uint_32) (*(profile+8)); 1141 if (temp > 3 && (profile_len & 0x03)) 1142 png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)"); 1143 1144 { 1145 png_uint_32 embedded_profile_len = png_get_uint_32(profile); 1146 1147 if (profile_len != embedded_profile_len) 1148 png_error(png_ptr, "Profile length does not match profile"); 1149 } 1150 1151 name_len = png_check_keyword(png_ptr, name, new_name); 1152 1153 if (name_len == 0) 1154 png_error(png_ptr, "iCCP: invalid keyword"); 1155 1156 new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE; 1157 1158 /* Make sure we include the NULL after the name and the compression type */ 1159 ++name_len; 1160 1161 png_text_compress_init(&comp, profile, profile_len); 1162 1163 /* Allow for keyword terminator and compression byte */ 1164 if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK) 1165 png_error(png_ptr, png_ptr->zstream.msg); 1166 1167 png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len); 1168 1169 png_write_chunk_data(png_ptr, new_name, name_len); 1170 1171 png_write_compressed_data_out(png_ptr, &comp); 1172 1173 png_write_chunk_end(png_ptr); 1174} 1175#endif 1176 1177#ifdef PNG_WRITE_sPLT_SUPPORTED 1178/* Write a sPLT chunk */ 1179void /* PRIVATE */ 1180png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette) 1181{ 1182 png_uint_32 name_len; 1183 png_byte new_name[80]; 1184 png_byte entrybuf[10]; 1185 png_size_t entry_size = (spalette->depth == 8 ? 6 : 10); 1186 png_size_t palette_size = entry_size * (png_size_t)spalette->nentries; 1187 png_sPLT_entryp ep; 1188#ifndef PNG_POINTER_INDEXING_SUPPORTED 1189 int i; 1190#endif 1191 1192 png_debug(1, "in png_write_sPLT"); 1193 1194 name_len = png_check_keyword(png_ptr, spalette->name, new_name); 1195 1196 if (name_len == 0) 1197 png_error(png_ptr, "sPLT: invalid keyword"); 1198 1199 /* Make sure we include the NULL after the name */ 1200 png_write_chunk_header(png_ptr, png_sPLT, 1201 (png_uint_32)(name_len + 2 + palette_size)); 1202 1203 png_write_chunk_data(png_ptr, (png_bytep)new_name, 1204 (png_size_t)(name_len + 1)); 1205 1206 png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1); 1207 1208 /* Loop through each palette entry, writing appropriately */ 1209#ifdef PNG_POINTER_INDEXING_SUPPORTED 1210 for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++) 1211 { 1212 if (spalette->depth == 8) 1213 { 1214 entrybuf[0] = (png_byte)ep->red; 1215 entrybuf[1] = (png_byte)ep->green; 1216 entrybuf[2] = (png_byte)ep->blue; 1217 entrybuf[3] = (png_byte)ep->alpha; 1218 png_save_uint_16(entrybuf + 4, ep->frequency); 1219 } 1220 1221 else 1222 { 1223 png_save_uint_16(entrybuf + 0, ep->red); 1224 png_save_uint_16(entrybuf + 2, ep->green); 1225 png_save_uint_16(entrybuf + 4, ep->blue); 1226 png_save_uint_16(entrybuf + 6, ep->alpha); 1227 png_save_uint_16(entrybuf + 8, ep->frequency); 1228 } 1229 1230 png_write_chunk_data(png_ptr, entrybuf, entry_size); 1231 } 1232#else 1233 ep=spalette->entries; 1234 for (i = 0; i>spalette->nentries; i++) 1235 { 1236 if (spalette->depth == 8) 1237 { 1238 entrybuf[0] = (png_byte)ep[i].red; 1239 entrybuf[1] = (png_byte)ep[i].green; 1240 entrybuf[2] = (png_byte)ep[i].blue; 1241 entrybuf[3] = (png_byte)ep[i].alpha; 1242 png_save_uint_16(entrybuf + 4, ep[i].frequency); 1243 } 1244 1245 else 1246 { 1247 png_save_uint_16(entrybuf + 0, ep[i].red); 1248 png_save_uint_16(entrybuf + 2, ep[i].green); 1249 png_save_uint_16(entrybuf + 4, ep[i].blue); 1250 png_save_uint_16(entrybuf + 6, ep[i].alpha); 1251 png_save_uint_16(entrybuf + 8, ep[i].frequency); 1252 } 1253 1254 png_write_chunk_data(png_ptr, entrybuf, entry_size); 1255 } 1256#endif 1257 1258 png_write_chunk_end(png_ptr); 1259} 1260#endif 1261 1262#ifdef PNG_WRITE_sBIT_SUPPORTED 1263/* Write the sBIT chunk */ 1264void /* PRIVATE */ 1265png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type) 1266{ 1267 png_byte buf[4]; 1268 png_size_t size; 1269 1270 png_debug(1, "in png_write_sBIT"); 1271 1272 /* Make sure we don't depend upon the order of PNG_COLOR_8 */ 1273 if ((color_type & PNG_COLOR_MASK_COLOR) != 0) 1274 { 1275 png_byte maxbits; 1276 1277 maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : 1278 png_ptr->usr_bit_depth); 1279 1280 if (sbit->red == 0 || sbit->red > maxbits || 1281 sbit->green == 0 || sbit->green > maxbits || 1282 sbit->blue == 0 || sbit->blue > maxbits) 1283 { 1284 png_warning(png_ptr, "Invalid sBIT depth specified"); 1285 return; 1286 } 1287 1288 buf[0] = sbit->red; 1289 buf[1] = sbit->green; 1290 buf[2] = sbit->blue; 1291 size = 3; 1292 } 1293 1294 else 1295 { 1296 if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) 1297 { 1298 png_warning(png_ptr, "Invalid sBIT depth specified"); 1299 return; 1300 } 1301 1302 buf[0] = sbit->gray; 1303 size = 1; 1304 } 1305 1306 if ((color_type & PNG_COLOR_MASK_ALPHA) != 0) 1307 { 1308 if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) 1309 { 1310 png_warning(png_ptr, "Invalid sBIT depth specified"); 1311 return; 1312 } 1313 1314 buf[size++] = sbit->alpha; 1315 } 1316 1317 png_write_complete_chunk(png_ptr, png_sBIT, buf, size); 1318} 1319#endif 1320 1321#ifdef PNG_WRITE_cHRM_SUPPORTED 1322/* Write the cHRM chunk */ 1323void /* PRIVATE */ 1324png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy) 1325{ 1326 png_byte buf[32]; 1327 1328 png_debug(1, "in png_write_cHRM"); 1329 1330 /* Each value is saved in 1/100,000ths */ 1331 png_save_int_32(buf, xy->whitex); 1332 png_save_int_32(buf + 4, xy->whitey); 1333 1334 png_save_int_32(buf + 8, xy->redx); 1335 png_save_int_32(buf + 12, xy->redy); 1336 1337 png_save_int_32(buf + 16, xy->greenx); 1338 png_save_int_32(buf + 20, xy->greeny); 1339 1340 png_save_int_32(buf + 24, xy->bluex); 1341 png_save_int_32(buf + 28, xy->bluey); 1342 1343 png_write_complete_chunk(png_ptr, png_cHRM, buf, 32); 1344} 1345#endif 1346 1347#ifdef PNG_WRITE_tRNS_SUPPORTED 1348/* Write the tRNS chunk */ 1349void /* PRIVATE */ 1350png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha, 1351 png_const_color_16p tran, int num_trans, int color_type) 1352{ 1353 png_byte buf[6]; 1354 1355 png_debug(1, "in png_write_tRNS"); 1356 1357 if (color_type == PNG_COLOR_TYPE_PALETTE) 1358 { 1359 if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) 1360 { 1361 png_app_warning(png_ptr, 1362 "Invalid number of transparent colors specified"); 1363 return; 1364 } 1365 1366 /* Write the chunk out as it is */ 1367 png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha, 1368 (png_size_t)num_trans); 1369 } 1370 1371 else if (color_type == PNG_COLOR_TYPE_GRAY) 1372 { 1373 /* One 16-bit value */ 1374 if (tran->gray >= (1 << png_ptr->bit_depth)) 1375 { 1376 png_app_warning(png_ptr, 1377 "Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); 1378 1379 return; 1380 } 1381 1382 png_save_uint_16(buf, tran->gray); 1383 png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2); 1384 } 1385 1386 else if (color_type == PNG_COLOR_TYPE_RGB) 1387 { 1388 /* Three 16-bit values */ 1389 png_save_uint_16(buf, tran->red); 1390 png_save_uint_16(buf + 2, tran->green); 1391 png_save_uint_16(buf + 4, tran->blue); 1392#ifdef PNG_WRITE_16BIT_SUPPORTED 1393 if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0) 1394#else 1395 if ((buf[0] | buf[2] | buf[4]) != 0) 1396#endif 1397 { 1398 png_app_warning(png_ptr, 1399 "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); 1400 return; 1401 } 1402 1403 png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); 1404 } 1405 1406 else 1407 { 1408 png_app_warning(png_ptr, "Can't write tRNS with an alpha channel"); 1409 } 1410} 1411#endif 1412 1413#ifdef PNG_WRITE_bKGD_SUPPORTED 1414/* Write the background chunk */ 1415void /* PRIVATE */ 1416png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type) 1417{ 1418 png_byte buf[6]; 1419 1420 png_debug(1, "in png_write_bKGD"); 1421 1422 if (color_type == PNG_COLOR_TYPE_PALETTE) 1423 { 1424 if ( 1425#ifdef PNG_MNG_FEATURES_SUPPORTED 1426 (png_ptr->num_palette != 0 || 1427 (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) && 1428#endif 1429 back->index >= png_ptr->num_palette) 1430 { 1431 png_warning(png_ptr, "Invalid background palette index"); 1432 return; 1433 } 1434 1435 buf[0] = back->index; 1436 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1); 1437 } 1438 1439 else if ((color_type & PNG_COLOR_MASK_COLOR) != 0) 1440 { 1441 png_save_uint_16(buf, back->red); 1442 png_save_uint_16(buf + 2, back->green); 1443 png_save_uint_16(buf + 4, back->blue); 1444#ifdef PNG_WRITE_16BIT_SUPPORTED 1445 if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0) 1446#else 1447 if ((buf[0] | buf[2] | buf[4]) != 0) 1448#endif 1449 { 1450 png_warning(png_ptr, 1451 "Ignoring attempt to write 16-bit bKGD chunk " 1452 "when bit_depth is 8"); 1453 1454 return; 1455 } 1456 1457 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6); 1458 } 1459 1460 else 1461 { 1462 if (back->gray >= (1 << png_ptr->bit_depth)) 1463 { 1464 png_warning(png_ptr, 1465 "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); 1466 1467 return; 1468 } 1469 1470 png_save_uint_16(buf, back->gray); 1471 png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2); 1472 } 1473} 1474#endif 1475 1476#ifdef PNG_WRITE_eXIf_SUPPORTED 1477/* Write the Exif data */ 1478void /* PRIVATE */ 1479png_write_eXIf(png_structrp png_ptr, png_bytep exif, int num_exif) 1480{ 1481 int i; 1482 png_byte buf[1]; 1483 1484 png_debug(1, "in png_write_eXIf"); 1485 1486 png_write_chunk_header(png_ptr, png_eXIf, (png_uint_32)(num_exif)); 1487 1488 for (i = 0; i < num_exif; i++) 1489 { 1490 buf[0] = exif[i]; 1491 png_write_chunk_data(png_ptr, buf, (png_size_t)1); 1492 } 1493 1494 png_write_chunk_end(png_ptr); 1495} 1496#endif 1497 1498#ifdef PNG_WRITE_hIST_SUPPORTED 1499/* Write the histogram */ 1500void /* PRIVATE */ 1501png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist) 1502{ 1503 int i; 1504 png_byte buf[3]; 1505 1506 png_debug(1, "in png_write_hIST"); 1507 1508 if (num_hist > (int)png_ptr->num_palette) 1509 { 1510 png_debug2(3, "num_hist = %d, num_palette = %d", num_hist, 1511 png_ptr->num_palette); 1512 1513 png_warning(png_ptr, "Invalid number of histogram entries specified"); 1514 return; 1515 } 1516 1517 png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); 1518 1519 for (i = 0; i < num_hist; i++) 1520 { 1521 png_save_uint_16(buf, hist[i]); 1522 png_write_chunk_data(png_ptr, buf, (png_size_t)2); 1523 } 1524 1525 png_write_chunk_end(png_ptr); 1526} 1527#endif 1528 1529#ifdef PNG_WRITE_tEXt_SUPPORTED 1530/* Write a tEXt chunk */ 1531void /* PRIVATE */ 1532png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, 1533 png_size_t text_len) 1534{ 1535 png_uint_32 key_len; 1536 png_byte new_key[80]; 1537 1538 png_debug(1, "in png_write_tEXt"); 1539 1540 key_len = png_check_keyword(png_ptr, key, new_key); 1541 1542 if (key_len == 0) 1543 png_error(png_ptr, "tEXt: invalid keyword"); 1544 1545 if (text == NULL || *text == '\0') 1546 text_len = 0; 1547 1548 else 1549 text_len = strlen(text); 1550 1551 if (text_len > PNG_UINT_31_MAX - (key_len+1)) 1552 png_error(png_ptr, "tEXt: text too long"); 1553 1554 /* Make sure we include the 0 after the key */ 1555 png_write_chunk_header(png_ptr, png_tEXt, 1556 (png_uint_32)/*checked above*/(key_len + text_len + 1)); 1557 /* 1558 * We leave it to the application to meet PNG-1.0 requirements on the 1559 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of 1560 * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. 1561 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. 1562 */ 1563 png_write_chunk_data(png_ptr, new_key, key_len + 1); 1564 1565 if (text_len != 0) 1566 png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len); 1567 1568 png_write_chunk_end(png_ptr); 1569} 1570#endif 1571 1572#ifdef PNG_WRITE_zTXt_SUPPORTED 1573/* Write a compressed text chunk */ 1574void /* PRIVATE */ 1575png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, 1576 int compression) 1577{ 1578 png_uint_32 key_len; 1579 png_byte new_key[81]; 1580 compression_state comp; 1581 1582 png_debug(1, "in png_write_zTXt"); 1583 1584 if (compression == PNG_TEXT_COMPRESSION_NONE) 1585 { 1586 png_write_tEXt(png_ptr, key, text, 0); 1587 return; 1588 } 1589 1590 if (compression != PNG_TEXT_COMPRESSION_zTXt) 1591 png_error(png_ptr, "zTXt: invalid compression type"); 1592 1593 key_len = png_check_keyword(png_ptr, key, new_key); 1594 1595 if (key_len == 0) 1596 png_error(png_ptr, "zTXt: invalid keyword"); 1597 1598 /* Add the compression method and 1 for the keyword separator. */ 1599 new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE; 1600 ++key_len; 1601 1602 /* Compute the compressed data; do it now for the length */ 1603 png_text_compress_init(&comp, (png_const_bytep)text, 1604 text == NULL ? 0 : strlen(text)); 1605 1606 if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK) 1607 png_error(png_ptr, png_ptr->zstream.msg); 1608 1609 /* Write start of chunk */ 1610 png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len); 1611 1612 /* Write key */ 1613 png_write_chunk_data(png_ptr, new_key, key_len); 1614 1615 /* Write the compressed data */ 1616 png_write_compressed_data_out(png_ptr, &comp); 1617 1618 /* Close the chunk */ 1619 png_write_chunk_end(png_ptr); 1620} 1621#endif 1622 1623#ifdef PNG_WRITE_iTXt_SUPPORTED 1624/* Write an iTXt chunk */ 1625void /* PRIVATE */ 1626png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key, 1627 png_const_charp lang, png_const_charp lang_key, png_const_charp text) 1628{ 1629 png_uint_32 key_len, prefix_len; 1630 png_size_t lang_len, lang_key_len; 1631 png_byte new_key[82]; 1632 compression_state comp; 1633 1634 png_debug(1, "in png_write_iTXt"); 1635 1636 key_len = png_check_keyword(png_ptr, key, new_key); 1637 1638 if (key_len == 0) 1639 png_error(png_ptr, "iTXt: invalid keyword"); 1640 1641 /* Set the compression flag */ 1642 switch (compression) 1643 { 1644 case PNG_ITXT_COMPRESSION_NONE: 1645 case PNG_TEXT_COMPRESSION_NONE: 1646 compression = new_key[++key_len] = 0; /* no compression */ 1647 break; 1648 1649 case PNG_TEXT_COMPRESSION_zTXt: 1650 case PNG_ITXT_COMPRESSION_zTXt: 1651 compression = new_key[++key_len] = 1; /* compressed */ 1652 break; 1653 1654 default: 1655 png_error(png_ptr, "iTXt: invalid compression"); 1656 } 1657 1658 new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE; 1659 ++key_len; /* for the keywod separator */ 1660 1661 /* We leave it to the application to meet PNG-1.0 requirements on the 1662 * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of 1663 * any non-Latin-1 characters except for NEWLINE. ISO PNG, however, 1664 * specifies that the text is UTF-8 and this really doesn't require any 1665 * checking. 1666 * 1667 * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. 1668 * 1669 * TODO: validate the language tag correctly (see the spec.) 1670 */ 1671 if (lang == NULL) lang = ""; /* empty language is valid */ 1672 lang_len = strlen(lang)+1; 1673 if (lang_key == NULL) lang_key = ""; /* may be empty */ 1674 lang_key_len = strlen(lang_key)+1; 1675 if (text == NULL) text = ""; /* may be empty */ 1676 1677 prefix_len = key_len; 1678 if (lang_len > PNG_UINT_31_MAX-prefix_len) 1679 prefix_len = PNG_UINT_31_MAX; 1680 else 1681 prefix_len = (png_uint_32)(prefix_len + lang_len); 1682 1683 if (lang_key_len > PNG_UINT_31_MAX-prefix_len) 1684 prefix_len = PNG_UINT_31_MAX; 1685 else 1686 prefix_len = (png_uint_32)(prefix_len + lang_key_len); 1687 1688 png_text_compress_init(&comp, (png_const_bytep)text, strlen(text)); 1689 1690 if (compression != 0) 1691 { 1692 if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK) 1693 png_error(png_ptr, png_ptr->zstream.msg); 1694 } 1695 1696 else 1697 { 1698 if (comp.input_len > PNG_UINT_31_MAX-prefix_len) 1699 png_error(png_ptr, "iTXt: uncompressed text too long"); 1700 1701 /* So the string will fit in a chunk: */ 1702 comp.output_len = (png_uint_32)/*SAFE*/comp.input_len; 1703 } 1704 1705 png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len); 1706 1707 png_write_chunk_data(png_ptr, new_key, key_len); 1708 1709 png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len); 1710 1711 png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len); 1712 1713 if (compression != 0) 1714 png_write_compressed_data_out(png_ptr, &comp); 1715 1716 else 1717 png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.output_len); 1718 1719 png_write_chunk_end(png_ptr); 1720} 1721#endif 1722 1723#ifdef PNG_WRITE_oFFs_SUPPORTED 1724/* Write the oFFs chunk */ 1725void /* PRIVATE */ 1726png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset, 1727 int unit_type) 1728{ 1729 png_byte buf[9]; 1730 1731 png_debug(1, "in png_write_oFFs"); 1732 1733 if (unit_type >= PNG_OFFSET_LAST) 1734 png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); 1735 1736 png_save_int_32(buf, x_offset); 1737 png_save_int_32(buf + 4, y_offset); 1738 buf[8] = (png_byte)unit_type; 1739 1740 png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); 1741} 1742#endif 1743#ifdef PNG_WRITE_pCAL_SUPPORTED 1744/* Write the pCAL chunk (described in the PNG extensions document) */ 1745void /* PRIVATE */ 1746png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0, 1747 png_int_32 X1, int type, int nparams, png_const_charp units, 1748 png_charpp params) 1749{ 1750 png_uint_32 purpose_len; 1751 png_size_t units_len, total_len; 1752 png_size_tp params_len; 1753 png_byte buf[10]; 1754 png_byte new_purpose[80]; 1755 int i; 1756 1757 png_debug1(1, "in png_write_pCAL (%d parameters)", nparams); 1758 1759 if (type >= PNG_EQUATION_LAST) 1760 png_error(png_ptr, "Unrecognized equation type for pCAL chunk"); 1761 1762 purpose_len = png_check_keyword(png_ptr, purpose, new_purpose); 1763 1764 if (purpose_len == 0) 1765 png_error(png_ptr, "pCAL: invalid keyword"); 1766 1767 ++purpose_len; /* terminator */ 1768 1769 png_debug1(3, "pCAL purpose length = %d", (int)purpose_len); 1770 units_len = strlen(units) + (nparams == 0 ? 0 : 1); 1771 png_debug1(3, "pCAL units length = %d", (int)units_len); 1772 total_len = purpose_len + units_len + 10; 1773 1774 params_len = (png_size_tp)png_malloc(png_ptr, 1775 (png_alloc_size_t)((png_alloc_size_t)nparams * (sizeof (png_size_t)))); 1776 1777 /* Find the length of each parameter, making sure we don't count the 1778 * null terminator for the last parameter. 1779 */ 1780 for (i = 0; i < nparams; i++) 1781 { 1782 params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1); 1783 png_debug2(3, "pCAL parameter %d length = %lu", i, 1784 (unsigned long)params_len[i]); 1785 total_len += params_len[i]; 1786 } 1787 1788 png_debug1(3, "pCAL total length = %d", (int)total_len); 1789 png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len); 1790 png_write_chunk_data(png_ptr, new_purpose, purpose_len); 1791 png_save_int_32(buf, X0); 1792 png_save_int_32(buf + 4, X1); 1793 buf[8] = (png_byte)type; 1794 buf[9] = (png_byte)nparams; 1795 png_write_chunk_data(png_ptr, buf, (png_size_t)10); 1796 png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len); 1797 1798 for (i = 0; i < nparams; i++) 1799 { 1800 png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]); 1801 } 1802 1803 png_free(png_ptr, params_len); 1804 png_write_chunk_end(png_ptr); 1805} 1806#endif 1807 1808#ifdef PNG_WRITE_sCAL_SUPPORTED 1809/* Write the sCAL chunk */ 1810void /* PRIVATE */ 1811png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width, 1812 png_const_charp height) 1813{ 1814 png_byte buf[64]; 1815 png_size_t wlen, hlen, total_len; 1816 1817 png_debug(1, "in png_write_sCAL_s"); 1818 1819 wlen = strlen(width); 1820 hlen = strlen(height); 1821 total_len = wlen + hlen + 2; 1822 1823 if (total_len > 64) 1824 { 1825 png_warning(png_ptr, "Can't write sCAL (buffer too small)"); 1826 return; 1827 } 1828 1829 buf[0] = (png_byte)unit; 1830 memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ 1831 memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ 1832 1833 png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); 1834 png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len); 1835} 1836#endif 1837 1838#ifdef PNG_WRITE_pHYs_SUPPORTED 1839/* Write the pHYs chunk */ 1840void /* PRIVATE */ 1841png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit, 1842 png_uint_32 y_pixels_per_unit, 1843 int unit_type) 1844{ 1845 png_byte buf[9]; 1846 1847 png_debug(1, "in png_write_pHYs"); 1848 1849 if (unit_type >= PNG_RESOLUTION_LAST) 1850 png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); 1851 1852 png_save_uint_32(buf, x_pixels_per_unit); 1853 png_save_uint_32(buf + 4, y_pixels_per_unit); 1854 buf[8] = (png_byte)unit_type; 1855 1856 png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); 1857} 1858#endif 1859 1860#ifdef PNG_WRITE_tIME_SUPPORTED 1861/* Write the tIME chunk. Use either png_convert_from_struct_tm() 1862 * or png_convert_from_time_t(), or fill in the structure yourself. 1863 */ 1864void /* PRIVATE */ 1865png_write_tIME(png_structrp png_ptr, png_const_timep mod_time) 1866{ 1867 png_byte buf[7]; 1868 1869 png_debug(1, "in png_write_tIME"); 1870 1871 if (mod_time->month > 12 || mod_time->month < 1 || 1872 mod_time->day > 31 || mod_time->day < 1 || 1873 mod_time->hour > 23 || mod_time->second > 60) 1874 { 1875 png_warning(png_ptr, "Invalid time specified for tIME chunk"); 1876 return; 1877 } 1878 1879 png_save_uint_16(buf, mod_time->year); 1880 buf[2] = mod_time->month; 1881 buf[3] = mod_time->day; 1882 buf[4] = mod_time->hour; 1883 buf[5] = mod_time->minute; 1884 buf[6] = mod_time->second; 1885 1886 png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7); 1887} 1888#endif 1889 1890/* Initializes the row writing capability of libpng */ 1891void /* PRIVATE */ 1892png_write_start_row(png_structrp png_ptr) 1893{ 1894#ifdef PNG_WRITE_INTERLACING_SUPPORTED 1895 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ 1896 1897 /* Start of interlace block */ 1898 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; 1899 1900 /* Offset to next interlace block */ 1901 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; 1902 1903 /* Start of interlace block in the y direction */ 1904 static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; 1905 1906 /* Offset to next interlace block in the y direction */ 1907 static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; 1908#endif 1909 1910 png_alloc_size_t buf_size; 1911 int usr_pixel_depth; 1912 1913#ifdef PNG_WRITE_FILTER_SUPPORTED 1914 png_byte filters; 1915#endif 1916 1917 png_debug(1, "in png_write_start_row"); 1918 1919 usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth; 1920 buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1; 1921 1922 /* 1.5.6: added to allow checking in the row write code. */ 1923 png_ptr->transformed_pixel_depth = png_ptr->pixel_depth; 1924 png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth; 1925 1926 /* Set up row buffer */ 1927 png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size)); 1928 1929 png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; 1930 1931#ifdef PNG_WRITE_FILTER_SUPPORTED 1932 filters = png_ptr->do_filter; 1933 1934 if (png_ptr->height == 1) 1935 filters &= 0xff & ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH); 1936 1937 if (png_ptr->width == 1) 1938 filters &= 0xff & ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH); 1939 1940 if (filters == 0) 1941 filters = PNG_FILTER_NONE; 1942 1943 png_ptr->do_filter = filters; 1944 1945 if (((filters & (PNG_FILTER_SUB | PNG_FILTER_UP | PNG_FILTER_AVG | 1946 PNG_FILTER_PAETH)) != 0) && png_ptr->try_row == NULL) 1947 { 1948 int num_filters = 0; 1949 1950 png_ptr->try_row = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size)); 1951 1952 if (filters & PNG_FILTER_SUB) 1953 num_filters++; 1954 1955 if (filters & PNG_FILTER_UP) 1956 num_filters++; 1957 1958 if (filters & PNG_FILTER_AVG) 1959 num_filters++; 1960 1961 if (filters & PNG_FILTER_PAETH) 1962 num_filters++; 1963 1964 if (num_filters > 1) 1965 png_ptr->tst_row = png_voidcast(png_bytep, png_malloc(png_ptr, 1966 buf_size)); 1967 } 1968 1969 /* We only need to keep the previous row if we are using one of the following 1970 * filters. 1971 */ 1972 if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0) 1973 png_ptr->prev_row = png_voidcast(png_bytep, 1974 png_calloc(png_ptr, buf_size)); 1975#endif /* WRITE_FILTER */ 1976 1977#ifdef PNG_WRITE_INTERLACING_SUPPORTED 1978 /* If interlaced, we need to set up width and height of pass */ 1979 if (png_ptr->interlaced != 0) 1980 { 1981 if ((png_ptr->transformations & PNG_INTERLACE) == 0) 1982 { 1983 png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - 1984 png_pass_ystart[0]) / png_pass_yinc[0]; 1985 1986 png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - 1987 png_pass_start[0]) / png_pass_inc[0]; 1988 } 1989 1990 else 1991 { 1992 png_ptr->num_rows = png_ptr->height; 1993 png_ptr->usr_width = png_ptr->width; 1994 } 1995 } 1996 1997 else 1998#endif 1999 { 2000 png_ptr->num_rows = png_ptr->height; 2001 png_ptr->usr_width = png_ptr->width; 2002 } 2003} 2004 2005/* Internal use only. Called when finished processing a row of data. */ 2006void /* PRIVATE */ 2007png_write_finish_row(png_structrp png_ptr) 2008{ 2009#ifdef PNG_WRITE_INTERLACING_SUPPORTED 2010 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ 2011 2012 /* Start of interlace block */ 2013 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; 2014 2015 /* Offset to next interlace block */ 2016 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; 2017 2018 /* Start of interlace block in the y direction */ 2019 static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; 2020 2021 /* Offset to next interlace block in the y direction */ 2022 static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; 2023#endif 2024 2025 png_debug(1, "in png_write_finish_row"); 2026 2027 /* Next row */ 2028 png_ptr->row_number++; 2029 2030 /* See if we are done */ 2031 if (png_ptr->row_number < png_ptr->num_rows) 2032 return; 2033 2034#ifdef PNG_WRITE_INTERLACING_SUPPORTED 2035 /* If interlaced, go to next pass */ 2036 if (png_ptr->interlaced != 0) 2037 { 2038 png_ptr->row_number = 0; 2039 if ((png_ptr->transformations & PNG_INTERLACE) != 0) 2040 { 2041 png_ptr->pass++; 2042 } 2043 2044 else 2045 { 2046 /* Loop until we find a non-zero width or height pass */ 2047 do 2048 { 2049 png_ptr->pass++; 2050 2051 if (png_ptr->pass >= 7) 2052 break; 2053 2054 png_ptr->usr_width = (png_ptr->width + 2055 png_pass_inc[png_ptr->pass] - 1 - 2056 png_pass_start[png_ptr->pass]) / 2057 png_pass_inc[png_ptr->pass]; 2058 2059 png_ptr->num_rows = (png_ptr->height + 2060 png_pass_yinc[png_ptr->pass] - 1 - 2061 png_pass_ystart[png_ptr->pass]) / 2062 png_pass_yinc[png_ptr->pass]; 2063 2064 if ((png_ptr->transformations & PNG_INTERLACE) != 0) 2065 break; 2066 2067 } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); 2068 2069 } 2070 2071 /* Reset the row above the image for the next pass */ 2072 if (png_ptr->pass < 7) 2073 { 2074 if (png_ptr->prev_row != NULL) 2075 memset(png_ptr->prev_row, 0, 2076 (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* 2077 png_ptr->usr_bit_depth, png_ptr->width)) + 1); 2078 2079 return; 2080 } 2081 } 2082#endif 2083 2084 /* If we get here, we've just written the last row, so we need 2085 to flush the compressor */ 2086 png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH); 2087} 2088 2089#ifdef PNG_WRITE_INTERLACING_SUPPORTED 2090/* Pick out the correct pixels for the interlace pass. 2091 * The basic idea here is to go through the row with a source 2092 * pointer and a destination pointer (sp and dp), and copy the 2093 * correct pixels for the pass. As the row gets compacted, 2094 * sp will always be >= dp, so we should never overwrite anything. 2095 * See the default: case for the easiest code to understand. 2096 */ 2097void /* PRIVATE */ 2098png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) 2099{ 2100 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ 2101 2102 /* Start of interlace block */ 2103 static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; 2104 2105 /* Offset to next interlace block */ 2106 static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; 2107 2108 png_debug(1, "in png_do_write_interlace"); 2109 2110 /* We don't have to do anything on the last pass (6) */ 2111 if (pass < 6) 2112 { 2113 /* Each pixel depth is handled separately */ 2114 switch (row_info->pixel_depth) 2115 { 2116 case 1: 2117 { 2118 png_bytep sp; 2119 png_bytep dp; 2120 unsigned int shift; 2121 int d; 2122 int value; 2123 png_uint_32 i; 2124 png_uint_32 row_width = row_info->width; 2125 2126 dp = row; 2127 d = 0; 2128 shift = 7; 2129 2130 for (i = png_pass_start[pass]; i < row_width; 2131 i += png_pass_inc[pass]) 2132 { 2133 sp = row + (png_size_t)(i >> 3); 2134 value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; 2135 d |= (value << shift); 2136 2137 if (shift == 0) 2138 { 2139 shift = 7; 2140 *dp++ = (png_byte)d; 2141 d = 0; 2142 } 2143 2144 else 2145 shift--; 2146 2147 } 2148 if (shift != 7) 2149 *dp = (png_byte)d; 2150 2151 break; 2152 } 2153 2154 case 2: 2155 { 2156 png_bytep sp; 2157 png_bytep dp; 2158 unsigned int shift; 2159 int d; 2160 int value; 2161 png_uint_32 i; 2162 png_uint_32 row_width = row_info->width; 2163 2164 dp = row; 2165 shift = 6; 2166 d = 0; 2167 2168 for (i = png_pass_start[pass]; i < row_width; 2169 i += png_pass_inc[pass]) 2170 { 2171 sp = row + (png_size_t)(i >> 2); 2172 value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; 2173 d |= (value << shift); 2174 2175 if (shift == 0) 2176 { 2177 shift = 6; 2178 *dp++ = (png_byte)d; 2179 d = 0; 2180 } 2181 2182 else 2183 shift -= 2; 2184 } 2185 if (shift != 6) 2186 *dp = (png_byte)d; 2187 2188 break; 2189 } 2190 2191 case 4: 2192 { 2193 png_bytep sp; 2194 png_bytep dp; 2195 unsigned int shift; 2196 int d; 2197 int value; 2198 png_uint_32 i; 2199 png_uint_32 row_width = row_info->width; 2200 2201 dp = row; 2202 shift = 4; 2203 d = 0; 2204 for (i = png_pass_start[pass]; i < row_width; 2205 i += png_pass_inc[pass]) 2206 { 2207 sp = row + (png_size_t)(i >> 1); 2208 value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; 2209 d |= (value << shift); 2210 2211 if (shift == 0) 2212 { 2213 shift = 4; 2214 *dp++ = (png_byte)d; 2215 d = 0; 2216 } 2217 2218 else 2219 shift -= 4; 2220 } 2221 if (shift != 4) 2222 *dp = (png_byte)d; 2223 2224 break; 2225 } 2226 2227 default: 2228 { 2229 png_bytep sp; 2230 png_bytep dp; 2231 png_uint_32 i; 2232 png_uint_32 row_width = row_info->width; 2233 png_size_t pixel_bytes; 2234 2235 /* Start at the beginning */ 2236 dp = row; 2237 2238 /* Find out how many bytes each pixel takes up */ 2239 pixel_bytes = (row_info->pixel_depth >> 3); 2240 2241 /* Loop through the row, only looking at the pixels that matter */ 2242 for (i = png_pass_start[pass]; i < row_width; 2243 i += png_pass_inc[pass]) 2244 { 2245 /* Find out where the original pixel is */ 2246 sp = row + (png_size_t)i * pixel_bytes; 2247 2248 /* Move the pixel */ 2249 if (dp != sp) 2250 memcpy(dp, sp, pixel_bytes); 2251 2252 /* Next pixel */ 2253 dp += pixel_bytes; 2254 } 2255 break; 2256 } 2257 } 2258 /* Set new row width */ 2259 row_info->width = (row_info->width + 2260 png_pass_inc[pass] - 1 - 2261 png_pass_start[pass]) / 2262 png_pass_inc[pass]; 2263 2264 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, 2265 row_info->width); 2266 } 2267} 2268#endif 2269 2270 2271/* This filters the row, chooses which filter to use, if it has not already 2272 * been specified by the application, and then writes the row out with the 2273 * chosen filter. 2274 */ 2275static void /* PRIVATE */ 2276png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, 2277 png_size_t row_bytes); 2278 2279#ifdef PNG_WRITE_FILTER_SUPPORTED 2280static png_size_t /* PRIVATE */ 2281png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp, 2282 const png_size_t row_bytes, const png_size_t lmins) 2283{ 2284 png_bytep rp, dp, lp; 2285 png_size_t i; 2286 png_size_t sum = 0; 2287 unsigned int v; 2288 2289 png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB; 2290 2291 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp; 2292 i++, rp++, dp++) 2293 { 2294 v = *dp = *rp; 2295#ifdef PNG_USE_ABS 2296 sum += 128 - abs((int)v - 128); 2297#else 2298 sum += (v < 128) ? v : 256 - v; 2299#endif 2300 } 2301 2302 for (lp = png_ptr->row_buf + 1; i < row_bytes; 2303 i++, rp++, lp++, dp++) 2304 { 2305 v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); 2306#ifdef PNG_USE_ABS 2307 sum += 128 - abs((int)v - 128); 2308#else 2309 sum += (v < 128) ? v : 256 - v; 2310#endif 2311 2312 if (sum > lmins) /* We are already worse, don't continue. */ 2313 break; 2314 } 2315 2316 return (sum); 2317} 2318 2319static void /* PRIVATE */ 2320png_setup_sub_row_only(png_structrp png_ptr, const png_uint_32 bpp, 2321 const png_size_t row_bytes) 2322{ 2323 png_bytep rp, dp, lp; 2324 png_size_t i; 2325 2326 png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB; 2327 2328 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp; 2329 i++, rp++, dp++) 2330 { 2331 *dp = *rp; 2332 } 2333 2334 for (lp = png_ptr->row_buf + 1; i < row_bytes; 2335 i++, rp++, lp++, dp++) 2336 { 2337 *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); 2338 } 2339} 2340 2341static png_size_t /* PRIVATE */ 2342png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes, 2343 const png_size_t lmins) 2344{ 2345 png_bytep rp, dp, pp; 2346 png_size_t i; 2347 png_size_t sum = 0; 2348 unsigned int v; 2349 2350 png_ptr->try_row[0] = PNG_FILTER_VALUE_UP; 2351 2352 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2353 pp = png_ptr->prev_row + 1; i < row_bytes; 2354 i++, rp++, pp++, dp++) 2355 { 2356 v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); 2357#ifdef PNG_USE_ABS 2358 sum += 128 - abs((int)v - 128); 2359#else 2360 sum += (v < 128) ? v : 256 - v; 2361#endif 2362 2363 if (sum > lmins) /* We are already worse, don't continue. */ 2364 break; 2365 } 2366 2367 return (sum); 2368} 2369static void /* PRIVATE */ 2370png_setup_up_row_only(png_structrp png_ptr, const png_size_t row_bytes) 2371{ 2372 png_bytep rp, dp, pp; 2373 png_size_t i; 2374 2375 png_ptr->try_row[0] = PNG_FILTER_VALUE_UP; 2376 2377 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2378 pp = png_ptr->prev_row + 1; i < row_bytes; 2379 i++, rp++, pp++, dp++) 2380 { 2381 *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); 2382 } 2383} 2384 2385static png_size_t /* PRIVATE */ 2386png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp, 2387 const png_size_t row_bytes, const png_size_t lmins) 2388{ 2389 png_bytep rp, dp, pp, lp; 2390 png_uint_32 i; 2391 png_size_t sum = 0; 2392 unsigned int v; 2393 2394 png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG; 2395 2396 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2397 pp = png_ptr->prev_row + 1; i < bpp; i++) 2398 { 2399 v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); 2400 2401#ifdef PNG_USE_ABS 2402 sum += 128 - abs((int)v - 128); 2403#else 2404 sum += (v < 128) ? v : 256 - v; 2405#endif 2406 } 2407 2408 for (lp = png_ptr->row_buf + 1; i < row_bytes; i++) 2409 { 2410 v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) 2411 & 0xff); 2412 2413#ifdef PNG_USE_ABS 2414 sum += 128 - abs((int)v - 128); 2415#else 2416 sum += (v < 128) ? v : 256 - v; 2417#endif 2418 2419 if (sum > lmins) /* We are already worse, don't continue. */ 2420 break; 2421 } 2422 2423 return (sum); 2424} 2425static void /* PRIVATE */ 2426png_setup_avg_row_only(png_structrp png_ptr, const png_uint_32 bpp, 2427 const png_size_t row_bytes) 2428{ 2429 png_bytep rp, dp, pp, lp; 2430 png_uint_32 i; 2431 2432 png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG; 2433 2434 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2435 pp = png_ptr->prev_row + 1; i < bpp; i++) 2436 { 2437 *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); 2438 } 2439 2440 for (lp = png_ptr->row_buf + 1; i < row_bytes; i++) 2441 { 2442 *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) 2443 & 0xff); 2444 } 2445} 2446 2447static png_size_t /* PRIVATE */ 2448png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp, 2449 const png_size_t row_bytes, const png_size_t lmins) 2450{ 2451 png_bytep rp, dp, pp, cp, lp; 2452 png_size_t i; 2453 png_size_t sum = 0; 2454 unsigned int v; 2455 2456 png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH; 2457 2458 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2459 pp = png_ptr->prev_row + 1; i < bpp; i++) 2460 { 2461 v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); 2462 2463#ifdef PNG_USE_ABS 2464 sum += 128 - abs((int)v - 128); 2465#else 2466 sum += (v < 128) ? v : 256 - v; 2467#endif 2468 } 2469 2470 for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes; 2471 i++) 2472 { 2473 int a, b, c, pa, pb, pc, p; 2474 2475 b = *pp++; 2476 c = *cp++; 2477 a = *lp++; 2478 2479 p = b - c; 2480 pc = a - c; 2481 2482#ifdef PNG_USE_ABS 2483 pa = abs(p); 2484 pb = abs(pc); 2485 pc = abs(p + pc); 2486#else 2487 pa = p < 0 ? -p : p; 2488 pb = pc < 0 ? -pc : pc; 2489 pc = (p + pc) < 0 ? -(p + pc) : p + pc; 2490#endif 2491 2492 p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; 2493 2494 v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); 2495 2496#ifdef PNG_USE_ABS 2497 sum += 128 - abs((int)v - 128); 2498#else 2499 sum += (v < 128) ? v : 256 - v; 2500#endif 2501 2502 if (sum > lmins) /* We are already worse, don't continue. */ 2503 break; 2504 } 2505 2506 return (sum); 2507} 2508static void /* PRIVATE */ 2509png_setup_paeth_row_only(png_structrp png_ptr, const png_uint_32 bpp, 2510 const png_size_t row_bytes) 2511{ 2512 png_bytep rp, dp, pp, cp, lp; 2513 png_size_t i; 2514 2515 png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH; 2516 2517 for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, 2518 pp = png_ptr->prev_row + 1; i < bpp; i++) 2519 { 2520 *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); 2521 } 2522 2523 for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes; 2524 i++) 2525 { 2526 int a, b, c, pa, pb, pc, p; 2527 2528 b = *pp++; 2529 c = *cp++; 2530 a = *lp++; 2531 2532 p = b - c; 2533 pc = a - c; 2534 2535#ifdef PNG_USE_ABS 2536 pa = abs(p); 2537 pb = abs(pc); 2538 pc = abs(p + pc); 2539#else 2540 pa = p < 0 ? -p : p; 2541 pb = pc < 0 ? -pc : pc; 2542 pc = (p + pc) < 0 ? -(p + pc) : p + pc; 2543#endif 2544 2545 p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; 2546 2547 *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); 2548 } 2549} 2550#endif /* WRITE_FILTER */ 2551 2552void /* PRIVATE */ 2553png_write_find_filter(png_structrp png_ptr, png_row_infop row_info) 2554{ 2555#ifndef PNG_WRITE_FILTER_SUPPORTED 2556 png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1); 2557#else 2558 unsigned int filter_to_do = png_ptr->do_filter; 2559 png_bytep row_buf; 2560 png_bytep best_row; 2561 png_uint_32 bpp; 2562 png_size_t mins; 2563 png_size_t row_bytes = row_info->rowbytes; 2564 2565 png_debug(1, "in png_write_find_filter"); 2566 2567 /* Find out how many bytes offset each pixel is */ 2568 bpp = (row_info->pixel_depth + 7) >> 3; 2569 2570 row_buf = png_ptr->row_buf; 2571 mins = PNG_SIZE_MAX - 256/* so we can detect potential overflow of the 2572 running sum */; 2573 2574 /* The prediction method we use is to find which method provides the 2575 * smallest value when summing the absolute values of the distances 2576 * from zero, using anything >= 128 as negative numbers. This is known 2577 * as the "minimum sum of absolute differences" heuristic. Other 2578 * heuristics are the "weighted minimum sum of absolute differences" 2579 * (experimental and can in theory improve compression), and the "zlib 2580 * predictive" method (not implemented yet), which does test compressions 2581 * of lines using different filter methods, and then chooses the 2582 * (series of) filter(s) that give minimum compressed data size (VERY 2583 * computationally expensive). 2584 * 2585 * GRR 980525: consider also 2586 * 2587 * (1) minimum sum of absolute differences from running average (i.e., 2588 * keep running sum of non-absolute differences & count of bytes) 2589 * [track dispersion, too? restart average if dispersion too large?] 2590 * 2591 * (1b) minimum sum of absolute differences from sliding average, probably 2592 * with window size <= deflate window (usually 32K) 2593 * 2594 * (2) minimum sum of squared differences from zero or running average 2595 * (i.e., ~ root-mean-square approach) 2596 */ 2597 2598 2599 /* We don't need to test the 'no filter' case if this is the only filter 2600 * that has been chosen, as it doesn't actually do anything to the data. 2601 */ 2602 best_row = png_ptr->row_buf; 2603 2604 if (PNG_SIZE_MAX/128 <= row_bytes) 2605 { 2606 /* Overflow can occur in the calculation, just select the lowest set 2607 * filter. 2608 */ 2609 filter_to_do &= 0U-filter_to_do; 2610 } 2611 else if ((filter_to_do & PNG_FILTER_NONE) != 0 && 2612 filter_to_do != PNG_FILTER_NONE) 2613 { 2614 /* Overflow not possible and multiple filters in the list, including the 2615 * 'none' filter. 2616 */ 2617 png_bytep rp; 2618 png_size_t sum = 0; 2619 png_size_t i; 2620 unsigned int v; 2621 2622 { 2623 for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) 2624 { 2625 v = *rp; 2626#ifdef PNG_USE_ABS 2627 sum += 128 - abs((int)v - 128); 2628#else 2629 sum += (v < 128) ? v : 256 - v; 2630#endif 2631 } 2632 } 2633 2634 mins = sum; 2635 } 2636 2637 /* Sub filter */ 2638 if (filter_to_do == PNG_FILTER_SUB) 2639 /* It's the only filter so no testing is needed */ 2640 { 2641 png_setup_sub_row_only(png_ptr, bpp, row_bytes); 2642 best_row = png_ptr->try_row; 2643 } 2644 2645 else if ((filter_to_do & PNG_FILTER_SUB) != 0) 2646 { 2647 png_size_t sum; 2648 png_size_t lmins = mins; 2649 2650 sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins); 2651 2652 if (sum < mins) 2653 { 2654 mins = sum; 2655 best_row = png_ptr->try_row; 2656 if (png_ptr->tst_row != NULL) 2657 { 2658 png_ptr->try_row = png_ptr->tst_row; 2659 png_ptr->tst_row = best_row; 2660 } 2661 } 2662 } 2663 2664 /* Up filter */ 2665 if (filter_to_do == PNG_FILTER_UP) 2666 { 2667 png_setup_up_row_only(png_ptr, row_bytes); 2668 best_row = png_ptr->try_row; 2669 } 2670 2671 else if ((filter_to_do & PNG_FILTER_UP) != 0) 2672 { 2673 png_size_t sum; 2674 png_size_t lmins = mins; 2675 2676 sum = png_setup_up_row(png_ptr, row_bytes, lmins); 2677 2678 if (sum < mins) 2679 { 2680 mins = sum; 2681 best_row = png_ptr->try_row; 2682 if (png_ptr->tst_row != NULL) 2683 { 2684 png_ptr->try_row = png_ptr->tst_row; 2685 png_ptr->tst_row = best_row; 2686 } 2687 } 2688 } 2689 2690 /* Avg filter */ 2691 if (filter_to_do == PNG_FILTER_AVG) 2692 { 2693 png_setup_avg_row_only(png_ptr, bpp, row_bytes); 2694 best_row = png_ptr->try_row; 2695 } 2696 2697 else if ((filter_to_do & PNG_FILTER_AVG) != 0) 2698 { 2699 png_size_t sum; 2700 png_size_t lmins = mins; 2701 2702 sum= png_setup_avg_row(png_ptr, bpp, row_bytes, lmins); 2703 2704 if (sum < mins) 2705 { 2706 mins = sum; 2707 best_row = png_ptr->try_row; 2708 if (png_ptr->tst_row != NULL) 2709 { 2710 png_ptr->try_row = png_ptr->tst_row; 2711 png_ptr->tst_row = best_row; 2712 } 2713 } 2714 } 2715 2716 /* Paeth filter */ 2717 if (filter_to_do == PNG_FILTER_PAETH) 2718 { 2719 png_setup_paeth_row_only(png_ptr, bpp, row_bytes); 2720 best_row = png_ptr->try_row; 2721 } 2722 2723 else if ((filter_to_do & PNG_FILTER_PAETH) != 0) 2724 { 2725 png_size_t sum; 2726 png_size_t lmins = mins; 2727 2728 sum = png_setup_paeth_row(png_ptr, bpp, row_bytes, lmins); 2729 2730 if (sum < mins) 2731 { 2732 best_row = png_ptr->try_row; 2733 if (png_ptr->tst_row != NULL) 2734 { 2735 png_ptr->try_row = png_ptr->tst_row; 2736 png_ptr->tst_row = best_row; 2737 } 2738 } 2739 } 2740 2741 /* Do the actual writing of the filtered row data from the chosen filter. */ 2742 png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1); 2743 2744#endif /* WRITE_FILTER */ 2745} 2746 2747 2748/* Do the actual writing of a previously filtered row. */ 2749static void 2750png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, 2751 png_size_t full_row_length/*includes filter byte*/) 2752{ 2753 png_debug(1, "in png_write_filtered_row"); 2754 2755 png_debug1(2, "filter = %d", filtered_row[0]); 2756 2757 png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH); 2758 2759#ifdef PNG_WRITE_FILTER_SUPPORTED 2760 /* Swap the current and previous rows */ 2761 if (png_ptr->prev_row != NULL) 2762 { 2763 png_bytep tptr; 2764 2765 tptr = png_ptr->prev_row; 2766 png_ptr->prev_row = png_ptr->row_buf; 2767 png_ptr->row_buf = tptr; 2768 } 2769#endif /* WRITE_FILTER */ 2770 2771 /* Finish row - updates counters and flushes zlib if last row */ 2772 png_write_finish_row(png_ptr); 2773 2774#ifdef PNG_WRITE_FLUSH_SUPPORTED 2775 png_ptr->flush_rows++; 2776 2777 if (png_ptr->flush_dist > 0 && 2778 png_ptr->flush_rows >= png_ptr->flush_dist) 2779 { 2780 png_write_flush(png_ptr); 2781 } 2782#endif /* WRITE_FLUSH */ 2783} 2784#endif /* WRITE */ 2785