static void
read_test(int fd) /* I - File descriptor to read from */
{
int y; /* Looping var */
cups_raster_t *r; /* Raster stream */
cups_page_header2_t header; /* Page header */
unsigned char buffer[8 * TEST_WIDTH];
/* Read buffer */
/*
* Test read speed...
*/
if ((r = cupsRasterOpen(fd, CUPS_RASTER_READ)) == NULL)
{
perror("Unable to create raster input stream");
return;
}
while (cupsRasterReadHeader2(r, &header))
{
for (y = 0; y < header.cupsHeight; y ++)
cupsRasterReadPixels(r, buffer, header.cupsBytesPerLine);
}
cupsRasterClose(r);
}
static int /* O - Number of errors */
do_ras_file(const char *filename) /* I - Filename */
{
unsigned y; /* Looping vars */
int fd; /* File descriptor */
cups_raster_t *ras; /* Raster stream */
cups_page_header2_t header; /* Page header */
unsigned char *data; /* Raster data */
int errors = 0; /* Number of errors */
unsigned pages = 0; /* Number of pages */
if ((fd = open(filename, O_RDONLY)) < 0)
{
printf("%s: %s\n", filename, strerror(errno));
return (1);
}
if ((ras = cupsRasterOpen(fd, CUPS_RASTER_READ)) == NULL)
{
printf("%s: cupsRasterOpen failed.\n", filename);
close(fd);
return (1);
}
printf("%s:\n", filename);
while (cupsRasterReadHeader2(ras, &header))
{
pages ++;
data = malloc(header.cupsBytesPerLine);
printf(" Page %u: %ux%ux%u@%ux%udpi", pages,
header.cupsWidth, header.cupsHeight, header.cupsBitsPerPixel,
header.HWResolution[0], header.HWResolution[1]);
fflush(stdout);
for (y = 0; y < header.cupsHeight; y ++)
if (cupsRasterReadPixels(ras, data, header.cupsBytesPerLine) <
header.cupsBytesPerLine)
break;
if (y < header.cupsHeight)
printf(" ERROR AT LINE %d\n", y);
else
putchar('\n');
free(data);
}
printf("EOF at %ld\n", (long)lseek(fd, SEEK_CUR, 0));
cupsRasterClose(ras);
close(fd);
return (errors);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int fd; /* File descriptor */
cups_raster_t *ras; /* Raster stream for printing */
cups_page_header2_t header; /* Page header from file */
unsigned y; /* Current line */
ppd_file_t *ppd; /* PPD file */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
/*
* Make sure status messages are not buffered...
*/
setbuf(stderr, NULL);
/*
* Check command-line...
*/
if (argc < 6 || argc > 7)
{
/*
* We don't have the correct number of arguments; write an error message
* and return.
*/
_cupsLangPrintFilter(stderr, "ERROR",
_("%s job-id user title copies options [file]"),
"rastertolabel");
return (1);
}
/*
* Open the page stream...
*/
if (argc == 7)
{
if ((fd = open(argv[6], O_RDONLY)) == -1)
{
_cupsLangPrintError("ERROR", _("Unable to open raster file"));
sleep(1);
return (1);
}
}
else
fd = 0;
ras = cupsRasterOpen(fd, CUPS_RASTER_READ);
/*
* Register a signal handler to eject the current page if the
* job is cancelled.
*/
Canceled = 0;
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, CancelJob);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = CancelJob;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, CancelJob);
#endif /* HAVE_SIGSET */
/*
* Open the PPD file and apply options...
*/
num_options = cupsParseOptions(argv[5], 0, &options);
ppd = ppdOpenFile(getenv("PPD"));
if (!ppd)
{
ppd_status_t status; /* PPD error */
int linenum; /* Line number */
_cupsLangPrintFilter(stderr, "ERROR",
_("The PPD file could not be opened."));
status = ppdLastError(&linenum);
fprintf(stderr, "DEBUG: %s on line %d.\n", ppdErrorString(status), linenum);
return (1);
}
ppdMarkDefaults(ppd);
cupsMarkOptions(ppd, num_options, options);
/*
* Initialize the print device...
*/
Setup(ppd);
/*
* Process pages as needed...
*/
Page = 0;
while (cupsRasterReadHeader2(ras, &header))
{
/*
* Write a status message with the page number and number of copies.
*/
if (Canceled)
break;
Page ++;
fprintf(stderr, "PAGE: %d 1\n", Page);
_cupsLangPrintFilter(stderr, "INFO", _("Starting page %d."), Page);
/*
* Start the page...
*/
StartPage(ppd, &header);
/*
* Loop for each line on the page...
*/
for (y = 0; y < header.cupsHeight && !Canceled; y ++)
{
/*
* Let the user know how far we have progressed...
*/
if (Canceled)
break;
if ((y & 15) == 0)
{
_cupsLangPrintFilter(stderr, "INFO",
_("Printing page %d, %u%% complete."),
Page, 100 * y / header.cupsHeight);
fprintf(stderr, "ATTR: job-media-progress=%u\n",
100 * y / header.cupsHeight);
}
/*
* Read a line of graphics...
*/
if (cupsRasterReadPixels(ras, Buffer, header.cupsBytesPerLine) < 1)
break;
/*
* Write it to the printer...
*/
OutputLine(ppd, &header, y);
}
/*
* Eject the page...
*/
_cupsLangPrintFilter(stderr, "INFO", _("Finished page %d."), Page);
EndPage(ppd, &header);
if (Canceled)
break;
}
/*
* Close the raster stream...
*/
cupsRasterClose(ras);
if (fd != 0)
close(fd);
/*
* Close the PPD file and free the options...
*/
ppdClose(ppd);
cupsFreeOptions(num_options, options);
/*
* If no pages were printed, send an error message...
*/
if (Page == 0)
{
_cupsLangPrintFilter(stderr, "ERROR", _("No pages were found."));
return (1);
}
else
return (0);
}
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 HPCupsFilter::processRasterData(cups_raster_t *cups_raster)
{
FILE *kfp = NULL;
FILE *cfp = NULL;
BYTE *kRaster = NULL;
BYTE *rgbRaster = NULL;
int current_page_number = 0;
cups_page_header2_t cups_header;
DRIVER_ERROR err;
int ret_status = 0;
char hpPreProcessedRasterFile[MAX_FILE_PATH_LEN]; //temp file needed to store raster data with swaped pages.
sprintf(hpPreProcessedRasterFile, "%s/hp_%s_cups_SwapedPagesXXXXXX",CUPS_TMP_DIR, m_JA.user_name);
while (cupsRasterReadHeader2(cups_raster, &cups_header))
{
current_page_number++;
if (current_page_number == 1) {
if (startPage(&cups_header) != NO_ERROR) {
return JOB_CANCELED;
}
if (m_JA.pre_process_raster) {
// CC ToDo: Why pSwapedPagesFileName should be sent as a parameter?
// Remove if not required to send it as parameter
err = m_Job.preProcessRasterData(&cups_raster, &cups_header, hpPreProcessedRasterFile);
if (err != NO_ERROR) {
if (m_iLogLevel & BASIC_LOG) {
dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err);
}
ret_status = JOB_CANCELED;
break;
}
}
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) {
rgbRaster = new BYTE[cups_header.cupsWidth * 3];
if (rgbRaster == NULL) {
return ALLOCMEM_ERROR;
}
kRaster = new BYTE[cups_header.cupsWidth];
if (kRaster == NULL) {
delete [] rgbRaster;
return ALLOCMEM_ERROR;
}
memset (kRaster, 0, cups_header.cupsWidth);
memset (rgbRaster, 0xFF, cups_header.cupsWidth * 3);
}
} // end of if(current_page_number == 1)
if (cups_header.cupsColorSpace == CUPS_CSPACE_K) {
kRaster = m_pPrinterBuffer;
rgbRaster = NULL;
}
else if (cups_header.cupsColorSpace != CUPS_CSPACE_RGBW) {
rgbRaster = m_pPrinterBuffer;
kRaster = NULL;
}
BYTE *color_raster = NULL;
BYTE *black_raster = NULL;
err = m_Job.StartPage(&m_JA);
if (err != NO_ERROR) {
if (m_iLogLevel & BASIC_LOG) {
dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err);
}
ret_status = JOB_CANCELED;
break;
}
// Save Raster file for Debugging
if (m_iLogLevel & SAVE_INPUT_RASTERS)
{
char szFileName[MAX_FILE_PATH_LEN];
memset(szFileName, 0, sizeof(szFileName));
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW ||
cups_header.cupsColorSpace == CUPS_CSPACE_RGB)
{
snprintf (szFileName, sizeof(szFileName), "%s/hpcups_%s_c_bmp_%d_XXXXXX", CUPS_TMP_DIR, m_JA.user_name, current_page_number);
createTempFile(szFileName, &cfp);
if (cfp)
{
chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
}
}
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW ||
cups_header.cupsColorSpace == CUPS_CSPACE_K)
{
snprintf (szFileName, sizeof(szFileName), "%s/hpcups_%s_k_bmp_%d_XXXXXX", CUPS_TMP_DIR, m_JA.user_name, current_page_number);
createTempFile(szFileName, &kfp);
if (kfp)
{
chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
}
}
WriteBMPHeader (cfp, cups_header.cupsWidth, cups_header.cupsHeight, COLOR_RASTER);
WriteBMPHeader (kfp, cups_header.cupsWidth, cups_header.cupsHeight, BLACK_RASTER);
}
fprintf(stderr, "PAGE: %d %s\r\n", current_page_number, m_argv[4]);
// Iterating through the raster per page
bool is_ljmono = strcmp(m_JA.printer_language, "ljmono");
for (int y = 0; y < (int) cups_header.cupsHeight; y++) {
cupsRasterReadPixels (cups_raster, m_pPrinterBuffer, cups_header.cupsBytesPerLine);
color_raster = rgbRaster;
black_raster = kRaster;
if ((y == 0) && !is_ljmono) {
//For ljmono, make sure that first line is not a blankRaster line.Otherwise printer
//may not skip blank lines before actual data
//Need to revisit to cross check if it is a firmware issue.
*m_pPrinterBuffer = 0x01;
dbglog("First raster data plane..\n" );
}
if (this->isBlankRaster((BYTE *) m_pPrinterBuffer, &cups_header)) {
color_raster = NULL;
black_raster = NULL;
}
extractBlackPixels(&cups_header, black_raster, color_raster);
//! Sending Raster bits off to encapsulation
err = m_Job.SendRasters (black_raster, color_raster);
if (err != NO_ERROR) {
break;
}
if (m_iLogLevel & SAVE_INPUT_RASTERS)
{
WriteBMPRaster (cfp, color_raster, cups_header.cupsWidth, COLOR_RASTER);
WriteBMPRaster (kfp, black_raster, cups_header.cupsWidth/8, BLACK_RASTER);
}
} // for() loop end
m_Job.NewPage();
if (err != NO_ERROR) {
break;
}
} // while() loop end
//! Remove the old processing band data...
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) {
delete [] kRaster;
delete [] rgbRaster;
kRaster = NULL;
rgbRaster = NULL;
}
unlink(hpPreProcessedRasterFile);
return ret_status;
}
int main(int argc, const char *argv[]) {
ppd_file_t *ppd;
cups_raster_t *ras;
cups_page_header2_t pagehdr;
job_data_t job;
printerRef prn;
int rasterfile;
int page;
char ls[64];
l10nInitialize();
setbuf(stderr, NULL);
if (argc < 6 || argc > 7) {
fprintf(stderr, "Usage: %s job user title copies options [filename]\n", argv[0]);
return 0;
}
if (initializeCupsOptions(&job, &ppd, argv)) return 1;
if (argc == 7) {
if ((rasterfile = open(argv[6], O_RDONLY)) == -1) {
l10nGetString("Unable to open raster file", ls, sizeof(ls));
fprintf(stderr, "ERROR: %s - %s\n", ls, strerror(errno));
return 1;
}
} else
rasterfile = 0;
ras = cupsRasterOpen(rasterfile, CUPS_RASTER_READ);
prn = prnAlloc(stdout, NULL, NULL);
prnTextPrint(prn, " \r");
initializeBidirectional(ppd, prn);
/* Page loop */
page = 0;
while (cupsRasterReadHeader2(ras, &pagehdr)) {
uint8_t *curStripe;
int y, row;
int hgr;
int lineskip;
/* Initialize printer for page */
if (pagehdr.NumCopies > 1) {
l10nGetString("Multiple copies of a single page not supported", ls, sizeof(ls));
fprintf(stderr, "ERROR: %s\n", ls);
return 1;
}
if (pagehdr.cupsBitsPerPixel > 1) {
l10nGetString("Color page not supported!", ls, sizeof(ls));
fprintf(stderr, "ERROR: %s\n", ls);
return 1;
}
hgr = (pagehdr.HWResolution[1] == 144);
if (prnSetHorizontalResolution(prn, pagehdr.HWResolution[0])) {
l10nGetString("Horizontal resolution not supported", ls, sizeof(ls));
fprintf(stderr, "ERROR: %s\n", ls);
return 1;
}
curStripe = malloc(pagehdr.cupsBytesPerLine*(8+8*hgr));
prnSetFormHeight(prn, pagehdr.PageSize[1]*2);
page++;
fprintf(stderr, "PAGE: %d %d\n", page, pagehdr.NumCopies);
row = 0;
lineskip = 0;
for (y=0; y<pagehdr.cupsHeight; y++) {
cupsRasterReadPixels(ras, &curStripe[row*pagehdr.cupsBytesPerLine], pagehdr.cupsBytesPerLine);
row++;
if ((row >= 8+(8*hgr)) || (y+1 == pagehdr.cupsHeight)) {
if (!stripeIsEmpty(curStripe, pagehdr.cupsBytesPerLine, 8+(8*hgr))) {
skipLines(prn, &lineskip);
outputStripeWithRes(prn, curStripe, pagehdr.cupsBytesPerLine, hgr);
memset(curStripe, 0, pagehdr.cupsBytesPerLine*(8+(8*hgr)));
} else
lineskip += 16;
row = 0;
}
if (y * 25 % pagehdr.cupsHeight < 25)
fprintf(stderr, "INFO: %d%%\n", y*100/pagehdr.cupsHeight);
}
prnFormFeed(prn);
free(curStripe);
}
/* Page loop end */
prnDealloc(prn);
if (page == 0) {
l10nGetString("No pages found!", ls, sizeof(ls));
fprintf(stderr, "ERROR: %s\n", ls);
return 1;
} else {
l10nGetString("Ready to print.", ls, sizeof(ls));
fprintf(stderr, "INFO: %s\n", ls);
}
return 0;
}
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);
}
int HPCupsFilter::processRasterData(cups_raster_t *cups_raster)
{
FILE *kfp = NULL;
FILE *cfp = NULL;
BYTE *kRaster = NULL;
BYTE *rgbRaster = NULL;
int current_page_number = 0;
cups_page_header2_t cups_header;
DRIVER_ERROR err;
int ret_status = 0;
char hpPreProcessedRasterFile[] = "/tmp/hplipSwapedPagesXXXXXX"; //temp file needed to store raster data with swaped pages.
while (cupsRasterReadHeader2(cups_raster, &cups_header))
{
current_page_number++;
if (current_page_number == 1) {
if (startPage(&cups_header) != NO_ERROR) {
return JOB_CANCELED;
}
if(m_JA.pre_process_raster) {
err = m_Job.preProcessRasterData(&cups_raster, &cups_header, hpPreProcessedRasterFile);
if (err != NO_ERROR) {
if (m_iLogLevel & BASIC_LOG) {
dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err);
}
ret_status = JOB_CANCELED;
break;
}
}
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) {
rgbRaster = new BYTE[cups_header.cupsWidth * 3];
if (rgbRaster == NULL) {
return ALLOCMEM_ERROR;
}
kRaster = new BYTE[cups_header.cupsWidth];
if (kRaster == NULL) {
delete [] rgbRaster;
return ALLOCMEM_ERROR;
}
memset (kRaster, 0, cups_header.cupsWidth);
memset (rgbRaster, 0xFF, cups_header.cupsWidth * 3);
}
} // current_page_number == 1
if (cups_header.cupsColorSpace == CUPS_CSPACE_K) {
kRaster = m_pPrinterBuffer;
rgbRaster = NULL;
}
else if (cups_header.cupsColorSpace != CUPS_CSPACE_RGBW) {
rgbRaster = m_pPrinterBuffer;
kRaster = NULL;
}
BYTE *color_raster = NULL;
BYTE *black_raster = NULL;
err = m_Job.StartPage(&m_JA);
if (err != NO_ERROR) {
if (m_iLogLevel & BASIC_LOG) {
dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err);
}
ret_status = JOB_CANCELED;
break;
}
if (m_iLogLevel & SAVE_INPUT_RASTERS)
{
char szFileName[32];
memset(szFileName, 0, sizeof(szFileName));
snprintf (szFileName, sizeof(szFileName), "/tmp/hpcupsfilterc_%d.bmp", current_page_number);
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW ||
cups_header.cupsColorSpace == CUPS_CSPACE_RGB)
{
cfp = fopen (szFileName, "w");
chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
}
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW ||
cups_header.cupsColorSpace == CUPS_CSPACE_K)
{
szFileName[17] = 'k';
kfp = fopen (szFileName, "w");
chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
}
WriteBMPHeader (cfp, cups_header.cupsWidth, cups_header.cupsHeight, COLOR_RASTER);
WriteBMPHeader (kfp, cups_header.cupsWidth, cups_header.cupsHeight, BLACK_RASTER);
}
fprintf(stderr, "PAGE: %d %s\r\n", current_page_number, m_argv[4]);
// Iterating through the raster per page
for (int y = 0; y < (int) cups_header.cupsHeight; y++) {
cupsRasterReadPixels (cups_raster, m_pPrinterBuffer, cups_header.cupsBytesPerLine);
color_raster = rgbRaster;
black_raster = kRaster;
if(y == 0 && (0 == strcmp(m_JA.printer_language, "ljmono")) )
{
//For ljmono, make sure that first line is not a blankRaster line.Otherwise printer
//may not skip blank lines before actual data
//Need to revisit to crosscheck if it is a firmware issue.
*m_pPrinterBuffer = 0x01;
dbglog("First raster data plane.." );
}
if (this->isBlankRaster((BYTE *) m_pPrinterBuffer, &cups_header)) {
color_raster = NULL;
black_raster = NULL;
}
extractBlackPixels(&cups_header, black_raster, color_raster);
//! Sending Raster bits off to encapsulation
err = m_Job.SendRasters (black_raster, color_raster);
if (err != NO_ERROR) {
break;
}
WriteBMPRaster (cfp, color_raster, cups_header.cupsWidth, COLOR_RASTER);
WriteBMPRaster (kfp, black_raster, cups_header.cupsWidth/8, BLACK_RASTER);
}
m_Job.NewPage();
if (err != NO_ERROR) {
break;
}
}
//! Remove the old processing band data...
if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) {
delete [] kRaster;
delete [] rgbRaster;
}
unlink(hpPreProcessedRasterFile);
return ret_status;
}
