Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <draw.h>

#include <memdraw.h>

#include <pool.h>

void

memimagemove(void *from, void *to)

{

	Memdata *md;

	md = *(Memdata**)to;

	if(md->base != from){

		print("compacted data not right: #%p\n", md->base);

		abort();

	}

	md->base = to;

	/* if allocmemimage changes this must change too */

	md->bdata = (uchar*)md->base+sizeof(Memdata*)+sizeof(ulong);

}

Memimage*

allocmemimaged(Rectangle r, ulong chan, Memdata *md)

{

	int d;

	ulong l;

	Memimage *i;

	if(Dx(r) <= 0 || Dy(r) <= 0){

		werrstr("bad rectangle %R", r);

		return nil;

	}

	if((d = chantodepth(chan)) == 0) {

		werrstr("bad channel descriptor %.8lux", chan);

		return nil;

	}

	l = wordsperline(r, d);

	i = mallocz(sizeof(Memimage), 1);

	if(i == nil)

		return nil;

	i->data = md;

	i->zero = sizeof(ulong)*l*r.min.y;

	if(r.min.x >= 0)

		i->zero += (r.min.x*d)/8;

	else

		i->zero -= (-r.min.x*d+7)/8;

	i->zero = -i->zero;

	i->width = l;

	i->r = r;

	i->clipr = r;

	i->flags = 0;

	i->layer = nil;

	i->cmap = memdefcmap;

	if(memsetchan(i, chan) < 0){

		free(i);

		return nil;

	}

	return i;

}

Memimage*

allocmemimage(Rectangle r, ulong chan)

{

	int d;

	uchar *p;

	ulong l, nw;

	Memdata *md;

	Memimage *i;

	if((d = chantodepth(chan)) == 0) {

		werrstr("bad channel descriptor %.8lux", chan);

		return nil;

	}

	l = wordsperline(r, d);

	nw = l*Dy(r);

	md = malloc(sizeof(Memdata));

	if(md == nil)

		return nil;

	md->ref = 1;

	md->base = poolalloc(imagmem, sizeof(Memdata*)+(1+nw)*sizeof(ulong));

	if(md->base == nil){

		free(md);

		return nil;

	}

	p = (uchar*)md->base;

	*(Memdata**)p = md;

	p += sizeof(Memdata*);

	*(ulong*)p = getcallerpc(&r);

	p += sizeof(ulong);

	/* if this changes, memimagemove must change too */

	md->bdata = p;

	md->allocd = 1;

	i = allocmemimaged(r, chan, md);

	if(i == nil){

		poolfree(imagmem, md->base);

		free(md);

		return nil;

	}

	md->imref = i;

	return i;

}

void

freememimage(Memimage *i)

{

	if(i == nil)

		return;

	if(i->data->ref-- == 1 && i->data->allocd){

		if(i->data->base)

			poolfree(imagmem, i->data->base);

		free(i->data);

	}

	free(i);

}

/*

 * Wordaddr is deprecated.

 */

ulong*

wordaddr(Memimage *i, Point p)

{

	return (ulong*) ((uintptr)byteaddr(i, p) & ~(sizeof(ulong)-1));

}

uchar*

byteaddr(Memimage *i, Point p)

{

	uchar *a;

	a = i->data->bdata+i->zero+sizeof(ulong)*p.y*i->width;

	if(i->depth < 8){

		/*

		 * We need to always round down,

		 * but C rounds toward zero.

		 */

		int np;

		np = 8/i->depth;

		if(p.x < 0)

			return a+(p.x-np+1)/np;

		else

			return a+p.x/np;

	}

	else

		return a+p.x*(i->depth/8);

}

int

memsetchan(Memimage *i, ulong chan)

{

	int d;

	int t, j, k;

	ulong cc;

	int bytes;

	if((d = chantodepth(chan)) == 0) {

		werrstr("bad channel descriptor");

		return -1;

	}

	i->depth = d;

	i->chan = chan;

	i->flags &= ~(Fgrey|Falpha|Fcmap|Fbytes);

	bytes = 1;

	for(cc=chan, j=0, k=0; cc; j+=NBITS(cc), cc>>=8, k++){

		t=TYPE(cc);

		if(t < 0 || t >= NChan){

			werrstr("bad channel string");

			return -1;

		}

		if(t == CGrey)

			i->flags |= Fgrey;

		if(t == CAlpha)

			i->flags |= Falpha;

		if(t == CMap && i->cmap == nil){

			i->cmap = memdefcmap;

			i->flags |= Fcmap;

		}

		i->shift[t] = j;

		i->mask[t] = (1<<NBITS(cc))-1;

		i->nbits[t] = NBITS(cc);

		if(NBITS(cc) != 8)

			bytes = 0;

	}

	i->nchan = k;

	if(bytes)

		i->flags |= Fbytes;

	return 0;

}