#include <u.h>
#include <libc.h>
#include <bio.h>
#include <draw.h>
#include "imagefile.h"
#include "bmp.h"

/*
MS-BMP file reader
(c) 2003, I.P.Keller

aims to decode *all* valid bitmap formats, although some of the
flavours couldn't be verified due to lack of suitable test-files.
the following flavours are supported:

       Bit/Pix Orientation     Compression     Tested?
         1     top->bottom     n/a             yes
         1     bottom->top     n/a             yes
         4     top->bottom     no              yes
         4     bottom->top     no              yes
         4     top->bottom     RLE4            yes, but not with displacement
         8     top->bottom     no              yes
         8     bottom->top     no              yes
         8     top->bottom     RLE8            yes, but not with displacement
        16     top->bottom     no              no
        16     bottom->top     no              no
        16     top->bottom     BITMASK         no
        16     bottom->top     BITMASK         no
        24     top->bottom     n/a             yes
        24     bottom->top     n/a             yes
        32     top->bottom     no              no
        32     bottom->top     no              no
        32     top->bottom     BITMASK         no
        32     bottom->top     BITMASK         no

OS/2 1.x bmp files are recognised as well, but testing was very limited.

verifying was done with a number of test files, generated by
different tools. nevertheless, the tests were in no way exhaustive
enough to guarantee bug-free decoding. caveat emptor!
*/

static short
r16(Biobuf*b)
{
       short s;

       s = Bgetc(b);
       s |= ((short)Bgetc(b)) << 8;
       return s;
}


static long
r32(Biobuf*b)
{
       long l;

       l = Bgetc(b);
       l |= ((long)Bgetc(b)) << 8;
       l |= ((long)Bgetc(b)) << 16;
       l |= ((long)Bgetc(b)) << 24;
       return l;
}


/* get highest bit set */
static int
msb(ulong x)
{
       int i;
       for(i = 32; i; i--, x <<= 1)
               if(x & 0x80000000L)
                       return i;
       return 0;
}

/* Load a 1-Bit encoded BMP file (uncompressed) */
static int
load_1T(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       long ix, iy, i = 0, step_up = 0, padded_width = ((width + 31) / 32) * 32;
       int val = 0, n;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       for(iy = height; iy; iy--, i += step_up)
               for(ix = 0, n = 0; ix < padded_width; ix++, n--) {
                       if(!n) {
                               val = Bgetc(b);
                               n = 8;
                       }
                       if(ix < width) {
                               buf[i] = clut[val & 0x80 ? 1 : 0];
                               i++;
                       }
                       val <<= 1;
               }
       return 0;
}

/* Load a 4-Bit encoded BMP file (uncompressed) */
static int
load_4T(Biobuf* b, long width, long height, Rgb* buf, Rgb* clut)
{
       long ix, iy, i = 0, step_up = 0, skip = (4 - (((width % 8) + 1) / 2)) & 3;
       uint valH, valL;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       for(iy = height; iy; iy--, i += step_up) {
               for(ix = 0; ix < width; ) {
                       valH = valL = Bgetc(b) & 0xff;
                       valH >>= 4;

                       buf[i] = clut[valH];
                       i++; ix++;

                       if(ix < width) {
                               valL &= 0xf;
                               buf[i] = clut[valL];
                               i++; ix++;
                       }
               }
               Bseek(b, skip, 1);
       }
       return 0;
}

/* Load a 4-Bit encoded BMP file (RLE4-compressed) */
static int
load_4C(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       long ix, iy = height -1;
       uint val, valS, skip;
       Rgb* p;

       while(iy >= 0) {
               ix = 0;
               while(ix < width) {
                       val = (uint)Bgetc(b);

                       if(0 != val) {
                               valS = (uint)Bgetc(b);
                               p = &buf[ix + iy * width];
                               while(val--) {
                                       *p = clut[0xf & (valS >> 4)];
                                       p++;
                                       ix++;
                                       if(val != 0) {
                                               *p = clut[0xf & valS];
                                               p++;
                                               ix++;
                                               val--;
                                       }
                               }
                       } else {
                               /* Special modes... */
                               val = Bgetc(b);
                               switch(val) {
                                       case 0: /* End-Of-Line detected */
                                               ix = width;
                                               iy--;
                                               break;
                                       case 1: /* End-Of-Picture detected -->> abort */
                                               ix = width;
                                               iy = -1;
                                               break;
                                       case 2: /* Position change detected */
                                               val = (uint)Bgetc(b);
                                               ix += val;
                                               val = (uint)Bgetc(b);
                                               iy -= val;
                                               break;

                                       default:/* Transparent data sequence detected */
                                               p = &buf[ix + iy * width];
                                               if((1 == (val & 3)) || (2 == (val & 3)))
                                                       skip = 1;
                                               else
                                                       skip = 0;

                                               while(val--) {
                                                       valS = (uint)Bgetc(b);
                                                       *p = clut[0xf & (valS >> 4)];
                                                       p++;
                                                       ix++;
                                                       if(val != 0) {
                                                               *p = clut[0xf & valS];
                                                               p++;
                                                               ix++;
                                                               val--;
                                                       }
                                               }
                                               if(skip)
                                                       Bgetc(b);
                                               break;
                               }
                       }
               }
       }
       return 0;
}

/* Load a 8-Bit encoded BMP file (uncompressed) */
static int
load_8T(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       long ix, iy, i = 0, step_up = 0, skip = (4 - (width % 4)) & 3;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       for(iy = height; iy; iy--, i += step_up) {
               for(ix = 0; ix < width; ix++, i++)
                       buf[i] = clut[Bgetc(b) & 0xff];
               Bseek(b, skip, 1);
       }
       return 0;
}

/* Load a 8-Bit encoded BMP file (RLE8-compressed) */
static int
load_8C(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       long ix, iy = height -1;
       int val, valS, skip;
       Rgb* p;

       while(iy >= 0) {
               ix = 0;
               while(ix < width) {
                       val = Bgetc(b);

                       if(0 != val) {
                               valS = Bgetc(b);
                               p = &buf[ix + iy * width];
                               while(val--) {
                                       *p = clut[valS];
                                       p++;
                                       ix++;
                               }
                       } else {
                               /* Special modes... */
                               val = Bgetc(b);
                               switch(val) {
                                       case 0: /* End-Of-Line detected */
                                               ix = width;
                                               iy--;
                                               break;
                                       case 1: /* End-Of-Picture detected */
                                               ix = width;
                                               iy = -1;
                                               break;
                                       case 2: /* Position change detected */
                                               val = Bgetc(b);
                                               ix += val;
                                               val = Bgetc(b);
                                               iy -= val;
                                               break;
                                       default: /* Transparent (not compressed) sequence detected */
                                               p = &buf[ix + iy * width];
                                               if(val & 1)
                                                       skip = 1;
                                               else
                                                       skip = 0;

                                               while(val--) {
                                                       valS = Bgetc(b);
                                                       *p = clut[valS];
                                                       p++;
                                                       ix++;
                                               }
                                               if(skip)
                                                       /* Align data stream */
                                                       Bgetc(b);
                                               break;
                               }
                       }
               }
       }
       return 0;
}

/* Load a 16-Bit encoded BMP file (uncompressed) */
static int
load_16(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       uchar c[2];
       long ix, iy, i = 0, step_up = 0;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       if(clut) {
               unsigned mask_blue =  (unsigned)clut[0].blue +
                                    ((unsigned)clut[0].green << 8);
               unsigned mask_green =  (unsigned)clut[1].blue +
                                     ((unsigned)clut[1].green << 8);
               unsigned mask_red =  (unsigned)clut[2].blue +
                                   ((unsigned)clut[2].green << 8);
               int shft_blue = msb((ulong)mask_blue) - 8;
               int shft_green = msb((ulong)mask_green) - 8;
               int shft_red = msb((ulong)mask_red) - 8;

               for(iy = height; iy; iy--, i += step_up)
                       for(ix = 0; ix < width; ix++, i++) {
                               unsigned val;
                               Bread(b, c, sizeof(c));
                               val = (unsigned)c[0] + ((unsigned)c[1] << 8);

                               buf[i].alpha = 0;
                               if(shft_blue >= 0)
                                       buf[i].blue = (uchar)((val & mask_blue) >> shft_blue);
                               else
                                       buf[i].blue = (uchar)((val & mask_blue) << -shft_blue);
                               if(shft_green >= 0)
                                       buf[i].green = (uchar)((val & mask_green) >> shft_green);
                               else
                                       buf[i].green = (uchar)((val & mask_green) << -shft_green);
                               if(shft_red >= 0)
                                       buf[i].red = (uchar)((val & mask_red) >> shft_red);
                               else
                                       buf[i].red = (uchar)((val & mask_red) << -shft_red);
                       }
       } else
               for(iy = height; iy; iy--, i += step_up)
                       for(ix = 0; ix < width; ix++, i++) {
                               Bread(b, c, sizeof(c));
                               buf[i].blue = (uchar)((c[0] << 3) & 0xf8);
                               buf[i].green = (uchar)(((((unsigned)c[1] << 6) +
                                                       (((unsigned)c[0]) >> 2))) & 0xf8);
                               buf[i].red = (uchar)((c[1] << 1) & 0xf8);
                       }
       return 0;
}

/* Load a 24-Bit encoded BMP file (uncompressed) */
static int
load_24T(Biobuf* b, long width, long height, Rgb* buf)
{
       long ix, iy, i = 0, step_up = 0, skip = (4 - ((width * 3) % 4)) & 3;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       for(iy = height; iy; iy--, i += step_up) {
               for(ix = 0; ix < width; ix++, i++) {
                       buf[i].alpha = 0;
                       buf[i].blue = Bgetc(b);
                       buf[i].green = Bgetc(b);
                       buf[i].red = Bgetc(b);
               }
               Bseek(b, skip, 1);
       }
       return 0;
}

/* Load a 32-Bit encoded BMP file (uncompressed) */
static int
load_32(Biobuf *b, long width, long height, Rgb* buf, Rgb* clut)
{
       uchar c[4];
       long ix, iy, i = 0, step_up = 0;

       if(height > 0) {        /* bottom-up */
               i = (height - 1) * width;
               step_up = -2 * width;
       } else
               height = -height;

       if(clut) {
               ulong mask_blue =  (ulong)clut[0].blue +
                                         ((ulong)clut[0].green << 8) +
                                         ((ulong)clut[0].red << 16) +
                                         ((ulong)clut[0].alpha << 24);
               ulong mask_green =  (ulong)clut[1].blue +
                                          ((ulong)clut[1].green << 8) +
                                          ((ulong)clut[1].red << 16) +
                                          ((ulong)clut[1].alpha << 24);
               ulong mask_red =  (ulong)clut[2].blue +
                                        ((ulong)clut[2].green << 8) +
                                        ((ulong)clut[2].red << 16) +
                                        ((ulong)clut[2].alpha << 24);
               int shft_blue = msb(mask_blue) - 8;
               int shft_green = msb(mask_green) - 8;
               int shft_red = msb(mask_red) - 8;

               for(iy = height; iy; iy--, i += step_up)
                       for(ix = 0; ix < width; ix++, i++) {
                               ulong val;
                               Bread(b, c, sizeof(c));
                               val =  (ulong)c[0] + ((ulong)c[1] << 8) +
                                     ((ulong)c[2] << 16) + ((ulong)c[1] << 24);

                               buf[i].alpha = 0;
                               if(shft_blue >= 0)
                                       buf[i].blue = (uchar)((val & mask_blue) >> shft_blue);
                               else
                                       buf[i].blue = (uchar)((val & mask_blue) << -shft_blue);
                               if(shft_green >= 0)
                                       buf[i].green = (uchar)((val & mask_green) >> shft_green);
                               else
                                       buf[i].green = (uchar)((val & mask_green) << -shft_green);
                               if(shft_red >= 0)
                                       buf[i].red = (uchar)((val & mask_red) >> shft_red);
                               else
                                       buf[i].red = (uchar)((val & mask_red) << -shft_red);
                       }
       } else
               for(iy = height; iy; iy--, i += step_up)
                       for(ix = 0; ix < width; ix++, i++) {
                               Bread(b, c, nelem(c));
                               buf[i].blue = c[0];
                               buf[i].green = c[1];
                               buf[i].red = c[2];
                       }
       return 0;
}


static Rgb*
ReadBMP(Biobuf *b, int *width, int *height)
{
       int colours, num_coltab = 0;
       Filehdr bmfh;
       Infohdr bmih;
       Rgb clut[256];
       Rgb* buf;

       bmfh.type = r16(b);
       if(bmfh.type != 0x4d42)         /* signature must be 'BM' */
               sysfatal("bad magic number, not a BMP file");

       bmfh.size = r32(b);
       bmfh.reserved1 = r16(b);
       bmfh.reserved2 = r16(b);
       bmfh.offbits = r32(b);

       memset(&bmih, 0, sizeof(bmih));
       bmih.size = r32(b);

       if(bmih.size == 0x0c) {                 /* OS/2 1.x version */
               bmih.width = r16(b);
               bmih.height = r16(b);
               bmih.planes = r16(b);
               bmih.bpp = r16(b);
               bmih.compression = BMP_RGB;
       } else {                                /* Windows */
               bmih.width = r32(b);
               bmih.height = r32(b);
               bmih.planes = r16(b);
               bmih.bpp = r16(b);
               bmih.compression = r32(b);
               bmih.imagesize = r32(b);
               bmih.hres = r32(b);
               bmih.vres = r32(b);
               bmih.colours = r32(b);
               bmih.impcolours = r32(b);
       }

       if(bmih.bpp < 16) {
               /* load colour table */
               if(bmih.impcolours)
                       num_coltab = (int)bmih.impcolours;
               else
                       num_coltab = 1 << bmih.bpp;
       } else if(bmih.compression == BMP_BITFIELDS &&
                 (bmih.bpp == 16 || bmih.bpp == 32))
               /* load bitmasks */
               num_coltab = 3;

       if(num_coltab) {
               int i;
               Bseek(b, bmih.size + Filehdrsz, 0);

               for(i = 0; i < num_coltab; i++) {
                       clut[i].blue  = (uchar)Bgetc(b);
                       clut[i].green = (uchar)Bgetc(b);
                       clut[i].red   = (uchar)Bgetc(b);
                       clut[i].alpha = (uchar)Bgetc(b);
               }
       }

       *width = bmih.width;
       *height = bmih.height;
       colours = bmih.bpp;

       Bseek(b, bmfh.offbits, 0);

       if ((buf = calloc(sizeof(Rgb), *width * abs(*height))) == nil)
               sysfatal("no memory");

       switch(colours) {
               case 1:
                       load_1T(b, *width, *height, buf, clut);
                       break;
               case 4:
                       if(bmih.compression == BMP_RLE4)
                               load_4C(b, *width, *height, buf, clut);
                       else
                               load_4T(b, *width, *height, buf, clut);
                       break;
               case 8:
                       if(bmih.compression == BMP_RLE8)
                               load_8C(b, *width, *height, buf, clut);
                       else
                               load_8T(b, *width, *height, buf, clut);
                       break;
               case 16:
                       load_16(b, *width, *height, buf,
                               bmih.compression == BMP_BITFIELDS ? clut : nil);
                       break;
               case 24:
                       load_24T(b, *width, *height, buf);
                       break;
               case 32:
                       load_32(b, *width, *height, buf,
                               bmih.compression == BMP_BITFIELDS ? clut : nil);
                       break;
       }
       return buf;
}

Rawimage**
Breadbmp(Biobuf *bp, int colourspace)
{
       Rawimage *a, **array;
       int c, width, height;
       uchar *r, *g, *b;
       Rgb *s, *e;
       Rgb *bmp;
       char ebuf[128];

       a = nil;
       bmp = nil;
       array = nil;
       USED(a);
       USED(bmp);
       if (colourspace != CRGB) {
               errstr(ebuf, sizeof ebuf);      /* throw it away */
               werrstr("ReadRGB: unknown colour space %d", colourspace);
               return nil;
       }

       if ((bmp = ReadBMP(bp, &width, &height)) == nil)
               return nil;

       if ((a = calloc(sizeof(Rawimage), 1)) == nil)
               goto Error;

       for (c = 0; c  < 3; c++)
               if ((a->chans[c] = calloc(width, height)) == nil)
                       goto Error;

       if ((array = calloc(sizeof(Rawimage *), 2)) == nil)
               goto Error;
       array[0] = a;
       array[1] = nil;

       a->nchans = 3;
       a->chandesc = CRGB;
       a->chanlen = width * height;
       a->r = Rect(0, 0, width, height);

       s = bmp;
       e = s + width * height;
       r = a->chans[0];
       g = a->chans[1];
       b = a->chans[2];

       do {
               *r++ = s->red;
               *g++ = s->green;
               *b++ = s->blue;
       }while(++s < e);

       free(bmp);
       return array;

Error:
       if (a)
               for (c = 0; c < 3; c++)
                       if (a->chans[c])
                               free(a->chans[c]);
       if (a)
               free(a);
       if (array)
               free(array);
       if (bmp)
               free(bmp);
       return nil;

}

Rawimage**
readbmp(int fd, int colorspace)
{
       Rawimage * *a;
       Biobuf b;

       if (Binit(&b, fd, OREAD) < 0)
               return nil;
       a = Breadbmp(&b, colorspace);
       Bterm(&b);
       return a;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.