mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 21:59:17 +00:00
546 lines
14 KiB
C++
546 lines
14 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.
|
|
*
|
|
*/
|
|
|
|
// QuickTime RLE Decoder
|
|
// Based off ffmpeg's QuickTime RLE decoder (written by Mike Melanson)
|
|
|
|
#include "image/codecs/qtrle.h"
|
|
|
|
#include "common/debug.h"
|
|
#include "common/scummsys.h"
|
|
#include "common/stream.h"
|
|
#include "common/system.h"
|
|
#include "common/textconsole.h"
|
|
#include "graphics/colormasks.h"
|
|
#include "graphics/surface.h"
|
|
|
|
namespace Image {
|
|
|
|
QTRLEDecoder::QTRLEDecoder(uint16 width, uint16 height, byte bitsPerPixel) : Codec() {
|
|
_bitsPerPixel = bitsPerPixel;
|
|
_ditherPalette = 0;
|
|
_width = width;
|
|
_height = height;
|
|
_surface = 0;
|
|
_dirtyPalette = false;
|
|
_colorMap = 0;
|
|
|
|
// We need to ensure the width is a multiple of 4
|
|
_paddedWidth = width;
|
|
uint16 wMod = width % 4;
|
|
if (wMod != 0)
|
|
_paddedWidth += 4 - wMod;
|
|
}
|
|
|
|
QTRLEDecoder::~QTRLEDecoder() {
|
|
if (_surface) {
|
|
_surface->free();
|
|
delete _surface;
|
|
}
|
|
|
|
delete[] _colorMap;
|
|
delete[] _ditherPalette;
|
|
}
|
|
|
|
#define CHECK_STREAM_PTR(n) \
|
|
do { \
|
|
if ((stream.pos() + n) > stream.size()) { \
|
|
warning("QTRLE Problem: stream out of bounds (%d > %d)", stream.pos() + n, stream.size()); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define CHECK_PIXEL_PTR(n) \
|
|
do { \
|
|
if ((int32)pixelPtr + n > (int)_paddedWidth * _surface->h) { \
|
|
warning("QTRLE Problem: pixel ptr = %d, pixel limit = %d", pixelPtr + n, _paddedWidth * _surface->h); \
|
|
return; \
|
|
} \
|
|
} while (0)
|
|
|
|
void QTRLEDecoder::decode1(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
byte *rgb = (byte *)_surface->getPixels();
|
|
|
|
while (linesToChange) {
|
|
CHECK_STREAM_PTR(2);
|
|
byte skip = stream.readByte();
|
|
int8 rleCode = stream.readSByte();
|
|
|
|
if (rleCode == 0)
|
|
break;
|
|
|
|
if (skip & 0x80) {
|
|
linesToChange--;
|
|
rowPtr += _paddedWidth;
|
|
pixelPtr = rowPtr + 2 * (skip & 0x7f);
|
|
} else
|
|
pixelPtr += 2 * skip;
|
|
|
|
if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
// get the next 2 bytes from the stream, treat them as groups of 8 pixels, and output them rleCode times */
|
|
CHECK_STREAM_PTR(2);
|
|
byte pi0 = stream.readByte();
|
|
byte pi1 = stream.readByte();
|
|
CHECK_PIXEL_PTR(rleCode * 2);
|
|
|
|
while (rleCode--) {
|
|
rgb[pixelPtr++] = pi0;
|
|
rgb[pixelPtr++] = pi1;
|
|
}
|
|
} else {
|
|
// copy the same pixel directly to output 2 times
|
|
rleCode *= 2;
|
|
CHECK_STREAM_PTR(rleCode);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = stream.readByte();
|
|
}
|
|
}
|
|
}
|
|
|
|
void QTRLEDecoder::decode2_4(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange, byte bpp) {
|
|
uint32 pixelPtr = 0;
|
|
byte *rgb = (byte *)_surface->getPixels();
|
|
byte numPixels = (bpp == 4) ? 8 : 16;
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
pixelPtr = rowPtr + (numPixels * (stream.readByte() - 1));
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += (numPixels * (stream.readByte() - 1));
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
|
|
// get the next 4 bytes from the stream, treat them as palette indices, and output them rleCode times */
|
|
CHECK_STREAM_PTR(4);
|
|
|
|
byte pi[16]; // 16 palette indices
|
|
|
|
for (int8 i = numPixels - 1; i >= 0; i--) {
|
|
pi[numPixels - 1 - i] = (stream.readByte() >> ((i * bpp) & 0x07)) & ((1 << bpp) - 1);
|
|
|
|
if ((i & ((numPixels >> 2) - 1)) == 0)
|
|
stream.readByte();
|
|
}
|
|
|
|
CHECK_PIXEL_PTR(rleCode * numPixels);
|
|
|
|
while (rleCode--)
|
|
for (byte i = 0; i < numPixels; i++)
|
|
rgb[pixelPtr++] = pi[i];
|
|
} else {
|
|
// copy the same pixel directly to output 4 times
|
|
rleCode *= 4;
|
|
CHECK_STREAM_PTR(rleCode);
|
|
CHECK_PIXEL_PTR(rleCode * (numPixels >> 2));
|
|
|
|
while (rleCode--) {
|
|
byte temp = stream.readByte();
|
|
if (bpp == 4) {
|
|
rgb[pixelPtr++] = (temp >> 4) & 0x0f;
|
|
rgb[pixelPtr++] = temp & 0x0f;
|
|
} else {
|
|
rgb[pixelPtr++] = (temp >> 6) & 0x03;
|
|
rgb[pixelPtr++] = (temp >> 4) & 0x03;
|
|
rgb[pixelPtr++] = (temp >> 2) & 0x03;
|
|
rgb[pixelPtr++] = temp & 0x03;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
}
|
|
}
|
|
|
|
void QTRLEDecoder::decode8(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
byte *rgb = (byte *)_surface->getPixels();
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
pixelPtr = rowPtr + 4 * (stream.readByte() - 1);
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += 4 * (stream.readByte() - 1);
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
|
|
// get the next 4 bytes from the stream, treat them as palette indices, and output them rleCode times
|
|
CHECK_STREAM_PTR(4);
|
|
|
|
byte pi[4]; // 4 palette indexes
|
|
|
|
for (byte i = 0; i < 4; i++)
|
|
pi[i] = stream.readByte();
|
|
|
|
CHECK_PIXEL_PTR(rleCode * 4);
|
|
|
|
while (rleCode--)
|
|
for (byte i = 0; i < 4; i++)
|
|
rgb[pixelPtr++] = pi[i];
|
|
} else {
|
|
// copy the same pixel directly to output 4 times
|
|
rleCode *= 4;
|
|
CHECK_STREAM_PTR(rleCode);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = stream.readByte();
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
}
|
|
}
|
|
|
|
void QTRLEDecoder::decode16(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
uint16 *rgb = (uint16 *)_surface->getPixels();
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
pixelPtr = rowPtr + stream.readByte() - 1;
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += stream.readByte() - 1;
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
CHECK_STREAM_PTR(2);
|
|
|
|
uint16 rgb16 = stream.readUint16BE();
|
|
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = rgb16;
|
|
} else {
|
|
CHECK_STREAM_PTR(rleCode * 2);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
// copy pixels directly to output
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = stream.readUint16BE();
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
}
|
|
}
|
|
|
|
void QTRLEDecoder::decode24(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
uint32 *rgb = (uint32 *)_surface->getPixels();
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
pixelPtr = rowPtr + stream.readByte() - 1;
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += stream.readByte() - 1;
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
|
|
CHECK_STREAM_PTR(3);
|
|
|
|
byte r = stream.readByte();
|
|
byte g = stream.readByte();
|
|
byte b = stream.readByte();
|
|
uint32 color = _surface->format.RGBToColor(r, g, b);
|
|
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = color;
|
|
} else {
|
|
CHECK_STREAM_PTR(rleCode * 3);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
// copy pixels directly to output
|
|
while (rleCode--) {
|
|
byte r = stream.readByte();
|
|
byte g = stream.readByte();
|
|
byte b = stream.readByte();
|
|
rgb[pixelPtr++] = _surface->format.RGBToColor(r, g, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
|
|
inline uint16 readDitherColor24(Common::ReadStream &stream) {
|
|
uint16 color = (stream.readByte() & 0xF8) << 6;
|
|
color |= (stream.readByte() & 0xF8) << 1;
|
|
color |= stream.readByte() >> 4;
|
|
return color;
|
|
}
|
|
|
|
} // End of anonymous namespace
|
|
|
|
void QTRLEDecoder::dither24(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
byte *output = (byte *)_surface->getPixels();
|
|
|
|
static const uint16 colorTableOffsets[] = { 0x0000, 0xC000, 0x4000, 0x8000 };
|
|
|
|
// clone2727 thinks this should be startLine & 3, but the original definitely
|
|
// isn't doing this. Unless startLine & 3 is always 0? Kinda defeats the
|
|
// purpose of the compression then.
|
|
byte curColorTableOffset = 0;
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
|
|
byte rowOffset = stream.readByte() - 1;
|
|
pixelPtr = rowPtr + rowOffset;
|
|
uint16 colorTableOffset = colorTableOffsets[curColorTableOffset] + (rowOffset << 14);
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += stream.readByte() - 1;
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
|
|
CHECK_STREAM_PTR(3);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
uint16 color = readDitherColor24(stream);
|
|
|
|
while (rleCode--) {
|
|
output[pixelPtr++] = _colorMap[colorTableOffset + color];
|
|
colorTableOffset += 0x4000;
|
|
}
|
|
} else {
|
|
CHECK_STREAM_PTR(rleCode * 3);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
// copy pixels directly to output
|
|
while (rleCode--) {
|
|
uint16 color = readDitherColor24(stream);
|
|
output[pixelPtr++] = _colorMap[colorTableOffset + color];
|
|
colorTableOffset += 0x4000;
|
|
}
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
curColorTableOffset = (curColorTableOffset + 1) & 3;
|
|
}
|
|
}
|
|
|
|
void QTRLEDecoder::decode32(Common::SeekableReadStream &stream, uint32 rowPtr, uint32 linesToChange) {
|
|
uint32 pixelPtr = 0;
|
|
uint32 *rgb = (uint32 *)_surface->getPixels();
|
|
|
|
while (linesToChange--) {
|
|
CHECK_STREAM_PTR(2);
|
|
pixelPtr = rowPtr + stream.readByte() - 1;
|
|
|
|
for (int8 rleCode = stream.readSByte(); rleCode != -1; rleCode = stream.readSByte()) {
|
|
if (rleCode == 0) {
|
|
// there's another skip code in the stream
|
|
CHECK_STREAM_PTR(1);
|
|
pixelPtr += stream.readByte() - 1;
|
|
} else if (rleCode < 0) {
|
|
// decode the run length code
|
|
rleCode = -rleCode;
|
|
|
|
CHECK_STREAM_PTR(4);
|
|
|
|
byte a = stream.readByte();
|
|
byte r = stream.readByte();
|
|
byte g = stream.readByte();
|
|
byte b = stream.readByte();
|
|
uint32 color = _surface->format.ARGBToColor(a, r, g, b);
|
|
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
while (rleCode--)
|
|
rgb[pixelPtr++] = color;
|
|
} else {
|
|
CHECK_STREAM_PTR(rleCode * 4);
|
|
CHECK_PIXEL_PTR(rleCode);
|
|
|
|
// copy pixels directly to output
|
|
while (rleCode--) {
|
|
byte a = stream.readByte();
|
|
byte r = stream.readByte();
|
|
byte g = stream.readByte();
|
|
byte b = stream.readByte();
|
|
rgb[pixelPtr++] = _surface->format.ARGBToColor(a, r, g, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
rowPtr += _paddedWidth;
|
|
}
|
|
}
|
|
|
|
const Graphics::Surface *QTRLEDecoder::decodeFrame(Common::SeekableReadStream &stream) {
|
|
if (!_surface)
|
|
createSurface();
|
|
|
|
uint16 startLine = 0;
|
|
uint16 height = _height;
|
|
|
|
// check if this frame is even supposed to change
|
|
if (stream.size() < 8)
|
|
return _surface;
|
|
|
|
// start after the chunk size
|
|
stream.readUint32BE();
|
|
|
|
// fetch the header
|
|
uint16 header = stream.readUint16BE();
|
|
|
|
// if a header is present, fetch additional decoding parameters
|
|
if (header & 8) {
|
|
if (stream.size() < 14)
|
|
return _surface;
|
|
|
|
startLine = stream.readUint16BE();
|
|
stream.readUint16BE(); // Unknown
|
|
height = stream.readUint16BE();
|
|
stream.readUint16BE(); // Unknown
|
|
}
|
|
|
|
uint32 rowPtr = _paddedWidth * startLine;
|
|
|
|
switch (_bitsPerPixel) {
|
|
case 1:
|
|
case 33:
|
|
decode1(stream, rowPtr, height);
|
|
break;
|
|
case 2:
|
|
case 34:
|
|
decode2_4(stream, rowPtr, height, 2);
|
|
break;
|
|
case 4:
|
|
case 36:
|
|
decode2_4(stream, rowPtr, height, 4);
|
|
break;
|
|
case 8:
|
|
case 40:
|
|
decode8(stream, rowPtr, height);
|
|
break;
|
|
case 16:
|
|
decode16(stream, rowPtr, height);
|
|
break;
|
|
case 24:
|
|
if (_ditherPalette)
|
|
dither24(stream, rowPtr, height);
|
|
else
|
|
decode24(stream, rowPtr, height);
|
|
break;
|
|
case 32:
|
|
decode32(stream, rowPtr, height);
|
|
break;
|
|
default:
|
|
error("Unsupported QTRLE bits per pixel %d", _bitsPerPixel);
|
|
}
|
|
|
|
return _surface;
|
|
}
|
|
|
|
Graphics::PixelFormat QTRLEDecoder::getPixelFormat() const {
|
|
if (_ditherPalette)
|
|
return Graphics::PixelFormat::createFormatCLUT8();
|
|
|
|
switch (_bitsPerPixel) {
|
|
case 1:
|
|
case 33:
|
|
case 2:
|
|
case 34:
|
|
case 4:
|
|
case 36:
|
|
case 8:
|
|
case 40:
|
|
return Graphics::PixelFormat::createFormatCLUT8();
|
|
case 16:
|
|
return Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0);
|
|
case 24:
|
|
case 32:
|
|
return Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24);
|
|
default:
|
|
error("Unsupported QTRLE bits per pixel %d", _bitsPerPixel);
|
|
}
|
|
|
|
return Graphics::PixelFormat();
|
|
}
|
|
|
|
bool QTRLEDecoder::canDither(DitherType type) const {
|
|
// Only 24-bit dithering is implemented at the moment
|
|
return type == kDitherTypeQT && _bitsPerPixel == 24;
|
|
}
|
|
|
|
void QTRLEDecoder::setDither(DitherType type, const byte *palette) {
|
|
assert(canDither(type));
|
|
|
|
_ditherPalette = new byte[256 * 3];
|
|
memcpy(_ditherPalette, palette, 256 * 3);
|
|
_dirtyPalette = true;
|
|
|
|
delete[] _colorMap;
|
|
_colorMap = createQuickTimeDitherTable(palette, 256);
|
|
}
|
|
|
|
void QTRLEDecoder::createSurface() {
|
|
if (_surface) {
|
|
_surface->free();
|
|
delete _surface;
|
|
}
|
|
|
|
_surface = new Graphics::Surface();
|
|
_surface->create(_paddedWidth, _height, getPixelFormat());
|
|
_surface->w = _width;
|
|
}
|
|
|
|
} // End of namespace Image
|