void MoviePlayer::decodeFrame() {
uint32 tag;
tag = _fd.readUint32BE();
if (tag == MKID_BE('CMAP')) {
uint8 rgb[768];
_fd.read(rgb, ARRAYSIZE(rgb));
_vm->setPaletteFromPtr(rgb, 256);
}
tag = _fd.readUint32BE();
if (tag == MKID_BE('FRAM')) {
uint8 type = _fd.readByte();
uint32 size = _fd.readUint32BE();
_fd.read(_frameBuffer2, size);
switch (type) {
case 2:
case 3:
decodeZlib(_frameBuffer2, size, _frameSize);
break;
default:
error("decodeFrame: Unknown compression type %d", type);
}
if (type == 2) {
memcpy(_frameBuffer1, _frameBuffer2, _frameSize);
} else {
for (int j = 0; j < _height; ++j) {
for (int i = 0; i < _width; ++i) {
const int offs = j * _width + i;
_frameBuffer1[offs] ^= _frameBuffer2[offs];
}
}
}
}
}
void DXADecoder::decode13(int size) {
#ifdef USE_ZLIB
uint8 *codeBuf, *dataBuf, *motBuf, *maskBuf;
if (_decompBuffer == NULL) {
_decompBuffer = (byte *)malloc(_decompBufferSize);
memset(_decompBuffer, 0, _decompBufferSize);
if (_decompBuffer == NULL)
error("Error allocating decomp buffer (size %u)", _decompBufferSize);
}
/* decompress the input data */
decodeZlib(_decompBuffer, size, _decompBufferSize);
memcpy(_frameBuffer2, _frameBuffer1, _frameSize);
int codeSize = _width * _curHeight / 16;
int dataSize, motSize;
dataSize = READ_BE_UINT32(&_decompBuffer[0]);
motSize = READ_BE_UINT32(&_decompBuffer[4]);
//maskSize = READ_BE_UINT32(&_decompBuffer[8]);
codeBuf = &_decompBuffer[12];
dataBuf = &codeBuf[codeSize];
motBuf = &dataBuf[dataSize];
maskBuf = &motBuf[motSize];
for (uint32 by = 0; by < _curHeight; by += BLOCKH) {
for (uint32 bx = 0; bx < _width; bx += BLOCKW) {
uint8 type = *codeBuf++;
uint8 *b2 = (uint8*)_frameBuffer1 + bx + by * _width;
switch (type) {
case 0:
break;
case 1: {
uint16 diffMap = READ_BE_UINT16(maskBuf);
maskBuf += 2;
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
if (diffMap & 0x8000) {
b2[xc] = *dataBuf++;
}
diffMap <<= 1;
}
b2 += _width;
}
break;
}
case 2: {
uint8 color = *dataBuf++;
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = color;
}
b2 += _width;
}
break;
}
case 3: {
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = *dataBuf++;
}
b2 += _width;
}
break;
}
case 4: {
uint8 mbyte = *motBuf++;
int mx = (mbyte >> 4) & 0x07;
if (mbyte & 0x80)
mx = -mx;
int my = mbyte & 0x07;
if (mbyte & 0x08)
my = -my;
uint8 *b1 = (uint8*)_frameBuffer2 + (bx+mx) + (by+my) * _width;
for (int yc = 0; yc < BLOCKH; yc++) {
memcpy(b2, b1, BLOCKW);
b1 += _width;
b2 += _width;
}
break;
}
case 8: {
static const int subX[4] = {0, 2, 0, 2};
static const int subY[4] = {0, 0, 2, 2};
uint8 subMask = *maskBuf++;
for (int subBlock = 0; subBlock < 4; subBlock++) {
int sx = bx + subX[subBlock], sy = by + subY[subBlock];
b2 = (uint8*)_frameBuffer1 + sx + sy * _width;
switch (subMask & 0xC0) {
// 00: skip
case 0x00:
break;
// 01: solid color
case 0x40: {
uint8 subColor = *dataBuf++;
for (int yc = 0; yc < BLOCKH / 2; yc++) {
for (int xc = 0; xc < BLOCKW / 2; xc++) {
b2[xc] = subColor;
}
b2 += _width;
}
break;
}
// 02: motion vector
case 0x80: {
uint8 mbyte = *motBuf++;
int mx = (mbyte >> 4) & 0x07;
if (mbyte & 0x80)
mx = -mx;
int my = mbyte & 0x07;
if (mbyte & 0x08)
my = -my;
uint8 *b1 = (uint8*)_frameBuffer2 + (sx+mx) + (sy+my) * _width;
for (int yc = 0; yc < BLOCKH / 2; yc++) {
memcpy(b2, b1, BLOCKW / 2);
b1 += _width;
b2 += _width;
}
break;
}
// 03: raw
case 0xC0:
for (int yc = 0; yc < BLOCKH / 2; yc++) {
for (int xc = 0; xc < BLOCKW / 2; xc++) {
b2[xc] = *dataBuf++;
}
b2 += _width;
}
break;
}
subMask <<= 2;
}
break;
}
case 32:
case 33:
case 34: {
int count = type - 30;
uint8 pixels[4];
memcpy(pixels, dataBuf, count);
dataBuf += count;
if (count == 2) {
uint16 code = READ_BE_UINT16(maskBuf);
maskBuf += 2;
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = pixels[code & 1];
code >>= 1;
}
b2 += _width;
}
} else {
uint32 code = READ_BE_UINT32(maskBuf);
maskBuf += 4;
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = pixels[code & 3];
code >>= 2;
}
b2 += _width;
}
}
break;
}
default:
error("decode13: Unknown type %d", type);
}
}
void DXADecoder::decode12(int size) {
#ifdef USE_ZLIB
if (_decompBuffer == NULL) {
_decompBuffer = (byte *)malloc(_decompBufferSize);
memset(_decompBuffer, 0, _decompBufferSize);
if (_decompBuffer == NULL)
error("Error allocating decomp buffer (size %u)", _decompBufferSize);
}
/* decompress the input data */
decodeZlib(_decompBuffer, size, _decompBufferSize);
byte *dat = _decompBuffer;
memcpy(_frameBuffer2, _frameBuffer1, _frameSize);
for (uint32 by = 0; by < _height; by += BLOCKH) {
for (uint32 bx = 0; bx < _width; bx += BLOCKW) {
byte type = *dat++;
byte *b2 = _frameBuffer1 + bx + by * _width;
switch (type) {
case 0:
break;
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 1: {
unsigned short diffMap;
if (type >= 10 && type <= 15) {
static const struct { uint8 sh1, sh2; } shiftTbl[6] = {
{0, 0}, {8, 0}, {8, 8}, {8, 4}, {4, 0}, {4, 4}
};
diffMap = ((*dat & 0xF0) << shiftTbl[type-10].sh1) |
((*dat & 0x0F) << shiftTbl[type-10].sh2);
dat++;
} else {
diffMap = *(unsigned short*)dat;
dat += 2;
}
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
if (diffMap & 0x8000) {
b2[xc] = *dat++;
}
diffMap <<= 1;
}
b2 += _width;
}
break;
}
case 2: {
byte color = *dat++;
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = color;
}
b2 += _width;
}
break;
}
case 3: {
for (int yc = 0; yc < BLOCKH; yc++) {
for (int xc = 0; xc < BLOCKW; xc++) {
b2[xc] = *dat++;
}
b2 += _width;
}
break;
}
case 4: {
byte mbyte = *dat++;
int mx = (mbyte >> 4) & 0x07;
if (mbyte & 0x80)
mx = -mx;
int my = mbyte & 0x07;
if (mbyte & 0x08)
my = -my;
byte *b1 = _frameBuffer2 + (bx+mx) + (by+my) * _width;
for (int yc = 0; yc < BLOCKH; yc++) {
memcpy(b2, b1, BLOCKW);
b1 += _width;
b2 += _width;
}
break;
}
case 5:
break;
default:
error("decode12: Unknown type %d", type);
}
}
}
#endif
}
