unsigned char c;
unsigned char d;
- cupsImageRGBToCMYK(src,cmyk,1);
+ cfImageRGBToCMYK(src,cmyk,1);
c = 0;
d = dither1[y & 0xf][x & 0xf];
/* K */
*
* Contents:
*
- * _cupsImageReadBMP() - Read a BMP image file.
+ * _cfImageReadBMP() - Read a BMP image file.
* read_word() - Read a 16-bit unsigned integer.
* read_dword() - Read a 32-bit unsigned integer.
* read_long() - Read a 32-bit signed integer.
/*
- * '_cupsImageReadBMP()' - Read a BMP image file.
+ * '_cfImageReadBMP()' - Read a BMP image file.
*/
int /* O - Read status */
-_cupsImageReadBMP(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadBMP(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int offset, /* Offset to bitmap data */
info_size, /* Size of info header */
count, /* Number of times to repeat */
temp, /* Temporary color */
align; /* Alignment bytes */
- cups_ib_t bit, /* Bit in image */
+ cf_ib_t bit, /* Bit in image */
byte; /* Byte in image */
- cups_ib_t *in, /* Input pixels */
+ cf_ib_t *in, /* Input pixels */
*out, /* Output pixels */
*ptr; /* Pointer into pixels */
- cups_ib_t colormap[256][4]; /* Colormap */
+ cf_ib_t colormap[256][4]; /* Colormap */
(void)secondary;
colors_used = read_dword(fp);
colors_important = read_dword(fp);
- if (img->xsize == 0 || img->xsize > CUPS_IMAGE_MAX_WIDTH ||
- img->ysize == 0 || img->ysize > CUPS_IMAGE_MAX_HEIGHT ||
+ if (img->xsize == 0 || img->xsize > CF_IMAGE_MAX_WIDTH ||
+ img->ysize == 0 || img->ysize > CF_IMAGE_MAX_HEIGHT ||
(depth != 1 && depth != 4 && depth != 8 && depth != 24))
{
DEBUG_printf(("DEBUG: Bad BMP dimensions %ux%ux%d\n",
* Setup image and buffers...
*/
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((in = malloc(img->xsize * 3)) == NULL)
{
}
if (saturation != 100 || hue != 0)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
fclose(fp);
*
* Contents:
*
- * cupsImageCMYKToBlack() - Convert CMYK data to black.
- * cupsImageCMYKToCMY() - Convert CMYK colors to CMY.
- * cupsImageCMYKToCMYK() - Convert CMYK colors to CMYK.
- * cupsImageCMYKToRGB() - Convert CMYK colors to device-dependent
+ * cfImageCMYKToBlack() - Convert CMYK data to black.
+ * cfImageCMYKToCMY() - Convert CMYK colors to CMY.
+ * cfImageCMYKToCMYK() - Convert CMYK colors to CMYK.
+ * cfImageCMYKToRGB() - Convert CMYK colors to device-dependent
* RGB.
- * cupsImageCMYKToWhite() - Convert CMYK colors to luminance.
- * cupsImageLut() - Adjust all pixel values with the given
+ * cfImageCMYKToWhite() - Convert CMYK colors to luminance.
+ * cfImageLut() - Adjust all pixel values with the given
* LUT.
- * cupsImageRGBAdjust() - Adjust the hue and saturation of the
+ * cfImageRGBAdjust() - Adjust the hue and saturation of the
* given RGB colors.
- * cupsImageRGBToBlack() - Convert RGB data to black.
- * cupsImageRGBToCMY() - Convert RGB colors to CMY.
- * cupsImageRGBToCMYK() - Convert RGB colors to CMYK.
- * cupsImageRGBToRGB() - Convert RGB colors to device-dependent
+ * cfImageRGBToBlack() - Convert RGB data to black.
+ * cfImageRGBToCMY() - Convert RGB colors to CMY.
+ * cfImageRGBToCMYK() - Convert RGB colors to CMYK.
+ * cfImageRGBToRGB() - Convert RGB colors to device-dependent
* RGB.
- * cupsImageRGBToWhite() - Convert RGB colors to luminance.
- * cupsImageSetProfile() - Set the device color profile.
- * cupsImageSetRasterColorSpace() - Set the destination colorspace.
- * cupsImageWhiteToBlack() - Convert luminance colors to black.
- * cupsImageWhiteToCMY() - Convert luminance colors to CMY.
- * cupsImageWhiteToCMYK() - Convert luminance colors to CMYK.
- * cupsImageWhiteToRGB() - Convert luminance data to RGB.
- * cupsImageWhiteToWhite() - Convert luminance colors to device-
+ * cfImageRGBToWhite() - Convert RGB colors to luminance.
+ * cfImageSetProfile() - Set the device color profile.
+ * cfImageSetRasterColorSpace() - Set the destination colorspace.
+ * cfImageWhiteToBlack() - Convert luminance colors to black.
+ * cfImageWhiteToCMY() - Convert luminance colors to CMY.
+ * cfImageWhiteToCMYK() - Convert luminance colors to CMYK.
+ * cfImageWhiteToRGB() - Convert luminance data to RGB.
+ * cfImageWhiteToWhite() - Convert luminance colors to device-
* dependent luminance.
* cielab() - Map CIE Lab transformation...
* huerotate() - Rotate the hue, maintaining luminance.
* Local globals...
*/
-static int cupsImageHaveProfile = 0;
+static int cfImageHaveProfile = 0;
/* Do we have a color profile? */
-static int *cupsImageDensity;
+static int *cfImageDensity;
/* Ink/marker density LUT */
-static cups_clut_t *cupsImageMatrix;
+static cups_clut_t *cfImageMatrix;
/* Color transform matrix LUT */
-static cups_cspace_t cupsImageColorSpace = CUPS_CSPACE_RGB;
+static cups_cspace_t cfImageColorSpace = CUPS_CSPACE_RGB;
/* Destination colorspace */
static void huerotate(float [3][3], float);
static void ident(float [3][3]);
static void mult(float [3][3], float [3][3], float [3][3]);
-static void rgb_to_lab(cups_ib_t *val);
-static void rgb_to_xyz(cups_ib_t *val);
+static void rgb_to_lab(cf_ib_t *val);
+static void rgb_to_xyz(cf_ib_t *val);
static void saturate(float [3][3], float);
static void xform(float [3][3], float, float, float, float *, float *, float *);
static void xrotate(float [3][3], float, float);
/*
- * 'cupsImageCMYKToBlack()' - Convert CMYK data to black.
+ * 'cfImageCMYKToBlack()' - Convert CMYK data to black.
*/
void
-cupsImageCMYKToBlack(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageCMYKToBlack(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int k; /* Black value */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
k = (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100 + in[3];
if (k < 255)
- *out++ = cupsImageDensity[k];
+ *out++ = cfImageDensity[k];
else
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
in += 4;
count --;
/*
- * 'cupsImageCMYKToCMY()' - Convert CMYK colors to CMY.
+ * 'cfImageCMYKToCMY()' - Convert CMYK colors to CMY.
*/
void
-cupsImageCMYKToCMY(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageCMYKToCMY(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cc, cm, cy; /* Calibrated CMY values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
c = *in++;
y = *in++;
k = *in++;
- cc = cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y] + k;
- cm = cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y] + k;
- cy = cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y] + k;
+ cc = cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y] + k;
+ cm = cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y] + k;
+ cy = cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y] + k;
if (cc < 0)
*out++ = 0;
else if (cc > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cc];
+ *out++ = cfImageDensity[cc];
if (cm < 0)
*out++ = 0;
else if (cm > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cm];
+ *out++ = cfImageDensity[cm];
if (cy < 0)
*out++ = 0;
else if (cy > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cy];
+ *out++ = cfImageDensity[cy];
count --;
}
/*
- * 'cupsImageCMYKToCMYK()' - Convert CMYK colors to CMYK.
+ * 'cfImageCMYKToCMYK()' - Convert CMYK colors to CMYK.
*/
void
-cupsImageCMYKToCMYK(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageCMYKToCMYK(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cc, cm, cy; /* Calibrated CMY values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
c = *in++;
y = *in++;
k = *in++;
- cc = (cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y]);
- cm = (cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y]);
- cy = (cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y]);
+ cc = (cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y]);
+ cm = (cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y]);
+ cy = (cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y]);
if (cc < 0)
*out++ = 0;
else if (cc > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cc];
+ *out++ = cfImageDensity[cc];
if (cm < 0)
*out++ = 0;
else if (cm > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cm];
+ *out++ = cfImageDensity[cm];
if (cy < 0)
*out++ = 0;
else if (cy > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cy];
+ *out++ = cfImageDensity[cy];
- *out++ = cupsImageDensity[k];
+ *out++ = cfImageDensity[k];
count --;
}
/*
- * 'cupsImageCMYKToRGB()' - Convert CMYK colors to device-dependent RGB.
+ * 'cfImageCMYKToRGB()' - Convert CMYK colors to device-dependent RGB.
*/
void
-cupsImageCMYKToRGB(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageCMYKToRGB(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cr, cg, cb; /* Calibrated RGB values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
{
while (count > 0)
{
y = *in++;
k = *in++;
- cr = cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y] + k;
- cg = cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y] + k;
- cb = cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y] + k;
+ cr = cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y] + k;
+ cg = cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y] + k;
+ cb = cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y] + k;
if (cr < 0)
*out++ = 255;
else if (cr > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cr];
+ *out++ = 255 - cfImageDensity[cr];
if (cg < 0)
*out++ = 255;
else if (cg > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cg];
+ *out++ = 255 - cfImageDensity[cg];
if (cb < 0)
*out++ = 255;
else if (cb > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cb];
+ *out++ = 255 - cfImageDensity[cb];
count --;
}
else
*out++ = 0;
- if (cupsImageColorSpace == CUPS_CSPACE_CIELab ||
- cupsImageColorSpace >= CUPS_CSPACE_ICC1)
+ if (cfImageColorSpace == CUPS_CSPACE_CIELab ||
+ cfImageColorSpace >= CUPS_CSPACE_ICC1)
rgb_to_lab(out - 3);
- else if (cupsImageColorSpace == CUPS_CSPACE_CIEXYZ)
+ else if (cfImageColorSpace == CUPS_CSPACE_CIEXYZ)
rgb_to_xyz(out - 3);
count --;
/*
- * 'cupsImageCMYKToWhite()' - Convert CMYK colors to luminance.
+ * 'cfImageCMYKToWhite()' - Convert CMYK colors to luminance.
*/
void
-cupsImageCMYKToWhite(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageCMYKToWhite(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int w; /* White value */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
{
while (count > 0)
{
w = 255 - (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100 - in[3];
if (w > 0)
- *out++ = cupsImageDensity[w];
+ *out++ = cfImageDensity[w];
else
- *out++ = cupsImageDensity[0];
+ *out++ = cfImageDensity[0];
in += 4;
count --;
/*
- * 'cupsImageLut()' - Adjust all pixel values with the given LUT.
+ * 'cfImageLut()' - Adjust all pixel values with the given LUT.
*/
void
-cupsImageLut(cups_ib_t *pixels, /* IO - Input/output pixels */
+cfImageLut(cf_ib_t *pixels, /* IO - Input/output pixels */
int count, /* I - Number of pixels/bytes to adjust */
- const cups_ib_t *lut) /* I - Lookup table */
+ const cf_ib_t *lut) /* I - Lookup table */
{
while (count > 0)
{
/*
- * 'cupsImageRGBAdjust()' - Adjust the hue and saturation of the given RGB colors.
+ * 'cfImageRGBAdjust()' - Adjust the hue and saturation of the given RGB colors.
*/
void
-cupsImageRGBAdjust(cups_ib_t *pixels, /* IO - Input/output pixels */
+cfImageRGBAdjust(cf_ib_t *pixels, /* IO - Input/output pixels */
int count, /* I - Number of pixels to adjust */
int saturation,/* I - Color saturation (%) */
int hue) /* I - Color hue (degrees) */
/*
- * 'cupsImageRGBToBlack()' - Convert RGB data to black.
+ * 'cfImageRGBToBlack()' - Convert RGB data to black.
*/
void
-cupsImageRGBToBlack(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageRGBToBlack(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
- *out++ = cupsImageDensity[255 - (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100];
+ *out++ = cfImageDensity[255 - (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100];
in += 3;
count --;
}
/*
- * 'cupsImageRGBToCMY()' - Convert RGB colors to CMY.
+ * 'cfImageRGBToCMY()' - Convert RGB colors to CMY.
*/
void
-cupsImageRGBToCMY(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageRGBToCMY(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cc, cm, cy; /* Calibrated CMY values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
c = 255 - *in++;
m -= k;
y -= k;
- cc = cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y] + k;
- cm = cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y] + k;
- cy = cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y] + k;
+ cc = cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y] + k;
+ cm = cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y] + k;
+ cy = cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y] + k;
if (cc < 0)
*out++ = 0;
else if (cc > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cc];
+ *out++ = cfImageDensity[cc];
if (cm < 0)
*out++ = 0;
else if (cm > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cm];
+ *out++ = cfImageDensity[cm];
if (cy < 0)
*out++ = 0;
else if (cy > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cy];
+ *out++ = cfImageDensity[cy];
count --;
}
/*
- * 'cupsImageRGBToCMYK()' - Convert RGB colors to CMYK.
+ * 'cfImageRGBToCMYK()' - Convert RGB colors to CMYK.
*/
void
-cupsImageRGBToCMYK(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageRGBToCMYK(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k, /* CMYK values */
int cc, cm, cy; /* Calibrated CMY values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
c = 255 - *in++;
m -= k;
y -= k;
- cc = (cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y]);
- cm = (cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y]);
- cy = (cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y]);
+ cc = (cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y]);
+ cm = (cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y]);
+ cy = (cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y]);
if (cc < 0)
*out++ = 0;
else if (cc > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cc];
+ *out++ = cfImageDensity[cc];
if (cm < 0)
*out++ = 0;
else if (cm > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cm];
+ *out++ = cfImageDensity[cm];
if (cy < 0)
*out++ = 0;
else if (cy > 255)
- *out++ = cupsImageDensity[255];
+ *out++ = cfImageDensity[255];
else
- *out++ = cupsImageDensity[cy];
+ *out++ = cfImageDensity[cy];
- *out++ = cupsImageDensity[k];
+ *out++ = cfImageDensity[k];
count --;
}
/*
- * 'cupsImageRGBToRGB()' - Convert RGB colors to device-dependent RGB.
+ * 'cfImageRGBToRGB()' - Convert RGB colors to device-dependent RGB.
*/
void
-cupsImageRGBToRGB(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageRGBToRGB(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cr, cg, cb; /* Calibrated RGB values */
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
{
while (count > 0)
{
m -= k;
y -= k;
- cr = cupsImageMatrix[0][0][c] +
- cupsImageMatrix[0][1][m] +
- cupsImageMatrix[0][2][y] + k;
- cg = cupsImageMatrix[1][0][c] +
- cupsImageMatrix[1][1][m] +
- cupsImageMatrix[1][2][y] + k;
- cb = cupsImageMatrix[2][0][c] +
- cupsImageMatrix[2][1][m] +
- cupsImageMatrix[2][2][y] + k;
+ cr = cfImageMatrix[0][0][c] +
+ cfImageMatrix[0][1][m] +
+ cfImageMatrix[0][2][y] + k;
+ cg = cfImageMatrix[1][0][c] +
+ cfImageMatrix[1][1][m] +
+ cfImageMatrix[1][2][y] + k;
+ cb = cfImageMatrix[2][0][c] +
+ cfImageMatrix[2][1][m] +
+ cfImageMatrix[2][2][y] + k;
if (cr < 0)
*out++ = 255;
else if (cr > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cr];
+ *out++ = 255 - cfImageDensity[cr];
if (cg < 0)
*out++ = 255;
else if (cg > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cg];
+ *out++ = 255 - cfImageDensity[cg];
if (cb < 0)
*out++ = 255;
else if (cb > 255)
- *out++ = 255 - cupsImageDensity[255];
+ *out++ = 255 - cfImageDensity[255];
else
- *out++ = 255 - cupsImageDensity[cb];
+ *out++ = 255 - cfImageDensity[cb];
count --;
}
if (in != out)
memcpy(out, in, count * 3);
- if (cupsImageColorSpace == CUPS_CSPACE_CIELab ||
- cupsImageColorSpace >= CUPS_CSPACE_ICC1)
+ if (cfImageColorSpace == CUPS_CSPACE_CIELab ||
+ cfImageColorSpace >= CUPS_CSPACE_ICC1)
{
while (count > 0)
{
count --;
}
}
- else if (cupsImageColorSpace == CUPS_CSPACE_CIEXYZ)
+ else if (cfImageColorSpace == CUPS_CSPACE_CIEXYZ)
{
while (count > 0)
{
/*
- * 'cupsImageRGBToWhite()' - Convert RGB colors to luminance.
+ * 'cfImageRGBToWhite()' - Convert RGB colors to luminance.
*/
void
-cupsImageRGBToWhite(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageRGBToWhite(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
{
while (count > 0)
{
- *out++ = 255 - cupsImageDensity[255 - (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100];
+ *out++ = 255 - cfImageDensity[255 - (31 * in[0] + 61 * in[1] + 8 * in[2]) / 100];
in += 3;
count --;
}
/*
- * 'cupsImageSetProfile()' - Set the device color profile.
+ * 'cfImageSetProfile()' - Set the device color profile.
*/
void
-cupsImageSetProfile(float d, /* I - Ink/marker density */
+cfImageSetProfile(float d, /* I - Ink/marker density */
float g, /* I - Ink/marker gamma */
float matrix[3][3]) /* I - Color transform matrix */
{
int i, j, k; /* Looping vars */
float m; /* Current matrix value */
- int *im; /* Pointer into cupsImageMatrix */
+ int *im; /* Pointer into cfImageMatrix */
/*
* Allocate memory for the profile data...
*/
- if (cupsImageMatrix == NULL)
- cupsImageMatrix = calloc(3, sizeof(cups_clut_t));
+ if (cfImageMatrix == NULL)
+ cfImageMatrix = calloc(3, sizeof(cups_clut_t));
- if (cupsImageMatrix == NULL)
+ if (cfImageMatrix == NULL)
return;
- if (cupsImageDensity == NULL)
- cupsImageDensity = calloc(256, sizeof(int));
+ if (cfImageDensity == NULL)
+ cfImageDensity = calloc(256, sizeof(int));
- if (cupsImageDensity == NULL)
+ if (cfImageDensity == NULL)
return;
/*
* Populate the profile lookup tables...
*/
- cupsImageHaveProfile = 1;
+ cfImageHaveProfile = 1;
- for (i = 0, im = cupsImageMatrix[0][0]; i < 3; i ++)
+ for (i = 0, im = cfImageMatrix[0][0]; i < 3; i ++)
for (j = 0; j < 3; j ++)
for (k = 0, m = matrix[i][j]; k < 256; k ++)
*im++ = (int)(k * m + 0.5);
- for (k = 0, im = cupsImageDensity; k < 256; k ++)
+ for (k = 0, im = cfImageDensity; k < 256; k ++)
*im++ = 255.0 * d * pow((float)k / 255.0, g) + 0.5;
}
/*
- * 'cupsImageSetRasterColorSpace()' - Set the destination colorspace.
+ * 'cfImageSetRasterColorSpace()' - Set the destination colorspace.
*/
void
-cupsImageSetRasterColorSpace(
+cfImageSetRasterColorSpace(
cups_cspace_t cs) /* I - Destination colorspace */
{
/*
* Set the destination colorspace...
*/
- cupsImageColorSpace = cs;
+ cfImageColorSpace = cs;
/*
* Don't use color profiles in colorimetric colorspaces...
if (cs == CUPS_CSPACE_CIEXYZ ||
cs == CUPS_CSPACE_CIELab ||
cs >= CUPS_CSPACE_ICC1)
- cupsImageHaveProfile = 0;
+ cfImageHaveProfile = 0;
}
/*
- * 'cupsImageWhiteToBlack()' - Convert luminance colors to black.
+ * 'cfImageWhiteToBlack()' - Convert luminance colors to black.
*/
void
-cupsImageWhiteToBlack(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageWhiteToBlack(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
- *out++ = cupsImageDensity[255 - *in++];
+ *out++ = cfImageDensity[255 - *in++];
count --;
}
else
/*
- * 'cupsImageWhiteToCMY()' - Convert luminance colors to CMY.
+ * 'cfImageWhiteToCMY()' - Convert luminance colors to CMY.
*/
void
-cupsImageWhiteToCMY(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageWhiteToCMY(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
- out[0] = cupsImageDensity[255 - *in++];
+ out[0] = cfImageDensity[255 - *in++];
out[1] = out[0];
out[2] = out[0];
out += 3;
/*
- * 'cupsImageWhiteToCMYK()' - Convert luminance colors to CMYK.
+ * 'cfImageWhiteToCMYK()' - Convert luminance colors to CMYK.
*/
void
-cupsImageWhiteToCMYK(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageWhiteToCMYK(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
*out++ = 0;
*out++ = 0;
*out++ = 0;
- *out++ = cupsImageDensity[255 - *in++];
+ *out++ = cfImageDensity[255 - *in++];
count --;
}
else
/*
- * 'cupsImageWhiteToRGB()' - Convert luminance data to RGB.
+ * 'cfImageWhiteToRGB()' - Convert luminance data to RGB.
*/
void
-cupsImageWhiteToRGB(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageWhiteToRGB(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
{
while (count > 0)
{
- out[0] = 255 - cupsImageDensity[255 - *in++];
+ out[0] = 255 - cfImageDensity[255 - *in++];
out[1] = out[0];
out[2] = out[0];
out += 3;
*out++ = *in;
*out++ = *in++;
- if (cupsImageColorSpace == CUPS_CSPACE_CIELab ||
- cupsImageColorSpace >= CUPS_CSPACE_ICC1)
+ if (cfImageColorSpace == CUPS_CSPACE_CIELab ||
+ cfImageColorSpace >= CUPS_CSPACE_ICC1)
rgb_to_lab(out - 3);
- else if (cupsImageColorSpace == CUPS_CSPACE_CIEXYZ)
+ else if (cfImageColorSpace == CUPS_CSPACE_CIEXYZ)
rgb_to_xyz(out - 3);
count --;
/*
- * 'cupsImageWhiteToWhite()' - Convert luminance colors to device-dependent
+ * 'cfImageWhiteToWhite()' - Convert luminance colors to device-dependent
* luminance.
*/
void
-cupsImageWhiteToWhite(
- const cups_ib_t *in, /* I - Input pixels */
- cups_ib_t *out, /* I - Output pixels */
+cfImageWhiteToWhite(
+ const cf_ib_t *in, /* I - Input pixels */
+ cf_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
- if (cupsImageHaveProfile)
+ if (cfImageHaveProfile)
while (count > 0)
{
- *out++ = 255 - cupsImageDensity[255 - *in++];
+ *out++ = 255 - cfImageDensity[255 - *in++];
count --;
}
else if (in != out)
*/
static void
-rgb_to_lab(cups_ib_t *val) /* IO - Color value */
+rgb_to_lab(cf_ib_t *val) /* IO - Color value */
{
float r, /* Red value */
g, /* Green value */
*/
static void
-rgb_to_xyz(cups_ib_t *val) /* IO - Color value */
+rgb_to_xyz(cf_ib_t *val) /* IO - Color value */
{
float r, /* Red value */
g, /* Green value */
*
* Contents:
*
- * _cupsImageReadGIF() - Read a GIF image file.
+ * _cfImageReadGIF() - Read a GIF image file.
* gif_get_block() - Read a GIF data block...
* gif_get_code() - Get a LZW code from the file...
* gif_read_cmap() - Read the colormap from a GIF file...
#define GIF_COLORMAP 0x80
#define GIF_MAX_BITS 12
-typedef cups_ib_t gif_cmap_t[256][4];
+typedef cf_ib_t gif_cmap_t[256][4];
typedef short gif_table_t[4096];
static int gif_get_code (FILE *fp, int code_size, int first_time);
static int gif_read_cmap(FILE *fp, int ncolors, gif_cmap_t cmap,
int *gray);
-static int gif_read_image(FILE *fp, cups_image_t *img, gif_cmap_t cmap,
+static int gif_read_image(FILE *fp, cf_image_t *img, gif_cmap_t cmap,
int interlace);
static int gif_read_lzw(FILE *fp, int first_time, int input_code_size);
/*
- * '_cupsImageReadGIF()' - Read a GIF image file.
+ * '_cfImageReadGIF()' - Read a GIF image file.
*/
int /* O - Read status */
-_cupsImageReadGIF(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadGIF(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
unsigned char buf[1024]; /* Input buffer */
gif_cmap_t cmap; /* Colormap */
* GIF files are either grayscale or RGB - no CMYK...
*/
- if (primary == CUPS_IMAGE_RGB_CMYK)
- primary = CUPS_IMAGE_RGB;
+ if (primary == CF_IMAGE_RGB_CMYK)
+ primary = CF_IMAGE_RGB;
/*
* Read the header; we already know it is a GIF file...
img->xsize = (buf[7] << 8) | buf[6];
img->ysize = (buf[9] << 8) | buf[8];
ncolors = 2 << (buf[10] & 0x07);
- gray = primary == CUPS_IMAGE_BLACK || primary == CUPS_IMAGE_WHITE;
+ gray = primary == CF_IMAGE_BLACK || primary == CF_IMAGE_WHITE;
if (buf[10] & GIF_COLORMAP)
if (gif_read_cmap(fp, ncolors, cmap, &gray))
}
break;
- case ',' : /* cupsImage data */
+ case ',' : /* Image data */
if (fread(buf, 9, 1, fp) == 0 && ferror(fp))
DEBUG_printf(("Error reading file!"));
if (buf[8] & GIF_COLORMAP)
{
ncolors = 2 << (buf[8] & 0x07);
- gray = primary == CUPS_IMAGE_BLACK || primary == CUPS_IMAGE_WHITE;
+ gray = primary == CF_IMAGE_BLACK || primary == CF_IMAGE_WHITE;
if (gif_read_cmap(fp, ncolors, cmap, &gray))
{
{
switch (secondary)
{
- case CUPS_IMAGE_CMYK :
+ case CF_IMAGE_CMYK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageWhiteToCMYK(cmap[i], cmap[i], 1);
+ cfImageWhiteToCMYK(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_CMY :
+ case CF_IMAGE_CMY :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageWhiteToCMY(cmap[i], cmap[i], 1);
+ cfImageWhiteToCMY(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_BLACK :
+ case CF_IMAGE_BLACK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageWhiteToBlack(cmap[i], cmap[i], 1);
+ cfImageWhiteToBlack(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
break;
- case CUPS_IMAGE_RGB :
- case CUPS_IMAGE_RGB_CMYK :
+ case CF_IMAGE_RGB :
+ case CF_IMAGE_RGB_CMYK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageWhiteToRGB(cmap[i], cmap[i], 1);
+ cfImageWhiteToRGB(cmap[i], cmap[i], 1);
break;
}
{
if (hue != 0 || saturation != 100)
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBAdjust(cmap[i], 1, saturation, hue);
+ cfImageRGBAdjust(cmap[i], 1, saturation, hue);
switch (primary)
{
- case CUPS_IMAGE_CMYK :
+ case CF_IMAGE_CMYK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBToCMYK(cmap[i], cmap[i], 1);
+ cfImageRGBToCMYK(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_CMY :
+ case CF_IMAGE_CMY :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBToCMY(cmap[i], cmap[i], 1);
+ cfImageRGBToCMY(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_BLACK :
+ case CF_IMAGE_BLACK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBToBlack(cmap[i], cmap[i], 1);
+ cfImageRGBToBlack(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBToWhite(cmap[i], cmap[i], 1);
+ cfImageRGBToWhite(cmap[i], cmap[i], 1);
break;
- case CUPS_IMAGE_RGB :
- case CUPS_IMAGE_RGB_CMYK :
+ case CF_IMAGE_RGB :
+ case CF_IMAGE_RGB_CMYK :
for (i = ncolors - 1; i >= 0; i --)
- cupsImageRGBToRGB(cmap[i], cmap[i], 1);
+ cfImageRGBToRGB(cmap[i], cmap[i], 1);
break;
}
if (lut)
{
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
for (i = ncolors - 1; i >= 0; i --)
- cupsImageLut(cmap[i], bpp, lut);
+ cfImageLut(cmap[i], bpp, lut);
}
img->xsize = (buf[5] << 8) | buf[4];
static int /* I - 0 = success, -1 = failure */
gif_read_image(FILE *fp, /* I - Input file */
- cups_image_t *img, /* I - cupsImage pointer */
+ cf_image_t *img, /* I - Image pointer */
gif_cmap_t cmap, /* I - Colormap */
int interlace) /* I - Non-zero = interlaced image */
{
unsigned char code_size; /* Code size */
- cups_ib_t *pixels, /* Pixel buffer */
+ cf_ib_t *pixels, /* Pixel buffer */
*temp; /* Current pixel */
int xpos, /* Current X position */
ypos, /* Current Y position */
{ 0, 4, 2, 1, 999999 };
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
pixels = calloc(bpp, img->xsize);
xpos = 0;
ypos = 0;
temp += bpp;
if (xpos == img->xsize)
{
- int res = _cupsImagePutRow(img, 0, ypos, img->xsize, pixels);
+ int res = _cfImagePutRow(img, 0, ypos, img->xsize, pixels);
if(res)
{
return (-1);
*
* Contents:
*
- * _cupsImageReadJPEG() - Read a JPEG image file.
+ * _cfImageReadJPEG() - Read a JPEG image file.
*/
/*
/*
- * '_cupsImageReadJPEG()' - Read a JPEG image file.
+ * '_cfImageReadJPEG()' - Read a JPEG image file.
*/
int /* O - Read status */
-_cupsImageReadJPEG(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadJPEG(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
struct jpeg_decompress_struct cinfo; /* Decompressor info */
struct jpeg_error_mgr jerr; /* Error handler info */
- cups_ib_t *in, /* Input pixels */
+ cf_ib_t *in, /* Input pixels */
*out; /* Output pixels */
jpeg_saved_marker_ptr marker; /* Pointer to marker data */
int psjpeg = 0; /* Non-zero if Photoshop CMYK JPEG */
cinfo.out_color_components = 4;
cinfo.output_components = 4;
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_CMYK : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_CMYK : primary;
}
else
{
cinfo.out_color_components = 3;
cinfo.output_components = 3;
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
}
jpeg_calc_output_dimensions(&cinfo);
- if (cinfo.output_width <= 0 || cinfo.output_width > CUPS_IMAGE_MAX_WIDTH ||
- cinfo.output_height <= 0 || cinfo.output_height > CUPS_IMAGE_MAX_HEIGHT)
+ if (cinfo.output_width <= 0 || cinfo.output_width > CF_IMAGE_MAX_WIDTH ||
+ cinfo.output_height <= 0 || cinfo.output_height > CF_IMAGE_MAX_HEIGHT)
{
DEBUG_printf(("DEBUG: Bad JPEG dimensions %dx%d!\n",
cinfo.output_width, cinfo.output_height));
img->xsize, img->ysize, cinfo.output_components,
img->xppi, img->yppi));
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
in = malloc(img->xsize * cinfo.output_components);
- out = malloc(img->xsize * cupsImageGetDepth(img));
+ out = malloc(img->xsize * cfImageGetDepth(img));
jpeg_start_decompress(&cinfo);
* Invert CMYK data from Photoshop...
*/
- cups_ib_t *ptr; /* Pointer into buffer */
+ cf_ib_t *ptr; /* Pointer into buffer */
int i; /* Looping var */
}
if ((saturation != 100 || hue != 0) && cinfo.output_components == 3)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
- if ((img->colorspace == CUPS_IMAGE_WHITE && cinfo.out_color_space == JCS_GRAYSCALE) ||
- (img->colorspace == CUPS_IMAGE_CMYK && cinfo.out_color_space == JCS_CMYK))
+ if ((img->colorspace == CF_IMAGE_WHITE && cinfo.out_color_space == JCS_GRAYSCALE) ||
+ (img->colorspace == CF_IMAGE_CMYK && cinfo.out_color_space == JCS_CMYK))
{
#ifdef DEBUG
int i, j;
- cups_ib_t *ptr;
+ cf_ib_t *ptr;
DEBUG_puts("DEBUG: Direct Data...\n");
#endif /* DEBUG */
if (lut)
- cupsImageLut(in, img->xsize * cupsImageGetDepth(img), lut);
+ cfImageLut(in, img->xsize * cfImageGetDepth(img), lut);
- _cupsImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, in);
+ _cfImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, in);
}
else if (cinfo.out_color_space == JCS_GRAYSCALE)
{
default :
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * cupsImageGetDepth(img), lut);
+ cfImageLut(out, img->xsize * cfImageGetDepth(img), lut);
- _cupsImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
+ _cfImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
}
else if (cinfo.out_color_space == JCS_RGB)
{
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * cupsImageGetDepth(img), lut);
+ cfImageLut(out, img->xsize * cfImageGetDepth(img), lut);
- _cupsImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
+ _cfImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
}
else /* JCS_CMYK */
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageCMYKToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageCMYKToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageCMYKToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageCMYKToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageCMYKToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageCMYKToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageCMYKToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageCMYKToRGB(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * cupsImageGetDepth(img), lut);
+ cfImageLut(out, img->xsize * cfImageGetDepth(img), lut);
- _cupsImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
+ _cfImagePutRow(img, 0, cinfo.output_scanline - 1, img->xsize, out);
}
}
*
* Contents:
*
- * _cupsImageReadPhotoCD() - Read a PhotoCD image file.
+ * _cfImageReadPhotoCD() - Read a PhotoCD image file.
*/
/*
/*
- * '_cupsImageReadPhotoCD()' - Read a PhotoCD image file.
+ * '_cfImageReadPhotoCD()' - Read a PhotoCD image file.
*/
int /* O - Read status */
-_cupsImageReadPhotoCD(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadPhotoCD(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int x, y; /* Looping vars */
int xdir, /* X direction */
int temp, /* Adjusted luminance */
temp2, /* Red, green, and blue values */
cb, cr; /* Adjusted chroma values */
- cups_ib_t *in, /* Input (YCC) pixels */
+ cf_ib_t *in, /* Input (YCC) pixels */
*iy, /* Luminance */
*icb, /* Blue chroma */
*icr, /* Red chroma */
* Allocate and initialize...
*/
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
img->xppi = 200;
img->yppi = 200;
img->ysize = 512;
}
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((in = malloc(768 * 3)) == NULL)
{
* in the image...
*/
- if (primary == CUPS_IMAGE_BLACK)
+ if (primary == CF_IMAGE_BLACK)
{
if (rotation)
{
*rgbptr-- = 255 - *iy++;
if (lut)
- cupsImageLut(out, 768, lut);
+ cfImageLut(out, 768, lut);
- _cupsImagePutCol(img, 511 - y - pass, 0, 768, out);
+ _cfImagePutCol(img, 511 - y - pass, 0, 768, out);
}
else
{
- cupsImageWhiteToBlack(iy, out, 768);
+ cfImageWhiteToBlack(iy, out, 768);
if (lut)
- cupsImageLut(out, 768, lut);
+ cfImageLut(out, 768, lut);
- _cupsImagePutRow(img, 0, y + pass, 768, out);
+ _cfImagePutRow(img, 0, y + pass, 768, out);
iy += 768;
}
}
*rgbptr-- = 255 - *iy++;
if (lut)
- cupsImageLut(out, 768, lut);
+ cfImageLut(out, 768, lut);
- _cupsImagePutCol(img, 511 - y - pass, 0, 768, out);
+ _cfImagePutCol(img, 511 - y - pass, 0, 768, out);
}
else
{
if (lut)
- cupsImageLut(iy, 768, lut);
+ cfImageLut(iy, 768, lut);
- _cupsImagePutRow(img, 0, y + pass, 768, iy);
+ _cfImagePutRow(img, 0, y + pass, 768, iy);
iy += 768;
}
}
*/
if (saturation != 100 || hue != 0)
- cupsImageRGBAdjust(rgb, 768, saturation, hue);
+ cfImageRGBAdjust(rgb, 768, saturation, hue);
/*
* Then convert the RGB data to the appropriate colorspace and
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(rgb, out, 768);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(rgb, out, 768);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(rgb, out, 768);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(rgb, out, 768);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(rgb, out, 768);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(rgb, out, 768);
break;
}
if (lut)
- cupsImageLut(out, 768 * bpp, lut);
+ cfImageLut(out, 768 * bpp, lut);
if (rotation)
- _cupsImagePutCol(img, 511 - y - pass, 0, 768, out);
+ _cfImagePutCol(img, 511 - y - pass, 0, 768, out);
else
- _cupsImagePutRow(img, 0, y + pass, 768, out);
+ _cfImagePutRow(img, 0, y + pass, 768, out);
}
}
}
*
* Contents:
*
- * _cupsImageReadPIX() - Read a PIX image file.
+ * _cfImageReadPIX() - Read a PIX image file.
* read_short() - Read a 16-bit integer.
*/
/*
- * '_cupsImageReadPIX()' - Read a PIX image file.
+ * '_cfImageReadPIX()' - Read a PIX image file.
*/
int /* O - Read status */
-_cupsImageReadPIX(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadPIX(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
short width, /* Width of image */
height, /* Height of image */
int count, /* Repetition count */
bpp, /* Bytes per pixel */
x, y; /* Looping vars */
- cups_ib_t r, g, b; /* Red, green/gray, blue values */
- cups_ib_t *in, /* Input pixels */
+ cf_ib_t r, g, b; /* Red, green/gray, blue values */
+ cf_ib_t *in, /* Input pixels */
*out, /* Output pixels */
*ptr; /* Pointer into pixels */
/*
* Check the dimensions of the image. Since the short values used for the
- * width and height cannot exceed CUPS_IMAGE_MAX_WIDTH or
- * CUPS_IMAGE_MAX_HEIGHT, we just need to verify they are positive integers.
+ * width and height cannot exceed CF_IMAGE_MAX_WIDTH or
+ * CF_IMAGE_MAX_HEIGHT, we just need to verify they are positive integers.
*/
if (width <= 0 || height <= 0 ||
if (depth == 8)
img->colorspace = secondary;
else
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
img->xsize = width;
img->ysize = height;
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((in = malloc(img->xsize * (depth / 8))) == NULL)
{
{
for (count = 0, y = 0, g = 0; y < img->ysize; y ++)
{
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
ptr = out;
else
ptr = in;
*ptr++ = g;
}
- if (img->colorspace != CUPS_IMAGE_WHITE)
+ if (img->colorspace != CF_IMAGE_WHITE)
switch (img->colorspace)
{
default :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
}
if (saturation != 100 || hue != 0)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
*
* Contents:
*
- * _cupsImageReadPNG() - Read a PNG image file.
+ * _cfImageReadPNG() - Read a PNG image file.
*/
/*
/*
- * '_cupsImageReadPNG()' - Read a PNG image file.
+ * '_cfImageReadPNG()' - Read a PNG image file.
*/
int /* O - Read status */
-_cupsImageReadPNG(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadPNG(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int y; /* Looping var */
png_structp pp; /* PNG read pointer */
int bpp; /* Bytes per pixel */
int pass, /* Current pass */
passes; /* Number of passes required */
- cups_ib_t *in, /* Input pixels */
+ cf_ib_t *in, /* Input pixels */
*inptr, /* Pointer into pixels */
*out; /* Output pixels */
png_color_16 bg; /* Background color */
png_set_strip_16(pp);
if (color_type & PNG_COLOR_MASK_COLOR)
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB :
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB :
primary;
else
img->colorspace = secondary;
- if (width == 0 || width > CUPS_IMAGE_MAX_WIDTH ||
- height == 0 || height > CUPS_IMAGE_MAX_HEIGHT)
+ if (width == 0 || width > CF_IMAGE_MAX_WIDTH ||
+ height == 0 || height > CF_IMAGE_MAX_HEIGHT)
{
DEBUG_printf(("DEBUG: PNG image has invalid dimensions %ux%u!\n",
(unsigned)width, (unsigned)height));
}
}
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
passes = png_set_interlace_handling(pp);
in = malloc(bufsize);
}
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
out = malloc(img->xsize * bpp);
if (!in || !out)
if (color_type & PNG_COLOR_MASK_COLOR)
{
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(inptr, img->xsize, saturation, hue);
+ cfImageRGBAdjust(inptr, img->xsize, saturation, hue);
switch (img->colorspace)
{
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(inptr, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- case CUPS_IMAGE_RGB_CMYK :
- cupsImageRGBToRGB(inptr, out, img->xsize);
+ case CF_IMAGE_RGB :
+ case CF_IMAGE_RGB_CMYK :
+ cfImageRGBToRGB(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(inptr, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(inptr, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(inptr, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(inptr, out, img->xsize);
break;
}
}
{
switch (img->colorspace)
{
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
memcpy(out, inptr, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- case CUPS_IMAGE_RGB_CMYK :
- cupsImageWhiteToRGB(inptr, out, img->xsize);
+ case CF_IMAGE_RGB :
+ case CF_IMAGE_RGB_CMYK :
+ cfImageWhiteToRGB(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(inptr, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(inptr, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(inptr, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(inptr, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(inptr, out, img->xsize);
break;
}
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
if (passes > 1)
*
* Contents:
*
- * _cupsImageReadPNM() - Read a PNM image file.
+ * _cfImageReadPNM() - Read a PNM image file.
*/
/*
/*
- * '_cupsImageReadPNM()' - Read a PNM image file.
+ * '_cfImageReadPNM()' - Read a PNM image file.
*/
int /* O - Read status */
-_cupsImageReadPNM(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadPNM(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int x, y; /* Looping vars */
int bpp; /* Bytes per pixel */
- cups_ib_t *in, /* Input pixels */
+ cf_ib_t *in, /* Input pixels */
*inptr, /* Current input pixel */
*out, /* Output pixels */
*outptr, /* Current output pixel */
else
maxval = 1;
- if (img->xsize == 0 || img->xsize > CUPS_IMAGE_MAX_WIDTH ||
- img->ysize == 0 || img->ysize > CUPS_IMAGE_MAX_HEIGHT)
+ if (img->xsize == 0 || img->xsize > CF_IMAGE_MAX_WIDTH ||
+ img->ysize == 0 || img->ysize > CF_IMAGE_MAX_HEIGHT)
{
DEBUG_printf(("DEBUG: Bad PNM dimensions %dx%d!\n",
img->xsize, img->ysize));
if (format == 1 || format == 2 || format == 4 || format == 5)
img->colorspace = secondary;
else
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((in = malloc(img->xsize * 3)) == NULL)
{
case 2 :
case 4 :
case 5 :
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
{
if (lut)
- cupsImageLut(in, img->xsize, lut);
+ cfImageLut(in, img->xsize, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, in);
+ _cfImagePutRow(img, 0, y, img->xsize, in);
}
else
{
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
break;
default :
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
break;
}
}
/*
- * Private image library definitions for CUPS.
+ * Private image library definitions for CUPS Filters.
*
* Copyright 2007-2010 by Apple Inc.
* Copyright 1993-2006 by Easy Software Products.
* Constants...
*/
-# define CUPS_IMAGE_MAX_WIDTH 0x07ffffff
+# define CF_IMAGE_MAX_WIDTH 0x07ffffff
/* 2^27-1 to allow for 15-channel data */
-# define CUPS_IMAGE_MAX_HEIGHT 0x3fffffff
+# define CF_IMAGE_MAX_HEIGHT 0x3fffffff
/* 2^30-1 */
-# define CUPS_TILE_SIZE 256 /* 256x256 pixel tiles */
-# define CUPS_TILE_MINIMUM 10 /* Minimum number of tiles */
+# define CF_TILE_SIZE 256 /* 256x256 pixel tiles */
+# define CF_TILE_MINIMUM 10 /* Minimum number of tiles */
/*
* Types and structures...
*/
-typedef enum cups_iztype_e /**** Image zoom type ****/
+typedef enum cf_iztype_e /**** Image zoom type ****/
{
- CUPS_IZOOM_FAST, /* Use nearest-neighbor sampling */
- CUPS_IZOOM_NORMAL, /* Use bilinear interpolation */
- CUPS_IZOOM_BEST /* Use bicubic interpolation */
-} cups_iztype_t;
+ CF_IZOOM_FAST, /* Use nearest-neighbor sampling */
+ CF_IZOOM_NORMAL, /* Use bilinear interpolation */
+ CF_IZOOM_BEST /* Use bicubic interpolation */
+} cf_iztype_t;
-struct cups_ic_s;
+struct cf_ic_s;
-typedef struct cups_itile_s /**** Image tile ****/
+typedef struct cf_itile_s /**** Image tile ****/
{
int dirty; /* True if tile is dirty */
- off_t pos; /* Position of tile on disk (-1 if not written) */
- struct cups_ic_s *ic; /* Pixel data */
-} cups_itile_t;
+ off_t pos; /* Position of tile on disk (-1 if not
+ written) */
+ struct cf_ic_s *ic; /* Pixel data */
+} cf_itile_t;
-typedef struct cups_ic_s /**** Image tile cache ****/
+typedef struct cf_ic_s /**** Image tile cache ****/
{
- struct cups_ic_s *prev, /* Previous tile in cache */
+ struct cf_ic_s *prev, /* Previous tile in cache */
*next; /* Next tile in cache */
- cups_itile_t *tile; /* Tile this is attached to */
- cups_ib_t *pixels; /* Pixel data */
-} cups_ic_t;
+ cf_itile_t *tile; /* Tile this is attached to */
+ cf_ib_t *pixels; /* Pixel data */
+} cf_ic_t;
-struct cups_image_s /**** Image file data ****/
+struct cf_image_s /**** Image file data ****/
{
- cups_icspace_t colorspace; /* Colorspace of image */
+ cf_icspace_t colorspace; /* Colorspace of image */
unsigned xsize, /* Width of image in pixels */
ysize, /* Height of image in pixels */
xppi, /* X resolution in pixels-per-inch */
yppi, /* Y resolution in pixels-per-inch */
num_ics, /* Number of cached tiles */
max_ics; /* Maximum number of cached tiles */
- cups_itile_t **tiles; /* Tiles in image */
- cups_ic_t *first, /* First cached tile in image */
+ cf_itile_t **tiles; /* Tiles in image */
+ cf_ic_t *first, /* First cached tile in image */
*last; /* Last cached tile in image */
int cachefile; /* Tile cache file */
char cachename[256]; /* Tile cache filename */
};
-struct cups_izoom_s /**** Image zoom data ****/
+struct cf_izoom_s /**** Image zoom data ****/
{
- cups_image_t *img; /* Image to zoom */
- cups_iztype_t type; /* Type of zooming */
+ cf_image_t *img; /* Image to zoom */
+ cf_iztype_t type; /* Type of zooming */
unsigned xorig, /* X origin */
yorig, /* Y origin */
width, /* Width of input area */
height, /* Height of input area */
depth, /* Number of bytes per pixel */
- rotated, /* Non-zero if image needs to be rotated */
+ rotated, /* Non-zero if image needs to be
+ rotated */
xsize, /* Width of output image */
ysize, /* Height of output image */
xmax, /* Maximum input image X position */
ymax, /* Maximum input image Y position */
xmod, /* Threshold for Bresenheim rounding */
ymod; /* ... */
- int xstep, /* Amount to step for each pixel along X */
+ int xstep, /* Amount to step for each pixel along
+ X */
xincr,
- instep, /* Amount to step pixel pointer along X */
+ instep, /* Amount to step pixel pointer along
+ X */
inincr,
- ystep, /* Amount to step for each pixel along Y */
+ ystep, /* Amount to step for each pixel along
+ Y */
yincr,
row; /* Current row */
- cups_ib_t *rows[2], /* Horizontally scaled pixel data */
+ cf_ib_t *rows[2], /* Horizontally scaled pixel data */
*in; /* Unscaled input pixel data */
};
* Prototypes...
*/
-extern int _cupsImagePutCol(cups_image_t *img, int x, int y,
- int height, const cups_ib_t *pixels);
-extern int _cupsImagePutRow(cups_image_t *img, int x, int y,
- int width, const cups_ib_t *pixels);
-extern int _cupsImageReadBMP(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadFPX(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadGIF(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadJPEG(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadPIX(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadPNG(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadPNM(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadPhotoCD(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
+extern int _cfImagePutCol(cf_image_t *img, int x, int y,
+ int height, const cf_ib_t *pixels);
+extern int _cfImagePutRow(cf_image_t *img, int x, int y,
+ int width, const cf_ib_t *pixels);
+extern int _cfImageReadBMP(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadFPX(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadGIF(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadJPEG(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadPIX(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadPNG(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadPNM(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadPhotoCD(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadSGI(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern int _cfImageReadSunRaster(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadSGI(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadSunRaster(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern int _cupsImageReadTIFF(cups_image_t *img, FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut);
-extern void _cupsImageZoomDelete(cups_izoom_t *z);
-extern void _cupsImageZoomFill(cups_izoom_t *z, int iy);
-extern cups_izoom_t *_cupsImageZoomNew(cups_image_t *img, int xc0, int yc0,
- int xc1, int yc1, int xsize,
- int ysize, int rotated,
- cups_iztype_t type);
-
-extern int _cupsRasterExecPS(cups_page_header2_t *h,
- int *preferred_bits,
- const char *code);
-extern void _cupsRasterAddError(const char *f, ...);
-extern void _cupsRasterClearError(void);
+ const cf_ib_t *lut);
+extern int _cfImageReadTIFF(cf_image_t *img, FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern void _cfImageZoomDelete(cf_izoom_t *z);
+extern void _cfImageZoomFill(cf_izoom_t *z, int iy);
+extern cf_izoom_t *_cfImageZoomNew(cf_image_t *img, int xc0, int yc0,
+ int xc1, int yc1, int xsize,
+ int ysize, int rotated,
+ cf_iztype_t type);
#endif /* !_CUPS_IMAGE_PRIVATE_H_ */
*
* Contents:
*
- * _cupsImageReadSGI() - Read a SGI image file.
+ * _cfImageReadSGI() - Read a SGI image file.
*/
/*
/*
- * '_cupsImageReadSGI()' - Read a SGI image file.
+ * '_cfImageReadSGI()' - Read a SGI image file.
*/
int /* O - Read status */
-_cupsImageReadSGI(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadSGI(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int i, y; /* Looping vars */
int bpp; /* Bytes per pixel */
- sgi_t *sgip; /* SGI image file */
- cups_ib_t *in, /* Input pixels */
+ cf_sgi_t *sgip; /* SGI image file */
+ cf_ib_t *in, /* Input pixels */
*inptr, /* Current input pixel */
*out; /* Output pixels */
unsigned short *rows[4], /* Row pointers for image data */
* Setup the SGI file...
*/
- sgip = sgiOpenFile(fp, SGI_READ, 0, 0, 0, 0, 0);
+ sgip = cfSGIOpenFile(fp, CF_SGI_READ, 0, 0, 0, 0, 0);
/*
* Get the image dimensions and load the output image...
/*
* Check the image dimensions; since xsize and ysize are unsigned shorts,
- * just check if they are 0 since they can't exceed CUPS_IMAGE_MAX_WIDTH or
- * CUPS_IMAGE_MAX_HEIGHT...
+ * just check if they are 0 since they can't exceed CF_IMAGE_MAX_WIDTH or
+ * CF_IMAGE_MAX_HEIGHT...
*/
if (sgip->xsize == 0 || sgip->ysize == 0 ||
{
DEBUG_printf(("DEBUG: Bad SGI image dimensions %ux%ux%u!\n",
sgip->xsize, sgip->ysize, sgip->zsize));
- sgiClose(sgip);
+ cfSGIClose(sgip);
return (1);
}
if (sgip->zsize < 3)
img->colorspace = secondary;
else
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
img->xsize = sgip->xsize;
img->ysize = sgip->ysize;
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((in = malloc(img->xsize * sgip->zsize)) == NULL)
{
DEBUG_puts("DEBUG: Unable to allocate memory!\n");
- sgiClose(sgip);
+ cfSGIClose(sgip);
return (1);
}
if ((out = malloc(img->xsize * bpp)) == NULL)
{
DEBUG_puts("DEBUG: Unable to allocate memory!\n");
- sgiClose(sgip);
+ cfSGIClose(sgip);
free(in);
return (1);
}
sizeof(unsigned short))) == NULL)
{
DEBUG_puts("DEBUG: Unable to allocate memory!\n");
- sgiClose(sgip);
+ cfSGIClose(sgip);
free(in);
free(out);
return (1);
for (y = 0; y < img->ysize; y ++)
{
for (i = 0; i < sgip->zsize; i ++)
- sgiGetRow(sgip, rows[i], img->ysize - 1 - y, i);
+ cfSGIGetRow(sgip, rows[i], img->ysize - 1 - y, i);
switch (sgip->zsize)
{
if (sgip->zsize < 3)
{
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
{
if (lut)
- cupsImageLut(in, img->xsize, lut);
+ cfImageLut(in, img->xsize, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, in);
+ _cfImagePutRow(img, 0, y, img->xsize, in);
}
else
{
default :
break;
- case CUPS_IMAGE_RGB :
- case CUPS_IMAGE_RGB_CMYK :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ case CF_IMAGE_RGB_CMYK :
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
{
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
free(out);
free(rows[0]);
- sgiClose(sgip);
+ cfSGIClose(sgip);
return (0);
}
/*
- * SGI image file format library definitions for CUPS.
+ * SGI image file format library definitions for CUPS Filters.
*
* Copyright 2007-2011 by Apple Inc.
* Copyright 1993-2005 by Easy Software Products.
* which should have been included with this file.
*/
-#ifndef _SGI_H_
-# define _SGI_H_
+#ifndef _CUPS_FILTERS_SGI_H_
+# define _CUPS_FILTERS_SGI_H_
# include <stdio.h>
# include <stdlib.h>
* Constants...
*/
-# define SGI_MAGIC 474 /* Magic number in image file */
+# define CF_SGI_MAGIC 474 /* Magic number in image file */
-# define SGI_READ 0 /* Read from an SGI image file */
-# define SGI_WRITE 1 /* Write to an SGI image file */
+# define CF_SGI_READ 0 /* Read from an SGI image file */
+# define CF_SGI_WRITE 1 /* Write to an SGI image file */
-# define SGI_COMP_NONE 0 /* No compression */
-# define SGI_COMP_RLE 1 /* Run-length encoding */
-# define SGI_COMP_ARLE 2 /* Agressive run-length encoding */
+# define CF_SGI_COMP_NONE 0 /* No compression */
+# define CF_SGI_COMP_RLE 1 /* Run-length encoding */
+# define CF_SGI_COMP_ARLE 2 /* Agressive run-length encoding */
/*
unsigned short *arle_row; /* Advanced RLE compression buffer */
long arle_offset, /* Advanced RLE buffer offset */
arle_length; /* Advanced RLE buffer length */
-} sgi_t;
+} cf_sgi_t;
/*
* Prototypes...
*/
-extern int sgiClose(sgi_t *sgip);
-extern int sgiGetRow(sgi_t *sgip, unsigned short *row, int y, int z);
-extern sgi_t *sgiOpen(const char *filename, int mode, int comp, int bpp,
- int xsize, int ysize, int zsize);
-extern sgi_t *sgiOpenFile(FILE *file, int mode, int comp, int bpp,
- int xsize, int ysize, int zsize);
-extern int sgiPutRow(sgi_t *sgip, unsigned short *row, int y, int z);
+extern int cfSGIClose(cf_sgi_t *sgip);
+extern int cfSGIGetRow(cf_sgi_t *sgip, unsigned short *row, int y, int z);
+extern cf_sgi_t *cfSGIOpen(const char *filename, int mode, int comp, int bpp,
+ int xsize, int ysize, int zsize);
+extern cf_sgi_t *cfSGIOpenFile(FILE *file, int mode, int comp, int bpp,
+ int xsize, int ysize, int zsize);
+extern int cfSGIPutRow(cf_sgi_t *sgip, unsigned short *row, int y, int z);
# ifdef __cplusplus
}
# endif
-#endif /* !_SGI_H_ */
+#endif /* !_CUPS_FILTERS_SGI_H_ */
*
* Contents:
*
- * sgiClose() - Close an SGI image file.
- * sgiGetRow() - Get a row of image data from a file.
- * sgiOpen() - Open an SGI image file for reading or writing.
- * sgiOpenFile() - Open an SGI image file for reading or writing.
- * sgiPutRow() - Put a row of image data to a file.
+ * cfSGIClose() - Close an SGI image file.
+ * cfSGIGetRow() - Get a row of image data from a file.
+ * cfSGIOpen() - Open an SGI image file for reading or writing.
+ * cfSGIOpenFile() - Open an SGI image file for reading or writing.
+ * cfSGIPutRow() - Put a row of image data to a file.
* getlong() - Get a 32-bit big-endian integer.
* getshort() - Get a 16-bit big-endian integer.
* putlong() - Put a 32-bit big-endian integer.
/*
- * 'sgiClose()' - Close an SGI image file.
+ * 'cfSGIClose()' - Close an SGI image file.
*/
int /* O - 0 on success, -1 on error */
-sgiClose(sgi_t *sgip) /* I - SGI image */
+cfSGIClose(cf_sgi_t *sgip) /* I - SGI image */
{
int i; /* Return status */
long *offset; /* Looping var for offset table */
if (sgip == NULL)
return (-1);
- if (sgip->mode == SGI_WRITE && sgip->comp != SGI_COMP_NONE)
+ if (sgip->mode == CF_SGI_WRITE && sgip->comp != CF_SGI_COMP_NONE)
{
/*
* Write the scanline offset table to the file...
free(sgip->length);
}
- if (sgip->comp == SGI_COMP_ARLE)
+ if (sgip->comp == CF_SGI_COMP_ARLE)
free(sgip->arle_row);
i = fclose(sgip->file);
/*
- * 'sgiGetRow()' - Get a row of image data from a file.
+ * 'cfSGIGetRow()' - Get a row of image data from a file.
*/
int /* O - 0 on success, -1 on error */
-sgiGetRow(sgi_t *sgip, /* I - SGI image */
+cfSGIGetRow(cf_sgi_t *sgip, /* I - SGI image */
unsigned short *row, /* O - Row to read */
int y, /* I - Line to read */
int z) /* I - Channel to read */
switch (sgip->comp)
{
- case SGI_COMP_NONE :
+ case CF_SGI_COMP_NONE :
/*
* Seek to the image row - optimize buffering by only seeking if
* necessary...
}
break;
- case SGI_COMP_RLE :
+ case CF_SGI_COMP_RLE :
offset = sgip->table[z][y];
if (offset != ftell(sgip->file))
fseek(sgip->file, offset, SEEK_SET);
/*
- * 'sgiOpen()' - Open an SGI image file for reading or writing.
+ * 'cfSGIOpen()' - Open an SGI image file for reading or writing.
*/
-sgi_t * /* O - New image */
-sgiOpen(const char *filename, /* I - File to open */
- int mode, /* I - Open mode (SGI_READ or SGI_WRITE) */
+cf_sgi_t * /* O - New image */
+cfSGIOpen(const char *filename, /* I - File to open */
+ int mode, /* I - Open mode (CF_SGI_READ or CF_SGI_WRITE) */
int comp, /* I - Type of compression */
int bpp, /* I - Bytes per pixel */
int xsize, /* I - Width of image in pixels */
int ysize, /* I - Height of image in pixels */
int zsize) /* I - Number of channels */
{
- sgi_t *sgip; /* New SGI image file */
+ cf_sgi_t *sgip; /* New SGI image file */
FILE *file; /* Image file pointer */
- if (mode == SGI_READ)
+ if (mode == CF_SGI_READ)
file = fopen(filename, "rb");
else
file = fopen(filename, "wb+");
if (file == NULL)
return (NULL);
- if ((sgip = sgiOpenFile(file, mode, comp, bpp, xsize, ysize, zsize)) == NULL)
+ if ((sgip = cfSGIOpenFile(file, mode, comp, bpp, xsize, ysize, zsize)) == NULL)
fclose(file);
return (sgip);
/*
- * 'sgiOpenFile()' - Open an SGI image file for reading or writing.
+ * 'cfSGIOpenFile()' - Open an SGI image file for reading or writing.
*/
-sgi_t * /* O - New image */
-sgiOpenFile(FILE *file, /* I - File to open */
- int mode, /* I - Open mode (SGI_READ or SGI_WRITE) */
+cf_sgi_t * /* O - New image */
+cfSGIOpenFile(FILE *file, /* I - File to open */
+ int mode, /* I - Open mode (CF_SGI_READ or CF_SGI_WRITE) */
int comp, /* I - Type of compression */
int bpp, /* I - Bytes per pixel */
int xsize, /* I - Width of image in pixels */
int i, j; /* Looping var */
char name[80]; /* Name of file in image header */
short magic; /* Magic number */
- sgi_t *sgip; /* New image pointer */
+ cf_sgi_t *sgip; /* New image pointer */
- if ((sgip = calloc(sizeof(sgi_t), 1)) == NULL)
+ if ((sgip = calloc(sizeof(cf_sgi_t), 1)) == NULL)
return (NULL);
sgip->file = file;
switch (mode)
{
- case SGI_READ :
- sgip->mode = SGI_READ;
+ case CF_SGI_READ :
+ sgip->mode = CF_SGI_READ;
magic = getshort(sgip->file);
- if (magic != SGI_MAGIC)
+ if (magic != CF_SGI_MAGIC)
{
free(sgip);
return (NULL);
}
break;
- case SGI_WRITE :
+ case CF_SGI_WRITE :
if (xsize < 1 ||
ysize < 1 ||
zsize < 1 ||
bpp < 1 || bpp > 2 ||
- comp < SGI_COMP_NONE || comp > SGI_COMP_ARLE)
+ comp < CF_SGI_COMP_NONE || comp > CF_SGI_COMP_ARLE)
{
free(sgip);
return (NULL);
}
- sgip->mode = SGI_WRITE;
+ sgip->mode = CF_SGI_WRITE;
- putshort(SGI_MAGIC, sgip->file);
+ putshort(CF_SGI_MAGIC, sgip->file);
putc(((sgip->comp = comp) != 0) ? '1': '0', sgip->file);
putc(sgip->bpp = bpp, sgip->file);
putshort(3, sgip->file); /* Dimensions */
switch (comp)
{
- case SGI_COMP_NONE : /* No compression */
+ case CF_SGI_COMP_NONE : /* No compression */
/*
* This file is uncompressed. To avoid problems with sparse files,
* we need to write blank pixels for the entire image...
}
break;
- case SGI_COMP_ARLE : /* Aggressive RLE */
+ case CF_SGI_COMP_ARLE : /* Aggressive RLE */
sgip->arle_row = calloc(xsize, sizeof(unsigned short));
sgip->arle_offset = 0;
- case SGI_COMP_RLE : /* Run-Length Encoding */
+ case CF_SGI_COMP_RLE : /* Run-Length Encoding */
/*
* This file is compressed; write the (blank) scanline tables...
*/
/*
- * 'sgiPutRow()' - Put a row of image data to a file.
+ * 'cfSGIPutRow()' - Put a row of image data to a file.
*/
int /* O - 0 on success, -1 on error */
-sgiPutRow(sgi_t *sgip, /* I - SGI image */
+cfSGIPutRow(cf_sgi_t *sgip, /* I - SGI image */
unsigned short *row, /* I - Row to write */
int y, /* I - Line to write */
int z) /* I - Channel to write */
switch (sgip->comp)
{
- case SGI_COMP_NONE :
+ case CF_SGI_COMP_NONE :
/*
* Seek to the image row - optimize buffering by only seeking if
* necessary...
}
break;
- case SGI_COMP_ARLE :
+ case CF_SGI_COMP_ARLE :
if (sgip->table[z][y] != 0)
return (-1);
else
fseek(sgip->file, 0, SEEK_END); /* Clear EOF */
- case SGI_COMP_RLE :
+ case CF_SGI_COMP_RLE :
if (sgip->table[z][y] != 0)
return (-1);
else
x = write_rle16(sgip->file, row, sgip->xsize);
- if (sgip->comp == SGI_COMP_ARLE)
+ if (sgip->comp == CF_SGI_COMP_ARLE)
{
sgip->arle_offset = offset;
sgip->arle_length = x;
*
* Contents:
*
- * _cupsImageReadSunRaster() - Read a SunRaster image file.
+ * _cfImageReadSunRaster() - Read a SunRaster image file.
* read_unsigned() - Read a 32-bit unsigned integer.
*/
/*
- * '_cupsImageReadSunRaster()' - Read a SunRaster image file.
+ * '_cfImageReadSunRaster()' - Read a SunRaster image file.
*/
int /* O - Read status */
-_cupsImageReadSunRaster(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadSunRaster(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
int i, x, y,
bpp, /* Bytes per pixel */
scanwidth,
run_count,
run_value;
- cups_ib_t *in,
+ cf_ib_t *in,
*out,
*scanline,
*scanptr,
/*
- * Read the header; we already know that this is a raster file (cupsImageOpen
+ * Read the header; we already know that this is a raster file (cfImageOpen
* checks this) so we don't need to check the magic number again.
*/
img->xsize, img->ysize, ras_depth, ras_type, ras_maplength));
if (ras_maplength > 768 ||
- img->xsize == 0 || img->xsize > CUPS_IMAGE_MAX_WIDTH ||
- img->ysize == 0 || img->ysize > CUPS_IMAGE_MAX_HEIGHT ||
+ img->xsize == 0 || img->xsize > CF_IMAGE_MAX_WIDTH ||
+ img->ysize == 0 || img->ysize > CF_IMAGE_MAX_HEIGHT ||
ras_depth == 0 || ras_depth > 32)
{
DEBUG_puts("DEBUG: Raster image cannot be loaded!\n");
}
else
{
- img->colorspace = (primary == CUPS_IMAGE_RGB_CMYK) ? CUPS_IMAGE_RGB : primary;
+ img->colorspace = (primary == CF_IMAGE_RGB_CMYK) ? CF_IMAGE_RGB : primary;
in = malloc(img->xsize * 3 + 1);
}
return (1);
}
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if ((out = malloc(img->xsize * bpp)) == NULL)
{
if (ras_depth <= 8 && ras_maplength == 0)
{
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
{
if (lut)
- cupsImageLut(in, img->xsize, lut);
+ cfImageLut(in, img->xsize, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, in);
+ _cfImagePutRow(img, 0, y, img->xsize, in);
}
else
{
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
{
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
*
* Contents:
*
- * _cupsImageReadTIFF() - Read a TIFF image file.
+ * _cfImageReadTIFF() - Read a TIFF image file.
*/
/*
/*
- * '_cupsImageReadTIFF()' - Read a TIFF image file.
+ * '_cfImageReadTIFF()' - Read a TIFF image file.
*/
int /* O - Read status */
-_cupsImageReadTIFF(
- cups_image_t *img, /* IO - cupsImage */
- FILE *fp, /* I - cupsImage file */
- cups_icspace_t primary, /* I - Primary choice for colorspace */
- cups_icspace_t secondary, /* I - Secondary choice for colorspace */
+_cfImageReadTIFF(
+ cf_image_t *img, /* IO - Image */
+ FILE *fp, /* I - Image file */
+ cf_icspace_t primary, /* I - Primary choice for colorspace */
+ cf_icspace_t secondary, /* I - Secondary choice for colorspace */
int saturation, /* I - Color saturation (%) */
int hue, /* I - Color hue (degrees) */
- const cups_ib_t *lut) /* I - Lookup table for gamma/brightness */
+ const cf_ib_t *lut) /* I - Lookup table for gamma/brightness */
{
TIFF *tif; /* TIFF file */
uint32 width, height; /* Size of image */
pstep, /* Pixel step (= bpp or -2 * bpp) */
scanwidth, /* Width of scanline */
r, g, b, k, /* Red, green, blue, and black values */
- alpha; /* cupsImage includes alpha? */
- cups_ib_t *in, /* Input buffer */
+ alpha; /* Image includes alpha? */
+ cf_ib_t *in, /* Input buffer */
*out, /* Output buffer */
*p, /* Pointer into buffer */
*scanline, /* Scanline buffer */
* Check the size of the image...
*/
- if (width == 0 || width > CUPS_IMAGE_MAX_WIDTH ||
- height == 0 || height > CUPS_IMAGE_MAX_HEIGHT ||
+ if (width == 0 || width > CF_IMAGE_MAX_WIDTH ||
+ height == 0 || height > CF_IMAGE_MAX_HEIGHT ||
(bits != 1 && bits != 2 && bits != 4 && bits != 8) ||
samples < 1 || samples > 4)
{
if (photometric == PHOTOMETRIC_MINISBLACK ||
photometric == PHOTOMETRIC_MINISWHITE)
img->colorspace = secondary;
- else if (photometric == PHOTOMETRIC_SEPARATED && primary == CUPS_IMAGE_RGB_CMYK)
- img->colorspace = CUPS_IMAGE_CMYK;
- else if (primary == CUPS_IMAGE_RGB_CMYK)
- img->colorspace = CUPS_IMAGE_RGB;
+ else if (photometric == PHOTOMETRIC_SEPARATED && primary == CF_IMAGE_RGB_CMYK)
+ img->colorspace = CF_IMAGE_CMYK;
+ else if (primary == CF_IMAGE_RGB_CMYK)
+ img->colorspace = CF_IMAGE_RGB;
else
img->colorspace = primary;
DEBUG_printf(("DEBUG: img->colorspace = %d\n", img->colorspace));
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
- cupsImageSetMaxTiles(img, 0);
+ cfImageSetMaxTiles(img, 0);
/*
* Set the X & Y start and direction according to the image orientation...
else
TIFFReadScanline(tif, in, row, 0);
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
{
if (lut)
- cupsImageLut(in, img->xsize, lut);
+ cfImageLut(in, img->xsize, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, in);
+ _cfImagePutRow(img, 0, y, img->xsize, in);
}
else
{
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageWhiteToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageWhiteToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
}
else
TIFFReadScanline(tif, in, row, 0);
- if (img->colorspace == CUPS_IMAGE_WHITE)
+ if (img->colorspace == CF_IMAGE_WHITE)
{
if (lut)
- cupsImageLut(in, img->ysize, lut);
+ cfImageLut(in, img->ysize, lut);
- _cupsImagePutCol(img, x, 0, img->ysize, in);
+ _cfImagePutCol(img, x, 0, img->ysize, in);
}
else
{
default :
break;
- case CUPS_IMAGE_RGB :
- cupsImageWhiteToRGB(in, out, img->ysize);
+ case CF_IMAGE_RGB :
+ cfImageWhiteToRGB(in, out, img->ysize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageWhiteToBlack(in, out, img->ysize);
+ case CF_IMAGE_BLACK :
+ cfImageWhiteToBlack(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageWhiteToCMY(in, out, img->ysize);
+ case CF_IMAGE_CMY :
+ cfImageWhiteToCMY(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageWhiteToCMYK(in, out, img->ysize);
+ case CF_IMAGE_CMYK :
+ cfImageWhiteToCMYK(in, out, img->ysize);
break;
}
if (lut)
- cupsImageLut(out, img->ysize * bpp, lut);
+ cfImageLut(out, img->ysize * bpp, lut);
- _cupsImagePutCol(img, x, 0, img->ysize, out);
+ _cfImagePutCol(img, x, 0, img->ysize, out);
}
}
}
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->ysize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->ysize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->ysize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->ysize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->ysize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->ysize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->ysize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->ysize);
break;
}
if (lut)
- cupsImageLut(out, img->ysize * bpp, lut);
+ cfImageLut(out, img->ysize * bpp, lut);
- _cupsImagePutCol(img, x, 0, img->ysize, out);
+ _cfImagePutCol(img, x, 0, img->ysize, out);
}
}
break;
TIFFReadScanline(tif, in, row, 0);
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * bpp, lut);
+ cfImageLut(out, img->xsize * bpp, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
TIFFReadScanline(tif, in, row, 0);
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->ysize, saturation, hue);
+ cfImageRGBAdjust(in, img->ysize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->ysize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->ysize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->ysize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->ysize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->ysize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->ysize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->ysize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->ysize);
break;
}
if (lut)
- cupsImageLut(out, img->ysize * bpp, lut);
+ cfImageLut(out, img->ysize * bpp, lut);
- _cupsImagePutCol(img, x, 0, img->ysize, out);
+ _cfImagePutCol(img, x, 0, img->ysize, out);
}
}
break;
}
}
}
- else if (img->colorspace == CUPS_IMAGE_CMYK)
+ else if (img->colorspace == CF_IMAGE_CMYK)
{
TIFFReadScanline(tif, scanline, row, 0);
- _cupsImagePutRow(img, 0, y, img->xsize, scanline);
+ _cfImagePutRow(img, 0, y, img->xsize, scanline);
}
else
{
}
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->xsize, saturation, hue);
+ cfImageRGBAdjust(in, img->xsize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->xsize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->xsize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->xsize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->xsize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->xsize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->xsize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->xsize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->xsize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->xsize);
break;
}
if (lut)
- cupsImageLut(out, img->xsize * 3, lut);
+ cfImageLut(out, img->xsize * 3, lut);
- _cupsImagePutRow(img, 0, y, img->xsize, out);
+ _cfImagePutRow(img, 0, y, img->xsize, out);
}
}
else
}
}
}
- else if (img->colorspace == CUPS_IMAGE_CMYK)
+ else if (img->colorspace == CF_IMAGE_CMYK)
{
TIFFReadScanline(tif, scanline, row, 0);
- _cupsImagePutCol(img, x, 0, img->ysize, scanline);
+ _cfImagePutCol(img, x, 0, img->ysize, scanline);
}
else
{
}
if ((saturation != 100 || hue != 0) && bpp > 1)
- cupsImageRGBAdjust(in, img->ysize, saturation, hue);
+ cfImageRGBAdjust(in, img->ysize, saturation, hue);
switch (img->colorspace)
{
default :
break;
- case CUPS_IMAGE_WHITE :
- cupsImageRGBToWhite(in, out, img->ysize);
+ case CF_IMAGE_WHITE :
+ cfImageRGBToWhite(in, out, img->ysize);
break;
- case CUPS_IMAGE_RGB :
- cupsImageRGBToRGB(in, out, img->ysize);
+ case CF_IMAGE_RGB :
+ cfImageRGBToRGB(in, out, img->ysize);
break;
- case CUPS_IMAGE_BLACK :
- cupsImageRGBToBlack(in, out, img->ysize);
+ case CF_IMAGE_BLACK :
+ cfImageRGBToBlack(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMY :
- cupsImageRGBToCMY(in, out, img->ysize);
+ case CF_IMAGE_CMY :
+ cfImageRGBToCMY(in, out, img->ysize);
break;
- case CUPS_IMAGE_CMYK :
- cupsImageRGBToCMYK(in, out, img->ysize);
+ case CF_IMAGE_CMYK :
+ cfImageRGBToCMYK(in, out, img->ysize);
break;
}
if (lut)
- cupsImageLut(out, img->ysize * bpp, lut);
+ cfImageLut(out, img->ysize * bpp, lut);
- _cupsImagePutCol(img, x, 0, img->ysize, out);
+ _cfImagePutCol(img, x, 0, img->ysize, out);
}
}
/*
- * cupsImage zoom routines for CUPS.
+ * Image zoom routines for CUPS.
*
* Copyright 2007-2011 by Apple Inc.
* Copyright 1993-2006 by Easy Software Products.
*
* Contents:
*
- * _cupsImageZoomDelete() - Free a zoom record...
- * _cupsImageZoomFill() - Fill a zoom record...
- * _cupsImageZoomNew() - Allocate a pixel zoom record...
+ * _cfImageZoomDelete() - Free a zoom record...
+ * _cfImageZoomFill() - Fill a zoom record...
+ * _cfImageZoomNew() - Allocate a pixel zoom record...
* zoom_bilinear() - Fill a zoom record with image data utilizing
* bilinear interpolation.
* zoom_nearest() - Fill a zoom record quickly using nearest-neighbor
* Local functions...
*/
-static void zoom_bilinear(cups_izoom_t *z, int iy);
-static void zoom_nearest(cups_izoom_t *z, int iy);
+static void zoom_bilinear(cf_izoom_t *z, int iy);
+static void zoom_nearest(cf_izoom_t *z, int iy);
/*
- * '_cupsImageZoomDelete()' - Free a zoom record...
+ * '_cfImageZoomDelete()' - Free a zoom record...
*/
void
-_cupsImageZoomDelete(cups_izoom_t *z) /* I - Zoom record to free */
+_cfImageZoomDelete(cf_izoom_t *z) /* I - Zoom record to free */
{
free(z->rows[0]);
free(z->rows[1]);
/*
- * '_cupsImageZoomFill()' - Fill a zoom record with image data utilizing bilinear
+ * '_cfImageZoomFill()' - Fill a zoom record with image data utilizing bilinear
* interpolation.
*/
void
-_cupsImageZoomFill(cups_izoom_t *z, /* I - Zoom record to fill */
+_cfImageZoomFill(cf_izoom_t *z, /* I - Zoom record to fill */
int iy) /* I - Zoom image row */
{
switch (z->type)
{
- case CUPS_IZOOM_FAST :
+ case CF_IZOOM_FAST :
zoom_nearest(z, iy);
break;
/*
- * '_cupsImageZoomNew()' - Allocate a pixel zoom record...
+ * '_cfImageZoomNew()' - Allocate a pixel zoom record...
*/
-cups_izoom_t *
-_cupsImageZoomNew(
- cups_image_t *img, /* I - cupsImage to zoom */
+cf_izoom_t *
+_cfImageZoomNew(
+ cf_image_t *img, /* I - Image to zoom */
int xc0, /* I - Upper-lefthand corner */
int yc0, /* I - ... */
int xc1, /* I - Lower-righthand corner */
int xsize, /* I - Final width of image */
int ysize, /* I - Final height of image */
int rotated, /* I - Non-zero if image is rotated 90 degs */
- cups_iztype_t type) /* I - Zoom type */
+ cf_iztype_t type) /* I - Zoom type */
{
- cups_izoom_t *z; /* New zoom record */
+ cf_izoom_t *z; /* New zoom record */
int flip; /* Flip on X axis? */
- if (xsize > CUPS_IMAGE_MAX_WIDTH ||
- ysize > CUPS_IMAGE_MAX_HEIGHT ||
- (xc1 - xc0) > CUPS_IMAGE_MAX_WIDTH ||
- (yc1 - yc0) > CUPS_IMAGE_MAX_HEIGHT)
+ if (xsize > CF_IMAGE_MAX_WIDTH ||
+ ysize > CF_IMAGE_MAX_HEIGHT ||
+ (xc1 - xc0) > CF_IMAGE_MAX_WIDTH ||
+ (yc1 - yc0) > CF_IMAGE_MAX_HEIGHT)
return (NULL); /* Protect against integer overflow */
- if ((z = (cups_izoom_t *)calloc(1, sizeof(cups_izoom_t))) == NULL)
+ if ((z = (cf_izoom_t *)calloc(1, sizeof(cf_izoom_t))) == NULL)
return (NULL);
z->img = img;
z->row = 0;
- z->depth = cupsImageGetDepth(img);
+ z->depth = cfImageGetDepth(img);
z->rotated = rotated;
z->type = type;
z->inincr = -z->inincr;
}
- if ((z->rows[0] = (cups_ib_t *)malloc(z->xsize * z->depth)) == NULL)
+ if ((z->rows[0] = (cf_ib_t *)malloc(z->xsize * z->depth)) == NULL)
{
free(z);
return (NULL);
}
- if ((z->rows[1] = (cups_ib_t *)malloc(z->xsize * z->depth)) == NULL)
+ if ((z->rows[1] = (cf_ib_t *)malloc(z->xsize * z->depth)) == NULL)
{
free(z->rows[0]);
free(z);
return (NULL);
}
- if ((z->in = (cups_ib_t *)malloc(z->width * z->depth)) == NULL)
+ if ((z->in = (cf_ib_t *)malloc(z->width * z->depth)) == NULL)
{
free(z->rows[0]);
free(z->rows[1]);
*/
static void
-zoom_bilinear(cups_izoom_t *z, /* I - Zoom record to fill */
+zoom_bilinear(cf_izoom_t *z, /* I - Zoom record to fill */
int iy) /* I - Zoom image row */
{
- cups_ib_t *r, /* Row pointer */
+ cf_ib_t *r, /* Row pointer */
*inptr; /* Pixel pointer */
int xerr0, /* X error counter */
xerr1; /* ... */
z_inincr = z->inincr;
if (z->rotated)
- cupsImageGetCol(z->img, z->xorig - iy, z->yorig, z->width, z->in);
+ cfImageGetCol(z->img, z->xorig - iy, z->yorig, z->width, z->in);
else
- cupsImageGetRow(z->img, z->xorig, z->yorig + iy, z->width, z->in);
+ cfImageGetRow(z->img, z->xorig, z->yorig + iy, z->width, z->in);
if (z_inincr < 0)
inptr = z->in + (z->width - 1) * z_depth;
*/
static void
-zoom_nearest(cups_izoom_t *z, /* I - Zoom record to fill */
+zoom_nearest(cf_izoom_t *z, /* I - Zoom record to fill */
int iy) /* I - Zoom image row */
{
- cups_ib_t *r, /* Row pointer */
+ cf_ib_t *r, /* Row pointer */
*inptr; /* Pixel pointer */
int xerr0; /* X error counter */
int ix,
z_inincr = z->inincr;
if (z->rotated)
- cupsImageGetCol(z->img, z->xorig - iy, z->yorig, z->width, z->in);
+ cfImageGetCol(z->img, z->xorig - iy, z->yorig, z->width, z->in);
else
- cupsImageGetRow(z->img, z->xorig, z->yorig + iy, z->width, z->in);
+ cfImageGetRow(z->img, z->xorig, z->yorig + iy, z->width, z->in);
if (z_inincr < 0)
inptr = z->in + (z->width - 1) * z_depth;
*
* Contents:
*
- * cupsImageClose() - Close an image file.
- * cupsImageGetCol() - Get a column of pixels from an image.
- * cupsImageGetColorSpace() - Get the image colorspace.
- * cupsImageGetDepth() - Get the number of bytes per pixel.
- * cupsImageGetHeight() - Get the height of an image.
- * cupsImageGetRow() - Get a row of pixels from an image.
- * cupsImageGetWidth() - Get the width of an image.
- * cupsImageGetXPPI() - Get the horizontal resolution of an image.
- * cupsImageGetYPPI() - Get the vertical resolution of an image.
- * cupsImageOpen() - Open an image file and read it into memory.
- * _cupsImagePutCol() - Put a column of pixels to an image.
- * _cupsImagePutRow() - Put a row of pixels to an image.
- * cupsImageSetMaxTiles() - Set the maximum number of tiles to cache.
+ * cfImageClose() - Close an image file.
+ * cfImageGetCol() - Get a column of pixels from an image.
+ * cfImageGetColorSpace() - Get the image colorspace.
+ * cfImageGetDepth() - Get the number of bytes per pixel.
+ * cfImageGetHeight() - Get the height of an image.
+ * cfImageGetRow() - Get a row of pixels from an image.
+ * cfImageGetWidth() - Get the width of an image.
+ * cfImageGetXPPI() - Get the horizontal resolution of an image.
+ * cfImageGetYPPI() - Get the vertical resolution of an image.
+ * cfImageOpen() - Open an image file and read it into memory.
+ * _cfImagePutCol() - Put a column of pixels to an image.
+ * _cfImagePutRow() - Put a row of pixels to an image.
+ * cfImageSetMaxTiles() - Set the maximum number of tiles to cache.
* flush_tile() - Flush the least-recently-used tile in the cache.
* get_tile() - Get a cached tile.
*/
* Local functions...
*/
-static int flush_tile(cups_image_t *img);
-static cups_ib_t *get_tile(cups_image_t *img, int x, int y);
+static int flush_tile(cf_image_t *img);
+static cf_ib_t *get_tile(cf_image_t *img, int x, int y);
/*
- * 'cupsImageClose()' - Close an image file.
+ * 'cfImageClose()' - Close an image file.
*/
void
-cupsImageClose(cups_image_t *img) /* I - Image to close */
+cfImageClose(cf_image_t *img) /* I - Image to close */
{
- cups_ic_t *current, /* Current cached tile */
+ cf_ic_t *current, /* Current cached tile */
*next; /* Next cached tile */
/*
- * 'cupsImageGetCol()' - Get a column of pixels from an image.
+ * 'cfImageGetCol()' - Get a column of pixels from an image.
*/
int /* O - -1 on error, 0 on success */
-cupsImageGetCol(cups_image_t *img, /* I - Image */
+cfImageGetCol(cf_image_t *img, /* I - Image */
int x, /* I - Column */
int y, /* I - Start row */
int height, /* I - Column height */
- cups_ib_t *pixels) /* O - Pixel data */
+ cf_ib_t *pixels) /* O - Pixel data */
{
int bpp, /* Bytes per pixel */
twidth, /* Tile width */
count; /* Number of pixels to get */
- const cups_ib_t *ib; /* Pointer into tile */
+ const cf_ib_t *ib; /* Pointer into tile */
if (img == NULL || x < 0 || x >= img->xsize || y >= img->ysize)
if (height < 1)
return (-1);
- bpp = cupsImageGetDepth(img);
- twidth = bpp * (CUPS_TILE_SIZE - 1);
+ bpp = cfImageGetDepth(img);
+ twidth = bpp * (CF_TILE_SIZE - 1);
while (height > 0)
{
if (ib == NULL)
return (-1);
- count = CUPS_TILE_SIZE - (y & (CUPS_TILE_SIZE - 1));
+ count = CF_TILE_SIZE - (y & (CF_TILE_SIZE - 1));
if (count > height)
count = height;
/*
- * 'cupsImageGetColorSpace()' - Get the image colorspace.
+ * 'cfImageGetColorSpace()' - Get the image colorspace.
*/
-cups_icspace_t /* O - Colorspace */
-cupsImageGetColorSpace(
- cups_image_t *img) /* I - Image */
+cf_icspace_t /* O - Colorspace */
+cfImageGetColorSpace(
+ cf_image_t *img) /* I - Image */
{
return (img->colorspace);
}
/*
- * 'cupsImageGetDepth()' - Get the number of bytes per pixel.
+ * 'cfImageGetDepth()' - Get the number of bytes per pixel.
*/
int /* O - Bytes per pixel */
-cupsImageGetDepth(cups_image_t *img) /* I - Image */
+cfImageGetDepth(cf_image_t *img) /* I - Image */
{
return (abs(img->colorspace));
}
/*
- * 'cupsImageGetHeight()' - Get the height of an image.
+ * 'cfImageGetHeight()' - Get the height of an image.
*/
unsigned /* O - Height in pixels */
-cupsImageGetHeight(cups_image_t *img) /* I - Image */
+cfImageGetHeight(cf_image_t *img) /* I - Image */
{
return (img->ysize);
}
/*
- * 'cupsImageGetRow()' - Get a row of pixels from an image.
+ * 'cfImageGetRow()' - Get a row of pixels from an image.
*/
int /* O - -1 on error, 0 on success */
-cupsImageGetRow(cups_image_t *img, /* I - Image */
+cfImageGetRow(cf_image_t *img, /* I - Image */
int x, /* I - Start column */
int y, /* I - Row */
int width, /* I - Width of row */
- cups_ib_t *pixels) /* O - Pixel data */
+ cf_ib_t *pixels) /* O - Pixel data */
{
int bpp, /* Bytes per pixel */
count; /* Number of pixels to get */
- const cups_ib_t *ib; /* Pointer to pixels */
+ const cf_ib_t *ib; /* Pointer to pixels */
if (img == NULL || y < 0 || y >= img->ysize || x >= img->xsize)
if (ib == NULL)
return (-1);
- count = CUPS_TILE_SIZE - (x & (CUPS_TILE_SIZE - 1));
+ count = CF_TILE_SIZE - (x & (CF_TILE_SIZE - 1));
if (count > width)
count = width;
memcpy(pixels, ib, count * bpp);
/*
- * 'cupsImageGetWidth()' - Get the width of an image.
+ * 'cfImageGetWidth()' - Get the width of an image.
*/
unsigned /* O - Width in pixels */
-cupsImageGetWidth(cups_image_t *img) /* I - Image */
+cfImageGetWidth(cf_image_t *img) /* I - Image */
{
return (img->xsize);
}
/*
- * 'cupsImageGetXPPI()' - Get the horizontal resolution of an image.
+ * 'cfImageGetXPPI()' - Get the horizontal resolution of an image.
*/
unsigned /* O - Horizontal PPI */
-cupsImageGetXPPI(cups_image_t *img) /* I - Image */
+cfImageGetXPPI(cf_image_t *img) /* I - Image */
{
return (img->xppi);
}
/*
- * 'cupsImageGetYPPI()' - Get the vertical resolution of an image.
+ * 'cfImageGetYPPI()' - Get the vertical resolution of an image.
*/
unsigned /* O - Vertical PPI */
-cupsImageGetYPPI(cups_image_t *img) /* I - Image */
+cfImageGetYPPI(cf_image_t *img) /* I - Image */
{
return (img->yppi);
}
/*
- * 'cupsImageOpen()' - Open an image file and read it into memory.
+ * 'cfImageOpen()' - Open an image file and read it into memory.
*/
-cups_image_t * /* O - New image */
-cupsImageOpen(
+cf_image_t * /* O - New image */
+cfImageOpen(
const char *filename, /* I - Filename of image */
- cups_icspace_t primary, /* I - Primary colorspace needed */
- cups_icspace_t secondary, /* I - Secondary colorspace if primary no good */
+ cf_icspace_t primary, /* I - Primary colorspace needed */
+ cf_icspace_t secondary, /* I - Secondary colorspace if primary no good */
int saturation, /* I - Color saturation level */
int hue, /* I - Color hue adjustment */
- const cups_ib_t *lut) /* I - RGB gamma/brightness LUT */
+ const cf_ib_t *lut) /* I - RGB gamma/brightness LUT */
{
FILE *fp; /* File pointer */
- DEBUG_printf(("cupsImageOpen(\"%s\", %d, %d, %d, %d, %p)\n",
+ DEBUG_printf(("cfImageOpen(\"%s\", %d, %d, %d, %d, %p)\n",
filename ? filename : "(null)", primary, secondary,
saturation, hue, lut));
if ((fp = fopen(filename, "r")) == NULL)
return (NULL);
- return cupsImageOpenFP(fp, primary, secondary, saturation, hue, lut);
+ return cfImageOpenFP(fp, primary, secondary, saturation, hue, lut);
}
/*
- * 'cupsImageOpenFP()' - Open an image file and read it into memory.
+ * 'cfImageOpenFP()' - Open an image file and read it into memory.
*/
-cups_image_t * /* O - New image */
-cupsImageOpenFP(
+cf_image_t * /* O - New image */
+cfImageOpenFP(
FILE *fp, /* I - File pointer of image */
- cups_icspace_t primary, /* I - Primary colorspace needed */
- cups_icspace_t secondary, /* I - Secondary colorspace if primary no good */
+ cf_icspace_t primary, /* I - Primary colorspace needed */
+ cf_icspace_t secondary, /* I - Secondary colorspace if primary no good */
int saturation, /* I - Color saturation level */
int hue, /* I - Color hue adjustment */
- const cups_ib_t *lut) /* I - RGB gamma/brightness LUT */
+ const cf_ib_t *lut) /* I - RGB gamma/brightness LUT */
{
unsigned char header[16], /* First 16 bytes of file */
header2[16]; /* Bytes 2048-2064 (PhotoCD) */
- cups_image_t *img; /* New image buffer */
+ cf_image_t *img; /* New image buffer */
int status; /* Status of load... */
- DEBUG_printf(("cupsImageOpen2(%p, %d, %d, %d, %d, %p)\n",
+ DEBUG_printf(("cfImageOpen2(%p, %d, %d, %d, %d, %p)\n",
fp, primary, secondary, saturation, hue, lut));
/*
* Allocate memory...
*/
- img = calloc(sizeof(cups_image_t), 1);
+ img = calloc(sizeof(cf_image_t), 1);
if (img == NULL)
{
*/
img->cachefile = -1;
- img->max_ics = CUPS_TILE_MINIMUM;
+ img->max_ics = CF_TILE_MINIMUM;
img->xppi = 200;
img->yppi = 200;
if (!memcmp(header, "GIF87a", 6) || !memcmp(header, "GIF89a", 6))
- status = _cupsImageReadGIF(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadGIF(img, fp, primary, secondary, saturation, hue,
lut);
else if (!memcmp(header, "BM", 2))
- status = _cupsImageReadBMP(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadBMP(img, fp, primary, secondary, saturation, hue,
lut);
else if (header[0] == 0x01 && header[1] == 0xda)
- status = _cupsImageReadSGI(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadSGI(img, fp, primary, secondary, saturation, hue,
lut);
else if (header[0] == 0x59 && header[1] == 0xa6 &&
header[2] == 0x6a && header[3] == 0x95)
- status = _cupsImageReadSunRaster(img, fp, primary, secondary, saturation,
+ status = _cfImageReadSunRaster(img, fp, primary, secondary, saturation,
hue, lut);
else if (header[0] == 'P' && header[1] >= '1' && header[1] <= '6')
- status = _cupsImageReadPNM(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadPNM(img, fp, primary, secondary, saturation, hue,
lut);
else if (!memcmp(header2, "PCD_IPI", 7))
- status = _cupsImageReadPhotoCD(img, fp, primary, secondary, saturation,
+ status = _cfImageReadPhotoCD(img, fp, primary, secondary, saturation,
hue, lut);
else if (!memcmp(header + 8, "\000\010", 2) ||
!memcmp(header + 8, "\000\030", 2))
- status = _cupsImageReadPIX(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadPIX(img, fp, primary, secondary, saturation, hue,
lut);
#if defined(HAVE_LIBPNG) && defined(HAVE_LIBZ)
else if (!memcmp(header, "\211PNG", 4))
- status = _cupsImageReadPNG(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadPNG(img, fp, primary, secondary, saturation, hue,
lut);
#endif /* HAVE_LIBPNG && HAVE_LIBZ */
#ifdef HAVE_LIBJPEG
else if (!memcmp(header, "\377\330\377", 3) && /* Start-of-Image */
header[3] >= 0xe0 && header[3] <= 0xef) /* APPn */
- status = _cupsImageReadJPEG(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadJPEG(img, fp, primary, secondary, saturation, hue,
lut);
#endif /* HAVE_LIBJPEG */
#ifdef HAVE_LIBTIFF
else if (!memcmp(header, "MM\000\052", 4) ||
!memcmp(header, "II\052\000", 4))
- status = _cupsImageReadTIFF(img, fp, primary, secondary, saturation, hue,
+ status = _cfImageReadTIFF(img, fp, primary, secondary, saturation, hue,
lut);
#endif /* HAVE_LIBTIFF */
else
/*
- * '_cupsImagePutCol()' - Put a column of pixels to an image.
+ * '_cfImagePutCol()' - Put a column of pixels to an image.
*/
int /* O - -1 on error, 0 on success */
-_cupsImagePutCol(
- cups_image_t *img, /* I - Image */
+_cfImagePutCol(
+ cf_image_t *img, /* I - Image */
int x, /* I - Column */
int y, /* I - Start row */
int height, /* I - Column height */
- const cups_ib_t *pixels) /* I - Pixels to put */
+ const cf_ib_t *pixels) /* I - Pixels to put */
{
int bpp, /* Bytes per pixel */
twidth, /* Width of tile */
count; /* Number of pixels to put */
int tilex, /* Column within tile */
tiley; /* Row within tile */
- cups_ib_t *ib; /* Pointer to pixels in tile */
+ cf_ib_t *ib; /* Pointer to pixels in tile */
if (img == NULL || x < 0 || x >= img->xsize || y >= img->ysize)
if (height < 1)
return (-1);
- bpp = cupsImageGetDepth(img);
- twidth = bpp * (CUPS_TILE_SIZE - 1);
- tilex = x / CUPS_TILE_SIZE;
- tiley = y / CUPS_TILE_SIZE;
+ bpp = cfImageGetDepth(img);
+ twidth = bpp * (CF_TILE_SIZE - 1);
+ tilex = x / CF_TILE_SIZE;
+ tiley = y / CF_TILE_SIZE;
while (height > 0)
{
img->tiles[tiley][tilex].dirty = 1;
tiley ++;
- count = CUPS_TILE_SIZE - (y & (CUPS_TILE_SIZE - 1));
+ count = CF_TILE_SIZE - (y & (CF_TILE_SIZE - 1));
if (count > height)
count = height;
/*
- * '_cupsImagePutRow()' - Put a row of pixels to an image.
+ * '_cfImagePutRow()' - Put a row of pixels to an image.
*/
int /* O - -1 on error, 0 on success */
-_cupsImagePutRow(
- cups_image_t *img, /* I - Image */
+_cfImagePutRow(
+ cf_image_t *img, /* I - Image */
int x, /* I - Start column */
int y, /* I - Row */
int width, /* I - Row width */
- const cups_ib_t *pixels) /* I - Pixel data */
+ const cf_ib_t *pixels) /* I - Pixel data */
{
int bpp, /* Bytes per pixel */
count; /* Number of pixels to put */
int tilex, /* Column within tile */
tiley; /* Row within tile */
- cups_ib_t *ib; /* Pointer to pixels in tile */
+ cf_ib_t *ib; /* Pointer to pixels in tile */
if (img == NULL || y < 0 || y >= img->ysize || x >= img->xsize)
return (-1);
bpp = img->colorspace < 0 ? -img->colorspace : img->colorspace;
- tilex = x / CUPS_TILE_SIZE;
- tiley = y / CUPS_TILE_SIZE;
+ tilex = x / CF_TILE_SIZE;
+ tiley = y / CF_TILE_SIZE;
while (width > 0)
{
img->tiles[tiley][tilex].dirty = 1;
- count = CUPS_TILE_SIZE - (x & (CUPS_TILE_SIZE - 1));
+ count = CF_TILE_SIZE - (x & (CF_TILE_SIZE - 1));
if (count > width)
count = width;
memcpy(ib, pixels, count * bpp);
/*
- * 'cupsImageSetMaxTiles()' - Set the maximum number of tiles to cache.
+ * 'cfImageSetMaxTiles()' - Set the maximum number of tiles to cache.
*
* If the "max_tiles" argument is 0 then the maximum number of tiles is
* computed from the image size or the RIP_CACHE environment variable.
*/
void
-cupsImageSetMaxTiles(
- cups_image_t *img, /* I - Image to set */
+cfImageSetMaxTiles(
+ cf_image_t *img, /* I - Image to set */
int max_tiles) /* I - Number of tiles to cache */
{
int cache_size, /* Size of tile cache in bytes */
cache_units[255]; /* Cache size units */
- min_tiles = max(CUPS_TILE_MINIMUM,
- 1 + max((img->xsize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE,
- (img->ysize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE));
+ min_tiles = max(CF_TILE_MINIMUM,
+ 1 + max((img->xsize + CF_TILE_SIZE - 1) / CF_TILE_SIZE,
+ (img->ysize + CF_TILE_SIZE - 1) / CF_TILE_SIZE));
if (max_tiles == 0)
- max_tiles = ((img->xsize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE) *
- ((img->ysize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE);
+ max_tiles = ((img->xsize + CF_TILE_SIZE - 1) / CF_TILE_SIZE) *
+ ((img->ysize + CF_TILE_SIZE - 1) / CF_TILE_SIZE);
- cache_size = max_tiles * CUPS_TILE_SIZE * CUPS_TILE_SIZE *
- cupsImageGetDepth(img);
+ cache_size = max_tiles * CF_TILE_SIZE * CF_TILE_SIZE *
+ cfImageGetDepth(img);
if ((cache_env = getenv("RIP_MAX_CACHE")) != NULL)
{
max_size = 32 * 1024 * 1024;
break;
case 1 :
- max_size *= 4 * CUPS_TILE_SIZE * CUPS_TILE_SIZE;
+ max_size *= 4 * CF_TILE_SIZE * CF_TILE_SIZE;
break;
case 2 :
if (tolower(cache_units[0] & 255) == 'g')
else if (tolower(cache_units[0] & 255) == 'k')
max_size *= 1024;
else if (tolower(cache_units[0] & 255) == 't')
- max_size *= 4 * CUPS_TILE_SIZE * CUPS_TILE_SIZE;
+ max_size *= 4 * CF_TILE_SIZE * CF_TILE_SIZE;
break;
}
}
max_size = 32 * 1024 * 1024;
if (cache_size > max_size)
- max_tiles = max_size / CUPS_TILE_SIZE / CUPS_TILE_SIZE /
- cupsImageGetDepth(img);
+ max_tiles = max_size / CF_TILE_SIZE / CF_TILE_SIZE /
+ cfImageGetDepth(img);
if (max_tiles < min_tiles)
max_tiles = min_tiles;
*/
static int
-flush_tile(cups_image_t *img) /* I - Image */
+flush_tile(cf_image_t *img) /* I - Image */
{
int bpp; /* Bytes per pixel */
- cups_itile_t *tile; /* Pointer to tile */
+ cf_itile_t *tile; /* Pointer to tile */
- bpp = cupsImageGetDepth(img);
+ bpp = cfImageGetDepth(img);
if(img==NULL||img->first==NULL||img->first->tile==NULL)
{
return -1;
}
if (write(img->cachefile, tile->ic->pixels,
- bpp * CUPS_TILE_SIZE * CUPS_TILE_SIZE) == -1)
+ bpp * CF_TILE_SIZE * CF_TILE_SIZE) == -1)
DEBUG_printf(("Error writing cache tile!"));
tile->ic = NULL;
* 'get_tile()' - Get a cached tile.
*/
-static cups_ib_t * /* O - Pointer to tile or NULL */
-get_tile(cups_image_t *img, /* I - Image */
+static cf_ib_t * /* O - Pointer to tile or NULL */
+get_tile(cf_image_t *img, /* I - Image */
int x, /* I - Column in image */
int y) /* I - Row in image */
{
tiley, /* Row within tile */
xtiles, /* Number of tiles horizontally */
ytiles; /* Number of tiles vertically */
- cups_ic_t *ic; /* Cache pointer */
- cups_itile_t *tile; /* Tile pointer */
+ cf_ic_t *ic; /* Cache pointer */
+ cf_itile_t *tile; /* Tile pointer */
if (img->tiles == NULL)
{
- xtiles = (img->xsize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE;
- ytiles = (img->ysize + CUPS_TILE_SIZE - 1) / CUPS_TILE_SIZE;
+ xtiles = (img->xsize + CF_TILE_SIZE - 1) / CF_TILE_SIZE;
+ ytiles = (img->ysize + CF_TILE_SIZE - 1) / CF_TILE_SIZE;
DEBUG_printf(("Creating tile array (%dx%d)\n", xtiles, ytiles));
- if ((img->tiles = calloc(sizeof(cups_itile_t *), ytiles)) == NULL)
+ if ((img->tiles = calloc(sizeof(cf_itile_t *), ytiles)) == NULL)
return (NULL);
- if ((tile = calloc(xtiles * sizeof(cups_itile_t), ytiles)) == NULL)
+ if ((tile = calloc(xtiles * sizeof(cf_itile_t), ytiles)) == NULL)
return (NULL);
for (tiley = 0; tiley < ytiles; tiley ++)
}
}
- bpp = cupsImageGetDepth(img);
- tilex = x / CUPS_TILE_SIZE;
- tiley = y / CUPS_TILE_SIZE;
+ bpp = cfImageGetDepth(img);
+ tilex = x / CF_TILE_SIZE;
+ tiley = y / CF_TILE_SIZE;
tile = img->tiles[tiley] + tilex;
- x &= (CUPS_TILE_SIZE - 1);
- y &= (CUPS_TILE_SIZE - 1);
+ x &= (CF_TILE_SIZE - 1);
+ y &= (CF_TILE_SIZE - 1);
if ((ic = tile->ic) == NULL)
{
if (img->num_ics < img->max_ics)
{
- if ((ic = calloc(sizeof(cups_ic_t) +
- bpp * CUPS_TILE_SIZE * CUPS_TILE_SIZE, 1)) == NULL)
+ if ((ic = calloc(sizeof(cf_ic_t) +
+ bpp * CF_TILE_SIZE * CF_TILE_SIZE, 1)) == NULL)
{
if (img->num_ics == 0)
return (NULL);
}
else
{
- ic->pixels = ((cups_ib_t *)ic) + sizeof(cups_ic_t);
+ ic->pixels = ((cf_ib_t *)ic) + sizeof(cf_ic_t);
img->num_ics ++;
lseek(img->cachefile, tile->pos, SEEK_SET);
if (read(img->cachefile, ic->pixels,
- bpp * CUPS_TILE_SIZE * CUPS_TILE_SIZE) == -1)
+ bpp * CF_TILE_SIZE * CF_TILE_SIZE) == -1)
DEBUG_printf(("Error reading cache tile!"));
}
else
{
DEBUG_puts("Clearing cache tile...");
- memset(ic->pixels, 0, bpp * CUPS_TILE_SIZE * CUPS_TILE_SIZE);
+ memset(ic->pixels, 0, bpp * CF_TILE_SIZE * CF_TILE_SIZE);
}
}
ic->next = NULL;
- return (ic->pixels + bpp * (y * CUPS_TILE_SIZE + x));
+ return (ic->pixels + bpp * (y * CF_TILE_SIZE + x));
}
/*
* (posw,posh): Position of left corner
* (width,height): width and height of required image.
*/
-cups_image_t* cupsImageCrop(cups_image_t* img,int posw,int posh,int width,int height)
+cf_image_t* cfImageCrop(cf_image_t* img,int posw,int posh,int width,int height)
{
- int image_width = cupsImageGetWidth(img);
- cups_image_t* temp=calloc(sizeof(cups_image_t),1);
- cups_ib_t *pixels=(cups_ib_t*)malloc(img->xsize*cupsImageGetDepth(img));
+ int image_width = cfImageGetWidth(img);
+ cf_image_t* temp=calloc(sizeof(cf_image_t),1);
+ cf_ib_t *pixels=(cf_ib_t*)malloc(img->xsize*cfImageGetDepth(img));
temp->cachefile = -1;
- temp->max_ics = CUPS_TILE_MINIMUM;
+ temp->max_ics = CF_TILE_MINIMUM;
temp->colorspace=img->colorspace;
temp->xppi = img->xppi;
temp->yppi = img->yppi;
temp->tiles = NULL;
temp->xsize = width;
temp->ysize = height;
- for(int i=posh;i<min(cupsImageGetHeight(img),posh+height);i++){
- cupsImageGetRow(img,posw,i,min(width,image_width-posw),pixels);
- _cupsImagePutRow(temp,0,i-posh,min(width,image_width-posw),pixels);
+ for(int i=posh;i<min(cfImageGetHeight(img),posh+height);i++){
+ cfImageGetRow(img,posw,i,min(width,image_width-posw),pixels);
+ _cfImagePutRow(temp,0,i-posh,min(width,image_width-posw),pixels);
}
free(pixels);
return temp;
/*
- * Image library definitions for CUPS.
+ * Image library definitions for CUPS Filters.
*
* Copyright 2007-2011 by Apple Inc.
* Copyright 1993-2006 by Easy Software Products.
* Constants...
*/
-typedef enum cups_icspace_e /**** Image colorspaces ****/
+typedef enum cf_icspace_e /**** Image colorspaces ****/
{
- CUPS_IMAGE_CMYK = -4, /* Cyan, magenta, yellow, and black */
- CUPS_IMAGE_CMY = -3, /* Cyan, magenta, and yellow */
- CUPS_IMAGE_BLACK = -1, /* Black */
- CUPS_IMAGE_WHITE = 1, /* White (luminance) */
- CUPS_IMAGE_RGB = 3, /* Red, green, and blue */
- CUPS_IMAGE_RGB_CMYK = 4 /* Use RGB or CMYK */
-} cups_icspace_t;
+ CF_IMAGE_CMYK = -4, /* Cyan, magenta, yellow, and black */
+ CF_IMAGE_CMY = -3, /* Cyan, magenta, and yellow */
+ CF_IMAGE_BLACK = -1, /* Black */
+ CF_IMAGE_WHITE = 1, /* White (luminance) */
+ CF_IMAGE_RGB = 3, /* Red, green, and blue */
+ CF_IMAGE_RGB_CMYK = 4 /* Use RGB or CMYK */
+} cf_icspace_t;
/*
* Types and structures...
*/
-typedef unsigned char cups_ib_t; /**** Image byte ****/
+typedef unsigned char cf_ib_t; /**** Image byte ****/
-struct cups_image_s;
-typedef struct cups_image_s cups_image_t;
- /**** Image file data ****/
+struct cf_image_s;
+typedef struct cf_image_s cf_image_t; /**** Image file data ****/
-struct cups_izoom_s;
-typedef struct cups_izoom_s cups_izoom_t;
- /**** Image zoom data ****/
+struct cf_izoom_s;
+typedef struct cf_izoom_s cf_izoom_t; /**** Image zoom data ****/
/*
* Prototypes...
*/
-extern void cupsImageClose(cups_image_t *img) _CUPS_API_1_2;
-extern void cupsImageCMYKToBlack(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageCMYKToCMY(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageCMYKToCMYK(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageCMYKToRGB(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageCMYKToWhite(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern int cupsImageGetCol(cups_image_t *img, int x, int y,
- int height, cups_ib_t *pixels) _CUPS_API_1_2;
-extern cups_icspace_t cupsImageGetColorSpace(cups_image_t *img) _CUPS_API_1_2;
-extern int cupsImageGetDepth(cups_image_t *img) _CUPS_API_1_2;
-extern unsigned cupsImageGetHeight(cups_image_t *img) _CUPS_API_1_2;
-extern int cupsImageGetRow(cups_image_t *img, int x, int y,
- int width, cups_ib_t *pixels) _CUPS_API_1_2;
-extern unsigned cupsImageGetWidth(cups_image_t *img) _CUPS_API_1_2;
-extern unsigned cupsImageGetXPPI(cups_image_t *img) _CUPS_API_1_2;
-extern unsigned cupsImageGetYPPI(cups_image_t *img) _CUPS_API_1_2;
-extern void cupsImageLut(cups_ib_t *pixels, int count,
- const cups_ib_t *lut) _CUPS_API_1_2;
-extern cups_image_t *cupsImageOpen(const char *filename,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut) _CUPS_API_1_2;
-extern cups_image_t *cupsImageOpenFP(FILE *fp,
- cups_icspace_t primary,
- cups_icspace_t secondary,
- int saturation, int hue,
- const cups_ib_t *lut) _CUPS_API_1_2;
-extern void cupsImageRGBAdjust(cups_ib_t *pixels, int count,
- int saturation, int hue) _CUPS_API_1_2;
-extern void cupsImageRGBToBlack(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageRGBToCMY(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageRGBToCMYK(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageRGBToRGB(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageRGBToWhite(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageSetMaxTiles(cups_image_t *img, int max_tiles) _CUPS_API_1_2;
-extern void cupsImageSetProfile(float d, float g,
- float matrix[3][3]) _CUPS_API_1_2;
-extern void cupsImageSetRasterColorSpace(cups_cspace_t cs) _CUPS_API_1_2;
-extern void cupsImageWhiteToBlack(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageWhiteToCMY(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageWhiteToCMYK(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageWhiteToRGB(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern void cupsImageWhiteToWhite(const cups_ib_t *in,
- cups_ib_t *out, int count) _CUPS_API_1_2;
-extern cups_image_t* cupsImageCrop(cups_image_t* img,int posw,
- int posh,int width,int height);
+extern void cfImageClose(cf_image_t *img);
+extern void cfImageCMYKToBlack(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageCMYKToCMY(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageCMYKToCMYK(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageCMYKToRGB(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageCMYKToWhite(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern int cfImageGetCol(cf_image_t *img, int x, int y,
+ int height, cf_ib_t *pixels);
+extern cf_icspace_t cfImageGetColorSpace(cf_image_t *img);
+extern int cfImageGetDepth(cf_image_t *img);
+extern unsigned cfImageGetHeight(cf_image_t *img);
+extern int cfImageGetRow(cf_image_t *img, int x, int y,
+ int width, cf_ib_t *pixels);
+extern unsigned cfImageGetWidth(cf_image_t *img);
+extern unsigned cfImageGetXPPI(cf_image_t *img);
+extern unsigned cfImageGetYPPI(cf_image_t *img);
+extern void cfImageLut(cf_ib_t *pixels, int count,
+ const cf_ib_t *lut);
+extern cf_image_t *cfImageOpen(const char *filename,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern cf_image_t *cfImageOpenFP(FILE *fp,
+ cf_icspace_t primary,
+ cf_icspace_t secondary,
+ int saturation, int hue,
+ const cf_ib_t *lut);
+extern void cfImageRGBAdjust(cf_ib_t *pixels, int count,
+ int saturation, int hue);
+extern void cfImageRGBToBlack(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageRGBToCMY(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageRGBToCMYK(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageRGBToRGB(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageRGBToWhite(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageSetMaxTiles(cf_image_t *img, int max_tiles);
+extern void cfImageSetProfile(float d, float g,
+ float matrix[3][3]);
+extern void cfImageSetRasterColorSpace(cups_cspace_t cs);
+extern void cfImageWhiteToBlack(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageWhiteToCMY(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageWhiteToCMYK(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageWhiteToRGB(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern void cfImageWhiteToWhite(const cf_ib_t *in,
+ cf_ib_t *out, int count);
+extern cf_image_t* cfImageCrop(cf_image_t* img,int posw,
+ int posh,int width,int height);
# ifdef __cplusplus
}
#define LINEBUFSIZE 1024
#ifdef CUPS_1_1
-#define cups_ib_t ib_t
-#define cups_image_t image_t
-#define CUPS_IMAGE_CMYK IMAGE_CMYK
-#define CUPS_IMAGE_WHITE IMAGE_WHITE
-#define CUPS_IMAGE_RGB IMAGE_RGB
-#define CUPS_IMAGE_RGB_CMYK IMAGE_RGB_CMYK
-#define cupsImageOpen ImageOpen
-#define cupsImageClose ImageClose
-#define cupsImageGetColorSpace(img) (img->colorspace)
-#define cupsImageGetXPPI(img) (img->xppi)
-#define cupsImageGetYPPI(img) (img->yppi)
-#define cupsImageGetWidth(img) (img->xsize)
-#define cupsImageGetHeight(img) (img->ysize)
-#define cupsImageGetRow ImageGetRow
+#define cf_ib_t ib_t
+#define cf_image_t image_t
+#define CF_IMAGE_CMYK IMAGE_CMYK
+#define CF_IMAGE_WHITE IMAGE_WHITE
+#define CF_IMAGE_RGB IMAGE_RGB
+#define CF_IMAGE_RGB_CMYK IMAGE_RGB_CMYK
+#define cfImageOpen ImageOpen
+#define cfImageClose ImageClose
+#define cfImageGetColorSpace(img) (img->colorspace)
+#define cfImageGetXPPI(img) (img->xppi)
+#define cfImageGetYPPI(img) (img->yppi)
+#define cfImageGetWidth(img) (img->xsize)
+#define cfImageGetHeight(img) (img->ysize)
+#define cfImageGetRow ImageGetRow
#endif
/*
xsize2,
ysize2;
float aspect; /* Aspect ratio */
- cups_image_t *img; /* Image to print */
+ cf_image_t *img; /* Image to print */
int colorspace; /* Output colorspace */
- cups_ib_t *row; /* Current row */
+ cf_ib_t *row; /* Current row */
float gammaval; /* Gamma correction value */
float brightness; /* Gamma correction value */
ppd_file_t *ppd; /* PPD file */
*/
#ifdef OUT_AS_HEX
-static void out_hex(imagetopdf_doc_t *doc, cups_ib_t *, int, int);
+static void out_hex(imagetopdf_doc_t *doc, cf_ib_t *, int, int);
#else
#ifdef OUT_AS_ASCII85
-static void out_ascii85(imagetopdf_doc_t *doc, cups_ib_t *, int, int);
+static void out_ascii85(imagetopdf_doc_t *doc, cf_ib_t *, int, int);
#else
-static void out_bin(imagetopdf_doc_t *doc, cups_ib_t *, int, int);
+static void out_bin(imagetopdf_doc_t *doc, cf_ib_t *, int, int);
#endif
#endif
static void outPdf(imagetopdf_doc_t *doc, const char *str);
break;
}
- doc->xc0 = cupsImageGetWidth(doc->img) * doc->xpage / doc->xpages;
- doc->xc1 = cupsImageGetWidth(doc->img) * (doc->xpage + 1) / doc->xpages - 1;
- doc->yc0 = cupsImageGetHeight(doc->img) * doc->ypage / doc->ypages;
- doc->yc1 = cupsImageGetHeight(doc->img) * (doc->ypage + 1) / doc->ypages - 1;
+ doc->xc0 = cfImageGetWidth(doc->img) * doc->xpage / doc->xpages;
+ doc->xc1 = cfImageGetWidth(doc->img) * (doc->xpage + 1) / doc->xpages - 1;
+ doc->yc0 = cfImageGetHeight(doc->img) * doc->ypage / doc->ypages;
+ doc->yc1 = cfImageGetHeight(doc->img) * (doc->ypage + 1) / doc->ypages - 1;
snprintf(doc->linebuf,LINEBUFSIZE,
"1 0 0 1 %.1f %.1f cm\n",doc->left,doc->top);
switch (doc->colorspace)
{
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
outPdf(doc, "/ColorSpace /DeviceGray ");
outPdf(doc, "/Decode[0 1] ");
break;
- case CUPS_IMAGE_RGB :
+ case CF_IMAGE_RGB :
outPdf(doc, "/ColorSpace /DeviceRGB ");
outPdf(doc, "/Decode[0 1 0 1 0 1] ");
break;
- case CUPS_IMAGE_CMYK :
+ case CF_IMAGE_CMYK :
outPdf(doc, "/ColorSpace /DeviceCMYK ");
outPdf(doc, "/Decode[0 1 0 1 0 1 0 1] ");
break;
/* out ascii85 needs multiple of 4bytes */
for (y = doc->yc0, out_offset = 0; y <= doc->yc1; y ++)
{
- cupsImageGetRow(doc->img, doc->xc0, y, doc->xc1 - doc->xc0 + 1,
+ cfImageGetRow(doc->img, doc->xc0, y, doc->xc1 - doc->xc0 + 1,
doc->row + out_offset);
out_length = (doc->xc1 - doc->xc0 + 1) * abs(doc->colorspace) + out_offset;
#else
for (y = doc->yc0; y <= doc->yc1; y ++)
{
- cupsImageGetRow(doc->img, doc->xc0, y, doc->xc1 - doc->xc0 + 1, doc->row);
+ cfImageGetRow(doc->img, doc->xc0, y, doc->xc1 - doc->xc0 + 1, doc->row);
out_length = (doc->xc1 - doc->xc0 + 1) * abs(doc->colorspace);
* Open the input image to print...
*/
- doc.colorspace = doc.Color ? CUPS_IMAGE_RGB_CMYK : CUPS_IMAGE_WHITE;
+ doc.colorspace = doc.Color ? CF_IMAGE_RGB_CMYK : CF_IMAGE_WHITE;
- doc.img = cupsImageOpenFP(fp, doc.colorspace, CUPS_IMAGE_WHITE, sat, hue,
+ doc.img = cfImageOpenFP(fp, doc.colorspace, CF_IMAGE_WHITE, sat, hue,
NULL);
if (doc.img != NULL) {
}
}
- float w = (float)cupsImageGetWidth(doc.img);
- float h = (float)cupsImageGetHeight(doc.img);
+ float w = (float)cfImageGetWidth(doc.img);
+ float h = (float)cfImageGetHeight(doc.img);
float pw = doc.PageRight-doc.PageLeft;
float ph = doc.PageTop-doc.PageBottom;
int tempOrientation = doc.Orientation;
doc.PageLeft = 0.0;
doc.PageRight = doc.PageWidth;
}
- float w = (float)cupsImageGetWidth(doc.img);
- float h = (float)cupsImageGetHeight(doc.img);
+ float w = (float)cfImageGetWidth(doc.img);
+ float h = (float)cfImageGetHeight(doc.img);
float pw = doc.PageRight-doc.PageLeft;
float ph = doc.PageTop-doc.PageBottom;
int tempOrientation = doc.Orientation;
float posw=(w-final_w)/2,posh=(h-final_h)/2;
posw = (1+doc.XPosition)*posw;
posh = (1-doc.YPosition)*posh;
- cups_image_t *img2 = cupsImageCrop(doc.img,posw,posh,final_w,final_h);
- cupsImageClose(doc.img);
+ cf_image_t *img2 = cfImageCrop(doc.img,posw,posh,final_w,final_h);
+ cfImageClose(doc.img);
doc.img = img2;
}
else {
float posw=(w-final_w)/2,posh=(h-final_h)/2;
posw = (1+doc.XPosition)*posw;
posh = (1-doc.YPosition)*posh;
- cups_image_t *img2 = cupsImageCrop(doc.img,posw,posh,final_w,final_h);
- cupsImageClose(doc.img);
+ cf_image_t *img2 = cfImageCrop(doc.img,posw,posh,final_w,final_h);
+ cfImageClose(doc.img);
doc.img = img2;
if(flag==4)
{
return (1);
}
- doc.colorspace = cupsImageGetColorSpace(doc.img);
+ doc.colorspace = cfImageGetColorSpace(doc.img);
/*
* Scale as necessary...
if (zoom == 0.0 && xppi == 0)
{
- xppi = cupsImageGetXPPI(doc.img);
- yppi = cupsImageGetYPPI(doc.img);
+ xppi = cfImageGetXPPI(doc.img);
+ yppi = cfImageGetYPPI(doc.img);
}
if (yppi == 0)
"cfFilterImageToPDF: Before scaling: xprint=%.1f, yprint=%.1f",
doc.xprint, doc.yprint);
- doc.xinches = (float)cupsImageGetWidth(doc.img) / (float)xppi;
- doc.yinches = (float)cupsImageGetHeight(doc.img) / (float)yppi;
+ doc.xinches = (float)cfImageGetWidth(doc.img) / (float)xppi;
+ doc.yinches = (float)cfImageGetHeight(doc.img) / (float)yppi;
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
"cfFilterImageToPDF: Image size is %.1f x %.1f inches...",
doc.xprint = (doc.PageRight - doc.PageLeft) / 72.0;
doc.yprint = (doc.PageTop - doc.PageBottom) / 72.0;
- doc.aspect = (float)cupsImageGetYPPI(doc.img) /
- (float)cupsImageGetXPPI(doc.img);
+ doc.aspect = (float)cfImageGetYPPI(doc.img) /
+ (float)cfImageGetXPPI(doc.img);
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
"cfFilterImageToPDF: Before scaling: xprint=%.1f, yprint=%.1f",
doc.xprint, doc.yprint);
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
- "cfFilterImageToPDF: cupsImageGetXPPI(img) = %d, "
- "cupsImageGetYPPI(img) = %d, aspect = %f",
- cupsImageGetXPPI(doc.img), cupsImageGetYPPI(doc.img),
+ "cfFilterImageToPDF: cfImageGetXPPI(img) = %d, "
+ "cfImageGetYPPI(img) = %d, aspect = %f",
+ cfImageGetXPPI(doc.img), cfImageGetYPPI(doc.img),
doc.aspect);
doc.xsize = doc.xprint * zoom;
- doc.ysize = doc.xsize * cupsImageGetHeight(doc.img) /
- cupsImageGetWidth(doc.img) / doc.aspect;
+ doc.ysize = doc.xsize * cfImageGetHeight(doc.img) /
+ cfImageGetWidth(doc.img) / doc.aspect;
if (doc.ysize > (doc.yprint * zoom))
{
doc.ysize = doc.yprint * zoom;
- doc.xsize = doc.ysize * cupsImageGetWidth(doc.img) *
- doc.aspect / cupsImageGetHeight(doc.img);
+ doc.xsize = doc.ysize * cfImageGetWidth(doc.img) *
+ doc.aspect / cfImageGetHeight(doc.img);
}
doc.xsize2 = doc.yprint * zoom;
- doc.ysize2 = doc.xsize2 * cupsImageGetHeight(doc.img) /
- cupsImageGetWidth(doc.img) / doc.aspect;
+ doc.ysize2 = doc.xsize2 * cfImageGetHeight(doc.img) /
+ cfImageGetWidth(doc.img) / doc.aspect;
if (doc.ysize2 > (doc.xprint * zoom))
{
doc.ysize2 = doc.xprint * zoom;
- doc.xsize2 = doc.ysize2 * cupsImageGetWidth(doc.img) *
- doc.aspect / cupsImageGetHeight(doc.img);
+ doc.xsize2 = doc.ysize2 * cfImageGetWidth(doc.img) *
+ doc.aspect / cfImageGetHeight(doc.img);
}
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
* Output the pages...
*/
- doc.row = malloc(cupsImageGetWidth(doc.img) * abs(doc.colorspace) + 3);
+ doc.row = malloc(cfImageGetWidth(doc.img) * abs(doc.colorspace) + 3);
if (log) {
log(ld, FILTER_LOGLEVEL_DEBUG,
}
#endif
- cupsImageClose(doc.img);
+ cfImageClose(doc.img);
fclose(doc.outputfp);
close(outputfd);
return (0);
if (log) log(ld, FILTER_LOGLEVEL_ERROR,
"cfFilterImageToPDF: Cannot allocate any more memory.");
freeAllObj(&doc);
- cupsImageClose(doc.img);
+ cfImageClose(doc.img);
fclose(doc.outputfp);
close(outputfd);
return (2);
static void
out_hex(imagetopdf_doc_t *doc,
- cups_ib_t *data, /* I - Data to print */
+ cf_ib_t *data, /* I - Data to print */
int length, /* I - Number of bytes to print */
int last_line) /* I - Last line of raster data? */
{
static void
out_ascii85(imagetopdf_doc_t *doc,
- cups_ib_t *data, /* I - Data to print */
+ cf_ib_t *data, /* I - Data to print */
int length, /* I - Number of bytes to print */
int last_line) /* I - Last line of raster data? */
{
static void
out_bin(imagetopdf_doc_t *doc,
- cups_ib_t *data, /* I - Data to print */
+ cf_ib_t *data, /* I - Data to print */
int length, /* I - Number of bytes to print */
int last_line) /* I - Last line of raster data? */
{
static void WriteLabels(imagetops_doc_t *doc, int orient);
static void WriteTextComment(imagetops_doc_t *doc,
const char *name, const char *value);
-static void ps_hex(FILE *outputfp, cups_ib_t *, int, int);
-static void ps_ascii85(FILE *outputfp, cups_ib_t *, int, int);
+static void ps_hex(FILE *outputfp, cf_ib_t *, int, int);
+static void ps_ascii85(FILE *outputfp, cf_ib_t *, int, int);
/*
void *parameters) /* I - Filter-specific parameters (unused) */
{
imagetops_doc_t doc; /* Document information */
- cups_image_t *img; /* Image to print */
+ cf_image_t *img; /* Image to print */
float xprint, /* Printable area */
yprint,
xinches, /* Total size in inches */
page; /* Current page number */
int xc0, yc0, /* Corners of the page in image coords */
xc1, yc1;
- cups_ib_t *row; /* Current row */
+ cf_ib_t *row; /* Current row */
int y; /* Current Y coordinate in image */
int colorspace; /* Output colorspace */
int out_offset, /* Offset into output buffer */
* Open the input image to print...
*/
- colorspace = doc.Color ? CUPS_IMAGE_RGB_CMYK : CUPS_IMAGE_WHITE;
+ colorspace = doc.Color ? CF_IMAGE_RGB_CMYK : CF_IMAGE_WHITE;
- img = cupsImageOpenFP(inputfp, colorspace, CUPS_IMAGE_WHITE, sat, hue, NULL);
+ img = cfImageOpenFP(inputfp, colorspace, CF_IMAGE_WHITE, sat, hue, NULL);
if (img != NULL) {
int margin_defined = 0;
}
}
- float w = (float)cupsImageGetWidth(img);
- float h = (float)cupsImageGetHeight(img);
+ float w = (float)cfImageGetWidth(img);
+ float h = (float)cfImageGetHeight(img);
float pw = doc.PageRight - doc.PageLeft;
float ph = doc.PageTop - doc.PageBottom;
int tempOrientation = doc.Orientation;
float posw = (w - final_w) / 2, posh = (h - final_h) / 2;
posw = (1 + XPosition) * posw;
posh = (1 - YPosition) * posh;
- cups_image_t *img2 = cupsImageCrop(img, posw, posh, final_w, final_h);
- cupsImageClose(img);
+ cf_image_t *img2 = cfImageCrop(img, posw, posh, final_w, final_h);
+ cfImageClose(img);
img = img2;
}
else
float posw = (w - final_w) / 2, posh = (h - final_h) / 2;
posw = (1 + XPosition) * posw;
posh = (1 - YPosition) * posh;
- cups_image_t *img2 = cupsImageCrop(img, posw, posh, final_w, final_h);
- cupsImageClose(img);
+ cf_image_t *img2 = cfImageCrop(img, posw, posh, final_w, final_h);
+ cfImageClose(img);
img = img2;
if (flag == 4)
{
return (1);
}
- colorspace = cupsImageGetColorSpace(img);
+ colorspace = cfImageGetColorSpace(img);
/*
* Scale as necessary...
if (zoom == 0.0 && xppi == 0)
{
- xppi = cupsImageGetXPPI(img);
- yppi = cupsImageGetYPPI(img);
+ xppi = cfImageGetXPPI(img);
+ yppi = cfImageGetYPPI(img);
}
if (yppi == 0)
"cfFilterImageToPS: Before scaling: xprint=%.1f, yprint=%.1f",
xprint, yprint);
- xinches = (float)cupsImageGetWidth(img) / (float)xppi;
- yinches = (float)cupsImageGetHeight(img) / (float)yppi;
+ xinches = (float)cfImageGetWidth(img) / (float)xppi;
+ yinches = (float)cfImageGetHeight(img) / (float)yppi;
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
"cfFilterImageToPS: Image size is %.1f x %.1f inches...",
xprint = (doc.PageRight - doc.PageLeft) / 72.0;
yprint = (doc.PageTop - doc.PageBottom) / 72.0;
- aspect = (float)cupsImageGetYPPI(img) / (float)cupsImageGetXPPI(img);
+ aspect = (float)cfImageGetYPPI(img) / (float)cfImageGetXPPI(img);
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
"cfFilterImageToPS: Before scaling: xprint=%.1f, yprint=%.1f",
xprint, yprint);
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
- "cfFilterImageToPS: cupsImageGetXPPI(img) = %d, "
- "cupsImageGetYPPI(img) = %d, aspect = %f",
- cupsImageGetXPPI(img), cupsImageGetYPPI(img), aspect);
+ "cfFilterImageToPS: cfImageGetXPPI(img) = %d, "
+ "cfImageGetYPPI(img) = %d, aspect = %f",
+ cfImageGetXPPI(img), cfImageGetYPPI(img), aspect);
xsize = xprint * zoom;
- ysize = xsize * cupsImageGetHeight(img) / cupsImageGetWidth(img) / aspect;
+ ysize = xsize * cfImageGetHeight(img) / cfImageGetWidth(img) / aspect;
if (ysize > (yprint * zoom))
{
ysize = yprint * zoom;
- xsize = ysize * cupsImageGetWidth(img) * aspect /
- cupsImageGetHeight(img);
+ xsize = ysize * cfImageGetWidth(img) * aspect /
+ cfImageGetHeight(img);
}
xsize2 = yprint * zoom;
- ysize2 = xsize2 * cupsImageGetHeight(img) / cupsImageGetWidth(img) /
+ ysize2 = xsize2 * cfImageGetHeight(img) / cfImageGetWidth(img) /
aspect;
if (ysize2 > (xprint * zoom))
{
ysize2 = xprint * zoom;
- xsize2 = ysize2 * cupsImageGetWidth(img) * aspect /
- cupsImageGetHeight(img);
+ xsize2 = ysize2 * cfImageGetWidth(img) * aspect /
+ cfImageGetHeight(img);
}
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
* Output the pages...
*/
- row = malloc(cupsImageGetWidth(img) * abs(colorspace) + 3);
+ row = malloc(cfImageGetWidth(img) * abs(colorspace) + 3);
if (row == NULL)
{
log(ld, FILTER_LOGLEVEL_ERROR,
"cfFilterImageToPS: Could not allocate memory.");
- cupsImageClose(img);
+ cfImageClose(img);
return (2);
}
fputs("gsave\n", doc.outputfp);
- xc0 = cupsImageGetWidth(img) * xpage / xpages;
- xc1 = cupsImageGetWidth(img) * (xpage + 1) / xpages - 1;
- yc0 = cupsImageGetHeight(img) * ypage / ypages;
- yc1 = cupsImageGetHeight(img) * (ypage + 1) / ypages - 1;
+ xc0 = cfImageGetWidth(img) * xpage / xpages;
+ xc1 = cfImageGetWidth(img) * (xpage + 1) / xpages - 1;
+ yc0 = cfImageGetHeight(img) * ypage / ypages;
+ yc1 = cfImageGetHeight(img) * (ypage + 1) / ypages - 1;
fprintf(doc.outputfp, "%.1f %.1f translate\n", left, top);
fprintf(doc.outputfp, "%d %d 8[1 0 0 -1 0 1]",
(xc1 - xc0 + 1), (yc1 - yc0 + 1));
- if (colorspace == CUPS_IMAGE_WHITE)
+ if (colorspace == CF_IMAGE_WHITE)
fputs("{currentfile picture readhexstring pop} image\n",
doc.outputfp);
else
for (y = yc0; y <= yc1; y ++)
{
- cupsImageGetRow(img, xc0, y, xc1 - xc0 + 1, row);
+ cfImageGetRow(img, xc0, y, xc1 - xc0 + 1, row);
ps_hex(doc.outputfp, row, (xc1 - xc0 + 1) * abs(colorspace),
y == yc1);
}
{
switch (colorspace)
{
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
fputs("/DeviceGray setcolorspace\n", doc.outputfp);
break;
- case CUPS_IMAGE_RGB :
+ case CF_IMAGE_RGB :
fputs("/DeviceRGB setcolorspace\n", doc.outputfp);
break;
- case CUPS_IMAGE_CMYK :
+ case CF_IMAGE_CMYK :
fputs("/DeviceCMYK setcolorspace\n", doc.outputfp);
break;
}
switch (colorspace)
{
- case CUPS_IMAGE_WHITE :
+ case CF_IMAGE_WHITE :
fputs("/Decode[0 1]", doc.outputfp);
break;
- case CUPS_IMAGE_RGB :
+ case CF_IMAGE_RGB :
fputs("/Decode[0 1 0 1 0 1]", doc.outputfp);
break;
- case CUPS_IMAGE_CMYK :
+ case CF_IMAGE_CMYK :
fputs("/Decode[0 1 0 1 0 1 0 1]", doc.outputfp);
break;
}
for (y = yc0, out_offset = 0; y <= yc1; y ++)
{
- cupsImageGetRow(img, xc0, y, xc1 - xc0 + 1, row + out_offset);
+ cfImageGetRow(img, xc0, y, xc1 - xc0 + 1, row + out_offset);
out_length = (xc1 - xc0 + 1) * abs(colorspace) + out_offset;
out_offset = out_length & 3;
* Close files...
*/
- cupsImageClose(img);
+ cfImageClose(img);
fclose(doc.outputfp);
close(outputfd);
static void
ps_hex(FILE *outputfp,
- cups_ib_t *data, /* I - Data to print */
+ cf_ib_t *data, /* I - Data to print */
int length, /* I - Number of bytes to print */
int last_line) /* I - Last line of raster data? */
{
static void
ps_ascii85(FILE *outputfp,
- cups_ib_t *data, /* I - Data to print */
+ cf_ib_t *data, /* I - Data to print */
int length, /* I - Number of bytes to print */
int last_line) /* I - Last line of raster data? */
{
PageTop, /* Top margin */
PageWidth, /* Total page width */
PageLength; /* Total page length */
- cups_ib_t OnPixels[256], /* On-pixel LUT */
+ cf_ib_t OnPixels[256], /* On-pixel LUT */
OffPixels[256]; /* Off-pixel LUT */
filter_logfunc_t logfunc; /* Logging function, NULL for no
logging */
static void format_CMY(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_CMYK(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_K(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_KCMYcm(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_KCMY(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
#define format_RGB format_CMY
static void format_RGBA(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_W(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_YMC(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
static void format_YMCK(imagetoraster_doc_t *doc,
cups_page_header2_t *header, unsigned char *row,
int y, int z, int xsize, int ysize, int yerr0,
- int yerr1, cups_ib_t *r0, cups_ib_t *r1);
-static void make_lut(cups_ib_t *, int, float, float);
+ int yerr1, cf_ib_t *r0, cf_ib_t *r1);
+static void make_lut(cf_ib_t *, int, float, float);
/*
{
imagetoraster_doc_t doc; /* Document information */
int i; /* Looping var */
- cups_image_t *img; /* Image to print */
+ cf_image_t *img; /* Image to print */
float xprint, /* Printable area */
yprint,
xinches, /* Total size in inches */
float zoom; /* Zoom facter */
int xppi, yppi; /* Pixels-per-inch */
int hue, sat; /* Hue and saturation adjustment */
- cups_izoom_t *z; /* Image zoom buffer */
- cups_iztype_t zoom_type; /* Image zoom type */
+ cf_izoom_t *z; /* Image zoom buffer */
+ cf_iztype_t zoom_type; /* Image zoom type */
int primary, /* Primary image colorspace */
secondary; /* Secondary image colorspace */
- cups_ib_t *row, /* Current row */
+ cf_ib_t *row, /* Current row */
*r0, /* Top row */
*r1; /* Bottom row */
int y, /* Current Y coordinate on page */
last_iy, /* Previous Y coordinate in image */
yerr0, /* Top Y error value */
yerr1; /* Bottom Y error value */
- cups_ib_t lut[256]; /* Gamma/brightness LUT */
+ cf_ib_t lut[256]; /* Gamma/brightness LUT */
int plane, /* Current color plane */
num_planes; /* Number of color planes */
char tempfile[1024]; /* Name of temporary file */
case CUPS_CSPACE_SW :
if (header.cupsBitsPerColor >= 8)
{
- primary = CUPS_IMAGE_WHITE;
- secondary = CUPS_IMAGE_WHITE;
+ primary = CF_IMAGE_WHITE;
+ secondary = CF_IMAGE_WHITE;
}
else
{
- primary = CUPS_IMAGE_BLACK;
- secondary = CUPS_IMAGE_BLACK;
+ primary = CF_IMAGE_BLACK;
+ secondary = CF_IMAGE_BLACK;
}
break;
case CUPS_CSPACE_ADOBERGB :
if (header.cupsBitsPerColor >= 8)
{
- primary = CUPS_IMAGE_RGB;
- secondary = CUPS_IMAGE_RGB;
+ primary = CF_IMAGE_RGB;
+ secondary = CF_IMAGE_RGB;
}
else
{
- primary = CUPS_IMAGE_CMY;
- secondary = CUPS_IMAGE_CMY;
+ primary = CF_IMAGE_CMY;
+ secondary = CF_IMAGE_CMY;
}
break;
case CUPS_CSPACE_WHITE :
case CUPS_CSPACE_GOLD :
case CUPS_CSPACE_SILVER :
- primary = CUPS_IMAGE_BLACK;
- secondary = CUPS_IMAGE_BLACK;
+ primary = CF_IMAGE_BLACK;
+ secondary = CF_IMAGE_BLACK;
break;
case CUPS_CSPACE_CMYK :
case CUPS_CSPACE_GMCS :
if (header.cupsBitsPerColor == 1)
{
- primary = CUPS_IMAGE_CMY;
- secondary = CUPS_IMAGE_CMY;
+ primary = CF_IMAGE_CMY;
+ secondary = CF_IMAGE_CMY;
}
else
{
- primary = CUPS_IMAGE_CMYK;
- secondary = CUPS_IMAGE_CMYK;
+ primary = CF_IMAGE_CMYK;
+ secondary = CF_IMAGE_CMYK;
}
break;
case CUPS_CSPACE_CMY :
case CUPS_CSPACE_YMC :
- primary = CUPS_IMAGE_CMY;
- secondary = CUPS_IMAGE_CMY;
+ primary = CF_IMAGE_CMY;
+ secondary = CF_IMAGE_CMY;
break;
case CUPS_CSPACE_CIEXYZ :
profile = NULL;
if (profile)
- cupsImageSetProfile(profile->density, profile->gamma, profile->matrix);
+ cfImageSetProfile(profile->density, profile->gamma, profile->matrix);
- cupsImageSetRasterColorSpace(header.cupsColorSpace);
+ cfImageSetRasterColorSpace(header.cupsColorSpace);
/*
* Create a gamma/brightness LUT...
if (header.cupsColorSpace == CUPS_CSPACE_CIEXYZ ||
header.cupsColorSpace == CUPS_CSPACE_CIELab ||
header.cupsColorSpace >= CUPS_CSPACE_ICC1)
- img = cupsImageOpenFP(fp, primary, secondary, sat, hue, NULL);
+ img = cfImageOpenFP(fp, primary, secondary, sat, hue, NULL);
else
- img = cupsImageOpenFP(fp, primary, secondary, sat, hue, lut);
+ img = cfImageOpenFP(fp, primary, secondary, sat, hue, lut);
if(img!=NULL){
}
}
- float w = (float)cupsImageGetWidth(img);
- float h = (float)cupsImageGetHeight(img);
+ float w = (float)cfImageGetWidth(img);
+ float h = (float)cfImageGetHeight(img);
float pw = doc.PageRight-doc.PageLeft;
float ph = doc.PageTop-doc.PageBottom;
int tempOrientation = doc.Orientation;
{
if(fillprint||cropfit)
{
- float w = (float)cupsImageGetWidth(img);
- float h = (float)cupsImageGetHeight(img);
+ float w = (float)cfImageGetWidth(img);
+ float h = (float)cfImageGetHeight(img);
/* For cropfit do the math without the unprintable margins to get correct
centering, for fillprint, fill the printable area */
float pw = (cropfit ? doc.PageWidth : doc.PageRight-doc.PageLeft);
float posw=(w-final_w)/2,posh=(h-final_h)/2;
posw = (1+doc.XPosition)*posw;
posh = (1-doc.YPosition)*posh;
- cups_image_t *img2 = cupsImageCrop(img,posw,posh,final_w,final_h);
- cupsImageClose(img);
+ cf_image_t *img2 = cfImageCrop(img,posw,posh,final_w,final_h);
+ cfImageClose(img);
img = img2;
}
else {
}
if(doc.PageBottom<0) doc.PageBottom = 0;
if(doc.PageLeft<0) doc.PageLeft = 0;
- cups_image_t *img2 = cupsImageCrop(img,posw,posh,final_w,final_h);
- cupsImageClose(img);
+ cf_image_t *img2 = cfImageCrop(img,posw,posh,final_w,final_h);
+ cfImageClose(img);
img = img2;
}
}
num_planes = 1;
if (header.cupsBitsPerColor >= 8)
- zoom_type = CUPS_IZOOM_NORMAL;
+ zoom_type = CF_IZOOM_NORMAL;
else
- zoom_type = CUPS_IZOOM_FAST;
+ zoom_type = CF_IZOOM_FAST;
/*
* See if we need to collate, and if so how we need to do it...
*/
if (doc.Flip)
- z = _cupsImageZoomNew(img, xc0, yc0, xc1, yc1, -xtemp, ytemp,
+ z = _cfImageZoomNew(img, xc0, yc0, xc1, yc1, -xtemp, ytemp,
doc.Orientation & 1, zoom_type);
else
- z = _cupsImageZoomNew(img, xc0, yc0, xc1, yc1, xtemp, ytemp,
+ z = _cfImageZoomNew(img, xc0, yc0, xc1, yc1, xtemp, ytemp,
doc.Orientation & 1, zoom_type);
/*
{
if (log) log(ld, FILTER_LOGLEVEL_ERROR,
"cfFilterImageToRaster: Unable to send raster data.");
- cupsImageClose(img);
+ cfImageClose(img);
return (1);
}
}
{
if (iy != last_iy)
{
- if (zoom_type != CUPS_IZOOM_FAST && (iy - last_iy) > 1)
- _cupsImageZoomFill(z, iy);
+ if (zoom_type != CF_IZOOM_FAST && (iy - last_iy) > 1)
+ _cfImageZoomFill(z, iy);
- _cupsImageZoomFill(z, iy + z->yincr);
+ _cfImageZoomFill(z, iy + z->yincr);
last_iy = iy;
}
{
if (log) log(ld, FILTER_LOGLEVEL_DEBUG,
"cfFilterImageToRaster: Unable to send raster data.");
- cupsImageClose(img);
+ cfImageClose(img);
return (1);
}
{
if (log) log(ld, FILTER_LOGLEVEL_ERROR,
"cfFilterImageToRaster: Unable to send raster data.");
- cupsImageClose(img);
+ cfImageClose(img);
return (1);
}
}
/*
* Free memory used for the "zoom" engine...
*/
- _cupsImageZoomDelete(z);
+ _cfImageZoomDelete(z);
}
}
/*
free(media_type);
free(row);
cupsRasterClose(ras);
- cupsImageClose(img);
+ cfImageClose(img);
close(outputfd);
return (0);
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
bitmask; /* Current mask for pixel */
int bitoffset; /* Current offset in line */
int x, /* Current X coordinate on page */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
int pc, pm, py, pk; /* Cyan, magenta, yellow, and
black values */
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
bitmask; /* Current mask for pixel */
int bitoffset; /* Current offset in line */
int x, /* Current X coordinate on page */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cf_ib_t *r0, /* I - Primary image data */
+ cf_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
+ cf_ib_t *ptr, /* Pointer into row */
*cptr, /* Pointer into cyan */
*mptr, /* Pointer into magenta */
*yptr, /* Pointer into yellow */
*/
static void
-make_lut(cups_ib_t *lut, /* I - Lookup table */
+make_lut(cf_ib_t *lut, /* I - Lookup table */
int colorspace, /* I - Colorspace */
float g, /* I - Image gamma */
float b) /* I - Image brightness */
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
return dst;
}
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageRGBToCMY(src,dst,pixels);
+ cfImageRGBToCMY(src,dst,pixels);
return dst;
}
pclmtoraster_data_t *data)
{
if (data->header.cupsBitsPerColor != 1) {
- cupsImageRGBToWhite(src,dst,pixels);
+ cfImageRGBToWhite(src,dst,pixels);
} else {
- cupsImageRGBToWhite(src,src,pixels);
+ cfImageRGBToWhite(src,src,pixels);
cfOneBitLine(src, dst, data->header.cupsWidth, row, data->bi_level);
}
pclmtoraster_data_t *data)
{
if (data->header.cupsBitsPerColor != 1) {
- cupsImageRGBToBlack(src,dst,pixels);
+ cfImageRGBToBlack(src,dst,pixels);
} else {
- cupsImageRGBToBlack(src,src,pixels);
+ cfImageRGBToBlack(src,src,pixels);
cfOneBitLine(src, dst, data->header.cupsWidth, row, data->bi_level);
}
return dst;
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageCMYKToRGB(src,dst,pixels);
+ cfImageCMYKToRGB(src,dst,pixels);
return dst;
}
pclmtoraster_data_t *data)
{
// Converted first to rgb and then to cmy for better outputs.
- cupsImageCMYKToRGB(src,src,pixels);
- cupsImageRGBToCMY(src,dst,pixels);
+ cfImageCMYKToRGB(src,src,pixels);
+ cfImageRGBToCMY(src,dst,pixels);
return dst;
}
pclmtoraster_data_t *data)
{
if (data->header.cupsBitsPerColor != 1) {
- cupsImageCMYKToWhite(src,dst,pixels);
+ cfImageCMYKToWhite(src,dst,pixels);
} else {
- cupsImageCMYKToWhite(src,src,pixels);
+ cfImageCMYKToWhite(src,src,pixels);
cfOneBitLine(src, dst, data->header.cupsWidth, row, data->bi_level);
}
return dst;
pclmtoraster_data_t *data)
{
if (data->header.cupsBitsPerColor != 1) {
- cupsImageCMYKToBlack(src,dst,pixels);
+ cfImageCMYKToBlack(src,dst,pixels);
} else {
- cupsImageCMYKToBlack(src,src,pixels);
+ cfImageCMYKToBlack(src,src,pixels);
cfOneBitLine(src, dst, data->header.cupsWidth, row, data->bi_level);
}
return dst;
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageWhiteToRGB(src,dst,pixels);
+ cfImageWhiteToRGB(src,dst,pixels);
return dst;
}
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageWhiteToCMYK(src,dst,pixels);
+ cfImageWhiteToCMYK(src,dst,pixels);
return dst;
}
unsigned int pixels,
pclmtoraster_data_t *data)
{
- cupsImageWhiteToCMY(src,dst,pixels);
+ cfImageWhiteToCMY(src,dst,pixels);
return dst;
}
pclmtoraster_data_t *data)
{
if (data->header.cupsBitsPerColor != 1) {
- cupsImageWhiteToBlack(src, dst, pixels);
+ cfImageWhiteToBlack(src, dst, pixels);
} else {
- cupsImageWhiteToBlack(src, src, pixels);
+ cfImageWhiteToBlack(src, src, pixels);
cfOneBitLine(src, dst, data->header.cupsWidth, row, data->bi_level);
}
return dst;
unsigned int row, unsigned int plane, unsigned int pixels,
unsigned int size, pdftoraster_doc_t* doc, ConvertCSpaceFunc convertCSpace)
{
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
return dst;
}
unsigned char *dp = dst;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 4) {
- cupsImageRGBToCMYK(bp,dp,1);
+ cfImageRGBToCMYK(bp,dp,1);
}
return dst;
}
unsigned int row, unsigned int plane, unsigned int pixels,
unsigned int size, pdftoraster_doc_t* doc, ConvertCSpaceFunc convertCSpace)
{
- cupsImageRGBToCMY(src,dst,pixels);
+ cfImageRGBToCMY(src,dst,pixels);
return dst;
}
unsigned char *dp = dst;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 3) {
- cupsImageRGBToCMY(bp,dp,1);
+ cfImageRGBToCMY(bp,dp,1);
}
return dst;
}
unsigned char *dp = dst;
unsigned char d;
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
/* CMYK to KCMY */
for (unsigned int i = 0;i < pixels;i++, bp += 3, dp += 4) {
d = dp[3];
unsigned char d;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 4) {
- cupsImageRGBToCMYK(bp,dp,1);
+ cfImageRGBToCMYK(bp,dp,1);
/* CMYK to KCMY */
d = dp[3];
dp[3] = dp[2];
unsigned char cmyk[4];
unsigned char *dp = pixelBuf;
- cupsImageRGBToCMYK(src,cmyk,1);
+ cfImageRGBToCMYK(src,cmyk,1);
for (int i = 0;i < 4;i++) {
*dp++ = ~cmyk[i];
}
static unsigned char *RGB8toCMYK(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pdftoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
return pixelBuf;
}
static unsigned char *RGB8toCMY(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pdftoraster_doc_t* doc)
{
- cupsImageRGBToCMY(src,pixelBuf,1);
+ cfImageRGBToCMY(src,pixelBuf,1);
return pixelBuf;
}
static unsigned char *RGB8toYMC(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pdftoraster_doc_t* doc)
{
- cupsImageRGBToCMY(src,pixelBuf,1);
+ cfImageRGBToCMY(src,pixelBuf,1);
/* swap C and Y */
unsigned char d = pixelBuf[0];
pixelBuf[0] = pixelBuf[2];
static unsigned char *RGB8toKCMY(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pdftoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
unsigned char d = pixelBuf[3];
pixelBuf[3] = pixelBuf[2];
pixelBuf[2] = pixelBuf[1];
static unsigned char *RGB8toYMCK(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pdftoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
/* swap C and Y */
unsigned char d = pixelBuf[0];
pixelBuf[0] = pixelBuf[2];
newdata = (unsigned char *)malloc(sizeof(char)*3*im.width()*im.height());
newdata = removeAlpha((unsigned char *)im.const_data(),newdata,im.width(),im.height());
graydata=(unsigned char *)malloc(sizeof(char)*im.width()*im.height());
- cupsImageRGBToWhite(newdata,graydata,im.width()*im.height());
+ cfImageRGBToWhite(newdata,graydata,im.width()*im.height());
onebitdata=(unsigned char *)malloc(sizeof(char)*(doc->bytesPerLine)*im.height());
onebitpixel(graydata,onebitdata,im.width(),im.height(), doc);
colordata=onebitdata;
newdata = removeAlpha((unsigned char *)im.const_data(),newdata,im.width(),im.height());
pixel_count=im.width()*im.height();
graydata=(unsigned char *)malloc(sizeof(char)*im.width()*im.height());
- cupsImageRGBToWhite(newdata,graydata,pixel_count);
+ cfImageRGBToWhite(newdata,graydata,pixel_count);
colordata=graydata;
rowsize=doc->header.cupsWidth;
}
unsigned int row, unsigned int plane, unsigned int pixels,
unsigned int size, pwgtoraster_doc_t* doc, ConvertCSpaceFunc convertCSpace)
{
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
return dst;
}
unsigned char *dp = dst;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 4) {
- cupsImageRGBToCMYK(bp,dp,1);
+ cfImageRGBToCMYK(bp,dp,1);
}
return dst;
}
unsigned int row, unsigned int plane, unsigned int pixels,
unsigned int size, pwgtoraster_doc_t* doc, ConvertCSpaceFunc convertCSpace)
{
- cupsImageRGBToCMY(src,dst,pixels);
+ cfImageRGBToCMY(src,dst,pixels);
return dst;
}
unsigned char *dp = dst;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 3) {
- cupsImageRGBToCMY(bp,dp,1);
+ cfImageRGBToCMY(bp,dp,1);
}
return dst;
}
unsigned char *dp = dst;
unsigned char d;
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
/* CMYK to KCMY */
for (unsigned int i = 0;i < pixels;i++, bp += 3, dp += 4) {
d = dp[3];
unsigned char d;
for (unsigned int i = 0;i < pixels;i++, bp -= 3, dp += 4) {
- cupsImageRGBToCMYK(bp,dp,1);
+ cfImageRGBToCMYK(bp,dp,1);
/* CMYK to KCMY */
d = dp[3];
dp[3] = dp[2];
unsigned char cmyk[4];
unsigned char *dp = pixelBuf;
- cupsImageRGBToCMYK(src,cmyk,1);
+ cfImageRGBToCMYK(src,cmyk,1);
for (int i = 0;i < 4;i++) {
*dp++ = ~cmyk[i];
}
static unsigned char *RGB8toCMYK(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pwgtoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
return pixelBuf;
}
static unsigned char *RGB8toCMY(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pwgtoraster_doc_t* doc)
{
- cupsImageRGBToCMY(src,pixelBuf,1);
+ cfImageRGBToCMY(src,pixelBuf,1);
return pixelBuf;
}
static unsigned char *RGB8toYMC(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pwgtoraster_doc_t* doc)
{
- cupsImageRGBToCMY(src,pixelBuf,1);
+ cfImageRGBToCMY(src,pixelBuf,1);
/* swap C and Y */
unsigned char d = pixelBuf[0];
pixelBuf[0] = pixelBuf[2];
static unsigned char *RGB8toKCMY(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pwgtoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
unsigned char d = pixelBuf[3];
pixelBuf[3] = pixelBuf[2];
pixelBuf[2] = pixelBuf[1];
static unsigned char *RGB8toYMCK(unsigned char *src, unsigned char *pixelBuf,
unsigned int x, unsigned int y, pwgtoraster_doc_t* doc)
{
- cupsImageRGBToCMYK(src,pixelBuf,1);
+ cfImageRGBToCMYK(src,pixelBuf,1);
/* swap C and Y */
unsigned char d = pixelBuf[0];
pixelBuf[0] = pixelBuf[2];
{
preBuf1 = (unsigned char *)calloc(doc->outheader.cupsWidth,
sizeof(unsigned char));
- cupsImageRGBToWhite(bp, preBuf1, doc->outheader.cupsWidth);
+ cfImageRGBToWhite(bp, preBuf1, doc->outheader.cupsWidth);
bp = preBuf1;
}
else if (input_color_mode == 0) // 1-bit mono
{
preBuf2 = (unsigned char *)calloc(doc->outheader.cupsWidth * 3,
sizeof(unsigned char));
- cupsImageWhiteToRGB(bp, preBuf2, doc->outheader.cupsWidth);
+ cfImageWhiteToRGB(bp, preBuf2, doc->outheader.cupsWidth);
bp = preBuf2;
}
else if (color_mode_needed == 0) // 1-bit mono
unsigned char *rgbToCmyk(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageRGBToCMYK(src,dst,pixels);
+ cfImageRGBToCMYK(src,dst,pixels);
return dst;
}
unsigned char *whiteToCmyk(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageWhiteToCMYK(src,dst,pixels);
+ cfImageWhiteToCMYK(src,dst,pixels);
return dst;
}
unsigned char *cmykToRgb(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageCMYKToRGB(src,dst,pixels);
+ cfImageCMYKToRGB(src,dst,pixels);
return dst;
}
unsigned char *whiteToRgb(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageWhiteToRGB(src,dst,pixels);
+ cfImageWhiteToRGB(src,dst,pixels);
return dst;
}
unsigned char *rgbToWhite(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageRGBToWhite(src,dst,pixels);
+ cfImageRGBToWhite(src,dst,pixels);
return dst;
}
unsigned char *cmykToWhite(unsigned char *src, unsigned char *dst,
unsigned int pixels)
{
- cupsImageCMYKToWhite(src,dst,pixels);
+ cfImageCMYKToWhite(src,dst,pixels);
return dst;
}
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
- cups_image_t *img; /* Image to print */
- cups_icspace_t primary; /* Primary image colorspace */
+ cf_image_t *img; /* Image to print */
+ cf_icspace_t primary; /* Primary image colorspace */
FILE *out; /* Output PPM/PGM file */
- cups_ib_t *line; /* Line from file */
+ cf_ib_t *line; /* Line from file */
int y, /* Current line */
width, /* Width of image */
height, /* Height of image */
}
if (strstr(argv[2], ".ppm") != NULL)
- primary = CUPS_IMAGE_RGB;
+ primary = CF_IMAGE_RGB;
else
- primary = CUPS_IMAGE_WHITE;
+ primary = CF_IMAGE_WHITE;
- img = cupsImageOpen(argv[1], primary, CUPS_IMAGE_WHITE, 100, 0, NULL);
+ img = cfImageOpen(argv[1], primary, CF_IMAGE_WHITE, 100, 0, NULL);
if (!img)
{
if (!out)
{
perror(argv[2]);
- cupsImageClose(img);
+ cfImageClose(img);
return (1);
}
- width = cupsImageGetWidth(img);
- height = cupsImageGetHeight(img);
- depth = cupsImageGetDepth(img);
+ width = cfImageGetWidth(img);
+ height = cfImageGetHeight(img);
+ depth = cfImageGetDepth(img);
line = calloc(width, depth);
fprintf(out, "P%d\n%d\n%d\n255\n",
- cupsImageGetColorSpace(img) == CUPS_IMAGE_WHITE ? 5 : 6,
+ cfImageGetColorSpace(img) == CF_IMAGE_WHITE ? 5 : 6,
width, height);
for (y = 0; y < height; y ++)
{
- cupsImageGetRow(img, 0, y, width, line);
+ cfImageGetRow(img, 0, y, width, line);
fwrite(line, width, depth, out);
}
- cupsImageClose(img);
+ cfImageClose(img);
fclose(out);
return (0);
projects / thirdparty / cups-filters.git / commitdiff
