kpriv/freebsd-ports
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Properly support png15

Browse source 
Obtained from:	OpenBSD ports
This commit is contained in:
Antoine Brodin 2014-12-24 12:04:25 +00:00
parent 0bf639a081
commit b73eb6fea3
Notes: svn2git 2021-03-31 03:12:20 +00:00 
svn path=/head/; revision=375444
6 changed files with 1359 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
graphics/netpbm/Makefile
View file

@ -13,7 +13,7 @@ COMMENT= Toolkit for conversion of images between different formats
LIB_DEPENDS= libtiff.so:${PORTSDIR}/graphics/tiff \
libjpeg.so:${PORTSDIR}/graphics/jpeg \
libpng15.so:${PORTSDIR}/graphics/png \
libpng.so:${PORTSDIR}/graphics/png \
libjbig.so:${PORTSDIR}/graphics/jbigkit \
libjasper.so:${PORTSDIR}/graphics/jasper \
libxml2.so:${PORTSDIR}/textproc/libxml2

27
graphics/netpbm/files/patch-pamrgbatopng.c
View file

@ -1,8 +1,19 @@
--- converter/other/pamrgbatopng.c.orig 2006-08-19 05:12:28.000000000 +0200
+++ converter/other/pamrgbatopng.c 2012-04-24 22:20:00.000000000 +0200
@@ -1,4 +1,5 @@
#include <png.h>
+#include <pngpriv.h>
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
$OpenBSD: patch-converter_other_pamrgbatopng_c,v 1.1 2011/07/08 20:36:09 naddy Exp $
Fix build with png-1.5.
--- converter/other/pamrgbatopng.c.orig Fri Aug 18 21:12:28 2006
+++ converter/other/pamrgbatopng.c Mon Jul 4 14:21:23 2011
@@ -101,10 +101,8 @@ writePng(const struct pam * const pamP,
if (!infoP)
pm_error("Could not allocate PNG info structure");
else {
- infoP->width = pamP->width;
- infoP->height = pamP->height;
- infoP->bit_depth = 8;
- infoP->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ png_set_IHDR(pngP, infoP, pamP->width, pamP->height,
+ 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0, 0);
png_init_io(pngP, ofP);

912
graphics/netpbm/files/patch-pngtopnm.c
View file

@ -1,66 +1,894 @@
--- converter/other/pngtopnm.c.orig 2011-11-25 01:15:46.000000000 +0100
+++ converter/other/pngtopnm.c 2012-04-24 22:15:14.000000000 +0200
@@ -37,6 +37,7 @@
#include <math.h>
#include <float.h>
#include <png.h> /* includes zlib.h and setjmp.h */
+#include <pngpriv.h>
#define VERSION "2.37.4 (5 December 1999) +netpbm"
#include "pnm.h"
@@ -44,7 +45,7 @@
$OpenBSD: patch-converter_other_pngtopnm_c,v 1.2 2011/12/13 21:39:17 naddy Exp $
Fix build with png-1.5.
--- converter/other/pngtopnm.c.orig Fri Nov 25 01:15:46 2011
+++ converter/other/pngtopnm.c Tue Dec 13 22:25:03 2011
@@ -44,12 +44,6 @@
#include "nstring.h"
#include "shhopt.h"
-#if PNG_LIBPNG_VER >= 10400
+#if 0
#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
#error You need either an older PNG library (older than 1.4)
#error newer Netpbm source code (at least 10.48)
@@ -489,7 +490,7 @@
-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
-#error You need either an older PNG library (older than 1.4)
-#error newer Netpbm source code (at least 10.48)
-#endif
-
typedef struct _jmpbuf_wrapper {
jmp_buf jmpbuf;
} jmpbuf_wrapper;
@@ -187,7 +181,7 @@ parseCommandLine(int argc,
-#define get_png_val(p) _get_png_val (&(p), info_ptr->bit_depth)
+#define get_png_val(p) _get_png_val (&(p), png_get_bit_depth(png_ptr, info_ptr))
static png_uint_16
_get_png_val (png_byte ** const pp,
@@ -266,33 +260,39 @@ png_color c;
}
#ifdef __STDC__
-static void save_text (png_info *info_ptr, FILE *tfp)
+static void save_text (png_structp png_ptr, png_info *info_ptr, FILE *tfp)
#else
-static void save_text (info_ptr, tfp)
+static void save_text (png_ptr, info_ptr, tfp)
+png_structp png_ptr;
png_info *info_ptr;
FILE *tfp;
#endif
{
int i, j, k;
+ png_textp text_ptr;
+ int num_text;
- for (i = 0 ; i < info_ptr->num_text ; i++) {
+ if (png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) == 0)
+ return;
+
+ for (i = 0 ; i < num_text ; i++) {
j = 0;
- while (info_ptr->text[i].key[j] != '\0' && info_ptr->text[i].key[j] != ' ')
+ while (text_ptr[i].key[j] != '\0' && text_ptr[i].key[j] != ' ')
j++;
- if (info_ptr->text[i].key[j] != ' ') {
- fprintf (tfp, "%s", info_ptr->text[i].key);
- for (j = strlen (info_ptr->text[i].key) ; j < 15 ; j++)
+ if (text_ptr[i].key[j] != ' ') {
+ fprintf (tfp, "%s", text_ptr[i].key);
+ for (j = strlen (text_ptr[i].key) ; j < 15 ; j++)
putc (' ', tfp);
} else {
- fprintf (tfp, "\"%s\"", info_ptr->text[i].key);
- for (j = strlen (info_ptr->text[i].key) ; j < 13 ; j++)
+ fprintf (tfp, "\"%s\"", text_ptr[i].key);
+ for (j = strlen (text_ptr[i].key) ; j < 13 ; j++)
putc (' ', tfp);
}
putc (' ', tfp); /* at least one space between key and text */
- for (j = 0 ; j < info_ptr->text[i].text_length ; j++) {
- putc (info_ptr->text[i].text[j], tfp);
- if (info_ptr->text[i].text[j] == '\n')
+ for (j = 0 ; j < text_ptr[i].text_length ; j++) {
+ putc (text_ptr[i].text[j], tfp);
+ if (text_ptr[i].text[j] == '\n')
for (k = 0 ; k < 16 ; k++)
putc ((int)' ', tfp);
}
@@ -301,9 +301,10 @@ FILE *tfp;
}
#ifdef __STDC__
-static void show_time (png_info *info_ptr)
+static void show_time (png_structp png_ptr, png_info *info_ptr)
#else
-static void show_time (info_ptr)
+static void show_time (png_ptr, info_ptr)
+png_structp png_ptr;
png_info *info_ptr;
#endif
{
@@ -311,19 +312,20 @@ png_info *info_ptr;
"", "January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
};
+ png_timep mod_time;
- if (info_ptr->valid & PNG_INFO_tIME) {
- if (info_ptr->mod_time.month < 1 ||
- info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
+ if (png_get_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME) {
+ if (mod_time->month < 1 ||
+ mod_time->month >= ARRAY_SIZE(month)) {
pm_message("tIME chunk in PNG input is invalid; "
"modification time of image is unknown. "
"The month value, which should be in the range "
- "1-12, is %u", info_ptr->mod_time.month);
+ "1-12, is %u", mod_time->month);
} else
pm_message ("modification time: %02d %s %d %02d:%02d:%02d",
- info_ptr->mod_time.day, month[info_ptr->mod_time.month],
- info_ptr->mod_time.year, info_ptr->mod_time.hour,
- info_ptr->mod_time.minute, info_ptr->mod_time.second);
+ mod_time->day, month[mod_time->month],
+ mod_time->year, mod_time->hour,
+ mod_time->minute, mod_time->second);
}
}
@@ -360,12 +362,28 @@ png_const_charp msg;
static void
-dump_png_info(png_info *info_ptr) {
+dump_png_info(png_structp png_ptr, png_info *info_ptr) {
const char *type_string;
const char *filter_string;
+ png_color_16p background;
+ int num_trans;
+ double gamma;
+ png_color_8p sig_bit;
+ png_colorp palette;
+ int num_palette;
+ png_uint_16p hist;
+ int res_x, res_y, unit_type;
+ png_int_32 offset_x, offset_y;
+ png_timep mod_time;
+ png_charp purpose;
+ png_int_32 X0, X1;
+ int type, nparams;
+ png_charp units;
+ png_charpp params;
+ int file_srgb_intent;
- switch (info_ptr->color_type) {
+ switch (png_get_color_type(png_ptr, info_ptr)) {
case PNG_COLOR_TYPE_GRAY:
type_string = "gray";
break;
@@ -387,90 +405,101 @@ dump_png_info(png_info *info_ptr) {
break;
}
- switch (info_ptr->filter_type) {
+ switch (png_get_filter_type(png_ptr, info_ptr)) {
case PNG_FILTER_TYPE_BASE:
asprintfN(&filter_string, "base filter");
break;
default:
asprintfN(&filter_string, "unknown filter type %d",
- info_ptr->filter_type);
+ png_get_filter_type(png_ptr, info_ptr));
}
- pm_message("reading a %ldw x %ldh image, %d bit%s",
- info_ptr->width, info_ptr->height,
- info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : "");
+ pm_message("reading a %uw x %uh image, %d bit%s",
+ png_get_image_width(png_ptr, info_ptr),
+ png_get_image_height(png_ptr, info_ptr),
+ png_get_bit_depth(png_ptr, info_ptr),
+ png_get_bit_depth(png_ptr, info_ptr) > 1 ? "s" : "");
pm_message("%s, %s, %s",
type_string,
- info_ptr->interlace_type ?
+ png_get_interlace_type(png_ptr, info_ptr) ?
"Adam7 interlaced" : "not interlaced",
filter_string);
- pm_message("background {index, gray, red, green, blue} = "
- "{%d, %d, %d, %d, %d}",
- info_ptr->background.index,
- info_ptr->background.gray,
- info_ptr->background.red,
- info_ptr->background.green,
- info_ptr->background.blue);
+ if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) {
+ pm_message("background {index, gray, red, green, blue} = "
+ "{%d, %d, %d, %d, %d}",
+ background->index,
+ background->gray,
+ background->red,
+ background->green,
+ background->blue);
+ }
+
strfree(filter_string);
- if (info_ptr->valid & PNG_INFO_tRNS)
+ if (png_get_tRNS(png_ptr, info_ptr,
+ NULL, &num_trans, NULL) & PNG_INFO_tRNS)
pm_message("tRNS chunk (transparency): %u entries",
- info_ptr->num_trans);
+ num_trans);
else
pm_message("tRNS chunk (transparency): not present");
- if (info_ptr->valid & PNG_INFO_gAMA)
- pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma);
+ if (png_get_gAMA(png_ptr, info_ptr, &gamma) & PNG_INFO_gAMA)
+ pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma);
else
pm_message("gAMA chunk (image gamma): not present");
- if (info_ptr->valid & PNG_INFO_sBIT)
+ if (png_get_sBIT(png_ptr, info_ptr, &sig_bit) & PNG_INFO_sBIT)
pm_message("sBIT chunk: present");
else
pm_message("sBIT chunk: not present");
- if (info_ptr->valid & PNG_INFO_cHRM)
+ if (png_get_cHRM(png_ptr, info_ptr,
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL) & PNG_INFO_cHRM)
pm_message("cHRM chunk: present");
else
pm_message("cHRM chunk: not present");
- if (info_ptr->valid & PNG_INFO_PLTE)
- pm_message("PLTE chunk: %d entries", info_ptr->num_palette);
+ if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) & PNG_INFO_PLTE)
+ pm_message("PLTE chunk: %d entries", num_palette);
else
pm_message("PLTE chunk: not present");
- if (info_ptr->valid & PNG_INFO_bKGD)
+ if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD)
pm_message("bKGD chunk: present");
else
pm_message("bKGD chunk: not present");
- if (info_ptr->valid & PNG_INFO_hIST)
+ if (png_get_hIST(png_ptr, info_ptr, &hist) & PNG_INFO_hIST)
pm_message("hIST chunk: present");
else
pm_message("hIST chunk: not present");
- if (info_ptr->valid & PNG_INFO_pHYs)
+ if (png_get_pHYs(png_ptr, info_ptr,
+ &res_x, &res_y, &unit_type) & PNG_INFO_pHYs)
pm_message("pHYs chunk: present");
else
pm_message("pHYs chunk: not present");
- if (info_ptr->valid & PNG_INFO_oFFs)
+ if (png_get_oFFs(png_ptr, info_ptr,
+ &offset_x, &offset_y, &unit_type) & PNG_INFO_oFFs)
pm_message("oFFs chunk: present");
else
pm_message("oFFs chunk: not present");
- if (info_ptr->valid & PNG_INFO_tIME)
+ if (png_get_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME)
pm_message("tIME chunk: present");
else
pm_message("tIME chunk: not present");
- if (info_ptr->valid & PNG_INFO_pCAL)
+ if (png_get_pCAL(png_ptr, info_ptr, &purpose, &X0, &X1,
+ &type, &nparams, &units, &params) & PNG_INFO_pCAL)
pm_message("pCAL chunk: present");
else
pm_message("pCAL chunk: not present");
- if (info_ptr->valid & PNG_INFO_sRGB)
+ if (png_get_sRGB(png_ptr, info_ptr, &file_srgb_intent) & PNG_INFO_sRGB)
pm_message("sRGB chunk: present");
else
pm_message("sRGB chunk: not present");
@@ -479,19 +508,19 @@ dump_png_info(png_info *info_ptr) {
static bool
-isTransparentColor(pngcolor const color,
- png_info * const info_ptr,
- double const totalgamma) {
+isTransparentColor(pngcolor const color,
+ png_structp const png_ptr,
+ png_info * const info_ptr,
+ double const totalgamma) {
/*----------------------------------------------------------------------------
Return TRUE iff pixels of color 'color' are supposed to be transparent
everywhere they occur. Assume it's an RGB image.
-----------------------------------------------------------------------------*/
bool retval;
+ png_color_16p transColorP;
- if (info_ptr->valid & PNG_INFO_tRNS) {
- const png_color_16 * const transColorP = &info_ptr->trans_values;
-
-
+ if (png_get_tRNS(png_ptr, info_ptr,
+ NULL, NULL, &transColorP) & PNG_INFO_tRNS) {
/* There seems to be a problem here: you can't compare real
numbers for equality. Also, I'm not sure the gamma
corrected/uncorrected color spaces are right here.
@@ -537,9 +566,11 @@ setupGammaCorrection(png_struct * const png_ptr,
if (displaygamma == -1.0)
*totalgammaP = -1.0;
else {
+ double fileGamma;
float imageGamma;
- if (info_ptr->valid & PNG_INFO_gAMA)
- imageGamma = info_ptr->gamma;
+
+ if (png_get_gAMA(png_ptr, info_ptr, &fileGamma) & PNG_INFO_gAMA)
+ imageGamma = fileGamma;
else {
if (verbose)
pm_message("PNG doesn't specify image gamma. Assuming 1.0");
@@ -555,10 +586,14 @@ setupGammaCorrection(png_struct * const png_ptr,
} else {
png_set_gamma(png_ptr, displaygamma, imageGamma);
*totalgammaP = imageGamma * displaygamma;
+#ifdef NOT_SUPPORTED_ANYMORE
+ /* The API doesn't clearing PNG_INFO_sBIT. */
+
/* in case of gamma-corrections, sBIT's as in the
PNG-file are not valid anymore
*/
info_ptr->valid &= ~PNG_INFO_sBIT;
+#endif
if (verbose)
pm_message("image gamma is %4.2f, "
"converted for display gamma of %4.2f",
@@ -570,20 +605,24 @@ setupGammaCorrection(png_struct * const png_ptr,
static bool
-paletteHasPartialTransparency(png_info * const info_ptr) {
+paletteHasPartialTransparency(png_structp png_ptr, png_info * const info_ptr) {
bool retval;
if (info_ptr->valid & PNG_INFO_tRNS) {
- const png_color_16 * const transColorP = &info_ptr->trans_values;
+ const png_color_16 * const transColorP = &info_ptr->trans_color;
/* There seems to be a problem here: you can't compare real
@@ -582,8 +583,8 @@
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
- if (info_ptr->valid & PNG_INFO_tRNS) {
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
+ png_bytep trans_alpha;
+ int num_trans;
+
+ if (png_get_tRNS(png_ptr, info_ptr,
+ &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) {
bool foundGray;
unsigned int i;
for (i = 0, foundGray = FALSE;
i < info_ptr->num_trans && !foundGray;
- i < info_ptr->num_trans && !foundGray;
+ i < num_trans && !foundGray;
++i) {
- if (info_ptr->trans[i] != 0 &&
- info_ptr->trans[i] != maxval) {
+ if (info_ptr->trans_alpha[i] != 0 &&
+ info_ptr->trans_alpha[i] != maxval) {
+ if (trans_alpha[i] != 0 &&
+ trans_alpha[i] != maxval) {
foundGray = TRUE;
}
}
@@ -654,7 +655,7 @@
@@ -611,14 +650,16 @@ setupSignificantBits(png_struct * const png_ptr
Return the result as *maxvalP.
-----------------------------------------------------------------------------*/
+ png_color_8p sig_bit;
+
/* Initial assumption of maxval */
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
if (alpha == ALPHA_ONLY) {
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY ||
+ png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB)
/* The alpha mask will be all opaque, so maxval 1 is plenty */
*maxvalP = 1;
- else if (paletteHasPartialTransparency(info_ptr))
+ else if (paletteHasPartialTransparency(png_ptr, info_ptr))
/* Use same maxval as PNG transparency palette for simplicity*/
*maxvalP = 255;
else
@@ -628,7 +669,7 @@ setupSignificantBits(png_struct * const png_ptr
/* Use same maxval as PNG palette for simplicity */
*maxvalP = 255;
} else {
- *maxvalP = (1l << info_ptr->bit_depth) - 1;
+ *maxvalP = (1l << png_get_bit_depth(png_ptr, info_ptr)) - 1;
}
/* sBIT handling is very tricky. If we are extracting only the
@@ -641,20 +682,26 @@ setupSignificantBits(png_struct * const png_ptr
is used
*/
- if (info_ptr->valid & PNG_INFO_sBIT) {
+ if (png_get_sBIT(png_ptr, info_ptr, &sig_bit) & PNG_INFO_sBIT) {
+ png_byte color_type;
+ png_bytep trans_alpha;
+ int num_trans;
+
+ color_type = png_get_color_type(png_ptr, info_ptr);
switch (alpha) {
case ALPHA_MIX:
- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ if (color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
break;
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
- (info_ptr->valid & PNG_INFO_tRNS)) {
+ if (color_type == PNG_COLOR_TYPE_PALETTE &&
+ png_get_tRNS(png_ptr, info_ptr,
+ &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) {
bool trans_mix;
unsigned int i;
trans_mix = TRUE;
for (i = 0; i < info_ptr->num_trans; ++i)
- for (i = 0; i < info_ptr->num_trans; ++i)
- if (info_ptr->trans[i] != 0 && info_ptr->trans[i] != 255) {
+ if (info_ptr->trans_alpha[i] != 0 && info_ptr->trans_alpha[i] != 255) {
+ for (i = 0; i < num_trans; ++i)
+ if (trans_alpha[i] != 0 && trans_alpha[i] != 255) {
trans_mix = FALSE;
break;
}
@@ -892,7 +893,7 @@
setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
((info_ptr->valid & PNG_INFO_tRNS) &&
(fgColor.r ==
- gamma_correct(info_ptr->trans_values.gray,
+ gamma_correct(info_ptr->trans_color.gray,
totalgamma))) ?
0 : maxval);
@@ -665,70 +712,76 @@ setupSignificantBits(png_struct * const png_ptr
/* else fall though to normal case */
case ALPHA_NONE:
- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
- (info_ptr->sig_bit.red != info_ptr->sig_bit.green ||
- info_ptr->sig_bit.red != info_ptr->sig_bit.blue) &&
+ if ((color_type == PNG_COLOR_TYPE_PALETTE ||
+ color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
+ (sig_bit->red != sig_bit->green ||
+ sig_bit->red != sig_bit->blue) &&
alpha == ALPHA_NONE) {
pm_message("This program cannot handle "
"different bit depths for color channels");
pm_message("writing file with %d bit resolution",
- info_ptr->bit_depth);
+ png_get_bit_depth(png_ptr, info_ptr));
*errorlevelP = PNMTOPNG_WARNING_LEVEL;
} else {
- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) &&
- (info_ptr->sig_bit.red < 255)) {
+ png_colorp palette;
+ int num_palette;
+
+ if ((color_type == PNG_COLOR_TYPE_PALETTE) &&
+ (sig_bit->red < 255) &&
+ png_get_PLTE(png_ptr, info_ptr,
+ &palette, &num_palette) & PNG_INFO_PLTE) {
unsigned int i;
- for (i = 0; i < info_ptr->num_palette; ++i) {
- info_ptr->palette[i].red >>=
- (8 - info_ptr->sig_bit.red);
- info_ptr->palette[i].green >>=
- (8 - info_ptr->sig_bit.green);
- info_ptr->palette[i].blue >>=
- (8 - info_ptr->sig_bit.blue);
+
+ for (i = 0; i < num_palette; ++i) {
+ palette[i].red >>=
+ (8 - sig_bit->red);
+ palette[i].green >>=
+ (8 - sig_bit->green);
+ palette[i].blue >>=
+ (8 - sig_bit->blue);
}
- *maxvalP = (1l << info_ptr->sig_bit.red) - 1;
+ *maxvalP = (1l << sig_bit->red) - 1;
if (verbose)
pm_message ("image has fewer significant bits, "
"writing file with %d bits per channel",
- info_ptr->sig_bit.red);
+ sig_bit->red);
} else
- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
- (info_ptr->sig_bit.red < info_ptr->bit_depth)) {
- png_set_shift (png_ptr, &(info_ptr->sig_bit));
- *maxvalP = (1l << info_ptr->sig_bit.red) - 1;
+ if ((color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
+ (sig_bit->red < png_get_bit_depth(png_ptr, info_ptr))) {
+ png_set_shift (png_ptr, sig_bit);
+ *maxvalP = (1l << sig_bit->red) - 1;
if (verbose)
pm_message("image has fewer significant bits, "
"writing file with %d "
"bits per channel",
- info_ptr->sig_bit.red);
+ sig_bit->red);
} else
- if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type ==
+ if ((color_type == PNG_COLOR_TYPE_GRAY ||
+ color_type ==
PNG_COLOR_TYPE_GRAY_ALPHA) &&
- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
- png_set_shift (png_ptr, &(info_ptr->sig_bit));
- *maxvalP = (1l << info_ptr->sig_bit.gray) - 1;
+ (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) {
+ png_set_shift (png_ptr, sig_bit);
+ *maxvalP = (1l << sig_bit->gray) - 1;
if (verbose)
pm_message("image has fewer significant bits, "
"writing file with %d bits",
- info_ptr->sig_bit.gray);
+ sig_bit->gray);
}
}
@@ -921,7 +922,7 @@
setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
(info_ptr->valid & PNG_INFO_tRNS) &&
index < info_ptr->num_trans ?
break;
case ALPHA_ONLY:
- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
- png_set_shift (png_ptr, &(info_ptr->sig_bit));
+ if ((color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
+ (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) {
+ png_set_shift (png_ptr, sig_bit);
if (verbose)
pm_message ("image has fewer significant bits, "
"writing file with %d bits",
- info_ptr->sig_bit.alpha);
- *maxvalP = (1l << info_ptr->sig_bit.alpha) - 1;
+ sig_bit->alpha);
+ *maxvalP = (1l << sig_bit->alpha) - 1;
}
break;
@@ -739,22 +792,28 @@ setupSignificantBits(png_struct * const png_ptr
static bool
-imageHasColor(png_info * const info_ptr) {
+imageHasColor(png_structp const png_ptr, png_info * const info_ptr) {
bool retval;
+ png_byte color_type;
+ png_colorp palette;
+ int num_palette;
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ color_type = png_get_color_type(png_ptr, info_ptr);
+ if (color_type == PNG_COLOR_TYPE_GRAY ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
retval = FALSE;
- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+ else if (color_type == PNG_COLOR_TYPE_PALETTE &&
+ png_get_PLTE(png_ptr, info_ptr,
+ &palette, &num_palette) & PNG_INFO_PLTE) {
bool foundColor;
unsigned int i;
for (i = 0, foundColor = FALSE;
- i < info_ptr->num_palette && !foundColor;
+ i < num_palette && !foundColor;
++i) {
- if (iscolor(info_ptr->palette[i]))
+ if (iscolor(palette[i]))
foundColor = TRUE;
}
retval = foundColor;
@@ -767,14 +826,15 @@ imageHasColor(png_info * const info_ptr) {
static void
-determineOutputType(png_info * const info_ptr,
+determineOutputType(png_structp const png_ptr,
+ png_info * const info_ptr,
enum alpha_handling const alphaHandling,
pngcolor const bgColor,
xelval const maxval,
int * const pnmTypeP) {
if (alphaHandling != ALPHA_ONLY &&
- (imageHasColor(info_ptr) || !isGrayscale(bgColor)))
+ (imageHasColor(png_ptr, info_ptr) || !isGrayscale(bgColor)))
*pnmTypeP = PPM_TYPE;
else {
if (maxval > 1)
@@ -787,7 +847,8 @@ determineOutputType(png_info * const info_ptr
static void
-getBackgroundColor(png_info * const info_ptr,
+getBackgroundColor(png_structp const png_ptr,
+ png_info * const info_ptr,
const char * const requestedColor,
float const totalgamma,
xelval const maxval,
@@ -798,6 +859,8 @@ getBackgroundColor(png_info * const info_ptr,
Otherwise, if the PNG specifies a background color, that's the one.
And otherwise, it's white.
-----------------------------------------------------------------------------*/
+ png_color_16p background;
+
if (requestedColor) {
/* Background was specified from the command-line; we always
use that. I chose to do no gamma-correction in this case;
@@ -809,27 +872,32 @@ getBackgroundColor(png_info * const info_ptr,
bgColorP->g = PPM_GETG(backcolor);
bgColorP->b = PPM_GETB(backcolor);
- } else if (info_ptr->valid & PNG_INFO_bKGD) {
+ } else if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) {
/* didn't manage to get libpng to work (bugs?) concerning background
processing, therefore we do our own.
*/
- switch (info_ptr->color_type) {
+ switch (png_get_color_type(png_ptr, info_ptr)) {
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_GRAY_ALPHA:
bgColorP->r = bgColorP->g = bgColorP->b =
- gamma_correct(info_ptr->background.gray, totalgamma);
+ gamma_correct(background->gray, totalgamma);
break;
case PNG_COLOR_TYPE_PALETTE: {
- png_color const rawBgcolor =
- info_ptr->palette[info_ptr->background.index];
- bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
- bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
- bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
+ png_colorp palette;
+ int num_palette;
+
+ if (png_get_PLTE(png_ptr, info_ptr,
+ &palette, &num_palette) & PNG_INFO_PLTE) {
+ png_color const rawBgcolor = palette[background->index];
+ bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
+ bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
+ bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
+ }
}
break;
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_RGB_ALPHA: {
- png_color_16 const rawBgcolor = info_ptr->background;
+ png_color_16 const rawBgcolor = *background;
bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
@@ -848,6 +916,7 @@ static void
writePnm(FILE * const ofP,
xelval const maxval,
int const pnm_type,
+ png_structp const png_ptr,
png_info * const info_ptr,
png_byte ** const png_image,
pngcolor const bgColor,
@@ -865,6 +934,7 @@ writePnm(FILE * const ofP,
-----------------------------------------------------------------------------*/
xel * xelrow;
unsigned int row;
+ png_uint_32 width, height;
if (verbose)
pm_message ("writing a %s file (maxval=%u)",
@@ -874,27 +944,35 @@ writePnm(FILE * const ofP,
"UNKNOWN!",
maxval);
- xelrow = pnm_allocrow(info_ptr->width);
+ xelrow = pnm_allocrow(png_get_image_width(png_ptr, info_ptr));
- pnm_writepnminit(stdout, info_ptr->width, info_ptr->height, maxval,
- pnm_type, FALSE);
+ width = png_get_image_width(png_ptr, info_ptr);
+ height = png_get_image_height(png_ptr, info_ptr);
- for (row = 0; row < info_ptr->height; ++row) {
+ pnm_writepnminit(stdout, width, height, maxval, pnm_type, FALSE);
+
+ for (row = 0; row < height; ++row) {
png_byte * png_pixelP;
int col;
png_pixelP = &png_image[row][0]; /* initial value */
- for (col = 0; col < info_ptr->width; ++col) {
- switch (info_ptr->color_type) {
+ for (col = 0; col < width; ++col) {
+ switch (png_get_color_type(png_ptr, info_ptr)) {
case PNG_COLOR_TYPE_GRAY: {
pngcolor fgColor;
+ png_color_16p trans_color;
+
fgColor.r = fgColor.g = fgColor.b = get_png_val(png_pixelP);
- setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
- ((info_ptr->valid & PNG_INFO_tRNS) &&
- (fgColor.r ==
- gamma_correct(info_ptr->trans_values.gray,
- totalgamma))) ?
- 0 : maxval);
+
+ if (png_get_tRNS(png_ptr, info_ptr,
+ NULL, NULL, &trans_color) & PNG_INFO_tRNS &&
+ (fgColor.r == gamma_correct(trans_color->gray,
+ totalgamma))) {
+ setXel(&xelrow[col], fgColor, bgColor, alpha_handling, 0);
+ } else {
+ setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
+ maxval);
+ }
}
break;
@@ -909,19 +987,31 @@ writePnm(FILE * const ofP,
break;
case PNG_COLOR_TYPE_PALETTE: {
- png_uint_16 const index = get_png_val(png_pixelP);
- png_color const paletteColor = info_ptr->palette[index];
+ png_uint_16 const index = get_png_val(png_pixelP);
+ png_colorp palette;
+ int num_palette;
- pngcolor fgColor;
+ if (png_get_PLTE(png_ptr, info_ptr,
+ &palette, &num_palette) & PNG_INFO_PLTE) {
+ png_color const paletteColor = palette[index];
+ pngcolor fgColor;
+ png_bytep trans_alpha;
+ int num_trans;
- fgColor.r = paletteColor.red;
- fgColor.g = paletteColor.green;
- fgColor.b = paletteColor.blue;
+ fgColor.r = paletteColor.red;
+ fgColor.g = paletteColor.green;
+ fgColor.b = paletteColor.blue;
- setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
- (info_ptr->valid & PNG_INFO_tRNS) &&
- index < info_ptr->num_trans ?
- info_ptr->trans[index] : maxval);
+ info_ptr->trans_alpha[index] : maxval);
+ if (png_get_tRNS(png_ptr, info_ptr,
+ &trans_alpha,
+ &num_trans, NULL) & PNG_INFO_tRNS) {
+ setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
+ index < num_trans ? trans_alpha[index] : maxval);
+ } else {
+ setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
+ maxval);
+ }
+ }
}
break;
@@ -932,8 +1022,8 @@ writePnm(FILE * const ofP,
fgColor.g = get_png_val(png_pixelP);
fgColor.b = get_png_val(png_pixelP);
setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
- isTransparentColor(fgColor, info_ptr, totalgamma) ?
- 0 : maxval);
+ isTransparentColor(fgColor, png_ptr, info_ptr,
+ totalgamma) ? 0 : maxval);
}
break;
@@ -950,10 +1040,10 @@ writePnm(FILE * const ofP,
break;
default:
- pm_error ("unknown PNG color type: %d", info_ptr->color_type);
+ pm_error ("unknown PNG color type: %d", png_get_color_type(png_ptr, info_ptr));
}
}
- pnm_writepnmrow(ofP, xelrow, info_ptr->width, maxval, pnm_type, FALSE);
+ pnm_writepnmrow(ofP, xelrow, width, maxval, pnm_type, FALSE);
}
pnm_freerow (xelrow);
}
@@ -974,6 +1064,7 @@ convertpng(FILE * const ifp,
int pnm_type;
pngcolor bgColor;
float totalgamma;
+ int res_x, res_y, unit_type;
*errorlevelP = 0;
@@ -996,28 +1087,28 @@ convertpng(FILE * const ifp,
png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE);
png_read_info (png_ptr, info_ptr);
- MALLOCARRAY(png_image, info_ptr->height);
+ MALLOCARRAY(png_image, png_get_image_height(png_ptr, info_ptr));
if (png_image == NULL) {
png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL);
pm_closer (ifp);
pm_error ("couldn't allocate space for image");
}
- if (info_ptr->bit_depth == 16)
- linesize = 2 * info_ptr->width;
+ if (png_get_bit_depth(png_ptr, info_ptr) == 16)
+ linesize = 2 * png_get_image_width(png_ptr, info_ptr);
else
- linesize = info_ptr->width;
+ linesize = png_get_image_width(png_ptr, info_ptr);
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA)
linesize *= 2;
else
- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB)
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB)
linesize *= 3;
else
- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA)
linesize *= 4;
- for (y = 0 ; y < info_ptr->height ; y++) {
+ for (y = 0 ; y < png_get_image_height(png_ptr, info_ptr) ; y++) {
png_image[y] = malloc (linesize);
if (png_image[y] == NULL) {
for (x = 0 ; x < y ; x++)
@@ -1029,7 +1120,7 @@ convertpng(FILE * const ifp,
}
}
- if (info_ptr->bit_depth < 8)
+ if (png_get_bit_depth(png_ptr, info_ptr) < 8)
png_set_packing (png_ptr);
setupGammaCorrection(png_ptr, info_ptr, cmdline.gamma, &totalgamma);
@@ -1037,8 +1128,8 @@ convertpng(FILE * const ifp,
setupSignificantBits(png_ptr, info_ptr, cmdline.alpha,
&maxval, errorlevelP);
- getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval,
- &bgColor);
+ getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma,
+ maxval, &bgColor);
png_read_image (png_ptr, png_image);
png_read_end (png_ptr, info_ptr);
@@ -1048,16 +1139,17 @@ convertpng(FILE * const ifp,
completes. That's because it comes from chunks that are at the
end of the stream.
*/
- dump_png_info(info_ptr);
+ dump_png_info(png_ptr, info_ptr);
if (mtime)
- show_time (info_ptr);
+ show_time (png_ptr, info_ptr);
if (tfp)
- save_text (info_ptr, tfp);
+ save_text (png_ptr, info_ptr, tfp);
- if (info_ptr->valid & PNG_INFO_pHYs) {
+ if (png_get_pHYs(png_ptr, info_ptr,
+ &res_x, &res_y, &unit_type) & PNG_INFO_pHYs) {
float r;
- r = (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit;
+ r = (float)res_x / res_y;
if (r != 1.0) {
pm_message ("warning - non-square pixels; "
"to fix do a 'pamscale -%cscale %g'",
@@ -1067,13 +1159,13 @@ convertpng(FILE * const ifp,
}
}
- determineOutputType(info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type);
+ determineOutputType(png_ptr, info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type);
- writePnm(stdout, maxval, pnm_type, info_ptr, png_image, bgColor,
+ writePnm(stdout, maxval, pnm_type, png_ptr, info_ptr, png_image, bgColor,
cmdline.alpha, totalgamma);
fflush(stdout);
- for (y = 0 ; y < info_ptr->height ; y++)
+ for (y = 0 ; y < png_get_image_height(png_ptr, info_ptr) ; y++)
free (png_image[y]);
free (png_image);
png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL);

88
graphics/netpbm/files/patch-pngtxt.c
View file

@ -1,10 +1,80 @@
--- converter/other/pngtxt.c.orig 2006-08-19 05:12:28.000000000 +0200
+++ converter/other/pngtxt.c 2012-04-24 22:12:39.000000000 +0200
@@ -2,6 +2,7 @@
#include <string.h>
#include <stdio.h>
#include <png.h>
+#include <pngpriv.h>
$OpenBSD: patch-converter_other_pngtxt_c,v 1.1 2011/07/08 20:36:09 naddy Exp $
Fix build with png-1.5.
--- converter/other/pngtxt.c.orig Fri Aug 18 21:12:28 2006
+++ converter/other/pngtxt.c Mon Jul 4 14:21:23 2011
@@ -240,7 +240,8 @@ handleArrayAllocation(png_text ** const arrayP,
void
-pnmpng_read_text (png_info * const info_ptr,
+pnmpng_read_text (png_struct * png_ptr,
+ png_info * info_ptr,
FILE * const tfp,
bool const ztxt,
bool const verbose) {
@@ -250,6 +251,7 @@ pnmpng_read_text (png_info * const info_ptr,
unsigned int commentIdx;
bool noCommentsYet;
bool eof;
+ png_textp text_ptr;
unsigned int allocatedComments;
/* Number of entries currently allocated for the info_ptr->text
array
@@ -257,8 +259,8 @@ pnmpng_read_text (png_info * const info_ptr,
allocatedComments = 256; /* initial value */
- MALLOCARRAY(info_ptr->text, allocatedComments);
- if (info_ptr->text == NULL)
+ MALLOCARRAY(text_ptr, allocatedComments);
+ if (text_ptr == NULL)
pm_error("unable to allocate memory for comment array");
commentIdx = 0;
@@ -273,7 +275,7 @@ pnmpng_read_text (png_info * const info_ptr,
if (lineLength == 0) {
/* skip this empty line */
} else {
- handleArrayAllocation(&info_ptr->text, &allocatedComments,
+ handleArrayAllocation(&text_ptr, &allocatedComments,
commentIdx);
if ((textline[0] != ' ') && (textline[0] != '\t')) {
/* Line doesn't start with white space, which
@@ -285,7 +287,7 @@ pnmpng_read_text (png_info * const info_ptr,
++commentIdx;
noCommentsYet = FALSE;
- startComment(&info_ptr->text[commentIdx],
+ startComment(&text_ptr[commentIdx],
textline, lineLength, ztxt);
} else {
/* Line starts with whitespace, which means it is
@@ -295,20 +297,20 @@ pnmpng_read_text (png_info * const info_ptr,
pm_error("Invalid comment file format: "
"first line is a continuation line! "
"(It starts with whitespace)");
- continueComment(&info_ptr->text[commentIdx],
+ continueComment(&text_ptr[commentIdx],
textline, lineLength);
}
}
strfree(textline);
}
}
- if (noCommentsYet)
- info_ptr->num_text = 0;
- else
- info_ptr->num_text = commentIdx + 1;
+ if (!noCommentsYet)
+ png_set_text(png_ptr, info_ptr, text_ptr, commentIdx + 1);
if (verbose)
- pm_message("%d comments placed in text chunk", info_ptr->num_text);
+ pm_message("%d comments placed in text chunk", commentIdx + 1);
+
+ free(text_ptr);
}
#include "nstring.h"
#include "pngtxt.h"

16
graphics/netpbm/files/patch-pngtxt.h Normal file
View file

@ -0,0 +1,16 @@
$OpenBSD: patch-converter_other_pngtxt_h,v 1.1 2011/07/08 20:36:09 naddy Exp $
Fix build with png-1.5.
--- converter/other/pngtxt.h.orig Fri Aug 18 21:12:28 2006
+++ converter/other/pngtxt.h Mon Jul 4 14:21:23 2011
@@ -5,7 +5,8 @@
#include <png.h>
void
-pnmpng_read_text (png_info * const info_ptr,
+pnmpng_read_text (png_struct * png_ptr,
+ png_info * const info_ptr,
FILE * const tfp,
bool const ztxt,
bool const verbose);

401
graphics/netpbm/files/patch-pnmtopng.c
View file

@ -1,55 +1,402 @@
--- converter/other/pnmtopng.c.orig 2011-09-25 20:51:44.000000000 +0200
+++ converter/other/pnmtopng.c 2012-04-23 20:23:10.000000000 +0200
@@ -61,7 +61,9 @@
$OpenBSD: patch-converter_other_pnmtopng_c,v 1.2 2011/12/13 21:39:17 naddy Exp $
Fix build with png-1.5.
--- converter/other/pnmtopng.c.orig Sun Sep 25 20:51:44 2011
+++ converter/other/pnmtopng.c Tue Dec 13 22:22:04 2011
@@ -61,7 +61,8 @@
#include <assert.h>
#include <string.h> /* strcat() */
#include <limits.h>
-#include <png.h> /* includes zlib.h and setjmp.h */
+#include <png.h>
+#include <png.h> /* includes setjmp.h */
+#include <zlib.h>
+#include <pngpriv.h>
#include "pnm.h"
#include "pngtxt.h"
#include "shhopt.h"
@@ -69,7 +71,7 @@
@@ -69,13 +70,6 @@
#include "nstring.h"
#include "version.h"
-#if PNG_LIBPNG_VER >= 10400
+#if 0
#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
#error You need either an older PNG library (older than 1.4)
#error newer Netpbm source code (at least 10.47.04)
@@ -2630,7 +2632,7 @@
info_ptr->num_palette = palette_size;
-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
-#error You need either an older PNG library (older than 1.4)
-#error newer Netpbm source code (at least 10.47.04)
-#endif
-
-
struct zlibCompression {
/* These are parameters that describe a form of zlib compression.
Values have the same meaning as the similarly named arguments to
@@ -2098,6 +2092,7 @@ makePngLine(png_byte * const line,
gray * const alpha_mask,
colorhash_table const cht,
coloralphahash_table const caht,
+ png_struct * const png_ptr,
png_info * const info_ptr,
xelval const png_maxval,
unsigned int const depth) {
@@ -2110,20 +2105,20 @@ makePngLine(png_byte * const line,
xel p_png;
xel const p = xelrow[col];
PPM_DEPTH(p_png, p, maxval, png_maxval);
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY ||
+ png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA) {
if (depth == 16)
*pp++ = PNM_GET1(p_png) >> 8;
*pp++ = PNM_GET1(p_png) & 0xff;
- } else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+ } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
unsigned int paletteIndex;
if (alpha)
paletteIndex = lookupColorAlpha(caht, &p, &alpha_mask[col]);
else
paletteIndex = ppm_lookupcolor(cht, &p);
*pp++ = paletteIndex;
- } else if (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
+ } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB ||
+ png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA) {
if (depth == 16)
*pp++ = PPM_GETR(p_png) >> 8;
*pp++ = PPM_GETR(p_png) & 0xff;
@@ -2136,7 +2131,7 @@ makePngLine(png_byte * const line,
} else
pm_error("INTERNAL ERROR: undefined color_type");
- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) {
+ if (png_get_color_type(png_ptr, info_ptr) & PNG_COLOR_MASK_ALPHA) {
int const png_alphaval = (int)
alpha_mask[col] * (float) png_maxval / maxval + 0.5;
if (depth == 16)
@@ -2193,7 +2188,7 @@ writeRaster(png_struct * const png_ptr,
makePngLine(line, xelrow, cols, maxval,
alpha, alpha ? alpha_mask[row] : NULL,
- cht, caht, info_ptr, png_maxval, depth);
+ cht, caht, png_ptr, info_ptr, png_maxval, depth);
png_write_row(png_ptr, line);
}
@@ -2205,12 +2200,12 @@ writeRaster(png_struct * const png_ptr,
static void
doGamaChunk(struct cmdlineInfo const cmdline,
+ png_struct * const png_ptr,
png_info * const info_ptr) {
if (cmdline.gammaSpec) {
/* gAMA chunk */
- info_ptr->valid |= PNG_INFO_gAMA;
- info_ptr->gamma = cmdline.gamma;
+ png_set_gAMA(png_ptr, info_ptr, cmdline.gamma);
}
}
@@ -2218,20 +2213,15 @@ doGamaChunk(struct cmdlineInfo const cmdline,
static void
doChrmChunk(struct cmdlineInfo const cmdline,
+ png_struct * const png_ptr,
png_info * const info_ptr) {
if (cmdline.rgbSpec) {
/* cHRM chunk */
- info_ptr->valid |= PNG_INFO_cHRM;
-
- info_ptr->x_white = cmdline.rgb.wx;
- info_ptr->y_white = cmdline.rgb.wy;
- info_ptr->x_red = cmdline.rgb.rx;
- info_ptr->y_red = cmdline.rgb.ry;
- info_ptr->x_green = cmdline.rgb.gx;
- info_ptr->y_green = cmdline.rgb.gy;
- info_ptr->x_blue = cmdline.rgb.bx;
- info_ptr->y_blue = cmdline.rgb.by;
+
+ png_set_cHRM (png_ptr, info_ptr, cmdline.rgb.wx, cmdline.rgb.wy,
+ cmdline.rgb.rx, cmdline.rgb.ry, cmdline.rgb.gx,
+ cmdline.rgb.gy, cmdline.rgb.bx, cmdline.rgb.by);
}
}
@@ -2239,15 +2229,12 @@ doChrmChunk(struct cmdlineInfo const cmdline,
static void
doPhysChunk(struct cmdlineInfo const cmdline,
+ png_struct * const png_ptr,
png_info * const info_ptr) {
if (cmdline.sizeSpec) {
/* pHYS chunk */
- info_ptr->valid |= PNG_INFO_pHYs;
-
- info_ptr->x_pixels_per_unit = cmdline.size.x;
- info_ptr->y_pixels_per_unit = cmdline.size.y;
- info_ptr->phys_unit_type = cmdline.size.unit;
+ png_set_pHYs(png_ptr, info_ptr, cmdline.size.x, cmdline.size.y, cmdline.size.unit);
}
}
@@ -2256,26 +2243,28 @@ doPhysChunk(struct cmdlineInfo const cmdline,
static void
doTimeChunk(struct cmdlineInfo const cmdline,
+ png_struct * const png_ptr,
png_info * const info_ptr) {
if (cmdline.modtimeSpec) {
/* tIME chunk */
- info_ptr->valid |= PNG_INFO_tIME;
-
- png_convert_from_time_t(&info_ptr->mod_time, cmdline.modtime);
+ png_timep ptime;
+ png_convert_from_time_t(ptime, cmdline.modtime);
+ png_set_tIME(png_ptr, info_ptr, ptime);
}
}
static void
-doSbitChunk(png_info * const pngInfoP,
+doSbitChunk(png_struct * const pngP,
+ png_info * const pngInfoP,
xelval const pngMaxval,
xelval const maxval,
bool const alpha,
xelval const alphaMaxval) {
- if (pngInfoP->color_type != PNG_COLOR_TYPE_PALETTE &&
+ if (png_get_color_type(pngP, pngInfoP) != PNG_COLOR_TYPE_PALETTE &&
(pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) {
/* We're writing in a bit depth that doesn't match the maxval
@@ -2294,27 +2283,29 @@ doSbitChunk(png_info * const pngInfoP,
sBIT chunk.
*/
- pngInfoP->valid |= PNG_INFO_sBIT;
-
{
int const sbitval = pm_maxvaltobits(MIN(maxval, pngMaxval));
+ png_color_8 sbit;
- if (pngInfoP->color_type & PNG_COLOR_MASK_COLOR) {
- pngInfoP->sig_bit.red = sbitval;
- pngInfoP->sig_bit.green = sbitval;
- pngInfoP->sig_bit.blue = sbitval;
+ (void)memset(&sbit, 0, sizeof(sbit));
+ if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_COLOR) {
+ sbit.red = sbitval;
+ sbit.green = sbitval;
+ sbit.blue = sbitval;
} else
- pngInfoP->sig_bit.gray = sbitval;
+ sbit.gray = sbitval;
if (verbose)
pm_message("Writing sBIT chunk with bits = %d", sbitval);
+
+ if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_ALPHA) {
+ sbit.alpha =
+ pm_maxvaltobits(MIN(alphaMaxval, pngMaxval));
+ if (verbose)
+ pm_message(" alpha bits = %d", sbit.alpha);
+ }
+ png_set_sBIT(pngP, pngInfoP, &sbit);
}
- if (pngInfoP->color_type & PNG_COLOR_MASK_ALPHA) {
- pngInfoP->sig_bit.alpha =
- pm_maxvaltobits(MIN(alphaMaxval, pngMaxval));
- if (verbose)
- pm_message(" alpha bits = %d", pngInfoP->sig_bit.alpha);
- }
}
}
@@ -2410,6 +2401,8 @@ convertpnm(struct cmdlineInfo const cmdline,
xelval maxmaxval;
gray ** alpha_mask;
+ int color_type;
+
/* these guys are initialized to quiet compiler warnings: */
maxmaxval = 255;
alpha_mask = NULL;
@@ -2595,43 +2588,42 @@ convertpnm(struct cmdlineInfo const cmdline,
pm_error ("setjmp returns error condition (2)");
}
- png_init_io (png_ptr, stdout);
- info_ptr->width = cols;
- info_ptr->height = rows;
- info_ptr->bit_depth = depth;
-
if (colorMapped)
- info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
- else if (pnm_type == PPM_TYPE)
- info_ptr->color_type = PNG_COLOR_TYPE_RGB;
- else
- info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
+ color_type = PNG_COLOR_TYPE_PALETTE;
+ else if (pnm_type == PPM_TYPE) {
+ if (alpha)
+ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ else
+ color_type = PNG_COLOR_TYPE_RGB;
+ } else {
+ if (alpha)
+ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ else
+ color_type = PNG_COLOR_TYPE_GRAY;
+ }
- if (alpha && info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
+ png_set_IHDR(png_ptr, info_ptr, cols, rows, depth, color_type, 0, 0, 0);
+ png_init_io (png_ptr, stdout);
- info_ptr->interlace_type = cmdline.interlace;
+ if (cmdline.interlace)
+ png_set_interlace_handling(png_ptr);
- doGamaChunk(cmdline, info_ptr);
+ doGamaChunk(cmdline, png_ptr, info_ptr);
- doChrmChunk(cmdline, info_ptr);
+ doChrmChunk(cmdline, png_ptr, info_ptr);
- doPhysChunk(cmdline, info_ptr);
+ doPhysChunk(cmdline, png_ptr, info_ptr);
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
/* creating PNG palette (PLTE and tRNS chunks) */
createPngPalette(palette_pnm, palette_size, maxval,
trans_pnm, trans_size, alpha_maxval,
palette, trans);
- info_ptr->valid |= PNG_INFO_PLTE;
- info_ptr->palette = palette;
- info_ptr->num_palette = palette_size;
+ png_set_PLTE(png_ptr, info_ptr, palette, palette_size);
if (trans_size > 0) {
info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->trans = trans;
+ info_ptr->trans_alpha = trans;
info_ptr->num_trans = trans_size; /* omit opaque values */
- info_ptr->num_trans = trans_size; /* omit opaque values */
+ png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL);
}
/* creating hIST chunk */
@@ -2667,7 +2669,7 @@
info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
if (cmdline.hist) {
@@ -2657,18 +2649,17 @@ convertpnm(struct cmdlineInfo const cmdline,
ppm_freecolorhash(cht);
- info_ptr->valid |= PNG_INFO_hIST;
- info_ptr->hist = histogram;
+ png_set_hIST(png_ptr, info_ptr, histogram);
if (verbose)
pm_message("histogram created");
}
} else { /* color_type != PNG_COLOR_TYPE_PALETTE */
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY ||
+ png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) {
if (transparent > 0) {
info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->trans_values =
+ info_ptr->trans_color =
xelToPngColor_16(transcolor, maxval, png_maxval);
- xelToPngColor_16(transcolor, maxval, png_maxval);
+ png_color_16 trans_color = xelToPngColor_16(transcolor, maxval, png_maxval);
+ png_set_tRNS(png_ptr, info_ptr, NULL, 0, &trans_color);
+
}
} else {
@@ -2679,10 +2681,10 @@
if (info_ptr->valid && PNG_INFO_tRNS)
/* This is PNG_COLOR_MASK_ALPHA. Transparency will be handled
@@ -2676,43 +2667,49 @@ convertpnm(struct cmdlineInfo const cmdline,
*/
}
if (verbose) {
- if (info_ptr->valid && PNG_INFO_tRNS)
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+ png_color_16p trans_color;
+
+ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_color);
pm_message("Transparent color {gray, red, green, blue} = "
"{%d, %d, %d, %d}",
- info_ptr->trans_values.gray,
- info_ptr->trans_values.red,
- info_ptr->trans_values.green,
- info_ptr->trans_values.blue);
+ info_ptr->trans_color.gray,
+ info_ptr->trans_color.red,
+ info_ptr->trans_color.green,
+ info_ptr->trans_color.blue);
else
- else
+ trans_color->gray,
+ trans_color->red,
+ trans_color->green,
+ trans_color->blue);
+ } else
pm_message("No transparent color");
}
}
/* bKGD chunk */
if (cmdline.background) {
- info_ptr->valid |= PNG_INFO_bKGD;
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
- info_ptr->background.index = background_index;
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
+ png_color_16 background;
+
+ (void)memset(&background, 0, sizeof(background));
+ background.index = background_index;
+ png_set_bKGD(png_ptr, info_ptr, &background);
} else {
- info_ptr->background =
- xelToPngColor_16(backcolor, maxval, png_maxval);
+ png_color_16 background = xelToPngColor_16(backcolor, maxval, png_maxval);
+ png_set_bKGD(png_ptr, info_ptr, &background);
if (verbose)
pm_message("Writing bKGD chunk with background color "
" {gray, red, green, blue} = {%d, %d, %d, %d}",
- info_ptr->background.gray,
- info_ptr->background.red,
- info_ptr->background.green,
- info_ptr->background.blue );
+ background.gray,
+ background.red,
+ background.green,
+ background.blue );
}
}
- doSbitChunk(info_ptr, png_maxval, maxval, alpha, alpha_maxval);
+ doSbitChunk(png_ptr, info_ptr, png_maxval, maxval, alpha, alpha_maxval);
/* tEXT and zTXT chunks */
if (cmdline.text || cmdline.ztxt)
- pnmpng_read_text(info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
+ pnmpng_read_text(png_ptr, info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
- doTimeChunk(cmdline, info_ptr);
+ doTimeChunk(cmdline, png_ptr, info_ptr);
if (cmdline.filterSet != 0)
png_set_filter(png_ptr, 0, cmdline.filterSet);
@@ -2722,6 +2719,7 @@ convertpnm(struct cmdlineInfo const cmdline,
/* write the png-info struct */
png_write_info(png_ptr, info_ptr);
+#if 0
if (cmdline.text || cmdline.ztxt)
/* prevent from being written twice with png_write_end */
info_ptr->num_text = 0;
@@ -2729,6 +2727,7 @@ convertpnm(struct cmdlineInfo const cmdline,
if (cmdline.modtime)
/* prevent from being written twice with png_write_end */
info_ptr->valid &= ~PNG_INFO_tIME;
+#endif
/* let libpng take care of, e.g., bit-depth conversions */
png_set_packing (png_ptr);