gvceps.c

GSview 4.6 PostScript previewer。Ghostscript在MS-Windows, OS/2 and Unix下的图形化接口

	tiff_long(ifd_next, f);

	/* BitsPerSample for 24 bit colour */
	if (!tiff4 && (prebmap.depth==24)) {
	    tiff_word(8, f);
	    tiff_word(8, f);
	    tiff_word(8, f);
	}

	/* strip offsets */
	end = tiff_end;
	if (stripsperimage > 1) {
	    int stripwidth = bwidth * rowsperstrip;
	    for (i=0; i<stripsperimage; i++) {
		tiff_long(end, f);
		if (use_packbits)
		    end += comp_length[i];
		else
		    end += stripwidth;
	    }
	}

	/* strip byte counts (after compression) */
	if (stripsperimage > 1) {
	    for (i=0; i<stripsperimage; i++) {
		if (use_packbits)
		    tiff_long(comp_length[i], f);
		else {
	    	    is = i * rowsperstrip;
	    	    lastrow = min( rowsperstrip, height - is);
		    tiff_long(lastrow * bwidth, f);
		}
	    }
	}

	/* XResolution rational */
	tiff_long((int)option.xdpi, f);
	tiff_long(1, f);
	/* YResolution rational */
	tiff_long((int)option.ydpi, f);
	tiff_long(1, f);

	/* software and time strings */
	if (!tiff4) {
	    time_t t;
	    char now[20];
	    struct tm* dt;
	    fwrite(appname, 1, strlen(appname)+1, f);
	    if (soft_extra)
	        fputc('\0',f);
	    t = time(NULL);
	    dt = localtime(&t);
	    sprintf(now, "%04d:%02d:%02d %02d:%02d:%02d",
		dt->tm_year+1900, dt->tm_mon+1, dt->tm_mday,
		dt->tm_hour, dt->tm_min, dt->tm_sec);
	    fwrite(now, 1, 20, f);
	}

	/* Palette */
	if (!tiff4 && ((prebmap.depth==4) || (prebmap.depth==8))) {
	    int palcount = 1<<prebmap.depth;
#define PALVAL(x) ((WORD)((x<< 8) | x))
	    if (*pbitmap == 'P') {
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(i), f);
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(i), f);
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(i), f);
	    }
	    else {
		unsigned char *prgb = pbitmap + get_dword(pbitmap);
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(prgb[i*RGB4_LENGTH + RGB4_RED]), f);
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(prgb[i*RGB4_LENGTH + RGB4_GREEN]), f);
		for (i=0; i<palcount; i++)
		    tiff_word(PALVAL(prgb[i*RGB4_LENGTH + RGB4_BLUE]), f);
	    }
#undef PALVAL
	}

	memset(preview,0xff,prebmap.bytewidth);

	if (prebmap.bits) {
	    if (prebmap.topleft)
		line = (BYTE *)prebmap.bits + ((long)prebmap.bytewidth * (prebmap.height - devbbox.ury));
	    else
		line = (BYTE *)prebmap.bits + ((long)prebmap.bytewidth * (devbbox.ury-1));
	}
	else {
	    return 1;
	}
        /* process each strip of bitmap */
	for (strip = 0; strip < stripsperimage; strip++) {
	    int len;
	    is = strip * rowsperstrip;
	    lastrow = min( rowsperstrip, height - is);
            /* process each row of strip */
	    for (i = 0; i < lastrow; i++) {
		if (tiff4 || prebmap.depth==1)
		    get_dib_line(line, preview, prebmap.width, prebmap.depth);
		else
		    memmove(preview,  line, prebmap.bytewidth);
		if (bitoffset)
		    shift_preview(preview, source_bwidth, bitoffset);
		if ( !tiff4 && (*pbitmap != 'P') && (prebmap.depth==24) )
		    reverse_triples(preview, width);
		if (use_packbits) {
		    len = (WORD)packbits(comp_line, preview, bwidth);
		    fwrite(comp_line, 1, len, f);
		}
		else
		    fwrite(preview, 1, bwidth, f);
		if (prebmap.bits) {
		    if (prebmap.topleft)
			line += prebmap.bytewidth;
		    else
			line -= prebmap.bytewidth;
		}
	    }
	}
	if (use_packbits) {
	    free(comp_length);
	    free(comp_line);
	}
	free(preview);
	return 0;
}


/* make a PC EPS file with a TIFF Preview */
/* from a PS file and a bitmap */
int
make_eps_tiff(int type, BOOL calc_bbox, const char *epsname)
{
unsigned char *pbitmap;
char *buffer;
unsigned int count;
FILE *epsfile;
FILE *tiff_file;
char tiffname[MAXSTR];
#if defined(__EMX__) || defined (_MSC_VER)
#pragma pack(1)
#endif
struct eps_header_s eps_header;
#if defined(__EMX__) || defined (_MSC_VER)
#pragma pack()
#endif
FILE *tpsfile;
char tpsname[MAXSTR];
int code;
	
	if ( (pbitmap = (unsigned char *)get_bitmap()) == (unsigned char *)NULL) {
	    play_sound(SOUND_ERROR);
	    return 1;
	}

	if ( (tiff_file = gp_open_scratch_file(szScratch, tiffname, "wb")) == (FILE *)NULL) {
	    play_sound(SOUND_ERROR);
	    release_bitmap();
	    return 1;
	}
	code = write_tiff(tiff_file, pbitmap, (type == IDM_MAKEEPST4), (type == IDM_MAKEEPST6P), calc_bbox);

	fclose(tiff_file);
	release_bitmap();
	if (code) {
	    unlink(tiffname);
	    return code;
	}

	if (calc_bbox) {
	    CDSC *dsc = psfile.dsc;
	    /* we need to copy the psfile to a temporary file */
	    /* because we will be changing the %%BoundingBox line */
	    if ( (tpsfile = gp_open_scratch_file(szScratch, tpsname, "wb")) == (FILE *)NULL) {
		play_sound(SOUND_ERROR);
		return 1;
	    }
	    copy_bbox_header(tpsfile); /* adjust %%BoundingBox: comment */
	    ps_copy(tpsfile, psfile.file, dsc->begindefaults, dsc->enddefaults);
	    ps_copy(tpsfile, psfile.file, dsc->beginprolog, dsc->endprolog);
	    ps_copy(tpsfile, psfile.file, dsc->beginsetup, dsc->endsetup);
	    if (dsc->page_count)
	        ps_copy(tpsfile, psfile.file, dsc->page[0].begin, dsc->page[0].end);
	    copy_trailer_without_bbox(tpsfile);
	    fclose(tpsfile);
	    if ( (tpsfile = fopen(tpsname, "rb")) == (FILE *)NULL) {
		play_sound(SOUND_ERROR);
		return 1;
	    }
	}
	else {
	    if ( (tpsfile = fopen(psfile_name(&psfile), "rb"))
	  	== (FILE *)NULL) {
		unlink(tiffname);
		return 1;
	    }
	}

#ifdef EPSTOOL
	if (*epsname!='\0')
	    epsfile = fopen(epsname,"wb");
	else
	    epsfile = stdout;
#else
	/* create EPS file */
	epsfile = fopen(epsname,"wb");
#endif
	if (epsfile == (FILE *)NULL) {
	    play_sound(SOUND_ERROR);
	    release_bitmap();
	    return 1;
	}

	/* write DOS EPS binary header */
	eps_header.id[0] = (char) 0xc5;
	eps_header.id[1] = (char) 0xd0;
	eps_header.id[2] = (char) 0xd3;
	eps_header.id[3] = (char) 0xc6;
	eps_header.ps_begin = EPS_HEADER_SIZE;
	if (calc_bbox) {
	    fseek(tpsfile, 0, SEEK_END);
	    eps_header.ps_length = ftell(tpsfile);
	}
	else if (psfile.dsc->dcs2 && psfile.dsc->page_count) {
	    /* add all pages */
	    int i;
 	    unsigned long begin = psfile.dsc->page[0].begin;
	    unsigned long end = begin;
	    for (i=0; i<(int)psfile.dsc->page_count; i++) {
		if (psfile.dsc->page[i].end > end)
	            end = psfile.dsc->page[i].end;
	    }
	    eps_header.ps_length = end - begin;
	}
	else {
	    /* don't use ftell(), because we may already have an eps preview */
	    unsigned long end = psfile.dsc->begincomments;
	    if (psfile.dsc->endcomments > end)
	       end = psfile.dsc->endcomments;
	    if (psfile.dsc->enddefaults > end)
	       end = psfile.dsc->enddefaults;
	    if (psfile.dsc->endprolog > end)
	       end = psfile.dsc->endprolog;
	    if (psfile.dsc->endsetup > end)
	       end = psfile.dsc->endsetup;
	    if (psfile.dsc->page_count && (psfile.dsc->page[0].end > end))
	        end = psfile.dsc->page[0].end;
	    if (psfile.dsc->endtrailer > end)
	       end = psfile.dsc->endtrailer;
	    eps_header.ps_length = end - psfile.dsc->begincomments;
	}
	eps_header.mf_begin = 0;
	eps_header.mf_length = 0;
	eps_header.tiff_begin = eps_header.ps_begin + eps_header.ps_length;
	tiff_file = fopen(tiffname,"rb");
	fseek(tiff_file, 0, SEEK_END);
	eps_header.tiff_length = ftell(tiff_file);
	eps_header.checksum = 0xffff;
	write_doseps_header(&eps_header, epsfile);

	buffer = (char *)malloc(COPY_BUF_SIZE);
	if (buffer == (char *)NULL) {
	    play_sound(SOUND_ERROR);
	    fclose(epsfile);
	    unlink(epsname);
	    fclose(tiff_file);
	    unlink(tiffname);
	    fclose(tpsfile);
	    if (calc_bbox)
		unlink(tpsname);
	    return 1;
	}

	/* copy EPS file */
	if (calc_bbox) {
	    rewind(tpsfile);
	    while ( (count = fread(buffer, 1, COPY_BUF_SIZE, tpsfile)) != 0 )
		fwrite(buffer, 1, count, epsfile);
	}
	else if (psfile.dsc->dcs2 && psfile.dsc->page_count) {
	    /* add all pages */
	    ps_copy(epsfile, psfile.file, psfile.dsc->page[0].begin, 
		eps_header.ps_length + psfile.dsc->page[0].begin);
	}
	else {
	    CDSC *dsc = psfile.dsc;
	    ps_copy(epsfile, psfile.file, dsc->begincomments, dsc->endcomments);
	    ps_copy(epsfile, psfile.file, dsc->begindefaults, dsc->enddefaults);
	    ps_copy(epsfile, psfile.file, dsc->beginprolog, dsc->endprolog);
	    ps_copy(epsfile, psfile.file, dsc->beginsetup, dsc->endsetup);
	    if (dsc->page_count)
	        ps_copy(epsfile, psfile.file, dsc->page[0].begin, dsc->page[0].end);
	    ps_copy(epsfile, psfile.file, dsc->begintrailer, dsc->endtrailer);
	}
	
	/* copy tiff file */
	rewind(tiff_file);
        while ( (count = fread(buffer, 1, COPY_BUF_SIZE, tiff_file)) != 0 ) 
	{
	    fwrite(buffer, 1, count, epsfile);
	}

	free(buffer);
	fclose(tiff_file);
	unlink(tiffname);
        fclose(tpsfile);
	if (calc_bbox)
	    unlink(tpsname);
	if (*epsname!='\0')
	   fclose(epsfile);
	return 0;
}

static char hex[17] = "0123456789ABCDEF";

/* write interchange preview to file f */
int
write_interchange(FILE *f, unsigned char *pbitmap, BOOL calc_bbox)
{
	int i, j;
	unsigned char *preview;
	BYTE *line;
	int preview_width, bwidth;
	int lines_per_scan;
	PREBMAP prebmap;
	PSBBOX devbbox;	/* in pixel units */
	int code;
	CDSC *dsc = psfile.dsc;
	
	if (*pbitmap == 'P')
	    code = scan_pbmplus(&prebmap, pbitmap);
	else {
	    code = scan_dib(&prebmap, pbitmap);
	}
	if (code)
	    return code;
	
	if (calc_bbox) {
	    scan_bbox(&prebmap, &devbbox);
	    if (devbbox.valid) {
	    	/* copy to global bbox as if obtained by PS to EPS */
	    	bbox.llx = (int)(devbbox.llx * 72.0 / option.xdpi - 0.5);
	    	bbox.lly = (int)(devbbox.lly * 72.0 / option.ydpi - 0.5);
	    	bbox.urx = (int)(devbbox.urx * 72.0 / option.xdpi + 1.5);
	    	bbox.ury = (int)(devbbox.ury * 72.0 / option.ydpi + 1.5);
	    	bbox.valid = TRUE;
	    }
	    copy_bbox_header(f); /* adjust %%BoundingBox: comment */
	}
	else {
#ifdef EPSTOOL
	    devbbox.urx = prebmap.width;
	    devbbox.ury = prebmap.height;
	    devbbox.llx = devbbox.lly = 0;
#else
	    if (display.epsf_clipped || (psfile.dsc->bbox==(CDSCBBOX *)NULL)) {
		/* copy all of display bitmap */
		devbbox.urx = prebmap.width;
		devbbox.ury = prebmap.height;
		devbbox.llx = devbbox.lly = 0;
	    }
	    else {
		/* copy only part of display bitmap */
		devbbox.llx = (int)(psfile.dsc->bbox->llx * option.xdpi / 72.0);
		devbbox.lly = (int)(psfile.dsc->bbox->lly * option.ydpi / 72.0);
		devbbox.urx = (int)(psfile.dsc->bbox->urx * option.xdpi / 72.0 + 0.5);
		devbbox.ury = (int)(psfile.dsc->bbox->ury * option.ydpi / 72.0 + 0.5);
#define LIMIT(z, limit) if (z < 0) z = 0; else if (z > limit) z = limit
		LIMIT(devbbox.llx, prebmap.width);
		LIMIT(devbbox.lly, prebmap.height);
		LIMIT(devbbox.urx, prebmap.width);
		LIMIT(devbbox.ury, prebmap.height);
#undef LIMIT
	    }
#endif
	    ps_copy(f, psfile.file, dsc->begincomments, dsc->endcomments);
	}

	bwidth = (((devbbox.urx-devbbox.llx) + 7) & ~7) >> 3; /* byte width with 1 bit/pixel */
	preview_width = ((prebmap.width + 7) & ~7) >> 3; /* byte width with 1 bit/pixel */

	preview = (unsigned char *) malloc(preview_width);

	lines_per_scan = ((bwidth-1) / 32) + 1;
	fprintf(f,"%%%%BeginPreview: %u %u 1 %u",(devbbox.urx-devbbox.llx), (devbbox.ury-devbbox.lly), 
	    (devbbox.ury-devbbox.lly)*lines_per_scan);
	fputs(EOLSTR, f);

	if (prebmap.bits) {
	    if (prebmap.topleft)
		line = (BYTE *)prebmap.bits + ((long)prebmap.bytewidth * (prebmap.height - devbbox.ury));
	    else
		line = (BYTE *)prebmap.bits + ((long)prebmap.bytewidth * (devbbox.ury-1));
	}
	else {
	    return FALSE;
	}
	/* process each line of bitmap */
	for (i = 0; i < (devbbox.ury-devbbox.lly); i++) {
	    get_dib_line(line, preview, prebmap.width, prebmap.depth);
	    if (devbbox.llx)
		shift_preview(preview, preview_width, devbbox.llx);
	    fputs("% ",f);
	    for (j=0; j<bwidth; j++) {
		if (j && ((j & 31) == 0)) {
		    fputs(EOLSTR, f);
		    fputs("% ",f);
		}
		fputc(hex[15-((preview[j]>>4)&15)],f);
		fputc(hex[15-((preview[j])&15)],f);
	    }
	    fputs(EOLSTR, f);
	    if (prebmap.bits) {
		if (prebmap.topleft)
		    line += prebmap.bytewidth;
		else 
		    line -= prebmap.bytewidth;
	    }
	}

	fputs("%%EndPreview",f);
	fputs(EOLSTR, f);
	free(preview);
	ps_copy(f, psfile.file, dsc->begindefaults, dsc->enddefaults);
	ps_copy(f, psfile.file, dsc->beginprolog, dsc->endprolog);
	ps_copy(f, psfile.file, dsc->beginsetup, dsc->endsetup);
	if (dsc->page_count)
	    ps_copy(f, psfile.file, dsc->page[0].begin, dsc->page[0].end);
	if (calc_bbox)
	    copy_trailer_without_bbox(f);
	else
	    ps_copy(f, psfile.file, dsc->begintrailer, dsc->endtrailer);
	return 0;
}

/* make an EPSI file with an Interchange Preview */
/* from a PS file and a bitmap */
int
make_eps_interchange(BOOL calc_bbox, const char *epiname)
{
FILE *epifile;
LPBITMAP2 pbm;
int code;

	if ( (pbm = get_bitmap()) == (LPBITMAP2)NULL) {
	    play_sound(SOUND_ERROR);
	    return 1;
	}

#ifdef EPSTOOL
	if (*epiname!='\0')
	    epifile = fopen(epiname,"wb");
	else
	    epifile = stdout;
#else
	/* create EPI file */
	epifile = fopen(epiname,"wb");
#endif

	if (epifile == (FILE *)NULL) {
	    play_sound(SOUND_ERROR);
	    release_bitmap();
	    return 1;
	}

	gfile_seek(psfile.file, 0, gfile_begin);
	code = write_interchange(epifile, (unsigned char *)pbm, calc_bbox);
	if (*epiname!='\0')