718 lines
20 KiB
C++
718 lines
20 KiB
C++
/**
|
|
@file GImage_bmp.cpp
|
|
@author Morgan McGuire, http://graphics.cs.williams.edu
|
|
@created 2002-05-27
|
|
@edited 2006-05-10
|
|
*/
|
|
#include "G3D/platform.h"
|
|
#include "G3D/GImage.h"
|
|
#include "G3D/BinaryInput.h"
|
|
#include "G3D/BinaryOutput.h"
|
|
#include "G3D/Log.h"
|
|
|
|
namespace G3D {
|
|
|
|
#ifndef G3D_WIN32
|
|
/**
|
|
This is used by the Windows bitmap I/O.
|
|
*/
|
|
static const int BI_RGB = 0;
|
|
#endif
|
|
|
|
void GImage::encodeBMP(
|
|
BinaryOutput& out) const {
|
|
|
|
debugAssert(m_channels == 1 || m_channels == 3);
|
|
out.setEndian(G3D_LITTLE_ENDIAN);
|
|
|
|
uint8 red;
|
|
uint8 green;
|
|
uint8 blue;
|
|
int pixelBufferSize = m_width * m_height * 3;
|
|
int fileHeaderSize = 14;
|
|
int infoHeaderSize = 40;
|
|
int BMScanWidth;
|
|
int BMPadding;
|
|
|
|
// First write the BITMAPFILEHEADER
|
|
//
|
|
// WORD bfType;
|
|
// DWORD bfSize;
|
|
// WORD bfReserved1;
|
|
// WORD bfReserved2;
|
|
// DWORD bfOffBits;
|
|
|
|
// Type
|
|
out.writeUInt8('B');
|
|
out.writeUInt8('M');
|
|
|
|
// File size
|
|
out.writeUInt32(fileHeaderSize + infoHeaderSize + pixelBufferSize);
|
|
|
|
// Two reserved fields set to zero
|
|
out.writeUInt16(0);
|
|
out.writeUInt16(0);
|
|
|
|
// The offset, in bytes, from the BITMAPFILEHEADER structure
|
|
// to the bitmap bits.
|
|
out.writeUInt32(infoHeaderSize + fileHeaderSize);
|
|
|
|
// Now the BITMAPINFOHEADER
|
|
//
|
|
// DWORD biSize;
|
|
// LONG biWidth;
|
|
// LONG biHeight;
|
|
// WORD biPlanes;
|
|
// WORD biBitCount
|
|
// DWORD biCompression;
|
|
// DWORD biSizeImage;
|
|
// LONG biXPelsPerMeter;
|
|
// LONG biYPelsPerMeter;
|
|
// DWORD biClrUsed;
|
|
// DWORD biClrImportant;
|
|
|
|
// Size of the info header
|
|
out.writeUInt32(infoHeaderSize);
|
|
|
|
// Width and height of the image
|
|
out.writeUInt32(m_width);
|
|
out.writeUInt32(m_height);
|
|
|
|
// Planes ("must be set to 1")
|
|
out.writeUInt16(1);
|
|
|
|
// BitCount and CompressionType
|
|
out.writeUInt16(24);
|
|
out.writeUInt32(BI_RGB);
|
|
|
|
// Image size ("may be zero for BI_RGB bitmaps")
|
|
out.writeUInt32(0);
|
|
|
|
// biXPelsPerMeter
|
|
out.writeUInt32(0);
|
|
// biYPelsPerMeter
|
|
out.writeUInt32(0);
|
|
|
|
// biClrUsed
|
|
out.writeUInt32(0);
|
|
|
|
// biClrImportant
|
|
out.writeUInt32(0);
|
|
|
|
BMScanWidth = m_width * 3;
|
|
|
|
if (BMScanWidth & 3) {
|
|
BMPadding = 4 - (BMScanWidth & 3);
|
|
} else {
|
|
BMPadding = 0;
|
|
}
|
|
|
|
int hStart = m_height - 1;
|
|
int hEnd = -1;
|
|
int hDir = -1;
|
|
int dest;
|
|
|
|
// Write the pixel data
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
dest = m_channels * h * m_width;
|
|
for (int w = 0; w < m_width; ++w) {
|
|
|
|
if (m_channels == 3) {
|
|
red = m_byte[dest];
|
|
green = m_byte[dest + 1];
|
|
blue = m_byte[dest + 2];
|
|
} else {
|
|
red = m_byte[dest];
|
|
green = m_byte[dest];
|
|
blue = m_byte[dest];
|
|
}
|
|
|
|
out.writeUInt8(blue);
|
|
out.writeUInt8(green);
|
|
out.writeUInt8(red);
|
|
|
|
dest += m_channels;
|
|
}
|
|
|
|
if (BMPadding > 0) {
|
|
out.skip(BMPadding);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void GImage::decodeBMP(
|
|
BinaryInput& input) {
|
|
|
|
// The BMP decoding uses these flags.
|
|
static const uint16 PICTURE_NONE = 0x0000;
|
|
static const uint16 PICTURE_BITMAP = 0x1000;
|
|
|
|
// Compression Flags
|
|
static const uint16 PICTURE_UNCOMPRESSED = 0x0100;
|
|
static const uint16 PICTURE_MONOCHROME = 0x0001;
|
|
static const uint16 PICTURE_4BIT = 0x0002;
|
|
static const uint16 PICTURE_8BIT = 0x0004;
|
|
static const uint16 PICTURE_16BIT = 0x0008;
|
|
static const uint16 PICTURE_24BIT = 0x0010;
|
|
static const uint16 PICTURE_32BIT = 0x0020;
|
|
|
|
(void)PICTURE_16BIT;
|
|
(void)PICTURE_32BIT;
|
|
|
|
// This is a simple BMP loader that can handle uncompressed BMP files.
|
|
// Verify this is a BMP file by looking for the BM tag.
|
|
input.reset();
|
|
std::string tag = input.readString(2);
|
|
if (tag != "BM") {
|
|
throw Error("Not a BMP file", input.getFilename());
|
|
}
|
|
|
|
m_channels = 3;
|
|
// Skip to the BITMAPINFOHEADER's width and height
|
|
input.skip(16);
|
|
|
|
m_width = input.readUInt32();
|
|
m_height = input.readUInt32();
|
|
|
|
// Skip to the bit count and compression type
|
|
input.skip(2);
|
|
|
|
uint16 bitCount = input.readUInt16();
|
|
uint32 compressionType = input.readUInt32();
|
|
|
|
uint8 red;
|
|
uint8 green;
|
|
uint8 blue;
|
|
uint8 blank;
|
|
|
|
// Only uncompressed bitmaps are supported by this code
|
|
if ((int32)compressionType != BI_RGB) {
|
|
throw Error("BMP images must be uncompressed", input.getFilename());
|
|
}
|
|
|
|
uint8* palette = NULL;
|
|
|
|
// Create the palette if needed
|
|
if (bitCount <= 8) {
|
|
|
|
// Skip to the palette color count in the header
|
|
input.skip(12);
|
|
|
|
int numColors = input.readUInt32();
|
|
|
|
palette = (uint8*)System::malloc(numColors * 3);
|
|
debugAssert(palette);
|
|
|
|
// Skip past the end of the header to the palette info
|
|
input.skip(4);
|
|
|
|
int c;
|
|
for(c = 0; c < numColors * 3; c += 3) {
|
|
// Palette information in bitmaps is stored in BGR_ format.
|
|
// That means it's blue-green-red-blank, for each entry.
|
|
blue = input.readUInt8();
|
|
green = input.readUInt8();
|
|
red = input.readUInt8();
|
|
blank = input.readUInt8();
|
|
|
|
palette[c] = red;
|
|
palette[c + 1] = green;
|
|
palette[c + 2] = blue;
|
|
}
|
|
}
|
|
|
|
int hStart = 0;
|
|
int hEnd = 0;
|
|
int hDir = 0;
|
|
|
|
if (m_height < 0) {
|
|
m_height = -m_height;
|
|
hStart = 0;
|
|
hEnd = m_height;
|
|
hDir = 1;
|
|
} else {
|
|
//height = height;
|
|
hStart = m_height - 1;
|
|
hEnd = -1;
|
|
hDir = -1;
|
|
}
|
|
|
|
m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3);
|
|
debugAssert(m_byte);
|
|
|
|
int BMScanWidth;
|
|
int BMPadding;
|
|
uint8 BMGroup;
|
|
uint8 BMPixel8;
|
|
int currPixel;
|
|
int dest;
|
|
int flags = PICTURE_NONE;
|
|
|
|
if (bitCount == 1) {
|
|
// Note that this file is not necessarily grayscale, since it's possible
|
|
// the palette is blue-and-white, or whatever. But of course most image
|
|
// programs only write 1-bit images if they're black-and-white.
|
|
flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_MONOCHROME;
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
BMScanWidth = (m_width + 7) >> 3;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
// Powers of 2
|
|
int pow2[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
dest = 3 * h * m_width;
|
|
|
|
for (int w = 0; w < BMScanWidth; ++w) {
|
|
|
|
BMGroup = input.readUInt8();
|
|
|
|
// Now we read the pixels. Usually there are eight pixels per byte,
|
|
// since each pixel is represented by one bit, but if the width
|
|
// is not a multiple of eight, the last byte will have some bits
|
|
// set, with the others just being extra. Plus there's the
|
|
// dword-alignment padding. So we keep checking to see if we've
|
|
// already read "width" number of pixels.
|
|
for (int i = 7; i >= 0; --i) {
|
|
if (currPixel < m_width) {
|
|
int src = 3 * ((BMGroup & pow2[i]) >> i);
|
|
|
|
m_byte[dest] = palette[src];
|
|
m_byte[dest + 1] = palette[src + 1];
|
|
m_byte[dest + 2] = palette[src + 2];
|
|
|
|
++currPixel;
|
|
dest += 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bitCount == 4) {
|
|
|
|
flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_4BIT;
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
int BMScanWidth = (m_width + 1) >> 1;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
dest = 3 * h * m_width;
|
|
|
|
for (int w = 0; w < BMScanWidth; w++) {
|
|
|
|
BMGroup = input.readUInt8();
|
|
int src[2];
|
|
src[0] = 3 * ((BMGroup & 0xF0) >> 4);
|
|
src[1] = 3 * (BMGroup & 0x0F);
|
|
|
|
// Now we read the pixels. Usually there are two pixels per byte,
|
|
// since each pixel is represented by four bits, but if the width
|
|
// is not a multiple of two, the last byte will have only four bits
|
|
// set, with the others just being extra. Plus there's the
|
|
// dword-alignment padding. So we keep checking to see if we've
|
|
// already read "Width" number of pixels.
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
if (currPixel < m_width) {
|
|
int tsrc = src[i];
|
|
|
|
m_byte[dest] = palette[tsrc];
|
|
m_byte[dest + 1] = palette[tsrc + 1];
|
|
m_byte[dest + 2] = palette[tsrc + 2];
|
|
|
|
++currPixel;
|
|
dest += 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bitCount == 8) {
|
|
|
|
flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_8BIT;
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
BMScanWidth = m_width;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
|
|
for (int w = 0; w < BMScanWidth; ++w) {
|
|
|
|
BMPixel8 = input.readUInt8();
|
|
|
|
if (currPixel < m_width) {
|
|
dest = 3 * ((h * m_width) + currPixel);
|
|
int src = 3 * BMPixel8;
|
|
|
|
m_byte[dest] = palette[src];
|
|
m_byte[dest + 1] = palette[src + 1];
|
|
m_byte[dest + 2] = palette[src + 2];
|
|
|
|
++currPixel;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bitCount == 16) {
|
|
|
|
m_memMan->free(m_byte);
|
|
m_byte = NULL;
|
|
System::free(palette);
|
|
palette = NULL;
|
|
throw Error("16-bit bitmaps not supported", input.getFilename());
|
|
|
|
} else if (bitCount == 24) {
|
|
input.skip(20);
|
|
|
|
flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_24BIT;
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
BMScanWidth = m_width * 3;
|
|
|
|
if (BMScanWidth & 3) {
|
|
BMPadding = 4 - (BMScanWidth & 3);
|
|
} else {
|
|
BMPadding = 0;
|
|
}
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
dest = 3 * h * m_width;
|
|
for (int w = 0; w < m_width; ++w) {
|
|
|
|
blue = input.readUInt8();
|
|
green = input.readUInt8();
|
|
red = input.readUInt8();
|
|
|
|
m_byte[dest] = red;
|
|
m_byte[dest + 1] = green;
|
|
m_byte[dest + 2] = blue;
|
|
|
|
dest += 3;
|
|
}
|
|
|
|
if (BMPadding) {
|
|
input.skip(2);
|
|
}
|
|
}
|
|
|
|
} else if (bitCount == 32) {
|
|
|
|
m_memMan->free(m_byte);
|
|
m_byte = NULL;
|
|
System::free(palette);
|
|
palette = NULL;
|
|
throw Error("32 bit bitmaps not supported", input.getFilename());
|
|
|
|
} else {
|
|
// We support all possible bit depths, so if the
|
|
// code gets here, it's not even a real bitmap.
|
|
m_memMan->free(m_byte);
|
|
m_byte = NULL;
|
|
throw Error("Not a bitmap!", input.getFilename());
|
|
}
|
|
|
|
System::free(palette);
|
|
palette = NULL;
|
|
}
|
|
|
|
|
|
void GImage::decodeICO(
|
|
BinaryInput& input) {
|
|
|
|
// Header
|
|
uint16 r = input.readUInt16();
|
|
debugAssert(r == 0);
|
|
r = input.readUInt16();
|
|
debugAssert(r == 1);
|
|
|
|
// Read the number of icons, although we'll only load the
|
|
// first one.
|
|
int count = input.readUInt16();
|
|
|
|
m_channels = 4;
|
|
|
|
debugAssert(count > 0);
|
|
|
|
const uint8* headerBuffer = input.getCArray() + input.getPosition();
|
|
int maxWidth = 0, maxHeight = 0;
|
|
int maxHeaderNum = 0;
|
|
for (int currentHeader = 0; currentHeader < count; ++currentHeader) {
|
|
|
|
const uint8* curHeaderBuffer = headerBuffer + (currentHeader * 16);
|
|
int tmpWidth = curHeaderBuffer[0];
|
|
int tmpHeight = curHeaderBuffer[1];
|
|
// Just in case there is a non-square icon, checking area
|
|
if ((tmpWidth * tmpHeight) > (maxWidth * maxHeight)) {
|
|
maxWidth = tmpWidth;
|
|
maxHeight = tmpHeight;
|
|
maxHeaderNum = currentHeader;
|
|
}
|
|
}
|
|
|
|
input.skip(maxHeaderNum * 16);
|
|
|
|
m_width = input.readUInt8();
|
|
m_height = input.readUInt8();
|
|
int numColors = input.readUInt8();
|
|
|
|
m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels);
|
|
debugAssert(m_byte);
|
|
|
|
// Bit mask for packed bits
|
|
int mask = 0;
|
|
|
|
int bitsPerPixel = 8;
|
|
|
|
switch (numColors) {
|
|
case 2:
|
|
mask = 0x01;
|
|
bitsPerPixel = 1;
|
|
break;
|
|
|
|
case 16:
|
|
mask = 0x0F;
|
|
bitsPerPixel = 4;
|
|
break;
|
|
|
|
case 0:
|
|
numColors = 256;
|
|
mask = 0xFF;
|
|
bitsPerPixel = 8;
|
|
break;
|
|
|
|
default:
|
|
throw Error("Unsupported ICO color count.", input.getFilename());
|
|
}
|
|
|
|
input.skip(5);
|
|
// Skip 'size' unused
|
|
input.skip(4);
|
|
|
|
int offset = input.readUInt32();
|
|
|
|
// Skip over any other icon descriptions
|
|
input.setPosition(offset);
|
|
|
|
// Skip over bitmap header; it is redundant
|
|
input.skip(40);
|
|
|
|
Array<Color4uint8> palette;
|
|
palette.resize(numColors, true);
|
|
for (int c = 0; c < numColors; ++c) {
|
|
palette[c].b = input.readUInt8();
|
|
palette[c].g = input.readUInt8();
|
|
palette[c].r = input.readUInt8();
|
|
palette[c].a = input.readUInt8();
|
|
}
|
|
|
|
// The actual image and mask follow
|
|
|
|
// The XOR Bitmap is stored as 1-bit, 4-bit or 8-bit uncompressed Bitmap
|
|
// using the same encoding as BMP files. The AND Bitmap is stored in as
|
|
// 1-bit uncompressed Bitmap.
|
|
//
|
|
// Pixels are stored bottom-up, left-to-right. Pixel lines are padded
|
|
// with zeros to end on a 32bit (4byte) boundary. Every line will have the
|
|
// same number of bytes. Color indices are zero based, meaning a pixel color
|
|
// of 0 represents the first color table entry, a pixel color of 255 (if there
|
|
// are that many) represents the 256th entry.
|
|
/*
|
|
int bitsPerRow = width * bitsPerPixel;
|
|
int bytesPerRow = iCeil((double)bitsPerRow / 8);
|
|
// Rows are padded to 32-bit boundaries
|
|
bytesPerRow += bytesPerRow % 4;
|
|
|
|
// Read the XOR values into the color channel
|
|
for (int y = height - 1; y >= 0; --y) {
|
|
int x = 0;
|
|
// Read the row
|
|
for (int i = 0; i < bytesPerRow; ++i) {
|
|
uint8 byte = input.readUInt8();
|
|
for (int j = 0; (j < 8) && (x < width); ++x, j += bitsPerPixel) {
|
|
int bit = ((byte << j) >> (8 - bitsPerPixel)) & mask;
|
|
pixel4(x, y) = colorTable[bit];
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
int hStart = 0;
|
|
int hEnd = 0;
|
|
int hDir = 0;
|
|
|
|
if (m_height < 0) {
|
|
m_height = -m_height;
|
|
hStart = 0;
|
|
hEnd = m_height;
|
|
hDir = 1;
|
|
} else {
|
|
//height = height;
|
|
hStart = m_height - 1;
|
|
hEnd = -1;
|
|
hDir = -1;
|
|
}
|
|
|
|
int BMScanWidth;
|
|
uint8 BMGroup;
|
|
uint8 BMPixel8;
|
|
int currPixel;
|
|
int dest;
|
|
|
|
if (bitsPerPixel == 1) {
|
|
// Note that this file is not necessarily grayscale, since it's possible
|
|
// the palette is blue-and-white, or whatever. But of course most image
|
|
// programs only write 1-bit images if they're black-and-white.
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
BMScanWidth = (m_width + 7) >> 3;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
// Powers of 2
|
|
int pow2[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
dest = 3 * h * m_width;
|
|
|
|
for (int w = 0; w < BMScanWidth; ++w) {
|
|
|
|
BMGroup = input.readUInt8();
|
|
|
|
// Now we read the pixels. Usually there are eight pixels per byte,
|
|
// since each pixel is represented by one bit, but if the width
|
|
// is not a multiple of eight, the last byte will have some bits
|
|
// set, with the others just being extra. Plus there's the
|
|
// dword-alignment padding. So we keep checking to see if we've
|
|
// already read "width" number of pixels.
|
|
for (int i = 7; i >= 0; --i) {
|
|
if (currPixel < m_width) {
|
|
int src = ((BMGroup & pow2[i]) >> i);
|
|
|
|
m_byte[dest] = palette[src].r;
|
|
m_byte[dest + 1] = palette[src].g;
|
|
m_byte[dest + 2] = palette[src].b;
|
|
|
|
++currPixel;
|
|
dest += 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bitsPerPixel == 4) {
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
int BMScanWidth = (m_width + 1) >> 1;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
dest = 4 * h * m_width;
|
|
|
|
for (int w = 0; w < BMScanWidth; w++) {
|
|
|
|
BMGroup = input.readUInt8();
|
|
int src[2];
|
|
src[0] = ((BMGroup & 0xF0) >> 4);
|
|
src[1] = (BMGroup & 0x0F);
|
|
|
|
// Now we read the pixels. Usually there are two pixels per byte,
|
|
// since each pixel is represented by four bits, but if the width
|
|
// is not a multiple of two, the last byte will have only four bits
|
|
// set, with the others just being extra. Plus there's the
|
|
// dword-alignment padding. So we keep checking to see if we've
|
|
// already read "Width" number of pixels.
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
if (currPixel < m_width) {
|
|
int tsrc = src[i];
|
|
|
|
m_byte[dest] = palette[tsrc].r;
|
|
m_byte[dest + 1] = palette[tsrc].g;
|
|
m_byte[dest + 2] = palette[tsrc].b;
|
|
|
|
++currPixel;
|
|
dest += 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bitsPerPixel == 8) {
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
BMScanWidth = m_width;
|
|
if (BMScanWidth & 3) {
|
|
BMScanWidth += 4 - (BMScanWidth & 3);
|
|
}
|
|
|
|
for (int h = hStart; h != hEnd; h += hDir) {
|
|
|
|
currPixel = 0;
|
|
|
|
for (int w = 0; w < BMScanWidth; ++w) {
|
|
|
|
BMPixel8 = input.readUInt8();
|
|
|
|
if (currPixel < m_width) {
|
|
dest = 4 * ((h * m_width) + currPixel);
|
|
int src = BMPixel8;
|
|
|
|
m_byte[dest] = palette[src].r;
|
|
m_byte[dest + 1] = palette[src].g;
|
|
m_byte[dest + 2] = palette[src].b;
|
|
|
|
++currPixel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Read the mask into the alpha channel
|
|
int bitsPerRow = m_width;
|
|
int bytesPerRow = iCeil((double)bitsPerRow / 8);
|
|
|
|
// For bitmaps, each scanline is dword-aligned.
|
|
//BMScanWidth = (width + 1) >> 1;
|
|
if (bytesPerRow & 3) {
|
|
bytesPerRow += 4 - (bytesPerRow & 3);
|
|
}
|
|
|
|
for (int y = m_height - 1; y >= 0; --y) {
|
|
int x = 0;
|
|
// Read the row
|
|
for (int i = 0; i < bytesPerRow; ++i) {
|
|
uint8 byte = input.readUInt8();
|
|
for (int j = 0; (j < 8) && (x < m_width); ++x, ++j) {
|
|
int bit = (byte >> (7 - j)) & 0x01;
|
|
pixel4(x, y).a = (1 - bit) * 0xFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|