static int /* O - Number of errors */
do_raster_tests(cups_mode_t mode) /* O - Write mode */
{
unsigned page, x, y; /* Looping vars */
FILE *fp; /* Raster file */
cups_raster_t *r; /* Raster stream */
cups_page_header2_t header, /* Page header */
expected; /* Expected page header */
unsigned char data[2048]; /* Raster data */
int errors = 0; /* Number of errors */
/*
* Test writing...
*/
printf("cupsRasterOpen(%s): ",
mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE" :
mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE_COMPRESSED" :
"CUPS_RASTER_WRITE_PWG");
fflush(stdout);
if ((fp = fopen("test.raster", "wb")) == NULL)
{
printf("FAIL (%s)\n", strerror(errno));
return (1);
}
if ((r = cupsRasterOpen(fileno(fp), mode)) == NULL)
{
printf("FAIL (%s)\n", strerror(errno));
fclose(fp);
return (1);
}
puts("PASS");
for (page = 0; page < 4; page ++)
{
memset(&header, 0, sizeof(header));
header.cupsWidth = 256;
header.cupsHeight = 256;
header.cupsBytesPerLine = 256;
if (page & 1)
{
header.cupsBytesPerLine *= 2;
header.cupsColorSpace = CUPS_CSPACE_CMYK;
header.cupsColorOrder = CUPS_ORDER_CHUNKED;
header.cupsNumColors = 4;
}
else
{
header.cupsColorSpace = CUPS_CSPACE_K;
header.cupsColorOrder = CUPS_ORDER_BANDED;
header.cupsNumColors = 1;
}
if (page & 2)
{
header.cupsBytesPerLine *= 2;
header.cupsBitsPerColor = 16;
header.cupsBitsPerPixel = (page & 1) ? 64 : 16;
}
else
{
header.cupsBitsPerColor = 8;
header.cupsBitsPerPixel = (page & 1) ? 32 : 8;
}
if (cupsRasterWriteHeader2(r, &header))
puts("cupsRasterWriteHeader2: PASS");
else
{
puts("cupsRasterWriteHeader2: FAIL");
errors ++;
}
fputs("cupsRasterWritePixels: ", stdout);
fflush(stdout);
memset(data, 0, header.cupsBytesPerLine);
for (y = 0; y < 64; y ++)
if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
break;
if (y < 64)
{
puts("FAIL");
errors ++;
}
else
{
for (x = 0; x < header.cupsBytesPerLine; x ++)
data[x] = (unsigned char)x;
for (y = 0; y < 64; y ++)
if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
break;
if (y < 64)
{
puts("FAIL");
errors ++;
}
else
{
memset(data, 255, header.cupsBytesPerLine);
for (y = 0; y < 64; y ++)
if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
break;
if (y < 64)
{
puts("FAIL");
errors ++;
}
else
{
for (x = 0; x < header.cupsBytesPerLine; x ++)
data[x] = (unsigned char)(x / 4);
for (y = 0; y < 64; y ++)
if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
break;
if (y < 64)
{
puts("FAIL");
errors ++;
}
else
puts("PASS");
}
}
}
}
cupsRasterClose(r);
fclose(fp);
/*
* Test reading...
*/
fputs("cupsRasterOpen(CUPS_RASTER_READ): ", stdout);
fflush(stdout);
if ((fp = fopen("test.raster", "rb")) == NULL)
{
printf("FAIL (%s)\n", strerror(errno));
return (1);
}
if ((r = cupsRasterOpen(fileno(fp), CUPS_RASTER_READ)) == NULL)
{
printf("FAIL (%s)\n", strerror(errno));
fclose(fp);
return (1);
}
puts("PASS");
for (page = 0; page < 4; page ++)
{
memset(&expected, 0, sizeof(expected));
expected.cupsWidth = 256;
expected.cupsHeight = 256;
expected.cupsBytesPerLine = 256;
if (mode == CUPS_RASTER_WRITE_PWG)
{
strlcpy(expected.MediaClass, "PwgRaster", sizeof(expected.MediaClass));
expected.cupsInteger[7] = 0xffffff;
}
if (page & 1)
{
expected.cupsBytesPerLine *= 2;
expected.cupsColorSpace = CUPS_CSPACE_CMYK;
expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
expected.cupsNumColors = 4;
}
else
{
expected.cupsColorSpace = CUPS_CSPACE_K;
expected.cupsColorOrder = CUPS_ORDER_BANDED;
expected.cupsNumColors = 1;
}
if (page & 2)
{
expected.cupsBytesPerLine *= 2;
expected.cupsBitsPerColor = 16;
expected.cupsBitsPerPixel = (page & 1) ? 64 : 16;
}
else
{
expected.cupsBitsPerColor = 8;
expected.cupsBitsPerPixel = (page & 1) ? 32 : 8;
}
fputs("cupsRasterReadHeader2: ", stdout);
fflush(stdout);
if (!cupsRasterReadHeader2(r, &header))
{
puts("FAIL (read error)");
errors ++;
break;
}
if (memcmp(&header, &expected, sizeof(header)))
{
puts("FAIL (bad page header)");
errors ++;
print_changes(&header, &expected);
}
fputs("cupsRasterReadPixels: ", stdout);
fflush(stdout);
for (y = 0; y < 64; y ++)
{
if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
{
puts("FAIL (read error)");
errors ++;
break;
}
if (data[0] != 0 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
{
printf("FAIL (raster line %d corrupt)\n", y);
errors ++;
break;
}
}
if (y == 64)
{
for (y = 0; y < 64; y ++)
{
if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
{
puts("FAIL (read error)");
errors ++;
break;
}
for (x = 0; x < header.cupsBytesPerLine; x ++)
if (data[x] != (x & 255))
break;
if (x < header.cupsBytesPerLine)
{
printf("FAIL (raster line %d corrupt)\n", y + 64);
errors ++;
break;
}
}
if (y == 64)
{
for (y = 0; y < 64; y ++)
{
if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
{
puts("FAIL (read error)");
errors ++;
break;
}
if (data[0] != 255 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
{
printf("fail (raster line %d corrupt)\n", y + 128);
errors ++;
break;
}
}
if (y == 64)
{
for (y = 0; y < 64; y ++)
{
if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
{
puts("FAIL (read error)");
errors ++;
break;
}
for (x = 0; x < header.cupsBytesPerLine; x ++)
if (data[x] != ((x / 4) & 255))
break;
if (x < header.cupsBytesPerLine)
{
printf("FAIL (raster line %d corrupt)\n", y + 192);
errors ++;
break;
}
}
if (y == 64)
puts("PASS");
}
}
}
}
cupsRasterClose(r);
fclose(fp);
return (errors);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int fd; /* Raster file */
cups_raster_t *inras, /* Input raster stream */
*outras; /* Output raster stream */
cups_page_header2_t inheader, /* Input raster page header */
outheader; /* Output raster page header */
int y; /* Current line */
unsigned char *line; /* Line buffer */
int page = 0, /* Current page */
page_width, /* Actual page width */
page_height, /* Actual page height */
page_top, /* Top margin */
page_bottom, /* Bottom margin */
page_left, /* Left margin */
linesize, /* Bytes per line */
lineoffset; /* Offset into line */
unsigned char white; /* White pixel */
ppd_file_t *ppd; /* PPD file */
ppd_attr_t *back; /* cupsBackSize attribute */
_ppd_cache_t *cache; /* PPD cache */
_pwg_size_t *pwg_size; /* PWG media size */
_pwg_media_t *pwg_media; /* PWG media name */
int num_options; /* Number of options */
cups_option_t *options = NULL;/* Options */
const char *val; /* Option value */
if (argc < 6 || argc > 7)
{
puts("Usage: rastertopwg job user title copies options [filename]");
return (1);
}
else if (argc == 7)
{
if ((fd = open(argv[6], O_RDONLY)) < 0)
{
perror("ERROR: Unable to open print file");
return (1);
}
}
else
fd = 0;
inras = cupsRasterOpen(fd, CUPS_RASTER_READ);
outras = cupsRasterOpen(1, CUPS_RASTER_WRITE_PWG);
ppd = ppdOpenFile(getenv("PPD"));
back = ppdFindAttr(ppd, "cupsBackSide", NULL);
num_options = cupsParseOptions(argv[5], 0, &options);
ppdMarkDefaults(ppd);
cupsMarkOptions(ppd, num_options, options);
cache = ppd ? ppd->cache : NULL;
while (cupsRasterReadHeader2(inras, &inheader))
{
/*
* Compute the real raster size...
*/
page ++;
fprintf(stderr, "PAGE: %d %d\n", page, inheader.NumCopies);
page_width = (int)(inheader.cupsPageSize[0] * inheader.HWResolution[0] /
72.0);
page_height = (int)(inheader.cupsPageSize[1] * inheader.HWResolution[1] /
72.0);
page_left = (int)(inheader.cupsImagingBBox[0] *
inheader.HWResolution[0] / 72.0);
page_bottom = (int)(inheader.cupsImagingBBox[1] *
inheader.HWResolution[1] / 72.0);
page_top = page_height - page_bottom - inheader.cupsHeight;
linesize = (page_width * inheader.cupsBitsPerPixel + 7) / 8;
lineoffset = page_left * inheader.cupsBitsPerPixel / 8; /* Round down */
switch (inheader.cupsColorSpace)
{
case CUPS_CSPACE_W :
case CUPS_CSPACE_RGB :
case CUPS_CSPACE_SW :
case CUPS_CSPACE_SRGB :
case CUPS_CSPACE_ADOBERGB :
white = 255;
break;
case CUPS_CSPACE_K :
case CUPS_CSPACE_CMYK :
case CUPS_CSPACE_DEVICE1 :
case CUPS_CSPACE_DEVICE2 :
case CUPS_CSPACE_DEVICE3 :
case CUPS_CSPACE_DEVICE4 :
case CUPS_CSPACE_DEVICE5 :
case CUPS_CSPACE_DEVICE6 :
case CUPS_CSPACE_DEVICE7 :
case CUPS_CSPACE_DEVICE8 :
case CUPS_CSPACE_DEVICE9 :
case CUPS_CSPACE_DEVICEA :
case CUPS_CSPACE_DEVICEB :
case CUPS_CSPACE_DEVICEC :
case CUPS_CSPACE_DEVICED :
case CUPS_CSPACE_DEVICEE :
case CUPS_CSPACE_DEVICEF :
white = 0;
break;
default :
_cupsLangPrintFilter(stderr, "ERROR", _("Unsupported raster data."));
fprintf(stderr, "DEBUG: Unsupported cupsColorSpace %d on page %d.\n",
inheader.cupsColorSpace, page);
return (1);
}
if (inheader.cupsColorOrder != CUPS_ORDER_CHUNKED)
{
_cupsLangPrintFilter(stderr, "ERROR", _("Unsupported raster data."));
fprintf(stderr, "DEBUG: Unsupported cupsColorOrder %d on page %d.\n",
inheader.cupsColorOrder, page);
return (1);
}
if (inheader.cupsBitsPerPixel != 1 &&
inheader.cupsBitsPerColor != 8 && inheader.cupsBitsPerColor != 16)
{
_cupsLangPrintFilter(stderr, "ERROR", _("Unsupported raster data."));
fprintf(stderr, "DEBUG: Unsupported cupsBitsPerColor %d on page %d.\n",
inheader.cupsBitsPerColor, page);
return (1);
}
memcpy(&outheader, &inheader, sizeof(outheader));
outheader.cupsWidth = page_width;
outheader.cupsHeight = page_height;
outheader.cupsBytesPerLine = linesize;
outheader.cupsInteger[14] = 0; /* VendorIdentifier */
outheader.cupsInteger[15] = 0; /* VendorLength */
if ((val = cupsGetOption("print-content-optimize", num_options,
options)) != NULL)
{
if (!strcmp(val, "automatic"))
strlcpy(outheader.OutputType, "Automatic",
sizeof(outheader.OutputType));
else if (!strcmp(val, "graphics"))
strlcpy(outheader.OutputType, "Graphics", sizeof(outheader.OutputType));
else if (!strcmp(val, "photo"))
strlcpy(outheader.OutputType, "Photo", sizeof(outheader.OutputType));
else if (!strcmp(val, "text"))
strlcpy(outheader.OutputType, "Text", sizeof(outheader.OutputType));
else if (!strcmp(val, "text-and-graphics"))
strlcpy(outheader.OutputType, "TextAndGraphics",
sizeof(outheader.OutputType));
else
{
fprintf(stderr, "DEBUG: Unsupported print-content-type \"%s\".\n", val);
outheader.OutputType[0] = '\0';
}
}
if ((val = cupsGetOption("print-quality", num_options, options)) != NULL)
{
int quality = atoi(val); /* print-quality value */
if (quality >= IPP_QUALITY_DRAFT && quality <= IPP_QUALITY_HIGH)
outheader.cupsInteger[8] = quality;
else
{
fprintf(stderr, "DEBUG: Unsupported print-quality %d.\n", quality);
outheader.cupsInteger[8] = 0;
}
}
if ((val = cupsGetOption("print-rendering-intent", num_options,
options)) != NULL)
{
if (!strcmp(val, "absolute"))
strlcpy(outheader.cupsRenderingIntent, "Absolute",
sizeof(outheader.cupsRenderingIntent));
else if (!strcmp(val, "automatic"))
strlcpy(outheader.cupsRenderingIntent, "Automatic",
sizeof(outheader.cupsRenderingIntent));
else if (!strcmp(val, "perceptual"))
strlcpy(outheader.cupsRenderingIntent, "Perceptual",
sizeof(outheader.cupsRenderingIntent));
else if (!strcmp(val, "relative"))
strlcpy(outheader.cupsRenderingIntent, "Relative",
sizeof(outheader.cupsRenderingIntent));
else if (!strcmp(val, "relative-bpc"))
strlcpy(outheader.cupsRenderingIntent, "RelativeBpc",
sizeof(outheader.cupsRenderingIntent));
else if (!strcmp(val, "saturation"))
strlcpy(outheader.cupsRenderingIntent, "Saturation",
sizeof(outheader.cupsRenderingIntent));
else
{
fprintf(stderr, "DEBUG: Unsupported print-rendering-intent \"%s\".\n",
val);
outheader.cupsRenderingIntent[0] = '\0';
}
}
if (inheader.cupsPageSizeName[0] &&
(pwg_size = _ppdCacheGetSize(cache, inheader.cupsPageSizeName)) != NULL)
{
strlcpy(outheader.cupsPageSizeName, pwg_size->map.pwg,
sizeof(outheader.cupsPageSizeName));
}
else
{
pwg_media = _pwgMediaForSize((int)(2540.0 * inheader.cupsPageSize[0] /
72.0),
(int)(2540.0 * inheader.cupsPageSize[1] /
72.0));
if (pwg_media)
strlcpy(outheader.cupsPageSizeName, pwg_media->pwg,
sizeof(outheader.cupsPageSizeName));
else
{
fprintf(stderr, "DEBUG: Unsupported PageSize %.2fx%.2f.\n",
inheader.cupsPageSize[0], inheader.cupsPageSize[1]);
outheader.cupsPageSizeName[0] = '\0';
}
}
if (inheader.Duplex && !(page & 1) &&
back && _cups_strcasecmp(back->value, "Normal"))
{
if (_cups_strcasecmp(back->value, "Flipped"))
{
if (inheader.Tumble)
{
outheader.cupsInteger[1] = -1;/* CrossFeedTransform */
outheader.cupsInteger[2] = 1; /* FeedTransform */
outheader.cupsInteger[3] = page_width - page_left -
inheader.cupsWidth;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_top;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_width - page_left;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_bottom;
/* ImageBoxBottom */
}
else
{
outheader.cupsInteger[1] = 1; /* CrossFeedTransform */
outheader.cupsInteger[2] = -1;/* FeedTransform */
outheader.cupsInteger[3] = page_left;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_bottom;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_left + inheader.cupsWidth;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_top;
/* ImageBoxBottom */
}
}
else if (_cups_strcasecmp(back->value, "ManualTumble"))
{
if (inheader.Tumble)
{
outheader.cupsInteger[1] = -1;/* CrossFeedTransform */
outheader.cupsInteger[2] = -1;/* FeedTransform */
outheader.cupsInteger[3] = page_width - page_left -
inheader.cupsWidth;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_bottom;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_width - page_left;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_top;
/* ImageBoxBottom */
}
else
{
outheader.cupsInteger[1] = 1; /* CrossFeedTransform */
outheader.cupsInteger[2] = 1; /* FeedTransform */
outheader.cupsInteger[3] = page_left;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_top;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_left + inheader.cupsWidth;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_bottom;
/* ImageBoxBottom */
}
}
else if (_cups_strcasecmp(back->value, "Rotated"))
{
if (inheader.Tumble)
{
outheader.cupsInteger[1] = -1;/* CrossFeedTransform */
outheader.cupsInteger[2] = -1;/* FeedTransform */
outheader.cupsInteger[3] = page_width - page_left -
inheader.cupsWidth;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_bottom;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_width - page_left;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_top;
/* ImageBoxBottom */
}
else
{
outheader.cupsInteger[1] = 1; /* CrossFeedTransform */
outheader.cupsInteger[2] = 1; /* FeedTransform */
outheader.cupsInteger[3] = page_left;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_top;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_left + inheader.cupsWidth;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_bottom;
/* ImageBoxBottom */
}
}
else
{
/*
* Unsupported value...
*/
fprintf(stderr, "DEBUG: Unsupported cupsBackSide \"%s\".\n", back->value);
outheader.cupsInteger[1] = 1; /* CrossFeedTransform */
outheader.cupsInteger[2] = 1; /* FeedTransform */
outheader.cupsInteger[3] = page_left;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_top;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_left + inheader.cupsWidth;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_bottom;
/* ImageBoxBottom */
}
}
else
{
outheader.cupsInteger[1] = 1; /* CrossFeedTransform */
outheader.cupsInteger[2] = 1; /* FeedTransform */
outheader.cupsInteger[3] = page_left;
/* ImageBoxLeft */
outheader.cupsInteger[4] = page_top;
/* ImageBoxTop */
outheader.cupsInteger[5] = page_left + inheader.cupsWidth;
/* ImageBoxRight */
outheader.cupsInteger[6] = page_height - page_bottom;
/* ImageBoxBottom */
}
if (!cupsRasterWriteHeader2(outras, &outheader))
{
_cupsLangPrintFilter(stderr, "ERROR", _("Error sending raster data."));
fprintf(stderr, "DEBUG: Unable to write header for page %d.\n", page);
return (1);
}
/*
* Copy raster data...
*/
line = malloc(linesize);
memset(line, white, linesize);
for (y = page_top; y > 0; y --)
if (!cupsRasterWritePixels(outras, line, outheader.cupsBytesPerLine))
{
_cupsLangPrintFilter(stderr, "ERROR", _("Error sending raster data."));
fprintf(stderr, "DEBUG: Unable to write line %d for page %d.\n",
page_top - y + 1, page);
return (1);
}
for (y = inheader.cupsHeight; y > 0; y --)
{
cupsRasterReadPixels(inras, line + lineoffset, inheader.cupsBytesPerLine);
if (!cupsRasterWritePixels(outras, line, outheader.cupsBytesPerLine))
{
_cupsLangPrintFilter(stderr, "ERROR", _("Error sending raster data."));
fprintf(stderr, "DEBUG: Unable to write line %d for page %d.\n",
inheader.cupsHeight - y + page_top + 1, page);
return (1);
}
}
memset(line, white, linesize);
for (y = page_bottom; y > 0; y --)
if (!cupsRasterWritePixels(outras, line, outheader.cupsBytesPerLine))
{
_cupsLangPrintFilter(stderr, "ERROR", _("Error sending raster data."));
fprintf(stderr, "DEBUG: Unable to write line %d for page %d.\n",
page_bottom - y + page_top + inheader.cupsHeight + 1, page);
return (1);
}
free(line);
}
cupsRasterClose(inras);
if (fd)
close(fd);
cupsRasterClose(outras);
return (0);
}
static void _write_header_pwg(cups_raster_t *outputfile, int print_resolution, wprint_image_info_t image_info, cups_page_header2_t *h, bool monochrome) {
if (outputfile != NULL) {
strcpy(h->MediaClass, "PwgRaster");
strcpy(h->MediaColor, "");
strcpy(h->MediaType, "");
strcpy(h->OutputType, "");
h->AdvanceDistance = 0;
h->AdvanceMedia = CUPS_ADVANCE_FILE;
h->Collate = CUPS_FALSE;
h->CutMedia = CUPS_CUT_NONE;
h->Duplex = CUPS_FALSE;
h->HWResolution[0] = print_resolution;
h->HWResolution[1] = print_resolution;
h->cupsPageSize[0] = (float) ( ( wprint_image_get_width(&image_info) / h->HWResolution[0]) * 72);
h->cupsPageSize[1] = (float) ( ( wprint_image_get_height(&image_info) / h->HWResolution[1]) * 72);
h->ImagingBoundingBox[0] = 0;
h->ImagingBoundingBox[1] = 0;
h->ImagingBoundingBox[2] = h->cupsPageSize[0];
h->ImagingBoundingBox[3] = h->cupsPageSize[1];
h->cupsBorderlessScalingFactor = 1.0;
h->InsertSheet = CUPS_FALSE;
h->Jog = CUPS_JOG_NONE;
h->LeadingEdge = CUPS_EDGE_TOP;
h->Margins[0] = 0;
h->Margins[1] = 0;
h->ManualFeed =CUPS_TRUE;
h->MediaPosition = 0;
h->MediaWeight = 0;
h->MirrorPrint = CUPS_FALSE;
h->NegativePrint = CUPS_FALSE;
h->NumCopies = 1;
h->Orientation = image_info.rotation;
h->OutputFaceUp = CUPS_FALSE;
h->PageSize[0] = (int)h->cupsPageSize[0];
h->PageSize[1] = (int)h->cupsPageSize[1];
h->Separations = CUPS_TRUE;
h->TraySwitch = CUPS_TRUE;
h->Tumble = CUPS_TRUE;
h->cupsWidth = (int) wprint_image_get_width(&image_info) ;
h->cupsHeight =(int) wprint_image_get_height(&image_info);
h->cupsMediaType = 2;
h->cupsBitsPerPixel = (monochrome ? 8 : 24);
h->cupsBitsPerColor = 8;
h->cupsBytesPerLine = (h->cupsBitsPerPixel * wprint_image_get_width(&image_info) + 7 ) / 8;
h->cupsColorOrder = CUPS_ORDER_CHUNKED;
h->cupsColorSpace = (monochrome ? CUPS_CSPACE_SW : CUPS_CSPACE_RGB);
h->cupsCompression = 0;
h->cupsRowCount = 1;
h->cupsRowFeed = 1;
h->cupsRowStep = 1;
h->cupsNumColors = (monochrome ? 1 : 3);
h->cupsImagingBBox[0] = 0.0;
h->cupsImagingBBox[1] = 0.0;
h->cupsImagingBBox[2] = 0.0;
h->cupsImagingBBox[3] = 0.0;
int j;
for( j = 0; j<16; j++)
{
h->cupsInteger[j] = (int)1+j;
h->cupsReal[j] = (float)j+1.1;
snprintf(h->cupsString[j], 20, "String # %d", j+1);
}
strcpy(h->cupsMarkerType, "Marker Type");
strcpy(h->cupsRenderingIntent, "endering IntentR");
strcpy(h->cupsPageSizeName, "Letter");
//Now write the header
cupsRasterWriteHeader2(outputfile, h);
}
}
static void
write_test(int fd, /* I - File descriptor to write to */
cups_mode_t mode) /* I - Write mode */
{
int page, x, y; /* Looping vars */
int count; /* Number of bytes to set */
cups_raster_t *r; /* Raster stream */
cups_page_header2_t header; /* Page header */
unsigned char data[32][8 * TEST_WIDTH];
/* Raster data to write */
/*
* Create a combination of random data and repeated data to simulate
* text with some whitespace.
*/
CUPS_SRAND(time(NULL));
memset(data, 0, sizeof(data));
for (y = 0; y < 28; y ++)
{
for (x = CUPS_RAND() & 127, count = (CUPS_RAND() & 15) + 1;
x < sizeof(data[0]);
x ++, count --)
{
if (count <= 0)
{
x += (CUPS_RAND() & 15) + 1;
count = (CUPS_RAND() & 15) + 1;
if (x >= sizeof(data[0]))
break;
}
data[y][x] = CUPS_RAND();
}
}
/*
* Test write speed...
*/
if ((r = cupsRasterOpen(fd, mode)) == NULL)
{
perror("Unable to create raster output stream");
return;
}
for (page = 0; page < TEST_PAGES; page ++)
{
memset(&header, 0, sizeof(header));
header.cupsWidth = TEST_WIDTH;
header.cupsHeight = TEST_HEIGHT;
header.cupsBytesPerLine = TEST_WIDTH;
if (page & 1)
{
header.cupsBytesPerLine *= 4;
header.cupsColorSpace = CUPS_CSPACE_CMYK;
header.cupsColorOrder = CUPS_ORDER_CHUNKED;
}
else
{
header.cupsColorSpace = CUPS_CSPACE_K;
header.cupsColorOrder = CUPS_ORDER_BANDED;
}
if (page & 2)
{
header.cupsBytesPerLine *= 2;
header.cupsBitsPerColor = 16;
header.cupsBitsPerPixel = (page & 1) ? 64 : 16;
}
else
{
header.cupsBitsPerColor = 8;
header.cupsBitsPerPixel = (page & 1) ? 32 : 8;
}
cupsRasterWriteHeader2(r, &header);
for (y = 0; y < TEST_HEIGHT; y ++)
cupsRasterWritePixels(r, data[y & 31], header.cupsBytesPerLine);
}
cupsRasterClose(r);
}
