www.pudn.com > Image_png.rar > pngset.c

 
/* pngset.c - storage of image information into info struct 
 * 
 * libpng 1.0.1 
 * For conditions of distribution and use, see copyright notice in png.h 
 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. 
 * Copyright (c) 1996, 1997 Andreas Dilger 
 * Copyright (c) 1998, Glenn Randers-Pehrson 
 * March 15, 1998 
 * 
 * The functions here are used during reads to store data from the file 
 * into the info struct, and during writes to store application data 
 * into the info struct for writing into the file.  This abstracts the 
 * info struct and allows us to change the structure in the future. 
 */ 
 
#define PNG_INTERNAL 
#include "png.h" 
 
#if defined(PNG_READ_bKGD_SUPPORTED) || defined(PNG_WRITE_bKGD_SUPPORTED) 
void 
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) 
{ 
   png_debug1(1, "in %s storage function\n", "bKGD"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   png_memcpy(&(info_ptr->background), background, sizeof(png_color_16)); 
   info_ptr->valid |= PNG_INFO_bKGD; 
} 
#endif 
 
#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED) 
void 
png_set_cHRM(png_structp png_ptr, png_infop info_ptr, 
   double white_x, double white_y, double red_x, double red_y, 
   double green_x, double green_y, double blue_x, double blue_y) 
{ 
   png_debug1(1, "in %s storage function\n", "cHRM"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->x_white = (float)white_x; 
   info_ptr->y_white = (float)white_y; 
   info_ptr->x_red   = (float)red_x; 
   info_ptr->y_red   = (float)red_y; 
   info_ptr->x_green = (float)green_x; 
   info_ptr->y_green = (float)green_y; 
   info_ptr->x_blue  = (float)blue_x; 
   info_ptr->y_blue  = (float)blue_y; 
   info_ptr->valid |= PNG_INFO_cHRM; 
} 
#endif 
 
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED) 
void 
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) 
{ 
   png_debug1(1, "in %s storage function\n", "gAMA"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->gamma = (float)file_gamma; 
   info_ptr->valid |= PNG_INFO_gAMA; 
} 
#endif 
 
#if defined(PNG_READ_hIST_SUPPORTED) || defined(PNG_WRITE_hIST_SUPPORTED) 
void 
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) 
{ 
   png_debug1(1, "in %s storage function\n", "hIST"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->hist = hist; 
   info_ptr->valid |= PNG_INFO_hIST; 
} 
#endif 
 
void 
png_set_IHDR(png_structp png_ptr, png_infop info_ptr, 
   png_uint_32 width, png_uint_32 height, int bit_depth, 
   int color_type, int interlace_type, int compression_type, 
   int filter_type) 
{ 
   int rowbytes_per_pixel; 
   png_debug1(1, "in %s storage function\n", "IHDR"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->width = width; 
   info_ptr->height = height; 
   info_ptr->bit_depth = (png_byte)bit_depth; 
   info_ptr->color_type =(png_byte) color_type; 
   info_ptr->compression_type = (png_byte)compression_type; 
   info_ptr->filter_type = (png_byte)filter_type; 
   info_ptr->interlace_type = (png_byte)interlace_type; 
   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 
      info_ptr->channels = 1; 
   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) 
      info_ptr->channels = 3; 
   else 
      info_ptr->channels = 1; 
   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) 
      info_ptr->channels++; 
   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); 
 
   /* check for overflow */ 
   rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3; 
   info_ptr->rowbytes = info_ptr->width * rowbytes_per_pixel; 
   if (( width > (png_uint_32)2147483647L/rowbytes_per_pixel)) 
   { 
      png_warning(png_ptr, 
         "Width too large to process image data; rowbytes will overflow."); 
      info_ptr->rowbytes = (png_size_t)0; 
   } 
} 
 
#if defined(PNG_READ_oFFs_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) 
void 
png_set_oFFs(png_structp png_ptr, png_infop info_ptr, 
   png_uint_32 offset_x, png_uint_32 offset_y, int unit_type) 
{ 
   png_debug1(1, "in %s storage function\n", "oFFs"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->x_offset = offset_x; 
   info_ptr->y_offset = offset_y; 
   info_ptr->offset_unit_type = (png_byte)unit_type; 
   info_ptr->valid |= PNG_INFO_oFFs; 
} 
#endif 
 
#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) 
void 
png_set_pCAL(png_structp png_ptr, png_infop info_ptr, 
   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, 
   png_charp units, png_charpp params) 
{ 
   png_uint_32 length; 
   int i; 
 
   png_debug1(1, "in %s storage function\n", "pCAL"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   length = png_strlen(purpose) + 1; 
   png_debug1(3, "allocating purpose for info (%d bytes)\n", length); 
   info_ptr->pcal_purpose = (png_charp)png_malloc(png_ptr, length); 
   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); 
 
   png_debug(3, "storing X0, X1, type, and nparams in info\n"); 
   info_ptr->pcal_X0 = X0; 
   info_ptr->pcal_X1 = X1; 
   info_ptr->pcal_type = (png_byte)type; 
   info_ptr->pcal_nparams = (png_byte)nparams; 
 
   length = png_strlen(units) + 1; 
   png_debug1(3, "allocating units for info (%d bytes)\n", length); 
   info_ptr->pcal_units = (png_charp)png_malloc(png_ptr, length); 
   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); 
 
   info_ptr->pcal_params = (png_charpp)png_malloc(png_ptr, 
      (png_uint_32)((nparams + 1) * sizeof(png_charp))); 
   info_ptr->pcal_params[nparams] = NULL; 
 
   for (i = 0; i < nparams; i++) 
   { 
      length = png_strlen(params[i]) + 1; 
      png_debug2(3, "allocating parameter %d for info (%d bytes)\n", i, length); 
      info_ptr->pcal_params[i] = (png_charp)png_malloc(png_ptr, length); 
      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); 
   } 
 
   info_ptr->valid |= PNG_INFO_pCAL; 
} 
#endif 
 
#if defined(PNG_READ_pHYs_SUPPORTED) || defined(PNG_WRITE_pHYs_SUPPORTED) 
void 
png_set_pHYs(png_structp png_ptr, png_infop info_ptr, 
   png_uint_32 res_x, png_uint_32 res_y, int unit_type) 
{ 
   png_debug1(1, "in %s storage function\n", "pHYs"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->x_pixels_per_unit = res_x; 
   info_ptr->y_pixels_per_unit = res_y; 
   info_ptr->phys_unit_type = (png_byte)unit_type; 
   info_ptr->valid |= PNG_INFO_pHYs; 
} 
#endif 
 
void 
png_set_PLTE(png_structp png_ptr, png_infop info_ptr, 
   png_colorp palette, int num_palette) 
{ 
   png_debug1(1, "in %s storage function\n", "PLTE"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->palette = palette; 
   info_ptr->num_palette = (png_uint_16)num_palette; 
   info_ptr->valid |= PNG_INFO_PLTE; 
} 
 
#if defined(PNG_READ_sBIT_SUPPORTED) || defined(PNG_WRITE_sBIT_SUPPORTED) 
void 
png_set_sBIT(png_structp png_ptr, png_infop info_ptr, 
   png_color_8p sig_bit) 
{ 
   png_debug1(1, "in %s storage function\n", "sBIT"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   png_memcpy(&(info_ptr->sig_bit), sig_bit, sizeof (png_color_8)); 
   info_ptr->valid |= PNG_INFO_sBIT; 
} 
#endif 
 
#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED) 
void 
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent) 
{ 
   png_debug1(1, "in %s storage function\n", "sRGB"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   info_ptr->srgb_intent = (png_byte)intent; 
   info_ptr->valid |= PNG_INFO_sRGB; 
} 
void 
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, 
   int intent) 
{ 
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED) 
   float file_gamma; 
#endif 
#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED) 
   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; 
#endif 
   png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   png_set_sRGB(png_ptr, info_ptr, intent); 
 
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_WRITE_gAMA_SUPPORTED) 
   file_gamma = (float).45; 
   png_set_gAMA(png_ptr, info_ptr, file_gamma); 
#endif 
 
#if defined(PNG_READ_cHRM_SUPPORTED) || defined(PNG_WRITE_cHRM_SUPPORTED) 
   white_x = (float).3127; 
   white_y = (float).3290; 
   red_x   = (float).64; 
   red_y   = (float).33; 
   green_x = (float).30; 
   green_y = (float).60; 
   blue_x  = (float).15; 
   blue_y  = (float).06; 
 
   png_set_cHRM(png_ptr, info_ptr, 
      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); 
 
#endif 
} 
#endif 
 
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ 
    defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_WRITE_zTXt_SUPPORTED) 
void 
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, 
   int num_text) 
{ 
   int i; 
 
   png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ? 
      "text" : (png_const_charp)png_ptr->chunk_name)); 
 
   if (png_ptr == NULL || info_ptr == NULL || num_text == 0) 
      return; 
 
   /* Make sure we have enough space in the "text" array in info_struct 
    * to hold all of the incoming text_ptr objects. 
    */ 
   if (info_ptr->num_text + num_text > info_ptr->max_text) 
   { 
      if (info_ptr->text != NULL) 
      { 
         png_textp old_text; 
         int old_max; 
 
         old_max = info_ptr->max_text; 
         info_ptr->max_text = info_ptr->num_text + num_text + 8; 
         old_text = info_ptr->text; 
         info_ptr->text = (png_textp)png_malloc(png_ptr, 
            (png_uint_32)(info_ptr->max_text * sizeof (png_text))); 
         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * 
            sizeof(png_text))); 
         png_free(png_ptr, old_text); 
      } 
      else 
      { 
         info_ptr->max_text = num_text + 8; 
         info_ptr->num_text = 0; 
         info_ptr->text = (png_textp)png_malloc(png_ptr, 
            (png_uint_32)(info_ptr->max_text * sizeof (png_text))); 
      } 
      png_debug1(3, "allocated %d entries for info_ptr->text\n", 
         info_ptr->max_text); 
   } 
 
   for (i = 0; i < num_text; i++) 
   { 
      png_textp textp = &(info_ptr->text[info_ptr->num_text]); 
 
      if (text_ptr[i].text == NULL) 
         text_ptr[i].text = (png_charp)""; 
 
      if (text_ptr[i].text[0] == '\0') 
      { 
         textp->text_length = 0; 
         textp->compression = PNG_TEXT_COMPRESSION_NONE; 
      } 
      else 
      { 
         textp->text_length = png_strlen(text_ptr[i].text); 
         textp->compression = text_ptr[i].compression; 
      } 
      textp->text = text_ptr[i].text; 
      textp->key = text_ptr[i].key; 
      info_ptr->num_text++; 
      png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text); 
   } 
} 
#endif 
 
#if defined(PNG_READ_tIME_SUPPORTED) || defined(PNG_WRITE_tIME_SUPPORTED) 
void 
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) 
{ 
   png_debug1(1, "in %s storage function\n", "tIME"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time)); 
   info_ptr->valid |= PNG_INFO_tIME; 
} 
#endif 
 
#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_WRITE_tRNS_SUPPORTED) 
void 
png_set_tRNS(png_structp png_ptr, png_infop info_ptr, 
   png_bytep trans, int num_trans, png_color_16p trans_values) 
{ 
   png_debug1(1, "in %s storage function\n", "tRNS"); 
   if (png_ptr == NULL || info_ptr == NULL) 
      return; 
 
   if (trans != NULL) 
   { 
      info_ptr->trans = trans; 
   } 
 
   if (trans_values != NULL) 
   { 
      png_memcpy(&(info_ptr->trans_values), trans_values, 
         sizeof(png_color_16)); 
      if (num_trans == 0) 
        num_trans = 1; 
   } 
   info_ptr->num_trans = (png_uint_16)num_trans; 
   info_ptr->valid |= PNG_INFO_tRNS; 
} 
#endif