static void
srf_img_init(struct srf_img * const imgP,
uint16_t const width,
uint16_t const height) {
struct srf_img_header * const headerP = &imgP->header;
struct srf_img_alpha * const alphaP = &imgP->alpha;
struct srf_img_data * const dataP = &imgP->data;
headerP->_ints[0] = 0;
headerP->_ints[1] = 16;
headerP->_ints[2] = 0;
headerP->height = height;
headerP->width = width;
headerP->_bytes[0] = 16;
headerP->_bytes[1] = 8;
headerP->line_len = width * 2;
headerP->zeros = 0;
alphaP->type = 11;
alphaP->data_len = height * width;
MALLOCARRAY(alphaP->data, alphaP->data_len);
if (!alphaP->data)
pm_error("Could not allocate buffer for %u bytes of alpha",
alphaP->data_len);
dataP->type = 1;
dataP->data_len = height * width * 2;
MALLOCARRAY(dataP->data, dataP->data_len / 2);
if (!dataP->data)
pm_error("Could not allocation buffer for %u units of data",
dataP->data_len);
}
static void
openFiles(struct CmdlineInfo const cmdline,
unsigned int * const fileCtP,
struct pam ** const imgPamP,
const char *** const namesP) {
unsigned int fileCt;
struct pam * imgPam;
const char ** names;
fileCt = cmdline.nFiles > 0 ? cmdline.nFiles : 1;
MALLOCARRAY(imgPam, fileCt);
MALLOCARRAY(names, fileCt);
if (!imgPam || !names)
pm_error("out of memory");
if (cmdline.nFiles > 0) {
unsigned int i;
for (i = 0; i < cmdline.nFiles; ++i) {
imgPam[i].file = pm_openr(cmdline.inFileName[i]);
names[i] = strdup(cmdline.inFileName[i]);
}
} else {
imgPam[0].file = stdin;
names[0] = strdup("stdin");
}
*fileCtP = fileCt;
*imgPamP = imgPam;
*namesP = names;
}
static void
findpack(struct pam * const imgs,
unsigned int const imgCt,
Coord ** const coordsP,
unsigned int const quality,
unsigned int const qfactor) {
Coord * coords; /* malloc'ed array */
unsigned int minarea;
unsigned int i;
unsigned int rdiv;
unsigned int cdiv;
Rectangle * current; /* malloc'ed array */
unsigned int z;
Coord c;
MALLOCARRAY(coords, imgCt);
if (!coords)
pm_error("Out of memory allocating %u-element coords array", imgCt);
z = UINT_MAX; /* initial value */
c.x = 0; c.y = 0; /* initial value */
if (quality > 1) {
unsigned int realMinarea;
for (realMinarea = i = 0; i < imgCt; ++i)
realMinarea += imgs[i].height * imgs[i].width;
minarea = realMinarea * qfactor / 100;
} else
minarea = UINT_MAX - 1;
/* It's relatively easy to show that, if all the images
* are multiples of a particular size, then a best
* packing will always align the images on a grid of
* that size.
*
* This speeds computation immensely.
*/
for (rdiv = imgs[0].height, i = 1; i < imgCt; ++i)
rdiv = gcf(imgs[i].height, rdiv);
for (cdiv = imgs[0].width, i = 1; i < imgCt; ++i)
cdiv = gcf(imgs[i].width, cdiv);
MALLOCARRAY(current, imgCt);
for (i = 0; i < imgCt; ++i) {
current[i].size.x = imgs[i].width;
current[i].size.y = imgs[i].height;
}
recursefindpack(current, c, coords, minarea, &z, 0, imgCt, cdiv, rdiv,
quality, qfactor);
free(current);
*coordsP = coords;
}
static void
newRGBMapData(RGBMap * const rgbP,
unsigned int const size) {
rgbP->used = 0;
rgbP->size = size;
rgbP->compressed = FALSE;
MALLOCARRAY(rgbP->red, size);
MALLOCARRAY(rgbP->grn, size);
MALLOCARRAY(rgbP->blu, size);
if (rgbP->red == NULL || rgbP->grn == NULL || rgbP->blu == NULL)
pm_error("Out of memory allocating %u pixels", size);
}
static void
findpack(struct pam *imgs, int n, coord *coords)
{
int minarea;
int i;
int rdiv;
int cdiv;
int minx = -1;
int miny = -1;
coord *current;
coord *set;
int z = INT_MAX;
coord c = { 0, 0 };
if (quality > 1)
{
for (minarea = i = 0; i < n; ++i)
minarea += imgs[i].height * imgs[i].width,
minx = imax(minx, imgs[i].width),
miny = imax(miny, imgs[i].height);
minarea = minarea * qfactor / 100;
}
else
{
minarea = INT_MAX - 1;
}
/* It's relatively easy to show that, if all the images
* are multiples of a particular size, then a best
* packing will always align the images on a grid of
* that size.
*
* This speeds computation immensely.
*/
for (rdiv = imgs[0].height, i = 1; i < n; ++i)
rdiv = gcd(imgs[i].height, rdiv);
for (cdiv = imgs[0].width, i = 1; i < n; ++i)
cdiv = gcd(imgs[i].width, cdiv);
MALLOCARRAY(current, n);
MALLOCARRAY(set, n);
for (i = 0; i < n; ++i)
set[i].x = imgs[i].width,
set[i].y = imgs[i].height;
recursefindpack(current, c, set, coords, minarea, &z, 0, n, cdiv, rdiv);
}
void
ppmd_read_font(FILE * const ifP,
const struct ppmd_font ** const fontPP) {
unsigned int relativeCodePoint;
struct ppmd_glyph * glyphTable;
struct ppmd_font * fontP;
MALLOCVAR(fontP);
if (fontP == NULL)
pm_error("Insufficient memory for font header");
readFontHeader(ifP, &fontP->header);
MALLOCARRAY(glyphTable, fontP->header.characterCount);
if (glyphTable == NULL)
pm_error("Insufficient memory to store %u characters",
fontP->header.characterCount);
for (relativeCodePoint = 0;
relativeCodePoint < fontP->header.characterCount;
++relativeCodePoint) {
readCharacter(ifP, &glyphTable[relativeCodePoint]);
}
fontP->glyphTable = glyphTable;
*fontPP = fontP;
}
static void
analyzeDistribution(struct pam * const inpamP,
bool const verbose,
const unsigned int ** const histogramP,
struct range * const rangeP) {
/*----------------------------------------------------------------------------
Find the distribution of the sample values -- minimum, maximum, and
how many of each value -- in input image *inpamP, whose file is
positioned to the raster.
Return the minimum and maximum as *rangeP and the frequency
distribution as *histogramP, an array such that histogram[i] is the
number of pixels that have sample value i.
Assume the file is positioned to the raster upon entry and leave
it positioned at the same place.
-----------------------------------------------------------------------------*/
unsigned int row;
tuple * inrow;
tuplen * inrown;
unsigned int * histogram; /* malloced array */
unsigned int i;
pm_filepos rasterPos; /* Position in input file of the raster */
pm_tell2(inpamP->file, &rasterPos, sizeof(rasterPos));
inrow = pnm_allocpamrow(inpamP);
inrown = pnm_allocpamrown(inpamP);
MALLOCARRAY(histogram, inpamP->maxval+1);
if (histogram == NULL)
pm_error("Unable to allocate space for %lu-entry histogram",
inpamP->maxval+1);
/* Initialize histogram -- zero occurrences of everything */
for (i = 0; i <= inpamP->maxval; ++i)
histogram[i] = 0;
initRange(rangeP);
for (row = 0; row < inpamP->height; ++row) {
unsigned int col;
pnm_readpamrow(inpamP, inrow);
pnm_normalizeRow(inpamP, inrow, NULL, inrown);
for (col = 0; col < inpamP->width; ++col) {
++histogram[inrow[col][0]];
addToRange(rangeP, inrown[col][0]);
}
}
*histogramP = histogram;
pnm_freepamrow(inrow);
pnm_freepamrown(inrown);
pm_seek2(inpamP->file, &rasterPos, sizeof(rasterPos));
if (verbose)
pm_message("Pixel values range from %f to %f",
rangeP->min, rangeP->max);
}
struct fillobj *
pamd_fill_create(void) {
fillobj * fillObjP;
struct fillState * stateP;
MALLOCVAR(fillObjP);
if (fillObjP == NULL)
pm_error("out of memory allocating a fillhandle");
MALLOCVAR(stateP);
if (stateP == NULL)
pm_error("out of memory allocating a fillhandle");
stateP->n = 0;
stateP->size = SOME;
MALLOCARRAY(stateP->coords, stateP->size);
if (stateP->coords == NULL)
pm_error("out of memory allocating a fillhandle");
stateP->curedge = 0;
fillObjP->stateP = stateP;
/* Turn off line clipping. */
/* UGGH! We must eliminate this global variable */
oldclip = pamd_setlineclip(0);
return fillObjP;
}
Image *
newRGBImage(unsigned int const width,
unsigned int const height,
unsigned int const depth) {
unsigned int const pixlen = depth > 0 ? (depth + 7) / 8 : 1;
/* Special case for "zero" depth image, which is sometimes
interpreted as "one color"
*/
unsigned int const numcolors = depthToColors(depth);
Image * imageP;
MALLOCVAR_NOFAIL(imageP);
imageP->type = IRGB;
newRGBMapData(&imageP->rgb, numcolors);
imageP->width = width;
imageP->height = height;
imageP->depth = depth;
imageP->pixlen = pixlen;
if (UINT_MAX / width / height < pixlen)
pm_error("Image dimensions %u x %u x %u are too big to compute.",
width, height, pixlen);
MALLOCARRAY(imageP->data, width * height * pixlen);
if (imageP->data == NULL)
pm_error("Unable to allocate %u x %u x %u raster array",
width, height, pixlen);
return imageP;
}
Image *
newBitImage(unsigned int const width,
unsigned int const height) {
unsigned int const linelen = (width + 7) / 8;
Image * imageP;
MALLOCVAR_NOFAIL(imageP);
imageP->type = IBITMAP;
newRGBMapData(&imageP->rgb, 2);
imageP->rgb.red[0] = imageP->rgb.grn[0] = imageP->rgb.blu[0] = 65535;
imageP->rgb.red[1] = imageP->rgb.grn[1] = imageP->rgb.blu[1] = 0;
imageP->rgb.used = 2;
imageP->width = width;
imageP->height = height;
imageP->depth = 1;
if (UINT_MAX / linelen < height)
pm_error("Image dimensions too big to compute: %u x %u",
linelen, height);
MALLOCARRAY(imageP->data, linelen * height);
if (imageP->data == NULL)
pm_error("Out of memory allocating array of %u x %u", linelen, height);
return imageP;
}
Image *
newTrueImage(unsigned int const width,
unsigned int const height) {
unsigned int const pixlen = 3;
Image * imageP;
MALLOCVAR_NOFAIL(imageP);
imageP->type = ITRUE;
imageP->rgb.used = 0;
imageP->rgb.size = 0;
imageP->width = width;
imageP->height = height;
imageP->depth = 24;
imageP->pixlen = 3;
if (UINT_MAX / width / height < pixlen)
pm_error("Image dimensions %u x %u x %u are too big to compute.",
width, height, pixlen);
MALLOCARRAY(imageP->data, width * height * pixlen);
if (imageP->data == NULL)
pm_error("Unable to allocate %u x %u x %u raster array",
width, height, pixlen);
return imageP;
}
static struct optionx *
createLongOptsArray(struct optionDesc * const optionDescArray,
unsigned int const numOptions) {
struct optionx * longopts;
MALLOCARRAY(longopts, numOptions+1);
if (longopts != NULL) {
unsigned int i;
for (i = 0; i < numOptions; ++i) {
longopts[i].name = optionDescArray[i].name;
/* If the option takes a value, we say it is optional even
though it never is. That's because if we say it is
mandatory, getopt_long_only() pretends it doesn't even
recognize the option if the user doesn't give a value.
We prefer to generate a meaningful error message when
the user omits a required option value.
*/
longopts[i].has_arg =
optionDescArray[i].type == OPTTYPE_FLAG ?
no_argument : optional_argument;
longopts[i].flag = NULL;
longopts[i].val = i;
}
longopts[numOptions].name = 0;
longopts[numOptions].has_arg = 0;
longopts[numOptions].flag = 0;
longopts[numOptions].val = 0;
}
return longopts;
}
static void
ppm_writeppmrowraw(FILE * const fileP,
const pixel * const pixelrow,
unsigned int const cols,
pixval const maxval ) {
unsigned int const bytesPerSample = maxval < 256 ? 1 : 2;
unsigned int const bytesPerRow = cols * 3 * bytesPerSample;
unsigned char * rowBuffer;
ssize_t rc;
MALLOCARRAY(rowBuffer, bytesPerRow);
if (rowBuffer == NULL)
pm_error("Unable to allocate memory for row buffer "
"for %u columns", cols);
if (maxval < 256)
format1bpsRow(pixelrow, cols, rowBuffer);
else
format2bpsRow(pixelrow, cols, rowBuffer);
rc = fwrite(rowBuffer, 1, bytesPerRow, fileP);
if (rc < 0)
pm_error("Error writing row. fwrite() errno=%d (%s)",
errno, strerror(errno));
else if (rc != bytesPerRow)
pm_error("Error writing row. Short write of %u bytes "
"instead of %u", rc, bytesPerRow);
free(rowBuffer);
}
void
xmlrpc_authcookie_set(xmlrpc_env *const envP,
const char *const username,
const char *const password) {
char *unencoded;
xmlrpc_mem_block *token;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(username);
XMLRPC_ASSERT_PTR_OK(password);
/* Create unencoded string/hash. */
MALLOCARRAY(unencoded, (strlen(username) + strlen(password) + 1 + 1));
sprintf(unencoded, "%s:%s", username, password);
/* Create encoded string. */
token = xmlrpc_base64_encode_without_newlines(
envP, (unsigned char *) unencoded, strlen(unencoded));
if (!envP->fault_occurred) {
/* Set HTTP_COOKIE_AUTH to the character representation of the
encoded string.
*/
#if HAVE_SETENV
setenv("HTTP_COOKIE_AUTH",
XMLRPC_MEMBLOCK_CONTENTS(char, token),
1);
#endif
xmlrpc_mem_block_free(token);
}
at_bitmap_type
at_bitmap_init(unsigned char * area,
unsigned short width,
unsigned short height,
unsigned int planes) {
at_bitmap_type bitmap;
if (area)
bitmap.bitmap = area;
else {
if (width * height == 0)
bitmap.bitmap = NULL;
else {
MALLOCARRAY(bitmap.bitmap, width * height * planes);
if (bitmap.bitmap == NULL)
pm_error("Unable to allocate %u x %u x %u bitmap array",
width, height, planes);
bzero(bitmap.bitmap,
width * height * planes * sizeof(unsigned char));
}
}
bitmap.width = width;
bitmap.height = height;
bitmap.np = planes;
return bitmap;
}
/* ----------------------------------------------------------------------------
** procedure for making the Abel integration for deconvolution of the image
** y <-> array with values for deconvolution and results
** N <- width of the array
** adl <- array with pre-calculated weighting factors
*/
static void
abel ( float *y, int N, double *adl)
{
register int n;
double *rho, *rhop; /* results and new index */
float *yp; /* new indizes for the y-array */
MALLOCARRAY(rho, N);
if( !rho )
pm_error( "out of memory" );
rhop = rho;
yp = y;
for (n=0 ; n<N ; n++)
{
*(rhop++) = ((*yp++) - Sum(n,rho,N,adl))/(adl[n*N+n]);
/* *(rhop++) = ((*yp++) - Sum(n,rho,N))/(dr(n,n+0.5,N)); old version */
if ( *rhop < 0.0 ) *rhop = 0.0; /* error correction ! */
/* if (n > 2) rhop[n-1] = (rho[n-2]+rho[n-1]+rho[n])/3.0; stabilization*/
}
for (n=0 ; n<N ; n++)
{
if (( n>=1 )&&( n<N-1 ))
(*y++) = ((rho[n-1]*0.5+rho[n]+rho[n+1]*0.5)/2.0);/*1D median filter*/
else (*y++) = rho[n];
}
free(rho);
}
static void
extractArguments(struct cmdlineParserCtl * const cpP,
unsigned int const argc,
const char ** const argv) {
cpP->numArguments = argc - getopt_argstart();
MALLOCARRAY(cpP->argumentArray, cpP->numArguments);
if (cpP->argumentArray == NULL) {
fprintf(stderr, "Unable to allocate memory for argument array "
"(%u arguments)\n", cpP->numArguments);
abort();
} else {
unsigned int i;
for (i = 0; i < cpP->numArguments; ++i) {
cpP->argumentArray[i] = strdup(argv[getopt_argstart() + i]);
if (cpP->argumentArray[i] == NULL) {
fprintf(stderr, "Unable to allocate memory for Argument %u\n",
i);
abort();
}
}
}
}
static void
createHist(bool const colorWanted[3],
unsigned int const histWidth,
unsigned int * (* const histP)[3]) {
/*----------------------------------------------------------------------------
Allocate the histogram arrays and set each slot count to zero.
-----------------------------------------------------------------------------*/
unsigned int color;
for (color = 0; color < 3; ++color) {
if (colorWanted[color]) {
unsigned int * hist;
unsigned int i;
MALLOCARRAY(hist, histWidth);
if (hist == NULL)
pm_error("Not enough memory for histogram arrays (%u bytes)",
histWidth * (unsigned)sizeof(hist[0]) * 3);
for (i = 0; i < histWidth; ++i)
hist[i] = 0;
(*histP)[color] = hist;
} else
(*histP)[color] = NULL;
}
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Convert program invocation arguments (argc,argv) into a format the
program can use easily, struct cmdlineInfo. Validate arguments along
the way and exit program with message if invalid.
Note that some string information we return as *cmdlineP is in the storage
argv[] points to.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int maxvalSpec;
unsigned int option_def_index;
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval, &maxvalSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = false; /* We have no short (old-fashioned) options */
opt.allowNegNum = false; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!maxvalSpec)
cmdlineP->maxval = PPM_MAXMAXVAL;
else {
if (cmdlineP->maxval > PPM_OVERALLMAXVAL)
pm_error("The value you specified for -maxval (%u) is too big. "
"Max allowed is %u", cmdlineP->maxval, PPM_OVERALLMAXVAL);
if (cmdlineP->maxval < 1)
pm_error("You cannot specify 0 for -maxval");
}
if (argc-1 < 3)
pm_error("Need 3 arguments: color, width, height.");
else if (argc-1 > 3)
pm_error("Only 3 arguments allowed: color, width, height. "
"You specified %d", argc-1);
else {
cmdlineP->color = ppm_parsecolor(argv[1], cmdlineP->maxval);
cmdlineP->cols = atoi(argv[2]);
cmdlineP->rows = atoi(argv[3]);
if (cmdlineP->cols <= 0)
pm_error("width argument must be a positive number. You "
"specified '%s'", argv[2]);
if (cmdlineP->rows <= 0)
pm_error("height argument must be a positive number. You "
"specified '%s'", argv[3]);
}
}
static void
load(const struct pam * const pamP,
unsigned int const hstep,
sample *** const pixelsP,
unsigned int * const hsamplesP) {
/*----------------------------------------------------------------------------
read file into memory, returning array of rows
-----------------------------------------------------------------------------*/
unsigned int const hsamples = 1 + (pamP->width - 1) / hstep;
/* use only this many cols */
unsigned int row;
tuple * tuplerow;
sample ** pixels;
tuplerow = pnm_allocpamrow(pamP);
MALLOCARRAY(pixels, pamP->height);
if (pixels == NULL)
pm_error("Unable to allocate array of %u pixel rows",
pamP->height);
if (pixels == NULL)
pm_error("Unable to allocate array of %u rows", pamP->height);
for (row = 0; row < pamP->height; ++row) {
unsigned int i;
unsigned int col;
pnm_readpamrow(pamP, tuplerow);
MALLOCARRAY(pixels[row], hsamples);
if (pixels[row] == NULL)
pm_error("Unable to allocate %u-sample array for Row %u",
hsamples, row);
/* save every hstep'th column */
for (i = col = 0; i < hsamples; ++i, col += hstep)
pixels[row][i] = tuplerow[col][0];
}
pnm_freepamrow(tuplerow);
*hsamplesP = hsamples;
*pixelsP = pixels;
}
void
rle_addhist(char * argv[],
rle_hdr * const in_hdr,
rle_hdr * const out_hdr) {
const char * const histoire = "HISTORY";
const char * const padding = "\t";
int length;
int i;
time_t temp;
/* padding must give number of characters in histoire */
/* plus one for "=" */
char * timedate;
const char * old;
static char * newc;
if (getenv("NO_ADD_RLE_HISTORY"))
return;
length = 0;
for (i = 0; argv[i]; ++i)
length += strlen(argv[i]) +1; /* length of each arg plus space. */
time(&temp);
timedate = ctime(&temp);
length += strlen(timedate); /* length of date and time in ASCII. */
length += strlen(padding) + 3 + strlen(histoire) + 1;
/* length of padding, "on " and length of history name plus "="*/
if (in_hdr) /* if we are interested in the old comments... */
old = rle_getcom(histoire, in_hdr); /* get old comment. */
else
old = NULL;
if (old && *old)
length += strlen(old); /* add length if there. */
++length; /*Cater for the null. */
MALLOCARRAY(newc, length);
if (newc == NULL)
return;
strcpy(newc,histoire);(void)strcat(newc,"=");
if (old && *old)
strcat(newc, old); /* add old string if there. */
for (i=0;argv[i];i++) {
strcat(newc, argv[i]);
strcat(newc, " ");
}
strcat(newc,"on ");
strcat(newc,timedate); /* \n supplied by time. */
strcat(newc,padding); /* to line up multiple histories.*/
rle_putcom(newc, out_hdr);
}
static void
readToken(char const textline[],
unsigned int const lineLength,
unsigned int * const cursorP,
const char ** const tokenP) {
/*----------------------------------------------------------------------------
Read a token from 'textline' (whose length is 'lineLength'), assuming the
cursor is positioned to it now, leaving the cursor positioned after it.
Tokens are delimited by white space. We don't skip any white space before
or after the token. Ergo, if we are positioned to white space right now,
the token we read is a null string.
-----------------------------------------------------------------------------*/
char * tokenBuffer;
char * cp;
unsigned int cursor;
cursor = *cursorP;
MALLOCARRAY(tokenBuffer, lineLength + 1);
/* leave room for terminating NUL */
if (tokenBuffer == NULL)
pm_error("Unable to allocate memory for a %u-character "
"text string file line", lineLength);
cp = &tokenBuffer[0]; /* initial value */
if (textline[0] == '"') {
++cursor; /* skip past opening quotation mark */
while (textline[cursor] != '"') {
if (cursor >= lineLength)
pm_error("Invalid text string file format. Line ends in "
"the middle of a quoted token. Text at the end of "
"the line is '%s'", tokenBuffer);
if (textline[cursor] == '\0')
pm_error("Invalid text string file format: Token contains "
"a NUL character. Text leading up to the NUL "
"character is '%s'", tokenBuffer);
*(cp++) = textline[cursor++];
}
++cursor; /* skip past closing quotation mark */
} else {
while ((cursor < lineLength) &&
(textline[cursor] != ' ') && (textline[cursor] != '\t')) {
if (textline[cursor] == '\0')
pm_error("Invalid text string file format: Token contains "
"a NUL character. Text leading up to the NUL "
"character is '%s'", tokenBuffer);
*(cp++) = textline[cursor++];
}
}
*cp++ = '\0';
*cursorP = cursor;
*tokenP = tokenBuffer;
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int dpiSpec, copiesSpec, compressSpec;
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "resolution", OPT_UINT, &cmdlineP->dpi,
&dpiSpec, 0);
OPTENT3(0, "copies", OPT_UINT, &cmdlineP->copies,
&copiesSpec, 0);
OPTENT3(0, "float", OPT_FLAG, NULL,
&cmdlineP->floating, 0);
OPTENT3(0, "noreset", OPT_FLAG, NULL,
&cmdlineP->noreset, 0);
OPTENT3(0, "packbits", OPT_FLAG, NULL,
&cmdlineP->pack, 0);
OPTENT3(0, "delta", OPT_FLAG, NULL,
&cmdlineP->delta, 0);
OPTENT3(0, "compress", OPT_FLAG, NULL,
&compressSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 == 0)
cmdlineP->inputFilename = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->inputFilename = argv[1];
if (!dpiSpec)
cmdlineP->dpi = 75;
if (!copiesSpec)
cmdlineP->copies = 1;
if (compressSpec) {
cmdlineP->pack = 1;
cmdlineP->delta = 1;
}
}
static int
rechdrRead(RECHDR * const rechdrP,
FILE * const fileP) {
int retval;
off_t len;
pm_readbiglongu2(fileP, &rechdrP->offset);
len = (off_t)rechdrP->offset - ftell(fileP);
switch(len) {
case 4:
case 12:
/*
* Version zero (eight bytes of record header) or version
* two with a note (two chunks of eight record header bytes).
*/
fread(&rechdrP->unknown[0], 1, 3, fileP);
fread(&rechdrP->rec_type, 1, 1, fileP);
rechdrP->n_extra = 0;
rechdrP->extra = NULL;
retval = 0;
break;
case 6:
/*
* Version one (ten bytes of record header).
*/
fread(&rechdrP->unknown[0], 1, 3, fileP);
fread(&rechdrP->rec_type, 1, 1, fileP);
rechdrP->n_extra = 2;
MALLOCARRAY(rechdrP->extra, rechdrP->n_extra);
if (rechdrP->extra == NULL)
retval = ENOMEM;
else {
fread(rechdrP->extra, 1, rechdrP->n_extra, fileP);
retval = 0;
}
break;
default:
/*
* hmmm.... I'll assume this is the record header
* for a text record.
*/
fread(&rechdrP->unknown[0], 1, 3, fileP);
fread(&rechdrP->rec_type, 1, 1, fileP);
rechdrP->n_extra = 0;
rechdrP->extra = NULL;
retval = 0;
break;
}
if (retval == 0) {
if ((rechdrP->rec_type != IMG_REC && rechdrP->rec_type != TEXT_REC)
|| !memeq(rechdrP->unknown, IPDB_MYST, 3))
retval = E_NOTRECHDR;
}
return retval;
}
static void
allocateOutputPointerRow(unsigned int const width,
tuple ** const tuplerowP) {
MALLOCARRAY(*tuplerowP, width);
if (*tuplerowP == NULL)
pm_error("Could not allocate a %u-column tuple pointer array", width);
}
static void
convertToPamPnm(struct pam * const outpamP,
jas_image_t * const jasperP,
int const jasperCmptNo[]) {
jas_matrix_t ** matrix; /* malloc'ed */
/* matrix[X] is the data for Plane X of the current row */
sample * jasperMaxval;
unsigned int row;
tuple * tuplerow;
jas_seqent_t ** jasperRow; /* malloc'ed */
/* A row of a plane of the raster from the Jasper library
This is an array of pointers into the 'matrix' data structures.
*/
bool singleMaxval;
createMatrices(outpamP, &matrix);
computeComponentMaxval(outpamP, jasperP, jasperCmptNo,
&jasperMaxval, &singleMaxval);
MALLOCARRAY(jasperRow, outpamP->depth);
if (jasperRow == NULL)
pm_error("Out of memory");
tuplerow = pnm_allocpamrow(outpamP);
for (row = 0; row < outpamP->height; ++row) {
unsigned int plane;
for (plane = 0; plane < outpamP->depth; ++plane) {
int rc;
rc = jas_image_readcmpt(jasperP, jasperCmptNo[plane], 0, row,
outpamP->width, 1,
matrix[plane]);
if (rc != 0)
pm_error("jas_image_readcmpt() of row %u plane %u "
"failed.",
row, plane);
jasperRow[plane] = jas_matrix_getref(matrix[plane], 0, 0);
}
if (singleMaxval)
copyRowSingleMaxval(jasperRow, tuplerow, outpamP);
else
copyRowAnyMaxval(jasperRow, tuplerow, outpamP, jasperMaxval);
pnm_writepamrow(outpamP, tuplerow);
}
pnm_freepamrow(tuplerow);
destroyMatrices(outpamP, matrix);
free(jasperRow);
free(jasperMaxval);
}
static void
initUintSet(struct uintSet * const uintSetP,
unsigned int const allocSize) {
uintSetP->allocSize = allocSize;
uintSetP->count = 0;
MALLOCARRAY(uintSetP->list, allocSize);
if (uintSetP->list == NULL)
pm_error("Could not allocate memory for an array of %u numbers.",
allocSize);
}
bit *
pbm_allocrow(unsigned int const cols) {
bit * bitrow;
MALLOCARRAY(bitrow, cols);
if (bitrow == NULL)
pm_error("Unable to allocate space for a %u-column bit row", cols);
return bitrow;
}
static void
initFserr(struct pam * const pamP,
struct fserr * const fserrP,
bool const initRandom) {
/*----------------------------------------------------------------------------
Initialize the Floyd-Steinberg error vectors
-----------------------------------------------------------------------------*/
unsigned int plane;
unsigned int const fserrSize = pamP->width + 2;
fserrP->width = pamP->width;
MALLOCARRAY(fserrP->thiserr, pamP->depth);
if (fserrP->thiserr == NULL)
pm_error("Out of memory allocating Floyd-Steinberg structures "
"for depth %u", pamP->depth);
MALLOCARRAY(fserrP->nexterr, pamP->depth);
if (fserrP->nexterr == NULL)
pm_error("Out of memory allocating Floyd-Steinberg structures "
"for depth %u", pamP->depth);
for (plane = 0; plane < pamP->depth; ++plane) {
MALLOCARRAY(fserrP->thiserr[plane], fserrSize);
if (fserrP->thiserr[plane] == NULL)
pm_error("Out of memory allocating Floyd-Steinberg structures "
"for Plane %u, size %u", plane, fserrSize);
MALLOCARRAY(fserrP->nexterr[plane], fserrSize);
if (fserrP->nexterr[plane] == NULL)
pm_error("Out of memory allocating Floyd-Steinberg structures "
"for Plane %u, size %u", plane, fserrSize);
}
if (initRandom)
randomizeError(fserrP->thiserr, fserrSize, pamP->depth);
else
zeroError(fserrP->thiserr, fserrSize, pamP->depth);
fserrSetForward(fserrP);
}
static ppm_fs_info *
allocateFi(int const cols) {
ppm_fs_info * fi;
MALLOCVAR(fi);
if (fi != NULL) {
MALLOCARRAY(fi->thisrederr , cols + 2);
MALLOCARRAY(fi->thisgreenerr, cols + 2);
MALLOCARRAY(fi->thisblueerr , cols + 2);
MALLOCARRAY(fi->nextrederr , cols + 2);
MALLOCARRAY(fi->nextgreenerr, cols + 2);
MALLOCARRAY(fi->nextblueerr , cols + 2);
if (fi->thisrederr == NULL ||
fi->thisgreenerr == NULL ||
fi->thisblueerr == NULL ||
fi->nextrederr == NULL ||
fi->nextgreenerr == NULL ||
fi->nextblueerr == NULL)
pm_error("out of memory allocating "
"Floyd-Steinberg control structure");
} else
pm_error("out of memory allocating Floyd-Steinberg control structure");
return(fi);
}
