void add_png_version(unsigned char **s, int *l)
{
add_to_str(s, l, cast_uchar "PNG (");
#ifdef HAVE_PNG_GET_LIBPNG_VER
add_to_str(s, l, cast_uchar png_get_libpng_ver(NULL));
#else
add_to_str(s, l, cast_uchar PNG_LIBPNG_VER_STRING);
#endif
add_to_str(s, l, cast_uchar ")");
}
/*!
* getImagelibVersions()
*
* Return: string of version numbers; e.g.,
* libgif 5.0.3
* libjpeg 8b
* libpng 1.4.3
* libtiff 3.9.5
* zlib 1.2.5
* libwebp 0.3.0
* libopenjp2 2.1.0
*
* Notes:
* (1) The caller has responsibility to free the memory.
*/
char *
getImagelibVersions()
{
char buf[128];
l_int32 first = TRUE;
#if HAVE_LIBJPEG
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr err;
char buffer[JMSG_LENGTH_MAX];
#endif
char *tempStrP;
char *versionNumP;
char *nextTokenP;
char *versionStrP = stringNew("");
#if HAVE_LIBGIF
first = FALSE;
stringJoinInPlace(versionStrP, "libgif ");
#ifdef GIFLIB_MAJOR
snprintf(buf, sizeof(buf), "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR,
GIFLIB_RELEASE);
#else
stringCopy(buf, "4.1.6(?)", sizeof(buf));
#endif
stringJoinInPlace(versionStrP, buf);
#endif
#if HAVE_LIBJPEG
cinfo.err = jpeg_std_error(&err);
err.msg_code = JMSG_VERSION;
(*err.format_message) ((j_common_ptr ) &cinfo, buffer);
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libjpeg ");
versionNumP = strtokSafe(buffer, " ", &nextTokenP);
stringJoinInPlace(versionStrP, versionNumP);
FREE(versionNumP);
#endif
#if HAVE_LIBPNG
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libpng ");
stringJoinInPlace(versionStrP, png_get_libpng_ver(NULL));
#endif
#if HAVE_LIBTIFF
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libtiff ");
versionNumP = strtokSafe((char *)TIFFGetVersion(), " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
stringJoinInPlace(versionStrP, versionNumP);
FREE(versionNumP);
#endif
#if HAVE_LIBZ
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "zlib ");
stringJoinInPlace(versionStrP, zlibVersion());
#endif
#if HAVE_LIBWEBP
{
l_int32 val;
char buf[32];
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libwebp ");
val = WebPGetEncoderVersion();
snprintf(buf, sizeof(buf), "%d.%d.%d", val >> 16, (val >> 8) & 0xff,
val & 0xff);
stringJoinInPlace(versionStrP, buf);
}
#endif
#if HAVE_LIBJP2K
{
const char *version;
if (!first) stringJoinInPlace(versionStrP, " : ");
first = FALSE;
stringJoinInPlace(versionStrP, "libopenjp2 ");
version = opj_version();
stringJoinInPlace(versionStrP, version);
}
#endif
stringJoinInPlace(versionStrP, "\n");
return versionStrP;
}
/*!
* getImagelibVersions()
*
* Return: string of version numbers; e.g.,
* libgif 5.0.3
* libjpeg 8b (libjpeg-turbo 1.3.0)
* libpng 1.4.3
* libtiff 3.9.5
* zlib 1.2.5
* libwebp 0.3.0
* libopenjp2 2.1.0
*
* Notes:
* (1) The caller must free the memory.
*/
char *
getImagelibVersions()
{
char buf[128];
l_int32 first = TRUE;
char *versionNumP;
char *nextTokenP;
char *versionStrP = NULL;
#if HAVE_LIBGIF
first = FALSE;
stringJoinIP(&versionStrP, "libgif ");
#ifdef GIFLIB_MAJOR
snprintf(buf, sizeof(buf), "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR,
GIFLIB_RELEASE);
#else
stringCopy(buf, "4.1.6(?)", sizeof(buf));
#endif
stringJoinIP(&versionStrP, buf);
#endif /* HAVE_LIBGIF */
#if HAVE_LIBJPEG
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr err;
char buffer[JMSG_LENGTH_MAX];
cinfo.err = jpeg_std_error(&err);
err.msg_code = JMSG_VERSION;
(*err.format_message) ((j_common_ptr ) &cinfo, buffer);
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libjpeg ");
versionNumP = strtokSafe(buffer, " ", &nextTokenP);
stringJoinIP(&versionStrP, versionNumP);
FREE(versionNumP);
#if defined(LIBJPEG_TURBO_VERSION)
/* To stringify the result of expansion of a macro argument,
* you must use two levels of macros. See:
* https://gcc.gnu.org/onlinedocs/cpp/Stringification.html */
#define l_xstr(s) l_str(s)
#define l_str(s) #s
snprintf(buf, sizeof(buf), " (libjpeg-turbo %s)",
l_xstr(LIBJPEG_TURBO_VERSION));
stringJoinIP(&versionStrP, buf);
#endif /* LIBJPEG_TURBO_VERSION */
}
#endif /* HAVE_LIBJPEG */
#if HAVE_LIBPNG
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libpng ");
stringJoinIP(&versionStrP, png_get_libpng_ver(NULL));
#endif /* HAVE_LIBPNG */
#if HAVE_LIBTIFF
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libtiff ");
versionNumP = strtokSafe((char *)TIFFGetVersion(), " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
FREE(versionNumP);
versionNumP = strtokSafe(NULL, " \n", &nextTokenP);
stringJoinIP(&versionStrP, versionNumP);
FREE(versionNumP);
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBZ
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "zlib ");
stringJoinIP(&versionStrP, zlibVersion());
#endif /* HAVE_LIBZ */
#if HAVE_LIBWEBP
{
l_int32 val;
char buf[32];
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libwebp ");
val = WebPGetEncoderVersion();
snprintf(buf, sizeof(buf), "%d.%d.%d", val >> 16, (val >> 8) & 0xff,
val & 0xff);
stringJoinIP(&versionStrP, buf);
}
#endif /* HAVE_LIBWEBP */
#if HAVE_LIBJP2K
{
const char *version;
if (!first) stringJoinIP(&versionStrP, " : ");
first = FALSE;
stringJoinIP(&versionStrP, "libopenjp2 ");
version = opj_version();
stringJoinIP(&versionStrP, version);
}
#endif /* HAVE_LIBJP2K */
stringJoinIP(&versionStrP, "\n");
return versionStrP;
}
int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
{
uch sig[8];
/* first do a quick check that the file really is a PNG image; could
* have used slightly more general png_sig_cmp() function instead */
fread(sig, 1, 8, infile);
if (png_sig_cmp(sig, 0, 8))
return 1; /* bad signature */
/* could pass pointers to user-defined error handlers instead of NULLs: */
png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL, NULL,
NULL);
if (!png_ptr)
return 4; /* out of memory */
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, NULL, NULL);
return 4; /* out of memory */
}
/* we could create a second info struct here (end_info), but it's only
* useful if we want to keep pre- and post-IDAT chunk info separated
* (mainly for PNG-aware image editors and converters) */
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function */
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return 2;
}
png_init_io(png_ptr, infile);
png_set_sig_bytes(png_ptr, 8); /* we already read the 8 signature bytes */
png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */
/* alternatively, could make separate calls to png_get_image_width(),
* etc., but want bit_depth and color_type for later [don't care about
* compression_type and filter_type => NULLs] */
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
*pWidth = width;
*pHeight = height;
/* OK, that's all we need for now; return happy */
return 0;
}
void Send_InitInfo()
{
POVMSAttributeList attrlist;
POVMSAttribute attr;
POVMSObject msg;
int err = kNoErr;
if(err == kNoErr)
err = POVMSObject_New(&msg, kPOVMSType_WildCard);
if(err == kNoErr)
err = POVMSUtil_SetString(&msg, kPOVAttrib_PlatformName, POVRAY_PLATFORM_NAME);
if(err == kNoErr)
err = POVMSUtil_SetFormatString(&msg, kPOVAttrib_CoreVersion,
"Persistence of Vision(tm) Ray Tracer Version %s%s", POV_RAY_VERSION, COMPILER_VER);
if(err == kNoErr)
err = POVMSUtil_SetString(&msg, kPOVAttrib_EnglishText,
DISTRIBUTION_MESSAGE_1 "\n" DISTRIBUTION_MESSAGE_2 "\n" DISTRIBUTION_MESSAGE_3
"\nPOV-Ray is based on DKBTrace 2.12 by David K. Buck & Aaron A. Collins\n" POV_RAY_COPYRIGHT);
if(err == kNoErr)
err = POVMSUtil_SetBool(&msg, kPOVAttrib_Official, POV_RAY_IS_OFFICIAL);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
if(err == kNoErr)
{
for(int i = 0; Primary_Developers[i] != NULL; i++)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
err = POVMSAttr_Set(&attr, kPOVMSType_CString, Primary_Developers[i], strlen(Primary_Developers[i]) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
}
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_PrimaryDevs);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
if(err == kNoErr)
{
for(int i = 0; Contributing_Authors[i] != NULL; i++)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
err = POVMSAttr_Set(&attr, kPOVMSType_CString, Contributing_Authors[i], strlen(Contributing_Authors[i]) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
}
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_ContributingDevs);
if(err == kNoErr)
err = POVMSAttrList_New(&attrlist);
#ifndef DONT_SHOW_IMAGE_LIB_VERSIONS
// ZLib library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("ZLib %s, Copyright 1995-1998 Jean-loup Gailly and Mark Adler", Extract_Version(zlibVersion()));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibPNG library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibPNG %s, Copyright 1998-2002 Glenn Randers-Pehrson", Extract_Version(png_get_libpng_ver(NULL)));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibJPEG library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibJPEG %s, Copyright 1998 Thomas G. Lane", Extract_Version(JVERSION));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
// LibTIFF library version and copyright notice
if(err == kNoErr)
{
err = POVMSAttr_New(&attr);
if(err == kNoErr)
{
const char *tempstr = pov_tsprintf("LibTIFF %s, Copyright 1988-1997 Sam Leffler, 1991-1997 SGI", Extract_Version(TIFFGetVersion()));
err = POVMSAttr_Set(&attr, kPOVMSType_CString, (void *)tempstr, strlen(tempstr) + 1);
if(err == kNoErr)
err = POVMSAttrList_Append(&attrlist, &attr);
else
err = POVMSAttr_Delete(&attr);
}
}
#endif
if(err == kNoErr)
err = POVMSObject_Set(&msg, &attrlist, kPOVAttrib_ImageLibVersions);
if(err == kNoErr)
err = POVMSMsg_SetupMessage(&msg, kPOVMsgClass_Miscellaneous, kPOVMsgIdent_InitInfo);
if(err == kNoErr)
err = POVMSMsg_SetDestinationAddress(&msg, FRONTEND_ADDRESS);
if(err == kNoErr)
err = POVMS_Send(POVMS_Render_Context, &msg, NULL, kPOVMSSendMode_NoReply);
if(err != 0)
(void)POVMS_ASSERT_OUTPUT("Sending InitInfo failed!", "povmsend.cpp", 0);
}
BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
volatile BOOL raw, BOOL alpha)
{
png_struct *png_ptr = NULL;
png_info *info_ptr = NULL;
png_byte buf[8];
png_byte *png_pixels = NULL;
png_byte **row_pointers = NULL;
png_byte *pix_ptr = NULL;
png_uint_32 row_bytes;
png_uint_32 width;
png_uint_32 height;
int bit_depth;
int channels;
int color_type;
int alpha_present;
int row, col;
int ret;
int i;
long dep_16;
/* read and check signature in PNG file */
ret = fread (buf, 1, 8, png_file);
if (ret != 8)
return FALSE;
ret = png_sig_cmp (buf, 0, 8);
if (ret)
return FALSE;
/* create png and info structures */
png_ptr = png_create_read_struct (png_get_libpng_ver(NULL),
NULL, NULL, NULL);
if (!png_ptr)
return FALSE; /* out of memory */
info_ptr = png_create_info_struct (png_ptr);
if (!info_ptr)
{
png_destroy_read_struct (&png_ptr, NULL, NULL);
return FALSE; /* out of memory */
}
if (setjmp (png_jmpbuf(png_ptr)))
{
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
return FALSE;
}
/* set up the input control for C streams */
png_init_io (png_ptr, png_file);
png_set_sig_bytes (png_ptr, 8); /* we already read the 8 signature bytes */
/* read the file information */
png_read_info (png_ptr, info_ptr);
/* get size and bit-depth of the PNG-image */
png_get_IHDR (png_ptr, info_ptr,
&width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
/* set-up the transformations */
/* transform paletted images into full-color rgb */
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_expand (png_ptr);
/* expand images to bit-depth 8 (only applicable for grayscale images) */
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
png_set_expand (png_ptr);
/* transform transparency maps into full alpha-channel */
if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
png_set_expand (png_ptr);
#ifdef NJET
/* downgrade 16-bit images to 8-bit */
if (bit_depth == 16)
png_set_strip_16 (png_ptr);
/* transform grayscale images into full-color */
if (color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb (png_ptr);
/* only if file has a file gamma, we do a correction */
if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
png_set_gamma (png_ptr, (double) 2.2, file_gamma);
#endif
/* all transformations have been registered; now update info_ptr data,
* get rowbytes and channels, and allocate image memory */
png_read_update_info (png_ptr, info_ptr);
/* get the new color-type and bit-depth (after expansion/stripping) */
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
/* check for 16-bit files */
if (bit_depth == 16)
{
raw = FALSE;
#ifdef __TURBOC__
pnm_file->flags &= ~((unsigned) _F_BIN);
#endif
}
/* calculate new number of channels and store alpha-presence */
if (color_type == PNG_COLOR_TYPE_GRAY)
channels = 1;
else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
channels = 2;
else if (color_type == PNG_COLOR_TYPE_RGB)
channels = 3;
else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
channels = 4;
else
channels = 0; /* should never happen */
alpha_present = (channels - 1) % 2;
/* check if alpha is expected to be present in file */
if (alpha && !alpha_present)
{
fprintf (stderr, "PNG2PNM\n");
fprintf (stderr, "Error: PNG-file doesn't contain alpha channel\n");
exit (1);
}
/* row_bytes is the width x number of channels x (bit-depth / 8) */
row_bytes = png_get_rowbytes (png_ptr, info_ptr);
if ((png_pixels = (png_byte *)
malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
return FALSE;
}
if ((row_pointers = (png_byte **)
malloc (height * sizeof (png_bytep))) == NULL)
{
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
free (png_pixels);
png_pixels = NULL;
return FALSE;
}
/* set the individual row_pointers to point at the correct offsets */
for (i = 0; i < ((int) height); i++)
row_pointers[i] = png_pixels + i * row_bytes;
/* now we can go ahead and just read the whole image */
png_read_image (png_ptr, row_pointers);
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end (png_ptr, info_ptr);
/* clean up after the read, and free any memory allocated - REQUIRED */
png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp) NULL);
/* write header of PNM file */
if ((color_type == PNG_COLOR_TYPE_GRAY) ||
(color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
{
fprintf (pnm_file, "%s\n", (raw) ? "P5" : "P2");
fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
}
else if ((color_type == PNG_COLOR_TYPE_RGB) ||
(color_type == PNG_COLOR_TYPE_RGB_ALPHA))
{
fprintf (pnm_file, "%s\n", (raw) ? "P6" : "P3");
fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
}
/* write header of PGM file with alpha channel */
if ((alpha) &&
((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
(color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
{
fprintf (alpha_file, "%s\n", (raw) ? "P5" : "P2");
fprintf (alpha_file, "%d %d\n", (int) width, (int) height);
fprintf (alpha_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
}
/* write data to PNM file */
pix_ptr = png_pixels;
for (row = 0; row < (int) height; row++)
{
for (col = 0; col < (int) width; col++)
{
for (i = 0; i < (channels - alpha_present); i++)
{
if (raw)
fputc ((int) *pix_ptr++ , pnm_file);
else
if (bit_depth == 16){
dep_16 = (long) *pix_ptr++;
fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
}
else
fprintf (pnm_file, "%ld ", (long) *pix_ptr++);
}
if (alpha_present)
{
if (!alpha)
{
pix_ptr++; /* alpha */
if (bit_depth == 16)
pix_ptr++;
}
else /* output alpha-channel as pgm file */
{
if (raw)
fputc ((int) *pix_ptr++ , alpha_file);
else
if (bit_depth == 16){
dep_16 = (long) *pix_ptr++;
fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
}
else
fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
}
} /* if alpha_present */
if (!raw)
if (col % 4 == 3)
fprintf (pnm_file, "\n");
} /* end for col */
if (!raw)
if (col % 4 != 0)
fprintf (pnm_file, "\n");
} /* end for row */
if (row_pointers != (unsigned char**) NULL)
free (row_pointers);
if (png_pixels != (unsigned char*) NULL)
free (png_pixels);
return TRUE;
} /* end of source */
int readpng2_init(mainprog_info *mainprog_ptr)
{
png_structp png_ptr; /* note: temporary variables! */
png_infop info_ptr;
/* could also replace libpng warning-handler (final NULL), but no need: */
png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
readpng2_error_handler, readpng2_warning_handler);
if (!png_ptr)
return 4; /* out of memory */
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, NULL, NULL);
return 4; /* out of memory */
}
/* we could create a second info struct here (end_info), but it's only
* useful if we want to keep pre- and post-IDAT chunk info separated
* (mainly for PNG-aware image editors and converters) */
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function, unless an alternate error handler was installed--
* but compatible error handlers must either use longjmp() themselves
* (as in this program) or exit immediately, so here we are: */
if (setjmp(mainprog_ptr->jmpbuf)) {
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return 2;
}
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
/* prepare the reader to ignore all recognized chunks whose data won't be
* used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
* IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
{
/* These byte strings were copied from png.h. If a future version
* of readpng2.c recognizes more chunks, add them to this list.
*/
static PNG_CONST png_byte chunks_to_process[] = {
98, 75, 71, 68, '\0', /* bKGD */
103, 65, 77, 65, '\0', /* gAMA */
115, 82, 71, 66, '\0', /* sRGB */
};
/* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
NULL, -1);
/* But do not ignore chunks in the "chunks_to_process" list */
png_set_keep_unknown_chunks(png_ptr,
0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
sizeof(chunks_to_process)/5);
}
#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
/* instead of doing png_init_io() here, now we set up our callback
* functions for progressive decoding */
png_set_progressive_read_fn(png_ptr, mainprog_ptr,
readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
/* make sure we save our pointers for use in readpng2_decode_data() */
mainprog_ptr->png_ptr = png_ptr;
mainprog_ptr->info_ptr = info_ptr;
/* and that's all there is to initialization */
return 0;
}
