src/libpng/png.c

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