#include <cups/cups.h>
#include <cups/ppd.h>
#include <cups/string-private.h>
#include <cups/language-private.h>
#include <cups/raster.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#define DYMO_3x0 0
#define ZEBRA_EPL_LINE 0x10
#define ZEBRA_EPL_PAGE 0x11
#define ZEBRA_ZPL 0x12
#define ZEBRA_CPCL 0x13
#define INTELLITECH_PCL 0x20
unsigned char *Buffer;
unsigned char *CompBuffer;
unsigned char *LastBuffer;
int LastSet;
int ModelNumber,
Page,
Feed,
Canceled;
void Setup(ppd_file_t *ppd);
void StartPage(ppd_file_t *ppd, cups_page_header2_t *header);
void EndPage(ppd_file_t *ppd, cups_page_header2_t *header);
void CancelJob(int sig);
void OutputLine(ppd_file_t *ppd, cups_page_header2_t *header, int y);
void PCLCompress(unsigned char *line, int length);
void ZPLCompress(char repeat_char, int repeat_count);
void
Setup(ppd_file_t *ppd)
{
int i;
if (ppd)
ModelNumber = ppd->model_number;
switch (ModelNumber)
{
case DYMO_3x0 :
for (i = 0; i < 100; i ++)
putchar(0x1b);
fputs("\033@", stdout);
break;
case ZEBRA_EPL_LINE :
break;
case ZEBRA_EPL_PAGE :
break;
case ZEBRA_ZPL :
break;
case ZEBRA_CPCL :
break;
case INTELLITECH_PCL :
putchar(0x1b);
putchar('E');
break;
}
}
void
StartPage(ppd_file_t *ppd,
cups_page_header2_t *header)
{
ppd_choice_t *choice;
int length;
fprintf(stderr, "DEBUG: StartPage...\n");
fprintf(stderr, "DEBUG: MediaClass = \"%s\"\n", header->MediaClass);
fprintf(stderr, "DEBUG: MediaColor = \"%s\"\n", header->MediaColor);
fprintf(stderr, "DEBUG: MediaType = \"%s\"\n", header->MediaType);
fprintf(stderr, "DEBUG: OutputType = \"%s\"\n", header->OutputType);
fprintf(stderr, "DEBUG: AdvanceDistance = %d\n", header->AdvanceDistance);
fprintf(stderr, "DEBUG: AdvanceMedia = %d\n", header->AdvanceMedia);
fprintf(stderr, "DEBUG: Collate = %d\n", header->Collate);
fprintf(stderr, "DEBUG: CutMedia = %d\n", header->CutMedia);
fprintf(stderr, "DEBUG: Duplex = %d\n", header->Duplex);
fprintf(stderr, "DEBUG: HWResolution = [ %d %d ]\n", header->HWResolution[0],
header->HWResolution[1]);
fprintf(stderr, "DEBUG: ImagingBoundingBox = [ %d %d %d %d ]\n",
header->ImagingBoundingBox[0], header->ImagingBoundingBox[1],
header->ImagingBoundingBox[2], header->ImagingBoundingBox[3]);
fprintf(stderr, "DEBUG: InsertSheet = %d\n", header->InsertSheet);
fprintf(stderr, "DEBUG: Jog = %d\n", header->Jog);
fprintf(stderr, "DEBUG: LeadingEdge = %d\n", header->LeadingEdge);
fprintf(stderr, "DEBUG: Margins = [ %d %d ]\n", header->Margins[0],
header->Margins[1]);
fprintf(stderr, "DEBUG: ManualFeed = %d\n", header->ManualFeed);
fprintf(stderr, "DEBUG: MediaPosition = %d\n", header->MediaPosition);
fprintf(stderr, "DEBUG: MediaWeight = %d\n", header->MediaWeight);
fprintf(stderr, "DEBUG: MirrorPrint = %d\n", header->MirrorPrint);
fprintf(stderr, "DEBUG: NegativePrint = %d\n", header->NegativePrint);
fprintf(stderr, "DEBUG: NumCopies = %d\n", header->NumCopies);
fprintf(stderr, "DEBUG: Orientation = %d\n", header->Orientation);
fprintf(stderr, "DEBUG: OutputFaceUp = %d\n", header->OutputFaceUp);
fprintf(stderr, "DEBUG: PageSize = [ %d %d ]\n", header->PageSize[0],
header->PageSize[1]);
fprintf(stderr, "DEBUG: Separations = %d\n", header->Separations);
fprintf(stderr, "DEBUG: TraySwitch = %d\n", header->TraySwitch);
fprintf(stderr, "DEBUG: Tumble = %d\n", header->Tumble);
fprintf(stderr, "DEBUG: cupsWidth = %d\n", header->cupsWidth);
fprintf(stderr, "DEBUG: cupsHeight = %d\n", header->cupsHeight);
fprintf(stderr, "DEBUG: cupsMediaType = %d\n", header->cupsMediaType);
fprintf(stderr, "DEBUG: cupsBitsPerColor = %d\n", header->cupsBitsPerColor);
fprintf(stderr, "DEBUG: cupsBitsPerPixel = %d\n", header->cupsBitsPerPixel);
fprintf(stderr, "DEBUG: cupsBytesPerLine = %d\n", header->cupsBytesPerLine);
fprintf(stderr, "DEBUG: cupsColorOrder = %d\n", header->cupsColorOrder);
fprintf(stderr, "DEBUG: cupsColorSpace = %d\n", header->cupsColorSpace);
fprintf(stderr, "DEBUG: cupsCompression = %d\n", header->cupsCompression);
fprintf(stderr, "DEBUG: cupsRowCount = %d\n", header->cupsRowCount);
fprintf(stderr, "DEBUG: cupsRowFeed = %d\n", header->cupsRowFeed);
fprintf(stderr, "DEBUG: cupsRowStep = %d\n", header->cupsRowStep);
switch (ModelNumber)
{
case DYMO_3x0 :
length = header->PageSize[1] * header->HWResolution[1] / 72;
printf("\033L%c%c", length >> 8, length);
printf("\033D%c", header->cupsBytesPerLine);
printf("\033%c", header->cupsCompression + 'c');
break;
case ZEBRA_EPL_LINE :
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
printf("\033S%.0f", atof(choice->choice) * 2.0 - 2.0);
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("\033D%d", 7 * header->cupsCompression / 100);
fputs("\033M01", stdout);
fputs("\033B", stdout);
break;
case ZEBRA_EPL_PAGE :
puts("");
puts("N");
if (!strcmp(header->MediaType, "Direct"))
puts("OD");
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
float val = atof(choice->choice);
if (val >= 3.0)
printf("S%.0f\n", val);
else
printf("S%.0f\n", val * 2.0 - 2.0);
}
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("D%d\n", 15 * header->cupsCompression / 100);
printf("q%d\n", (header->cupsWidth + 7) & ~7);
break;
case ZEBRA_ZPL :
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("~SD%02d\n", 30 * header->cupsCompression / 100);
printf("~DGR:CUPS.GRF,%d,%d,\n",
header->cupsHeight * header->cupsBytesPerLine,
header->cupsBytesPerLine);
CompBuffer = malloc(2 * header->cupsBytesPerLine + 1);
LastBuffer = malloc(header->cupsBytesPerLine);
LastSet = 0;
break;
case ZEBRA_CPCL :
printf("! 0 %u %u %u %u\r\n", header->HWResolution[0],
header->HWResolution[1], header->cupsHeight,
header->NumCopies);
printf("PAGE-WIDTH %d\r\n", header->cupsWidth);
printf("PAGE-HEIGHT %d\r\n", header->cupsWidth);
break;
case INTELLITECH_PCL :
printf("\033&l6D\033&k12H");
printf("\033&l0O");
switch (header->PageSize[1])
{
case 540 :
printf("\033&l80A");
break;
case 624 :
printf("\033&l90A");
break;
case 649 :
printf("\033&l91A");
break;
case 684 :
printf("\033&l81A");
break;
case 756 :
printf("\033&l1A");
break;
case 792 :
printf("\033&l2A");
break;
case 842 :
printf("\033&l26A");
break;
case 1008 :
printf("\033&l3A");
break;
default :
printf("\033!f%dZ", header->PageSize[1] * 300 / 72);
break;
}
printf("\033&l%dP",
header->PageSize[1] / 12);
printf("\033&l0E");
printf("\033&l%dX", header->NumCopies);
printf("\033&l0L");
if (Page == 1)
{
if (header->cupsRowFeed)
printf("\033!p%dS", header->cupsRowFeed);
if (header->cupsCompression != ~0)
printf("\033&d%dA", 30 * header->cupsCompression / 100 - 15);
if ((choice = ppdFindMarkedChoice(ppd, "inPrintMode")) != NULL)
{
if (!strcmp(choice->choice, "Standard"))
fputs("\033!p0M", stdout);
else if (!strcmp(choice->choice, "Tear"))
{
fputs("\033!p1M", stdout);
if (header->cupsRowCount)
printf("\033!n%dT", header->cupsRowCount);
}
else
{
fputs("\033!p2M", stdout);
if (header->cupsRowStep)
printf("\033!n%dC", header->cupsRowStep);
}
}
}
printf("\033*t%dR", header->HWResolution[0]);
printf("\033*r%dS", header->cupsWidth);
printf("\033*r%dT", header->cupsHeight);
printf("\033&a0H");
printf("\033&a0V");
printf("\033*r1A");
printf("\033*b3M");
CompBuffer = malloc(2 * header->cupsBytesPerLine + 1);
LastBuffer = malloc(header->cupsBytesPerLine);
LastSet = 0;
break;
}
Buffer = malloc(header->cupsBytesPerLine);
Feed = 0;
}
void
EndPage(ppd_file_t *ppd,
cups_page_header2_t *header)
{
int val;
ppd_choice_t *choice;
switch (ModelNumber)
{
case DYMO_3x0 :
fputs("\033E", stdout);
break;
case ZEBRA_EPL_LINE :
fputs("\033E\014", stdout);
break;
case ZEBRA_EPL_PAGE :
puts("P1");
break;
case ZEBRA_ZPL :
if (Canceled)
{
puts("~DN");
break;
}
puts("^XA");
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
val = atoi(choice->choice);
printf("^PR%d,%d,%d\n", val, val, val);
}
printf("^LH0,0\n");
if (ppdIsMarked(ppd, "zeMediaTracking", "Continuous"))
{
printf("^LL%d\n", header->cupsHeight);
printf("^MNN\n");
}
else if (ppdIsMarked(ppd, "zeMediaTracking", "Web"))
printf("^MNY\n");
else if (ppdIsMarked(ppd, "zeMediaTracking", "Mark"))
printf("^MNM\n");
if (header->cupsRowStep != 200)
printf("^LT%u\n", header->cupsRowStep);
if (!strcmp(header->MediaType, "Thermal"))
printf("^MTT\n");
else if (!strcmp(header->MediaType, "Direct"))
printf("^MTD\n");
if ((choice = ppdFindMarkedChoice(ppd, "zePrintMode")) != NULL &&
strcmp(choice->choice, "Saved"))
{
printf("^MM");
if (!strcmp(choice->choice, "Tear"))
printf("T,Y\n");
else if (!strcmp(choice->choice, "Peel"))
printf("P,Y\n");
else if (!strcmp(choice->choice, "Rewind"))
printf("R,Y\n");
else if (!strcmp(choice->choice, "Applicator"))
printf("A,Y\n");
else
printf("C,Y\n");
}
if (header->AdvanceDistance != 1000)
{
if ((int)header->AdvanceDistance < 0)
printf("~TA%04d\n", (int)header->AdvanceDistance);
else
printf("~TA%03d\n", (int)header->AdvanceDistance);
}
if (ppdIsMarked(ppd, "zeErrorReprint", "Always"))
printf("^JZY\n");
else if (ppdIsMarked(ppd, "zeErrorReprint", "Never"))
printf("^JZN\n");
if (header->NumCopies > 1)
printf("^PQ%d, 0, 0, N\n", header->NumCopies);
puts("^FO0,0^XGR:CUPS.GRF,1,1^FS");
puts("^IDR:CUPS.GRF^FS");
puts("^XZ");
free(CompBuffer);
free(LastBuffer);
break;
case ZEBRA_CPCL :
if (header->AdvanceDistance != 1000)
printf("PRESENT-AT %d 1\r\n", (int)header->AdvanceDistance);
if (ppdIsMarked(ppd, "zeErrorReprint", "Always"))
puts("ON-OUT-OF-PAPER WAIT\r");
else if (ppdIsMarked(ppd, "zeErrorReprint", "Never"))
puts("ON-OUT-OF-PAPER PURGE\r");
if (header->CutMedia)
puts("CUT\r");
if (header->cupsCompression > 0)
printf("TONE %u\r\n", 2 * header->cupsCompression);
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
val = atoi(choice->choice);
printf("SPEED %d\r\n", val);
}
if ((choice = ppdFindMarkedChoice(ppd, "zeMediaTracking")) == NULL ||
strcmp(choice->choice, "Continuous"))
puts("FORM\r");
puts("PRINT\r");
break;
case INTELLITECH_PCL :
printf("\033*rB");
printf("\014");
break;
}
fflush(stdout);
free(Buffer);
}
void
CancelJob(int sig)
{
(void)sig;
Canceled = 1;
}
void
OutputLine(ppd_file_t *ppd,
cups_page_header2_t *header,
int y)
{
int i;
unsigned char *ptr;
unsigned char *compptr;
char repeat_char;
int repeat_count;
static const char *hex = "0123456789ABCDEF";
switch (ModelNumber)
{
case DYMO_3x0 :
if (Buffer[0] ||
memcmp(Buffer, Buffer + 1, header->cupsBytesPerLine - 1))
{
if (Feed)
{
while (Feed > 255)
{
printf("\033f\001%c", 255);
Feed -= 255;
}
printf("\033f\001%c", Feed);
Feed = 0;
}
putchar(0x16);
fwrite(Buffer, header->cupsBytesPerLine, 1, stdout);
fflush(stdout);
#ifdef __sgi
sginap(1);
#endif
}
else
Feed ++;
break;
case ZEBRA_EPL_LINE :
printf("\033g%03d", header->cupsBytesPerLine);
fwrite(Buffer, 1, header->cupsBytesPerLine, stdout);
fflush(stdout);
break;
case ZEBRA_EPL_PAGE :
if (Buffer[0] || memcmp(Buffer, Buffer + 1, header->cupsBytesPerLine))
{
printf("GW0,%d,%d,1\n", y, header->cupsBytesPerLine);
for (i = header->cupsBytesPerLine, ptr = Buffer; i > 0; i --, ptr ++)
putchar(~*ptr);
putchar('\n');
fflush(stdout);
}
break;
case ZEBRA_ZPL :
if (LastSet)
{
if (!memcmp(Buffer, LastBuffer, header->cupsBytesPerLine))
{
putchar(':');
return;
}
}
for (ptr = Buffer, compptr = CompBuffer, i = header->cupsBytesPerLine;
i > 0;
i --, ptr ++)
{
*compptr++ = hex[*ptr >> 4];
*compptr++ = hex[*ptr & 15];
}
*compptr = '\0';
for (compptr = CompBuffer + 1, repeat_char = CompBuffer[0], repeat_count = 1;
*compptr;
compptr ++)
if (*compptr == repeat_char)
repeat_count ++;
else
{
ZPLCompress(repeat_char, repeat_count);
repeat_char = *compptr;
repeat_count = 1;
}
if (repeat_char == '0')
{
if (repeat_count & 1)
{
repeat_count --;
putchar('0');
}
if (repeat_count > 0)
putchar(',');
}
else
ZPLCompress(repeat_char, repeat_count);
fflush(stdout);
memcpy(LastBuffer, Buffer, header->cupsBytesPerLine);
LastSet = 1;
break;
case ZEBRA_CPCL :
if (Buffer[0] || memcmp(Buffer, Buffer + 1, header->cupsBytesPerLine))
{
printf("CG %u 1 0 %d ", header->cupsBytesPerLine, y);
fwrite(Buffer, 1, header->cupsBytesPerLine, stdout);
puts("\r");
fflush(stdout);
}
break;
case INTELLITECH_PCL :
if (Buffer[0] ||
memcmp(Buffer, Buffer + 1, header->cupsBytesPerLine - 1))
{
if (Feed)
{
printf("\033*b%dY", Feed);
Feed = 0;
LastSet = 0;
}
PCLCompress(Buffer, header->cupsBytesPerLine);
}
else
Feed ++;
break;
}
}
void
PCLCompress(unsigned char *line,
int length)
{
unsigned char *line_ptr,
*line_end,
*comp_ptr,
*start,
*seed;
int count,
offset;
line_ptr = line;
line_end = line + length;
comp_ptr = CompBuffer;
seed = LastBuffer;
while (line_ptr < line_end)
{
start = line_ptr;
if (!LastSet)
{
offset = 0;
if ((count = line_end - line_ptr) > 8)
count = 8;
line_ptr += count;
}
else
{
while (*line_ptr == *seed &&
line_ptr < line_end)
{
line_ptr ++;
seed ++;
}
if (line_ptr == line_end)
break;
offset = line_ptr - start;
start = line_ptr;
count = 0;
while (*line_ptr != *seed &&
line_ptr < line_end &&
count < 8)
{
line_ptr ++;
seed ++;
count ++;
}
}
if (offset >= 31)
{
*comp_ptr++ = ((count - 1) << 5) | 31;
offset -= 31;
while (offset >= 255)
{
*comp_ptr++ = 255;
offset -= 255;
}
*comp_ptr++ = offset;
}
else
{
*comp_ptr++ = ((count - 1) << 5) | offset;
}
memcpy(comp_ptr, start, count);
comp_ptr += count;
}
printf("\033*b%dW", (int)(comp_ptr - CompBuffer));
fwrite(CompBuffer, comp_ptr - CompBuffer, 1, stdout);
memcpy(LastBuffer, line, length);
LastSet = 1;
}
void
ZPLCompress(char repeat_char,
int repeat_count)
{
if (repeat_count > 1)
{
while (repeat_count >= 400)
{
putchar('z');
repeat_count -= 400;
}
if (repeat_count >= 20)
{
putchar('f' + repeat_count / 20);
repeat_count %= 20;
}
if (repeat_count > 0)
putchar('F' + repeat_count);
}
putchar(repeat_char);
}
int
main(int argc,
char *argv[])
{
int fd;
cups_raster_t *ras;
cups_page_header2_t header;
int y;
ppd_file_t *ppd;
int num_options;
cups_option_t *options;
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action;
#endif
setbuf(stderr, NULL);
if (argc < 6 || argc > 7)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("%s job-id user title copies options [file]"),
"rastertolabel");
return (1);
}
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);
Canceled = 0;
#ifdef HAVE_SIGSET
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
num_options = cupsParseOptions(argv[5], 0, &options);
ppd = ppdOpenFile(getenv("PPD"));
if (!ppd)
{
ppd_status_t status;
int linenum;
_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);
Setup(ppd);
Page = 0;
while (cupsRasterReadHeader2(ras, &header))
{
if (Canceled)
break;
Page ++;
fprintf(stderr, "PAGE: %d 1\n", Page);
_cupsLangPrintFilter(stderr, "INFO", _("Starting page %d."), Page);
StartPage(ppd, &header);
for (y = 0; y < header.cupsHeight && !Canceled; y ++)
{
if (Canceled)
break;
if ((y & 15) == 0)
{
_cupsLangPrintFilter(stderr, "INFO",
_("Printing page %d, %d%% complete."),
Page, 100 * y / header.cupsHeight);
fprintf(stderr, "ATTR: job-media-progress=%d\n",
100 * y / header.cupsHeight);
}
if (cupsRasterReadPixels(ras, Buffer, header.cupsBytesPerLine) < 1)
break;
OutputLine(ppd, &header, y);
}
_cupsLangPrintFilter(stderr, "INFO", _("Finished page %d."), Page);
EndPage(ppd, &header);
if (Canceled)
break;
}
cupsRasterClose(ras);
if (fd != 0)
close(fd);
ppdClose(ppd);
cupsFreeOptions(num_options, options);
if (Page == 0)
{
_cupsLangPrintFilter(stderr, "ERROR", _("No pages were found."));
return (1);
}
else
{
_cupsLangPrintFilter(stderr, "INFO", _("Ready to print."));
return (0);
}
}