/*============================================================================= pamenlarge =============================================================================== By Bryan Henderson 2004.09.26. Contributed to the public domain by its author. The design and code for the fast processing of PBMs is by Akira Urushibata in March 2010 and substantially improved in February 2019. =============================================================================*/ #include #include #include "netpbm/mallocvar.h" #include "netpbm/pm_c_util.h" #include "netpbm/pam.h" #include "netpbm/pbm.h" #include "netpbm/shhopt.h" #include "netpbm/nstring.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 xScaleFactor; unsigned int yScaleFactor; }; static void parseCommandLine(int argc, const char ** argv, struct CmdlineInfo * cmdlineP) { /*---------------------------------------------------------------------------- Note that the file spec array we return is stored in the storage that was passed to us as the argv array. -----------------------------------------------------------------------------*/ optStruct3 opt; /* set by OPTENT3 */ optEntry * option_def; unsigned int option_def_index; unsigned int scale; unsigned int xscaleSpec; unsigned int yscaleSpec; unsigned int scaleSpec; MALLOCARRAY_NOFAIL(option_def, 100); option_def_index = 0; /* incremented by OPTENTRY */ OPTENT3(0, "xscale", OPT_UINT, &cmdlineP->xScaleFactor, &xscaleSpec, 0); OPTENT3(0, "yscale", OPT_UINT, &cmdlineP->yScaleFactor, &yscaleSpec, 0); OPTENT3(0, "scale", OPT_UINT, &scale, &scaleSpec, 0); opt.opt_table = option_def; opt.short_allowed = false; /* We have some short (old-fashioned) options */ opt.allowNegNum = false; /* We have no parms that are negative numbers */ pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0); /* Uses and sets argc, argv, and some of *cmdlineP and others. */ if (scaleSpec && scale == 0) pm_error("-scale must be positive. You specified zero"); if (xscaleSpec && cmdlineP->xScaleFactor == 0) pm_error("-xscale must be positive. You specified zero"); if (yscaleSpec && cmdlineP->yScaleFactor == 0) pm_error("-yscale must be positive. You specified zero"); if (scaleSpec && xscaleSpec) pm_error("You cannot specify both -scale and -xscale"); if (scaleSpec && yscaleSpec) pm_error("You cannot specify both -scale and -yscale"); if (scaleSpec) { cmdlineP->xScaleFactor = scale; cmdlineP->yScaleFactor = scale; } if (xscaleSpec && !yscaleSpec) cmdlineP->yScaleFactor = 1; if (yscaleSpec && !xscaleSpec) cmdlineP->xScaleFactor = 1; if (scaleSpec || xscaleSpec || yscaleSpec) { /* Scale options specified. Naked scale argument not allowed */ if ((argc-1) > 1) pm_error("Too many arguments (%u). With a scale option, " "the only argument is the " "optional file specification", argc-1); if (argc-1 > 0) cmdlineP->inputFilespec = argv[1]; else cmdlineP->inputFilespec = "-"; } else { /* scale must be specified in an argument */ if ((argc-1) != 1 && (argc-1) != 2) pm_error("Wrong number of arguments (%d). Without scale options, " "you must supply 1 or 2 arguments: scale and " "optional file specification", argc-1); { const char * error; /* error message of pm_string_to_uint */ unsigned int scale; pm_string_to_uint(argv[1], &scale, &error); if (error == NULL) { if (scale == 0) pm_error("Scale argument must be positive. " "You specified zero"); else cmdlineP->xScaleFactor = cmdlineP->yScaleFactor = scale; } else pm_error("Invalid scale factor: %s", error); } if (argc-1 > 1) cmdlineP->inputFilespec = argv[2]; else cmdlineP->inputFilespec = "-"; } free(option_def); } 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 xScaleFactor, unsigned int const yScaleFactor) { /*---------------------------------------------------------------------------- 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); unsigned int const greaterScaleFactor = MAX(xScaleFactor, yScaleFactor); if (greaterScaleFactor > maxScaleFactor) pm_error("Scale factor '%u' too large. " "The maximum for this %u x %u input image is %u.", greaterScaleFactor, width, height, maxScaleFactor); } static unsigned char const pair[7][4] = { { 0x00 , 0x7F , 0x80 , 0xFF}, { 0x00 , 0x3F , 0xC0 , 0xFF}, { 0x00 , 0x1F , 0xE0 , 0xFF}, { 0x00 , 0x0F , 0xF0 , 0xFF}, { 0x00 , 0x07 , 0xF8 , 0xFF}, { 0x00 , 0x03 , 0xFC , 0xFF}, { 0x00 , 0x01 , 0xFE , 0xFF} }; static void enlargePbmRowHorizontallySmall(const unsigned char * const inrow, unsigned int const inColChars, unsigned int const xScaleFactor, unsigned char * const outrow) { /*---------------------------------------------------------------------------- Fast routines for scale factors 1-13. Using a temp value "inrowChar" makes a difference. We know that inrow and outrow don't overlap, but the compiler does not and emits code which reads inrow[colChar] each time fearing that a write to outrow[x] may have altered the value. (The first "const" for inrow in the above argument list is not enough for the compiler.) -----------------------------------------------------------------------------*/ 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 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 char const * quad = pair[3]; unsigned int colChar; switch (xScaleFactor) { case 1: break; /* outrow set to inrow */ case 2: /* Make outrow using prefabricated parts (same for 3, 5). */ for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*2] = dbl[ inrowChar >> 4]; outrow[colChar*2+1] = dbl[(inrowChar & 0x0F) >> 0]; /* Possible outrow overrun by one byte. */ } break; case 3: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*3] = trp1[ inrowChar >> 5]; outrow[colChar*3+1] = trp2[(inrowChar >> 2) & 0x0F]; outrow[colChar*3+2] = trp3[(inrowChar >> 0) & 0x07]; } break; case 4: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; unsigned int i; for (i = 0; i < 4; ++i) outrow[colChar*4+i] = quad[(inrowChar >> (6 - 2 * i)) & 0x03]; } break; case 5: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*5] = pair [4][(inrowChar >> 6) & 0x03]; outrow[colChar*5+1] = quin2[(inrowChar >> 4) & 0x07] >> 0; outrow[colChar*5+2] = quad [(inrowChar >> 3) & 0x03] >> 0; outrow[colChar*5+3] = quin4[(inrowChar >> 1) & 0x07] >> 0; outrow[colChar*5+4] = pair [2][(inrowChar >> 0) & 0x03]; } break; case 6: /* Compound of 2 and 3 */ for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; unsigned char const hi = dbl[(inrowChar & 0xF0) >> 4]; unsigned char const lo = dbl[(inrowChar & 0x0F) >> 0]; outrow[colChar*6] = trp1[hi >> 5]; outrow[colChar*6+1] = trp2[(hi >> 2) & 0x0F]; outrow[colChar*6+2] = trp3[hi & 0x07]; outrow[colChar*6+3] = trp1[lo >> 5]; outrow[colChar*6+4] = trp2[(lo >> 2) & 0x0F]; outrow[colChar*6+5] = trp3[lo & 0x07]; } break; case 7: /* This approach can be used for other scale values. Good for architectures which provide wide registers such as SSE. */ for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; uint32_t hi, lo; hi = inrowChar >> 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 = inrowChar & 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 char const inrowChar = inrow[colChar]; unsigned int i; for (i = 0; i < 8; ++i) { outrow[colChar*8+i] = ((inrowChar >> (7-i)) & 0x01) *0xFF; } } break; case 9: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*9] = ((inrowChar >> 7) & 0x01) * 0xFF; outrow[colChar*9+1] = pair[0][(inrowChar >> 6) & 0x03]; outrow[colChar*9+2] = pair[1][(inrowChar >> 5) & 0x03]; outrow[colChar*9+3] = pair[2][(inrowChar >> 4) & 0x03]; outrow[colChar*9+4] = pair[3][(inrowChar >> 3) & 0x03]; outrow[colChar*9+5] = pair[4][(inrowChar >> 2) & 0x03]; outrow[colChar*9+6] = pair[5][(inrowChar >> 1) & 0x03]; outrow[colChar*9+7] = pair[6][(inrowChar >> 0) & 0x03]; outrow[colChar*9+8] = (inrowChar & 0x01) * 0xFF; } break; case 10: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*10] = ((inrowChar >> 7) & 0x01 ) * 0xFF; outrow[colChar*10+1] = pair[1][(inrowChar >> 6) & 0x03]; outrow[colChar*10+2] = quad[(inrowChar >> 5) & 0x03]; outrow[colChar*10+3] = pair[5][(inrowChar >> 4) & 0x03]; outrow[colChar*10+4] = ((inrowChar >> 4) & 0x01) * 0xFF; outrow[colChar*10+5] = ((inrowChar >> 3) & 0x01) * 0xFF; outrow[colChar*10+6] = pair[1][(inrowChar >> 2) & 0x03]; outrow[colChar*10+7] = quad[(inrowChar >> 1) & 0x03]; outrow[colChar*10+8] = pair[5][(inrowChar >> 0) & 0x03]; outrow[colChar*10+9] = ((inrowChar >> 0) & 0x01) * 0xFF; } break; case 11: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*11] = ((inrowChar >> 7) & 0x01 ) * 0xFF; outrow[colChar*11+1] = pair[2][(inrowChar >> 6) & 0x03]; outrow[colChar*11+2] = pair[5][(inrowChar >> 5) & 0x03]; outrow[colChar*11+3] = ((inrowChar >> 5) & 0x01) * 0xFF; outrow[colChar*11+4] = pair[0][(inrowChar >> 4) & 0x03]; outrow[colChar*11+5] = quad[(inrowChar >> 3) & 0x03]; outrow[colChar*11+6] = pair[6][(inrowChar >> 2) & 0x03]; outrow[colChar*11+7] = ((inrowChar >> 2) & 0x01) * 0xFF; outrow[colChar*11+8] = pair[1][(inrowChar >> 1) & 0x03]; outrow[colChar*11+9] = pair[4][(inrowChar >> 0) & 0x03]; outrow[colChar*11+10] = ((inrowChar >> 0) & 0x01) * 0xFF; } break; case 12: for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*12+ 0] = ((inrowChar >> 7) & 0x01) * 0xFF; outrow[colChar*12+ 1] = quad[(inrowChar >> 6) & 0x03]; outrow[colChar*12+ 2] = ((inrowChar >> 6) & 0x01) * 0xFF; outrow[colChar*12+ 3] = ((inrowChar >> 5) & 0x01) * 0xFF; outrow[colChar*12+ 4] = quad[(inrowChar >> 4) & 0x03]; outrow[colChar*12+ 5] = ((inrowChar >> 4) & 0x01) * 0xFF; outrow[colChar*12+ 6] = ((inrowChar >> 3) & 0x01) * 0xFF; outrow[colChar*12+ 7] = quad[(inrowChar >> 2) & 0x03]; outrow[colChar*12+ 8] = ((inrowChar >> 2) & 0x01) * 0xFF; outrow[colChar*12+ 9] = ((inrowChar >> 1) & 0x01) * 0xFF; outrow[colChar*12+10] = quad[(inrowChar >> 0) & 0x03]; outrow[colChar*12+11] = ((inrowChar >> 0) & 0x01) * 0xFF; } break; case 13: /* Math quiz: 13 is the last entry here. Is this an arbitrary choice? Or is there something which makes 13 necessary? If you like working on questions like this you may like number/group theory. However don't expect a straightforward answer from a college math textbook. - afu */ for (colChar = 0; colChar < inColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; outrow[colChar*13+ 0] = ((inrowChar >> 7) & 0x01) * 0xFF; outrow[colChar*13+ 1] = pair[4][(inrowChar >> 6) & 0x03]; outrow[colChar*13+ 2] = ((inrowChar >> 6) & 0x01) * 0xFF; outrow[colChar*13+ 3] = pair[1][(inrowChar >> 5) & 0x03]; outrow[colChar*13+ 4] = pair[6][(inrowChar >> 4) & 0x03]; outrow[colChar*13+ 5] = ((inrowChar >> 4) & 0x01) * 0xFF; outrow[colChar*13+ 6] = quad[(inrowChar >> 3) & 0x03]; outrow[colChar*13+ 7] = ((inrowChar >> 3) & 0x01) * 0xFF; outrow[colChar*13+ 8] = pair[0][(inrowChar >> 2) & 0x03]; outrow[colChar*13+ 9] = pair[5][(inrowChar >> 1) & 0x03]; outrow[colChar*13+10] = ((inrowChar >> 1) & 0x01) * 0xFF; outrow[colChar*13+11] = pair[2][(inrowChar >> 0) & 0x03]; outrow[colChar*13+12] = ((inrowChar >> 0) & 0x01) * 0xFF; } break; default: pm_error("Internal error. Invalid scale factor for " "enlargePbmRowHorizontallySmall: %u", xScaleFactor); } } /* General method for scale values 14 and above First notice that all output characters are either entirely 0, entirely 1 or a combination with the change from 0->1 or 1->0 happening only once. (Sequences like 00111000 never appear when scale value is above 8). Let us call the chars which are entirely 0 or 1 "solid" and those which may potentially contain both "transitional". For scale values 6 - 14 each input character expands to output characters aligned as follows: 6 : TTTTTT 7 : TTTTTTT 8 : SSSSSSSS 9 : STTTTTTTS 10: STSTSSTSTS 11: STTSTTTSTTS 12: STSSTSSTSSTS 13: STSTTSTSTTSTS 14: STSTSTSSTSTSTS Above 15 we insert strings of solid chars as necessary: 22: SsTSsTSsTSsSsTSsTSsTSs 30: SssTSssTSssTSssSssTSssTSssTSss 38: SsssTSsssTSsssTSsssSsssTSsssTSsssTSsss */ struct OffsetInit { unsigned int scale; const char * alignment; }; static struct OffsetInit const offsetInit[8] = { /* 0: single char copied from output of enlargePbmRowHorizontallySmall() 1: stretch of solid chars Each entry is symmetrical left-right and has exactly eight '2's */ { 8, "22222222" }, /* 8n+0 */ { 9, "21121212121212112" }, /* 8n+1 */ { 10, "211212112211212112" }, /* 8n+2 */ { 11, "2112121121211212112" }, /* 8n+3 */ { 4, "212212212212" }, /* 8n+4 */ { 13, "211211211212112112112" }, /* 8n+5 */ { 6, "21212122121212" }, /* 8n+6 */ { 7, "212121212121212" } /* 8n+7 */ }; /* Relationship between 'S' 'T' in previous comment and '1' '2' here 11: STTSTTTSTTS 19: sSTsTsSTsTsTSsTsTSs 2112121121211212112 # table entry for 8n+3 27: ssSTssTssSTssTssTSssTssTSss 2*112*12*112*12*112*12*112* 35: sssSTsssTsssSTsssTsssTSsssTsssTSsss 2**112**12**112**12**112**12**112** 42: ssssSTssssTssssSTssssTssssTSssssTssssTSssss 2***112***12***112***12***112***12***112*** */ struct OffsetTable { unsigned int offsetSolid[8]; unsigned int offsetTrans[13]; unsigned int scale; unsigned int solidChars; }; static void setupOffsetTable(unsigned int const xScaleFactor, struct OffsetTable * const offsetTableP) { unsigned int i, j0, j1, dest; struct OffsetInit const classEntry = offsetInit[xScaleFactor % 8]; unsigned int const scale = classEntry.scale; unsigned int const solidChars = xScaleFactor / 8 - (scale > 8 ? 1 : 0); for (i = j0 = j1 = dest = 0; classEntry.alignment[i] != '\0'; ++i) { switch (classEntry.alignment[i]) { case '1': offsetTableP->offsetTrans[j0++] = dest++; break; case '2': offsetTableP->offsetSolid[j1++] = dest; dest += solidChars; break; default: pm_error("Internal error. Abnormal alignment value"); } } offsetTableP->scale = scale; offsetTableP->solidChars = solidChars; } static void enlargePbmRowFractional(unsigned char const inrowChar, unsigned int const outColChars, unsigned int const xScaleFactor, unsigned char * const outrow, struct OffsetTable * const tableP) { /*---------------------------------------------------------------------------- Routine called from enlargePbmRowHorizontallyGen() to process the final fractional inrow char. outrow : write position for this function (not left edge of entire row) ----------------------------------------------------------------------------*/ unsigned int i; /* Deploy (most) solid chars */ for (i = 0; i < 7; ++i) { unsigned int j; unsigned char const bit8 = (inrowChar >> (7 - i) & 0x01) * 0xFF; if (tableP->offsetSolid[i] >= outColChars) break; else for (j = 0; j < tableP->solidChars; ++j) { outrow[j + tableP->offsetSolid[i]] = bit8; } } /* If scale factor is a multiple of 8 we are done. */ if (tableP->scale != 8) { unsigned char outrowTemp[16]; enlargePbmRowHorizontallySmall(&inrowChar, 1, tableP->scale, outrowTemp); for (i = 0 ; i < tableP->scale; ++i) { unsigned int const offset = tableP->offsetTrans[i]; if (offset >= outColChars) break; else outrow[offset] = outrowTemp[i]; } } } static void enlargePbmRowHorizontallyGen(const unsigned char * const inrow, unsigned int const inColChars, unsigned int const outColChars, unsigned int const xScaleFactor, unsigned char * const outrow, struct OffsetTable * const tableP) { /*---------------------------------------------------------------------------- We iterate through inrow. Output chars are deployed according to offsetTable. All transitional chars and some solid chars are determined by calling one the fast routines in enlargePbmRowHorizontallySmall(). ----------------------------------------------------------------------------*/ unsigned int colChar; unsigned int const fullColChars = inColChars - ((inColChars * xScaleFactor == outColChars) ? 0 : 1); for (colChar = 0; colChar < fullColChars; ++colChar) { unsigned char const inrowChar = inrow[colChar]; char bit8[8]; unsigned int i; /* Deploy most solid chars Some scale factors yield uneven string lengths: in such cases we don't handle the odd solid chars at this point */ for (i = 0; i < 8; ++i) bit8[i] = (inrowChar >> (7 - i) & 0x01) * 0xFF; for (i = 0; i < tableP->solidChars; ++i) { unsigned int base = colChar * xScaleFactor + i; outrow[base] = bit8[0]; outrow[base + tableP->offsetSolid[1]] = bit8[1]; outrow[base + tableP->offsetSolid[2]] = bit8[2]; outrow[base + tableP->offsetSolid[3]] = bit8[3]; outrow[base + tableP->offsetSolid[4]] = bit8[4]; outrow[base + tableP->offsetSolid[5]] = bit8[5]; outrow[base + tableP->offsetSolid[6]] = bit8[6]; outrow[base + tableP->offsetSolid[7]] = bit8[7]; } /* If scale factor is a multiple of 8 we are done */ if (tableP->scale != 8) { /* Deploy transitional chars and any remaining solid chars */ unsigned char outrowTemp[16]; unsigned int base = colChar * xScaleFactor; enlargePbmRowHorizontallySmall(&inrowChar, 1, tableP->scale, outrowTemp); /* There are at least 4 valid entries in offsetTrans[] */ outrow[base + tableP->offsetTrans[0]] = outrowTemp[0]; outrow[base + tableP->offsetTrans[1]] = outrowTemp[1]; outrow[base + tableP->offsetTrans[2]] = outrowTemp[2]; outrow[base + tableP->offsetTrans[3]] = outrowTemp[3]; for (i = 4; i < tableP->scale; ++i) outrow[base + tableP->offsetTrans[i]] = outrowTemp[i]; } } /* Process the fractional final inrow byte */ if (fullColChars < inColChars) { unsigned int const start = fullColChars * xScaleFactor; unsigned char const inrowLast = inrow[inColChars -1]; enlargePbmRowFractional(inrowLast, outColChars - start, xScaleFactor, &outrow[start], tableP); } } static void enlargePbm(struct pam * const inpamP, unsigned int const xScaleFactor, unsigned int const yScaleFactor, FILE * const ofP) { enum ScaleMethod {METHOD_USEINPUT, METHOD_SMALL, METHOD_GENERAL}; enum ScaleMethod const scaleMethod = xScaleFactor == 1 ? METHOD_USEINPUT : xScaleFactor <= 13 ? METHOD_SMALL : METHOD_GENERAL; unsigned int const outcols = inpamP->width * xScaleFactor; unsigned int const outrows = inpamP->height * yScaleFactor; unsigned int const inColChars = pbm_packed_bytes(inpamP->width); unsigned int const outColChars = pbm_packed_bytes(outcols); unsigned char * inrow; unsigned char * outrow; unsigned int row; struct OffsetTable offsetTable; inrow = pbm_allocrow_packed(inpamP->width); if (scaleMethod == METHOD_USEINPUT) outrow = inrow; else { /* Allow writes beyond outrow data end when using the table method. */ unsigned int const rightPadding = scaleMethod == METHOD_GENERAL ? 0 : (xScaleFactor - 1) * 8; assert (outcols < UINT_MAX - rightPadding); outrow = pbm_allocrow_packed(outcols + rightPadding); if (scaleMethod == METHOD_GENERAL) setupOffsetTable(xScaleFactor, &offsetTable); } 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); switch (scaleMethod) { case METHOD_USEINPUT: /* Nothing to do */ break; case METHOD_SMALL: enlargePbmRowHorizontallySmall(inrow, inColChars, xScaleFactor, outrow); break; case METHOD_GENERAL: enlargePbmRowHorizontallyGen(inrow, inColChars, outColChars, xScaleFactor, outrow, &offsetTable); break; } for (i = 0; i < yScaleFactor; ++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 xScaleFactor, unsigned int const yScaleFactor, 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 * xScaleFactor; outpam.height = inpamP->height * yScaleFactor; 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, yScaleFactor); } free(newtuplerow); pnm_freepamrow(tuplerow); } int main(int argc, const char ** const 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)); assert(cmdline.xScaleFactor > 0); assert(cmdline.yScaleFactor > 0); validateComputableDimensions(inpam.width, inpam.height, cmdline.xScaleFactor, cmdline.yScaleFactor); if (PNM_FORMAT_TYPE(inpam.format) == PBM_TYPE) enlargePbm(&inpam, cmdline.xScaleFactor, cmdline.yScaleFactor, stdout); else enlargeGeneral(&inpam, cmdline.xScaleFactor, cmdline.yScaleFactor, stdout); pm_close(ifP); pm_close(stdout); return 0; }