/*============================================================================= pamenlarge =============================================================================== By Bryan Henderson 2004.09.26. Contributed to the public domain by its author. =============================================================================*/ #include "netpbm/mallocvar.h" #include "netpbm/pm_c_util.h" #include "netpbm/pam.h" #include "netpbm/pbm.h" struct cmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ const char *inputFilespec; unsigned int scaleFactor; }; static void parseCommandLine(int const argc, const char ** const argv, struct cmdlineInfo * const cmdlineP) { /*---------------------------------------------------------------------------- Note that the file spec array we return is stored in the storage that was passed to us as the argv array. -----------------------------------------------------------------------------*/ if (argc-1 < 1) pm_error("You must specify at least one argument: The scale factor"); else { cmdlineP->scaleFactor = atoi(argv[1]); if (cmdlineP->scaleFactor < 1) pm_error("Scale factor must be an integer at least 1. " "You specified '%s'", argv[1]); if (argc-1 >= 2) cmdlineP->inputFilespec = argv[2]; else cmdlineP->inputFilespec = "-"; } } static void makeOutputRowMap(tuple ** const outTupleRowP, struct pam * const outpamP, struct pam * const inpamP, tuple * const inTuplerow) { /*---------------------------------------------------------------------------- Create a tuple *outTupleRowP which is actually a row of pointers into inTupleRow[], so as to map input pixels to output pixels by stretching. -----------------------------------------------------------------------------*/ tuple * newtuplerow; int col; MALLOCARRAY_NOFAIL(newtuplerow, outpamP->width); for (col = 0 ; col < inpamP->width; ++col) { unsigned int const scaleFactor = outpamP->width / inpamP->width; unsigned int subcol; for (subcol = 0; subcol < scaleFactor; ++subcol) newtuplerow[col * scaleFactor + subcol] = inTuplerow[col]; } *outTupleRowP = newtuplerow; } static void validateComputableDimensions(unsigned int const width, unsigned int const height, unsigned int const scaleFactor) { /*---------------------------------------------------------------------------- Make sure that multiplication for output image width and height do not overflow. See validateComputetableSize() in libpam.c and pbm_readpbminitrest() in libpbm2.c -----------------------------------------------------------------------------*/ unsigned int const maxWidthHeight = INT_MAX - 2; unsigned int const maxScaleFactor = maxWidthHeight / MAX(height, width); if (scaleFactor > maxScaleFactor) pm_error("Scale factor '%u' too large. " "The maximum for this %u x %u input image is %u.", scaleFactor, width, height, maxScaleFactor); } static void enlargePbmRowHorizontally(struct pam * const inpamP, const unsigned char * const inrow, unsigned int const inColChars, unsigned int const outColChars, unsigned int const scaleFactor, unsigned char * const outrow) { static unsigned char const dbl[16] = { 0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F, 0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF }; static unsigned char const trp1[8] = { 0x00, 0x03, 0x1C, 0x1F, 0xE0, 0xE3, 0xFC, 0xFF }; static unsigned char const trp2[16] = { 0x00, 0x01, 0x0E, 0x0F, 0x70, 0x71, 0x7E, 0x7F, 0x80, 0x81, 0x8E, 0x8F, 0xF0, 0xF1, 0xFE, 0xFF }; static unsigned char const trp3[8] = { 0x00, 0x07, 0x38, 0x3F, 0xC0, 0xC7, 0xF8, 0xFF }; static unsigned char const quad[4] = { 0x00, 0x0F, 0xF0, 0xFF }; static unsigned char const quin2[8] = { 0x00, 0x01, 0x3E, 0x3F, 0xC0, 0xC1, 0xFE, 0xFF }; static unsigned char const quin4[8] = { 0x00, 0x03, 0x7C, 0x7F, 0x80, 0x83, 0xFC, 0xFF }; static unsigned int const pair[4] = { 0x0000, 0x00FF, 0xFF00, 0xFFFF }; unsigned int colChar; switch (scaleFactor) { case 1: break; /* outrow set to inrow */ case 2: /* Make outrow using prefabricated parts (same for 3, 5). */ for (colChar = 0; colChar < inColChars; ++colChar) { outrow[colChar*2] = dbl[(inrow[colChar] & 0xF0) >> 4]; outrow[colChar*2+1] = dbl[(inrow[colChar] & 0x0F) >> 0]; /* Possible outrow overrun by one byte. */ } break; case 3: for (colChar = 0; colChar < inColChars; ++colChar) { outrow[colChar*3] = trp1[(inrow[colChar] & 0xF0) >> 5]; outrow[colChar*3+1] = trp2[(inrow[colChar] >> 2) & 0x0F]; outrow[colChar*3+2] = trp3[(inrow[colChar] >> 0) & 0x07]; } break; case 4: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned int i; for (i = 0; i < 4; ++i) outrow[colChar*4+i]= quad[(inrow[colChar] >> (6 - 2 * i)) & 0x03]; } break; case 5: for (colChar = 0; colChar < inColChars; ++colChar) { outrow[colChar*5] = pair [(inrow[colChar] >> 6) & 0x03] >> 5; outrow[colChar*5+1] = quin2[(inrow[colChar] >> 4) & 0x07] >> 0; outrow[colChar*5+2] = quad [(inrow[colChar] >> 3) & 0x03] >> 0; outrow[colChar*5+3] = quin4[(inrow[colChar] >> 1) & 0x07] >> 0; outrow[colChar*5+4] = pair [(inrow[colChar] >> 0) & 0x03] >> 3; } break; case 6: /* Compound of 2 and 3 */ for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const hi = dbl[(inrow[colChar] & 0xF0) >> 4]; unsigned char const lo = dbl[(inrow[colChar] & 0x0F) >> 0]; outrow[colChar*6] = trp1[(hi & 0xF0) >> 5]; outrow[colChar*6+1] = trp2[(hi >> 2) & 0x0F]; outrow[colChar*6+2] = trp3[hi & 0x07]; outrow[colChar*6+3] = trp1[(lo & 0xF0) >> 5]; outrow[colChar*6+4] = trp2[(lo >> 2) & 0x0F]; outrow[colChar*6+5] = trp3[lo & 0x07]; } break; case 7: for (colChar = 0; colChar < inColChars; ++colChar) { uint32_t hi, lo; hi = inrow[colChar] >> 4; hi = ((((hi>>1) * 0x00082080) | (0x01 & hi)) & 0x00204081 ) * 0x7F; hi >>= 4; outrow[colChar*7] = (unsigned char) ( hi >> 16); outrow[colChar*7+1] = (unsigned char) ((hi >> 8) & 0xFF); outrow[colChar*7+2] = (unsigned char) ((hi >> 0) & 0xFF); lo = inrow[colChar] & 0x001F; lo = ((((lo>>1) * 0x02082080) | (0x01 & lo)) & 0x10204081 ) * 0x7F; outrow[colChar*7+3] = (unsigned char) ((lo >> 24) & 0xFF); outrow[colChar*7+4] = (unsigned char) ((lo >> 16) & 0xFF); outrow[colChar*7+5] = (unsigned char) ((lo >> 8) & 0xFF); outrow[colChar*7+6] = (unsigned char) ((lo >> 0) & 0xFF); } break; case 8: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned int i; for (i = 0; i < 8; ++i) { outrow[colChar*8+i] = ((inrow[colChar] >> (7-i)) & 0x01) *0xFF; } } break; case 9: for (colChar = 0; colChar < inColChars; ++colChar) { outrow[colChar*9] = ((inrow[colChar] >> 7) & 0x01) * 0xFF; outrow[colChar*9+1] = pair[(inrow[colChar] >> 6) & 0x03] >> 1; outrow[colChar*9+2] = pair[(inrow[colChar] >> 5) & 0x03] >> 2; outrow[colChar*9+3] = pair[(inrow[colChar] >> 4) & 0x03] >> 3; outrow[colChar*9+4] = pair[(inrow[colChar] >> 3) & 0x03] >> 4; outrow[colChar*9+5] = pair[(inrow[colChar] >> 2) & 0x03] >> 5; outrow[colChar*9+6] = pair[(inrow[colChar] >> 1) & 0x03] >> 6; outrow[colChar*9+7] = pair[(inrow[colChar] >> 0) & 0x03] >> 7; outrow[colChar*9+8] = (inrow[colChar] & 0x01) * 0xFF; } break; case 10: for (colChar = 0; colChar < inColChars; ++colChar) { outrow[colChar*10] = ((inrow[colChar] >> 7) & 0x01 ) * 0xFF; outrow[colChar*10+1] = pair[(inrow[colChar] >> 6) & 0x03] >> 2; outrow[colChar*10+2] = pair[(inrow[colChar] >> 5) & 0x03] >> 4; outrow[colChar*10+3] = pair[(inrow[colChar] >> 4) & 0x03] >> 6; outrow[colChar*10+4] = ((inrow[colChar] >> 4) & 0x01) * 0xFF; outrow[colChar*10+5] = ((inrow[colChar] >> 3) & 0x01) * 0xFF; outrow[colChar*10+6] = pair[(inrow[colChar] >> 2) & 0x03] >> 2; outrow[colChar*10+7] = pair[(inrow[colChar] >> 1) & 0x03] >> 4; outrow[colChar*10+8] = pair[(inrow[colChar] >> 0) & 0x03] >> 6; outrow[colChar*10+9] = ((inrow[colChar] >> 0) & 0x01) * 0xFF; } break; default: /* Unlike the above cases, we iterate through outrow. To compute the color composition of each outrow byte, we consult a single bit or two consecutive bits in inrow. Color changes never happen twice in a single outrow byte. This is a generalization of above routines for scale factors 9 and 10. Logic works for scale factors 4, 6, 7, 8, and above (but not 5). */ for (colChar = 0; colChar < outColChars; ++colChar) { unsigned int const mult = scaleFactor; unsigned int const mod = colChar % mult; unsigned int const bit = (mod*8)/mult; /* source bit position, leftmost=0 */ unsigned int const offset = mult - (mod*8)%mult; /* number of outrow bits derived from the same "source" inrow bit, starting at and to the right of leftmost bit of outrow byte, inclusive */ if (offset >= 8) /* Bits in outrow byte are all 1 or 0 */ outrow[colChar] = (inrow[colChar/mult] >> (7-bit) & 0x01) * 0xFF; else /* Two inrow bits influence this outrow byte */ outrow[colChar] = (unsigned char) (pair[inrow[colChar/mult] >> (6-bit) & 0x03] >> offset) & 0xFF; } } } static void enlargePbm(struct pam * const inpamP, unsigned int const scaleFactor, FILE * const ofP) { unsigned char * inrow; unsigned char * outrow; unsigned int row; unsigned int const outcols = inpamP->width * scaleFactor; unsigned int const outrows = inpamP->height * scaleFactor; unsigned int const inColChars = pbm_packed_bytes(inpamP->width); unsigned int const outColChars = pbm_packed_bytes(outcols); inrow = pbm_allocrow_packed(inpamP->width); if (scaleFactor == 1) outrow = inrow; else { /* Allow writes beyond outrow data end when scaleFactor is one of the special fast cases: 2, 3, 4, 5, 6, 7, 8, 9, 10. */ unsigned int const rightPadding = scaleFactor > 10 ? 0 : (scaleFactor - 1) * 8; outrow = pbm_allocrow_packed(outcols + rightPadding); } pbm_writepbminit(ofP, outcols, outrows, 0); for (row = 0; row < inpamP->height; ++row) { unsigned int i; pbm_readpbmrow_packed(inpamP->file, inrow, inpamP->width, inpamP->format); if (outcols % 8 > 0) /* clean final partial byte */ pbm_cleanrowend_packed(inrow, inpamP->width); enlargePbmRowHorizontally(inpamP, inrow, inColChars, outColChars, scaleFactor, outrow); for (i = 0; i < scaleFactor; ++i) pbm_writepbmrow_packed(ofP, outrow, outcols, 0); } if (outrow != inrow) pbm_freerow(outrow); pbm_freerow(inrow); } static void enlargeGeneral(struct pam * const inpamP, unsigned int const scaleFactor, FILE * const ofP) { /*---------------------------------------------------------------------------- Enlarge the input image described by *pamP. Assume the dimensions won't cause an arithmetic overflow. This works on all kinds of images, but is slower than enlargePbm on PBM. -----------------------------------------------------------------------------*/ struct pam outpam; tuple * tuplerow; tuple * newtuplerow; unsigned int row; outpam = *inpamP; outpam.file = ofP; outpam.width = inpamP->width * scaleFactor; outpam.height = inpamP->height * scaleFactor; pnm_writepaminit(&outpam); tuplerow = pnm_allocpamrow(inpamP); makeOutputRowMap(&newtuplerow, &outpam, inpamP, tuplerow); for (row = 0; row < inpamP->height; ++row) { pnm_readpamrow(inpamP, tuplerow); pnm_writepamrowmult(&outpam, newtuplerow, scaleFactor); } free(newtuplerow); pnm_freepamrow(tuplerow); } int main(int argc, const char ** argv) { struct cmdlineInfo cmdline; FILE * ifP; struct pam inpam; pm_proginit(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFilespec); pnm_readpaminit(ifP, &inpam, PAM_STRUCT_SIZE(tuple_type)); validateComputableDimensions(inpam.width, inpam.height, cmdline.scaleFactor); if (PNM_FORMAT_TYPE(inpam.format) == PBM_TYPE) enlargePbm(&inpam, cmdline.scaleFactor, stdout); else enlargeGeneral(&inpam, cmdline.scaleFactor, stdout); pm_close(ifP); pm_close(stdout); return 0; }