mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-23 02:11:38 +00:00
aed02365ec
svn-id: r47541
706 lines
20 KiB
C++
706 lines
20 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#include "mohawk/bitmap.h"
|
|
|
|
#include "common/debug.h"
|
|
#include "common/util.h"
|
|
#include "common/endian.h"
|
|
#include "common/system.h"
|
|
|
|
namespace Mohawk {
|
|
|
|
#define PACK_COMPRESSION (_header.format & kPackMASK)
|
|
#define DRAW_COMPRESSION (_header.format & kDrawMASK)
|
|
|
|
MohawkBitmap::MohawkBitmap() {
|
|
}
|
|
|
|
MohawkBitmap::~MohawkBitmap() {
|
|
}
|
|
|
|
ImageData *MohawkBitmap::decodeImage(Common::SeekableReadStream *stream) {
|
|
_data = stream;
|
|
_header.colorTable.palette = NULL;
|
|
|
|
// NOTE: Only the bottom 12 bits of width/height/bytesPerRow are
|
|
// considered valid and bytesPerRow has to be an even number.
|
|
_header.width = _data->readUint16BE() & 0x3FFF;
|
|
_header.height = _data->readUint16BE() & 0x3FFF;
|
|
_header.bytesPerRow = _data->readSint16BE() & 0x3FFE;
|
|
_header.format = _data->readUint16BE();
|
|
|
|
debug (2, "Decoding Mohawk Bitmap (%dx%d, %dbpp, %s Packing + %s Drawing)", _header.width, _header.height, getBitsPerPixel(), getPackName(), getDrawName());
|
|
|
|
if (getBitsPerPixel() != 8)
|
|
error ("Unhandled bpp %d", getBitsPerPixel());
|
|
|
|
// Read in the palette if it's here.
|
|
if (_header.format & kBitmapHasCLUT || (PACK_COMPRESSION == kPackRiven && getBitsPerPixel() == 8)) {
|
|
_header.colorTable.tableSize = _data->readUint16BE();
|
|
_header.colorTable.rgbBits = _data->readByte();
|
|
_header.colorTable.colorCount = _data->readByte();
|
|
_header.colorTable.palette = (byte *)malloc(256 * 4);
|
|
|
|
for (uint16 i = 0; i < 256; i++) {
|
|
_header.colorTable.palette[i * 4 + 2] = _data->readByte();
|
|
_header.colorTable.palette[i * 4 + 1] = _data->readByte();
|
|
_header.colorTable.palette[i * 4] = _data->readByte();
|
|
_header.colorTable.palette[i * 4 + 3] = 0;
|
|
}
|
|
}
|
|
|
|
_surface = new Graphics::Surface();
|
|
_surface->create(_header.width, _header.height, getBitsPerPixel() >> 3);
|
|
|
|
unpackImage();
|
|
drawImage();
|
|
delete _data;
|
|
|
|
return new ImageData(_surface, _header.colorTable.palette);
|
|
}
|
|
|
|
byte MohawkBitmap::getBitsPerPixel() {
|
|
switch (_header.format & kBitsPerPixelMask) {
|
|
case kBitsPerPixel1:
|
|
return 1;
|
|
case kBitsPerPixel4:
|
|
return 4;
|
|
case kBitsPerPixel8:
|
|
return 8;
|
|
case kBitsPerPixel16:
|
|
return 16;
|
|
case kBitsPerPixel24:
|
|
return 24;
|
|
default:
|
|
error ("Unknown bits per pixel");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct CompressionInfo {
|
|
uint16 flag;
|
|
const char *name;
|
|
void (MohawkBitmap::*func)();
|
|
};
|
|
|
|
static const CompressionInfo packTable[] = {
|
|
{ kPackNone, "Raw", &MohawkBitmap::unpackRaw },
|
|
{ kPackLZ, "LZ", &MohawkBitmap::unpackLZ },
|
|
{ kPackLZ1, "LZ1", &MohawkBitmap::unpackLZ1 },
|
|
{ kPackRiven, "Riven", &MohawkBitmap::unpackRiven }
|
|
};
|
|
|
|
const char *MohawkBitmap::getPackName() {
|
|
for (uint32 i = 0; i < ARRAYSIZE(packTable); i++)
|
|
if (PACK_COMPRESSION == packTable[i].flag)
|
|
return packTable[i].name;
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
void MohawkBitmap::unpackImage() {
|
|
for (uint32 i = 0; i < ARRAYSIZE(packTable); i++)
|
|
if (PACK_COMPRESSION == packTable[i].flag) {
|
|
(this->*packTable[i].func)();
|
|
return;
|
|
}
|
|
|
|
warning("Unknown Pack Compression");
|
|
}
|
|
|
|
static const CompressionInfo drawTable[] = {
|
|
{ kDrawRaw, "Raw", &MohawkBitmap::drawRaw },
|
|
{ kDrawRLE8, "RLE8", &MohawkBitmap::drawRLE8 },
|
|
{ kDrawRLE, "RLE", &MohawkBitmap::drawRLE }
|
|
};
|
|
|
|
const char *MohawkBitmap::getDrawName() {
|
|
for (uint32 i = 0; i < ARRAYSIZE(drawTable); i++)
|
|
if (DRAW_COMPRESSION == drawTable[i].flag)
|
|
return drawTable[i].name;
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
void MohawkBitmap::drawImage() {
|
|
for (uint32 i = 0; i < ARRAYSIZE(drawTable); i++)
|
|
if (DRAW_COMPRESSION == drawTable[i].flag) {
|
|
(this->*drawTable[i].func)();
|
|
return;
|
|
}
|
|
|
|
warning("Unknown Draw Compression");
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// Raw "Unpacker"
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::unpackRaw() {
|
|
// Do nothing :D
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// LZ Unpacker
|
|
//////////////////////////////////////////
|
|
|
|
#define LEN_BITS 6
|
|
#define MIN_STRING 3 // lower limit for string length
|
|
#define POS_BITS (16 - LEN_BITS)
|
|
#define MAX_STRING ((1 << LEN_BITS) + MIN_STRING - 1) // upper limit for string length
|
|
#define CBUFFERSIZE (1 << POS_BITS) // size of the circular buffer
|
|
#define POS_MASK (CBUFFERSIZE - 1)
|
|
|
|
Common::SeekableReadStream *MohawkBitmap::decompressLZ(Common::SeekableReadStream *stream, uint32 uncompressedSize) {
|
|
uint16 flags = 0;
|
|
uint32 bytesOut = 0;
|
|
uint16 insertPos = 0;
|
|
|
|
// Expand the output buffer to at least the ring buffer size
|
|
uint32 outBufSize = MAX<int>(uncompressedSize, CBUFFERSIZE);
|
|
|
|
byte *outputData = (byte *)malloc(outBufSize);
|
|
byte *dst = outputData;
|
|
byte *buf = dst;
|
|
|
|
// Clear the buffer to all 0's
|
|
memset(outputData, 0, outBufSize);
|
|
|
|
while (stream->pos() < stream->size()) {
|
|
flags >>= 1;
|
|
|
|
if (!(flags & 0x100))
|
|
flags = stream->readByte() | 0xff00;
|
|
|
|
if (flags & 1) {
|
|
if (++bytesOut > uncompressedSize)
|
|
break;
|
|
*dst++ = stream->readByte();
|
|
if (++insertPos > POS_MASK) {
|
|
insertPos = 0;
|
|
buf += CBUFFERSIZE;
|
|
}
|
|
} else {
|
|
uint16 offLen = stream->readUint16BE();
|
|
uint16 stringLen = (offLen >> POS_BITS) + MIN_STRING;
|
|
uint16 stringPos = (offLen + MAX_STRING) & POS_MASK;
|
|
|
|
bytesOut += stringLen;
|
|
if (bytesOut > uncompressedSize)
|
|
stringLen -= bytesOut - uncompressedSize;
|
|
|
|
byte *strPtr = buf + stringPos;
|
|
if (stringPos > insertPos) {
|
|
if (bytesOut >= CBUFFERSIZE)
|
|
strPtr -= CBUFFERSIZE;
|
|
else if (stringPos + stringLen > POS_MASK) {
|
|
for (uint16 k = 0; k < stringLen; k++) {
|
|
*dst++ = *strPtr++;
|
|
if (++stringPos > POS_MASK) {
|
|
stringPos = 0;
|
|
strPtr = outputData;
|
|
}
|
|
}
|
|
insertPos = (insertPos + stringLen) & POS_MASK;
|
|
if (bytesOut >= uncompressedSize)
|
|
break;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
insertPos += stringLen;
|
|
|
|
if (insertPos > POS_MASK) {
|
|
insertPos &= POS_MASK;
|
|
buf += CBUFFERSIZE;
|
|
}
|
|
|
|
for (uint16 k = 0; k < stringLen; k++)
|
|
*dst++ = *strPtr++;
|
|
|
|
if (bytesOut >= uncompressedSize)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return new Common::MemoryReadStream(outputData, uncompressedSize, DisposeAfterUse::YES);
|
|
}
|
|
|
|
void MohawkBitmap::unpackLZ() {
|
|
uint32 uncompressedSize = _data->readUint32BE();
|
|
/* uint32 compressedSize = */ _data->readUint32BE();
|
|
uint16 dictSize = _data->readUint16BE();
|
|
|
|
// We only support the buffer size of 0x400
|
|
if (dictSize != CBUFFERSIZE)
|
|
error("Unsupported dictionary size of %04x", dictSize);
|
|
|
|
// Now go and decompress the data
|
|
Common::SeekableReadStream *decompressedData = decompressLZ(_data, uncompressedSize);
|
|
delete _data;
|
|
_data = decompressedData;
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// LZ Unpacker
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::unpackLZ1() {
|
|
error("STUB: unpackLZ1()");
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// Riven Unpacker
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::unpackRiven() {
|
|
_data->readUint32BE(); // Unknown, the number is close to bytesPerRow * height. Could be bufSize.
|
|
|
|
byte *uncompressedData = (byte *)malloc(_header.bytesPerRow * _header.height);
|
|
byte *dst = uncompressedData;
|
|
|
|
while (!_data->eos() && dst < (uncompressedData + _header.bytesPerRow * _header.height)) {
|
|
byte cmd = _data->readByte();
|
|
debug (8, "Riven Pack Command %02x", cmd);
|
|
|
|
if (cmd == 0x00) { // End of stream
|
|
break;
|
|
} else if (cmd >= 0x01 && cmd <= 0x3f) { // Simple Pixel Duplet Output
|
|
for (byte i = 0; i < cmd; i++) {
|
|
*dst++ = _data->readByte();
|
|
*dst++ = _data->readByte();
|
|
}
|
|
} else if (cmd >= 0x40 && cmd <= 0x7f) { // Simple Repetition of last 2 pixels (cmd - 0x40) times
|
|
byte pixel[] = { *(dst - 2), *(dst - 1) };
|
|
|
|
for (byte i = 0; i < (cmd - 0x40); i++) {
|
|
*dst++ = pixel[0];
|
|
*dst++ = pixel[1];
|
|
}
|
|
} else if (cmd >= 0x80 && cmd <= 0xbf) { // Simple Repetition of last 4 pixels (cmd - 0x80) times
|
|
byte pixel[] = { *(dst - 4), *(dst - 3), *(dst - 2), *(dst - 1) };
|
|
|
|
for (byte i = 0; i < (cmd - 0x80); i++) {
|
|
*dst++ = pixel[0];
|
|
*dst++ = pixel[1];
|
|
*dst++ = pixel[2];
|
|
*dst++ = pixel[3];
|
|
}
|
|
} else { // Subcommand Stream of (cmd - 0xc0) subcommands
|
|
handleRivenSubcommandStream(cmd - 0xc0, dst);
|
|
}
|
|
}
|
|
|
|
delete _data;
|
|
_data = new Common::MemoryReadStream(uncompressedData, _header.bytesPerRow * _header.height, DisposeAfterUse::YES);
|
|
}
|
|
|
|
static byte getLastTwoBits(byte c) {
|
|
return (c & 0x03);
|
|
}
|
|
|
|
static byte getLastThreeBits(byte c) {
|
|
return (c & 0x07);
|
|
}
|
|
|
|
static byte getLastFourBits(byte c) {
|
|
return (c & 0x0f);
|
|
}
|
|
|
|
#define B_BYTE() \
|
|
*dst = _data->readByte(); \
|
|
dst++
|
|
|
|
#define B_LASTDUPLET() \
|
|
*dst = *(dst - 2); \
|
|
dst++
|
|
|
|
#define B_LASTDUPLET_PLUS_M() \
|
|
*dst = *(dst - 2) + m; \
|
|
dst++
|
|
|
|
#define B_LASTDUPLET_MINUS_M() \
|
|
*dst = *(dst - 2) - m; \
|
|
dst++
|
|
|
|
#define B_LASTDUPLET_PLUS(m) \
|
|
*dst = *(dst - 2) + (m); \
|
|
dst++
|
|
|
|
#define B_LASTDUPLET_MINUS(m) \
|
|
*dst = *(dst - 2) - (m); \
|
|
dst++
|
|
|
|
#define B_PIXEL_MINUS(m) \
|
|
*dst = *(dst - (m)); \
|
|
dst++
|
|
|
|
#define B_NDUPLETS(n) \
|
|
uint16 m1 = ((getLastTwoBits(cmd) << 8) + _data->readByte()); \
|
|
for (uint16 j = 0; j < (n); j++) { \
|
|
*dst = *(dst - m1); \
|
|
dst++; \
|
|
} \
|
|
void dummyFuncToAllowTrailingSemicolon()
|
|
|
|
|
|
|
|
void MohawkBitmap::handleRivenSubcommandStream(byte count, byte *&dst) {
|
|
for (byte i = 0; i < count; i++) {
|
|
byte cmd = _data->readByte();
|
|
uint16 m = getLastFourBits(cmd);
|
|
debug (9, "Riven Pack Subcommand %02x", cmd);
|
|
|
|
// Notes: p = value of the next byte, m = last four bits of the command
|
|
|
|
// Arithmetic operations
|
|
if (cmd >= 0x01 && cmd <= 0x0f) {
|
|
// Repeat duplet at relative position of -m duplets
|
|
B_PIXEL_MINUS(m * 2);
|
|
B_PIXEL_MINUS(m * 2);
|
|
} else if (cmd == 0x10) {
|
|
// Repeat last duplet, but set the value of the second pixel to p
|
|
B_LASTDUPLET();
|
|
B_BYTE();
|
|
} else if (cmd >= 0x11 && cmd <= 0x1f) {
|
|
// Repeat last duplet, but set the value of the second pixel to the value of the -m pixel
|
|
B_LASTDUPLET();
|
|
B_PIXEL_MINUS(m);
|
|
} else if (cmd >= 0x20 && cmd <= 0x2f) {
|
|
// Repeat last duplet, but add x to second pixel
|
|
B_LASTDUPLET();
|
|
B_LASTDUPLET_PLUS_M();
|
|
} else if (cmd >= 0x30 && cmd <= 0x3f) {
|
|
// Repeat last duplet, but subtract x from second pixel
|
|
B_LASTDUPLET();
|
|
B_LASTDUPLET_MINUS_M();
|
|
} else if (cmd == 0x40) {
|
|
// Repeat last duplet, but set the value of the first pixel to p
|
|
B_BYTE();
|
|
B_LASTDUPLET();
|
|
} else if (cmd >= 0x41 && cmd <= 0x4f) {
|
|
// Output pixel at relative position -m, then second pixel of last duplet
|
|
B_PIXEL_MINUS(m);
|
|
B_LASTDUPLET();
|
|
} else if (cmd == 0x50) {
|
|
// Output two absolute pixel values, p1 and p2
|
|
B_BYTE();
|
|
B_BYTE();
|
|
} else if (cmd >= 0x51 && cmd <= 0x57) {
|
|
// Output pixel at relative position -m, then absolute pixel value p
|
|
// m is the last 3 bits of cmd here, not last 4
|
|
B_PIXEL_MINUS(getLastThreeBits(cmd));
|
|
B_BYTE();
|
|
} else if (cmd >= 0x59 && cmd <= 0x5f) {
|
|
// Output absolute pixel value p, then pixel at relative position -m
|
|
// m is the last 3 bits of cmd here, not last 4
|
|
B_BYTE();
|
|
B_PIXEL_MINUS(getLastThreeBits(cmd));
|
|
} else if (cmd >= 0x60 && cmd <= 0x6f) {
|
|
// Output absolute pixel value p, then (second pixel of last duplet) + x
|
|
B_BYTE();
|
|
B_LASTDUPLET_PLUS_M();
|
|
} else if (cmd >= 0x70 && cmd <= 0x7f) {
|
|
// Output absolute pixel value p, then (second pixel of last duplet) - x
|
|
B_BYTE();
|
|
B_LASTDUPLET_MINUS_M();
|
|
} else if (cmd >= 0x80 && cmd <= 0x8f) {
|
|
// Repeat last duplet adding x to the first pixel
|
|
B_LASTDUPLET_PLUS_M();
|
|
B_LASTDUPLET();
|
|
} else if (cmd >= 0x90 && cmd <= 0x9f) {
|
|
// Output (first pixel of last duplet) + x, then absolute pixel value p
|
|
B_LASTDUPLET_PLUS_M();
|
|
B_BYTE();
|
|
} else if (cmd == 0xa0) {
|
|
// Repeat last duplet, adding first 4 bits of the next byte
|
|
// to first pixel and last 4 bits to second
|
|
byte pattern = _data->readByte();
|
|
B_LASTDUPLET_PLUS(pattern >> 4);
|
|
B_LASTDUPLET_PLUS(getLastFourBits(pattern));
|
|
} else if (cmd == 0xb0) {
|
|
// Repeat last duplet, adding first 4 bits of the next byte
|
|
// to first pixel and subtracting last 4 bits from second
|
|
byte pattern = _data->readByte();
|
|
B_LASTDUPLET_PLUS(pattern >> 4);
|
|
B_LASTDUPLET_MINUS(getLastFourBits(pattern));
|
|
} else if (cmd >= 0xc0 && cmd <= 0xcf) {
|
|
// Repeat last duplet subtracting x from first pixel
|
|
B_LASTDUPLET_MINUS_M();
|
|
B_LASTDUPLET();
|
|
} else if (cmd >= 0xd0 && cmd <= 0xdf) {
|
|
// Output (first pixel of last duplet) - x, then absolute pixel value p
|
|
B_LASTDUPLET_MINUS_M();
|
|
B_BYTE();
|
|
} else if (cmd == 0xe0) {
|
|
// Repeat last duplet, subtracting first 4 bits of the next byte
|
|
// to first pixel and adding last 4 bits to second
|
|
byte pattern = _data->readByte();
|
|
B_LASTDUPLET_MINUS(pattern >> 4);
|
|
B_LASTDUPLET_PLUS(getLastFourBits(pattern));
|
|
} else if (cmd == 0xf0 || cmd == 0xff) {
|
|
// Repeat last duplet, subtracting first 4 bits from the next byte
|
|
// to first pixel and last 4 bits from second
|
|
byte pattern = _data->readByte();
|
|
B_LASTDUPLET_MINUS(pattern >> 4);
|
|
B_LASTDUPLET_MINUS(getLastFourBits(pattern));
|
|
|
|
// Repeat operations
|
|
// Repeat n duplets from relative position -m (given in pixels, not duplets).
|
|
// If r is 0, another byte follows and the last pixel is set to that value
|
|
} else if (cmd >= 0xa4 && cmd <= 0xa7) {
|
|
B_NDUPLETS(3);
|
|
B_BYTE();
|
|
} else if (cmd >= 0xa8 && cmd <= 0xab) {
|
|
B_NDUPLETS(4);
|
|
} else if (cmd >= 0xac && cmd <= 0xaf) {
|
|
B_NDUPLETS(5);
|
|
B_BYTE();
|
|
} else if (cmd >= 0xb4 && cmd <= 0xb7) {
|
|
B_NDUPLETS(6);
|
|
} else if (cmd >= 0xb8 && cmd <= 0xbb) {
|
|
B_NDUPLETS(7);
|
|
B_BYTE();
|
|
} else if (cmd >= 0xbc && cmd <= 0xbf) {
|
|
B_NDUPLETS(8);
|
|
} else if (cmd >= 0xe4 && cmd <= 0xe7) {
|
|
B_NDUPLETS(9);
|
|
B_BYTE();
|
|
} else if (cmd >= 0xe8 && cmd <= 0xeb) {
|
|
B_NDUPLETS(10); // 5 duplets
|
|
} else if (cmd >= 0xec && cmd <= 0xef) {
|
|
B_NDUPLETS(11);
|
|
B_BYTE();
|
|
} else if (cmd >= 0xf4 && cmd <= 0xf7) {
|
|
B_NDUPLETS(12);
|
|
} else if (cmd >= 0xf8 && cmd <= 0xfb) {
|
|
B_NDUPLETS(13);
|
|
B_BYTE();
|
|
} else if (cmd == 0xfc) {
|
|
byte b1 = _data->readByte();
|
|
byte b2 = _data->readByte();
|
|
uint16 m1 = ((getLastTwoBits(b1) << 8) + b2);
|
|
|
|
for (uint16 j = 0; j < ((b1 >> 3) + 1); j++) { // one less iteration
|
|
B_PIXEL_MINUS(m1);
|
|
B_PIXEL_MINUS(m1);
|
|
}
|
|
|
|
// last iteration
|
|
B_PIXEL_MINUS(m1);
|
|
|
|
if ((b1 & (1 << 2)) == 0) {
|
|
B_BYTE();
|
|
} else {
|
|
B_PIXEL_MINUS(m1);
|
|
}
|
|
} else
|
|
warning("Unknown Riven Pack Subcommand 0x%02x", cmd);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// Raw Drawer
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::drawRaw() {
|
|
for (uint16 y = 0; y < _header.height; y++) {
|
|
_data->read((byte *)_surface->pixels + y * _header.width, _header.width);
|
|
_data->skip(_header.bytesPerRow - _header.width);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// RLE8 Drawer
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::drawRLE8() {
|
|
// A very simple RLE8 scheme is used as a secondary compression on
|
|
// most images in non-Riven tBMP's.
|
|
|
|
for (uint16 i = 0; i < _header.height; i++) {
|
|
uint16 rowByteCount = _data->readUint16BE();
|
|
int32 startPos = _data->pos();
|
|
byte *dst = (byte *)_surface->pixels + i * _header.width;
|
|
int16 remaining = _header.width;
|
|
|
|
// HACK: It seems only the bottom 9 bits are valid for images
|
|
// TODO: Verify if this is still needed after the buffer clearing fix.
|
|
rowByteCount &= 0x1ff;
|
|
|
|
while (remaining > 0) {
|
|
byte code = _data->readByte();
|
|
uint16 runLen = (code & 0x7F) + 1;
|
|
|
|
if (runLen > remaining)
|
|
runLen = remaining;
|
|
|
|
if (code & 0x80) {
|
|
byte val = _data->readByte();
|
|
for (uint16 j = 0; j < runLen; j++)
|
|
*dst++ = val;
|
|
} else {
|
|
for (uint16 j = 0; j < runLen; j++)
|
|
*dst++ = _data->readByte();
|
|
}
|
|
|
|
remaining -= runLen;
|
|
}
|
|
|
|
_data->seek(startPos + rowByteCount);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// RLE Drawer
|
|
//////////////////////////////////////////
|
|
|
|
void MohawkBitmap::drawRLE() {
|
|
warning("STUB: drawRLE()");
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// Myst Bitmap Decoder
|
|
//////////////////////////////////////////
|
|
|
|
ImageData* MystBitmap::decodeImage(Common::SeekableReadStream* stream) {
|
|
uint32 uncompressedSize = stream->readUint32LE();
|
|
Common::SeekableReadStream* bmpStream = decompressLZ(stream, uncompressedSize);
|
|
delete stream;
|
|
|
|
_header.type = bmpStream->readUint16BE();
|
|
|
|
if (_header.type != 'BM')
|
|
error("BMP header not detected");
|
|
|
|
_header.size = bmpStream->readUint32LE();
|
|
assert (_header.size > 0);
|
|
_header.res1 = bmpStream->readUint16LE();
|
|
_header.res2 = bmpStream->readUint16LE();
|
|
_header.imageOffset = bmpStream->readUint32LE();
|
|
|
|
_info.size = bmpStream->readUint32LE();
|
|
|
|
if (_info.size != 40)
|
|
error("Only Windows v3 BMP's are supported");
|
|
|
|
_info.width = bmpStream->readUint32LE();
|
|
_info.height = bmpStream->readUint32LE();
|
|
_info.planes = bmpStream->readUint16LE();
|
|
_info.bitsPerPixel = bmpStream->readUint16LE();
|
|
_info.compression = bmpStream->readUint32LE();
|
|
_info.imageSize = bmpStream->readUint32LE();
|
|
_info.pixelsPerMeterX = bmpStream->readUint32LE();
|
|
_info.pixelsPerMeterY = bmpStream->readUint32LE();
|
|
_info.colorsUsed = bmpStream->readUint32LE();
|
|
_info.colorsImportant = bmpStream->readUint32LE();
|
|
|
|
if (_info.compression != 0)
|
|
error("Unhandled BMP compression %d", _info.compression);
|
|
|
|
if (_info.colorsUsed == 0)
|
|
_info.colorsUsed = 256;
|
|
|
|
if (_info.bitsPerPixel != 8 && _info.bitsPerPixel != 24)
|
|
error("%dbpp Bitmaps not supported", _info.bitsPerPixel);
|
|
|
|
byte *palData = NULL;
|
|
|
|
if (_info.bitsPerPixel == 8) {
|
|
palData = (byte *)malloc(256 * 4);
|
|
for (uint16 i = 0; i < _info.colorsUsed; i++) {
|
|
palData[i * 4 + 2] = bmpStream->readByte();
|
|
palData[i * 4 + 1] = bmpStream->readByte();
|
|
palData[i * 4] = bmpStream->readByte();
|
|
palData[i * 4 + 3] = bmpStream->readByte();
|
|
}
|
|
}
|
|
|
|
bmpStream->seek(_header.imageOffset);
|
|
|
|
Graphics::Surface *surface = new Graphics::Surface();
|
|
int srcPitch = _info.width * (_info.bitsPerPixel >> 3);
|
|
const int extraDataLength = (srcPitch % 4) ? 4 - (srcPitch % 4) : 0;
|
|
|
|
if (_info.bitsPerPixel == 8) {
|
|
surface->create(_info.width, _info.height, 1);
|
|
byte *dst = (byte *)surface->pixels;
|
|
|
|
for (uint32 i = 0; i < _info.height; i++) {
|
|
bmpStream->read(dst + (_info.height - i - 1) * _info.width, _info.width);
|
|
bmpStream->skip(extraDataLength);
|
|
}
|
|
} else {
|
|
Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
|
|
surface->create(_info.width, _info.height, pixelFormat.bytesPerPixel);
|
|
|
|
byte *dst = (byte *)surface->pixels + (surface->h - 1) * surface->pitch;
|
|
|
|
for (uint32 i = 0; i < _info.height; i++) {
|
|
for (uint32 j = 0; j < _info.width; j++) {
|
|
byte b = bmpStream->readByte();
|
|
byte g = bmpStream->readByte();
|
|
byte r = bmpStream->readByte();
|
|
|
|
if (pixelFormat.bytesPerPixel == 2)
|
|
*((uint16 *)dst) = pixelFormat.RGBToColor(r, g, b);
|
|
else
|
|
*((uint32 *)dst) = pixelFormat.RGBToColor(r, g, b);
|
|
|
|
dst += pixelFormat.bytesPerPixel;
|
|
}
|
|
|
|
bmpStream->skip(extraDataLength);
|
|
dst -= surface->pitch * 2;
|
|
}
|
|
}
|
|
|
|
delete bmpStream;
|
|
|
|
return new ImageData(surface, palData);
|
|
}
|
|
|
|
ImageData *OldMohawkBitmap::decodeImage(Common::SeekableReadStream *stream) {
|
|
Common::SeekableSubReadStreamEndian *endianStream = (Common::SeekableSubReadStreamEndian *)stream;
|
|
|
|
// The format part is just a guess at this point. Note that the width and height roles have been reversed!
|
|
|
|
_header.height = endianStream->readUint16() & 0x3FF;
|
|
_header.width = endianStream->readUint16() & 0x3FF;
|
|
_header.bytesPerRow = endianStream->readUint16() & 0x3FE;
|
|
_header.format = endianStream->readUint16();
|
|
|
|
debug(2, "Decoding Old Mohawk Bitmap (%dx%d, %04x Format)", _header.width, _header.height, _header.format);
|
|
|
|
warning("Unhandled old Mohawk Bitmap decoding");
|
|
|
|
delete stream;
|
|
return new ImageData(NULL, NULL);
|
|
}
|
|
|
|
} // End of namespace Mohawk
|