/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* pngset.c - storage of image information into info struct

 *

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file and, per its terms, should not be removed:

 *

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 * 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.

 */

#include "pngpriv.h"

#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

#ifdef PNG_bKGD_SUPPORTED

void PNGAPI

png_set_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,

    png_const_color_16p background)

{

   png_debug1(1, "in %s storage function", "bKGD");

   if (png_ptr == NULL || info_ptr == NULL || background == NULL)

      return;

   info_ptr->background = *background;

   info_ptr->valid |= PNG_INFO_bKGD;

}

#endif

#ifdef PNG_cHRM_SUPPORTED

void PNGFAPI

png_set_cHRM_fixed(png_const_structrp png_ptr, png_inforp info_ptr,

    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

    png_fixed_point blue_x, png_fixed_point blue_y)

{

   png_xy xy;

   png_debug1(1, "in %s storage function", "cHRM fixed");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   xy.redx = red_x;

   xy.redy = red_y;

   xy.greenx = green_x;

   xy.greeny = green_y;

   xy.bluex = blue_x;

   xy.bluey = blue_y;

   xy.whitex = white_x;

   xy.whitey = white_y;

   if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy,

       2/* override with app values*/) != 0)

      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

   png_colorspace_sync_info(png_ptr, info_ptr);

}

void PNGFAPI

png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_inforp info_ptr,

    png_fixed_point int_red_X, png_fixed_point int_red_Y,

    png_fixed_point int_red_Z, png_fixed_point int_green_X,

    png_fixed_point int_green_Y, png_fixed_point int_green_Z,

    png_fixed_point int_blue_X, png_fixed_point int_blue_Y,

    png_fixed_point int_blue_Z)

{

   png_XYZ XYZ;

   png_debug1(1, "in %s storage function", "cHRM XYZ fixed");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   XYZ.red_X = int_red_X;

   XYZ.red_Y = int_red_Y;

   XYZ.red_Z = int_red_Z;

   XYZ.green_X = int_green_X;

   XYZ.green_Y = int_green_Y;

   XYZ.green_Z = int_green_Z;

   XYZ.blue_X = int_blue_X;

   XYZ.blue_Y = int_blue_Y;

   XYZ.blue_Z = int_blue_Z;

   if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace,

       &XYZ, 2) != 0)

      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

   png_colorspace_sync_info(png_ptr, info_ptr);

}

#  ifdef PNG_FLOATING_POINT_SUPPORTED

void PNGAPI

png_set_cHRM(png_const_structrp png_ptr, png_inforp 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_set_cHRM_fixed(png_ptr, info_ptr,

       png_fixed(png_ptr, white_x, "cHRM White X"),

       png_fixed(png_ptr, white_y, "cHRM White Y"),

       png_fixed(png_ptr, red_x, "cHRM Red X"),

       png_fixed(png_ptr, red_y, "cHRM Red Y"),

       png_fixed(png_ptr, green_x, "cHRM Green X"),

       png_fixed(png_ptr, green_y, "cHRM Green Y"),

       png_fixed(png_ptr, blue_x, "cHRM Blue X"),

       png_fixed(png_ptr, blue_y, "cHRM Blue Y"));

}

void PNGAPI

png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,

    double red_Y, double red_Z, double green_X, double green_Y, double green_Z,

    double blue_X, double blue_Y, double blue_Z)

{

   png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,

       png_fixed(png_ptr, red_X, "cHRM Red X"),

       png_fixed(png_ptr, red_Y, "cHRM Red Y"),

       png_fixed(png_ptr, red_Z, "cHRM Red Z"),

       png_fixed(png_ptr, green_X, "cHRM Green X"),

       png_fixed(png_ptr, green_Y, "cHRM Green Y"),

       png_fixed(png_ptr, green_Z, "cHRM Green Z"),

       png_fixed(png_ptr, blue_X, "cHRM Blue X"),

       png_fixed(png_ptr, blue_Y, "cHRM Blue Y"),

       png_fixed(png_ptr, blue_Z, "cHRM Blue Z"));

}

#  endif /* FLOATING_POINT */

#endif /* cHRM */

#ifdef PNG_eXIf_SUPPORTED

void PNGAPI

png_set_eXIf(png_const_structrp png_ptr, png_inforp info_ptr,

    const png_bytep eXIf_buf)

{

  png_warning(png_ptr, "png_set_eXIf does not work; use png_set_eXIf_1");

  PNG_UNUSED(info_ptr)

  PNG_UNUSED(eXIf_buf)

}

void PNGAPI

png_set_eXIf_1(png_const_structrp png_ptr, png_inforp info_ptr,

    const png_uint_32 num_exif, const png_bytep eXIf_buf)

{

   int i;

   png_debug1(1, "in %s storage function", "eXIf");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   if (info_ptr->exif)

   {

      png_free(png_ptr, info_ptr->exif);

      info_ptr->exif = NULL;

   }

   info_ptr->num_exif = num_exif;

   info_ptr->exif = png_voidcast(png_bytep, png_malloc_warn(png_ptr,

       info_ptr->num_exif));

   if (info_ptr->exif == NULL)

   {

      png_warning(png_ptr, "Insufficient memory for eXIf chunk data");

      return;

   }

   info_ptr->free_me |= PNG_FREE_EXIF;

   for (i = 0; i < (int) info_ptr->num_exif; i++)

      info_ptr->exif[i] = eXIf_buf[i];

   info_ptr->valid |= PNG_INFO_eXIf;

}

#endif /* eXIf */

#ifdef PNG_gAMA_SUPPORTED

void PNGFAPI

png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr,

    png_fixed_point file_gamma)

{

   png_debug1(1, "in %s storage function", "gAMA");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma);

   png_colorspace_sync_info(png_ptr, info_ptr);

}

#  ifdef PNG_FLOATING_POINT_SUPPORTED

void PNGAPI

png_set_gAMA(png_const_structrp png_ptr, png_inforp info_ptr, double file_gamma)

{

   png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma,

       "png_set_gAMA"));

}

#  endif

#endif

#ifdef PNG_hIST_SUPPORTED

void PNGAPI

png_set_hIST(png_const_structrp png_ptr, png_inforp info_ptr,

    png_const_uint_16p hist)

{

   int i;

   png_debug1(1, "in %s storage function", "hIST");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   if (info_ptr->num_palette == 0 || info_ptr->num_palette

       > PNG_MAX_PALETTE_LENGTH)

   {

      png_warning(png_ptr,

          "Invalid palette size, hIST allocation skipped");

      return;

   }

   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);

   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in

    * version 1.2.1

    */

   info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr,

       PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16))));

   if (info_ptr->hist == NULL)

   {

      png_warning(png_ptr, "Insufficient memory for hIST chunk data");

      return;

   }

   info_ptr->free_me |= PNG_FREE_HIST;

   for (i = 0; i < info_ptr->num_palette; i++)

      info_ptr->hist[i] = hist[i];

   info_ptr->valid |= PNG_INFO_hIST;

}

#endif

void PNGAPI

png_set_IHDR(png_const_structrp png_ptr, png_inforp 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)

{

   png_debug1(1, "in %s storage function", "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;

   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,

       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

       info_ptr->compression_type, info_ptr->filter_type);

   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

      info_ptr->channels = 1;

   else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)

      info_ptr->channels = 3;

   else

      info_ptr->channels = 1;

   if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)

      info_ptr->channels++;

   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);

   info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);

}

#ifdef PNG_oFFs_SUPPORTED

void PNGAPI

png_set_oFFs(png_const_structrp png_ptr, png_inforp info_ptr,

    png_int_32 offset_x, png_int_32 offset_y, int unit_type)

{

   png_debug1(1, "in %s storage function", "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

#ifdef PNG_pCAL_SUPPORTED

void PNGAPI

png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,

    png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,

    int nparams, png_const_charp units, png_charpp params)

{

   int i;

   png_debug1(1, "in %s storage function", "pCAL");

   if (png_ptr == NULL || info_ptr == NULL || purpose == NULL || units == NULL

       || (nparams > 0 && params == NULL))

      return;

   length = strlen(purpose) + 1;

   png_debug1(3, "allocating purpose for info (%lu bytes)",

       (unsigned long)length);

   /* TODO: validate format of calibration name and unit name */

   /* Check that the type matches the specification. */

   if (type < 0 || type > 3)

   {

      png_chunk_report(png_ptr, "Invalid pCAL equation type",

            PNG_CHUNK_WRITE_ERROR);

      return;

   }

   if (nparams < 0 || nparams > 255)

   {

      png_chunk_report(png_ptr, "Invalid pCAL parameter count",

            PNG_CHUNK_WRITE_ERROR);

      return;

   }

   /* Validate params[nparams] */

   for (i=0; i<nparams; ++i)

   {

      if (params[i] == NULL ||

          !png_check_fp_string(params[i], strlen(params[i])))

      {

         png_chunk_report(png_ptr, "Invalid format for pCAL parameter",

               PNG_CHUNK_WRITE_ERROR);

         return;

      }

   }

   info_ptr->pcal_purpose = png_voidcast(png_charp,

       png_malloc_warn(png_ptr, length));

   if (info_ptr->pcal_purpose == NULL)

   {

      png_chunk_report(png_ptr, "Insufficient memory for pCAL purpose",

            PNG_CHUNK_WRITE_ERROR);

      return;

   }

   memcpy(info_ptr->pcal_purpose, purpose, length);

   png_debug(3, "storing X0, X1, type, and nparams in info");

   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 = strlen(units) + 1;

   png_debug1(3, "allocating units for info (%lu bytes)",

       (unsigned long)length);

   info_ptr->pcal_units = png_voidcast(png_charp,

       png_malloc_warn(png_ptr, length));

   if (info_ptr->pcal_units == NULL)

   {

      png_warning(png_ptr, "Insufficient memory for pCAL units");

      return;

   }

   memcpy(info_ptr->pcal_units, units, length);

   info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,

   if (info_ptr->pcal_params == NULL)

   {

      png_warning(png_ptr, "Insufficient memory for pCAL params");

      return;

   }

   memset(info_ptr->pcal_params, 0, ((unsigned int)nparams + 1) *

       (sizeof (png_charp)));

   for (i = 0; i < nparams; i++)

   {

      length = strlen(params[i]) + 1;

      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,

          (unsigned long)length);

      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);

      if (info_ptr->pcal_params[i] == NULL)

      {

         png_warning(png_ptr, "Insufficient memory for pCAL parameter");

         return;

      }

      memcpy(info_ptr->pcal_params[i], params[i], length);

   }

   info_ptr->valid |= PNG_INFO_pCAL;

   info_ptr->free_me |= PNG_FREE_PCAL;

}

#endif

#ifdef PNG_sCAL_SUPPORTED

void PNGAPI

png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,

    int unit, png_const_charp swidth, png_const_charp sheight)

{

   png_debug1(1, "in %s storage function", "sCAL");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   /* Double check the unit (should never get here with an invalid

    * unit unless this is an API call.)

    */

   if (unit != 1 && unit != 2)

      png_error(png_ptr, "Invalid sCAL unit");

   if (swidth == NULL || (lengthw = strlen(swidth)) == 0 ||

       swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw))

      png_error(png_ptr, "Invalid sCAL width");

   if (sheight == NULL || (lengthh = strlen(sheight)) == 0 ||

       sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh))

      png_error(png_ptr, "Invalid sCAL height");

   info_ptr->scal_unit = (png_byte)unit;

   ++lengthw;

   png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw);

   info_ptr->scal_s_width = png_voidcast(png_charp,

       png_malloc_warn(png_ptr, lengthw));

   if (info_ptr->scal_s_width == NULL)

   {

      png_warning(png_ptr, "Memory allocation failed while processing sCAL");