X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=sys%2Fsrc%2Flibmemdraw%2Fdraw.c;h=d72715aad56f646f7016ee5367cf3f46a58735b6;hb=485a3301e6119f0c85d7869d469fc0a0888e49c1;hp=dfc89b890f0cba02380f411a5eabb29dae010dc4;hpb=68571320fa2ba4f993199370d60dc4dbd114bea8;p=plan9front.git

diff --git a/sys/src/libmemdraw/draw.c b/sys/src/libmemdraw/draw.c
index dfc89b890..d72715aad 100644
--- a/sys/src/libmemdraw/draw.c
+++ b/sys/src/libmemdraw/draw.c
@@ -5,7 +5,6 @@
 #include <pool.h>
 
 extern Pool* imagmem;
-int drawdebug;
 
 /* perfect approximation to NTSC = .299r+.587g+.114b when 0 ≤ r,g,b < 256 */
 #define RGB2K(r,g,b)	((156763*(r)+307758*(g)+59769*(b))>>19)
@@ -98,7 +97,6 @@ static ulong imgtorgba(Memimage*, ulong);
 static ulong rgbatoimg(Memimage*, ulong);
 static ulong pixelbits(Memimage*, Point);
 
-#define DBG if(0)
 void
 memimagedraw(Memimage *dst, Rectangle r, Memimage *src, Point p0, Memimage *mask, Point p1, int op)
 {
@@ -107,19 +105,11 @@ memimagedraw(Memimage *dst, Rectangle r, Memimage *src, Point p0, Memimage *mask
 	if(mask == nil)
 		mask = memopaque;
 
-DBG	print("memimagedraw %p/%luX %R @ %p %p/%luX %P %p/%luX %P... ", dst, dst->chan, r, dst->data->bdata, src, src->chan, p0, mask, mask->chan, p1);
-
-	if(drawclip(dst, &r, src, &p0, mask, &p1, &par.sr, &par.mr) == 0){
-//		if(drawdebug)
-//			iprint("empty clipped rectangle\n");
+	if(drawclip(dst, &r, src, &p0, mask, &p1, &par.sr, &par.mr) == 0)
 		return;
-	}
 
-	if(op < Clear || op > SoverD){
-//		if(drawdebug)
-//			iprint("op out of range: %d\n", op);
+	if(op < Clear || op > SoverD)
 		return;
-	}
 
 	par.op = op;
 	par.dst = dst;
@@ -137,10 +127,8 @@ DBG	print("memimagedraw %p/%luX %R @ %p %p/%luX %P %p/%luX %P... ", dst, dst->ch
 			par.state |= Simplesrc;
 			par.srgba = imgtorgba(src, par.sval);
 			par.sdval = rgbatoimg(dst, par.srgba);
-			if((par.srgba&0xFF) == 0 && (op&DoutS)){
-//				if (drawdebug) iprint("fill with transparent source\n");
+			if((par.srgba&0xFF) == 0 && (op&DoutS))
 				return;	/* no-op successfully handled */
-			}
 		}
 	}
 
@@ -148,10 +136,8 @@ DBG	print("memimagedraw %p/%luX %R @ %p %p/%luX %P %p/%luX %P... ", dst, dst->ch
 		par.state |= Replmask;
 		if(Dx(mask->r)==1 && Dy(mask->r)==1){
 			par.mval = pixelbits(mask, mask->r.min);
-			if(par.mval == 0 && (op&DoutS)){
-//				if(drawdebug) iprint("fill with zero mask\n");
+			if(par.mval == 0 && (op&DoutS))
 				return;	/* no-op successfully handled */
-			}
 			par.state |= Simplemask;
 			if(par.mval == ~0)
 				par.state |= Fullmask;
@@ -159,10 +145,6 @@ DBG	print("memimagedraw %p/%luX %R @ %p %p/%luX %P %p/%luX %P... ", dst, dst->ch
 		}
 	}
 
-//	if(drawdebug)
-//		iprint("dr %R sr %R mr %R...", r, par.sr, par.mr);
-DBG print("draw dr %R sr %R mr %R %lux\n", r, par.sr, par.mr, par.state);
-
 	/*
 	 * Now that we've clipped the parameters down to be consistent, we 
 	 * simply try sub-drawing routines in order until we find one that was able
@@ -175,42 +157,27 @@ DBG print("draw dr %R sr %R mr %R %lux\n", r, par.sr, par.mr, par.state);
 	 * which checks to see if there is anything it can help with.
 	 * There could be an if around this checking to see if dst is in video memory.
 	 */
-DBG print("test hwdraw\n");
-	if(hwdraw(&par)){
-//if(drawdebug) iprint("hw handled\n");
-DBG print("hwdraw handled\n");
+	if(hwdraw(&par))
 		return;
-	}
+
 	/*
 	 * Optimizations using memmove and memset.
 	 */
-DBG print("test memoptdraw\n");
-	if(memoptdraw(&par)){
-//if(drawdebug) iprint("memopt handled\n");
-DBG print("memopt handled\n");
+	if(memoptdraw(&par))
 		return;
-	}
 
 	/*
 	 * Character drawing.
 	 * Solid source color being painted through a boolean mask onto a high res image.
 	 */
-DBG print("test chardraw\n");
-	if(chardraw(&par)){
-//if(drawdebug) iprint("chardraw handled\n");
-DBG print("chardraw handled\n");
+	if(chardraw(&par))
 		return;
-	}
 
 	/*
 	 * General calculation-laden case that does alpha for each pixel.
 	 */
-DBG print("do alphadraw\n");
 	alphadraw(&par);
-//if(drawdebug) iprint("alphadraw handled\n");
-DBG print("alphadraw handled\n");
 }
-#undef DBG
 
 
 /*
@@ -461,9 +428,6 @@ struct Param {
 	int	convdx;
 };
 
-static uchar *drawbuf;
-static int	ndrawbuf;
-static int	mdrawbuf;
 static Readfn	greymaskread, replread, readptr;
 static Writefn	nullwrite;
 static Calcfn	alphacalc0, alphacalc14, alphacalc2810, alphacalc3679, alphacalc5, alphacalc11, alphacalcS;
@@ -475,7 +439,6 @@ static Writefn*	writefn(Memimage*);
 
 static Calcfn*	boolcopyfn(Memimage*, Memimage*);
 static Readfn*	convfn(Memimage*, Param*, Memimage*, Param*, int*);
-static Readfn*	ptrfn(Memimage*);
 
 static Calcfn *alphacalc[Ncomp] = 
 {
@@ -584,40 +547,6 @@ clipy(Memimage *img, int *y)
 	assert(0 <= *y && *y < dy);
 }
 
-static void
-dumpbuf(char *s, Buffer b, int n)
-{
-	int i;
-	uchar *p;
-	
-	print("%s", s);
-	for(i=0; i<n; i++){
-		print(" ");
-		if(p=b.grey){
-			print(" k%.2uX", *p);
-			b.grey += b.delta;
-		}else{	
-			if(p=b.red){
-				print(" r%.2uX", *p);
-				b.red += b.delta;
-			}
-			if(p=b.grn){
-				print(" g%.2uX", *p);
-				b.grn += b.delta;
-			}
-			if(p=b.blu){
-				print(" b%.2uX", *p);
-				b.blu += b.delta;
-			}
-		}
-		if((p=b.alpha) != &ones){
-			print(" α%.2uX", *p);
-			b.alpha += b.delta;
-		}
-	}
-	print("\n");
-}
-
 /*
  * For each scan line, we expand the pixels from source, mask, and destination
  * into byte-aligned red, green, blue, alpha, and grey channels.  If buffering is not
@@ -633,7 +562,6 @@ dumpbuf(char *s, Buffer b, int n)
  * the calculator, and that buffer is passed to a function to write it to the destination.
  * If the buffer is already pointing at the destination, the writing function is a no-op.
  */
-#define DBG if(0)
 static int
 alphadraw(Memdrawparam *par)
 {
@@ -697,9 +625,7 @@ alphadraw(Memdrawparam *par)
 	 * but it avoids a fair amount of code duplication to make this a case here
 	 * rather than have a separate booldraw.
 	 */
-//if(drawdebug) iprint("flag %lud mchan %lux=?%x dd %d\n", src->flags&Falpha, mask->chan, GREY1, dst->depth);
 	if(!(src->flags&Falpha) && mask->chan == GREY1 && dst->depth >= 8 && op == SoverD){
-//if(drawdebug) iprint("boolcopy...");
 		rdsrc = convfn(dst, &z->dpar, src, &z->spar, &ndrawbuf);
 		rddst = readptr;
 		rdmask = readfn(mask);
@@ -799,13 +725,8 @@ alphadraw(Memdrawparam *par)
 		clipy(mask, &masky);
 
 		bsrc = rdsrc(&z->spar, z->spar.bufbase, srcy);
-DBG print("[");
 		bmask = rdmask(&z->mpar, z->mpar.bufbase, masky);
-DBG print("]\n");
 		bdst = rddst(&z->dpar, z->dpar.bufbase, dsty);
-DBG		dumpbuf("src", bsrc, dx);
-DBG		dumpbuf("mask", bmask, dx);
-DBG		dumpbuf("dst", bdst, dx);
 		bdst = calc(bdst, bsrc, bmask, dx, isgrey, op);
 		wrdst(&z->dpar, z->dpar.bytermin+dsty*z->dpar.bwidth, bdst);
 	}
@@ -813,7 +734,6 @@ DBG		dumpbuf("dst", bdst, dx);
 	z->inuse = 0;
 	return 1;
 }
-#undef DBG
 
 static Buffer
 alphacalc0(Buffer bdst, Buffer b1, Buffer b2, int dx, int grey, int op)
@@ -1346,7 +1266,6 @@ greymaskread(Param *p, uchar *buf, int y)
 	return b;
 }
 
-#define DBG if(0)
 static Buffer
 readnbit(Param *p, uchar *buf, int y)
 {
@@ -1375,22 +1294,18 @@ readnbit(Param *p, uchar *buf, int y)
 		n = p->img->r.max.x - x;
 
 	r = p->bytermin + y*p->bwidth;
-DBG print("readnbit dx %d %p=%p+%d*%d, *r=%d fetch %d ", dx, r, p->bytermin, y, p->bwidth, *r, n);
 	bits = *r++;
 	nbits = 8;
 	if(i=x&(npack-1)){
-DBG print("throwaway %d...", i);
 		bits <<= depth*i;
 		nbits -= depth*i;
 	}
 	for(i=0; i<n; i++){
 		if(nbits == 0){
-DBG print("(%.2ux)...", *r);
 			bits = *r++;
 			nbits = 8;
 		}
 		*w++ = repl[bits>>sh];
-DBG print("bit %x...", repl[bits>>sh]);
 		bits <<= depth;
 		nbits -= depth;
 	}
@@ -1407,24 +1322,20 @@ DBG print("bit %x...", repl[bits>>sh]);
 		n = p->r.min.x - x;
 
 	r = p->bytey0s + y*p->bwidth;
-DBG print("x=%d r=%p...", x, r);
 	bits = *r++;
 	nbits = 8;
 	if(i=x&(npack-1)){
 		bits <<= depth*i;
 		nbits -= depth*i;
 	}
-DBG print("nbits=%d...", nbits);
 	for(i=0; i<n; i++){
 		if(nbits == 0){
 			bits = *r++;
 			nbits = 8;
 		}
 		*w++ = repl[bits>>sh];
-DBG print("bit %x...", repl[bits>>sh]);
 		bits <<= depth;
 		nbits -= depth;
-DBG print("bits %x nbits %d...", bits, nbits);
 	}
 	dx -= n;
 	if(dx == 0)
@@ -1438,9 +1349,7 @@ DBG print("bits %x nbits %d...", bits, nbits);
 
 	return b;
 }
-#undef DBG
 
-#define DBG if(0)
 static void
 writenbit(Param *p, uchar *w, Buffer src)
 {
@@ -1463,7 +1372,6 @@ writenbit(Param *p, uchar *w, Buffer src)
 
 	for(; x<ex; x++){
 		bits <<= depth;
-DBG print(" %x", *r);
 		bits |= (*r++ >> sh);
 		nbits += depth;
 		if(nbits == 8){
@@ -1478,10 +1386,8 @@ DBG print(" %x", *r);
 		bits |= *w & ((1<<sh)-1);
 		*w = bits;
 	}
-DBG print("\n");
 	return;
 }
-#undef DBG
 
 static Buffer
 readcmap(Param *p, uchar *buf, int y)
@@ -1579,7 +1485,6 @@ writecmap(Param *p, uchar *w, Buffer src)
 	}
 }
 
-#define DBG if(0)
 static Buffer
 readbyte(Param *p, uchar *buf, int y)
 {
@@ -1604,7 +1509,6 @@ readbyte(Param *p, uchar *buf, int y)
 	alphaonly = p->alphaonly;
 	copyalpha = (img->flags&Falpha) != 0;
 
-DBG print("copyalpha %d alphaonly %d convgrey %d isgrey %d\n", copyalpha, alphaonly, convgrey, isgrey);
 	/* if we can, avoid processing everything */
 	if(!(img->flags&Frepl) && !convgrey && (img->flags&Fbytes)){
 		memset(&b, 0, sizeof b);
@@ -1629,7 +1533,6 @@ DBG print("copyalpha %d alphaonly %d convgrey %d isgrey %d\n", copyalpha, alphao
 		return b;
 	}
 
-DBG print("2\n");
 	rrepl = replbit[img->nbits[CRed]];
 	grepl = replbit[img->nbits[CGreen]];
 	brepl = replbit[img->nbits[CBlue]];
@@ -1640,7 +1543,6 @@ DBG print("2\n");
 		u = r[0] | (r[1]<<8) | (r[2]<<16) | (r[3]<<24);
 		if(copyalpha) {
 			*w++ = arepl[(u>>img->shift[CAlpha]) & img->mask[CAlpha]];
-DBG print("a %x\n", w[-1]);
 		}
 
 		if(isgrey)
@@ -1650,9 +1552,7 @@ DBG print("a %x\n", w[-1]);
 			ugrn = grepl[(u >> img->shift[CGreen]) & img->mask[CGreen]];
 			ublu = brepl[(u >> img->shift[CBlue]) & img->mask[CBlue]];
 			if(convgrey){
-DBG print("g %x %x %x\n", ured, ugrn, ublu);
 				*w++ = RGB2K(ured, ugrn, ublu);
-DBG print("%x\n", w[-1]);
 			}else{
 				w[0] = ublu;
 				w[1] = ugrn;
@@ -1676,7 +1576,6 @@ DBG print("%x\n", w[-1]);
 		b.grey = buf+copyalpha;
 		b.red = b.grn = b.blu = buf+copyalpha;
 		b.delta = copyalpha+1;
-DBG print("alpha %x grey %x\n", *b.alpha, *b.grey);
 	}else{
 		b.blu = buf+copyalpha;
 		b.grn = buf+copyalpha+1;
@@ -1686,9 +1585,7 @@ DBG print("alpha %x grey %x\n", *b.alpha, *b.grey);
 	}
 	return b;
 }
-#undef DBG
 
-#define DBG if(0)
 static void
 writebyte(Param *p, uchar *w, Buffer src)
 {
@@ -1749,12 +1646,9 @@ writebyte(Param *p, uchar *w, Buffer src)
 	mask = (nb==4) ? 0 : ~((1<<img->depth)-1);
 	for(i=0; i<dx; i++){
 		u = w[0] | (w[1]<<8) | (w[2]<<16) | (w[3]<<24);
-DBG print("u %.8lux...", u);
 		u &= mask;
-DBG print("&mask %.8lux...", u);
 		if(isgrey){
 			u |= ((*grey >> (8-img->nbits[CGrey])) & img->mask[CGrey]) << img->shift[CGrey];
-DBG print("|grey %.8lux...", u);
 			grey += delta;
 		}else{
 			u |= ((*red >> (8-img->nbits[CRed])) & img->mask[CRed]) << img->shift[CRed];
@@ -1763,13 +1657,11 @@ DBG print("|grey %.8lux...", u);
 			red += delta;
 			grn += delta;
 			blu += delta;
-DBG print("|rgb %.8lux...", u);
 		}
 
 		if(isalpha){
 			u |= ((*alpha >> (8-img->nbits[CAlpha])) & img->mask[CAlpha]) << img->shift[CAlpha];
 			alpha += adelta;
-DBG print("|alpha %.8lux...", u);
 		}
 
 		w[0] = u;
@@ -1779,7 +1671,6 @@ DBG print("|alpha %.8lux...", u);
 		w += nb;
 	}
 }
-#undef DBG
 
 static Readfn*
 readfn(Memimage *img)
@@ -1955,14 +1846,11 @@ genconv(Param *p, uchar *buf, int y)
 static Readfn*
 convfn(Memimage *dst, Param *dpar, Memimage *src, Param *spar, int *ndrawbuf)
 {
-	if(dst->chan == src->chan && !(src->flags&Frepl)){
-//if(drawdebug) iprint("readptr...");
+	if(dst->chan == src->chan && !(src->flags&Frepl))
 		return readptr;
-	}
 
 	if(dst->chan==CMAP8 && (src->chan==GREY1||src->chan==GREY2||src->chan==GREY4)){
 		/* cheat because we know the replicated value is exactly the color map entry. */
-//if(drawdebug) iprint("Readnbit...");
 		return readnbit;
 	}
 
@@ -1979,7 +1867,6 @@ convfn(Memimage *dst, Param *dpar, Memimage *src, Param *spar, int *ndrawbuf)
 		spar->dx = Dx(spar->img->r);
 	}
 
-//if(drawdebug) iprint("genconv...");
 	return genconv;
 }
 
@@ -2190,11 +2077,9 @@ rgbatoimg(Memimage *img, ulong rgba)
 		}
 		d += nb;
 	}
-//	print("rgba2img %.8lux = %.*lux\n", rgba, 2*d/8, v);
 	return v;
 }
 
-#define DBG if(0)
 static int
 memoptdraw(Memdrawparam *par)
 {
@@ -2209,7 +2094,6 @@ memoptdraw(Memdrawparam *par)
 	dst = par->dst;
 	op = par->op;
 
-DBG print("state %lux mval %lux dd %d\n", par->state, par->mval, dst->depth);
 	/*
 	 * If we have an opaque mask and source is one opaque pixel we can convert to the
 	 * destination format and just replicate with memset.
@@ -2219,11 +2103,9 @@ DBG print("state %lux mval %lux dd %d\n", par->state, par->mval, dst->depth);
 		int d, dwid, ppb, np, nb;
 		uchar *dp, lm, rm;
 
-DBG print("memopt, dst %p, dst->data->bdata %p\n", dst, dst->data->bdata);
 		dwid = dst->width*sizeof(ulong);
 		dp = byteaddr(dst, par->r.min);
 		v = par->sdval;
-DBG print("sdval %lud, depth %d\n", v, dst->depth);
 		switch(dst->depth){
 		case 1:
 		case 2:
@@ -2237,16 +2119,13 @@ DBG print("sdval %lud, depth %d\n", v, dst->depth);
 			dx -= (ppb-np);
 			nb = 8 - np * dst->depth;		/* no. bits used on right side of word */
 			lm = (1<<nb)-1;
-DBG print("np %d x %d nb %d lm %ux ppb %d m %ux\n", np, par->r.min.x, nb, lm, ppb, m);	
 
 			/* right edge */
 			np = par->r.max.x&m;	/* no. pixels used on left side of word */
 			dx -= np;
 			nb = 8 - np * dst->depth;		/* no. bits unused on right side of word */
 			rm = ~((1<<nb)-1);
-DBG print("np %d x %d nb %d rm %ux ppb %d m %ux\n", np, par->r.max.x, nb, rm, ppb, m);	
 
-DBG print("dx %d Dx %d\n", dx, Dx(par->r));
 			/* lm, rm are masks that are 1 where we should touch the bits */
 			if(dx < 0){	/* just one byte */
 				lm &= rm;
@@ -2258,7 +2137,6 @@ DBG print("dx %d Dx %d\n", dx, Dx(par->r));
 
 				for(y=0; y<dy; y++, dp+=dwid){
 					if(lm){
-DBG print("dp %p v %lux lm %ux (v ^ *dp) & lm %lux\n", dp, v, lm, (v^*dp)&lm);
 						*dp ^= (v ^ *dp) & lm;
 						dp++;
 					}
@@ -2432,13 +2310,11 @@ DBG print("dp %p v %lux lm %ux (v ^ *dp) & lm %lux\n", dp, v, lm, (v^*dp)&lm);
 	}
 	return 0;	
 }
-#undef DBG
 
 /*
  * Boolean character drawing.
  * Solid opaque color through a 1-bit greyscale mask.
  */
-#define DBG if(0)
 static int
 chardraw(Memdrawparam *par)
 {
@@ -2451,10 +2327,6 @@ chardraw(Memdrawparam *par)
 	Rectangle r, mr;
 	Memimage *mask, *src, *dst;
 
-if(0) if(drawdebug) iprint("chardraw? mf %lux md %d sf %lux dxs %d dys %d dd %d ddat %p sdat %p\n",
-		par->mask->flags, par->mask->depth, par->src->flags, 
-		Dx(par->src->r), Dy(par->src->r), par->dst->depth, par->dst->data, par->src->data);
-
 	mask = par->mask;
 	src = par->src;
 	dst = par->dst;
@@ -2467,8 +2339,6 @@ if(0) if(drawdebug) iprint("chardraw? mf %lux md %d sf %lux dxs %d dys %d dd %d
 	|| op != SoverD)
 		return 0;
 
-//if(drawdebug) iprint("chardraw...");
-
 	depth = mask->depth;
 	maskwid = mask->width*sizeof(ulong);
 	rp = byteaddr(mask, mr.min);
@@ -2477,7 +2347,6 @@ if(0) if(drawdebug) iprint("chardraw? mf %lux md %d sf %lux dxs %d dys %d dd %d
 
 	wp = byteaddr(dst, r.min);
 	dstwid = dst->width*sizeof(ulong);
-DBG print("bsh %d\n", bsh);
 	dy = Dy(r);
 	dx = Dx(r);
 
@@ -2503,20 +2372,17 @@ DBG print("bsh %d\n", bsh);
 	sp[2] = v>>16;
 	sp[3] = v>>24;
 
-//print("sp %x %x %x %x\n", sp[0], sp[1], sp[2], sp[3]);
 	for(y=0; y<dy; y++, rp+=maskwid, wp+=dstwid){
 		q = rp;
 		if(bsh)
 			bits = *q++;
 		switch(ddepth){
 		case 8:
-//if(drawdebug) iprint("8loop...");
 			wc = wp;
 			for(x=bx; x>ex; x--, wc++){
 				i = x&7;
 				if(i == 8-1)
 					bits = *q++;
-DBG print("bits %lux sh %d...", bits, i);
 				if((bits>>i)&1)
 					*wc = v;
 			}
@@ -2528,7 +2394,6 @@ DBG print("bits %lux sh %d...", bits, i);
 				i = x&7;
 				if(i == 8-1)
 					bits = *q++;
-DBG print("bits %lux sh %d...", bits, i);
 				if((bits>>i)&1)
 					*ws = v;
 			}
@@ -2539,7 +2404,6 @@ DBG print("bits %lux sh %d...", bits, i);
 				i = x&7;
 				if(i == 8-1)
 					bits = *q++;
-DBG print("bits %lux sh %d...", bits, i);
 				if((bits>>i)&1){
 					wc[0] = sp[0];
 					wc[1] = sp[1];
@@ -2554,44 +2418,15 @@ DBG print("bits %lux sh %d...", bits, i);
 				i = x&7;
 				if(i == 8-1)
 					bits = *q++;
-DBG iprint("bits %lux sh %d...", bits, i);
 				if((bits>>i)&1)
 					*wl = v;
 			}
 			break;
 		}
 	}
-
-DBG print("\n");	
 	return 1;	
 }
-#undef DBG
-
 
-/*
- * Fill entire byte with replicated (if necessary) copy of source pixel,
- * assuming destination ldepth is >= source ldepth.
- *
- * This code is just plain wrong for >8bpp.
- *
-ulong
-membyteval(Memimage *src)
-{
-	int i, val, bpp;
-	uchar uc;
-
-	unloadmemimage(src, src->r, &uc, 1);
-	bpp = src->depth;
-	uc <<= (src->r.min.x&(7/src->depth))*src->depth;
-	uc &= ~(0xFF>>bpp);
-	/* pixel value is now in high part of byte. repeat throughout byte 
-	val = uc;
-	for(i=bpp; i<8; i<<=1)
-		val |= val>>i;
-	return val;
-}
- * 
- */
 
 void
 memfillcolor(Memimage *i, ulong val)