* Typical file extensions are .bmp and .rle
* (the latter is only used for compressed files).
*
* This codec supports the bounds concept for loading and saving. *
**
*
The RLE-compressed BMP files that I could test this codec on seem to
* have an end-of-line code at the end of every line instead of relying
* on the decoder to know when it has unpacked enough bytes for a line.
* Whenever this codec encounters an EOL symbol and has a current column
* value of 0, the EOL is ignored.
*
* BMPCodec codec = new BMPCodec();
* codec.setImage(image);
* codec.setFile("out.bmp", CodecMode.SAVE);
* codec.process();
* codec.close();
*
* Read an image from a BMP file.
*
* BMPCodec codec = new BMPCodec();
* codec.setFile("image.bmp", CodecMode.LOAD);
* codec.process();
* codec.close();
* PixelImage image = codec.getImage();
*
* @author Marco Schmidt
* @since 0.7.0
*/
public class BMPCodec extends ImageCodec
{
private int colorDepth;
private int compression;
private int dataOffset;
private int imageHeight;
private int imageWidth;
private DataInput in;
private DataOutput out;
private Palette palette;
public String[] getFileExtensions()
{
return new String[] {".bmp", ".rle"};
}
public String getFormatName()
{
return "Windows BMP";
}
public String[] getMimeTypes()
{
return new String[] {"image/bmp", "image/x-ms-bmp"};
}
public boolean isLoadingSupported()
{
return true;
}
public boolean isSavingSupported()
{
return true;
}
private void load() throws
MissingParameterException,
OperationFailedException,
UnsupportedTypeException,
WrongFileFormatException
{
in = getInputAsDataInput();
if (in == null)
{
throw new MissingParameterException("Input stream / random access file parameter missing.");
}
// now write the output stream
try
{
loadHeader();
loadStream();
}
catch (IOException ioe)
{
// wrap any I/O failures in an OperationFailedException
throw new OperationFailedException("I/O failure: " + ioe.toString());
}
}
private void loadCompressedPaletted4Stream() throws IOException
{
Paletted8Image image = (Paletted8Image)getImage();
int imageBytesPerRow = imageWidth;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
final int COLUMNS = getBoundsWidth();
final int ROWS = imageHeight - getBoundsY1();
final int X1 = getBoundsX1();
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
int x = 0;
int y = imageHeight - 1;
boolean endOfBitmap = false;
boolean delta = false;
int newX = 0;
int newY = 0;
while (processedRows < ROWS)
{
int v1 = in.readUnsignedByte();
int v2 = in.readUnsignedByte();
if (v1 == 0)
{
switch(v2)
{
case(0):
{
// end of line
if (x != 0)
{
x = bytesPerRow;
}
break;
}
case(1):
{
// end of bitmap
x = bytesPerRow;
endOfBitmap = true;
break;
}
case(2):
{
// delta
delta = true;
newX = x + in.readUnsignedByte();
newY = y - in.readUnsignedByte();
x = bytesPerRow;
break;
}
default:
{
// copy the next v2 (3..255) samples from file to output
// two samples are packed into one byte
// if the number of bytes used to pack is not a multiple of 2,
// an additional padding byte is in the stream and must be skipped
boolean paddingByte = (((v2 + 1) / 2) % 2) != 0;
while (v2 > 1)
{
int packed = in.readUnsignedByte();
int sample1 = (packed >> 4) & 0x0f;
int sample2 = packed & 0x0f;
row[x++] = (byte)sample1;
row[x++] = (byte)sample2;
v2 -= 2;
}
if (v2 == 1)
{
int packed = in.readUnsignedByte();
int sample = (packed >> 4) & 0x0f;
row[x++] = (byte)sample;
}
if (paddingByte)
{
v2 = in.readUnsignedByte();
}
break;
}
}
}
else
{
// rle: replicate the two samples in v2 as many times as v1 says
byte sample1 = (byte)((v2 >> 4) & 0x0f);
byte sample2 = (byte)(v2 & 0x0f);
while (v1 > 1)
{
row[x++] = sample1;
row[x++] = sample2;
v1 -= 2;
}
if (v1 == 1)
{
row[x++] = sample1;
}
}
// end of line?
if (x == bytesPerRow)
{
if (y <= getBoundsY2())
{
image.putByteSamples(0, 0, y - getBoundsY1(), COLUMNS, 1, row, X1);
}
if (delta)
{
x = newX;
y = newY;
}
else
{
x = 0;
y--;
}
if (endOfBitmap)
{
processedRows = ROWS - 1;
}
setProgress(processedRows, ROWS);
processedRows++;
delta = false;
}
}
}
private void loadCompressedPaletted8Stream() throws IOException
{
Paletted8Image image = (Paletted8Image)getImage();
int imageBytesPerRow = imageWidth;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
final int COLUMNS = getBoundsWidth();
final int ROWS = imageHeight - getBoundsY1();
final int X1 = getBoundsX1();
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
int x = 0;
int y = imageHeight - 1;
boolean endOfBitmap = false;
boolean delta = false;
int newX = 0;
int newY = 0;
while (processedRows < ROWS)
{
int v1 = in.readUnsignedByte();
int v2 = in.readUnsignedByte();
if (v1 == 0)
{
switch(v2)
{
case(0):
{
// end of line
if (x != 0)
{
x = bytesPerRow;
}
break;
}
case(1):
{
// end of bitmap
x = bytesPerRow;
endOfBitmap = true;
break;
}
case(2):
{
// delta
delta = true;
newX = x + in.readUnsignedByte();
newY = y - in.readUnsignedByte();
x = bytesPerRow;
break;
}
default:
{
// copy the next v2 (3..255) bytes from file to output
boolean paddingByte = (v2 % 2) != 0;
while (v2-- > 0)
{
row[x++] = (byte)in.readUnsignedByte();
}
if (paddingByte)
{
v2 = in.readUnsignedByte();
}
break;
}
}
}
else
{
// rle: replicate v2 as many times as v1 says
byte value = (byte)v2;
while (v1-- > 0)
{
row[x++] = value;
}
}
// end of line?
if (x == bytesPerRow)
{
if (y <= getBoundsY2())
{
image.putByteSamples(0, 0, y - getBoundsY1(), COLUMNS, 1, row, X1);
}
if (delta)
{
x = newX;
y = newY;
}
else
{
x = 0;
y--;
}
if (endOfBitmap)
{
processedRows = ROWS - 1;
}
setProgress(processedRows, ROWS);
processedRows++;
delta = false;
}
}
}
private void loadHeader() throws
IOException,
MissingParameterException,
OperationFailedException,
UnsupportedTypeException,
WrongFileFormatException
{
byte[] header = new byte[54];
in.readFully(header);
if (header[0] != 'B' || header[1] != 'M')
{
throw new WrongFileFormatException("Not a BMP file (first two bytes are not 0x42 0x4d).");
}
dataOffset = ArrayConverter.getIntLE(header, 0x0a);
if (dataOffset < 54)
{
throw new InvalidFileStructureException("BMP data expected to be 54dec or larger, got " + dataOffset);
}
imageWidth = ArrayConverter.getIntLE(header, 0x12);
imageHeight = ArrayConverter.getIntLE(header, 0x16);
if (imageWidth < 1 || imageHeight < 1)
{
throw new InvalidFileStructureException("BMP image width and height must be larger than 0, got " + imageWidth + " x " + imageHeight);
}
int planes = ArrayConverter.getShortLE(header, 0x1a);
if (planes != 1)
{
throw new InvalidFileStructureException("Can only handle BMP number of planes = 1, got " + planes);
}
colorDepth = ArrayConverter.getShortLE(header, 0x1c);
if (colorDepth != 1 && colorDepth != 4 && colorDepth != 8 && colorDepth != 24)
{
// TO DO: add support for 16 bpp BMP reading
throw new InvalidFileStructureException("Unsupported BMP color depth: " + colorDepth);
}
compression = ArrayConverter.getIntLE(header, 0x1e);
if (compression != 0 && !(compression == 1 && colorDepth == 8) && !(compression == 2 && colorDepth == 4))
{
throw new InvalidFileStructureException("Unsupported BMP compression type / color depth combination: " +
compression + " / " + colorDepth);
}
float dpiXValue = ArrayConverter.getIntLE(header, 0x26) / (100.0f / 2.54f);
float dpiYValue = ArrayConverter.getIntLE(header, 0x2a) / (100.0f / 2.54f);
setDpi((int)dpiXValue, (int)dpiYValue);
}
private void loadStream() throws
IOException,
MissingParameterException,
OperationFailedException,
UnsupportedTypeException
{
// 1. check bounds, initialize them if necessary
setBoundsIfNecessary(imageWidth, imageHeight);
checkBounds(imageWidth, imageHeight);
// 2. read palette if the image isn't truecolor (even monochrome BMPs have a palette)
int bytesToSkip;
if (colorDepth <= 8)
{
int numPaletteEntries = 1 << colorDepth;
int expectedPaletteSize = 4 * numPaletteEntries;
int headerSpaceLeft = dataOffset - 54;
bytesToSkip = headerSpaceLeft - expectedPaletteSize;
if (bytesToSkip < 0)
{
throw new InvalidFileStructureException("Not enough space in header for palette with " +
numPaletteEntries + "entries.");
}
palette = new Palette(numPaletteEntries);
for (int index = 0; index < numPaletteEntries; index++)
{
int blue = in.readUnsignedByte();
int green = in.readUnsignedByte();
int red = in.readUnsignedByte();
in.readUnsignedByte();
palette.put(index, red, green, blue);
}
}
else
{
bytesToSkip = dataOffset - 54;
}
// 3. seek to beginning of image data
while (bytesToSkip > 0)
{
int skipped = in.skipBytes(bytesToSkip);
if (skipped > 0)
{
bytesToSkip -= skipped;
}
}
// 4. check if we have an image object that we are supposed to reuse
// if there is one, check if it has the correct type
// if there is none, create a new one
PixelImage image = getImage();
if (image == null)
{
switch(colorDepth)
{
case(1):
{
setImage(new MemoryBilevelImage(getBoundsWidth(), getBoundsHeight()));
break;
}
case(4):
case(8):
{
setImage(new MemoryPaletted8Image(getBoundsWidth(), getBoundsHeight(), palette));
break;
}
case(24):
{
setImage(new MemoryRGB24Image(getBoundsWidth(), getBoundsHeight()));
break;
}
// loadHeader would have thrown an exception for any other color depths
}
}
else
{
// TODO: check if image is of correct type
}
// now read actual image data
if (compression == 0)
{
loadUncompressedStream();
}
else
if (compression == 1)
{
loadCompressedPaletted8Stream();
}
else
if (compression == 2)
{
loadCompressedPaletted4Stream();
}
}
private void loadUncompressedBilevelStream() throws
IOException,
OperationFailedException
{
if ((getBoundsX1() % 8) != 0)
{
throw new OperationFailedException("When loading bilevel images, horizontal X1 bounds must be a multiple of 8; got " + getBoundsX1());
}
BilevelImage image = (BilevelImage)getImage();
int imageBytesPerRow = (imageWidth + 7) / 8;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
int bottomRowsToSkip = imageHeight - 1 - getBoundsY2();
int bytesToSkip = bottomRowsToSkip * bytesPerRow;
while (bytesToSkip > 0)
{
int skipped = in.skipBytes(bytesToSkip);
if (skipped > 0)
{
bytesToSkip -= skipped;
}
}
final int COLUMNS = getBoundsWidth();
final int ROWS = getBoundsHeight();
final int SRC_OFFSET = getBoundsX1() / 8;
final int SRC_BIT_OFFSET = getBoundsX1() % 8;
int y = image.getHeight() - 1;
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
while (processedRows < ROWS)
{
in.readFully(row);
image.putPackedBytes(0, y, COLUMNS, row, SRC_OFFSET, SRC_BIT_OFFSET);
y--;
setProgress(processedRows, ROWS);
processedRows++;
}
}
private void loadUncompressedPaletted4Stream() throws
IOException
{
Paletted8Image image = (Paletted8Image)getImage();
int imageBytesPerRow = (imageWidth + 1) / 2;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
int bottomRowsToSkip = imageHeight - 1 - getBoundsY2();
int bytesToSkip = bottomRowsToSkip * bytesPerRow;
while (bytesToSkip > 0)
{
int skipped = in.skipBytes(bytesToSkip);
if (skipped > 0)
{
bytesToSkip -= skipped;
}
}
final int COLUMNS = getBoundsWidth();
final int ROWS = getBoundsHeight();
final int X1 = getBoundsX1();
int y = image.getHeight() - 1;
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
byte[] samples = new byte[bytesPerRow * 2];
while (processedRows < ROWS)
{
in.readFully(row);
ArrayConverter.decodePacked4Bit(row, 0, samples, 0, row.length);
image.putByteSamples(0, 0, y, COLUMNS, 1, samples, X1);
y--;
setProgress(processedRows, ROWS);
processedRows++;
}
}
private void loadUncompressedPaletted8Stream() throws IOException
{
Paletted8Image image = (Paletted8Image)getImage();
int imageBytesPerRow = imageWidth;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
int bottomRowsToSkip = imageHeight - 1 - getBoundsY2();
int bytesToSkip = bottomRowsToSkip * bytesPerRow;
while (bytesToSkip > 0)
{
int skipped = in.skipBytes(bytesToSkip);
if (skipped > 0)
{
bytesToSkip -= skipped;
}
}
final int COLUMNS = getBoundsWidth();
final int ROWS = getBoundsHeight();
final int X1 = getBoundsX1();
int y = image.getHeight() - 1;
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
while (processedRows < ROWS)
{
in.readFully(row);
image.putByteSamples(0, 0, y, COLUMNS, 1, row, X1);
y--;
setProgress(processedRows, ROWS);
processedRows++;
}
}
private void loadUncompressedRgb24Stream() throws IOException
{
RGB24Image image = (RGB24Image)getImage();
int imageBytesPerRow = imageWidth * 3;
int bytesPerRow = imageBytesPerRow;
int mod = bytesPerRow % 4;
if (mod != 0)
{
bytesPerRow += 4 - mod;
}
int bottomRowsToSkip = imageHeight - 1 - getBoundsY2();
int bytesToSkip = bottomRowsToSkip * bytesPerRow;
while (bytesToSkip > 0)
{
int skipped = in.skipBytes(bytesToSkip);
if (skipped > 0)
{
bytesToSkip -= skipped;
}
}
final int COLUMNS = getBoundsWidth();
final int ROWS = getBoundsHeight();
final int X1 = getBoundsX1();
int y = image.getHeight() - 1;
int processedRows = 0;
byte[] row = new byte[bytesPerRow];
byte[] samples = new byte[COLUMNS];
while (processedRows < ROWS)
{
in.readFully(row);
// copy red samples to array samples and store those samples
for (int x = X1 * 3 + 2, i = 0; i < COLUMNS; x += 3, i++)
{
samples[i] = row[x];
}
image.putByteSamples(RGBIndex.INDEX_RED, 0, y, COLUMNS, 1, samples, 0);
// copy green samples to array samples and store those samples
for (int x = X1 * 3 + 1, i = 0; i < COLUMNS; x += 3, i++)
{
samples[i] = row[x];
}
image.putByteSamples(RGBIndex.INDEX_GREEN, 0, y, COLUMNS, 1, samples, 0);
// copy blue samples to array samples and store those samples
for (int x = X1 * 3, i = 0; i < COLUMNS; x += 3, i++)
{
samples[i] = row[x];
}
image.putByteSamples(RGBIndex.INDEX_BLUE, 0, y, COLUMNS, 1, samples, 0);
y--;
setProgress(processedRows, ROWS);
processedRows++;
}
}
private void loadUncompressedStream() throws
IOException,
OperationFailedException
{
switch(colorDepth)
{
case(1):
{
loadUncompressedBilevelStream();
break;
}
case(4):
{
loadUncompressedPaletted4Stream();
break;
}
case(8):
{
loadUncompressedPaletted8Stream();
break;
}
case(24):
{
loadUncompressedRgb24Stream();
break;
}
}
}
public void process() throws
MissingParameterException,
OperationFailedException
{
initModeFromIOObjects();
if (getMode() == CodecMode.LOAD)
{
load();
}
else
{
save();
}
}
private void save() throws
MissingParameterException,
OperationFailedException,
UnsupportedTypeException
{
// check parameters of this operation
// 1 image to be saved
// 1.1 is it available?
PixelImage image = getImage();
if (image == null)
{
throw new MissingParameterException("No image available.");
}
// 1.2 is it supported?
if (!(image instanceof Paletted8Image ||
image instanceof Gray8Image ||
image instanceof BilevelImage ||
image instanceof RGB24Image))
{
throw new UnsupportedTypeException("Unsupported image type: " + image.getClass().getName());
}
// 2 is output stream available?
out = getOutputAsDataOutput();
if (out == null)
{
throw new MissingParameterException("Output stream / random access file parameter missing.");
}
// now write the output stream
try
{
writeStream();
}
catch (IOException ioe)
{
throw new OperationFailedException("I/O failure: " + ioe.toString());
}
}
public String suggestFileExtension(PixelImage image)
{
return ".bmp";
}
private void writeHeader(PixelImage image, int filesize, int offset, int numBits) throws IOException
{
out.write(0x42); // 'B'
out.write(0x4d); // 'M'
writeInt(filesize);
writeShort(0);
writeShort(0);
writeInt(offset);
writeInt(40); // BITMAP_INFO header length
writeInt(getBoundsWidth());
writeInt(getBoundsHeight());
writeShort(1); // # of planes
writeShort(numBits);
writeInt(0); // compression (0 = none)
writeInt(filesize - offset); // size of image data in bytes
writeInt((int)(getDpiX() * (100f / 2.54f))); // horizontal resolution in dpi
writeInt((int)(getDpiY() * (100f / 2.54f))); // vertical resolution in dpi
writeInt(0); // # of used colors
writeInt(0); // # of important colors
}
// we can't use out.writeInt because we need little endian byte order
private void writeInt(int value) throws IOException
{
out.write(value & 0xff);
out.write((value >> 8) & 0xff);
out.write((value >> 16) & 0xff);
out.write((value >> 24) & 0xff);
}
/**
* Write the palette associated with the image getImage().
* Required not only for image objects that implement PalettedImage
* but also for BilevelImage and Grayscale8Image.
* For the latter two the palette values must be explicitly written into the file.
*/
private void writePalette() throws IOException
{
PixelImage pi = getImage();
if (pi == null)
{
return;
}
if (pi instanceof Paletted8Image)
{
// always write 256 entries; if there aren't enough
// in the palette, fill it up to 256 with (0, 0, 0, 0)
Palette palette = ((Paletted8Image)pi).getPalette();
for (int i = 0; i < 256; i++)
{
if (i < palette.getNumEntries())
{
out.write(palette.getSample(RGBIndex.INDEX_BLUE, i));
out.write(palette.getSample(RGBIndex.INDEX_GREEN, i));
out.write(palette.getSample(RGBIndex.INDEX_RED, i));
out.write(0);
}
else
{
out.writeInt(0); // writes four 0 bytes
}
}
}
if (pi instanceof Gray8Image)
{
for (int i = 0; i < 256; i++)
{
out.write(i);
out.write(i);
out.write(i);
out.write(0);
}
}
if (pi instanceof BilevelImage)
{
for (int i = 0; i < 2; i++)
{
out.write(i * 255);
out.write(i * 255);
out.write(i * 255);
out.write(0);
}
}
}
// we can't use out.writeShort because we need little endian byte order
private void writeShort(int value) throws IOException
{
out.write(value & 0xff);
out.write((value >> 8) & 0xff);
}
private void writeStream() throws IOException
{
PixelImage image = getImage();
setBoundsIfNecessary(image.getWidth(), image.getHeight());
int width = getBoundsWidth();
int height = getBoundsHeight();
ByteChannelImage bcimg = null;
BilevelImage bilevelImage = null;
RGB24Image rgbimg = null;
int bytesPerRow = 0;
int offset = 54;
int numBits = 0;
int numPackedBytes = 0;
if (image instanceof Paletted8Image ||
image instanceof Gray8Image)
{
bcimg = (ByteChannelImage)image;
bytesPerRow = width;
offset += 1024;
numBits = 8;
}
else
if (image instanceof BilevelImage)
{
bilevelImage = (BilevelImage)image;
numPackedBytes = (width + 7) / 8;
bytesPerRow = numPackedBytes;
offset += 8;
numBits = 1;
}
else
if (image instanceof RGB24Image)
{
rgbimg = (RGB24Image)image;
bytesPerRow = width * 3;
numBits = 24;
}
if ((bytesPerRow % 4) != 0)
{
bytesPerRow = ((bytesPerRow + 3) / 4) * 4;
}
int filesize = offset + bytesPerRow * height;
writeHeader(image, filesize, offset, numBits);
writePalette();
byte[] row = new byte[bytesPerRow];
final int X1 = getBoundsX1();
for (int y = getBoundsY2(), processed = 0; processed < height; y--, processed++)
{
if (bilevelImage != null)
{
bilevelImage.getPackedBytes(X1, y, width, row, 0, 0);
}
else
if (bcimg != null)
{
bcimg.getByteSamples(0, 0, y, width, 1, row, 0);
}
else
if (rgbimg != null)
{
int offs = 0;
for (int x = X1; x < X1 + width; x++)
{
row[offs++] = rgbimg.getByteSample(RGBIndex.INDEX_BLUE, x, y);
row[offs++] = rgbimg.getByteSample(RGBIndex.INDEX_GREEN, x, y);
row[offs++] = rgbimg.getByteSample(RGBIndex.INDEX_RED, x, y);
}
}
else
{
// error
}
out.write(row);
setProgress(processed, height);
if (getAbort())
{
break;
}
}
close();
}
}