/*
 *	webfont - 
 *		Make a PostScript Type1 font into a B/W image
 *	and a fontinfo file.
 *
 *				Paul Haeberli - 1995
 *
 */
#include "math.h"
#include "image.h"
#include "stdio.h"
#include "objfnt.h"
#include "bitmap.h"
#include "vect.h"
#include "canvas.h"

unsigned long *makebitmaps();

typedef struct glyph {
    unsigned long *data;
    int xsize, ysize;
    int pixoffset;
    int xdorg, ydorg;
} glyph;

int fbxsize, fbysize;
objfnt *fnt;
int pixhigh;
int supersample;
glyph **glyphs;
char fullname[1024];

unsigned long *yflip(lbuf,xsize,ysize)
unsigned long *lbuf;
int xsize, ysize;
{
    unsigned long *rbuf;
    int sy, dy;

    rbuf = (unsigned long *)malloc(xsize*ysize*sizeof(long));
    for(dy=0; dy<ysize; dy++) {
	sy = ysize-1-dy;
	bcopy(lbuf+(sy*xsize),rbuf+(dy*xsize),xsize*sizeof(long));
    }
    return rbuf;
}

main(argc,argv)
int argc;
char **argv;
{
    unsigned long *lbuf, *fbuf;
    int ixsize, iysize;

    if( argc<6 ) {
	fprintf(stderr,"usage: webfont type1name out.bw out.info pixhigh supersample\n");
	exit(1);
    } 
    pixhigh = atoi(argv[4]);
    supersample = atoi(argv[5]);

/* find the font fullname */
    sprintf(fullname,"/usr/lib/DPS/outline/base/%s",argv[1]);

/* read in the font */
    fnt = readtype1(fullname,3.0,0);
    if(!fnt ) {
	fprintf(stderr,"webfont: can't open input font\n");
	exit(1);
    } 

/* make the bitmaps */
    lbuf = (unsigned long *)makebitmaps(fullname,argv[1],&ixsize,&iysize);
    fbuf = yflip(lbuf,ixsize,iysize);
    longstoimage(fbuf,ixsize,iysize,1,argv[2]);

    writefontinfo(argv[3],argv[2],fnt);
    exit(0);
}

putshort(val,outf)
int val;
FILE *outf;
{
    fputc((val>>8)&0xff,outf);
    fputc((val>>0)&0xff,outf);
}

writefontinfo(outname,imgname,fnt)
char *outname;
char *imgname;
objfnt *fnt;
{
    FILE *outf;
    int c, i, len, xadvance;
    int first, last;
    char advcode, sizecode;
    int xsize, ysize, pixoffset, xdorg, ydorg, pb;
    chardesc *cd;
    glyph *g;

    outf = fopen(outname,"w");
    if(!outf) {
	fprintf(stderr,"webfont: can't open output file %s\n",outname);
	exit(1);
    }
    fputc(23,outf);
    fputc(45,outf);
    putshort(1,outf);		/* advancedivisor */
    putshort(0,outf);		/* lineadvance x */
    putshort(pixhigh,outf);	/* lineadvance y */
    advcode = 4;		/* L-R, T-B, only X advances given */
    fputc(advcode,outf);

    putshort(fnt->nchars,outf);   /* glyphset */
    putshort(fnt->charmin,outf);  /* glyphset */
    fputc(0,outf);		/* glyphsetlist terminator */
    fputc(0,outf);		/* glyphsetlist terminator */

    first = fnt->charmin;
    last = fnt->charmax;
    for(c=first; c<=last; c++)  {
	i = c-first;
	cd = getchardesc(fnt,c);
	if(cd)
	    xadvance = (pixhigh*cd->movex)/fnt->scale;
	else
	    xadvance = 0;
	if(glyphs[i]) {
	    g = glyphs[i];
	    xsize = g->xsize;
	    ysize = g->ysize;
	    xdorg = g->xdorg;
	    ydorg = g->ydorg;
	    pixoffset = g->pixoffset;
	} else {
	    xsize = ysize = 0;
	    pixoffset = 0;
	    xdorg = ydorg = 0;
	}
	sizecode = 0;
	if(xadvance>255)
	    sizecode |= 1;
	if(xsize>255 || ysize>255) 
	    sizecode |= 2;
	if(pixoffset<256) {
	    pb = 1;
	} else if(pixoffset<(256*256)) {
	    pb = 2;
	    sizecode |= 4;
	} else if(pixoffset<(256*256*256)) {
	    pb = 3;
	    sizecode |= 8;
	} else {
	    pb = 4;
	    sizecode |= 4;
	    sizecode |= 8;
	}
	if(xdorg>127 || xdorg<-128 || ydorg>127 || ydorg<-128)
	    sizecode |= 16;
printf("char %d sizecode %d adv %d size %d %d pixoffset %d dorg %d %d\n",c,sizecode,xadvance,xsize,ysize,pixoffset,xdorg,ydorg);
	fputc(sizecode,outf);
	if(xadvance>255)
	    putshort(xadvance,outf);
	else
	    fputc(xadvance,outf);
	if(xsize>255 || ysize>255) {
	    putshort(xsize,outf);
	    putshort(ysize,outf);
	} else {
	    fputc(xsize,outf);
	    fputc(ysize,outf);
	}
	for(i=0; i<pb; i++) 
	    fputc((pixoffset>>(8*(pb-1-i)))&0xff,outf);
	if(xdorg>127 || xdorg<-128 || ydorg>127 || ydorg<-128) {
	    putshort(xdorg,outf);
	    putshort(ydorg,outf);
	} else {
	    fputc(xdorg,outf);
	    fputc(ydorg,outf);
	}
    }
    fclose(outf);
}

unsigned long *makepixdata(lbuf,xpix,ypix,xmin,xmax,ymin,ymax)
unsigned long *lbuf;
int xpix, ypix;
int xmin, xmax, ymin, ymax;
{
    unsigned long *gbuf, *lptr;
    int x, y, dxsize, dysize;
   
    dxsize = xmax-xmin+1;
    dysize = ymax-ymin+1;
    gbuf = lptr = (unsigned long *)malloc(dxsize*dysize*sizeof(long));
    for(y=ymin; y<=ymax; y++) {
	for(x=xmin; x<=xmax; x++)
	    *lptr++ = lbuf[y*xpix+x];
    }
    return gbuf;
}

glyph *charglyph(fullname,psname,c)
char *fullname;
char *psname;
int c;
{
    glyph *g;
    FILE *outf;
    float inches;
    int margin, ixpix, iypix;
    unsigned long *lbuf;
    char cmd[1024];
    int xmin, xmax, ymin, ymax;

    printf("car is '%c'\n",c);

    outf = fopen("PIXFONT.ps","w");
    if(!outf) {
	fprintf(stderr,"pixfont: can't open output .ps file\n");
	exit(1);
    }
    margin = pixhigh;
    inches = (supersample*3*pixhigh)/72.0;

    fprintf(outf,"%%!\n");
    fprintf(outf,"/%s findfont\n",psname);
    fprintf(outf,"%d scalefont setfont\n",supersample*pixhigh);
    fprintf(outf,"%d %d moveto\n",supersample*margin,supersample*margin);
    if(c == '(' || c == ')')
	fprintf(outf,"(\\%c) show\n",c);
    else
	fprintf(outf,"(%c) show\n",c);
    fprintf(outf,"showpage\n");
    fclose(outf);

    sprintf(cmd,"fromps PIXFONT.ps PIXFONT -p 72 -s %f %f",inches,inches);
    system(cmd);
    if(supersample>1) {
	sprintf(cmd,"izoom PIXFONT001.rgb PIXFONT.rgb %f %f -l",1.0/supersample,1.0/supersample);
	system(cmd);
	sprintf(cmd,"imgexp PIXFONT.rgb PIXFONT001.rgb 0 250");
	system(cmd);
    }
    sizeofimage("PIXFONT001.rgb",&ixpix,&iypix);
    lbuf = (unsigned long *)longimagedata("PIXFONT001.rgb");
    if(findbbox(lbuf,ixpix,iypix,&xmin,&xmax,&ymin,&ymax)) {
	g = (glyph *)malloc(sizeof(glyph));
	g->xsize = xmax-xmin+1;
	g->ysize = ymax-ymin+1;
	g->data = makepixdata(lbuf,ixpix,iypix,xmin,xmax,ymin,ymax);
	g->xdorg = xmin-margin;
	g->ydorg = ymin-margin;
printf("size %d %d org %d %d\n",g->xsize,g->ysize,g->xdorg,g->ydorg);
	return g;
    } else 
	return 0;
}

findbbox(cbuf, xpix, ypix, xmin, xmax, ymin, ymax)
unsigned char *cbuf;
int xpix, ypix;
int *xmin, *xmax, *ymin, *ymax;
{
    int Xmin, Xmax, Ymin, Ymax;
    int x, y;

    Xmin = Ymin = 10000;
    Xmax = Ymax = -10000;
    for(y=0; y<ypix; y++) {
	for(x=0; x<ypix; x++) {
	   if(cbuf[OFFSET_R]<255) {
		if(Xmin>x) Xmin = x;
		if(Xmax<x) Xmax = x;
		if(Ymin>y) Ymin = y;
		if(Ymax<y) Ymax = y;
	   }
	   cbuf+=4;
	}
    }
    if(Xmin == 10000)
	return 0;
    else {
	*xmin = Xmin;
	*xmax = Xmax;
	*ymin = Ymin;
	*ymax = Ymax;
	return 1;
    }
}

unsigned long *makebitmaps(fullname,psname,fxsize,fysize)
char *fullname, *psname;
int *fxsize, *fysize;
{
    int i, c, first, last, nchars;
    int oysize, oxsize;
    chardesc *cd;
    unsigned long *lbuf;
    int pixoffset;
    glyph *g;

    first = fnt->charmin;
    last = fnt->charmax;
    nchars = last-first+1;

/* malloc temp buffers */
    glyphs = (glyph **)mymalloc(nchars*sizeof(glyph*));

    for(c=first; c<=last; c++)  {
	i = c-first;
	if(hasvertdata(fnt,c)) {
	    cd = getchardesc(fnt,c);
	    glyphs[i] = charglyph(fullname,psname,c);
	} else 
	    glyphs[i] = 0;
    }

    pixoffset = 0;
    for(c=first; c<=last; c++)  {
	i = c-first;
	if(glyphs[i]) {
	    pixoffset += (glyphs[i]->xsize*glyphs[i]->ysize);
	}
    }
    oxsize = 256;
    oysize = 1+((pixoffset-1)/oxsize);

printf("width height %d %d\n",oxsize,oysize);
    lbuf = (unsigned long *)malloc(oxsize*oysize*sizeof(long));
    setlongs(lbuf,0xffffff,oxsize*oysize);
    pixoffset = 0;
    for(c=first; c<=last; c++)  {
	i = c-first;
	if(glyphs[i]) {
	    placeglyph(lbuf,pixoffset,glyphs[i]);
	    pixoffset += (glyphs[i]->xsize*glyphs[i]->ysize);
	}
    }
    *fxsize = oxsize;
    *fysize = oysize;
    return lbuf;
}

placeglyph(lbuf,pixoffset,g)
unsigned long *lbuf;
int pixoffset;
glyph *g;
{
    int x, y;
    unsigned long *sptr;

    sptr = g->data;
    lbuf += pixoffset;
    for(y=0; y<g->ysize; y++) {
	for(x=0; x<g->xsize; x++) 
	    *lbuf++ = *sptr++;
    }
    g->pixoffset = pixoffset;
}

setlongs(lbuf,val,n)
unsigned long *lbuf;
long val;
int n;
{
    while(n--) 
	*lbuf++ = val;
}