1 2/* png.c - location for general purpose libpng functions 3 * 4 * libpng version 1.2.7 - September 12, 2004 5 * For conditions of distribution and use, see copyright notice in png.h 6 * Copyright (c) 1998-2004 Glenn Randers-Pehrson 7 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 8 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 9 */ 10 11#define PNG_INTERNAL 12#define PNG_NO_EXTERN 13#include "png.h" 14 15/* Generate a compiler error if there is an old png.h in the search path. */ 16typedef version_1_2_7 Your_png_h_is_not_version_1_2_7; 17 18/* Version information for C files. This had better match the version 19 * string defined in png.h. */ 20 21#ifdef PNG_USE_GLOBAL_ARRAYS 22/* png_libpng_ver was changed to a function in version 1.0.5c */ 23const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING; 24 25/* png_sig was changed to a function in version 1.0.5c */ 26/* Place to hold the signature string for a PNG file. */ 27const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; 28 29/* Invoke global declarations for constant strings for known chunk types */ 30PNG_IHDR; 31PNG_IDAT; 32PNG_IEND; 33PNG_PLTE; 34PNG_bKGD; 35PNG_cHRM; 36PNG_gAMA; 37PNG_hIST; 38PNG_iCCP; 39PNG_iTXt; 40PNG_oFFs; 41PNG_pCAL; 42PNG_sCAL; 43PNG_pHYs; 44PNG_sBIT; 45PNG_sPLT; 46PNG_sRGB; 47PNG_tEXt; 48PNG_tIME; 49PNG_tRNS; 50PNG_zTXt; 51 52/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ 53 54/* start of interlace block */ 55const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; 56 57/* offset to next interlace block */ 58const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; 59 60/* start of interlace block in the y direction */ 61const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; 62 63/* offset to next interlace block in the y direction */ 64const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; 65 66/* width of interlace block (used in assembler routines only) */ 67#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW 68const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; 69#endif 70 71/* Height of interlace block. This is not currently used - if you need 72 * it, uncomment it here and in png.h 73const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; 74*/ 75 76/* Mask to determine which pixels are valid in a pass */ 77const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; 78 79/* Mask to determine which pixels to overwrite while displaying */ 80const int FARDATA png_pass_dsp_mask[] 81 = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; 82 83#endif 84 85/* Tells libpng that we have already handled the first "num_bytes" bytes 86 * of the PNG file signature. If the PNG data is embedded into another 87 * stream we can set num_bytes = 8 so that libpng will not attempt to read 88 * or write any of the magic bytes before it starts on the IHDR. 89 */ 90 91void PNGAPI 92png_set_sig_bytes(png_structp png_ptr, int num_bytes) 93{ 94 png_debug(1, "in png_set_sig_bytes\n"); 95 if (num_bytes > 8) 96 png_error(png_ptr, "Too many bytes for PNG signature."); 97 98 png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); 99} 100 101/* Checks whether the supplied bytes match the PNG signature. We allow 102 * checking less than the full 8-byte signature so that those apps that 103 * already read the first few bytes of a file to determine the file type 104 * can simply check the remaining bytes for extra assurance. Returns 105 * an integer less than, equal to, or greater than zero if sig is found, 106 * respectively, to be less than, to match, or be greater than the correct 107 * PNG signature (this is the same behaviour as strcmp, memcmp, etc). 108 */ 109int PNGAPI 110png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) 111{ 112 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; 113 if (num_to_check > 8) 114 num_to_check = 8; 115 else if (num_to_check < 1) 116 return (0); 117 118 if (start > 7) 119 return (0); 120 121 if (start + num_to_check > 8) 122 num_to_check = 8 - start; 123 124 return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); 125} 126 127/* (Obsolete) function to check signature bytes. It does not allow one 128 * to check a partial signature. This function might be removed in the 129 * future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. 130 */ 131int PNGAPI 132png_check_sig(png_bytep sig, int num) 133{ 134 return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); 135} 136 137/* Function to allocate memory for zlib and clear it to 0. */ 138#ifdef PNG_1_0_X 139voidpf PNGAPI 140#else 141voidpf /* private */ 142#endif 143png_zalloc(voidpf png_ptr, uInt items, uInt size) 144{ 145 png_voidp ptr; 146 png_structp p=(png_struct*)png_ptr; 147 png_uint_32 save_flags=p->flags; 148 png_uint_32 num_bytes; 149 150 if (items > PNG_UINT_32_MAX/size) 151 { 152 png_warning (png_ptr, "Potential overflow in png_zalloc()"); 153 return (NULL); 154 } 155 num_bytes = (png_uint_32)items * size; 156 157 p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; 158 ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); 159 p->flags=save_flags; 160 161#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO) 162 if (ptr == NULL) 163 return ((voidpf)ptr); 164 165 if (num_bytes > (png_uint_32)0x8000L) 166 { 167 png_memset(ptr, 0, (png_size_t)0x8000L); 168 png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, 169 (png_size_t)(num_bytes - (png_uint_32)0x8000L)); 170 } 171 else 172 { 173 png_memset(ptr, 0, (png_size_t)num_bytes); 174 } 175#endif 176 return ((voidpf)ptr); 177} 178 179/* function to free memory for zlib */ 180#ifdef PNG_1_0_X 181void PNGAPI 182#else 183void /* private */ 184#endif 185png_zfree(voidpf png_ptr, voidpf ptr) 186{ 187 png_free((png_structp)png_ptr, (png_voidp)ptr); 188} 189 190/* Reset the CRC variable to 32 bits of 1's. Care must be taken 191 * in case CRC is > 32 bits to leave the top bits 0. 192 */ 193void /* PRIVATE */ 194png_reset_crc(png_structp png_ptr) 195{ 196 png_ptr->crc = crc32(0, Z_NULL, 0); 197} 198 199/* Calculate the CRC over a section of data. We can only pass as 200 * much data to this routine as the largest single buffer size. We 201 * also check that this data will actually be used before going to the 202 * trouble of calculating it. 203 */ 204void /* PRIVATE */ 205png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) 206{ 207 int need_crc = 1; 208 209 if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ 210 { 211 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == 212 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) 213 need_crc = 0; 214 } 215 else /* critical */ 216 { 217 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) 218 need_crc = 0; 219 } 220 221 if (need_crc) 222 png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); 223} 224 225/* Allocate the memory for an info_struct for the application. We don't 226 * really need the png_ptr, but it could potentially be useful in the 227 * future. This should be used in favour of malloc(png_sizeof(png_info)) 228 * and png_info_init() so that applications that want to use a shared 229 * libpng don't have to be recompiled if png_info changes size. 230 */ 231png_infop PNGAPI 232png_create_info_struct(png_structp png_ptr) 233{ 234 png_infop info_ptr; 235 236 png_debug(1, "in png_create_info_struct\n"); 237 if(png_ptr == NULL) return (NULL); 238#ifdef PNG_USER_MEM_SUPPORTED 239 info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, 240 png_ptr->malloc_fn, png_ptr->mem_ptr); 241#else 242 info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); 243#endif 244 if (info_ptr != NULL) 245 png_info_init_3(&info_ptr, png_sizeof(png_info)); 246 247 return (info_ptr); 248} 249 250/* This function frees the memory associated with a single info struct. 251 * Normally, one would use either png_destroy_read_struct() or 252 * png_destroy_write_struct() to free an info struct, but this may be 253 * useful for some applications. 254 */ 255void PNGAPI 256png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) 257{ 258 png_infop info_ptr = NULL; 259 260 png_debug(1, "in png_destroy_info_struct\n"); 261 if (info_ptr_ptr != NULL) 262 info_ptr = *info_ptr_ptr; 263 264 if (info_ptr != NULL) 265 { 266 png_info_destroy(png_ptr, info_ptr); 267 268#ifdef PNG_USER_MEM_SUPPORTED 269 png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, 270 png_ptr->mem_ptr); 271#else 272 png_destroy_struct((png_voidp)info_ptr); 273#endif 274 *info_ptr_ptr = NULL; 275 } 276} 277 278/* Initialize the info structure. This is now an internal function (0.89) 279 * and applications using it are urged to use png_create_info_struct() 280 * instead. 281 */ 282#undef png_info_init 283void PNGAPI 284png_info_init(png_infop info_ptr) 285{ 286 /* We only come here via pre-1.0.12-compiled applications */ 287 png_info_init_3(&info_ptr, 0); 288} 289 290void PNGAPI 291png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) 292{ 293 png_infop info_ptr = *ptr_ptr; 294 295 png_debug(1, "in png_info_init_3\n"); 296 297 if(png_sizeof(png_info) > png_info_struct_size) 298 { 299 png_destroy_struct(info_ptr); 300 info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); 301 *ptr_ptr = info_ptr; 302 } 303 304 /* set everything to 0 */ 305 png_memset(info_ptr, 0, png_sizeof (png_info)); 306} 307 308#ifdef PNG_FREE_ME_SUPPORTED 309void PNGAPI 310png_data_freer(png_structp png_ptr, png_infop info_ptr, 311 int freer, png_uint_32 mask) 312{ 313 png_debug(1, "in png_data_freer\n"); 314 if (png_ptr == NULL || info_ptr == NULL) 315 return; 316 if(freer == PNG_DESTROY_WILL_FREE_DATA) 317 info_ptr->free_me |= mask; 318 else if(freer == PNG_USER_WILL_FREE_DATA) 319 info_ptr->free_me &= ~mask; 320 else 321 png_warning(png_ptr, 322 "Unknown freer parameter in png_data_freer."); 323} 324#endif 325 326void PNGAPI 327png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, 328 int num) 329{ 330 png_debug(1, "in png_free_data\n"); 331 if (png_ptr == NULL || info_ptr == NULL) 332 return; 333 334#if defined(PNG_TEXT_SUPPORTED) 335/* free text item num or (if num == -1) all text items */ 336#ifdef PNG_FREE_ME_SUPPORTED 337if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) 338#else 339if (mask & PNG_FREE_TEXT) 340#endif 341{ 342 if (num != -1) 343 { 344 if (info_ptr->text && info_ptr->text[num].key) 345 { 346 png_free(png_ptr, info_ptr->text[num].key); 347 info_ptr->text[num].key = NULL; 348 } 349 } 350 else 351 { 352 int i; 353 for (i = 0; i < info_ptr->num_text; i++) 354 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); 355 png_free(png_ptr, info_ptr->text); 356 info_ptr->text = NULL; 357 info_ptr->num_text=0; 358 } 359} 360#endif 361 362#if defined(PNG_tRNS_SUPPORTED) 363/* free any tRNS entry */ 364#ifdef PNG_FREE_ME_SUPPORTED 365if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) 366#else 367if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) 368#endif 369{ 370 png_free(png_ptr, info_ptr->trans); 371 info_ptr->valid &= ~PNG_INFO_tRNS; 372#ifndef PNG_FREE_ME_SUPPORTED 373 png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; 374#endif 375 info_ptr->trans = NULL; 376} 377#endif 378 379#if defined(PNG_sCAL_SUPPORTED) 380/* free any sCAL entry */ 381#ifdef PNG_FREE_ME_SUPPORTED 382if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) 383#else 384if (mask & PNG_FREE_SCAL) 385#endif 386{ 387#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) 388 png_free(png_ptr, info_ptr->scal_s_width); 389 png_free(png_ptr, info_ptr->scal_s_height); 390 info_ptr->scal_s_width = NULL; 391 info_ptr->scal_s_height = NULL; 392#endif 393 info_ptr->valid &= ~PNG_INFO_sCAL; 394} 395#endif 396 397#if defined(PNG_pCAL_SUPPORTED) 398/* free any pCAL entry */ 399#ifdef PNG_FREE_ME_SUPPORTED 400if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) 401#else 402if (mask & PNG_FREE_PCAL) 403#endif 404{ 405 png_free(png_ptr, info_ptr->pcal_purpose); 406 png_free(png_ptr, info_ptr->pcal_units); 407 info_ptr->pcal_purpose = NULL; 408 info_ptr->pcal_units = NULL; 409 if (info_ptr->pcal_params != NULL) 410 { 411 int i; 412 for (i = 0; i < (int)info_ptr->pcal_nparams; i++) 413 { 414 png_free(png_ptr, info_ptr->pcal_params[i]); 415 info_ptr->pcal_params[i]=NULL; 416 } 417 png_free(png_ptr, info_ptr->pcal_params); 418 info_ptr->pcal_params = NULL; 419 } 420 info_ptr->valid &= ~PNG_INFO_pCAL; 421} 422#endif 423 424#if defined(PNG_iCCP_SUPPORTED) 425/* free any iCCP entry */ 426#ifdef PNG_FREE_ME_SUPPORTED 427if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) 428#else 429if (mask & PNG_FREE_ICCP) 430#endif 431{ 432 png_free(png_ptr, info_ptr->iccp_name); 433 png_free(png_ptr, info_ptr->iccp_profile); 434 info_ptr->iccp_name = NULL; 435 info_ptr->iccp_profile = NULL; 436 info_ptr->valid &= ~PNG_INFO_iCCP; 437} 438#endif 439 440#if defined(PNG_sPLT_SUPPORTED) 441/* free a given sPLT entry, or (if num == -1) all sPLT entries */ 442#ifdef PNG_FREE_ME_SUPPORTED 443if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) 444#else 445if (mask & PNG_FREE_SPLT) 446#endif 447{ 448 if (num != -1) 449 { 450 if(info_ptr->splt_palettes) 451 { 452 png_free(png_ptr, info_ptr->splt_palettes[num].name); 453 png_free(png_ptr, info_ptr->splt_palettes[num].entries); 454 info_ptr->splt_palettes[num].name = NULL; 455 info_ptr->splt_palettes[num].entries = NULL; 456 } 457 } 458 else 459 { 460 if(info_ptr->splt_palettes_num) 461 { 462 int i; 463 for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) 464 png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); 465 466 png_free(png_ptr, info_ptr->splt_palettes); 467 info_ptr->splt_palettes = NULL; 468 info_ptr->splt_palettes_num = 0; 469 } 470 info_ptr->valid &= ~PNG_INFO_sPLT; 471 } 472} 473#endif 474 475#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) 476#ifdef PNG_FREE_ME_SUPPORTED 477if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) 478#else 479if (mask & PNG_FREE_UNKN) 480#endif 481{ 482 if (num != -1) 483 { 484 if(info_ptr->unknown_chunks) 485 { 486 png_free(png_ptr, info_ptr->unknown_chunks[num].data); 487 info_ptr->unknown_chunks[num].data = NULL; 488 } 489 } 490 else 491 { 492 int i; 493 494 if(info_ptr->unknown_chunks_num) 495 { 496 for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) 497 png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); 498 499 png_free(png_ptr, info_ptr->unknown_chunks); 500 info_ptr->unknown_chunks = NULL; 501 info_ptr->unknown_chunks_num = 0; 502 } 503 } 504} 505#endif 506 507#if defined(PNG_hIST_SUPPORTED) 508/* free any hIST entry */ 509#ifdef PNG_FREE_ME_SUPPORTED 510if ((mask & PNG_FREE_HIST) & info_ptr->free_me) 511#else 512if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) 513#endif 514{ 515 png_free(png_ptr, info_ptr->hist); 516 info_ptr->hist = NULL; 517 info_ptr->valid &= ~PNG_INFO_hIST; 518#ifndef PNG_FREE_ME_SUPPORTED 519 png_ptr->flags &= ~PNG_FLAG_FREE_HIST; 520#endif 521} 522#endif 523 524/* free any PLTE entry that was internally allocated */ 525#ifdef PNG_FREE_ME_SUPPORTED 526if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) 527#else 528if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) 529#endif 530{ 531 png_zfree(png_ptr, info_ptr->palette); 532 info_ptr->palette = NULL; 533 info_ptr->valid &= ~PNG_INFO_PLTE; 534#ifndef PNG_FREE_ME_SUPPORTED 535 png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; 536#endif 537 info_ptr->num_palette = 0; 538} 539 540#if defined(PNG_INFO_IMAGE_SUPPORTED) 541/* free any image bits attached to the info structure */ 542#ifdef PNG_FREE_ME_SUPPORTED 543if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) 544#else 545if (mask & PNG_FREE_ROWS) 546#endif 547{ 548 if(info_ptr->row_pointers) 549 { 550 int row; 551 for (row = 0; row < (int)info_ptr->height; row++) 552 { 553 png_free(png_ptr, info_ptr->row_pointers[row]); 554 info_ptr->row_pointers[row]=NULL; 555 } 556 png_free(png_ptr, info_ptr->row_pointers); 557 info_ptr->row_pointers=NULL; 558 } 559 info_ptr->valid &= ~PNG_INFO_IDAT; 560} 561#endif 562 563#ifdef PNG_FREE_ME_SUPPORTED 564 if(num == -1) 565 info_ptr->free_me &= ~mask; 566 else 567 info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); 568#endif 569} 570 571/* This is an internal routine to free any memory that the info struct is 572 * pointing to before re-using it or freeing the struct itself. Recall 573 * that png_free() checks for NULL pointers for us. 574 */ 575void /* PRIVATE */ 576png_info_destroy(png_structp png_ptr, png_infop info_ptr) 577{ 578 png_debug(1, "in png_info_destroy\n"); 579 580 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); 581 582#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) 583 if (png_ptr->num_chunk_list) 584 { 585 png_free(png_ptr, png_ptr->chunk_list); 586 png_ptr->chunk_list=NULL; 587 png_ptr->num_chunk_list=0; 588 } 589#endif 590 591 png_info_init_3(&info_ptr, png_sizeof(png_info)); 592} 593 594/* This function returns a pointer to the io_ptr associated with the user 595 * functions. The application should free any memory associated with this 596 * pointer before png_write_destroy() or png_read_destroy() are called. 597 */ 598png_voidp PNGAPI 599png_get_io_ptr(png_structp png_ptr) 600{ 601 return (png_ptr->io_ptr); 602} 603 604#if !defined(PNG_NO_STDIO) 605/* Initialize the default input/output functions for the PNG file. If you 606 * use your own read or write routines, you can call either png_set_read_fn() 607 * or png_set_write_fn() instead of png_init_io(). If you have defined 608 * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't 609 * necessarily available. 610 */ 611void PNGAPI 612png_init_io(png_structp png_ptr, png_FILE_p fp) 613{ 614 png_debug(1, "in png_init_io\n"); 615 png_ptr->io_ptr = (png_voidp)fp; 616} 617#endif 618 619#if defined(PNG_TIME_RFC1123_SUPPORTED) 620/* Convert the supplied time into an RFC 1123 string suitable for use in 621 * a "Creation Time" or other text-based time string. 622 */ 623png_charp PNGAPI 624png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) 625{ 626 static PNG_CONST char short_months[12][4] = 627 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", 628 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; 629 630 if (png_ptr->time_buffer == NULL) 631 { 632 png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* 633 png_sizeof(char))); 634 } 635 636#if defined(_WIN32_WCE) 637 { 638 wchar_t time_buf[29]; 639 wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), 640 ptime->day % 32, short_months[(ptime->month - 1) % 12], 641 ptime->year, ptime->hour % 24, ptime->minute % 60, 642 ptime->second % 61); 643 WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, 644 NULL, NULL); 645 } 646#else 647#ifdef USE_FAR_KEYWORD 648 { 649 char near_time_buf[29]; 650 sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", 651 ptime->day % 32, short_months[(ptime->month - 1) % 12], 652 ptime->year, ptime->hour % 24, ptime->minute % 60, 653 ptime->second % 61); 654 png_memcpy(png_ptr->time_buffer, near_time_buf, 655 29*png_sizeof(char)); 656 } 657#else 658 sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", 659 ptime->day % 32, short_months[(ptime->month - 1) % 12], 660 ptime->year, ptime->hour % 24, ptime->minute % 60, 661 ptime->second % 61); 662#endif 663#endif /* _WIN32_WCE */ 664 return ((png_charp)png_ptr->time_buffer); 665} 666#endif /* PNG_TIME_RFC1123_SUPPORTED */ 667 668#if 0 669/* Signature string for a PNG file. */ 670png_bytep PNGAPI 671png_sig_bytes(void) 672{ 673 return ((png_bytep)"\211\120\116\107\015\012\032\012"); 674} 675#endif 676 677png_charp PNGAPI 678png_get_copyright(png_structp png_ptr) 679{ 680 if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ 681 return ((png_charp) "\n libpng version 1.2.7 - September 12, 2004\n\ 682 Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\ 683 Copyright (c) 1996-1997 Andreas Dilger\n\ 684 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); 685 return ((png_charp) ""); 686} 687 688/* The following return the library version as a short string in the 689 * format 1.0.0 through 99.99.99zz. To get the version of *.h files 690 * used with your application, print out PNG_LIBPNG_VER_STRING, which 691 * is defined in png.h. 692 * Note: now there is no difference between png_get_libpng_ver() and 693 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, 694 * it is guaranteed that png.c uses the correct version of png.h. 695 */ 696png_charp PNGAPI 697png_get_libpng_ver(png_structp png_ptr) 698{ 699 /* Version of *.c files used when building libpng */ 700 if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ 701 return ((png_charp) PNG_LIBPNG_VER_STRING); 702 return ((png_charp) ""); 703} 704 705png_charp PNGAPI 706png_get_header_ver(png_structp png_ptr) 707{ 708 /* Version of *.h files used when building libpng */ 709 if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ 710 return ((png_charp) PNG_LIBPNG_VER_STRING); 711 return ((png_charp) ""); 712} 713 714png_charp PNGAPI 715png_get_header_version(png_structp png_ptr) 716{ 717 /* Returns longer string containing both version and date */ 718 if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ 719 return ((png_charp) PNG_HEADER_VERSION_STRING); 720 return ((png_charp) ""); 721} 722 723#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 724int PNGAPI 725png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) 726{ 727 /* check chunk_name and return "keep" value if it's on the list, else 0 */ 728 int i; 729 png_bytep p; 730 if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) 731 return 0; 732 p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; 733 for (i = png_ptr->num_chunk_list; i; i--, p-=5) 734 if (!png_memcmp(chunk_name, p, 4)) 735 return ((int)*(p+4)); 736 return 0; 737} 738#endif 739 740/* This function, added to libpng-1.0.6g, is untested. */ 741int PNGAPI 742png_reset_zstream(png_structp png_ptr) 743{ 744 return (inflateReset(&png_ptr->zstream)); 745} 746 747/* This function was added to libpng-1.0.7 */ 748png_uint_32 PNGAPI 749png_access_version_number(void) 750{ 751 /* Version of *.c files used when building libpng */ 752 return((png_uint_32) PNG_LIBPNG_VER); 753} 754 755 756#if !defined(PNG_1_0_X) 757#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) 758 /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ 759/* this INTERNAL function was added to libpng 1.2.0 */ 760void /* PRIVATE */ 761png_init_mmx_flags (png_structp png_ptr) 762{ 763 png_ptr->mmx_rowbytes_threshold = 0; 764 png_ptr->mmx_bitdepth_threshold = 0; 765 766# if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) 767 768 png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; 769 770 if (png_mmx_support() > 0) { 771 png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 772# ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW 773 | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 774# endif 775# ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE 776 | PNG_ASM_FLAG_MMX_READ_INTERLACE 777# endif 778# ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW 779 ; 780# else 781 | PNG_ASM_FLAG_MMX_READ_FILTER_SUB 782 | PNG_ASM_FLAG_MMX_READ_FILTER_UP 783 | PNG_ASM_FLAG_MMX_READ_FILTER_AVG 784 | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; 785 786 png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; 787 png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; 788# endif 789 } else { 790 png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 791 | PNG_MMX_READ_FLAGS 792 | PNG_MMX_WRITE_FLAGS ); 793 } 794 795# else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ 796 797 /* clear all MMX flags; no support is compiled in */ 798 png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); 799 800# endif /* ?(PNGVCRD || PNGGCCRD) */ 801} 802 803#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ 804 805/* this function was added to libpng 1.2.0 */ 806#if !defined(PNG_USE_PNGGCCRD) && \ 807 !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) 808int PNGAPI 809png_mmx_support(void) 810{ 811 return -1; 812} 813#endif 814#endif /* PNG_1_0_X */ 815 816#ifdef PNG_SIZE_T 817/* Added at libpng version 1.2.6 */ 818 PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); 819png_size_t PNGAPI 820png_convert_size(size_t size) 821{ 822 if (size > (png_size_t)-1) 823 PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ 824 return ((png_size_t)size); 825} 826#endif /* PNG_SIZE_T */ 827