20060303a

1 files changed, 442 insertions, 0 deletions

diff --git a/appl/lib/readgif.b b/appl/lib/readgif.b
new file mode 100644
index 00000000..3c3bb486
--- /dev/null
+++ b/appl/lib/readgif.b
@@ -0,0 +1,442 @@
+implement RImagefile;
+
+include "sys.m";
+	sys: Sys;
+
+include "draw.m";
+
+include "bufio.m";
+	bufio: Bufio;
+	Iobuf: import bufio;
+
+include "imagefile.m";
+
+Header: adt
+{
+	fd: ref Iobuf;
+	buf: array of byte;
+	vers: string;
+	screenw: int;
+	screenh: int;
+	fields: int;
+	bgrnd: int;
+	aspect: int;
+	transp: int;
+	trindex: byte;
+};
+
+Entry: adt
+{
+	prefix: int;
+	exten: int;
+};
+
+tbl: array of Entry;
+
+init(iomod: Bufio)
+{
+	if(sys == nil)
+		sys = load Sys Sys->PATH;
+	bufio = iomod;
+}
+read(fd: ref Iobuf): (ref Rawimage, string)
+{
+	(a, err) := readarray(fd, 0);
+	if(a != nil)
+		return (a[0], err);
+	return (nil, err);
+}
+
+readmulti(fd: ref Iobuf): (array of ref Rawimage, string)
+{
+	return readarray(fd, 1);
+}
+
+readarray(fd: ref Iobuf, multi: int): (array of ref Rawimage, string)
+{
+	inittbl();
+
+	buf := array[3*256] of byte;
+
+	(header, err) := readheader(fd, buf);
+	if(header == nil)
+		return (nil, err);
+
+	globalcmap: array of byte;
+	if(header.fields & 16r80){
+		(globalcmap, err) = readcmap(header, (header.fields&7)+1);
+		if(globalcmap == nil)
+			return (nil, err);
+	}
+
+	images: array of ref Rawimage;
+	new: ref Rawimage;
+
+    Loop:
+	for(;;){
+		case c := fd.getb(){
+		Bufio->EOF =>
+			if(err == "")
+				err = "ReadGIF: premature EOF";
+			break Loop;
+		Bufio->ERROR =>
+			err = sys->sprint("ReadGIF: read error: %r");
+			return (nil, err);
+		16r21 =>	# Extension (ignored)
+			err = skipextension(header);
+			if(err != nil)
+				return (nil, err);
+
+		16r2C =>	# Image Descriptor
+			if(!multi && images!=nil)	# why read the rest?
+				break Loop;
+			(new, err) = readimage(header);
+			if(new == nil)
+				return (nil ,err);
+			if(new.fields & 16r80){
+				(new.cmap, err) = readcmap(header, (new.fields&7)+1);
+				if(new.cmap == nil)
+					return (nil, err);
+			}else
+				new.cmap = globalcmap;
+			(new.chans[0], err) = decode(header, new);
+			if(new.chans[0] == nil)
+				return (nil, err);
+			if(new.fields & 16r40)
+				interlace(new);
+			new.transp = header.transp;
+			new.trindex = header.trindex;
+			nimages := array[len images+1] of ref Rawimage;
+			nimages[0:] = images[0:];
+			nimages[len images] = new;
+			images = nimages;
+
+		16r3B =>	# Trailer
+			break Loop;
+
+		* =>
+			err = sys->sprint("ReadGIF: unknown block type: %x", c);
+			break Loop;
+		}
+	}
+
+	if(images==nil || images[0].chans[0] == nil){
+		if(err == nil)
+			err = "ReadGIF: no picture in file";
+		return (nil, err);
+	}
+
+	return (images, err);
+}
+
+readheader(fd: ref Iobuf, buf: array of byte): (ref Header, string)
+{
+	if(fd.read(buf, 13) != 13){
+		err := sys->sprint("ReadGIF: can't read header: %r");
+		return (nil, err);
+	}
+	h := ref Header;
+	h.vers = string buf[0:6];
+	if(h.vers!="GIF87a" && h.vers!="GIF89a"){
+		err := sys->sprint("ReadGIF: can't recognize format %s", h.vers);
+		return (nil, err);
+	}
+	h.screenw = int buf[6]+(int buf[7]<<8);
+	h.screenh = int buf[8]+(int buf[9]<<8);
+	h.fields = int buf[10];
+	h.bgrnd = int buf[11];
+	h.aspect = int buf[12];
+	h.fd = fd;
+	h.buf = buf;
+	h.transp = 0;
+	return (h, "");
+}
+
+readcmap(h: ref Header, size: int): (array of byte,string)
+{
+	size = 3*(1<<size);
+	map := array[size] of byte;
+	if(h.fd.read(map, size) != size)
+		return (nil, "ReadGIF: short read on color map");
+	return (map, "");
+}
+
+readimage(h: ref Header): (ref Rawimage, string)
+{
+	if(h.fd.read(h.buf, 9) != 9){
+		err := sys->sprint("ReadGIF: can't read image descriptor: %r");
+		return (nil, err);
+	}
+	i := ref Rawimage;
+	left := int h.buf[0]+(int h.buf[1]<<8);
+	top := int h.buf[2]+(int h.buf[3]<<8);
+	width := int h.buf[4]+(int h.buf[5]<<8);
+	height := int h.buf[6]+(int h.buf[7]<<8);
+	i.fields = int h.buf[8];
+	i.r.min.x = left;
+	i.r.min.y = top;
+	i.r.max.x = left+width;
+	i.r.max.y = top+height;
+	i.nchans = 1;
+	i.chans = array[1] of array of byte;
+	i.chandesc = CRGB1;
+	return (i, "");
+}
+
+readdata(h: ref Header, ch: chan of (array of byte, string))
+{
+	err: string;
+
+	# send nil for error, buffer of length 0 for EOF
+	for(;;){
+		nbytes := h.fd.getb();
+		if(nbytes < 0){
+			err = sys->sprint("ReadGIF: can't read data: %r");
+			ch <-= (nil, err);
+			return;
+		}
+		d := array[nbytes] of byte;
+		if(nbytes == 0){
+			ch <-= (d, "");
+			return;
+		}
+		n := h.fd.read(d, nbytes);
+		if(n != nbytes){
+			if(n > 0){
+				ch <-= (d[0:n], nil);
+				ch <-= (d[0:0], "ReadGIF: short data subblock");
+			}else
+				ch <-= (nil, sys->sprint("ReadGIF: can't read data: %r"));
+			return;
+		}
+		ch <-= (d, "");
+	}
+}
+
+readerr: con "ReadGIF: can't read extension: %r";
+
+skipextension(h: ref Header): string
+{
+	fmterr: con "ReadGIF: bad extension format";
+
+	hsize := 0;
+	hasdata := 0;
+
+	case XX := h.fd.getb(){
+	Bufio->ERROR or Bufio->EOF =>
+		return sys->sprint(readerr);
+	16r01 =>	# Plain Text Extension
+		hsize = 13;
+		hasdata = 1;
+	16rF9 =>	# Graphic Control Extension
+		return graphiccontrol(h);
+	16rFE =>	# Comment Extension
+		hasdata = 1;
+	16rFF =>	# Application Extension
+		hsize = h.fd.getb();
+		# standard says this must be 11, but Adobe likes to put out 10-byte ones,
+		# so we pay attention to the field.
+		hasdata = 1;
+	* =>
+		return "ReadGIF: unknown extension";
+	}
+	if(hsize>0 && h.fd.read(h.buf, hsize) != hsize)
+		return sys->sprint(readerr);
+	if(!hasdata){
+		if(int h.buf[hsize-1] != 0)
+			return fmterr;
+	}else{
+		ch := chan of (array of byte, string);
+		spawn readdata(h, ch);
+		for(;;){
+			(data, err) := <-ch;
+			if(data == nil)
+				return err;
+			if(len data == 0)
+				break;
+		}
+	}
+	return "";
+}
+
+graphiccontrol(h: ref Header): string
+{
+	if(h.fd.read(h.buf, 5+1) != 5+1)
+		return sys->sprint(readerr);
+	if(int h.buf[1] & 1){
+		h.transp = 1;
+		h.trindex = h.buf[4];
+	}
+	return "";
+}
+
+inittbl()
+{
+	tbl = array[4096] of Entry;
+	for(i:=0; i<258; i++) {
+		tbl[i].prefix = -1;
+		tbl[i].exten = i;
+	}
+}
+
+decode(h: ref Header, i: ref Rawimage): (array of byte, string)
+{
+	c, incode: int;
+
+	err := "";
+	if(h.fd.read(h.buf, 1) != 1){
+		err = sys->sprint("ReadGIF: can't read data: %r");
+		return (nil, err);
+	}
+	codesize := int h.buf[0];
+	if(codesize>8 || 0>codesize){
+		err = sys->sprint("ReadGIF: can't handle codesize %d", codesize);
+		return (nil, err);
+	}
+	err1 := "";
+	if(i.cmap!=nil && len i.cmap!=3*(1<<codesize)
+	  && (codesize!=2 || len i.cmap!=3*2)) # peculiar GIF bitmap files...
+		err1 = sys->sprint("ReadGIF: codesize %d doesn't match color map 3*%d", codesize, len i.cmap/3);
+
+	ch := chan of (array of byte, string);
+
+	spawn readdata(h, ch);
+
+	CTM :=1<<codesize;
+	EOD := CTM+1;
+
+	pic := array[(i.r.max.x-i.r.min.x)*(i.r.max.y-i.r.min.y)] of byte;
+	pici := 0;
+	data := array[0] of byte;
+	datai := 0;
+
+	nbits := 0;
+	sreg := 0;
+	stack := array[4096] of byte;
+	stacki: int;
+	fc := 0;
+
+Init:
+	for(;;){
+		csize := codesize+1;
+		nentry := EOD+1;
+		maxentry := (1<<csize)-1;
+		first := 1;
+		ocode := -1;
+
+		for(;; ocode = incode) {
+			while(nbits < csize) {
+				if(datai == len data){
+					(data, err) = <-ch;
+					if(data == nil)
+						return (nil, err);
+					if(err!="" && err1=="")
+						err1 = err;
+					if(len data == 0)
+						break Init;
+					datai = 0;
+				}
+				c = int data[datai++];
+				sreg |= c<<nbits;
+				nbits += 8;
+			}
+			code := sreg & ((1<<csize) - 1);
+			sreg >>= csize;
+			nbits -= csize;
+
+			if(code == EOD){
+				(data, err) = <-ch;
+				if(len data != 0)
+					err = "ReadGIF: unexpected data past EOD";
+				if(err!="" && err1=="")
+					err1 = err;
+				break Init;
+			}
+
+			if(code == CTM)
+				continue Init;
+
+			stacki = len stack-1;
+
+			incode = code;
+
+			# special case for KwKwK 
+			if(code == nentry) {
+				stack[stacki--] = byte fc;
+				code = ocode;
+			}
+
+			if(code > nentry) {
+				err = sys->sprint("ReadGIF: bad code %x %x", code, nentry);
+				return (nil, err);
+			}
+		
+			for(c=code; c>=0; c=tbl[c].prefix)
+				stack[stacki--] = byte tbl[c].exten;
+
+			nb := len stack-(stacki+1);
+			if(pici+nb > len pic){
+				if(err1 == "")
+					err1 = "ReadGIF: data overflows picture";
+			}else{
+				pic[pici:] = stack[stacki+1:];
+				pici += nb;
+			}
+
+			fc = int stack[stacki+1];
+
+			if(first){
+				first = 0;
+				continue;
+			}
+			early:=0; # peculiar tiff feature here for reference
+			if(nentry == maxentry-early) {
+				if(csize >= 12)
+					continue;
+				csize++;
+				maxentry = (1<<csize);
+				if(csize < 12)
+					maxentry--;
+			}
+			tbl[nentry].prefix = ocode;
+			tbl[nentry].exten = fc;
+			nentry++;
+		}
+	}
+	return (pic, err1);
+}
+
+interlace(image: ref Rawimage)
+{
+	pic := image.chans[0];
+	r := image.r;
+	dx := r.max.x-r.min.x;
+	ipic := array[dx*(r.max.y-r.min.y)] of byte;
+
+	# Group 1: every 8th row, starting with row 0
+	yy := 0;
+	for(y:=r.min.y; y<r.max.y; y+=8){
+		ipic[y*dx:] = pic[yy*dx:(yy+1)*dx];
+		yy++;
+	}
+
+	# Group 2: every 8th row, starting with row 4
+	for(y=r.min.y+4; y<r.max.y; y+=8){
+		ipic[y*dx:] = pic[yy*dx:(yy+1)*dx];
+		yy++;
+	}
+
+	# Group 3: every 4th row, starting with row 2
+	for(y=r.min.y+2; y<r.max.y; y+=4){
+		ipic[y*dx:] = pic[yy*dx:(yy+1)*dx];
+		yy++;
+	}
+
+	# Group 4: every 2nd row, starting with row 1
+	for(y=r.min.y+1; y<r.max.y; y+=2){
+		ipic[y*dx:] = pic[yy*dx:(yy+1)*dx];
+		yy++;
+	}
+
+	image.chans[0] = ipic;
+}