Back to index

plt-scheme  4.2.1
Defines | Typedefs | Functions | Variables
png.c File Reference
#include "png.h"

Go to the source code of this file.

Defines

#define PNG_INTERNAL
#define PNG_NO_EXTERN

Typedefs

typedef version_1_2_5 Your_png_h_is_not_version_1_2_5

Functions

void PNGAPI png_set_sig_bytes (png_structp png_ptr, int num_bytes)
int PNGAPI png_sig_cmp (png_bytep sig, png_size_t start, png_size_t num_to_check)
int PNGAPI png_check_sig (png_bytep sig, int num)
voidpf png_zalloc (voidpf png_ptr, uInt items, uInt size)
void png_zfree (voidpf png_ptr, voidpf ptr)
void png_reset_crc (png_structp png_ptr)
void png_calculate_crc (png_structp png_ptr, png_bytep ptr, png_size_t length)
png_infop PNGAPI png_create_info_struct (png_structp png_ptr)
void PNGAPI png_destroy_info_struct (png_structp png_ptr, png_infopp info_ptr_ptr)
void PNGAPI png_info_init (png_infop info_ptr)
void PNGAPI png_info_init_3 (png_infopp ptr_ptr, png_size_t png_info_struct_size)
void PNGAPI png_data_freer (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)
void PNGAPI png_free_data (png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num)
void png_info_destroy (png_structp png_ptr, png_infop info_ptr)
png_voidp PNGAPI png_get_io_ptr (png_structp png_ptr)
void PNGAPI png_init_io (png_structp png_ptr, png_FILE_p fp)
png_charp PNGAPI png_convert_to_rfc1123 (png_structp png_ptr, png_timep ptime)
png_charp PNGAPI png_get_copyright (png_structp png_ptr)
png_charp PNGAPI png_get_libpng_ver (png_structp png_ptr)
png_charp PNGAPI png_get_header_ver (png_structp png_ptr)
png_charp PNGAPI png_get_header_version (png_structp png_ptr)
int PNGAPI png_handle_as_unknown (png_structp png_ptr, png_bytep chunk_name)
int PNGAPI png_reset_zstream (png_structp png_ptr)
png_uint_32 PNGAPI png_access_version_number (void)
void png_init_mmx_flags (png_structp png_ptr)
int PNGAPI png_mmx_support (void)

Variables

const char png_libpng_ver [18] = "1.2.5"
const png_byte FARDATA png_sig [8] = {137, 80, 78, 71, 13, 10, 26, 10}
 PNG_IHDR
 PNG_IDAT
 PNG_IEND
 PNG_PLTE
 PNG_bKGD
 PNG_cHRM
 PNG_gAMA
 PNG_hIST
 PNG_iCCP
 PNG_iTXt
 PNG_oFFs
 PNG_pCAL
 PNG_sCAL
 PNG_pHYs
 PNG_sBIT
 PNG_sPLT
 PNG_sRGB
 PNG_tEXt
 PNG_tIME
 PNG_tRNS
 PNG_zTXt
const int FARDATA png_pass_start [] = {0, 4, 0, 2, 0, 1, 0}
const int FARDATA png_pass_inc [] = {8, 8, 4, 4, 2, 2, 1}
const int FARDATA png_pass_ystart [] = {0, 0, 4, 0, 2, 0, 1}
const int FARDATA png_pass_yinc [] = {8, 8, 8, 4, 4, 2, 2}
const int FARDATA png_pass_mask [] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}
const int FARDATA png_pass_dsp_mask [] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}

Define Documentation

#define PNG_INTERNAL

Definition at line 11 of file png.c.

#define PNG_NO_EXTERN

Definition at line 12 of file png.c.


Typedef Documentation

Definition at line 16 of file png.c.


Function Documentation

Definition at line 740 of file png.c.

{
   /* Version of *.c files used when building libpng */
   return((png_uint_32) 10205L);
}

Here is the caller graph for this function:

void png_calculate_crc ( png_structp  png_ptr,
png_bytep  ptr,
png_size_t  length 
)

Definition at line 198 of file png.c.

{
   int need_crc = 1;

   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
   {
      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
         need_crc = 0;
   }
   else                                                    /* critical */
   {
      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
         need_crc = 0;
   }

   if (need_crc)
      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PNGAPI png_check_sig ( png_bytep  sig,
int  num 
)

Definition at line 132 of file png.c.

{
  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
}

Here is the call graph for this function:

Definition at line 617 of file png.c.

{
   static PNG_CONST char short_months[12][4] =
        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

   if (png_ptr->time_buffer == NULL)
   {
      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
         sizeof(char)));
   }

#if defined(_WIN32_WCE)
   {
      wchar_t time_buf[29];
      wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
          ptime->day % 32, short_months[(ptime->month - 1) % 12],
        ptime->year, ptime->hour % 24, ptime->minute % 60,
          ptime->second % 61);
      WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
          NULL, NULL);
   }
#else
#ifdef USE_FAR_KEYWORD
   {
      char near_time_buf[29];
      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
          ptime->day % 32, short_months[(ptime->month - 1) % 12],
          ptime->year, ptime->hour % 24, ptime->minute % 60,
          ptime->second % 61);
      png_memcpy(png_ptr->time_buffer, near_time_buf,
          29*sizeof(char));
   }
#else
   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
       ptime->day % 32, short_months[(ptime->month - 1) % 12],
       ptime->year, ptime->hour % 24, ptime->minute % 60,
       ptime->second % 61);
#endif
#endif /* _WIN32_WCE */
   return ((png_charp)png_ptr->time_buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 225 of file png.c.

{
   png_infop info_ptr;

   png_debug(1, "in png_create_info_struct\n");
   if(png_ptr == NULL) return (NULL);
#ifdef PNG_USER_MEM_SUPPORTED
   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
      png_ptr->malloc_fn, png_ptr->mem_ptr);
#else
   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
#endif
   if (info_ptr != NULL)
      png_info_init_3(&info_ptr, sizeof(png_info));

   return (info_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PNGAPI png_data_freer ( png_structp  png_ptr,
png_infop  info_ptr,
int  freer,
png_uint_32  mask 
)

Definition at line 303 of file png.c.

{
   png_debug(1, "in png_data_freer\n");
   if (png_ptr == NULL || info_ptr == NULL)
      return;
   if(freer == PNG_DESTROY_WILL_FREE_DATA)
      info_ptr->free_me |= mask;
   else if(freer == PNG_USER_WILL_FREE_DATA)
      info_ptr->free_me &= ~mask;
   else
      png_warning(png_ptr,
         "Unknown freer parameter in png_data_freer.");
}

Here is the call graph for this function:

void PNGAPI png_destroy_info_struct ( png_structp  png_ptr,
png_infopp  info_ptr_ptr 
)

Definition at line 249 of file png.c.

{
   png_infop info_ptr = NULL;

   png_debug(1, "in png_destroy_info_struct\n");
   if (info_ptr_ptr != NULL)
      info_ptr = *info_ptr_ptr;

   if (info_ptr != NULL)
   {
      png_info_destroy(png_ptr, info_ptr);

#ifdef PNG_USER_MEM_SUPPORTED
      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
          png_ptr->mem_ptr);
#else
      png_destroy_struct((png_voidp)info_ptr);
#endif
      *info_ptr_ptr = NULL;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PNGAPI png_free_data ( png_structp  png_ptr,
png_infop  info_ptr,
png_uint_32  mask,
int  num 
)

Definition at line 320 of file png.c.

{
   png_debug(1, "in png_free_data\n");
   if (png_ptr == NULL || info_ptr == NULL)
      return;

#if defined(PNG_TEXT_SUPPORTED)
/* free text item num or (if num == -1) all text items */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
#else
if (mask & PNG_FREE_TEXT)
#endif
{
   if (num != -1)
   {
     if (info_ptr->text && info_ptr->text[num].key)
     {
         png_free(png_ptr, info_ptr->text[num].key);
         info_ptr->text[num].key = NULL;
     }
   }
   else
   {
       int i;
       for (i = 0; i < info_ptr->num_text; i++)
           png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
       png_free(png_ptr, info_ptr->text);
       info_ptr->text = NULL;
       info_ptr->num_text=0;
   }
}
#endif

#if defined(PNG_tRNS_SUPPORTED)
/* free any tRNS entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
#else
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
#endif
{
    png_free(png_ptr, info_ptr->trans);
    info_ptr->valid &= ~PNG_INFO_tRNS;
#ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
#endif
    info_ptr->trans = NULL;
}
#endif

#if defined(PNG_sCAL_SUPPORTED)
/* free any sCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
#else
if (mask & PNG_FREE_SCAL)
#endif
{
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
    png_free(png_ptr, info_ptr->scal_s_width);
    png_free(png_ptr, info_ptr->scal_s_height);
    info_ptr->scal_s_width = NULL;
    info_ptr->scal_s_height = NULL;
#endif
    info_ptr->valid &= ~PNG_INFO_sCAL;
}
#endif

#if defined(PNG_pCAL_SUPPORTED)
/* free any pCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
#else
if (mask & PNG_FREE_PCAL)
#endif
{
    png_free(png_ptr, info_ptr->pcal_purpose);
    png_free(png_ptr, info_ptr->pcal_units);
    info_ptr->pcal_purpose = NULL;
    info_ptr->pcal_units = NULL;
    if (info_ptr->pcal_params != NULL)
    {
        int i;
        for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
        {
          png_free(png_ptr, info_ptr->pcal_params[i]);
          info_ptr->pcal_params[i]=NULL;
        }
        png_free(png_ptr, info_ptr->pcal_params);
        info_ptr->pcal_params = NULL;
    }
    info_ptr->valid &= ~PNG_INFO_pCAL;
}
#endif

#if defined(PNG_iCCP_SUPPORTED)
/* free any iCCP entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
#else
if (mask & PNG_FREE_ICCP)
#endif
{
    png_free(png_ptr, info_ptr->iccp_name);
    png_free(png_ptr, info_ptr->iccp_profile);
    info_ptr->iccp_name = NULL;
    info_ptr->iccp_profile = NULL;
    info_ptr->valid &= ~PNG_INFO_iCCP;
}
#endif

#if defined(PNG_sPLT_SUPPORTED)
/* free a given sPLT entry, or (if num == -1) all sPLT entries */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
#else
if (mask & PNG_FREE_SPLT)
#endif
{
   if (num != -1)
   {
      if(info_ptr->splt_palettes)
      {
          png_free(png_ptr, info_ptr->splt_palettes[num].name);
          png_free(png_ptr, info_ptr->splt_palettes[num].entries);
          info_ptr->splt_palettes[num].name = NULL;
          info_ptr->splt_palettes[num].entries = NULL;
      }
   }
   else
   {
       if(info_ptr->splt_palettes_num)
       {
         int i;
         for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
            png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);

         png_free(png_ptr, info_ptr->splt_palettes);
         info_ptr->splt_palettes = NULL;
         info_ptr->splt_palettes_num = 0;
       }
       info_ptr->valid &= ~PNG_INFO_sPLT;
   }
}
#endif

#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
#else
if (mask & PNG_FREE_UNKN)
#endif
{
   if (num != -1)
   {
       if(info_ptr->unknown_chunks)
       {
          png_free(png_ptr, info_ptr->unknown_chunks[num].data);
          info_ptr->unknown_chunks[num].data = NULL;
       }
   }
   else
   {
       int i;

       if(info_ptr->unknown_chunks_num)
       {
         for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
            png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);

         png_free(png_ptr, info_ptr->unknown_chunks);
         info_ptr->unknown_chunks = NULL;
         info_ptr->unknown_chunks_num = 0;
       }
   }
}
#endif

#if defined(PNG_hIST_SUPPORTED)
/* free any hIST entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
#else
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
#endif
{
    png_free(png_ptr, info_ptr->hist);
    info_ptr->hist = NULL;
    info_ptr->valid &= ~PNG_INFO_hIST;
#ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
#endif
}
#endif

/* free any PLTE entry that was internally allocated */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
#else
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
#endif
{
    png_zfree(png_ptr, info_ptr->palette);
    info_ptr->palette = NULL;
    info_ptr->valid &= ~PNG_INFO_PLTE;
#ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
#endif
    info_ptr->num_palette = 0;
}

#if defined(PNG_INFO_IMAGE_SUPPORTED)
/* free any image bits attached to the info structure */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
#else
if (mask & PNG_FREE_ROWS)
#endif
{
    if(info_ptr->row_pointers)
    {
       int row;
       for (row = 0; row < (int)info_ptr->height; row++)
       {
          png_free(png_ptr, info_ptr->row_pointers[row]);
          info_ptr->row_pointers[row]=NULL;
       }
       png_free(png_ptr, info_ptr->row_pointers);
       info_ptr->row_pointers=NULL;
    }
    info_ptr->valid &= ~PNG_INFO_IDAT;
}
#endif

#ifdef PNG_FREE_ME_SUPPORTED
   if(num == -1)
     info_ptr->free_me &= ~mask;
   else
     info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 671 of file png.c.

{
   if (png_ptr != NULL || png_ptr == NULL)  /* silence compiler warning */
   return ((png_charp) "\n libpng version 1.2.5 - October 3, 2002\n\
   Copyright (c) 1998-2002 Glenn Randers-Pehrson\n\
   Copyright (c) 1996-1997 Andreas Dilger\n\
   Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
   return ((png_charp) "");
}

Here is the caller graph for this function:

Definition at line 697 of file png.c.

{
   /* Version of *.h files used when building libpng */
   if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
      return((png_charp) PNG_LIBPNG_VER_STRING);
   return((png_charp) PNG_LIBPNG_VER_STRING);
}

Definition at line 706 of file png.c.

{
   /* Returns longer string containing both version and date */
   if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
      return((png_charp) PNG_HEADER_VERSION_STRING);
   return((png_charp) PNG_HEADER_VERSION_STRING);
}

Here is the caller graph for this function:

Definition at line 592 of file png.c.

{
   return (png_ptr->io_ptr);
}

Definition at line 688 of file png.c.

{
   /* Version of *.c files used when building libpng */
   if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
      return((png_charp) "1.2.5");
   return((png_charp) "1.2.5");
}
int PNGAPI png_handle_as_unknown ( png_structp  png_ptr,
png_bytep  chunk_name 
)

Definition at line 716 of file png.c.

{
   /* check chunk_name and return "keep" value if it's on the list, else 0 */
   int i;
   png_bytep p;
   if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
      return 0;
   p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
   for (i = png_ptr->num_chunk_list; i; i--, p-=5)
      if (!png_memcmp(chunk_name, p, 4))
        return ((int)*(p+4));
   return 0;
}

Here is the caller graph for this function:

void png_info_destroy ( png_structp  png_ptr,
png_infop  info_ptr 
)

Definition at line 569 of file png.c.

{
   png_debug(1, "in png_info_destroy\n");

   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
   if (png_ptr->num_chunk_list)
   {
       png_free(png_ptr, png_ptr->chunk_list);
       png_ptr->chunk_list=NULL;
       png_ptr->num_chunk_list=0;
   }
#endif

   png_info_init_3(&info_ptr, sizeof(png_info));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 277 of file png.c.

{
   /* We only come here via pre-1.0.12-compiled applications */
   png_info_init_3(&info_ptr, 0);
}

Here is the call graph for this function:

void PNGAPI png_info_init_3 ( png_infopp  ptr_ptr,
png_size_t  png_info_struct_size 
)

Definition at line 284 of file png.c.

{
   png_infop info_ptr = *ptr_ptr;

   png_debug(1, "in png_info_init_3\n");

   if(sizeof(png_info) > png_info_struct_size)
     {
       png_destroy_struct(info_ptr);
       info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
       *ptr_ptr = info_ptr;
     }

   /* set everything to 0 */
   png_memset(info_ptr, 0, sizeof (png_info));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PNGAPI png_init_io ( png_structp  png_ptr,
png_FILE_p  fp 
)

Definition at line 605 of file png.c.

{
   png_debug(1, "in png_init_io\n");
   png_ptr->io_ptr = (png_voidp)fp;
}

Here is the caller graph for this function:

Definition at line 752 of file png.c.

{
    png_ptr->mmx_rowbytes_threshold = 0;
    png_ptr->mmx_bitdepth_threshold = 0;

#  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))

    png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;

    if (png_mmx_support() > 0) {
        png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
#    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
                              | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
#    endif
#    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
                              | PNG_ASM_FLAG_MMX_READ_INTERLACE
#    endif
#    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
                              ;
#    else
                              | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
                              | PNG_ASM_FLAG_MMX_READ_FILTER_UP
                              | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
                              | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

        png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
        png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
#    endif
    } else {
        png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
                               | PNG_MMX_READ_FLAGS
                               | PNG_MMX_WRITE_FLAGS );
    }

#  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */

    /* clear all MMX flags; no support is compiled in */
    png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );

#  endif /* ?(PNGVCRD || PNGGCCRD) */
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 800 of file png.c.

{
    return -1;
}

Here is the caller graph for this function:

Definition at line 187 of file png.c.

{
   png_ptr->crc = crc32(0, Z_NULL, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 733 of file png.c.

{
   return (inflateReset(&png_ptr->zstream));
}

Here is the call graph for this function:

void PNGAPI png_set_sig_bytes ( png_structp  png_ptr,
int  num_bytes 
)

Definition at line 92 of file png.c.

{
   png_debug(1, "in png_set_sig_bytes\n");
   if (num_bytes > 8)
      png_error(png_ptr, "Too many bytes for PNG signature.");

   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
}

Here is the call graph for this function:

int PNGAPI png_sig_cmp ( png_bytep  sig,
png_size_t  start,
png_size_t  num_to_check 
)

Definition at line 110 of file png.c.

{
   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
   if (num_to_check > 8)
      num_to_check = 8;
   else if (num_to_check < 1)
      return (0);

   if (start > 7)
      return (0);

   if (start + num_to_check > 8)
      num_to_check = 8 - start;

   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
}

Here is the caller graph for this function:

voidpf png_zalloc ( voidpf  png_ptr,
uInt  items,
uInt  size 
)

Definition at line 143 of file png.c.

{
   png_uint_32 num_bytes = (png_uint_32)items * size;
   png_voidp ptr;
   png_structp p=png_ptr;
   png_uint_32 save_flags=p->flags;

   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
   p->flags=save_flags;

#ifndef PNG_NO_ZALLOC_ZERO
   if (ptr == NULL)
       return ((voidpf)ptr);

   if (num_bytes > (png_uint_32)0x8000L)
   {
      png_memset(ptr, 0, (png_size_t)0x8000L);
      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
         (png_size_t)(num_bytes - (png_uint_32)0x8000L));
   }
   else
   {
      png_memset(ptr, 0, (png_size_t)num_bytes);
   }
#endif
   return ((voidpf)ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void png_zfree ( voidpf  png_ptr,
voidpf  ptr 
)

Definition at line 178 of file png.c.

{
   png_free((png_structp)png_ptr, (png_voidp)ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 34 of file png.c.

Definition at line 35 of file png.c.

Definition at line 36 of file png.c.

Definition at line 37 of file png.c.

Definition at line 38 of file png.c.

Definition at line 31 of file png.c.

Definition at line 32 of file png.c.

Definition at line 30 of file png.c.

Definition at line 39 of file png.c.

const char png_libpng_ver[18] = "1.2.5"

Definition at line 23 of file png.c.

Definition at line 40 of file png.c.

const int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}

Definition at line 81 of file png.c.

const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}

Definition at line 58 of file png.c.

const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}

Definition at line 77 of file png.c.

const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}

Definition at line 55 of file png.c.

const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}

Definition at line 64 of file png.c.

const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}

Definition at line 61 of file png.c.

Definition at line 41 of file png.c.

Definition at line 43 of file png.c.

Definition at line 33 of file png.c.

Definition at line 44 of file png.c.

Definition at line 42 of file png.c.

const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}

Definition at line 27 of file png.c.

Definition at line 45 of file png.c.

Definition at line 46 of file png.c.

Definition at line 47 of file png.c.

Definition at line 48 of file png.c.

Definition at line 49 of file png.c.

Definition at line 50 of file png.c.