Subversion Repositories planix.SVN

#include        <u.h>
#include        <libc.h>
#include        <bio.h>
#include        "sky.h"

static  void    dodecode(Biobuf*, Pix*, int, int, uchar*);
static  long    getlong(uchar*);
int     debug;

Img*
dssread(char *file)
{
        int nx, ny, scale, sumall;
        Pix  *p, *pend;
        uchar buf[21];
        Biobuf *bp;
        Img *ip;

        if(debug)
                Bprint(&bout, "reading %s\n", file);
        bp = Bopen(file, OREAD);
        if(bp == 0)
                return 0;
        if(Bread(bp, buf, sizeof(buf)) != sizeof(buf) ||
           buf[0] != 0xdd || buf[1] != 0x99){
                werrstr("bad format");
                return 0;
        }
        nx = getlong(buf+2);
        ny = getlong(buf+6);
        scale = getlong(buf+10);
        sumall = getlong(buf+14);
        if(debug)
                fprint(2, "%s: nx=%d, ny=%d, scale=%d, sumall=%d, nbitplanes=%d,%d,%d\n",
                        file, nx, ny, scale, sumall, buf[18], buf[19], buf[20]);
        ip = malloc(sizeof(Img) + (nx*ny-1)*sizeof(int));
        if(ip == 0){
                Bterm(bp);
                werrstr("no memory");
                return 0;
        }
        ip->nx = nx;
        ip->ny = ny;
        dodecode(bp, ip->a, nx, ny, buf+18);
        ip->a[0] = sumall;      /* sum of all pixels */
        Bterm(bp);
        if(scale > 1){
                p = ip->a;
                pend = &ip->a[nx*ny];
                while(p < pend)
                        *p++ *= scale;
        }
        hinv(ip->a, nx, ny);
        return ip;
}

static
void
dodecode(Biobuf *infile, Pix  *a, int nx, int ny, uchar *nbitplanes)
{
        int nel, nx2, ny2, bits, mask;
        Pix *aend, px;

        nel = nx*ny;
        nx2 = (nx+1)/2;
        ny2 = (ny+1)/2;
        memset(a, 0, nel*sizeof(*a));

        /*
         * Initialize bit input
         */
        start_inputing_bits();

        /*
         * read bit planes for each quadrant
         */
        qtree_decode(infile, &a[0],          ny, nx2,  ny2,  nbitplanes[0]);
        qtree_decode(infile, &a[ny2],        ny, nx2,  ny/2, nbitplanes[1]);
        qtree_decode(infile, &a[ny*nx2],     ny, nx/2, ny2,  nbitplanes[1]);
        qtree_decode(infile, &a[ny*nx2+ny2], ny, nx/2, ny/2, nbitplanes[2]);

        /*
         * make sure there is an EOF symbol (nybble=0) at end
         */
        if(input_nybble(infile) != 0){
                fprint(2, "dodecode: bad bit plane values\n");
                exits("format");
        }

        /*
         * get the sign bits
         */
        aend = &a[nel];
        mask = 0;
        bits = 0;;
        for(; a<aend; a++) {
                if(px = *a) {
                        if(mask == 0) {
                                mask = 0x80;
                                bits = Bgetc(infile);
                        }
                        if(mask & bits)
                                *a = -px;
                        mask >>= 1;
                }
        }
}

static
long    getlong(uchar *p)
{
        return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
}