Back to index

lightning-sunbird  0.9+nobinonly
png.c
Go to the documentation of this file.
00001 
00002 /* png.c - location for general purpose libpng functions
00003  *
00004  * libpng version 1.2.7 - September 12, 2004
00005  * For conditions of distribution and use, see copyright notice in png.h
00006  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
00007  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
00008  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
00009  */
00010 
00011 #define PNG_INTERNAL
00012 #define PNG_NO_EXTERN
00013 #include "png.h"
00014 
00015 /* Generate a compiler error if there is an old png.h in the search path. */
00016 typedef version_1_2_7 Your_png_h_is_not_version_1_2_7;
00017 
00018 /* Version information for C files.  This had better match the version
00019  * string defined in png.h.  */
00020 
00021 #ifdef PNG_USE_GLOBAL_ARRAYS
00022 /* png_libpng_ver was changed to a function in version 1.0.5c */
00023 const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
00024 
00025 /* png_sig was changed to a function in version 1.0.5c */
00026 /* Place to hold the signature string for a PNG file. */
00027 const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
00028 
00029 /* Invoke global declarations for constant strings for known chunk types */
00030 PNG_IHDR;
00031 PNG_IDAT;
00032 PNG_IEND;
00033 PNG_PLTE;
00034 PNG_bKGD;
00035 PNG_cHRM;
00036 PNG_gAMA;
00037 PNG_hIST;
00038 PNG_iCCP;
00039 PNG_iTXt;
00040 PNG_oFFs;
00041 PNG_pCAL;
00042 PNG_sCAL;
00043 PNG_pHYs;
00044 PNG_sBIT;
00045 PNG_sPLT;
00046 PNG_sRGB;
00047 PNG_tEXt;
00048 PNG_tIME;
00049 PNG_tRNS;
00050 PNG_zTXt;
00051 
00052 /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
00053 
00054 /* start of interlace block */
00055 const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
00056 
00057 /* offset to next interlace block */
00058 const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
00059 
00060 /* start of interlace block in the y direction */
00061 const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
00062 
00063 /* offset to next interlace block in the y direction */
00064 const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
00065 
00066 /* width of interlace block (used in assembler routines only) */
00067 #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
00068 const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
00069 #endif
00070 
00071 /* Height of interlace block.  This is not currently used - if you need
00072  * it, uncomment it here and in png.h
00073 const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
00074 */
00075 
00076 /* Mask to determine which pixels are valid in a pass */
00077 const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
00078 
00079 /* Mask to determine which pixels to overwrite while displaying */
00080 const int FARDATA png_pass_dsp_mask[]
00081    = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
00082 
00083 #endif
00084 
00085 /* Tells libpng that we have already handled the first "num_bytes" bytes
00086  * of the PNG file signature.  If the PNG data is embedded into another
00087  * stream we can set num_bytes = 8 so that libpng will not attempt to read
00088  * or write any of the magic bytes before it starts on the IHDR.
00089  */
00090 
00091 void PNGAPI
00092 png_set_sig_bytes(png_structp png_ptr, int num_bytes)
00093 {
00094    png_debug(1, "in png_set_sig_bytes\n");
00095    if (num_bytes > 8)
00096       png_error(png_ptr, "Too many bytes for PNG signature.");
00097 
00098    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
00099 }
00100 
00101 /* Checks whether the supplied bytes match the PNG signature.  We allow
00102  * checking less than the full 8-byte signature so that those apps that
00103  * already read the first few bytes of a file to determine the file type
00104  * can simply check the remaining bytes for extra assurance.  Returns
00105  * an integer less than, equal to, or greater than zero if sig is found,
00106  * respectively, to be less than, to match, or be greater than the correct
00107  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
00108  */
00109 int PNGAPI
00110 png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
00111 {
00112    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
00113    if (num_to_check > 8)
00114       num_to_check = 8;
00115    else if (num_to_check < 1)
00116       return (0);
00117 
00118    if (start > 7)
00119       return (0);
00120 
00121    if (start + num_to_check > 8)
00122       num_to_check = 8 - start;
00123 
00124    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
00125 }
00126 
00127 /* (Obsolete) function to check signature bytes.  It does not allow one
00128  * to check a partial signature.  This function might be removed in the
00129  * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
00130  */
00131 int PNGAPI
00132 png_check_sig(png_bytep sig, int num)
00133 {
00134   return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
00135 }
00136 
00137 /* Function to allocate memory for zlib and clear it to 0. */
00138 #ifdef PNG_1_0_X
00139 voidpf PNGAPI
00140 #else
00141 voidpf /* private */
00142 #endif
00143 png_zalloc(voidpf png_ptr, uInt items, uInt size)
00144 {
00145    png_voidp ptr;
00146    png_structp p=png_ptr;
00147    png_uint_32 save_flags=p->flags;
00148    png_uint_32 num_bytes;
00149 
00150    if (items > PNG_UINT_32_MAX/size)
00151    {
00152      png_warning (png_ptr, "Potential overflow in png_zalloc()");
00153      return (NULL);
00154    }
00155    num_bytes = (png_uint_32)items * size;
00156 
00157    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
00158    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
00159    p->flags=save_flags;
00160 
00161 #if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
00162    if (ptr == NULL)
00163        return ((voidpf)ptr);
00164 
00165    if (num_bytes > (png_uint_32)0x8000L)
00166    {
00167       png_memset(ptr, 0, (png_size_t)0x8000L);
00168       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
00169          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
00170    }
00171    else
00172    {
00173       png_memset(ptr, 0, (png_size_t)num_bytes);
00174    }
00175 #endif
00176    return ((voidpf)ptr);
00177 }
00178 
00179 /* function to free memory for zlib */
00180 #ifdef PNG_1_0_X
00181 void PNGAPI
00182 #else
00183 void /* private */
00184 #endif
00185 png_zfree(voidpf png_ptr, voidpf ptr)
00186 {
00187    png_free((png_structp)png_ptr, (png_voidp)ptr);
00188 }
00189 
00190 /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
00191  * in case CRC is > 32 bits to leave the top bits 0.
00192  */
00193 void /* PRIVATE */
00194 png_reset_crc(png_structp png_ptr)
00195 {
00196    png_ptr->crc = crc32(0, Z_NULL, 0);
00197 }
00198 
00199 /* Calculate the CRC over a section of data.  We can only pass as
00200  * much data to this routine as the largest single buffer size.  We
00201  * also check that this data will actually be used before going to the
00202  * trouble of calculating it.
00203  */
00204 void /* PRIVATE */
00205 png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
00206 {
00207    int need_crc = 1;
00208 
00209    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
00210    {
00211       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
00212           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
00213          need_crc = 0;
00214    }
00215    else                                                    /* critical */
00216    {
00217       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
00218          need_crc = 0;
00219    }
00220 
00221    if (need_crc)
00222       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
00223 }
00224 
00225 /* Allocate the memory for an info_struct for the application.  We don't
00226  * really need the png_ptr, but it could potentially be useful in the
00227  * future.  This should be used in favour of malloc(png_sizeof(png_info))
00228  * and png_info_init() so that applications that want to use a shared
00229  * libpng don't have to be recompiled if png_info changes size.
00230  */
00231 png_infop PNGAPI
00232 png_create_info_struct(png_structp png_ptr)
00233 {
00234    png_infop info_ptr;
00235 
00236    png_debug(1, "in png_create_info_struct\n");
00237    if(png_ptr == NULL) return (NULL);
00238 #ifdef PNG_USER_MEM_SUPPORTED
00239    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
00240       png_ptr->malloc_fn, png_ptr->mem_ptr);
00241 #else
00242    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
00243 #endif
00244    if (info_ptr != NULL)
00245       png_info_init_3(&info_ptr, png_sizeof(png_info));
00246 
00247    return (info_ptr);
00248 }
00249 
00250 /* This function frees the memory associated with a single info struct.
00251  * Normally, one would use either png_destroy_read_struct() or
00252  * png_destroy_write_struct() to free an info struct, but this may be
00253  * useful for some applications.
00254  */
00255 void PNGAPI
00256 png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
00257 {
00258    png_infop info_ptr = NULL;
00259 
00260    png_debug(1, "in png_destroy_info_struct\n");
00261    if (info_ptr_ptr != NULL)
00262       info_ptr = *info_ptr_ptr;
00263 
00264    if (info_ptr != NULL)
00265    {
00266       png_info_destroy(png_ptr, info_ptr);
00267 
00268 #ifdef PNG_USER_MEM_SUPPORTED
00269       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
00270           png_ptr->mem_ptr);
00271 #else
00272       png_destroy_struct((png_voidp)info_ptr);
00273 #endif
00274       *info_ptr_ptr = NULL;
00275    }
00276 }
00277 
00278 /* Initialize the info structure.  This is now an internal function (0.89)
00279  * and applications using it are urged to use png_create_info_struct()
00280  * instead.
00281  */
00282 #undef png_info_init
00283 void PNGAPI
00284 png_info_init(png_infop info_ptr)
00285 {
00286    /* We only come here via pre-1.0.12-compiled applications */
00287    png_info_init_3(&info_ptr, 0);
00288 }
00289 
00290 void PNGAPI
00291 png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
00292 {
00293    png_infop info_ptr = *ptr_ptr;
00294 
00295    png_debug(1, "in png_info_init_3\n");
00296 
00297    if(png_sizeof(png_info) > png_info_struct_size)
00298      {
00299        png_destroy_struct(info_ptr);
00300        info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
00301        *ptr_ptr = info_ptr;
00302      }
00303 
00304    /* set everything to 0 */
00305    png_memset(info_ptr, 0, png_sizeof (png_info));
00306 }
00307 
00308 #ifdef PNG_FREE_ME_SUPPORTED
00309 void PNGAPI
00310 png_data_freer(png_structp png_ptr, png_infop info_ptr,
00311    int freer, png_uint_32 mask)
00312 {
00313    png_debug(1, "in png_data_freer\n");
00314    if (png_ptr == NULL || info_ptr == NULL)
00315       return;
00316    if(freer == PNG_DESTROY_WILL_FREE_DATA)
00317       info_ptr->free_me |= mask;
00318    else if(freer == PNG_USER_WILL_FREE_DATA)
00319       info_ptr->free_me &= ~mask;
00320    else
00321       png_warning(png_ptr,
00322          "Unknown freer parameter in png_data_freer.");
00323 }
00324 #endif
00325 
00326 void PNGAPI
00327 png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
00328    int num)
00329 {
00330    png_debug(1, "in png_free_data\n");
00331    if (png_ptr == NULL || info_ptr == NULL)
00332       return;
00333 
00334 #if defined(PNG_TEXT_SUPPORTED)
00335 /* free text item num or (if num == -1) all text items */
00336 #ifdef PNG_FREE_ME_SUPPORTED
00337 if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
00338 #else
00339 if (mask & PNG_FREE_TEXT)
00340 #endif
00341 {
00342    if (num != -1)
00343    {
00344      if (info_ptr->text && info_ptr->text[num].key)
00345      {
00346          png_free(png_ptr, info_ptr->text[num].key);
00347          info_ptr->text[num].key = NULL;
00348      }
00349    }
00350    else
00351    {
00352        int i;
00353        for (i = 0; i < info_ptr->num_text; i++)
00354            png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
00355        png_free(png_ptr, info_ptr->text);
00356        info_ptr->text = NULL;
00357        info_ptr->num_text=0;
00358    }
00359 }
00360 #endif
00361 
00362 #if defined(PNG_tRNS_SUPPORTED)
00363 /* free any tRNS entry */
00364 #ifdef PNG_FREE_ME_SUPPORTED
00365 if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
00366 #else
00367 if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
00368 #endif
00369 {
00370     png_free(png_ptr, info_ptr->trans);
00371     info_ptr->valid &= ~PNG_INFO_tRNS;
00372 #ifndef PNG_FREE_ME_SUPPORTED
00373     png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
00374 #endif
00375     info_ptr->trans = NULL;
00376 }
00377 #endif
00378 
00379 #if defined(PNG_sCAL_SUPPORTED)
00380 /* free any sCAL entry */
00381 #ifdef PNG_FREE_ME_SUPPORTED
00382 if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
00383 #else
00384 if (mask & PNG_FREE_SCAL)
00385 #endif
00386 {
00387 #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
00388     png_free(png_ptr, info_ptr->scal_s_width);
00389     png_free(png_ptr, info_ptr->scal_s_height);
00390     info_ptr->scal_s_width = NULL;
00391     info_ptr->scal_s_height = NULL;
00392 #endif
00393     info_ptr->valid &= ~PNG_INFO_sCAL;
00394 }
00395 #endif
00396 
00397 #if defined(PNG_pCAL_SUPPORTED)
00398 /* free any pCAL entry */
00399 #ifdef PNG_FREE_ME_SUPPORTED
00400 if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
00401 #else
00402 if (mask & PNG_FREE_PCAL)
00403 #endif
00404 {
00405     png_free(png_ptr, info_ptr->pcal_purpose);
00406     png_free(png_ptr, info_ptr->pcal_units);
00407     info_ptr->pcal_purpose = NULL;
00408     info_ptr->pcal_units = NULL;
00409     if (info_ptr->pcal_params != NULL)
00410     {
00411         int i;
00412         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
00413         {
00414           png_free(png_ptr, info_ptr->pcal_params[i]);
00415           info_ptr->pcal_params[i]=NULL;
00416         }
00417         png_free(png_ptr, info_ptr->pcal_params);
00418         info_ptr->pcal_params = NULL;
00419     }
00420     info_ptr->valid &= ~PNG_INFO_pCAL;
00421 }
00422 #endif
00423 
00424 #if defined(PNG_iCCP_SUPPORTED)
00425 /* free any iCCP entry */
00426 #ifdef PNG_FREE_ME_SUPPORTED
00427 if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
00428 #else
00429 if (mask & PNG_FREE_ICCP)
00430 #endif
00431 {
00432     png_free(png_ptr, info_ptr->iccp_name);
00433     png_free(png_ptr, info_ptr->iccp_profile);
00434     info_ptr->iccp_name = NULL;
00435     info_ptr->iccp_profile = NULL;
00436     info_ptr->valid &= ~PNG_INFO_iCCP;
00437 }
00438 #endif
00439 
00440 #if defined(PNG_sPLT_SUPPORTED)
00441 /* free a given sPLT entry, or (if num == -1) all sPLT entries */
00442 #ifdef PNG_FREE_ME_SUPPORTED
00443 if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
00444 #else
00445 if (mask & PNG_FREE_SPLT)
00446 #endif
00447 {
00448    if (num != -1)
00449    {
00450       if(info_ptr->splt_palettes)
00451       {
00452           png_free(png_ptr, info_ptr->splt_palettes[num].name);
00453           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
00454           info_ptr->splt_palettes[num].name = NULL;
00455           info_ptr->splt_palettes[num].entries = NULL;
00456       }
00457    }
00458    else
00459    {
00460        if(info_ptr->splt_palettes_num)
00461        {
00462          int i;
00463          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
00464             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
00465 
00466          png_free(png_ptr, info_ptr->splt_palettes);
00467          info_ptr->splt_palettes = NULL;
00468          info_ptr->splt_palettes_num = 0;
00469        }
00470        info_ptr->valid &= ~PNG_INFO_sPLT;
00471    }
00472 }
00473 #endif
00474 
00475 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
00476 #ifdef PNG_FREE_ME_SUPPORTED
00477 if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
00478 #else
00479 if (mask & PNG_FREE_UNKN)
00480 #endif
00481 {
00482    if (num != -1)
00483    {
00484        if(info_ptr->unknown_chunks)
00485        {
00486           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
00487           info_ptr->unknown_chunks[num].data = NULL;
00488        }
00489    }
00490    else
00491    {
00492        int i;
00493 
00494        if(info_ptr->unknown_chunks_num)
00495        {
00496          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
00497             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
00498 
00499          png_free(png_ptr, info_ptr->unknown_chunks);
00500          info_ptr->unknown_chunks = NULL;
00501          info_ptr->unknown_chunks_num = 0;
00502        }
00503    }
00504 }
00505 #endif
00506 
00507 #if defined(PNG_hIST_SUPPORTED)
00508 /* free any hIST entry */
00509 #ifdef PNG_FREE_ME_SUPPORTED
00510 if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
00511 #else
00512 if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
00513 #endif
00514 {
00515     png_free(png_ptr, info_ptr->hist);
00516     info_ptr->hist = NULL;
00517     info_ptr->valid &= ~PNG_INFO_hIST;
00518 #ifndef PNG_FREE_ME_SUPPORTED
00519     png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
00520 #endif
00521 }
00522 #endif
00523 
00524 /* free any PLTE entry that was internally allocated */
00525 #ifdef PNG_FREE_ME_SUPPORTED
00526 if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
00527 #else
00528 if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
00529 #endif
00530 {
00531     png_zfree(png_ptr, info_ptr->palette);
00532     info_ptr->palette = NULL;
00533     info_ptr->valid &= ~PNG_INFO_PLTE;
00534 #ifndef PNG_FREE_ME_SUPPORTED
00535     png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
00536 #endif
00537     info_ptr->num_palette = 0;
00538 }
00539 
00540 #if defined(PNG_INFO_IMAGE_SUPPORTED)
00541 /* free any image bits attached to the info structure */
00542 #ifdef PNG_FREE_ME_SUPPORTED
00543 if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
00544 #else
00545 if (mask & PNG_FREE_ROWS)
00546 #endif
00547 {
00548     if(info_ptr->row_pointers)
00549     {
00550        int row;
00551        for (row = 0; row < (int)info_ptr->height; row++)
00552        {
00553           png_free(png_ptr, info_ptr->row_pointers[row]);
00554           info_ptr->row_pointers[row]=NULL;
00555        }
00556        png_free(png_ptr, info_ptr->row_pointers);
00557        info_ptr->row_pointers=NULL;
00558     }
00559     info_ptr->valid &= ~PNG_INFO_IDAT;
00560 }
00561 #endif
00562 
00563 #ifdef PNG_FREE_ME_SUPPORTED
00564    if(num == -1)
00565      info_ptr->free_me &= ~mask;
00566    else
00567      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
00568 #endif
00569 }
00570 
00571 /* This is an internal routine to free any memory that the info struct is
00572  * pointing to before re-using it or freeing the struct itself.  Recall
00573  * that png_free() checks for NULL pointers for us.
00574  */
00575 void /* PRIVATE */
00576 png_info_destroy(png_structp png_ptr, png_infop info_ptr)
00577 {
00578    png_debug(1, "in png_info_destroy\n");
00579 
00580    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
00581 
00582 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
00583    if (png_ptr->num_chunk_list)
00584    {
00585        png_free(png_ptr, png_ptr->chunk_list);
00586        png_ptr->chunk_list=NULL;
00587        png_ptr->num_chunk_list=0;
00588    }
00589 #endif
00590 
00591    png_info_init_3(&info_ptr, png_sizeof(png_info));
00592 }
00593 
00594 /* This function returns a pointer to the io_ptr associated with the user
00595  * functions.  The application should free any memory associated with this
00596  * pointer before png_write_destroy() or png_read_destroy() are called.
00597  */
00598 png_voidp PNGAPI
00599 png_get_io_ptr(png_structp png_ptr)
00600 {
00601    return (png_ptr->io_ptr);
00602 }
00603 
00604 #if !defined(PNG_NO_STDIO)
00605 /* Initialize the default input/output functions for the PNG file.  If you
00606  * use your own read or write routines, you can call either png_set_read_fn()
00607  * or png_set_write_fn() instead of png_init_io().  If you have defined
00608  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
00609  * necessarily available.
00610  */
00611 void PNGAPI
00612 png_init_io(png_structp png_ptr, png_FILE_p fp)
00613 {
00614    png_debug(1, "in png_init_io\n");
00615    png_ptr->io_ptr = (png_voidp)fp;
00616 }
00617 #endif
00618 
00619 #if defined(PNG_TIME_RFC1123_SUPPORTED)
00620 /* Convert the supplied time into an RFC 1123 string suitable for use in
00621  * a "Creation Time" or other text-based time string.
00622  */
00623 png_charp PNGAPI
00624 png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
00625 {
00626    static PNG_CONST char short_months[12][4] =
00627         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
00628          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
00629 
00630    if (png_ptr->time_buffer == NULL)
00631    {
00632       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
00633          png_sizeof(char)));
00634    }
00635 
00636 #if defined(_WIN32_WCE)
00637    {
00638       wchar_t time_buf[29];
00639       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
00640           ptime->day % 32, short_months[(ptime->month - 1) % 12],
00641         ptime->year, ptime->hour % 24, ptime->minute % 60,
00642           ptime->second % 61);
00643       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
00644           NULL, NULL);
00645    }
00646 #else
00647 #ifdef USE_FAR_KEYWORD
00648    {
00649       char near_time_buf[29];
00650       sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
00651           ptime->day % 32, short_months[(ptime->month - 1) % 12],
00652           ptime->year, ptime->hour % 24, ptime->minute % 60,
00653           ptime->second % 61);
00654       png_memcpy(png_ptr->time_buffer, near_time_buf,
00655           29*png_sizeof(char));
00656    }
00657 #else
00658    sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
00659        ptime->day % 32, short_months[(ptime->month - 1) % 12],
00660        ptime->year, ptime->hour % 24, ptime->minute % 60,
00661        ptime->second % 61);
00662 #endif
00663 #endif /* _WIN32_WCE */
00664    return ((png_charp)png_ptr->time_buffer);
00665 }
00666 #endif /* PNG_TIME_RFC1123_SUPPORTED */
00667 
00668 #if 0
00669 /* Signature string for a PNG file. */
00670 png_bytep PNGAPI
00671 png_sig_bytes(void)
00672 {
00673    return ((png_bytep)"\211\120\116\107\015\012\032\012");
00674 }
00675 #endif
00676 
00677 png_charp PNGAPI
00678 png_get_copyright(png_structp png_ptr)
00679 {
00680    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
00681    return ((png_charp) "\n libpng version 1.2.7 - September 12, 2004\n\
00682    Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\
00683    Copyright (c) 1996-1997 Andreas Dilger\n\
00684    Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
00685    return ((png_charp) "");
00686 }
00687 
00688 /* The following return the library version as a short string in the
00689  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
00690  * used with your application, print out PNG_LIBPNG_VER_STRING, which
00691  * is defined in png.h.
00692  * Note: now there is no difference between png_get_libpng_ver() and
00693  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
00694  * it is guaranteed that png.c uses the correct version of png.h.
00695  */
00696 png_charp PNGAPI
00697 png_get_libpng_ver(png_structp png_ptr)
00698 {
00699    /* Version of *.c files used when building libpng */
00700    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
00701       return ((png_charp) PNG_LIBPNG_VER_STRING);
00702    return ((png_charp) "");
00703 }
00704 
00705 png_charp PNGAPI
00706 png_get_header_ver(png_structp png_ptr)
00707 {
00708    /* Version of *.h files used when building libpng */
00709    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
00710       return ((png_charp) PNG_LIBPNG_VER_STRING);
00711    return ((png_charp) "");
00712 }
00713 
00714 png_charp PNGAPI
00715 png_get_header_version(png_structp png_ptr)
00716 {
00717    /* Returns longer string containing both version and date */
00718    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
00719       return ((png_charp) PNG_HEADER_VERSION_STRING);
00720    return ((png_charp) "");
00721 }
00722 
00723 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
00724 int PNGAPI
00725 png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
00726 {
00727    /* check chunk_name and return "keep" value if it's on the list, else 0 */
00728    int i;
00729    png_bytep p;
00730    if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
00731       return 0;
00732    p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
00733    for (i = png_ptr->num_chunk_list; i; i--, p-=5)
00734       if (!png_memcmp(chunk_name, p, 4))
00735         return ((int)*(p+4));
00736    return 0;
00737 }
00738 #endif
00739 
00740 /* This function, added to libpng-1.0.6g, is untested. */
00741 int PNGAPI
00742 png_reset_zstream(png_structp png_ptr)
00743 {
00744    return (inflateReset(&png_ptr->zstream));
00745 }
00746 
00747 /* This function was added to libpng-1.0.7 */
00748 png_uint_32 PNGAPI
00749 png_access_version_number(void)
00750 {
00751    /* Version of *.c files used when building libpng */
00752    return((png_uint_32) PNG_LIBPNG_VER);
00753 }
00754 
00755 
00756 #if !defined(PNG_1_0_X)
00757 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
00758     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
00759 /* this INTERNAL function was added to libpng 1.2.0 */
00760 void /* PRIVATE */
00761 png_init_mmx_flags (png_structp png_ptr)
00762 {
00763     png_ptr->mmx_rowbytes_threshold = 0;
00764     png_ptr->mmx_bitdepth_threshold = 0;
00765 
00766 #  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
00767 
00768     png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
00769 
00770     if (png_mmx_support() > 0) {
00771         png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
00772 #    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
00773                               | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
00774 #    endif
00775 #    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
00776                               | PNG_ASM_FLAG_MMX_READ_INTERLACE
00777 #    endif
00778 #    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
00779                               ;
00780 #    else
00781                               | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
00782                               | PNG_ASM_FLAG_MMX_READ_FILTER_UP
00783                               | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
00784                               | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
00785 
00786         png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
00787         png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
00788 #    endif
00789     } else {
00790         png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
00791                                | PNG_MMX_READ_FLAGS
00792                                | PNG_MMX_WRITE_FLAGS );
00793     }
00794 
00795 #  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
00796 
00797     /* clear all MMX flags; no support is compiled in */
00798     png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
00799 
00800 #  endif /* ?(PNGVCRD || PNGGCCRD) */
00801 }
00802 
00803 #endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */
00804 
00805 /* this function was added to libpng 1.2.0 */
00806 #if !defined(PNG_USE_PNGGCCRD) && \
00807     !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
00808 int PNGAPI
00809 png_mmx_support(void)
00810 {
00811     return -1;
00812 }
00813 #endif
00814 #endif /* PNG_1_0_X */
00815 
00816 #ifdef PNG_SIZE_T
00817 /* Added at libpng version 1.2.6 */
00818    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
00819 png_size_t PNGAPI
00820 png_convert_size(size_t size)
00821 {
00822   if (size > (png_size_t)-1)
00823      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
00824   return ((png_size_t)size);
00825 }
00826 #endif /* PNG_SIZE_T */