diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /graphics/bm2font/bm2font.c |
Initial commit
Diffstat (limited to 'graphics/bm2font/bm2font.c')
-rw-r--r-- | graphics/bm2font/bm2font.c | 4932 |
1 files changed, 4932 insertions, 0 deletions
diff --git a/graphics/bm2font/bm2font.c b/graphics/bm2font/bm2font.c new file mode 100644 index 0000000000..6b69597d6f --- /dev/null +++ b/graphics/bm2font/bm2font.c @@ -0,0 +1,4932 @@ +/* Output from p2c, the Pascal-to-C translator */ +/* From input file "bm2font.pas" */ + + +/*1:*/ + +#include "p2c.h" +/* p2c: bm2font.pas, line 1: + * Note: Unexpected name "texfile" in program header [262] */ +/* p2c: bm2font.pas, line 1: + * Note: Unexpected name "tfmfile" in program header [262] */ +/* p2c: bm2font.pas, line 1: + * Note: Unexpected name "pxlfile" in program header [262] */ +/* p2c: bm2font.pas, line 1: + * Note: Unexpected name "bitmap" in program header [262] */ +/* p2c: bm2font.pas, line 1: + * Note: Unexpected name "tmpfil" in program header [262] */ + + +/*logfile,*/ + + +typedef uchar ebts; + +typedef short halfk; + +typedef long dynlong[52][129]; +typedef unsigned short dynword[52][129]; +typedef short korbyte[511]; +typedef short spreadbyte[256]; +/*55:*/ +typedef unsigned short pxlstr; + +typedef ebts pxla[65522L]; +/*:55*/ +/*59:*/ +typedef short pxlba[32761]; +/*:59*/ +/*91:*/ +typedef uchar dmatrix[7][7]; + +/*:91*/ + + +#define maxmemsize 32760 + + +/*92:*/ + +Static dmatrix ditherm = { + { 1, 3, 6, 10, 18, 26, 38 }, + { 2, 4, 8, 12, 20, 28, 40 }, + { 5, 7, 9, 14, 22, 30, 42 }, + { 11, 13, 15, 16, 24, 32, 44 }, + { 17, 19, 21, 23, 25, 34, 46 }, + { 27, 29, 31, 33, 35, 36, 48 }, + { 37, 39, 41, 43, 45, 47, 49 } +}; + +/*:92*/ +/*:1*/ +/*2:*/ +Static ebts hrep, vrep, xrep, yrep, patswitch, usecol, pminval, pmaxval, + bufsh, nextbuf, tmpcolor, invbyte, invbit, xratio, yratio; +Static unsigned short tpal[256]; +Static long bitspsam, rowspstrip; +Static unsigned short photoinf; +Static short colpos; +Static ebts pxllook[256]; +Static ebts lutone[256]; +Static ebts lutvga[256]; +Static ebts lutsl[256]; +Static double spreadcol, patref, greyunit; +Static short greykor; +Static short *gkorh, *gkordivp; +Static short *spreadvals; +Static short hktab[256]; +Static boolean cspread; +Static unsigned short bhell[256]; +Static boolean cmyk, cyan, magenta, yellow, black, saveblack; +Static short colcyan, colblack, colmagenta, colyellow; +Static dmatrix colmatrix; +Static unsigned short pxlcolor; +Static boolean greypxl, egastretch, ledprinter, distribute, giftemp, pcxtemp; +Static short maxcol; +Static long usepxl, vusepxl, brightness; +Static short greypix; +Static ebts pattern[4][197][7]; +Static ebts ipattern[4][197][7]; +Static unsigned short tab[64][3]; +Static uchar ccol; +Static Char cref[77]; +Static ebts b1[3000]; +Static ebts b2[3000]; +Static ebts b3[3000]; +Static ebts b4[3000]; +Static long linepos_, posbit; +Static halfk dbuf; +Static boolean clipon, zeroline, zerorow, nameok, fok; +Static Char cmd[256]; +Static Char bmname[256]; +Static Char font[256]; +Static Char tmpname[256]; +Static Char fontpre[256]; +Static Char fontupc[256]; +Static ebts curpat[2]; +Static short gbufp, gbufpp; +Static halfk pxlinlen, zeropads; +Static short mapwidth, mapheight, maplines, freelines; +Static long mapinlen, newwidth, newheight; +Static short a, b, f, nf, g, ng, ly, lx, minx, maxx, i, nj, j, v, k, pk, pkn; +Static uchar pm, pn; +Static unsigned short pl, pb; +Static uchar c, cb; +Static long fh, sh, fw, sw; +Static unsigned short lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np; +Static union { + uchar b[4]; + long i; +} cx; +Static long checksum, dsize; +Static long tabdsize[52]; +Static long (*width)[129], (*height)[129]; +Static unsigned short (*yoffset)[129], (*pwidth)[129], (*pheight)[129]; +Static long dirpoint[129]; +Static pxlstr pkpoint[129]; +Static long hres, vres; +Static double truehres, truevres; +Static long noffonts, nofchars, mincharpf; +Static uchar charpf[53]; +/*logfile,*/ +Static FILE *texfile; +Static FILE *bitmap, *pxlfile, *tmpfil; +Static short filestat; +Static unsigned short gi; +Static boolean invert; +Static unsigned short cv, dv, lv; +Static Char comment[256]; +Static Char aliasname[256]; +Static boolean aliasused; +Static double mapdiv; +Static long pkwidth, pkheight; +Static boolean nowhite, halfinch; +Static pxlstr nextmemfree; +/*25:*/ +Static ebts cutrep, outputbyte; +Static halfk cutlen; +Static boolean cutgrey; /*:25*/ +/*53:*/ +Static Char tfmstr[256]; +Static uchar tfmb; +Static FILE *tfmfile; +/*:53*/ +/*56:*/ +Static uchar *pxlbm; +Static pxlstr pxlbmi; +/*:56*/ +/*58:*/ +Static uchar *pkbm; +Static short *repbm; +Static pxlstr pkloc; +/*:58*/ +/*62:*/ +Static short bitweight; +/*:62*/ +/*64:*/ +Static ebts car; +/*:64*/ +/*69:*/ +Static short cxoff, cyoff; +/*:69*/ +/*73:*/ +Static short power[9]; /*:73*/ +/*93:*/ +Static double valinc, redval, grx, grxzero; +Static long gradint; +Static uchar *greymem; +Static long pgreymem; +Static boolean randomst, newrandom; +Static Char texfile_NAME[_FNSIZE]; +Static Char bitmap_NAME[_FNSIZE]; +Static Char pxlfile_NAME[_FNSIZE]; +Static Char tmpfil_NAME[_FNSIZE]; +Static Char tfmfile_NAME[_FNSIZE]; + + +/*:93*/ +/*:2*/ +/*6:*/ +Static uchar korrlastb(i, j) +uchar i; +short j; +{ + ebts k; + + k = 8 - j; + if (k > 0) { + i >>= k; + i <<= k; + } + return i; +} + + +/*:6*/ +/*7:*/ +Static uchar pxladd(i, j, k) +uchar i, j; +short k; +{ + i = (i << k) & 255; + j >>= k; + return (i | j); +} + + +/*:7*/ +/*8:*/ +Static unsigned short getcolor() +{ + halfk j, k; + unsigned short a, o; + ebts savcol, lcol, rcol, l, r; + + if (cutgrey) { + if ((cutrep & 127) == 0) { + if (cutrep == 128) + colpos++; + cutrep = b1[(halfk)colpos]; + colpos++; + } + savcol = b1[(halfk)colpos]; + if (cutrep < 128) + colpos++; + cutrep--; + return savcol; + } + a = colpos; + colpos += bitspsam; + o = a + bitspsam - 1; + l = a & 7; + r = (o + 1) & 7; + k = o >> 3; + j = a >> 3; + lcol = b1[j]; + rcol = b1[k]; + if (k != j) { + savcol = lcol << l; + savcol = (savcol >> (l - r)) ^ (rcol >> (8 - r)); + return savcol; + } + savcol = lcol << l; + savcol >>= l; + if (r > 0) + savcol >>= 8 - r; + return savcol; +} + + +/*:8*/ +/*10:*/ +Static Void sepcols(cr, cg, cb) +uchar cr, cg, cb; +{ + colcyan = 255 - cr; + colmagenta = 255 - cg; + colyellow = 255 - cb; + if (colcyan != colmagenta || colcyan != colyellow || colmagenta != colyellow) { + colcyan -= colmagenta / 3; + if (colcyan < 0) + colcyan = 0; + colmagenta -= colyellow / 3; + if (colmagenta < 0) + colmagenta = 0; + } + colblack = colcyan; + if (colblack > colmagenta) + colblack = colmagenta; + if (colblack > colyellow) + colblack = colyellow; +} + + +/*:10*/ +/*11:*/ +Static Char *numtostr(Result, i) +Char *Result; +long i; +{ + Char nstr[256]; + + sprintf(nstr, "%ld", i); + return strcpy(Result, nstr); +} + + +/*:9*/ +/*10:*/ +Static Void korrfont() +{ + uchar i, j; + + i = strpos2(font, "/", 1); + while (i > 0) { + strdelete((Anyptr)font, 1, i); + i = strpos2(font, "/", 1); + } + j = strlen(font); + i = strpos2(font, ".", 1); + if (i != 0) + strdelete((Anyptr)font, i, j - i + 1); + if (strlen(font) > 7) + font[7] = '\0'; +} + + +/*:10*/ +/*11:*/ +Static Void whatistrue() +{ + hres = (long)floor(truehres + 0.5); + vres = (long)floor(truevres + 0.5); + if (halfinch) { + hres /= 2; + vres /= 2; + } + hres -= hres & 7; + if (hres * vres <= 262136L) + return; + if (truehres > truevres) { + hres = (long)sqrt(262136.0) - 31; + vres = (long)(hres * truevres / truehres); + return; + } + if (truevres > truehres) { + vres = (long)sqrt(262136.0) - 31; + hres = (long)(vres * truehres / truevres); + } else { + hres = (long)sqrt(262136.0) - 31; + vres = hres; + } +} /*:11*/ + + +/*12:*/ +Static Void outfix(k) +long k; +{ + short a; + long f; + char j; + long delta; + union { + ebts b[4]; + long i; + } ax; + char dig[12]; + + ax.i = k; +#ifdef INTEL + a = (long)ax.b[3] * 16 + ax.b[2] / 16; + f = ((ax.b[2] & 15) * 256 + ax.b[1]) * 256 + ax.b[0]; +#else + a = (long)ax.b[0] * 16 + ax.b[1] / 16; + f = ((ax.b[1] & 15) * 256 + ax.b[2]) * 256 + ax.b[3]; +#endif + if (a > 2047) { + putc('-', texfile); + a = 4096 - a; + if (f > 0) { + f = 1048576L - f; + a--; + } + } + j = 0; + do { + dig[j] = a % 10; + a /= 10; + j++; + } while (a != 0); + do { + j--; + fprintf(texfile, "%d", dig[j]); + } while (j != 0); + putc('.', texfile); + f = f * 10 + 5; + delta = 10; + do { + if (delta > 1048576L) + f += 524288L - delta / 2; + fprintf(texfile, "%ld", f / 1048576L); + f = f % 1048576L * 10; +/* p2c: bm2font.pas, line 102: + * Note: Using % for possibly-negative arguments [317] */ + delta *= 10; + } while (f > delta); +} + + +/*:12*/ +/*13:*/ +Static Void fileproblem() +{ + printf("file-error %d : ", filestat); + switch (filestat) { + + case 2: + printf("file not found"); + break; + + case 3: + printf("path not found"); + break; + + case 4: + printf("too many files open"); + break; + + case 5: + printf("file access denied"); + break; + + case 6: + printf("invalid file handle"); + break; + + case 12: + printf("invalid file access mode"); + break; + + case 15: + printf("invalid drive number"); + break; + + case 101: + printf("disk full"); + break; + + default: + printf("ask a tpc guru"); + break; + } + printf("!\n"); + if (pcxtemp) +/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "pcxtemp.tmp"); +#else + Exec("rm", "pcxtemp.tmp"); +#endif + if (giftemp) +/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "giftemp.tmp"); +#else + Exec("rm", "giftemp.tmp"); +#endif + if (greypxl) +/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", tmpname); +#else + Exec("rm", tmpname); +#endif +} + + +/*:13*/ +/*14:*/ +Static Void opentempfile() +{ + strcpy(tmpname, "pcxtemp.tmp"); + strcpy(tmpfil_NAME, "pcxtemp.tmp"); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("tempfile pcxtemp.tmp not accessable, abort\n"); + fileproblem(); + _Escape(0); + } + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + _SETIO(tmpfil != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (!fok) + return; + printf("Unable to create pcxtmp.tmp, abort\n"); + fileproblem(); + _Escape(0); +} + + +/*:14*/ +/*15:*/ +Static Void picstretch() +{ + short FORLIM; + + printf("Stretching the picture because of odd aspect ratio\n"); + posbit = 0; + giftemp = true; + strcpy(tmpname, "giftemp.tmp"); + strcpy(tmpfil_NAME, "giftemp.tmp"); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("tempfile giftemp.tmp not accessable, abort\n"); + fileproblem(); + _Escape(0); + } + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + if (tmpfil == NULL) + _EscIO(FileNotFound); + while (!P_eof(bitmap)) { + fread(b1, mapinlen, 1, bitmap); + if (posbit == xratio) { + if (bitspsam == 8) { + FORLIM = mapinlen; + for (gbufp = 0; gbufp < FORLIM; gbufp++) + b3[gbufp] = ((unsigned)(b3[gbufp] + b1[gbufp])) >> 1; + } else if (bitspsam == 4) { + FORLIM = mapinlen; + for (gbufp = 0; gbufp < FORLIM; gbufp++) { + b = ((unsigned)((b3[gbufp] >> 4) + (b1[gbufp] >> 4))) >> 1; + c = ((unsigned)((b3[gbufp] & 15) + (b1[gbufp] & 15))) >> 1; + b3[gbufp] = (b << 4) + c; + } + } +/* p2c: bm2font.pas, line 131: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + posbit = 0; + } + posbit++; + if (posbit == xratio) { + FORLIM = mapinlen; + for (gbufp = 0; gbufp < FORLIM; gbufp++) + b3[gbufp] = b1[gbufp]; + } +/* p2c: bm2font.pas, line 135: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b1, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 126: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + strcpy(bitmap_NAME, "giftemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + posbit = 0; + cutgrey = false; + if (pcxtemp) { +/* p2c: bm2font.pas, line 140: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "pcxtemp.tmp"); +#else + Exec("rm", "pcxtemp.tmp"); +#endif + pcxtemp = false; + } +} + + +/*:15*/ +/*16:*/ +Static Void scaling() +{ /*17:*/ + long newh, newv, counth, countv; + double scaleh, scalev, ledfac, repfac; + boolean grver, grhor, remlast; + short FORLIM; + + if (ledprinter) + ledfac = 0.5; + else + ledfac = 0.0; + if (hrep != 1) + repfac = 2.0; + else + repfac = 1.0; + if (!greypxl) { + usepxl = 1; + vusepxl = 1; + bitspsam = 1; + } + if (newwidth != 0) + newwidth = (long)floor( + newwidth * truehres / 25.4 / (repfac * (usepxl + ledfac)) + 0.5); + if (newheight != 0) + newheight = (long)floor( + newheight * truevres / 25.4 / (repfac * (vusepxl + ledfac)) + 0.5); + if (newheight == 0) + newheight = (long)floor((double)mapheight / mapwidth * newwidth + 0.5); + if (newwidth == 0) + newwidth = (long)floor((double)mapwidth / mapheight * newheight + 0.5); + printf("Scaling the picture from %dx%d", mapwidth, mapheight); + printf(" to %ldx%ld pixels\n", newwidth, newheight); + grver = (newheight > mapheight); + grhor = (newwidth > mapwidth); + if (grhor) + scaleh = newwidth / (newwidth - mapwidth + 1.0); + else + scaleh = mapwidth / (mapwidth - newwidth + 1.0); + if (grver) /*:17*/ + scalev = newheight / (newheight - mapheight + 1.0); + else + scalev = mapheight / (mapheight - newheight + 1.0); + /*18:*/ + if (giftemp) + strcpy(tmpname, "pcxtemp.tmp"); + else + strcpy(tmpname, "giftemp.tmp"); + strcpy(tmpfil_NAME, tmpname); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("tempfile %s not accessable, abort\n", tmpname); + fileproblem(); + _Escape(0); + } + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + if (tmpfil == NULL) + _EscIO(FileNotFound); + /*:18*/ + pxlinlen = (halfk)(((unsigned long)(mapwidth * bitspsam + 7)) >> 3); + greypix = mapwidth; + if (cutgrey) { + checksum = mapheight; + pxlinlen = cutlen; + } else + checksum = mapheight; + pl = 0; + fseek(bitmap, posbit, 0); + for (pk = 0; pk <= 255; pk++) + lutsl[pk] = pk << (8 - bitspsam); + newv = 1; + countv = 0; + remlast = false; + do { + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + colpos = 0; + cutrep = 0; + gbufpp = (newwidth * bitspsam + 7) / 8; + memset((Anyptr)b4, invbyte, sizeof(uchar) * 1500L); + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b4[pk] = getcolor(); + if (remlast) { + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b4[pk] = (b2[pk] * 2 + b4[pk]) / 3; + remlast = false; + } + gbufp = 0; + cb = 0; +/* p2c: bm2font.pas, line 172: + * Note: Can't interpret size in FILLCHAR [174] */ + memset((Anyptr)b3, invbyte, (long)gbufpp); + newh = 1; + counth = 0; + pk = 0; + while (pk < greypix) { /*19:*/ + cb = lutsl[b4[pk]]; + dbuf = ((unsigned)gbufp) >> 3; + bufsh = gbufp & 7; + nextbuf = bufsh + bitspsam; + switch (bufsh) { + + case 0: + b3[dbuf] = cb; + break; + + default: + b3[dbuf] ^= cb >> bufsh; + if (nextbuf > 8) + b3[dbuf + 1] = cb << (8 - bufsh); + break; + } + gbufp += bitspsam; + pk++; + counth++; + if (counth != (long)floor(newh * scaleh + 0.5)) + continue; + if (grhor) { + while (counth >= (long)floor(newh * scaleh + 0.5)) { + if (pk == greypix) + cb = lutsl[(b4[pk - 1] * 2 + b4[pk - 2]) / 3]; + else + cb = lutsl[(b4[pk] * 2 + b4[pk - 1]) / 3]; + dbuf = ((unsigned)gbufp) >> 3; + bufsh = gbufp & 7; + nextbuf = bufsh + bitspsam; + switch (bufsh) { + + case 0: + b3[dbuf] = cb; + break; + + default: + b3[dbuf] ^= cb >> bufsh; + if (nextbuf > 8) + b3[dbuf + 1] = cb << (8 - bufsh); + break; + } + gbufp += bitspsam; + counth++; + newh++; + } + continue; + } + while (counth == (long)floor(newh * scaleh + 0.5)) { + b4[pk + 1] = (b4[pk + 1] * 2 + b4[pk]) / 3; + pk++; + newh++; + counth++; + } + } /*:19*/ + if (bitspsam == 1) { + dbuf = ((unsigned)gbufp) >> 3; + bufsh = gbufp & 7; + if (dbuf < gbufpp) { + cb = invbyte; + b3[dbuf] ^= cb >> bufsh; + } + } +/* p2c: bm2font.pas, line 191: + * Note: Can't interpret size in BLOCKWRITE [174] */ + fwrite(b3, gbufpp, 1, tmpfil); + checksum--; /*20:*/ + countv++; + if (cutgrey) + pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2); + if (countv == (long)floor(newv * scalev + 0.5)) { /*:20*/ + if (grver) { + while (countv >= (long)floor(newv * scalev + 0.5)) { + fwrite(b3, gbufpp, 1, tmpfil); + countv++; + newv++; + } +/* p2c: bm2font.pas, line 194: + * Note: Can't interpret size in BLOCKWRITE [174] */ + } else { + while (countv == (long)floor(newv * scalev + 0.5)) { + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + colpos = 0; + cutrep = 0; + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b2[pk] = getcolor(); + remlast = true; + if (checksum > 0) + checksum--; + if (cutgrey) + pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2); + newv++; + countv++; + } +/* p2c: bm2font.pas, line 196: + * Note: Can't interpret size in BLOCKREAD [174] */ + } + } + } while (checksum != 0); +/* p2c: bm2font.pas, line 168: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; /*21:*/ + if (giftemp) { /*:21*/ +/* p2c: bm2font.pas, line 206: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "giftemp.tmp"); +#else + Exec("rm", "giftemp.tmp"); +#endif + giftemp = false; + pcxtemp = true; + } else { +/* p2c: bm2font.pas, line 206: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "pcxtemp.tmp"); +#else + Exec("rm", "pcxtemp.tmp"); +#endif + giftemp = true; + pcxtemp = false; + } + strcpy(bitmap_NAME, tmpname); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + posbit = 0; + cutgrey = false; + mapheight = newheight; + mapwidth = newwidth; + if (bitspsam == 1) + pxlinlen = (mapwidth + 7) / 8; + mapheight = (P_maxpos(bitmap)) / ((mapwidth * bitspsam + 7) / 8); +} /*:16*/ + + +/* Local variables for tifint: */ +struct LOC_tifint { + boolean le; + uchar tb[3000]; +} ; + +/*:22*/ +/*23:*/ +Local unsigned short tifword(ba, LINK) +unsigned short ba; +struct LOC_tifint *LINK; +{ + if (LINK->le) + return ((unsigned short)LINK->tb[ba] + (unsigned short)LINK->tb[ba + 1] * 256); + else + return ((unsigned short)(LINK->tb[ba] * 256) + + (unsigned short)LINK->tb[ba + 1]); +} + +Local long tiflong(ba, LINK) +unsigned short ba; +struct LOC_tifint *LINK; +{ + if (LINK->le) + return ((long)tifword(ba, LINK) + (long)tifword(ba + 2, LINK) * 65536L); + else + return (LINK->tb[ba] * 16777216 + LINK->tb[ba + 1] * 65536 + + LINK->tb[ba + 2] * 256 + (long)LINK->tb[ba + 3]); +} + +Local unsigned short tiftwobyte(ba, LINK) +unsigned short ba; +struct LOC_tifint *LINK; +{ + if (LINK->le) + return ((unsigned short)LINK->tb[ba] + (unsigned short)LINK->tb[ba + 1] * 256); + else + return ((unsigned short)(LINK->tb[ba] * 256) + + (unsigned short)LINK->tb[ba + 1]); +} + + +/*22:*/ +Static Void tifint() +{ /*:23*/ + struct LOC_tifint V; + unsigned short i, j, l, m, tl; + long ll; + uchar tp; + boolean strips, tiffrgb; + unsigned short ttype; + long tiftemp; + ebts tiffbuf[3]; + unsigned short FORLIM; + uchar FORLIM1; + unsigned short FORLIM2; + + /*24:*/ + strips = false; + tl = fread(V.tb, 1, sizeof(uchar) * 1199, bitmap); + V.le = (V.tb[1] == 'I'); + ll = tiflong(4, &V); + if (ll > 900) { + printf("I can't digest this\n"); + _Escape(0); + } + l = ll; + m = tiftwobyte(l, &V); + l += 2; + for (i = 1; i <= m; i++) { + j = tiftwobyte(l, &V); + ttype = tiftwobyte(l + 2, &V); + if (ttype == 3) + tiftemp = tifword(l + 8, &V); + else + tiftemp = tiflong(l + 8, &V); + switch (j) { + + case 256: + mapwidth = tiftemp; + break; + + case 257: + mapheight = tiftemp; + break; + + case 258: + if (tiftemp > 1) { + greypxl = true; + bitspsam = tiftemp; + if (bitspsam > 8) { + printf("Assuming 8 greyshades\n"); + bitspsam = 8; + } + mapdiv = 1.0; + FORLIM1 = bitspsam; + for (tp = 1; tp <= FORLIM1; tp++) + mapdiv *= 2; + mapdiv /= 16; + } + break; + + case 259: + if (tiftemp > 1) { + printf("No compression supported\n"); + _Escape(0); + } + break; + + case 262: + photoinf = tiftemp; + if (photoinf > 1) + tiffrgb = true; + else + tiffrgb = false; + if (photoinf == 0) + invert = !invert; + if (invert) { + invbit = 0; + invbyte = 0; + } else { + invbit = 1; + invbyte = 255; + } + photoinf = 15; + break; + + case 273: + if (tiflong(l + 4, &V) != 1) + strips = true; + posbit = tiftemp; + break; + + case 277: + if (tiftemp == 3) + tiffrgb = true; + else + tiffrgb = false; + break; + + case 278: + rowspstrip = tiftemp; + break; + + case 290: + greyunit = 1.0; + FORLIM1 = tifword(l + 4, &V); + for (tp = 1; tp <= FORLIM1; tp++) + greyunit /= 10; + break; + + case 291: + FORLIM1 = tiflong(l + 4, &V); + for (tp = 0; tp < FORLIM1; tp++) + tpal[tp] = V.tb[l + tp + 8]; + break; + } + l += 12; + if (l >= tl) { + tl = fread(V.tb, 1, sizeof(uchar) * 1199, bitmap); + l = 0; + } + } + if (strips) { + fseek(bitmap, posbit, 0); + l = fread(V.tb, 1, sizeof(uchar) * 2, bitmap); + posbit = tiflong(0, &V); + } + if (!tiffrgb) + return; + opentempfile(); + fseek(bitmap, posbit, 0); + FORLIM = mapheight; + for (j = 1; j <= FORLIM; j++) { + FORLIM2 = mapwidth; + for (i = 0; i < FORLIM2; i++) { + l = fread(tiffbuf, 1, 3, bitmap); + if (cmyk) { + sepcols(tiffbuf[0], tiffbuf[1], tiffbuf[2]); + if (cyan) + b3[i] = 255 - colcyan; + if (magenta) + b3[i] = 255 - colmagenta; + if (yellow) + b3[i] = 255 - colyellow; + if (black) + b3[i] = 255 - colblack; + } else + b3[i] = (long)floor(tiffbuf[0] * 0.287 + tiffbuf[1] * 0.589 + + tiffbuf[2] * 0.114 + 0.5); + } +/* p2c: bm2font.pas, line 244: + * Note: Can't interpret size in BLOCKREAD [174] */ +/* p2c: bm2font.pas, line 257: + * Note: Can't interpret size in BLOCKWRITE [174] */ + fwrite(b3, mapwidth, 1, tmpfil); + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + posbit = 0; + pcxtemp = true; + mapinlen = mapwidth; +} + + +/*:24*/ +/*26:*/ +Static Void cutint() +{ + long FORLIM; + short FORLIM1; + + pxlinlen = 8; +/* p2c: bm2font.pas, line 241: + * Note: Can't interpret size in BLOCKREAD [174] */ + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + if (pxlinlen != 8) { + printf("CUT file too small!\n"); + _Escape(0); + } + mapheight = b1[3] * 256 + b1[2]; + mapwidth = b1[1] * 256 + b1[0]; + photoinf = 15; + mapdiv = 16.0; + posbit = 8; + cutlen = b1[7] * 256 + b1[6] + 2; + bitspsam = 8; + cutgrey = true; + greypxl = true; + if (!egastretch) + return; + mapinlen = mapwidth; + printf("Shrinking the CUT picture because of odd aspect ratio\n"); + giftemp = true; + strcpy(tmpname, "giftemp.tmp"); + strcpy(tmpfil_NAME, "giftemp.tmp"); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("tempfile giftemp.tmp not accessable, abort\n"); + fileproblem(); + _Escape(0); + } + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + if (tmpfil == NULL) + _EscIO(FileNotFound); + xratio = 2; + posbit = 0; + pxlinlen = cutlen; + FORLIM = mapheight; + for (checksum = 1; checksum <= FORLIM; checksum++) { + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + colpos = 0; + cutrep = 0; + FORLIM1 = mapinlen; + for (pk = 0; pk < FORLIM1; pk++) + b2[pk] = getcolor(); + posbit++; + FORLIM1 = mapinlen; + for (gbufp = 0; gbufp < FORLIM1; gbufp++) + b3[gbufp] = b2[gbufp]; + if (posbit < xratio) { + _SETIO(fwrite(b2, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 256: + * Note: Can't interpret size in BLOCKWRITE [174] */ + if (posbit > xratio) { + FORLIM1 = mapinlen; + for (gbufp = 0; gbufp < FORLIM1; gbufp++) + b3[gbufp] = ((unsigned)(b3[gbufp] + b2[gbufp])) >> 1; +/* p2c: bm2font.pas, line 261: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + posbit = 0; + if (xratio == 2) + xratio = 3; + else + xratio = 2; + } + pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2); + } +/* p2c: bm2font.pas, line 253: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + strcpy(bitmap_NAME, "giftemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + cutgrey = false; + posbit = 0; +} + + +typedef unsigned short tabcode[4097]; +typedef uchar bytecod[4097]; +typedef uchar ilaced[4]; +typedef uchar ebts_; + + +typedef long gifmask[13]; + + +/* Local variables for gifint: */ +struct LOC_gifint { + ilaced ioff, ijump; + long lvr, linepos; + ebts_ logvr, codesample, modus, gifshift, nextbuf, bufsh; + unsigned short maxcode, hh; + short ec, ki; + unsigned short hell[256]; + ebts_ gifbuf[3000]; + unsigned short codepos, gifinlen, gotinlen; + long codesav; + unsigned short dbuf, linebytes; +} ; + +/*:27*/ +/*28:*/ +Local uchar getgif(LINK) +struct LOC_gifint *LINK; +{ +/* p2c: bm2font.pas, line 279: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(b1, 1, 1, bitmap); + return (b1[0]); +} + +Local Void gifout(b, LINK) +unsigned short b; +struct LOC_gifint *LINK; +{ + short i, FORLIM; + ebts_ ibits; + + if (gbufpp < 3000) + b2[gbufpp] = LINK->hell[b]; + gbufpp++; + if (gbufpp != LINK->hh) + return; + LINK->codepos = 0; +/* p2c: bm2font.pas, line 282: + * Note: Can't interpret size in FILLCHAR [174] */ + memset((Anyptr)LINK->gifbuf, invbyte, 3000L); + FORLIM = LINK->hh; + for (i = 0; i < FORLIM; i++) { + LINK->dbuf = LINK->codepos / 8; + LINK->bufsh = LINK->codepos & 7; + LINK->nextbuf = LINK->bufsh + bitspsam; + cb = lutsl[b2[i]]; + if (LINK->bufsh == 0) + LINK->gifbuf[LINK->dbuf] = cb; + else { + LINK->gifbuf[LINK->dbuf] |= cb >> LINK->bufsh; + if (LINK->nextbuf > 8) + LINK->gifbuf[LINK->dbuf + 1] = cb << (8 - LINK->bufsh); + } + LINK->codepos += bitspsam; + } + if (LINK->modus == 1) + fseek(tmpfil, LINK->linepos, 0); + if (bitspsam == 1) { + i = 8 - (LINK->hh & 7); + if (i != 8) { + cb = LINK->gifbuf[LINK->dbuf] >> i; + cb <<= i; + LINK->gifbuf[LINK->dbuf] = cb; + cb = invbit; + for (ibits = 1; ibits <= i; ibits++) { + LINK->gifbuf[LINK->dbuf] ^= cb; + cb <<= 1; + } + } + } +/* p2c: bm2font.pas, line 291: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(LINK->gifbuf, LINK->linebytes, 1, tmpfil) == 1, + FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + LINK->lvr++; + gbufpp = 0; + LINK->linepos += LINK->linebytes * LINK->ijump[LINK->logvr]; + if (LINK->linepos >= P_maxpos(tmpfil)-1) { + LINK->logvr++; + LINK->linepos = LINK->ioff[LINK->logvr] * LINK->linebytes; + } +} + +Local unsigned short gifcode(LINK) +struct LOC_gifint *LINK; +{ + unsigned short Result; + + static gifmask codemask = { + 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095 + }; + + long codebyte; + + while (LINK->gifshift < LINK->codesample) { + codebyte = b1[gbufp]; + gbufp++; + if (gbufp == LINK->gifinlen) { + LINK->gifinlen = getgif(LINK); +/* p2c: bm2font.pas, line 303: + * Note: Can't interpret size in BLOCKREAD [174] */ + LINK->gotinlen = fread(b1, 1, LINK->gifinlen, bitmap); + gbufp = 0; + if (LINK->gifinlen == 0) + printf("Code zero, proceeding\n"); + if (LINK->gotinlen != LINK->gifinlen) { + b1[LINK->gotinlen] = LINK->ec; + LINK->gifinlen = LINK->gotinlen + 1; + } + } + LINK->codesav |= codebyte << LINK->gifshift; + LINK->gifshift += 8; + } + Result = LINK->codesav & codemask[LINK->codesample]; + LINK->codesav = ((unsigned long)LINK->codesav) >> LINK->codesample; + LINK->gifshift -= LINK->codesample; + LINK->ki++; + if (LINK->ki > LINK->maxcode && LINK->codesample < 12) { + LINK->codesample++; + LINK->maxcode = 1 << LINK->codesample; + } + return Result; +} + + +/*:26*/ +/*27:*/ +Static Void gifint() +{ /*:28*/ + struct LOC_gifint V; + + static ilaced ioff = { + 0, 4, 2, 1 + }; + + static ilaced ijump = { + 8, 8, 4, 2 + }; + + unsigned short a, g, hi, vi, vh, hr, vr; + short merk, ic, codegif, i; + ebts_ colmap, b, col, bpp; + ebts_ gpal[256][3]; + unsigned short *codtab; + unsigned short folge, minhell, maxhell; + uchar *anf; + Char hexbyte[7]; + short FORLIM; + + /*29:*/ + memcpy(V.ioff, ioff, sizeof(ilaced)); + memcpy(V.ijump, ijump, sizeof(ilaced)); + printf("Decoding GIF file\n"); + V.logvr = 0; + V.codesav = 0; + V.lvr = 0; + minhell = 9999; + maxhell = 0; + codtab = (unsigned short *)Malloc(sizeof(tabcode)); + anf = (uchar *)Malloc(sizeof(bytecod)); + opentempfile(); + *hexbyte = '\0'; + for (i = 1; i <= 3; i++) { + sprintf(hexbyte + strlen(hexbyte), "%c", getgif(&V)); +/* p2c: bm2font.pas, line 313: + * Note: Possible string truncation in assignment [145] */ + } + if (strcmp(hexbyte, "GIF")) { + printf("This file is NOT a gif file!\n"); + _Escape(0); + } + for (i = 1; i <= 3; i++) { + sprintf(hexbyte + strlen(hexbyte), "%c", getgif(&V)); +/* p2c: bm2font.pas, line 315: + * Note: Possible string truncation in assignment [145] */ + } + if (strcmp(hexbyte, "GIF87a") && strcmp(hexbyte, "GIF89a")) { + printf("The program only supports version 87a and 89a!\n"); + _Escape(0); + } + b = getgif(&V); + hr = b; + b = getgif(&V); + hr += b * 256; + b = getgif(&V); + vr = b; + b = getgif(&V); + vr += b * 256; + if (hr == 640 && vr == 350) { + xratio = 3; + yratio = 4; + } + b = getgif(&V); + colmap = b & 128; + colmap >>= 7; + col = b & 112; + col >>= 4; + col++; + bitspsam = b & 7; + bitspsam++; + b = getgif(&V); + b = getgif(&V); + if (colmap == 1) { /*30:*/ + g = 1; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + g *= 2; + for (i = 0; i < g; i++) { + for (j = 0; j <= 2; j++) + gpal[i][j] = getgif(&V); + if (cmyk) { + sepcols(gpal[i][0], gpal[i][1], gpal[i][2]); + if (cyan) + V.hell[i] = 255 - colcyan; + if (magenta) + V.hell[i] = 255 - colmagenta; + if (yellow) + V.hell[i] = 255 - colyellow; + if (black) + V.hell[i] = 255 - colblack; + bhell[V.hell[i]] = 255 - colblack; + } else + V.hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i] + [2] * 0.114 + 0.5); + if (V.hell[i] > maxhell) + maxhell = V.hell[i]; + } + if (bitspsam > 1) { + for (i = 0; i < g; i++) + V.hell[i] = (long)floor((double)V.hell[i] / maxhell * (g - 1) + 0.5); + for (i = 0; i < g; i++) + bhell[i] = (long)floor((double)bhell[i] / maxhell * (g - 1) + 0.5); + } else { + V.hell[0] = 0; + V.hell[1] = 1; + bhell[0] = 0; + bhell[1] = 1; + } + } + b = getgif(&V); + if (b != 44) { /*31:*/ + while (b != 44) { /*:31*/ + b = getgif(&V); + switch (b) { + + case 249: + a = getgif(&V); + for (g = 0; g <= a; g++) + b = getgif(&V); + break; + + case 254: + a = getgif(&V); + while (a != 0) { + for (g = 0; g <= a; g++) + b = getgif(&V); + a = b; + if (P_eof(bitmap)) { + printf("file ended while looking for image\n"); + _Escape(0); + } + } + break; + + case 1: + case 255: + a = getgif(&V); + for (g = 1; g <= a; g++) + b = getgif(&V); + a = getgif(&V); + while (a != 0) { + for (g = 0; g <= a; g++) + b = getgif(&V); + a = b; + if (P_eof(bitmap)) { + printf("file ended while looking for image\n"); + _Escape(0); + } + } + break; + } + b = getgif(&V); + if (P_eof(bitmap)) { + printf("file ended while looking for image\n"); + _Escape(0); + } + } + } + b = getgif(&V); + hi = b; + b = getgif(&V); + hi += b * 256; + b = getgif(&V); + vi = b; + b = getgif(&V); + vi += b * 256; + b = getgif(&V); + V.hh = b; + b = getgif(&V); + V.hh += b * 256; + b = getgif(&V); + vh = b; + b = getgif(&V); + vh += b * 256; + if (V.hh != hr || vh != vr) + printf("No fragments supported!\n"); + V.linebytes = (V.hh * bitspsam + (bitspsam - 1)+7) / 8; + if (V.linebytes > 3000) { + V.linebytes = 3000; + printf("Sorry, had to cut picture to a width of 3000 bytes\n"); + } + b = getgif(&V); + col = b & 128; + col >>= 7; + if (col != 0) { + bitspsam = b & 7; + bitspsam++; /*30:*/ + g = 1; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + g *= 2; + for (i = 0; i < g; i++) { + for (j = 0; j <= 2; j++) + gpal[i][j] = getgif(&V); + if (cmyk) { + sepcols(gpal[i][0], gpal[i][1], gpal[i][2]); + if (cyan) + V.hell[i] = 255 - colcyan; + if (magenta) + V.hell[i] = 255 - colmagenta; + if (yellow) + V.hell[i] = 255 - colyellow; + if (black) + V.hell[i] = 255 - colblack; + bhell[V.hell[i]] = 255 - colblack; + } else + V.hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i] + [2] * 0.114 + 0.5); + if (V.hell[i] > maxhell) + maxhell = V.hell[i]; + } + for (i = 0; i < g; i++) + V.hell[i] = (long)floor((double)V.hell[i] / maxhell * (g - 1) + 0.5); + for (i = 0; i < g; i++) /*:30*/ + bhell[i] = (long)floor((double)bhell[i] / maxhell * (g - 1) + 0.5); + } + for (pk = 0; pk <= 255; pk++) + lutsl[pk] = pk << (8 - bitspsam); + V.modus = b << 1; + V.modus >>= 7; + if (V.modus == 0) + printf("Image is loaded sequentially.\n"); + else + printf("Interlaced mode, loading the image will take more time.\n"); + if (V.modus != 0) { + memset((Anyptr)V.gifbuf, invbyte, 3000L); + for (i = 1; i <= vh; i++) { + _SETIO(fwrite(V.gifbuf, V.linebytes, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 379: + * Note: Can't interpret size in BLOCKWRITE [174] */ + V.linepos = 0; + V.logvr = 0; + fseek(tmpfil, 0L, 0); + } +/* p2c: bm2font.pas, line 378: + * Note: Can't interpret size in FILLCHAR [174] */ + bpp = b << 5; + bpp >>= 5; + bpp++; + bpp = getgif(&V); + g = 1 << bpp; + ic = 1 << bpp; + V.ec = ic + 1; + V.codesample = bpp + 1; + V.maxcode = 1 << V.codesample; + for (i = 0; i <= 4095; i++) + codtab[i] = 4098; + V.ki = V.ec + 1; + a = 4098; + gbufpp = 0; + V.gifshift = 0; + V.gifinlen = getgif(&V); +/* p2c: bm2font.pas, line 387: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(b1, V.gifinlen, 1, bitmap); + gbufp = 0; + if (V.gifinlen == 0) + _Escape(0); + merk = 0; /*32:*/ + while (V.lvr < vh) { /*:32*/ + codegif = gifcode(&V); + if (codegif == V.ec) { + printf("End of code before gif image completed!\n"); + V.lvr = vh; + continue; + } + if (codegif == ic) { + for (i = 0; i <= 4095; i++) + codtab[i] = 4098; + V.ki = V.ec + 1; + V.codesample = bpp + 1; + V.maxcode = 1 << V.codesample; + a = 4098; + continue; + } + if (codegif < ic) + gifout(codegif, &V); + else { + if (codtab[codegif] == 4098) { + if (codegif != V.ki - 2) { + printf("Bytes are mangled!\n"); + _Escape(0); + } + folge = a; + merk++; + while (folge > ic) + folge = codtab[folge]; + b3[merk] = folge; + anf[V.ki - 2] = folge; + folge = a; + } else + folge = codegif; + while (folge > ic && folge <= 4095) { + merk++; + b3[merk] = anf[folge]; + folge = codtab[folge]; + } + merk++; + b3[merk] = folge; + while (merk > 0) { + gifout(b3[merk], &V); + merk--; + } + } + if (a != 4098) { + codtab[V.ki - 2] = a; + if (codegif == V.ki - 2) { + folge = a; + while (folge > ic) + folge = codtab[folge]; + anf[V.ki - 2] = folge; + } else { + folge = codegif; + while (folge > ic) + folge = codtab[folge]; + anf[V.ki - 2] = folge; + } + } + a = codegif; + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + if (bitspsam > 1) + greypxl = true; + mapinlen = V.linebytes; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + pcxtemp = true; + if (egastretch) { + if (xratio + 1 == yratio) + picstretch(); + } + posbit = 0; + mapdiv = 1.0; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + mapdiv *= 2; + mapdiv /= 16; +} + + +/*:29*/ +/*33:*/ +Static uchar getpcx() +{ + uchar Result; + + if (gbufp == pxlinlen) { + gbufp = 0; + pxlinlen = fread(b1, 1, sizeof(uchar) * 320, bitmap); + } + Result = b1[gbufp]; + gbufp++; + return Result; +} + + +/*:33*/ +/*34:*/ +Static long longpcx() +{ + long bl; + ebts pb; + + pb = getpcx(); + bl = pb; + pb = getpcx(); + bl += pb * 256; + pb = getpcx(); + bl += pb * 65536; + pb = getpcx(); + bl += pb * 16777216; + return bl; +} + + +/*:34*/ +/*35:*/ +Static unsigned short wordpcx() +{ + unsigned short bl; + ebts pb; + + pb = getpcx(); + bl = pb; + pb = getpcx(); + bl += pb * 256; + return bl; +} /*:35*/ + + +/*36:*/ +Static Void pcxint() +{ + unsigned short i, ki, k, hi, hh, vi, vh, hr, vr, bzf; + ebts xb, j, b, a, col, bps, ibits, pcxver, pcxcomp; + ebts gpal[256][3]; + unsigned short hell[256]; + unsigned short FORLIM; + short FORLIM1; + + printf("Analysing PCX file %s\n", bmname); + gbufp = 640; + pxlinlen = 640; + b = getpcx(); + if (b != 10 && b != 205) { + printf("What a bad joke!\n"); + printf("This is NOT a PCX file!\n"); + _Escape(0); + } + if (b == 205) + printf("First byte 205, file seems to be captured!\n"); + /*37:*/ + pcxver = getpcx(); + pcxcomp = getpcx(); + bps = getpcx(); + hi = getpcx(); + b = getpcx(); + hi += b * 256; + vi = getpcx(); + b = getpcx(); + vi += b * 256; + hh = getpcx(); + b = getpcx(); + hh += b * 256; + vh = getpcx(); + b = getpcx(); + vh += b * 256; + hr = getpcx(); + b = getpcx(); + hr += b * 256; + vr = getpcx(); + b = getpcx(); + vr += b * 256; + if (hr == 640 && vr == 350) { + xratio = 3; + yratio = 4; + } + if (hr == 320 && vr == 200) { + xratio = 5; + yratio = 6; + } + hh -= hi; + vh -= vi; + mapwidth = hh; + for (i = 0; i <= 15; i++) { + for (j = 0; j <= 2; j++) + gpal[i][j] = getpcx(); + } + b = getpcx(); + col = getpcx(); + bzf = getpcx(); + b = getpcx(); + bzf += b * 256; + hh = bzf; + b = getpcx(); + b = getpcx(); + for (i = 70; i <= 127; i++) + b = getpcx(); + bitspsam = bps; + if (col == 4) { + bitspsam = 4; + greypxl = true; + } else if (bps > 1) { + bitspsam = bps; + greypxl = true; + } + mapinlen = ((unsigned long)(mapwidth * bitspsam + 7)) >> 3; /*:37*/ + /*38:*/ + for (i = 0; i <= 15; i++) { + if (cmyk) { + sepcols(gpal[i][0], gpal[i][1], gpal[i][2]); + if (cyan) + hell[i] = 255 - colcyan; + if (magenta) + hell[i] = 255 - colmagenta; + if (yellow) + hell[i] = 255 - colyellow; + if (black) + hell[i] = 255 - colblack; + hell[i] /= 16; + if (hell[i] > 15) + hell[i] = 15; + bhell[hell[i]] = 0; + } else + hell[i] = (long)(gpal[i][0] / 16.0 * 0.287 + gpal[i][1] / 16.0 * 0.589 + + gpal[i][2] / 16.0 * 0.114); + } + for (i = 0; i <= 15; i++) { + if (hell[i] > 15) + hell[i] = 15; + } + for (i = 0; i <= 15; i++) { + if (bhell[i] > 15) + bhell[i] = 15; + } + opentempfile(); /*:38*/ + if (pcxver == 5 && bitspsam > 4) { /*39:*/ + gbufp = 640; + pxlinlen = 640; + posbit = P_maxpos(bitmap); + posbit -= 769; + fseek(bitmap, posbit, 0); + b = getpcx(); + if (b != 12) { + printf("No valid information in 256 colors palette\n"); + printf("Using standard 16 colors palette\n"); + } else { + for (i = 0; i <= 255; i++) { + for (j = 0; j <= 2; j++) + gpal[i][j] = getpcx(); + if (cmyk) { + sepcols(gpal[i][0], gpal[i][1], gpal[i][2]); + if (cyan) + hell[i] = 255 - colcyan; + if (magenta) + hell[i] = 255 - colmagenta; + if (yellow) + hell[i] = 255 - colyellow; + if (black) + hell[i] = 255 - colblack; + bhell[hell[i]] = 255 - colblack; + } else + hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i] + [2] * 0.114 + 0.5); + } + } + fseek(bitmap, 128L, 0); + gbufp = 640; + pxlinlen = 640; + } + /*:39*/ + /*40:*/ + a = 0; + for (i = 0; i <= vh; i++) { /*:40*/ + FORLIM1 = mapinlen; + for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) + b3[gbufpp] = 0; + for (j = 0; j < col; j++) { + gbufpp = 0; + for (k = 1; k <= hh; k++) { + if (a == 0) { + b = getpcx(); + if ((b & 0xc0) == 0xc0) { + a = (b & 0x3f) - 1; + b = getpcx(); + } + } else + a--; + if (col == 4) { + for (ibits = 0; ibits <= 7; ibits++) { + ki = gbufpp * 4 + (ibits >> 1); + xb = b << ibits; + xb >>= 7; + xb <<= j; + xb <<= (1 - (ibits & 1)) << 2; + b3[ki] ^= xb; + } + } else { + b3[gbufpp] = b; + if (gbufpp == mapinlen - 1 && bitspsam == 1) { + ki = 8 - (mapwidth & 7); + if (ki != 8) { + xb = b3[gbufpp] >> ki; + xb <<= ki; + b3[gbufpp] = xb; + xb = invbit; + for (ibits = 1; ibits <= ki; ibits++) { + b3[gbufpp] ^= xb; + xb <<= 1; + } + } + } + } + gbufpp++; + } + } + if (col == 4) { + gbufpp = 0; + hi = (hh - 1) * 4 + 3; + for (k = 0; k <= hi; k++) { + b3[gbufpp] = (hell[b3[k] >> 4] << 4) + hell[b3[k] & 15]; + gbufpp++; + } + } else if (bps == 8 && pcxver == 5) { + hi = hh - 1; + for (k = 0; k <= hi; k++) + b3[k] = hell[b3[k]]; + gbufpp = hh; + } +/* p2c: bm2font.pas, line 489: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + if (hr == 640 && vr == 200) { + _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 492: + * Note: Can't interpret size in BLOCKWRITE [174] */ + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + if (bitmap == NULL) + _EscIO(FileNotFound); + pcxtemp = true; + if (egastretch) { + if (xratio + 1 == yratio) + picstretch(); + } + posbit = 0; + mapdiv = 1.0; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + mapdiv *= 2; + mapdiv /= 16; +} + + +/* Local variables for iffint: */ +struct LOC_iffint { + unsigned short hi, hh, vi, vh, compr; + uchar a, b, col, bps; + uchar gpal[256][3]; + unsigned short hell[256]; + Char bmstr[256]; + long bmsize, bmoff, bl; +} ; + +/*:41*/ +/*42:*/ +Local long ifflong(LINK) +struct LOC_iffint *LINK; +{ + ebts k; + + fread(b1, 4, 1, bitmap); + LINK->bl = b1[0]; + for (k = 1; k <= 3; k++) + LINK->bl = LINK->bl * 256 + b1[k]; + return LINK->bl; +} + +/*:42*/ +/*43:*/ +Local unsigned short iffword(LINK) +struct LOC_iffint *LINK; +{ + fread(b1, 2, 1, bitmap); + return (b1[0] * 256 + b1[1]); +} + +/*:43*/ +/*44:*/ +Local Void junkchunk(LINK) +struct LOC_iffint *LINK; +{ + if (LINK->bmsize > P_maxpos(bitmap)) { + printf("File endend while reading junk\n"); + _Escape(0); + } + while (LINK->bmsize > 0) { + fread(&LINK->b, 1, 1, bitmap); + LINK->bmsize--; + } +/* p2c: bm2font.pas, line 509: + * Note: Can't interpret size in BLOCKREAD [174] */ +} /*:44*/ + +/*45:*/ +Local Void checkchunk(LINK) +struct LOC_iffint *LINK; +{ + short i, j, FORLIM; + + if (!strcmp(LINK->bmstr, "BMHD")) { + LINK->bmsize = ifflong(LINK); + if (LINK->bmsize & 1) + LINK->bmsize++; + LINK->hh = iffword(LINK); + LINK->vh = iffword(LINK); + LINK->hi = iffword(LINK); + LINK->vi = iffword(LINK); +/* p2c: bm2font.pas, line 513: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&LINK->bps, 1, 1, bitmap); +/* p2c: bm2font.pas, line 513: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&LINK->b, 1, 1, bitmap); +/* p2c: bm2font.pas, line 514: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&LINK->b, 1, 1, bitmap); + LINK->compr = LINK->b; + for (i = 1; i <= 4; i++) + fread(&xratio, 1, 1, bitmap); +/* p2c: bm2font.pas, line 515: + * Note: Can't interpret size in BLOCKREAD [174] */ +/* p2c: bm2font.pas, line 515: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&yratio, 1, 1, bitmap); + LINK->bmsize -= 16; + junkchunk(LINK); + if (LINK->bps == 1) { + LINK->col = 1; + return; + } + if (LINK->bps == 4) + LINK->col = 15; + else + LINK->col = 255; + return; + } + if (!strcmp(LINK->bmstr, "CMAP")) { + LINK->bmsize = ifflong(LINK); + LINK->col = LINK->bmsize / 3 - 1; + FORLIM = LINK->col; + for (i = 0; i <= FORLIM; i++) { + for (j = 0; j <= 2; j++) { + fread(&LINK->b, 1, 1, bitmap); + LINK->gpal[i][j] = LINK->b; + } +/* p2c: bm2font.pas, line 519: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (cmyk) { + colcyan = 255 - LINK->gpal[i][0]; + colmagenta = 255 - LINK->gpal[i][1]; + colyellow = 255 - LINK->gpal[i][2]; + if (colcyan != colmagenta || colcyan != colyellow || + colmagenta != colyellow) { + colcyan -= colmagenta / 3; + if (colcyan < 0) + colcyan = 0; + colmagenta -= colyellow / 3; + if (colmagenta < 0) + colmagenta = 0; + } + colblack = colcyan; + if (colblack > colmagenta) + colblack = colmagenta; + if (colblack > colyellow) + colblack = colyellow; + if (cyan) + LINK->hell[i] = 255 - colcyan; + if (magenta) + LINK->hell[i] = 255 - colmagenta; + if (yellow) + LINK->hell[i] = 255 - colyellow; + if (black) + LINK->hell[i] = 255 - colblack; + } else + LINK->hell[i] = (long)floor(LINK->gpal[i][0] * 0.287 + LINK->gpal[i] + [1] * 0.589 + LINK->gpal[i][2] * 0.114 + 0.5); + LINK->hell[i] = (long)(LINK->hell[i] / (256.0 / (LINK->col + 1))); + bhell[LINK->hell[i]] = (long)(255 - colblack / (256.0 / (LINK->col + 1))); + } + if (LINK->bmsize & 1) + fread(&LINK->b, 1, 1, bitmap); +/* p2c: bm2font.pas, line 534: + * Note: Can't interpret size in BLOCKREAD [174] */ + return; + } + if (!strcmp(LINK->bmstr, "CRNG")) { + LINK->bmsize = ifflong(LINK); + LINK->bmoff = iffword(LINK); + LINK->bmoff = iffword(LINK); + LINK->bmoff = iffword(LINK); +/* p2c: bm2font.pas, line 536: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&LINK->b, 1, 1, bitmap); +/* p2c: bm2font.pas, line 537: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&LINK->a, 1, 1, bitmap); + if (LINK->bmsize & 1) + fread(&LINK->b, 1, 1, bitmap); +/* p2c: bm2font.pas, line 537: + * Note: Can't interpret size in BLOCKREAD [174] */ + return; + } + LINK->bmsize = ifflong(LINK); + if (LINK->bmsize & 1) + LINK->bmsize++; + junkchunk(LINK); +} + + +/*:36*/ +/*41:*/ +Static Void iffint() +{ /*:45*/ + struct LOC_iffint V; + unsigned short ohh; + uchar cb; + short FORLIM, FORLIM1; + + /*46:*/ + printf("Analysing IFF file %s\n", bmname); + opentempfile(); + fread(V.bmstr, 4, 1, bitmap); + V.bmstr[4] = '\0'; + if (strcmp(V.bmstr, "FORM")) { + printf("Graphic file not stored as Interchange File Format\n"); + _Escape(0); + } + V.bmsize = ifflong(&V) + 8; + if (V.bmsize != P_maxpos(bitmap)) { + printf("File is incomplete, should contain %ld\n", V.bmsize); + _Escape(0); + } + fread(V.bmstr, 4, 1, bitmap); + V.bmstr[4] = '\0'; + if (strcmp(V.bmstr, "ILBM")) + printf("Type of file is %s, should be ILBM\n", V.bmstr); + fread(V.bmstr, 4, 1, bitmap); + V.bmstr[4] = '\0'; + while (strcmp(V.bmstr, "BODY")) { + if (P_eof(bitmap)) { + printf("No graphics information available\n"); + _Escape(0); + } + checkchunk(&V); + fread(V.bmstr, 4, 1, bitmap); + V.bmstr[4] = '\0'; + } + V.bmsize = ifflong(&V); + V.hh = (V.hh * V.bps + 7) / 8; + ohh = V.hh; + if (ohh & 1) + ohh++; + FORLIM = V.vh; + for (i = 1; i <= FORLIM; i++) { + if (P_eof(bitmap)) { + printf("ende\n"); + _Escape(0); + } + if (V.compr == 0) + fread(b3, ohh, 1, bitmap); + else { /*47:*/ + gbufp = 0; + while (gbufp < ohh) { + fread(&V.b, 1, 1, bitmap); + V.bmoff++; + if (V.b < 128) { + V.b++; +/* p2c: bm2font.pas, line 555: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&b3[gbufp], V.b, 1, bitmap); + gbufp += V.b; + continue; + } + if (V.b <= 128) + continue; +/* p2c: bm2font.pas, line 556: + * Note: Can't interpret size in BLOCKREAD [174] */ + fread(&V.a, 1, 1, bitmap); + V.b = 257 - V.b; + while (V.b > 0) { + b3[gbufp] = V.a; + gbufp++; + V.b--; + } + } +/* p2c: bm2font.pas, line 554: + * Note: Can't interpret size in BLOCKREAD [174] */ + } /*:47*/ +/* p2c: bm2font.pas, line 553: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (V.bps == 4) { /*48:*/ + gi = 0; + FORLIM1 = V.hh; + for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) + b2[gbufpp] = 0; + V.a = 0; + FORLIM1 = V.hh; + for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) { + V.b = b3[gbufpp]; + for (j = 0; j <= 3; j++) { + cb = V.b & 128; + cb >>= 3 - V.a; + b2[gi] ^= cb; + V.b <<= 1; + cb = V.b & 128; + cb >>= 7 - V.a; + b2[gi] ^= cb; + V.b <<= 1; + gi++; + } + if (gi >= V.hh) { + gi = 0; + V.a++; + } + } + FORLIM1 = V.hh; + for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) + b3[gbufpp] = b2[gbufpp]; + gi = 0; + FORLIM1 = V.hh; + for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) { + b2[gi] = (V.hell[b3[gbufpp] >> 4] << 4) + V.hell[b3[gbufpp] & 15]; + gi++; + } /*:48*/ + } else if (V.bps == 8) { + FORLIM1 = V.hh; + for (gbufp = 0; gbufp < FORLIM1; gbufp++) + b2[gbufp] = V.hell[b3[gbufp]]; + } else { + FORLIM1 = V.hh; + for (gbufp = 0; gbufp < FORLIM1; gbufp++) + b2[gbufp] = b3[gbufp]; + } +/* p2c: bm2font.pas, line 568: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b2, V.hh, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + mapinlen = V.hh; + bitspsam = V.bps; + posbit = 0; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + if (bitmap == NULL) + _EscIO(FileNotFound); + pcxtemp = true; + if (egastretch) { + if (xratio + 1 == yratio) + picstretch(); + } + posbit = 0; + if (bitspsam > 1) + greypxl = true; + mapdiv = 1.0; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + mapdiv *= 2; + mapdiv /= 16; +} /*:46*/ + + +/*49:*/ +Static Void bmpint() +{ + unsigned short i, k, hi, hh, hhl, vi, vh, compr, lcol; + uchar j, b, a, col, bps; + uchar gpal[256][4]; + unsigned short hell[256]; + Char bmstr[256]; + long bmsize, bmoff; + unsigned short FORLIM; + + printf("Analysing BMP file %s\n", bmname); + opentempfile(); + fread(bmstr, 2, 1, bitmap); + bmstr[2] = '\0'; + if (strcmp(bmstr, "BM")) { + printf("No windows bitmap %s\n", bmstr); + _Escape(0); + } + gbufp = 640; + pxlinlen = 640; + bmsize = longpcx(); + for (i = 1; i <= 4; i++) + b = getpcx(); + bmoff = longpcx(); + bmsize = longpcx(); + bmoff -= bmsize; + if (bmsize > 12) { + hi = longpcx(); + vi = longpcx(); + b = getpcx(); + b = getpcx(); + bps = wordpcx(); + if (bps > 8) { + printf("only up to 256 colors supported\n"); + _Escape(0); + } + hh = hi; + vh = vi; + compr = longpcx(); + for (i = 1; i <= 4; i++) + b = getpcx(); + xratio = longpcx(); + yratio = longpcx(); + lcol = longpcx(); + lcol--; + if (col == 0) { + if (bps == 1) + col = 1; + else if (bps == 4) + col = 15; + else + col = 255; + } + col = longpcx(); + col--; + } else { + hi = wordpcx(); + vi = wordpcx(); + b = getpcx(); + b = getpcx(); + bps = wordpcx(); + if (bps > 8) { + printf("only up to 256 colors supported\n"); + _Escape(0); + } + hh = hi; + vh = vi; + compr = 0; + xratio = 1; + yratio = 1; + col = 0; + } + if (lcol == 0) { + if (bps == 1) + col = 1; + else if (bps == 4) + col = 15; + else + col = 255; + } + if (bps == 1) + col = 1; + else if (bps == 4) + col = 15; + else + col = 255; + for (i = 0; i <= col; i++) { + if (bmsize > 12) { + for (j = 0; j <= 3; j++) + gpal[i][j] = getpcx(); + } else { + for (j = 0; j <= 2; j++) + gpal[i][j] = getpcx(); + } + if (cmyk) { + colcyan = 255 - gpal[i][2]; + colmagenta = 255 - gpal[i][1]; + colyellow = 255 - gpal[i][0]; + if (colcyan != colmagenta || colcyan != colyellow || + colmagenta != colyellow) { + colcyan -= colmagenta / 3; + if (colcyan < 0) + colcyan = 0; + colmagenta -= colyellow / 3; + if (colmagenta < 0) + colmagenta = 0; + } + colblack = colcyan; + if (colblack > colmagenta) + colblack = colmagenta; + if (colblack > colyellow) + colblack = colyellow; + if (cyan) + hell[i] = 255 - colcyan; + if (magenta) + hell[i] = 255 - colmagenta; + if (yellow) + hell[i] = 255 - colyellow; + if (black) + hell[i] = 255 - colblack; + hell[i] = (long)(hell[i] / (256.0 / (col + 1))); + bhell[hell[i]] = (long)((255 - colblack) / (256.0 / (col + 1))); + } else + hell[i] = (long)((gpal[i][2] * 0.287 + gpal[i][1] * 0.589 + gpal[i] + [0] * 0.114) / (256.0 / (col + 1))); + } + if (bmsize > 12) + bmoff -= (col + 1) * 4; + else + bmoff -= (col + 1) * 3; + if (compr != 0) { + printf("compression not supported yet\n"); + _Escape(0); + } + hh = (hh * bps + 7) / 8; + hhl = (hh + 3) / 4 * 4 - 1; + a = 8 - ((hi * bps) & 7); +/* p2c: bm2font.pas, line 616: + * Note: Suspicious mixture of sizes in FILLCHAR [173] */ + memset((Anyptr)b3, 0, hhl + 1L); + for (i = 1; i <= vh; i++) { /*$I-*/ + _SETIO(fwrite(b3, hh, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 617: + * Note: Can't interpret size in BLOCKWRITE [174] */ + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + if (tmpfil == NULL) + _EscIO(FileNotFound); + bmoff = (vh - 1) * (long)hh; + for (i = 0; i < vh; i++) { + for (k = 0; k <= hhl; k++) + b3[k] = getpcx(); + if (bps == 4) { + gi = 0; + for (k = 0; k < hh; k++) { + b2[gi] = (hell[b3[k] >> 4] << 4) + hell[b3[k] & 15]; + gi++; + } + } else if (bps == 8) { + for (k = 0; k < hh; k++) + b2[k] = hell[b3[k]]; + } else { + for (k = 0; k < hh; k++) + b2[k] = b3[k]; + } + if (a < 8) { + for (k = 0; k < a; k++) + b2[hh - 1] ^= invbit >> k; + } + fseek(tmpfil, bmoff, 0); + bmoff = bmoff - (long)hh; +/* p2c: bm2font.pas, line 629: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + mapinlen = hh; + posbit = 0; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + if (bitmap == NULL) + _EscIO(FileNotFound); + pcxtemp = true; + bitspsam = bps; + if (bitspsam > 1) + greypxl = true; + mapdiv = 1.0; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + mapdiv *= 2; + mapdiv /= 16; +} + + +/*50:*/ +Static Void imgint() +{ + unsigned short i, ki, hi, hh, bzf, imgpat; + short vh; + uchar mi, cb, j, b, a, col, bps; + unsigned short hell[16]; + uchar linerep; + unsigned short FORLIM; + + printf("Analysing IMG file %s\n", bmname); + invert = !invert; + if (invert) { /*51:*/ + invbit = 0; + invbyte = 0; + } else { + invbit = 1; + invbyte = 255; + } + hell[0] = 0; + hell[1] = 1; + hell[2] = 6; + hell[3] = 8; + hell[4] = 3; + hell[5] = 2; + hell[6] = 7; + hell[7] = 11; + hell[8] = 4; + hell[9] = 5; + hell[10] = 12; + hell[11] = 13; + hell[12] = 10; + hell[13] = 9; + hell[14] = 14; + hell[15] = 15; + opentempfile(); /*:51*/ + gbufp = 640; + pxlinlen = 640; + a = getpcx(); + b = getpcx(); + if (a * 256 + b != 1) { /*52:*/ + printf("File does not contain GEM Image File Format\n"); + _Escape(0); + } + b = getpcx(); + bzf = b * 256; + b = getpcx(); + bzf += b; + b = getpcx(); + bps = b * 256; + b = getpcx(); + bps += b; + b = getpcx(); + imgpat = b * 256; + b = getpcx(); + imgpat += b; + b = getpcx(); + xratio = b * 256; + b = getpcx(); + xratio += b; + b = getpcx(); + yratio = b * 256; + b = getpcx(); + yratio += b; + if (xratio != yratio) { + mapdiv = (double)yratio / xratio; + xratio = 0; + yratio = 0; + while (xratio == yratio) { + xratio++; + yratio = (long)floor(xratio * mapdiv + 0.5); + } + } + b = getpcx(); + hi = b * 256; + b = getpcx(); + hi += b; + b = getpcx(); + vh = b * 256; + b = getpcx(); + vh += b; /*:52*/ + hh = (hi * bps + 7) / 8; + if (bzf > 8) { + for (i = 1; i <= (bzf - 8) * 2; i++) + b = getpcx(); + } + linerep = 0; + gi = 0; + while (vh > 0) { + for (gi = 0; gi <= hh; gi++) + b3[gi] = 0; + gi = 0; + while (gi < hh) { + b = getpcx(); + if (b != 0 && b != 128) { + a = b & 127; + cb = ((unsigned)(b - a)) >> 7; + if (cb == 1) + cb = 255; + for (ki = 1; ki <= a; ki++) { + b3[gi] = cb; + gi++; + } + continue; + } + if (b == 128) { + a = getpcx(); + for (ki = 1; ki <= a; ki++) { + b3[gi] = getpcx(); + gi++; + } + continue; + } + a = getpcx(); + if (a <= 0) { + b = getpcx(); + linerep = getpcx(); + continue; + } + for (ki = 1; ki <= imgpat; ki++) + b2[ki] = getpcx(); + for (ki = 1; ki <= a; ki++) { + for (mi = 1; mi <= imgpat; mi++) { + b = b2[mi]; + b3[gi] = b; + gi++; + } + } + } + if (bps == 4) { /*48:*/ + gi = 0; + for (gbufpp = 0; gbufpp < hh; gbufpp++) + b2[gbufpp] = 0; + a = 0; + for (gbufpp = 0; gbufpp < hh; gbufpp++) { + b = b3[gbufpp]; + for (j = 0; j <= 3; j++) { + cb = b & 128; + cb >>= 3 - a; + b2[gi] ^= cb; + b <<= 1; + cb = b & 128; + cb >>= 7 - a; + b2[gi] ^= cb; + b <<= 1; + gi++; + } + if (gi >= hh) { + gi = 0; + a++; + } + } + for (gbufpp = 0; gbufpp < hh; gbufpp++) + b3[gbufpp] = b2[gbufpp]; + gi = 0; + for (gbufpp = 0; gbufpp < hh; gbufpp++) { + b2[gi] = (hell[b3[gbufpp] >> 4] << 4) + hell[b3[gbufpp] & 15]; + gi++; + } /*:48*/ + } else { + for (ki = 0; ki < hh; ki++) + b2[ki] = b3[ki]; + } +/* p2c: bm2font.pas, line 674: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + vh--; + if (linerep <= 0) + continue; + for (i = 1; i <= linerep; i++) { /*$I-*/ + _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 678: + * Note: Can't interpret size in BLOCKWRITE [174] */ + vh += 1 - linerep; + linerep = 0; + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + if (col == 4) { + bitspsam = 4; + greypxl = true; + } else if (bps > 1) { + bitspsam = bps; + greypxl = true; + } + mapinlen = hh; + posbit = 0; + strcpy(bitmap_NAME, "pcxtemp.tmp"); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + if (bitmap == NULL) + _EscIO(FileNotFound); + if (egastretch) { + if (xratio + 1 == yratio) + picstretch(); + } + posbit = 0; + pcxtemp = true; + mapdiv = 1.0; + FORLIM = bitspsam; + for (i = 1; i <= FORLIM; i++) + mapdiv *= 2; + mapdiv /= 16; +} + + +/*54:*/ +Static Void tfmhword(hword) +long hword; +{ + union { + uchar b[4]; + long i; + } ax; + short i; + + ax.i = hword; +#ifdef INTEL + for (i = 1; i >= 0; i--) + fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile); +#else + for (i = 2; i <= 3; i++) + fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile); +#endif +} + + +Static Void tfmword(lword) +long lword; +{ + union { + uchar b[4]; + long i; + } ax; + short i; + + ax.i = lword; +#ifdef INTEL + for (i = 3; i >= 0; i--) + fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile); +#else + for (i = 0; i <= 3; i++) + fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile); +#endif +} + + +/*:54*/ +/*57:*/ +Static Void pxlmap(lword) +long lword; +{ + union { + ebts b[4]; + long i; + } ax; + uchar i; + + ax.i = lword; + for (i = 0; i <= 3; i++) { + pxlbm[pxlbmi] = ax.b[i]; + pxlbmi++; + } +} /*:57*/ + + +/*61:*/ +Static Void pkbyte(b) +uchar b; +{ + pkbm[pkloc] = b; + pkloc++; +} + + +Static Void pkhalfword(a) +short a; +{ + union { + ebts b[2]; + short w; + } ax; + + ax.w = a; +#ifdef INTEL + pkbyte(ax.b[1]); + pkbyte(ax.b[0]); +#else + pkbyte(ax.b[0]); + pkbyte(ax.b[1]); +#endif +} + + +Static Void pkthreebytes(a) +long a; +{ + union { + ebts b[4]; + long i; + } ax; + + ax.i = a; +#ifdef INTEL + pkbyte(ax.b[2]); + pkbyte(ax.b[1]); + pkbyte(ax.b[0]); +#else + pkbyte(ax.b[1]); + pkbyte(ax.b[2]); + pkbyte(ax.b[3]); +#endif +} + + +Static Void pkword(a) +long a; +{ + union { + ebts b[4]; + long i; + } ax; + + ax.i = a; +#ifdef INTEL + pkbyte(ax.b[3]); + pkbyte(ax.b[2]); + pkbyte(ax.b[1]); + pkbyte(ax.b[0]); +#else + pkbyte(ax.b[0]); + pkbyte(ax.b[1]); + pkbyte(ax.b[2]); + pkbyte(ax.b[3]); +#endif +} + + +Static Void pknyb(a) +uchar a; +{ + if (bitweight == 16) { + outputbyte = a << 4; + bitweight = 1; + } else { + pkbyte(outputbyte + a); + bitweight = 16; + } +} + + +/*:61*/ +/*63:*/ +Static Void writepreambl() +{ + short i; + Char nstr[256]; + + sprintf(nstr, "%ld", (long)floor(truehres + 0.5)); +#ifdef MSDOS + sprintf(cmd, "%s%c.pk", font, fontpre[nf]); +#else + sprintf(cmd, "%s%c.%spk", font, fontpre[nf], nstr); +#endif + strcpy(pxlfile_NAME, cmd); + if (pxlfile != NULL) + pxlfile = freopen(pxlfile_NAME, "w+b", pxlfile); + else + pxlfile = fopen(pxlfile_NAME, "w+b"); + _SETIO(pxlfile != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 3 || filestat == 5) { + strcpy(cmd, bmname); + sprintf(cmd + strlen(cmd), "%c.pk", fontupc[nf]); + strcpy(pxlfile_NAME, cmd); + if (pxlfile != NULL) + pxlfile = freopen(pxlfile_NAME, "w+b", pxlfile); + else + pxlfile = fopen(pxlfile_NAME, "w+b"); + _SETIO(pxlfile != NULL, FileNotFound); + filestat = P_ioresult; + } + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("error occurred when "); + printf("allocating pkfile "); + puts(cmd); + fileproblem(); + _Escape(0); + } + pkloc = 0; + pkbyte(247); + pkbyte(89); + pkbyte(14); + strcpy(comment, "BM2FONT output"); + for (i = 0; i <= 13; i++) + pkbyte(comment[i]); + pkword(tabdsize[nf]); + pkword(checksum); + pkword(floor(truehres * 65536L / 72.27 + 0.5)); + pkword(floor(truevres * 65536L / 72.27 + 0.5)); + nextmemfree = 0; + printf("Packing font %s\n", cmd); +} + + +/*:63*/ +/*65:*/ +Static Void writepostamb() +{ + pkbyte(245); + while ((pkloc & 3) != 0) + pkbyte(246); +/* p2c: bm2font.pas, line 781: + * Note: Can't interpret size in BLOCKWRITE [174] */ + _SETIO(fwrite(pkbm, pkloc, 1, pxlfile) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing font %s!\n", cmd) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + if (pxlfile != NULL) + fclose(pxlfile); + pxlfile = NULL; + printf(" \n"); + printf("Font %s at %ld dots per inch written\n", + cmd, (long)floor(truehres + 0.5)); + nf++; + if (nf > 25) { + printf("More then 26 fonts! Giving up\n"); + _Escape(0); + } + charpf[nf] = ng; + ng = 0; + pkloc = 0; +} + + +/*:65*/ +/*67:*/ +Static boolean equal(row1, row2) +pxlstr row1, row2; +{ + short i; + boolean temp; + + i = pkwidth; + temp = true; + while (i > 0 && temp) { + if (pxlbm[row1] != pxlbm[row2]) + temp = false; + row1++; + row2++; + i -= 8; + } + return temp; +} + + +/*:67*/ +/*68:*/ +Static boolean equalzo(row1, row2) +pxlstr row1; +short row2; +{ + short i; + boolean temp; + + i = pkwidth; + temp = true; + while (i > 0 && temp) { + if (pxlbm[row1] != (repbm[row2] & 255)) + temp = false; + row1++; + row2++; + i -= 8; + } + return temp; +} + + +/*:68*/ +/*70:*/ +Static Void shipcharacte() +{ /*:87*/ + pxlstr crst; + short wwid; + long compsize; + long horesc; + /*72:*/ + short l; + long i, j, k; + short rowzero, onesrow, repptr, bitcounts; + ebts fillbytes, longind, mixbyte, restbyte, pkshift, dshift; + long longtab[20]; + /*:72*/ + /*77:*/ + long count; + short test, curptr, bit, repflag; + schar pkkword; + short bitptr, bitmod32, currepeat; + pxlstr endraster; /*:77*/ + /*80:*/ + short dynf; + long deriv[13]; + long bcompsize; + boolean firston; + short flagbyte; + /*:80*/ + /*87:*/ + unsigned short max2; + pxlstr predpkloc; + short bytelength; + + horesc = pwidth[f][car]; + pkwidth = pwidth[f][car]; + pkheight = pheight[f][car]; + pkheight -= yoffset[f][car]; + cxoff = 0; + cyoff = pkheight; + crst = pkpoint[car]; + wwid = (pkwidth + 31) / 32 * 4; + fillbytes = wwid - (pkwidth + 7) / 8; /*71:*/ + rowzero = nextmemfree; + onesrow = nextmemfree + wwid; + repptr = onesrow + wwid; + bitcounts = repptr + pkheight + 1; + for (i = rowzero; i < onesrow; i++) + repbm[i] = 0; + for (i = onesrow; i <= repptr - 2; i++) + repbm[i] = -1; + j = onesrow + (((unsigned long)(pkwidth + 7)) >> 3); + repbm[j - 1] = power[8] - power[7 - ((pkwidth + 7) & 7)]; + for (i = j; i < repptr; i++) + repbm[i] = 0; + i = 0; + j = pkheight; + while (i < j) { + if (equalzo((i * wwid + crst), rowzero)) + repbm[repptr + i] = 0; + else if (equalzo((i * wwid + crst), onesrow)) + repbm[repptr + i] = 0; + else if (i + 1 == j) + repbm[repptr + i] = 0; + else if (equal((i * wwid + crst), (int)((i + 1) * wwid + crst))) + repbm[repptr + i] = 1; + else + repbm[repptr + i] = 0; + i++; + } + i = 0; + while (i < j) { + k = i; + while (repbm[repptr + k] == 1) + k++; + repbm[repptr + i] = k - i; + i = k + 1; + } + repbm[repptr + i] = 0; /*:71*/ + /*75:*/ + repflag = 0; + bitptr = pkwidth - 1; + currepeat = repptr; + endraster = crst + pkheight * wwid; + curptr = bitcounts; + count = 0; + longind = 0; + test = 0; + do { /*76:*/ + bitptr++; + if (bitptr == pkwidth) { + bitmod32 = 0; + bitptr = 0; + if (currepeat > repptr) + crst += fillbytes; + if (repbm[currepeat] > 0) { + repflag = repbm[currepeat]; + currepeat += repflag; + crst += wwid * repflag; + } + currepeat++; + } + bitmod32--; + if (bitmod32 == -1) { + bitmod32 = 7; + pkkword = pxlbm[crst]; + crst++; + } + if (crst > endraster) + bit = 2; + else if (pkkword < 0) + bit = 1; + else + bit = 0; + pkkword <<= 1; /*:76*/ + if (bit == test) + count++; + else { + if (count > 32767) { + longind++; + longtab[longind - 1] = count; + count = -longind - 10000; + } + repbm[curptr] = count; + curptr++; + if (curptr + 1 > maxmemsize) + test = 3; + else { + count = 1; + test = bit; + if (repflag > 0) { + repbm[curptr] = -repflag; + repflag = 0; + curptr++; + } + } + } + } while (test < 2); + repbm[curptr] = 0; + repbm[curptr + 1] = 0; /*:75*/ + /*78:*/ + if (test < 3) { + for (i = 0; i <= 12; i++) + deriv[i] = 0; + firston = (repbm[bitcounts] == 0); + if (firston) + bitcounts++; + i = bitcounts; + compsize = 0; + while (repbm[i] != 0) { /*79:*/ + j = repbm[i]; + if (j < -10000) + j = longtab[-j - 10001]; + if (j == -1) + compsize++; + else { + if (j < 0) { + compsize++; + j = -j; + } + if (j < 209) + compsize += 2; + else { + k = j - 193; + while (k >= 16) { + k = ((unsigned long)k) >> 4; + compsize += 2; + } + compsize++; + } + if (j < 14) + deriv[j - 1]--; + else if (j < 209) + deriv[(223 - j) / 15 - 1]++; + else { + k = 16; + while (k <= ((unsigned long)(j + 2)) >> 4) { + k <<= 4; + if (k == 0) { + k = 32767; + j += 32767; + } + } + if (j - k <= 192) + deriv[(k - j + 207) / 15 - 1] += 2; + } + } + i++; + } + /*:79*/ + bcompsize = compsize; + dynf = 0; + for (i = 1; i <= 13; i++) { + compsize += deriv[i - 1]; + if (compsize <= bcompsize) { + bcompsize = compsize; + dynf = i; + } + } + compsize = (bcompsize + 1) / 2; + if (compsize > (pkheight * pkwidth + 7) / 8 || pkheight * pkwidth == 0) { + compsize = (pkheight * pkwidth + 7) / 8; + dynf = 14; + } + } else { + dynf = 14; + firston = (repbm[bitcounts] == 0); + compsize = (pkheight * pkwidth + 7) / 8; + } + if (pkloc + compsize > 65487L || ng > 127) { /*81:*/ + writepostamb(); + if (nf > 26) { + printf("Sorry, more than 26 fonts necessary, reduce bitmap\n"); + _Escape(0); + } + writepreambl(); + } + flagbyte = dynf * 16; + if (firston) + flagbyte += 8; + if (width[f][car] > 16777215L || width[f][car] < 0 || horesc < 0 || + compsize > 196594L || pkwidth > 65535L || pkheight > 65535L || + cxoff > 32767 || cyoff > 32767 || cxoff < -32768L || cyoff < -32768L) + { /*82:*/ + flagbyte += 7; + pkbyte(flagbyte); + compsize += 28; + pkword(compsize); + pkword(ng); + predpkloc = pkloc + compsize; + pkword(width[f][car]); + pkword(horesc); + pkword(0); + pkword(pkwidth); + pkword(pkheight); + pkword(cxoff); + pkword(cyoff); + } /*:82*/ + else if (horesc > 255 || pkwidth > 255 || pkheight > 255 || cxoff > 127 || + cyoff > 127 || cxoff < -128 || cyoff < -128 || compsize > 1015) { + compsize += 13; + flagbyte += compsize / 65536L + 4; + pkbyte(flagbyte); +/* p2c: bm2font.pas, line 874: + * Note: Using % for possibly-negative arguments [317] */ + pkhalfword((compsize % 65536L)); + pkbyte(ng); + predpkloc = pkloc + compsize; + pkthreebytes(width[f][car]); + pkhalfword(horesc); + pkhalfword(pkwidth); + pkhalfword(pkheight); + pkhalfword(cxoff); + pkhalfword(cyoff); + } else { + compsize += 8; + flagbyte += compsize / 256; + pkbyte(flagbyte); + pkbyte((compsize & 255)); + pkbyte(ng); + predpkloc = pkloc + compsize; + pkthreebytes(width[f][car]); + pkbyte(horesc & 255); + pkbyte(pkwidth); + pkbyte(pkheight); + pkbyte(cxoff); + pkbyte(cyoff); + } + if (dynf != 14) { /*85:*/ + bitweight = 16; + max2 = 208 - dynf * 15; + i = bitcounts; + while (repbm[i] != 0) { + j = repbm[i]; + if (j < -10000) + j = longtab[-j - 10001]; + if (j == -1) + pknyb(15); + else { + if (j < 0) { + pknyb(14); + j = -j; + } + if (j <= dynf) + pknyb(j); + else if (j <= max2) { + j += -dynf - 1; + pknyb(((j) >> 4) + dynf + 1); + pknyb((j & 15)); + } else { + j += 15 - max2; + k = 1; + while (k <= ((unsigned long)j) >> 4) { + k <<= 4; + pknyb(0); + } + while (k > 0) { + pknyb((j / k)); + j %= k; +/* p2c: bm2font.pas, line 889: + * Note: Using % for possibly-negative arguments [317] */ + k = ((unsigned long)k) >> 4; + } + } + } + i++; + } + if (bitweight != 16) + pkbyte(outputbyte); + } else /*86:*/ + { /*:86*/ + crst = pkpoint[car]; + bytelength = (((unsigned long)(pkwidth + 7)) >> 3) - 1; + if ((pkwidth & 7) == 0) { + while (crst < endraster) { + for (i = 0; i <= bytelength; i++) + pkbyte(pxlbm[crst + i]); + crst += wwid; + } + } else { + pkshift = 0; + dshift = pkwidth & 7; + while (crst < endraster) { + if (pkshift == 0) { + for (i = 0; i < bytelength; i++) + pkbyte(pxlbm[crst + i]); + mixbyte = pxlbm[crst + bytelength]; + } else { + i = crst; + l = pkwidth + pkshift; + while (l >= 8) { + l -= 8; + restbyte = pxlbm[i]; + i++; + pkbyte(mixbyte + (restbyte >> pkshift)); + mixbyte = restbyte << (8 - pkshift); + } + if (pkshift < ((pkshift + dshift) & 7)) + mixbyte += pxlbm[i] >> pkshift; + } + crst += wwid; + pkshift = (pkshift + dshift) & 7; + } + if (pkshift > 0) + pkbyte(mixbyte); + } + } + /*:85*/ + if (predpkloc != pkloc) { + printf("Bad predicted character length: character %d\n", car); + printf("pred: %uloc: %u\n", predpkloc, pkloc); + _Escape(0); + } + pkpoint[car] = 0; /*:78*/ + putchar('.'); + if (car == 79) + putchar('\n'); + pwidth[nf][ng] = pwidth[f][car]; + pheight[nf][ng] = pheight[f][car]; + width[nf][ng] = width[f][car]; + height[nf][ng] = height[f][car]; + yoffset[nf][ng] = yoffset[f][car]; + ng++; + + /*84:*/ + /*:84*/ + /*83:*/ + /*:83*/ + /*:81*/ +} + + +/*:70*/ +/*88:*/ +Static Void fonteject() +{ + short lx, FORLIM, FORLIM1, FORLIM2; + + nf = 0; + ng = 0; + writepreambl(); + while (maplines > 0) { + FORLIM = maxx; + for (k = 1; k <= FORLIM; k++) { + i = k - 1; + dirpoint[g] = pxlbmi / 4; + pkpoint[g] = pxlbmi; + linepos_ = posbit + i * hres / 8; + pxlinlen = (pwidth[f][g] + 7) / 8; + zeroline = true; + gi = 0; + FORLIM1 = pheight[f][g]; + for (v = 1; v <= FORLIM1; v++) { + fseek(bitmap, linepos_, 0); +/* p2c: bm2font.pas, line 916: + * Note: Can't interpret size in BLOCKREAD [174] */ + j = fread(b1, 1, pxlinlen, bitmap); + FORLIM2 = pxlinlen; + for (lx = 0; lx < FORLIM2; lx++) + b2[lx] = b1[lx]; + if (invert) { + FORLIM2 = pxlinlen; + for (lx = 0; lx < FORLIM2; lx++) + b2[lx] = 255 - b1[lx]; + } + gi += dv; + if (gi >= lv) + gi -= cv; + if (invbyte == 255) { + FORLIM2 = pxlinlen; + for (lx = 0; lx < FORLIM2; lx++) + b1[lx] = invbyte - b1[lx]; + } + lx = 0; + zerorow = true; + FORLIM2 = pxlinlen; + for (j = 0; j < FORLIM2; j++) { + if (b1[j] != 0) { + zerorow = false; + zeroline = false; + } + } + if (zeroline) { + yoffset[f][g]++; + if (yoffset[f][g] == pheight[f][g]) { + yoffset[f][g]--; + zerorow = false; + zeroline = false; + } + } + cx.i = 0; + if (!zeroline) { + FORLIM2 = pxlinlen; + for (j = 0; j < FORLIM2; j++) { + if (lx > 3) { + lx = 0; + pxlmap(cx.i); + cx.i = 0; + } + cx.b[lx] = b1[j]; + lx++; + } + pxlmap(cx.i); + } + linepos_ += (mapwidth + 7) / 8 + zeropads; + } + i += maxx; + g++; + if (g == mincharpf) { /*89:*/ + for (car = 0; car <= 127; car++) { + if (pkpoint[car] != 0) + shipcharacte(); + } + f++; + g = 0; + pxlbmi = 4; + } + /*:89*/ + } + maplines -= vres; + posbit += vres * ((mapwidth + 7) / 8 + zeropads); + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; /*90:*/ + for (car = 0; car <= 127; car++) { + if (pkpoint[car] != 0) + shipcharacte(); + } + writepostamb(); + noffonts = nf; /*:90*/ +} + + +/*:88*/ +/*103:*/ +Static Void userhelp() +{ + short FORLIM, FORLIM1; + + sprintf(cmd, "%s.tex", font); + strcpy(texfile_NAME, cmd); + if (texfile != NULL) + texfile = freopen(texfile_NAME, "w", texfile); + else + texfile = fopen(texfile_NAME, "w"); + _SETIO(texfile != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (filestat == 5) { + *cmd = '\0'; + sprintf(cmd + strlen(cmd), "%s.tex", font); + strcpy(texfile_NAME, cmd); + if (texfile != NULL) + texfile = freopen(texfile_NAME, "w", texfile); + else + texfile = fopen(texfile_NAME, "w"); + _SETIO(texfile != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + } + if (fok) { /*104:*/ + printf("%s error occured when allocating TeXfile %s\n", cmd, cmd); + fileproblem(); + _Escape(0); + } + fprintf(texfile, "\\newbox\\%sbox\n", font); + fprintf(texfile, "\\newdimen\\%swd\n", font); + FORLIM = noffonts; + for (a = 1; a <= FORLIM; a++) { + fprintf(texfile, "\\font\\%s%c=%s%c at ", + font, fontpre[a - 1], font, fontpre[a - 1]); + outfix(tabdsize[a - 1]); + fprintf(texfile, "truept\n"); + } + fprintf(texfile, "\\setbox\\%sbox=\\vbox{\\hbox{%%\n", font); + a = 0; + k = 1; + c = 0; + i = (mapwidth + hres - 1) / hres; + FORLIM = i; + for (b = 1; b <= FORLIM; b++) { + if (a != k) { + fprintf(texfile, "\\%s%c", font, fontpre[k - 1]); + a = k; + } + fprintf(texfile, "\\char%d", c); + if ((b & 7) == 0 && b != i) + fprintf(texfile, "%%\n"); + c++; + if (c == charpf[k]) { + k++; + c = 0; + } + } + fprintf(texfile, "}}\n"); + /*:104*/ + /*105:*/ + fprintf(texfile, "\\%swd=\\wd\\%sbox\n", font, font); + fprintf(texfile, "\\setbox\\%sbox=\\hbox{\\vbox{\\hsize=\\%swd\n", + font, font); + fprintf(texfile, "\\parskip=0pt\\offinterlineskip\\parindent0pt\n"); + v = 1; + k = 1; + c = 0; + FORLIM = nj; + for (a = 0; a < FORLIM; a++) { + fprintf(texfile, "\\hbox{\\%s%c", font, fontpre[k - 1]); + v = k; + FORLIM1 = i; + for (b = 0; b < FORLIM1; b++) { + if (v != k) { + fprintf(texfile, "\\%s%c", font, fontpre[k - 1]); + v = k; + } + fprintf(texfile, "\\char%d", c); + if (((b + 1) & 7) == 0 && b + 1 != i) + fprintf(texfile, "%%\n"); + c++; + if (c == charpf[k]) { + k++; + c = 0; + } + } + if (a < nj - 1) + fprintf(texfile, "}\n"); + } + fprintf(texfile, "}}}\n"); + fprintf(texfile, "\\ifx\\parbox\\undefined\n"); + fprintf(texfile, " \\def\\set%s{\\box\\%sbox}\n", font, font); + fprintf(texfile, "\\else\n"); + fprintf(texfile, " \\def\\set%s{\\parbox{\\wd\\%sbox}", font, font); + fprintf(texfile, "{\\box\\%sbox}}\n", font); + fprintf(texfile, "\\fi\n"); + if (texfile != NULL) + fclose(texfile); + texfile = NULL; + printf("File %s written\n", cmd); /*:105*/ +} + + +/*:103*/ +/*106:*/ +main(argc, argv) +int argc; +Char *argv[]; +{ + short FORLIM; + Char STR2[256]; + uchar FORLIM1; + short FORLIM2, FORLIM3; + uchar FORLIM4; + + PASCAL_MAIN(argc, argv); + tfmfile = NULL; + tmpfil = NULL; + pxlfile = NULL; + bitmap = NULL; + texfile = NULL; + power[0] = 1; + for (i = 1; i <= 8; i++) + power[i] = power[i - 1] * 2; + pxlbm = (uchar *)Malloc(sizeof(pxla)); + pkbm = (uchar *)Malloc(sizeof(pxla)); + repbm = (short *)Malloc(sizeof(pxlba)); + gkorh = (short *)Malloc(sizeof(korbyte)); + gkordivp = (short *)Malloc(sizeof(korbyte)); + spreadvals = (short *)Malloc(sizeof(spreadbyte)); + width = (long(*)[129])Malloc(sizeof(dynlong)); + height = (long(*)[129])Malloc(sizeof(dynlong)); + yoffset = (unsigned short(*)[129])Malloc(sizeof(dynword)); + pwidth = (unsigned short(*)[129])Malloc(sizeof(dynword)); + pheight = (unsigned short(*)[129])Malloc(sizeof(dynword)); + greymem = (uchar *)Malloc(sizeof(pxla)); /*107:*/ + strcpy(cref, "!()+,-./0123456789:;<=>?"); + strcat(cref, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); +/* p2c: bm2font.pas, line 974: + * Note: Possible string truncation in assignment [145] */ + strcat(cref, "abcdefghijklmnopqrstuvwxyz"); +/* p2c: bm2font.pas, line 975: + * Note: Possible string truncation in assignment [145] */ + strcpy(fontupc, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + strcpy(fontpre, "abcdefghijklmnopqrstuvwxyz"); + truehres = 0.0; + truevres = 0.0; + halfinch = false; + invert = false; + greypxl = false; + pcxtemp = false; + giftemp = false; + cutgrey = false; + aliasused = false; + cmyk = false; + cyan = false; + magenta = false; + yellow = false; + black = false; + saveblack = false; + clipon = true; + xratio = 0; + yratio = 0; + egastretch = true; + ledprinter = false; + distribute = true; + brightness = 0; + bitspsam = 8; + nowhite = true; + usepxl = 0; + vusepxl = 0; + hrep = 1; + vrep = 1; + valinc = 70.0; + gradint = 70; + newwidth = 0; + newheight = 0; + printf("This is BitMapTOfont, version 3.0 of january 94, via p2c\n"); + printf("Converting Bitmap Files to TeX-Fonts\n"); + /*assign(logfile,'test.log');rewrite(logfile);close(logfile);*/ + /*110:*/ + if (P_argc == 1) { + printf("usage is BM2FONT filename and parameters\n"); + printf("-f<name of picture for TeX> (std filename)\n"); + printf("-h<horizontal resolution> (pixel/inch, std 300)\n"); + printf("-v<vertical resolution> (pixel/inch, std 300)\n"); + printf("-l<length of mapline> (in bytes, only pure bitmaps)\n"); + printf("-p<height of character 1 inch> (y or n, std y)\n"); + printf("-e<stretch EGA pictures> (y or n, std y)\n"); + printf("-i<inversion of pixels> (y or n, std n)\n"); + printf("-g<greypixels in bitmap> (y or n, std n)\n"); + printf("-w<let white be light grey> (y or n, std y)\n"); + printf("-d<distribute errors> (y or n, std y)\n"); + printf("-s<separation of grey dots> (y or n, std n)\n"); + printf("-r<repeat each grey pixel> (y or n, std n)\n"); + printf("-u<pixels for grey rectangle> (less 8)\n"); + printf("-c<vert. pixels for rectangle> (less 8)\n"); + printf("-x<bits per sample> (0 < x < 9)\n"); + printf("-b<reduce halftone colors> (f.e. by 1, less u*c*4, std 0)\n"); + printf("-t<gradation value> (in %%, std 70)\n"); + printf("-z<area of gradation> (in %%, std 70)\n"); + printf("-m<width of picture on paper> (in mm)\n"); + printf("-n<height of picture on paper> (in mm)\n"); + printf("-j<clip off white space> (y or n, std y)\n"); + printf("-k<color: c,m,y or k> (std k)\n"); + /*readln(comment); +if length(comment)=0 then goto 9999;j:=ord(comment[0])+1; +if j<=127 then move(comment[0],mem[prefixseg:$80],j);*/ + goto _L9999; + } + /*:110*/ + /*111:*/ + for (j = 1; j < P_argc; j++) { + strcpy(comment, P_argv[j]); + if (comment[0] != '-') { + strcpy(font, comment); + if (strlen(font) < 1 || !strcmp(font, " ")) { + printf("give the name of your bitmap file next time\n"); + goto _L9999; + } + } else { + switch (comment[1]) { + + case 'h': + case 'H': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%lg", &truehres) == 0); + break; + + case 'v': + case 'V': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%lg", &truevres) == 0); + break; + + case 'l': + case 'L': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &mapinlen) == 0); + break; + + case 'm': + case 'M': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &newwidth) == 0); + break; + + case 'n': + case 'N': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &newheight) == 0); + break; + + case 'c': + case 'C': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &vusepxl) == 0); + break; + + case 'b': + case 'B': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &brightness) == 0); + break; + + case 'x': + case 'X': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &bitspsam) == 0); + break; + + case 't': + case 'T': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%lg", &valinc) == 0); + break; + + case 'z': + case 'Z': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &gradint) == 0); + break; + + case 'g': + case 'G': + strdelete((Anyptr)comment, 1, 2); + greypxl = (!strcmp(comment, "y") || !strcmp(comment, "Y")); + break; + + case 'e': + case 'E': + strdelete((Anyptr)comment, 1, 2); + egastretch = (!strcmp(comment, "n") || !strcmp(comment, "N")); + egastretch = !egastretch; + break; + + case 'd': + case 'D': + strdelete((Anyptr)comment, 1, 2); + distribute = (!strcmp(comment, "n") || !strcmp(comment, "N")); + distribute = !distribute; + break; + + case 'f': + case 'F': + strdelete((Anyptr)comment, 1, 2); + strcpy(aliasname, comment); + aliasused = true; + break; + + case 's': + case 'S': + strdelete((Anyptr)comment, 1, 2); + ledprinter = (!strcmp(comment, "y") || !strcmp(comment, "Y")); + break; + + case 'p': + case 'P': + strdelete((Anyptr)comment, 1, 2); + halfinch = (!strcmp(comment, "n") || !strcmp(comment, "N")); + break; + + case 'r': + case 'R': + strdelete((Anyptr)comment, 1, 2); + if (!strcmp(comment, "y")) { + hrep = 2; + vrep = 2; + } + break; + + case 'w': + case 'W': + strdelete((Anyptr)comment, 1, 2); + nowhite = (!strcmp(comment, "n") || !strcmp(comment, "N")); + nowhite = !nowhite; + break; + + case 'k': + case 'K': + strdelete((Anyptr)comment, 1, 2); + if (!strcmp(comment, "c") || !strcmp(comment, "N")) + cyan = true; + else if (!strcmp(comment, "m") || !strcmp(comment, "M")) + magenta = true; + else if (!strcmp(comment, "y") || !strcmp(comment, "Y")) + yellow = true; + else if (!strcmp(comment, "k") || !strcmp(comment, "K")) + black = true; + break; + + case 'i': + case 'I': + strdelete((Anyptr)comment, 1, 2); + invert = (!strcmp(comment, "y") || !strcmp(comment, "Y")); + break; + + case 'j': + case 'J': + strdelete((Anyptr)comment, 1, 2); + clipon = (!strcmp(comment, "y") || !strcmp(comment, "Y")); + break; + + case 'u': + case 'U': + strdelete((Anyptr)comment, 1, 2); + i = (sscanf(comment, "%ld", &usepxl) == 0); + break; + } + } + } + /*:111*/ + /*112:*/ + if (bitspsam < 1 || bitspsam > 8) + bitspsam = 8; + if (invert) { + invbit = 0; + invbyte = 0; + } else { + invbit = 1; + invbyte = 255; + } + if (usepxl == 0) + usepxl = 2; + if (vusepxl == 0) + vusepxl = usepxl; + if (brightness >= usepxl * vusepxl * 4) + brightness = 0; + if (brightness != 0 && usepxl < 2) + brightness = 0; + if (valinc > 99) + valinc = 99.0; + if (valinc > 0) { + if (gradint == 0) + gradint = 1; + } + if (gradint > 99) + gradint = 99; + if (newheight < 0) + newheight = 0; + if (newwidth < 0) + newwidth = 0; + if (newwidth > 200) { + printf("Sorry, new width set to 200mm\n"); + newwidth = 200; + } + if (newheight > 280) { + printf("Sorry, new height set to 280mm\n"); + newheight = 280; + } + if (truehres == 0) + truehres = 300.0; + if (truevres == 0) + truevres = truehres; + cmyk = (cyan || magenta || yellow || black); + saveblack = (cyan || magenta || yellow); /*:112*/ + /*:107*/ + /*108:*/ + for (j = 0; j <= 51; j++) { + for (i = 0; i <= 128; i++) { + pwidth[j][i] = 0; + width[j][i] = 0; + height[j][i] = 0; + pheight[j][i] = 0; + yoffset[j][i] = 0; + } + } + for (i = 0; i <= 128; i++) + dirpoint[i] = 0; + for (i = 0; i <= 128; i++) + pkpoint[i] = 0; + for (i = 0; i <= 52; i++) + charpf[i] = 0; + maxx = 0; + minx = 646; + mapheight = 0; /*:108*/ + fok = true; + strcpy(bmname, font); + strcpy(bitmap_NAME, bmname); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + _SETIO(bitmap != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { /*113:*/ + printf("File %s not found, abort\n", font); + fileproblem(); + goto _L9999; + } + i = 1; + j = 0; + strcpy(cmd, " "); + while (i <= strlen(bmname)) { + if (bmname[i - 1] == '.') + j = i; + i++; + } + if (j > 0) + strsub(cmd, bmname, j + 1, (int)(strlen(bmname) - j + 1)); + if (!strcmp(cmd, "tif") || !strcmp(cmd, "TIF") || !strcmp(cmd, "tiff") || + !strcmp(cmd, "TIFF")) + tifint(); + else { + if (!strcmp(cmd, "pcx") || !strcmp(cmd, "PCX")) + pcxint(); + else if (!strcmp(cmd, "lbm") || !strcmp(cmd, "LBM") || + !strcmp(cmd, "iff") || !strcmp(cmd, "IFF")) + iffint(); + else if (!strcmp(cmd, "gif") || !strcmp(cmd, "GIF")) + gifint(); + else if (!strcmp(cmd, "bmp") || !strcmp(cmd, "BMP")) + bmpint(); + else if (!strcmp(cmd, "img") || !strcmp(cmd, "IMG")) + imgint(); + else if (!strcmp(cmd, "cut") || !strcmp(cmd, "CUT")) + cutint(); + else + posbit = 0; + } + if (aliasused) { + strcpy(font, aliasname); + strcpy(bmname, aliasname); + } + FORLIM = strlen(bmname); + for (i = 1; i <= FORLIM; i++) { + sprintf(STR2, "%c", bmname[i - 1]); + j = strpos2(fontpre, STR2, 1); + if (j != 0) + bmname[i - 1] = fontupc[j - 1]; + } + FORLIM = strlen(font); + for (i = 1; i <= FORLIM; i++) { + sprintf(STR2, "%c", font[i - 1]); + j = strpos2(fontupc, STR2, 1); + if (j != 0) + font[i - 1] = fontpre[j - 1]; + } + korrfont(); + nameok = true; + FORLIM = strlen(font); + for (i = 1; i <= FORLIM; i++) { + if (isdigit(font[i - 1])) + nameok = false; + } + if (!nameok) { + printf("no digits allowed in name of font\n"); + goto _L9999; + } + strcpy(bmname, font); + FORLIM = strlen(bmname); + for (i = 1; i <= FORLIM; i++) { /*:113*/ + sprintf(STR2, "%c", bmname[i - 1]); + j = strpos2(fontpre, STR2, 1); + if (j != 0) + bmname[i - 1] = fontupc[j - 1]; + } + /*114:*/ + if (truehres <= 0 || truehres > 2000) + truehres = 300.0; + if (truevres <= 0 || truevres > 2000) + truevres = 300.0; + whatistrue(); + if (hres != (long)floor(truehres + 0.5)) + printf("maximum width of characters is %ld pixel\n", hres); + if (vres != (long)floor(truevres + 0.5)) + printf("maximum height of characters is %ld pixel\n", vres); + if (posbit != 0) + pxlinlen = (halfk)((mapwidth + 7) / 8); + else { + pxlinlen = mapinlen; + mapwidth = pxlinlen * 8; + if (greypxl) /*116:*/ + mapwidth /= bitspsam; + if (mapwidth < 1) { + printf("Width not correct!\n"); + goto _L9999; + } + mapheight = (P_maxpos(bitmap)) / mapinlen; + if ((P_maxpos(bitmap)) % mapinlen > 0) { + printf("Remainder > 0 when dividing size of file by width!\n"); + goto _L9999; + } +/* p2c: bm2font.pas, line 1102: + * Note: Using % for possibly-negative arguments [317] */ + if (greypxl) { + mapdiv = 1.0; + photoinf = 15; + FORLIM1 = bitspsam; + for (cb = 1; cb <= FORLIM1; cb++) + mapdiv *= 2; + mapdiv /= 16; + } /*:116*/ + } + if (pxlinlen > 3000) { + printf("File not processable, width > 3000 bytes\n"); + goto _L9999; + } /*:114*/ + if (newwidth != 0 || newheight != 0) + scaling(); + if (greypxl) { /*94:*/ + printf("Halftone picture required\n"); + pxlinlen = (halfk)(((unsigned long)(mapwidth * bitspsam + 7)) >> 3); + greypix = mapwidth; + mapwidth *= bitspsam; /*95:*/ + sprintf(tmpname, "%s.tmp", font); + strcpy(tmpfil_NAME, tmpname); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("tempfile %s not accessable, abort\n", tmpname); + fileproblem(); + goto _L9999; + } + if (tmpfil != NULL) + tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil); + else + tmpfil = fopen(tmpfil_NAME, "w+b"); + _SETIO(tmpfil != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { /*:95*/ + printf("Tempfile for font %s not found, abort\n", font); + fileproblem(); + goto _L9999; + } + /*101:*/ + k = 0; + if (usepxl != vusepxl) { + FORLIM = vusepxl; + for (i = 0; i < FORLIM; i++) { + FORLIM2 = usepxl; + for (j = 0; j < FORLIM2; j++) { + k++; + tab[k - 1][0] = i + 1; + tab[k - 1][1] = j + 1; + tab[k - 1][2] = i * i * (usepxl - 1) * (usepxl - 1) + + j * j * (vusepxl - 1) * (vusepxl - 1); + } + } + FORLIM = k; + for (i = 1; i <= FORLIM; i++) { + FORLIM2 = k; + for (j = i; j <= FORLIM2; j++) { + if (tab[i - 1][2] > tab[j - 1][2]) { + lx = tab[i - 1][0]; + tab[i - 1][0] = tab[j - 1][0]; + tab[j - 1][0] = lx; + lx = tab[i - 1][1]; + tab[i - 1][1] = tab[j - 1][1]; + tab[j - 1][1] = lx; + lx = tab[i - 1][2]; + tab[i - 1][2] = tab[j - 1][2]; + tab[j - 1][2] = lx; + } + } + } + FORLIM = k; + for (i = 1; i <= FORLIM; i++) { + lx = tab[i - 1][0]; + ly = tab[i - 1][1]; + ditherm[lx - 1][ly - 1] = i; + } + } + if (usepxl > 7) + usepxl = 7; + if (vusepxl > 7) + vusepxl = 7; + maxcol = 1; + cb = 0; + usecol = usepxl * vusepxl * 4; + FORLIM = bitspsam; + for (k = 1; k <= FORLIM; k++) + maxcol *= 2; + maxcol--; + for (k = 1; k <= 4; k++) { + for (i = 0; i <= 196; i++) { + for (j = 1; j <= 7; j++) + pattern[k - 1][i][j - 1] = 0; + } + } + FORLIM = vusepxl; + for (i = 1; i <= FORLIM; i++) { + FORLIM2 = usepxl; + for (j = 1; j <= FORLIM2; j++) { + if (ditherm[i - 1][j - 1] <= usecol / 4 && ditherm[i - 1][j - 1] > 0) { + v = (ditherm[i - 1][j - 1] - 1) * 4 + 1; + for (ccol = 1; ccol <= 4; ccol++) { + if (ccol == 1) + c = 1; + else if (ccol == 2) + c = 3; + else if (ccol == 3) + c = 4; + else + c = 2; + FORLIM3 = usecol; + for (k = v; k <= FORLIM3; k++) { + switch (c) { + + case 4: + if (usepxl > 2 || vusepxl > 2) + pattern[0][k][j - 1] |= (cb + 2) << (7 - i); + else + pattern[0][k][i - 1] |= (cb + 2) << (7 - j); + break; + + case 1: + pattern[1][k][vusepxl - i] |= (cb + 1) << (j - usepxl + 7); + break; + + case 2: + if (usepxl > 2 || vusepxl > 2) + pattern[2][k][vusepxl - j] |= (cb + 2) << (7 - i); + else + pattern[2][k][vusepxl - i] |= (cb + 2) << (7 - j); + break; + + case 3: + pattern[3][k][i - 1] |= (cb + 1) << (j - usepxl + 7); + break; + } + } + v++; + } + } + } + } + if (nowhite) + pattern[1][0][usepxl - 1] = 128 >> (usepxl - 1); + usecol -= brightness; /*:101*/ + /*[102:]append(logfile); +for k:=0 to usecol do begin for j:=1 to vusepxl do begin for i:=1 to 4 +do begin cb:=pattern[i,k,j];write(logfile,cb:4,' '); +for pk:=1 to usepxl do begin if cb>127 then write(logfile,'1')else write +(logfile,'0');cb:=cb shl 1;end;write(logfile,' ');end; +writeln(logfile,'.');end;writeln(logfile,'---- ',k:1,' ----');end; +close(logfile);[:102]*/ + greypix -= greypix & 3; + mapwidth = greypix * bitspsam; + if (ledprinter) + gbufpp = ((long)floor(greypix * (usepxl + 0.5) + 0.5) * hrep + 7) / 8; + else + gbufpp = (greypix * usepxl * hrep + 7) / 8; + if (gbufpp > 1280) { + printf("Only up to 1280 bytes in one row allowed!\n"); + printf("Try again by decreasing param <u> or <r=n>\n"); + _Escape(0); + } /*96:*/ + printf("Analysing and optimizing the picture\n"); + pminval = 255; + pmaxval = 0; + if (cmyk) { + pminval = 0; + pmaxval = maxcol; + } + if (cutgrey) { + checksum = mapheight; + pxlinlen = cutlen; + } else + checksum = mapheight; + pl = 0; + fseek(bitmap, posbit, 0); + do { + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + colpos = 0; + cutrep = 0; + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) { + tmpcolor = getcolor(); + if (tmpcolor > pmaxval) + pmaxval = tmpcolor; + if (tmpcolor < pminval) + pminval = tmpcolor; + } + checksum--; + if (cutgrey) + pxlinlen = b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2; + } while (checksum != 0); +/* p2c: bm2font.pas, line 1165: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (pminval == pmaxval && !cmyk) { + printf("Only one color (value %d) used by bitmap!\n", pmaxval); + printf("It makes no sence to generate a picture!\n"); + _Escape(0); + } /*:96*/ + if (brightness == 0) { + brightness = (long)floor( + (maxcol - pmaxval + pminval + 1.0) * usecol / (maxcol + 1) + 0.5); + if (brightness > 0) + printf("Best result may be with parameter -b%ld !?\n", brightness); + } + printf("Dithering the picture\n"); + memset((Anyptr)greymem, 255, sizeof(uchar) * 32761L); + pgreymem = 0; + if (cutgrey) { + checksum = mapheight; + pxlinlen = cutlen; + } else + checksum = mapheight; + pl = 0; + fseek(bitmap, posbit, 0); + patswitch = 4; + spreadcol = (maxcol + 1.0) / (pmaxval - pminval + 1); + patref = (double)usecol / maxcol; /*97:*/ + for (k = 0; k <= 255; k++) + pxllook[k] = k; + if (invert) { + for (k = 0; k <= 255; k++) + pxllook[k] = 255 - k; + } + if (invert) { + FORLIM = pmaxval; + for (k = pminval; k <= FORLIM; k++) + pxllook[pmaxval - k + pminval] = + (long)floor((k - pminval) * spreadcol + 0.5); + invbit = 1; + invbyte = 255; + } else { + FORLIM = pmaxval; + for (k = pminval; k <= FORLIM; k++) + pxllook[k] = (long)floor((k - pminval) * spreadcol + 0.5); + } + FORLIM = maxcol; + for (k = 0; k <= FORLIM; k++) + lutone[k] = (long)floor((maxcol - k) * patref + 0.5); + if (valinc > 0) { /*98:*/ + k = pminval; + pk = 0; + while (pk <= gradint && k <= pmaxval) { + pk = (long)floor(pxllook[k] * 100.0 / maxcol + 0.5); + k++; + } + pkn = pxllook[k - 1]; + grxzero = pkn; + redval = valinc / 100; + FORLIM = pmaxval; + for (k = pminval; k <= FORLIM; k++) { + /*write(logfile,(pxllook[k]/maxcol):1:5 +);*/ + grx = pxllook[k]; + if (grx <= pkn) { + if (grx > 0) + pxllook[k] = (long) + floor(0.5 * grx * (exp(redval * log(grx / grxzero)) + + exp(-redval * log(grx / grxzero))) + 0.5); +/* p2c: bm2font.pas, line 1353: + * Note: Line breaker spent 1.0 seconds, 5000 tries on line 4297 [251] */ + } + /*writeln(logfile,' ',(pxllook[k]/maxcol):1:5);*/ + } /*close(logfile);;*/ + /*:98*/ + } + /*append(logfile);*/ + FORLIM = maxcol; + for (pk = 0; pk <= FORLIM; pk++) + hktab[pk] = (long)floor((maxcol - pk) * patref * 100 + 0.5) - + (long)(lutone[pk] * 100.0); + cspread = false; + if (usecol - 1 > maxcol) { + pk = usecol; + for (k = maxcol; k >= 0; k--) { + if (invert) + pk = usecol - lutone[pxllook[maxcol - k]]; + else + pk = usecol - lutone[pxllook[k]]; + while (pk >= k) { + lutone[pk] = lutone[pxllook[k]]; + hktab[pk] = (long)floor(lutone[pk] * 100.0 + 0.5) - + (long)floor((usecol - pk) * 100.0 + 0.5); + lutone[pk] -= hktab[pk] / 100; + pk--; + } + } + if (invert) { + FORLIM = usecol; + for (k = 0; k <= FORLIM; k++) + pxllook[k] = lutone[k]; + } else { + FORLIM = usecol; + for (k = 0; k <= FORLIM; k++) + pxllook[k] = usecol - lutone[k]; + } + maxcol = usecol; + cspread = true; + } + invert = false; + mapdiv = (usecol + 1.0) / 16; + FORLIM = usecol; + for (k = 0; k <= FORLIM; k++) + lutvga[k] = (long)((usecol - k) / mapdiv); + for (pk = -255; pk <= 255; pk++) { + if (cspread) + gkorh[pk + 255] = (long)(pk / 2.0); + else + gkorh[pk + 255] = (long)floor(pk / 2.0 * spreadcol + 0.5); + if (cspread) + gkordivp[pk + 255] = (long)(pk / 2.0); + else + gkordivp[pk + 255] = (long)(pk / 2.0 * patref + hktab[abs(pk)] / 100.0); + } + for (pk = 0; pk <= 255; pk++) /*:97*/ + spreadvals[pk] = (long)floor(pk * patref + 0.5); + do { + pxlinlen = fread(b1, 1, pxlinlen, bitmap); + colpos = 0; + cutrep = 0; + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b4[pk] = getcolor(); + if (cspread) { + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b4[pk] = spreadvals[b4[pk]]; + } + if (distribute) { /*99:*/ + pk = 1; + pkn = 1; + while (pk < greypix) { + pkn++; + greykor = 0; + if (b4[pk] != b4[pkn]) { + greykor = gkorh[b4[pk] - b4[pkn] + 255]; + greykor = gkordivp[greykor + 255]; + } + if (greykor != 0) { + tmpcolor = lutone[pxllook[b4[pkn]]]; + if (abs(tmpcolor + greykor) <= usecol && + abs(tmpcolor + greykor) >= 0) + b4[pkn] += greykor; + } + pk++; + } + pk = greypix - 1; + pkn = pk; + while (pk > 0) { /*:99*/ + pkn--; + greykor = 0; + if (b4[pk] != b4[pkn]) { + greykor = gkorh[b4[pk] - b4[pkn] + 255]; + greykor = gkordivp[greykor + 255]; + } + if (greykor != 0) { + tmpcolor = lutone[pxllook[b4[pkn]]]; + if (abs(tmpcolor + greykor) <= usecol && + abs(tmpcolor + greykor) >= 0) + b4[pkn] += greykor; + } + pk--; + } + } + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) + b4[pk] = lutone[pxllook[b4[pk]]]; + FORLIM1 = vrep; + for (yrep = 1; yrep <= FORLIM1; yrep++) { /*100:*/ + FORLIM = vusepxl; + for (k = 1; k <= FORLIM; k++) { + gbufp = 0; + cb = 0; + pn = 0; + switch (patswitch) { + + case 1: + curpat[0] = 2; + curpat[1] = 3; + break; + + case 2: + curpat[0] = 4; + curpat[1] = 1; + break; + + case 3: + curpat[0] = 3; + curpat[1] = 2; + break; + + case 4: + curpat[0] = 1; + curpat[1] = 4; + break; + } +/* p2c: bm2font.pas, line 1233: + * Note: Can't interpret size in FILLCHAR [174] */ + memset((Anyptr)b3, 0, (long)gbufpp); + FORLIM2 = greypix; + for (pk = 0; pk < FORLIM2; pk++) { + FORLIM4 = hrep; + for (xrep = 1; xrep <= FORLIM4; xrep++) { + cb = pattern[curpat[pn] - 1][b4[pk]][k - 1]; + if (saveblack) + cb &= ~pattern[curpat[pn] - 1][bhell[b4[pk]]][k - 1]; + dbuf = ((unsigned)gbufp) >> 3; + bufsh = gbufp & 7; + nextbuf = bufsh + usepxl; + switch (bufsh) { + + case 0: + b3[dbuf] = cb; + break; + + default: + b3[dbuf] |= cb >> bufsh; + if (nextbuf > 8) + b3[dbuf + 1] = cb << (8 - bufsh); + break; + } + gbufp += usepxl; + if (ledprinter) { + if (curpat[pn] == 1 || curpat[pn] == 3) + gbufp++; + } + pn = abs(pn - 1); + } + } + FORLIM2 = gbufpp; + for (pk = 0; pk <= FORLIM2; pk++) + b3[pk] = ~b3[pk]; + if (pgreymem + gbufpp > 65522L) { + _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + pgreymem = 0; + } +/* p2c: bm2font.pas, line 1242: + * Note: Can't interpret size in BLOCKWRITE [174] */ +/* p2c: bm2font.pas, line 1245: Note: Can't interpret size in MOVE [174] */ + memmove((Anyptr)(&greymem[pgreymem]), (Anyptr)b3, (long)gbufpp); + pgreymem += gbufpp; + } +/* p2c: bm2font.pas, line 1246: + * Note: Can't interpret size in FILLCHAR [174] */ + memset((Anyptr)b3, 255, (long)gbufpp); + if (ledprinter) { + if (patswitch == 2 || patswitch == 4) { + if (pgreymem + gbufpp > 65522L) { + _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1, + FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", + tmpname) >= 0, FileWriteError); + fileproblem(); + _Escape(0); + } + pgreymem = 0; + } +/* p2c: bm2font.pas, line 1249: + * Note: Can't interpret size in BLOCKWRITE [174] */ +/* p2c: bm2font.pas, line 1252: Note: Can't interpret size in MOVE [174] */ + memmove((Anyptr)(&greymem[pgreymem]), (Anyptr)b3, (long)gbufpp); + pgreymem += gbufpp; + } /*:100*/ + } + patswitch++; + if (patswitch > 4) + patswitch = 1; + } + pm = 128; + pb = pl; + FORLIM = greypix; + for (pk = 0; pk < FORLIM; pk++) { + pxlcolor = lutvga[b4[pk]]; + pm >>= 1; + if (pm == 0) { + pm = 128; + pb++; + } + } + pl += 80; + if (pl >= 38400L) + pl = 0; + checksum--; + if (cutgrey) + pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2); + } while (checksum != 0); +/* p2c: bm2font.pas, line 1213: + * Note: Can't interpret size in BLOCKREAD [174] */ + if (pgreymem != 0) { /*$I-*/ + _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1, FileWriteError); + filestat = P_ioresult; + if (filestat != 0) { + _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0, + FileWriteError); + fileproblem(); + _Escape(0); + } + } +/* p2c: bm2font.pas, line 1259: + * Note: Can't interpret size in BLOCKWRITE [174] */ + posbit = 0; + if (ledprinter) + mapwidth = (long)floor(greypix * (usepxl + 0.5) + 0.5) * hrep; + else + mapwidth = greypix * usepxl * hrep; + pxlinlen = (mapwidth + 7) / 8; + mapinlen = pxlinlen; + if (ledprinter) + mapheight = (long)floor(mapheight * (vusepxl + 0.5) + 0.5) * vrep; + else + mapheight *= vusepxl * vrep; + if (tmpfil != NULL) + fclose(tmpfil); + tmpfil = NULL; + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + strcpy(bitmap_NAME, tmpname); + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "r+b", bitmap); + else + bitmap = fopen(bitmap_NAME, "r+b"); + if (bitmap == NULL) + _EscIO(FileNotFound); + } + mapwidth = pxlinlen * 8; + zeropads = 0; + maplines = mapheight; + if (clipon) /*117:*/ + { /*115:*/ + checksum = mapheight * ((mapwidth + 7) / 8); + mapheight = 0; + freelines = 0; + fseek(bitmap, posbit, 0); + while (checksum >= pxlinlen) { + fread(b1, pxlinlen, 1, bitmap); + mapwidth = pxlinlen * 8; + j = pxlinlen - 1; + while (b1[j] == invbyte && j >= 0) + j--; + if (j >= 0) { + i = 0; + while (b1[i] == invbyte && i <= j) + i++; + if (i < minx) + minx = i; + lx = j * 8 + 8; + cb = b1[j]; + for (i = 1; i <= 8; i++) { + if ((cb & 1) == invbit) { + cb >>= 1; + lx--; + } else + i = 8; + } + if (lx > maxx) + maxx = lx; + freelines++; + mapheight += freelines; + freelines = 0; + } else if (mapheight == 0) + posbit += pxlinlen; + else + freelines++; + checksum -= pxlinlen; + } +/* p2c: bm2font.pas, line 1271: + * Note: Can't interpret size in BLOCKREAD [174] */ + mapwidth = maxx - minx * 8; + zeropads = pxlinlen - (mapwidth + 7) / 8; + maplines = mapheight; + posbit += minx; /*:115*/ + } + i = (mapwidth + hres - 1) / hres; + j = (mapheight + vres - 1) / vres; + nj = j; + nofchars = i * j; + mincharpf = 515832L / (vres * ((hres + 31) / 32) * 32); + noffonts = (nofchars + mincharpf - 1) / mincharpf; + if (noffonts > 52) { + printf("Sorry, bitmap is too large! Giving up\n"); + goto _L9999; + } + if (mincharpf > 128) { /*:117*/ + mincharpf = 128; + noffonts = (nofchars + 127) / 128; + } + /*118:*/ + k = 0; + c = 0; + while (mapheight > 0) { /*:118*/ + maxx = mapwidth; + while (maxx > 0) { + if (maxx > hres) + pwidth[k][c] = hres; + else + pwidth[k][c] = maxx; + if (mapheight > vres) + pheight[k][c] = vres; + else + pheight[k][c] = mapheight; + dsize = (long)floor(vres / truehres * 72.27 * 65536L * 16 + 0.5); + tabdsize[k] = dsize; + c++; + if (c == mincharpf || mapheight <= vres && maxx <= hres) { + FORLIM1 = mincharpf; + for (c = 0; c < FORLIM1; c++) { + height[k][c] = (long)floor(pheight[k][c] / truevres * 4736286.7227 / + dsize * 16777215L + 0.5); + width[k] + [c] = (long)floor(pwidth[k][c] / truehres * 4736286.7227 / dsize * + 16777215L + 0.5); + } + k++; + c = 0; + } + maxx -= hres; + } + mapheight -= vres; + } + maxx = (mapwidth + hres - 1) / hres; + f = 0; + g = 0; + pxlbmi = 4; + if (fok) { + printf("error occurred when allocating pxlfile "); + puts(cmd); + fileproblem(); + goto _L9999; + } + if (bitmap != NULL) + fclose(bitmap); + bitmap = NULL; + if (bitmap != NULL) + bitmap = freopen(bitmap_NAME, "rb", bitmap); + else + bitmap = fopen(bitmap_NAME, "rb"); + if (bitmap == NULL) + _EscIO(FileNotFound); + fonteject(); /*119:*/ + FORLIM = noffonts; + for (a = 0; a < FORLIM; a++) { /*:119*/ + lh = 17; + bc = 0; + ec = 127; + while (pheight[a][ec] == 0) /*120:*/ + ec--; + sprintf(cmd, "%s%c.tfm", font, fontpre[a]); + strcpy(tfmfile_NAME, cmd); + if (tfmfile != NULL) + tfmfile = freopen(tfmfile_NAME, "w+b", tfmfile); + else + tfmfile = fopen(tfmfile_NAME, "w+b"); + _SETIO(tfmfile != NULL, FileNotFound); + filestat = P_ioresult; + if (filestat == 3 || filestat == 5) { + strcpy(cmd, bmname); + sprintf(cmd + strlen(cmd), "%c.tfm", fontupc[a]); + strcpy(tfmfile_NAME, cmd); + if (tfmfile != NULL) + tfmfile = freopen(tfmfile_NAME, "w+b", tfmfile); + else + tfmfile = fopen(tfmfile_NAME, "w+b"); + _SETIO(tfmfile != NULL, FileNotFound); + filestat = P_ioresult; + } + if (filestat == 0) + fok = false; + else + fok = true; + if (fok) { + printf("error occurred when allocating tfmfile "); + puts(cmd); + fileproblem(); + goto _L9999; + } + printf("Generating tfmfile %s\n", cmd); /*:120*/ + dsize = (long)floor(vres / truehres * 72.27 * 65536L * 16 + 0.5); + tabdsize[a] = dsize; + FORLIM2 = ec; + for (k = bc; k <= FORLIM2; k++) { + height[a][k] = (long)floor( + pheight[a][k] / truevres * 4736286.7227 / dsize * 16777215L + 0.5); + width[a][k] = (long)floor( + pwidth[a][k] / truehres * 4736286.7227 / dsize * 16777215L + 0.5); + } + fh = height[a][bc]; + fw = width[a][bc]; + sh = fh; + sw = fw; + nw = 2; + nh = 2; + FORLIM2 = ec; + for (k = bc; k <= FORLIM2; k++) { + if (height[a][k] != 0 && height[a][k] != fh && height[a][k] != sh) { + sh = height[a][k]; + nh++; + } + if (width[a][k] != 0 && width[a][k] != fw && width[a][k] != sw) { + sw = width[a][k]; + nw++; + } + } + if (nh > 3) { + printf("more than 2 heights, should be impossible\n"); + goto _L9999; + } + if (nw > 3) { + printf("more than 2 widths, should be impossible\n"); + goto _L9999; + } + nd = 2; + ni = 2; + nl = 0; + nk = 0; + ne = 0; + np = 0; + lf = lh + ec - bc + nw + nh + nd + ni + nk + nl + ne + np + 7; + checksum = 0; + tfmhword(lf); + tfmhword(lh); + tfmhword(bc); + tfmhword(ec); + tfmhword(nw); + tfmhword(nh); + tfmhword(nd); + tfmhword(ni); + tfmhword(nl); + tfmhword(nk); + tfmhword(ne); + tfmhword(np); + tfmword(checksum); + tfmword(dsize); + strcpy(tfmstr, "0Graphic"); + tfmstr[0] = '\007'; + FORLIM2 = strlen(tfmstr); + for (i = 1; i <= FORLIM2; i++) { + tfmb = tfmstr[i - 1]; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } + tfmb = 0; + for (i = 1; i <= 32; i++) + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + strcpy(tfmstr, "0Bitmap"); + tfmstr[0] = '\006'; + FORLIM2 = strlen(tfmstr); + for (i = 1; i <= FORLIM2; i++) { + tfmb = tfmstr[i - 1]; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } + tfmb = 0; + for (i = 1; i <= 13; i++) + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + FORLIM2 = ec; + for (i = bc; i <= FORLIM2; i++) { + if (width[a][i] == 0) { + tfmb = 0; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } else if (width[a][i] == fw) { + tfmb = 1; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } else { + tfmb = 2; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } + if (height[a][i] == 0) { + tfmb = 0; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } else if (height[a][i] == fh) { + tfmb = 16; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } else { + tfmb = 32; + fwrite(&tfmb, sizeof(uchar), 1, tfmfile); + } + tfmhword(0L); + } + tfmword(0L); + tfmword(fw); + if (nw > 2) + tfmword(sw); + tfmword(0L); + tfmword(fh); + if (nh > 2) + tfmword(sh); + tfmword(0L); + tfmword(0L); + tfmword(0L); + tfmword(0L); + if (tfmfile != NULL) + fclose(tfmfile); + tfmfile = NULL; + } + userhelp(); /*109:*/ + if (pcxtemp) +/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "pcxtemp.tmp"); +#else + Exec("rm", "pcxtemp.tmp"); +#endif + if (giftemp) +/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", "giftemp.tmp"); +#else + Exec("rm", "giftemp.tmp"); +#endif + if (greypxl) +/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */ +#ifdef MSDOS + Exec("del", tmpname); +#else + Exec("rm", tmpname); +#endif + printf("input %s.tex into your document", font); + printf(" and set the picture with \\set%s\n", font); /*:109*/ +_L9999: + if (texfile != NULL) + fclose(texfile); + if (bitmap != NULL) + fclose(bitmap); + if (pxlfile != NULL) + fclose(pxlfile); + if (tmpfil != NULL) + fclose(tmpfil); + if (tfmfile != NULL) + fclose(tfmfile); + exit(EXIT_SUCCESS); +} /*:106*/ + + + +/* End. */ |