static void
doPartialBlockTop(const struct pam * const inpamP,
bit ** const inrow,
const bit * const blockPartial[16],
unsigned int const topOfFullBlock,
uint16_t ** const outplane) {
if (topOfFullBlock > 0) {
unsigned int colChar, row;
unsigned int pad = 16 - topOfFullBlock;
for (colChar=0; colChar < pbm_packed_bytes(inpamP->width); ++colChar)
inrow[0][colChar] = 0x00;
for (row = 0; row < topOfFullBlock; ++row){
pbm_readpbmrow_packed(inpamP->file, inrow[row+pad],
inpamP->width, inpamP->format);
if (inpamP->width % 8 > 0){
/* Clear partial byte at end of input row */
int const lastByte = pbm_packed_bytes(inpamP->width) -1;
inrow[row+pad][lastByte] >>= (8 - inpamP->width % 8);
inrow[row+pad][lastByte] <<= (8 - inpamP->width % 8);
}
}
static void
readOffBorderPbm(unsigned int const height,
FILE * const ifP,
unsigned int const cols,
int const format) {
unsigned char * bitrow;
unsigned int i;
bitrow = pbm_allocrow_packed(cols);
for (i = 0; i < height; ++i)
pbm_readpbmrow_packed(ifP, bitrow, cols, format);
pbm_freerow_packed(bitrow);
}
int
main(int argc, char* argv[]) {
FILE* ifP;
int rows, cols;
int format;
unsigned int row, idx, len;
unsigned int h, v;
unsigned char *bytes, *cprbytes;
struct cmdlineInfo cmdline;
pbm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
pbm_readpbminit(ifP, &cols, &rows, &format);
bytes = malloc(24*pbm_packed_bytes(cols)+2);
cprbytes = malloc(2*24*pbm_packed_bytes(cols));
if (bytes == NULL || cprbytes == NULL)
pm_error("Cannot allocate memory");
h = v = 3600/cmdline.resolution;
/* Set raster graphic mode. */
printf("%c%c%c%c%c%c", esc, '(', 'G', 1, 0, 1);
/* Set line spacing in units of 1/360 inches. */
printf("%c%c%c", esc, '+', 24*h/10);
/* Write out raster stripes 24 rows high. */
for (row = 0; row < rows; row += 24) {
unsigned int const linesThisStripe = (rows-row<24) ? rows%24 : 24;
printf("%c%c%c%c%c%c%c%c", esc, '.', cmdline.compress,
v, h, linesThisStripe,
cols%256, cols/256);
/* Read pbm rows, each padded to full byte */
for (idx = 0; idx < 24 && row+idx < rows; ++idx)
pbm_readpbmrow_packed(ifP,bytes+idx*pbm_packed_bytes(cols),
cols,format);
/* Write raster data. */
if (cmdline.compress != 0) {
/* compressed */
len = enc_epson_rle(linesThisStripe * pbm_packed_bytes(cols),
bytes, cprbytes);
fwrite(cprbytes,len,1,stdout);
} else
/* uncompressed */
fwrite(bytes, pbm_packed_bytes(cols), linesThisStripe, stdout);
if (rows-row >= 24) putchar('\n');
}
free(bytes); free(cprbytes);
pm_close(ifP);
/* Reset printer. */
printf("%c%c", esc, '@');
return 0;
}
int
main(int argc, const char * argv[]) {
FILE * ifP;
int rows, cols;
int format;
unsigned int row;
unsigned int idx;
unsigned int outColByteCt;
unsigned int stripeByteCt;
unsigned int hres, vres;
unsigned char * inBuff;
unsigned char * bitrow[256];
unsigned char * compressedData;
struct CmdlineInfo cmdline;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
pbm_readpbminit(ifP, &cols, &rows, &format);
if (cols / 256 > 127) /* Limit in official Epson manual */
pm_error("Image width is too large");
outColByteCt = pbm_packed_bytes(cols);
stripeByteCt = cmdline.stripeHeight * outColByteCt;
MALLOCARRAY(inBuff, stripeByteCt);
if (inBuff == NULL)
pm_error("Out of memory trying to create input buffer of %u bytes",
stripeByteCt);
if (cmdline.compress != 0)
pm_rlenc_allocoutbuf(&compressedData, stripeByteCt, PM_RLE_PACKBITS);
else
compressedData = NULL;
for (idx = 0; idx <= cmdline.stripeHeight; ++idx)
bitrow[idx]= &inBuff[idx * outColByteCt];
hres = vres = 3600 / cmdline.resolution;
/* Possible values for hres, vres: 20, 10, 5 */
if (!cmdline.raw)
writeSetup(hres);
/* Write out raster stripes */
for (row = 0; row < rows; row += cmdline.stripeHeight ) {
unsigned int const rowsThisStripe =
MIN(rows - row, cmdline.stripeHeight);
unsigned int const outCols = outColByteCt * 8;
if (rowsThisStripe > 0) {
unsigned int idx;
printf("%c%c%c%c%c%c%c%c", esc, '.', cmdline.compress, vres, hres,
cmdline.stripeHeight, outCols % 256, outCols / 256);
/* Read pbm rows, each padded to full byte */
for (idx = 0; idx < rowsThisStripe; ++idx) {
pbm_readpbmrow_packed (ifP, bitrow[idx], cols, format);
pbm_cleanrowend_packed(bitrow[idx], cols);
}
/* If at bottom pad with empty rows up to stripe height */
if (rowsThisStripe < cmdline.stripeHeight )
memset(bitrow[rowsThisStripe], 0,
(cmdline.stripeHeight - rowsThisStripe) * outColByteCt);
/* Write raster data */
if (cmdline.compress != 0) { /* compressed */
size_t compressedDataCt;
pm_rlenc_compressbyte(inBuff, compressedData, PM_RLE_PACKBITS,
stripeByteCt, &compressedDataCt);
fwrite(compressedData, compressedDataCt, 1, stdout);
} else /* uncompressed */
fwrite(inBuff, stripeByteCt, 1, stdout);
/* Emit newline to print the stripe */
putchar('\n');
}
}
free(inBuff);
free(compressedData);
pm_close(ifP);
/* Form feed */
if (cmdline.formfeed)
putchar('\f');
if (!cmdline.raw) {
/* Reset printer. a*/
printf("%c%c", esc, '@');
}
return 0;
}
