4.3BSD/usr/contrib/dipress/src/bin/dipress/bitmap.c
/*
* bitmap - routines that help build a bitmap of a graphical image
*
* These are primarily used to implement all of the drawing primitives
* (except for lines)
*
* History:
*28-aug-85 John Mellor-Crummey added flush_bitmap which is used instead
* of print_bitmap if current page is not outputted
*
* 17-jun-85 ed flint bitmap width(bm_width) must be multiple of 32
* bits for print services 12 (?)
*
* Copyright (c) 1984, 1985 Xerox Corp.
*
*/
# include <stdio.h>
# include "iptokens.h"
# include "literal.h"
# include "operator.h"
# define local static
# define No 0
# define Yes 1
# define INCH 2540 /* micas per inch */
extern int drawidth;
extern double drawscale;
char *malloc();
local int minx;
local int miny;
local int maxx;
local int maxy;
local int bm_width; /* in real bytes */
local int bm_size;
local char *bitmap;
local char *bm_prelude;
local char bm_active = No;
# define scale_x(x) x = (double)x * drawscale
# define scale_y(y) y = (double)y * drawscale
/*
* new_bitmap(x1, y1, x2, y2) - prepare for a new bitmap, the extreme x and y
* values are x1, y1, x2, and y2.
*/
new_bitmap(stroke, x1, y1, x2, y2)
int stroke, x1, y1, x2, y2;
{
int new_size;
register int temp;
#ifdef DEBUG
fprintf(stderr, "new_bitmap(%d, %d, %d, %d, %d)\n", stroke,x1, y1, x2, y2);
#endif
drawidth = stroke * drawscale;
scale_x(x1);
scale_y(y1);
scale_x(x2);
scale_y(y2);
#ifdef DEBUG
fprintf(stderr, "after scaling: width %d: %d, %d and %d, %d\n", drawidth, x1, y1, x2, y2);
#endif
/* insure that x1, y1 is the lower left */
if (x1 > x2)
{
#ifdef DEBUG
fprintf(stderr, "exchanging pairs ... ");
#endif
temp = x1; /* exchange x1 and x2 */
x1 = x2;
x2 = temp;
temp = y1; /* exchange y1 and y2 */
y1 = y2;
y2 = temp;
#ifdef DEBUG
fprintf(stderr, "now %d, %d and %d, %d\n", x1, y1, x2, y2);
#endif
}
/* adjust the extremes to allow for pen thickness */
temp = (drawidth + 1) / 2;
x1 -= temp;
y1 -= temp;
x2 += temp;
y2 += temp;
if (!bm_active || !(x1 >= minx && y1 >= miny && x2 <= maxx && y2 <= maxy))
{
/* we need to set up a new map */
/* but first, print the old one if it is still active */
#ifdef DEBUG
fprintf(stderr, "setting up new map, bm_active is %d\n", bm_active);
#endif
print_bitmap();
minx = x1;
miny = y1;
maxx = x2;
maxy = y2;
bm_width = (y2 - y1 + 7) / 8;
/* print services 12 (?) wants packed pixel vectors to produce each */
/* scan line as a mutliple of 32 bits, this is backward compatible */
/* with previous versions of services */
/* (the previous version of bitmap produced 16 bit multiples which */
/* will NOT work with services 12 (?) and beyond) */
if ( bm_width%4 != 0 )
{
bm_width= bm_width + (4 - bm_width%4);
}
new_size = (x2 - x1) * bm_width;
if (new_size > bm_size)
{
/* need to allocate a larger area for the bitmap */
if (bitmap != NULL)
{
free(bitmap);
}
/* leave space for the ppv prelude (leading 4 bytes) */
bm_prelude = malloc((unsigned)(new_size + 4));
bitmap = bm_prelude + 4;
bm_size = new_size;
}
#ifdef DEBUG
fprintf(stderr, "bm_width %d, bm_size %d\n", bm_width, bm_size);
#endif
bzero(bitmap, bm_size);
}
}
set_pixel(x, y)
int x;
int y;
{
int mask;
int half_drawidth;
register int i;
register int ybit, temp;
register char *ptr;
scale_x(x);
scale_y(y);
bm_active = Yes;
#ifdef DEBUG
if (x < minx || x > maxx || y < miny || y > maxy)
{
fprintf(stderr, "point off map: (%d, %d)\n", x, y);
return;
}
#endif
x -= minx;
y = maxy - y; /* yes, it works */
half_drawidth = drawidth >> 1;
/* Remember the bitmap is built in increasing y */
/* draw the "x" line vertically */
mask = 0x80 >> (y & 007);
ptr = (x - half_drawidth) * bm_width + (y >> 3) + bitmap;
for (i = 0; i < drawidth; i++, ptr += bm_width)
{
*ptr |= mask;
}
/* draw the "y" line horizontally */
y -= half_drawidth;
ptr = (x * bm_width) + (y >> 3) + bitmap;
ybit = y & 007;
temp = ybit + drawidth;
if (temp < 8)
{
/* special case -- less than one byte */
*ptr |= (0xff >> ybit) ^ (0xff >> temp);
}
else
{
*ptr |= (0xff >> ybit);
for (i = drawidth - 8 + ybit; i > 8; i -= 8)
{
*++ptr |= 0xff;
}
*++ptr |= ~(0xff >> i);
}
}
flush_bitmap()
{
bm_active = No;
}
print_bitmap()
{
register int bits;
register char *prelude = bm_prelude;
int totalbits, size, bm_xdelta, bm_x = minx;
#ifdef DEBUG2
int x;
int y;
int i;
char *ptr;
#endif
if (!bm_active)
{
/* don't bother */
return;
}
#ifdef DEBUG2
/* debugging version for now */
ptr = bitmap;
for (x = minx; x <= maxx; x++)
{
for (y = miny; y <= maxy; y += 8, ptr++)
{
for (i = 0x80; i != 0; i >>= 1)
{
if (*ptr & i)
{
putchar('*');
}
else
{
putchar(' ');
}
}
}
putchar('\n');
}
#endif
/* The following is conservative (might actually be twice as big) */
#define MAXPPVSAMPS 262144
bm_xdelta = maxx - minx;
bits = bm_width << 3; /* (* 8) */
totalbits = bits * bm_xdelta;
if (totalbits > MAXPPVSAMPS) {
bm_xdelta = MAXPPVSAMPS / bits;
}
while (bm_x < maxx) {
/* Check for last time through loop */
if (bm_xdelta > (maxx - bm_x)) {
bm_xdelta = maxx - bm_x;
}
size = (bits * bm_xdelta) >> 3; /* Could hand optimize! */
/* inside a dosavesimplebody to preserve transform */
Op(dosavesimplebody);
Op(beginBody);
AppendInteger((long) bm_xdelta); /* xPixels */
AppendInteger((long) bits); /* yPixels */
AppendInteger(1L); /* samplesPerPixel */
AppendInteger(1L); /* maxSampleValue */
AppendInteger(1L); /* samplesInterleaved */
Translate(0.0, 0.0); /* (null) transform */
/* spew out the packed pixel vector */
prelude[0] = 0;
prelude[1] = 1;
prelude[2] = (char)((bits & 0xff00) >> 8); /* high order byte */
prelude[3] = (char) (bits & 0x00ff); /* low order byte */
append_Sequence(sequencePackedPixelVector, size + 4,
(unsigned char *) prelude);
/* make the pixel array */
Op(makepixelarray);
/* set the transform to the right scale and position */
/* transform must scale back to micas and position bitmap */
AppendInteger((long) bm_x);
AppendInteger((long) ((11 * INCH * drawscale) - maxy));
Op(translate);
AppendInteger(5L);
Op(scale);
Op(concat);
Op(concatt);
/* mask it and finish the simple-body */
Op(maskpixel);
Op(endBody);
prelude += size;
bm_x += bm_xdelta;
}
/* no longer active, now is it? */
bm_active = No;
}