byte *ScummEngine_v71he::findWrappedBlock(uint32 tag, byte *ptr, int state, bool errorFlag) {
if (READ_BE_UINT32(ptr) == MKID_BE('MULT')) {
byte *offs, *wrap;
uint32 size;
wrap = heFindResource(MKID_BE('WRAP'), ptr);
if (wrap == NULL)
return NULL;
offs = heFindResourceData(MKID_BE('OFFS'), wrap);
if (offs == NULL)
return NULL;
size = getResourceDataSize(offs) / 4;
assert((uint32)state <= (uint32)size);
offs += READ_LE_UINT32(offs + state * sizeof(uint32));
offs = heFindResourceData(tag, offs - 8);
if (offs)
return offs;
offs = heFindResourceData(MKID_BE('DEFA'), ptr);
if (offs == NULL)
return NULL;
return heFindResourceData(tag, offs - 8);
} else {
return heFindResourceData(tag, ptr);
}
}
byte *findSoundTag(uint32 tag, byte *ptr) {
byte *endPtr;
uint32 offset, size;
if (READ_BE_UINT32(ptr) == MKID_BE('WSOU')) {
ptr += 8;
}
if (READ_BE_UINT32(ptr) != MKID_BE('RIFF'))
return NULL;
endPtr = (ptr + 12);
size = READ_LE_UINT32(ptr + 4);
while (endPtr < ptr + size) {
offset = READ_LE_UINT32(endPtr + 4);
if (offset <= 0)
error("Illegal chunk length - %d bytes.", offset);
if (offset > size)
error("Chunk extends beyond file end - %d versus %d.", offset, size);
if (READ_BE_UINT32(endPtr) == tag)
return endPtr;
endPtr = endPtr + offset + 8;
}
return NULL;
}
Sound::AudioStream *QuickTimeDecoder::AudioSampleDesc::createAudioStream(Common::SeekableReadStream *stream) const {
if (!stream)
return 0;
if (_codec) {
// If we've loaded a codec, make sure we use first
Sound::AudioStream *audioStream = _codec->decodeFrame(*stream);
delete stream;
return audioStream;
} else if (_codecTag == MKID_BE('twos') || _codecTag == MKID_BE('raw ')) {
// Standard PCM
uint16 flags = 0;
if (_codecTag == MKID_BE('raw '))
flags |= Sound::FLAG_UNSIGNED;
if (_bitsPerSample == 16)
flags |= Sound::FLAG_16BITS;
return Sound::makePCMStream(stream, _sampleRate, flags, _channels);
} else if (_codecTag == MKID_BE('ima4')) {
// QuickTime IMA ADPCM
return Sound::makeADPCMStream(stream, true, stream->size(), Sound::kADPCMApple, _sampleRate, _channels, 34);
}
return 0;
}
int QuickTimeDecoder::readHDLR(Atom atom) {
Track *track = _tracks.back();
_fd->readByte(); // version
_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
// component type
/* uint32 ctype = */ _fd->readUint32BE();
uint32 type = _fd->readUint32BE(); // component subtype
if (type == MKID_BE('vide'))
track->codecType = CODEC_TYPE_VIDEO;
else if (type == MKID_BE('soun'))
track->codecType = CODEC_TYPE_AUDIO;
_fd->readUint32BE(); // component manufacture
_fd->readUint32BE(); // component flags
_fd->readUint32BE(); // component flags mask
if (atom.size <= 24)
return 0; // nothing left to read
// .mov: PASCAL string
byte len = _fd->readByte();
_fd->seek(len, SEEK_CUR);
_fd->seek(atom.size - (_fd->pos() - atom.offset), SEEK_CUR);
return 0;
}
void QuickTimeDecoder::VideoSampleDesc::initCodec(Graphics::Surface &surface) {
if (_codecTag == MKID_BE('mp4v')) {
Common::UString videoType;
// Parse the object type
switch (_parentTrack->objectTypeMP4) {
case 0x20:
videoType = "h.263";
_videoCodec = new H263Codec(_parentTrack->width, _parentTrack->height);
if (_parentTrack->extraData)
_videoCodec->decodeFrame(surface, *_parentTrack->extraData);
break;
default:
videoType = "Unknown";
break;
}
if (!_videoCodec)
warning("MPEG-4 Video (%s) not yet supported", videoType.c_str());
} else if (_codecTag == MKID_BE('SVQ3')) {
// TODO: Sorenson Video 3
warning("Sorenson Video 3 not yet supported");
} else {
warning("Unsupported codec \'%s\'", tag2str(_codecTag));
}
}
bool CUP_Player::parseNextHeaderTag(Common::SeekableReadStream &dataStream) {
uint32 tag = dataStream.readUint32BE();
uint32 size = dataStream.readUint32BE() - 8;
if (dataStream.eos())
return false;
uint32 next = dataStream.pos() + size;
debug(1, "New header tag %s %d dataSize %d", tag2str(tag), size, _dataSize);
switch (tag) {
case MKID_BE('HEAD'):
handleHEAD(dataStream, size);
break;
case MKID_BE('SFXB'):
handleSFXB(dataStream, size);
break;
case MKID_BE('RGBS'):
handleRGBS(dataStream, size);
break;
case MKID_BE('DATA'):
_dataSize = size;
return false;
case MKID_BE('GFXB'):
// this is never triggered
default:
warning("Unhandled tag %s", tag2str(tag));
break;
}
dataStream.seek(next);
return true;
}
int QuickTimeDecoder::readCMOV(MOVatom atom) {
#ifdef USE_ZLIB
// Read in the dcom atom
_fd->readUint32BE();
if (_fd->readUint32BE() != MKID_BE('dcom'))
return -1;
if (_fd->readUint32BE() != MKID_BE('zlib')) {
warning("Unknown cmov compression type");
return -1;
}
// Read in the cmvd atom
uint32 compressedSize = _fd->readUint32BE() - 12;
if (_fd->readUint32BE() != MKID_BE('cmvd'))
return -1;
uint32 uncompressedSize = _fd->readUint32BE();
// Read in data
byte *compressedData = (byte *)malloc(compressedSize);
_fd->read(compressedData, compressedSize);
// Create uncompressed stream
byte *uncompressedData = (byte *)malloc(uncompressedSize);
// Uncompress the data
unsigned long dstLen = uncompressedSize;
if (!Common::uncompress(uncompressedData, &dstLen, compressedData, compressedSize)) {
warning ("Could not uncompress cmov chunk");
free(compressedData);
free(uncompressedData);
return -1;
}
// Load data into a new MemoryReadStream and assign _fd to be that
Common::SeekableReadStream *oldStream = _fd;
_fd = new Common::MemoryReadStream(uncompressedData, uncompressedSize, DisposeAfterUse::YES);
// Read the contents of the uncompressed data
MOVatom a = { MKID_BE('moov'), 0, uncompressedSize };
int err = readDefault(a);
// Assign the file handle back to the original handle
free(compressedData);
delete _fd;
_fd = oldStream;
return err;
#else
warning ("zlib not found, cannot read QuickTime cmov atom");
return -1;
#endif
}
Codec *QuickTimeDecoder::createCodec(uint32 codecTag, byte bitsPerPixel) {
if (codecTag == MKID_BE('cvid')) {
// Cinepak: As used by most Myst and all Riven videos as well as some Myst ME videos. "The Chief" videos also use this.
return new CinepakDecoder(bitsPerPixel);
} else if (codecTag == MKID_BE('rpza')) {
// Apple Video ("Road Pizza"): Used by some Myst videos.
return new RPZADecoder(getWidth(), getHeight());
} else if (codecTag == MKID_BE('rle ')) {
// QuickTime RLE: Used by some Myst ME videos.
return new QTRLEDecoder(getWidth(), getHeight(), bitsPerPixel);
} else if (codecTag == MKID_BE('smc ')) {
// Apple SMC: Used by some Myst videos.
return new SMCDecoder(getWidth(), getHeight());
} else if (codecTag == MKID_BE('SVQ1')) {
// Sorenson Video 1: Used by some Myst ME videos.
warning("Sorenson Video 1 not yet supported");
} else if (codecTag == MKID_BE('SVQ3')) {
// Sorenson Video 3: Used by some Myst ME videos.
warning("Sorenson Video 3 not yet supported");
} else if (codecTag == MKID_BE('jpeg')) {
// Motion JPEG: Used by some Myst ME 10th Anniversary videos.
return new JPEGDecoder();
} else if (codecTag == MKID_BE('QkBk')) {
// CDToons: Used by most of the Broderbund games.
return new CDToonsDecoder(getWidth(), getHeight());
} else {
warning("Unsupported codec \'%s\'", tag2str(codecTag));
}
return NULL;
}
void MoviePlayer::handleNextFrame() {
if (_fd.isOpen() == false) {
return;
}
VirtScreen *pvs = &_vm->virtscr[kMainVirtScreen];
uint8 *dst;
decodeFrame();
if (_flags & 2) {
uint8 *dstPtr = _vm->getResourceAddress(rtImage, _wizResNum);
assert(dstPtr);
dst = _vm->findWrappedBlock(MKID_BE('WIZD'), dstPtr, 0, 0);
assert(dst);
copyFrame(dst, 0, 0);
} else if (_flags & 1) {
dst = pvs->getBackPixels(0, 0);
copyFrame(dst, 0, 0);
Common::Rect imageRect(_width, _height);
_vm->gdi.copyVirtScreenBuffers(imageRect);
} else {
dst = pvs->getPixels(0, 0);
copyFrame(dst, 0, 0);
_vm->markRectAsDirty(kMainVirtScreen, 0, 0, _width, _height);
}
_frameNum++;
if (_frameNum == _framesCount) {
close();
}
}
bool BundleMgr::loadCompTable(int32 index) {
_file->seek(_bundleTable[index].offset, SEEK_SET);
uint32 tag = _file->readUint32BE();
_numCompItems = _file->readUint32BE();
assert(_numCompItems > 0);
_file->seek(8, SEEK_CUR);
if (tag != MKID_BE('COMP')) {
error("BundleMgr::loadCompTable() Compressed sound %d invalid (%s)", index, tag2str(tag));
return false;
}
_compTable = (CompTable *)malloc(sizeof(CompTable) * _numCompItems);
assert(_compTable);
int32 maxSize = 0;
for (int i = 0; i < _numCompItems; i++) {
_compTable[i].offset = _file->readUint32BE();
_compTable[i].size = _file->readUint32BE();
_compTable[i].codec = _file->readUint32BE();
_file->seek(4, SEEK_CUR);
if (_compTable[i].size > maxSize)
maxSize = _compTable[i].size;
}
// CMI hack: one more byte at the end of input buffer
_compInput = (byte *)malloc(maxSize + 1);
assert(_compInput);
return true;
}
void MoviePlayer::handleNextFrame() {
if (!isVideoLoaded())
return;
VirtScreen *pvs = &_vm->_virtscr[kMainVirtScreen];
if (_flags & 2) {
uint8 *dstPtr = _vm->getResourceAddress(rtImage, _wizResNum);
assert(dstPtr);
uint8 *dst = _vm->findWrappedBlock(MKID_BE('WIZD'), dstPtr, 0, 0);
assert(dst);
copyFrameToBuffer(dst, kDstResource, 0, 0, _vm->_screenWidth * _vm->_bytesPerPixel);
} else if (_flags & 1) {
copyFrameToBuffer(pvs->getBackPixels(0, 0), kDstScreen, 0, 0, pvs->pitch);
Common::Rect imageRect(getWidth(), getHeight());
_vm->restoreBackgroundHE(imageRect);
} else {
copyFrameToBuffer(pvs->getPixels(0, 0), kDstScreen, 0, 0, pvs->pitch);
Common::Rect imageRect(getWidth(), getHeight());
_vm->markRectAsDirty(kMainVirtScreen, imageRect);
}
if (endOfVideo())
close();
}
void MoviePlayerDXA::startSound() {
uint32 offset, size;
if (getSoundTag() == MKID_BE('WAVE')) {
size = _fileStream->readUint32BE();
if (_sequenceNum) {
Common::File in;
_fileStream->seek(size, SEEK_CUR);
in.open((const char *)"audio.wav");
if (!in.isOpen()) {
error("Can't read offset file 'audio.wav'");
}
in.seek(_sequenceNum * 8, SEEK_SET);
offset = in.readUint32LE();
size = in.readUint32LE();
in.seek(offset, SEEK_SET);
_bgSoundStream = Audio::makeWAVStream(in.readStream(size), DisposeAfterUse::YES);
in.close();
} else {
_bgSoundStream = Audio::makeWAVStream(_fileStream->readStream(size), DisposeAfterUse::YES);
}
} else {
_bgSoundStream = Audio::SeekableAudioStream::openStreamFile(baseName);
}
if (_bgSoundStream != NULL) {
_vm->_mixer->stopHandle(_bgSound);
_vm->_mixer->playStream(Audio::Mixer::kSFXSoundType, &_bgSound, _bgSoundStream);
}
}
Localizer::Localizer() {
Common::File f;
const char *namesToTry[] = { "GRIM.TAB", "Grim.tab", "grim.tab" };
if (g_grim->getGameFlags() & GF_DEMO)
return;
for (unsigned i = 0; i < sizeof(namesToTry) / sizeof(namesToTry[0]); i++) {
f.open(namesToTry[i]);
if (f.isOpen())
break;
}
if (!f.isOpen()) {
error("Localizer::Localizer: Unable to find localization information (grim.tab)");
return;
}
long filesize = f.size();
// Read in the data
char *data = new char[filesize + 1];
f.read(data, filesize);
data[filesize] = '\0';
f.close();
if (filesize < 4 || READ_BE_UINT32(data) != MKID_BE('RCNE'))
error("Invalid magic reading grim.tab");
// Decode the data
for (int i = 4; i < filesize; i++)
data[i] ^= '\xdd';
char *nextline;
for (char *line = data + 4; line != NULL && *line != '\0'; line = nextline) {
nextline = strchr(line, '\n');
if (nextline) {
if (nextline[-1] == '\r')
nextline[-1] = '\0';
nextline++;
}
char *tab = strchr(line, '\t');
if (!tab)
continue;
LocaleEntry entry;
entry.text = new char[(tab - line) + 1];
strncpy(entry.text, line, tab - line);
entry.text[tab - line] = '\0';
entry.translation = new char[strlen(tab + 1) + 1];
strcpy(entry.translation, tab + 1);
_entries.push_back(entry);
}
qsort(_entries.begin(), _entries.size(), sizeof(LocaleEntry), sortCallback);
delete[] data;
}
void CUP_Player::handleSFXB(Common::SeekableReadStream &dataStream, uint32 dataSize) {
if (dataSize > 16) { // WRAP and OFFS chunks
uint32 tag = dataStream.readUint32BE();
uint32 size = dataStream.readUint32BE();
if (tag == MKID_BE('WRAP')) {
tag = dataStream.readUint32BE();
size = dataStream.readUint32BE();
if (tag == MKID_BE('OFFS')) {
_sfxCount = (size - 8) / 4;
_sfxBuffer = (uint8 *)malloc(dataSize - 16);
if (_sfxBuffer) {
dataStream.read(_sfxBuffer, dataSize - 16);
}
}
}
}
}
bool SaudChannel::handleSubTags(int32 &offset) {
if (_tbufferSize - offset >= 8) {
uint32 type = READ_BE_UINT32(_tbuffer + offset);
uint32 size = READ_BE_UINT32(_tbuffer + offset + 4);
uint32 available_size = _tbufferSize - offset;
switch (type) {
case MKID_BE('STRK'):
_inData = false;
if (available_size >= (size + 8)) {
int32 subSize = READ_BE_UINT32((byte *)_tbuffer + offset + 4);
if (subSize != 14 && subSize != 10) {
error("STRK has an invalid size : %d", subSize);
}
} else
return false;
break;
case MKID_BE('SMRK'):
_inData = false;
if (available_size >= (size + 8))
_markReached = true;
else
return false;
break;
case MKID_BE('SHDR'):
_inData = false;
if (available_size >= (size + 8)) {
int32 subSize = READ_BE_UINT32((byte *)_tbuffer + offset + 4);
if (subSize != 4)
error("SHDR has an invalid size : %d", subSize);
} else
return false;
break;
case MKID_BE('SDAT'):
_inData = true;
_dataSize = size;
offset += 8;
return false;
default:
error("unknown Chunk in SAUD track : %s ", tag2str(type));
}
offset += size + 8;
return true;
}
return false;
}
bool PEResources::loadFromEXE(SeekableReadStream *stream) {
clear();
if (!stream)
return false;
if (stream->readUint16BE() != 'MZ')
return false;
stream->skip(58);
uint32 peOffset = stream->readUint32LE();
if (!peOffset || peOffset >= (uint32)stream->size())
return false;
stream->seek(peOffset);
if (stream->readUint32BE() != MKID_BE('PE\0\0'))
return false;
stream->skip(2);
uint16 sectionCount = stream->readUint16LE();
stream->skip(12);
uint16 optionalHeaderSize = stream->readUint16LE();
stream->skip(optionalHeaderSize + 2);
// Read in all the sections
for (uint16 i = 0; i < sectionCount; i++) {
char sectionName[9];
stream->read(sectionName, 8);
sectionName[8] = 0;
Section section;
stream->skip(4);
section.virtualAddress = stream->readUint32LE();
section.size = stream->readUint32LE();
section.offset = stream->readUint32LE();
stream->skip(16);
_sections[sectionName] = section;
}
// Currently, we require loading a resource section
if (_sections.find(".rsrc") == _sections.end()) {
clear();
return false;
}
_exe = stream;
Section &resSection = _sections[".rsrc"];
parseResourceLevel(resSection, resSection.offset, 0);
return true;
}
Model::Model(const char *filename, const char *data, int len, const CMap *cmap) :
_numMaterials(0), _numGeosets(0) {
_fname = filename;
if (len >= 4 && READ_BE_UINT32(data) == MKID_BE('LDOM'))
loadBinary(data, cmap);
else {
TextSplitter ts(data, len);
loadText(&ts, cmap);
}
}
void QuickTimeDecoder::AudioSampleDesc::initCodec() {
delete _codec; _codec = 0;
switch (_codecTag) {
case MKID_BE('mp4a'):
if (_parentTrack->objectTypeMP4 == 0x40)
_codec = Sound::makeAACDecoder(_parentTrack->extraData);
break;
default:
break;
}
}
int QuickTimeDecoder::readHDLR(MOVatom atom) {
MOVStreamContext *st = _streams[_numStreams - 1];
_fd->readByte(); // version
_fd->readByte(); _fd->readByte(); _fd->readByte(); // flags
// component type
uint32 ctype = _fd->readUint32LE();
uint32 type = _fd->readUint32BE(); // component subtype
debug(0, "ctype= %s (0x%08lx)", tag2str(ctype), (long)ctype);
debug(0, "stype= %s", tag2str(type));
if(ctype == MKID_BE('mhlr')) // MOV
debug(0, "MOV detected");
else if(ctype == 0) {
warning("MP4 streams are not supported");
return -1;
}
if (type == MKID_BE('vide'))
st->codec_type = CODEC_TYPE_VIDEO;
else if (type == MKID_BE('soun'))
st->codec_type = CODEC_TYPE_AUDIO;
_fd->readUint32BE(); // component manufacture
_fd->readUint32BE(); // component flags
_fd->readUint32BE(); // component flags mask
if (atom.size <= 24)
return 0; // nothing left to read
// .mov: PASCAL string
byte len = _fd->readByte();
_fd->seek(len, SEEK_CUR);
_fd->seek(atom.size - (_fd->pos() - atom.offset), SEEK_CUR);
return 0;
}
void CUP_Player::updateSfx() {
int lastSfxChannel = _lastSfxChannel;
for (int i = 0; i < _sfxQueuePos; ++i) {
const CUP_Sfx *sfx = &_sfxQueue[i];
if (sfx->num == -1) {
debug(1, "Stopping sound channel %d", _lastSfxChannel);
if (_lastSfxChannel != -1) {
_mixer->stopHandle(_sfxChannels[_lastSfxChannel].handle);
}
continue;
}
if ((sfx->flags & kSfxFlagRestart) != 0) {
for (int ch = 0; ch < kSfxChannels; ++ch) {
if (_mixer->isSoundHandleActive(_sfxChannels[ch].handle) && _sfxChannels[ch].sfxNum == sfx->num) {
_mixer->stopHandle(_sfxChannels[ch].handle);
break;
}
}
}
CUP_SfxChannel *sfxChannel = 0;
for (int ch = 0; ch < kSfxChannels; ++ch) {
if (!_mixer->isSoundHandleActive(_sfxChannels[ch].handle)) {
lastSfxChannel = ch;
sfxChannel = &_sfxChannels[ch];
sfxChannel->sfxNum = sfx->num;
sfxChannel->flags = sfx->flags;
break;
}
}
if (sfxChannel) {
debug(1, "Start sound %d channel %d flags 0x%X", sfx->num, lastSfxChannel, sfx->flags);
int sfxIndex = sfxChannel->sfxNum - 1;
assert(sfxIndex >= 0 && sfxIndex < _sfxCount);
uint32 offset = READ_LE_UINT32(_sfxBuffer + sfxIndex * 4) - 8;
uint8 *soundData = _sfxBuffer + offset;
if (READ_BE_UINT32(soundData) == MKID_BE('DATA')) {
uint32 soundSize = READ_BE_UINT32(soundData + 4);
_mixer->playStream(Audio::Mixer::kSFXSoundType, &sfxChannel->handle,
Audio::makeLoopingAudioStream(
Audio::makeRawStream(soundData + 8, soundSize - 8,
11025, Audio::FLAG_UNSIGNED, DisposeAfterUse::NO),
(sfx->flags & kSfxFlagLoop) ? 0 : 1
)
);
}
} else {
warning("Unable to find a free channel to play sound %d", sfx->num);
}
}
_lastSfxChannel = lastSfxChannel;
_sfxQueuePos = 0;
}
bool QuickTimeDecoder::AudioSampleDesc::isAudioCodecSupported() const {
// Check if the codec is a supported codec
if (_codecTag == MKID_BE('twos') || _codecTag == MKID_BE('raw ') || _codecTag == MKID_BE('ima4'))
return true;
if (_codecTag == MKID_BE('mp4a')) {
Common::UString audioType;
switch (_parentTrack->objectTypeMP4) {
case 0x40:
return true;
default:
audioType = "Unknown";
break;
}
warning("No MPEG-4 audio (%s) support", audioType.c_str());
} else
warning("Audio Codec Not Supported: \'%s\'", tag2str(_codecTag));
return false;
}
void ActimagineDecoder::load() {
if (_vx->readUint32BE() != MKID_BE('VXDS'))
throw Common::Exception("Not a valid Actimagine video");
_vx->readUint32LE(); // header size?
_vx->readUint32LE(); // version? (0x100)
_vx->readUint32LE(); // unknown
_vx->readUint32LE(); // unknown
_vx->readUint32LE(); // unknown
uint32 sampleRate = _vx->readUint32LE(); // Oh yeah! I'm good at this!
throw Common::Exception("STUB: ActimagineDecoder::load(): Sample rate = %d", sampleRate);
}
bool QuickTimeDecoder::loadFile(const Common::String &filename) {
if (!_resFork->open(filename) || !_resFork->hasDataFork())
return false;
_foundMOOV = false;
_numStreams = 0;
_videoStreamIndex = _audioStreamIndex = -1;
_startTime = 0;
MOVatom atom = { 0, 0, 0xffffffff };
if (_resFork->hasResFork()) {
// Search for a 'moov' resource
Common::MacResIDArray idArray = _resFork->getResIDArray(MKID_BE('moov'));
if (!idArray.empty())
_fd = _resFork->getResource(MKID_BE('moov'), idArray[0]);
if (_fd) {
atom.size = _fd->size();
if (readDefault(atom) < 0 || !_foundMOOV)
return false;
}
delete _fd;
atom.type = 0;
atom.offset = 0;
atom.size = 0xffffffff;
}
_fd = _resFork->getDataFork();
if (readDefault(atom) < 0 || !_foundMOOV)
return false;
init();
return true;
}
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];
}
}
}
}
}
Common::InSaveFile *QueenEngine::readGameStateHeader(int slot, GameStateHeader *gsh) {
char name[20];
makeGameStateName(slot, name);
Common::InSaveFile *file = _saveFileMan->openForLoading(name);
if (file && file->readUint32BE() == MKID_BE('SCVM')) {
gsh->version = file->readUint32BE();
gsh->flags = file->readUint32BE();
gsh->dataSize = file->readUint32BE();
file->read(gsh->description, sizeof(gsh->description));
} else {
memset(gsh, 0, sizeof(GameStateHeader));
}
return file;
}
int ScummEngine_v72he::getSoundResourceSize(int id) {
const byte *ptr;
int offs, size;
if (id > _numSounds) {
if (!((SoundHE *)_sound)->getHEMusicDetails(id, offs, size)) {
debug(0, "getSoundResourceSize: musicID %d not found", id);
return 0;
}
} else {
ptr = getResourceAddress(rtSound, id);
if (!ptr)
return 0;
if (READ_BE_UINT32(ptr) == MKID_BE('RIFF')) {
byte flags;
int rate;
size = READ_BE_UINT32(ptr + 4);
Common::MemoryReadStream stream(ptr, size);
if (!Audio::loadWAVFromStream(stream, size, rate, flags)) {
error("getSoundResourceSize: Not a valid WAV file");
}
} else {
ptr += 8 + READ_BE_UINT32(ptr + 12);
if (READ_BE_UINT32(ptr) == MKID_BE('SBNG')) {
ptr += READ_BE_UINT32(ptr + 4);
}
assert(READ_BE_UINT32(ptr) == MKID_BE('SDAT'));
size = READ_BE_UINT32(ptr + 4) - 8;
}
}
return size;
}
bool CUP_Player::parseNextBlockTag(Common::SeekableReadStream &dataStream) {
uint32 tag = dataStream.readUint32BE();
uint32 size = dataStream.readUint32BE() - 8;
uint32 next = dataStream.pos() + size;
debug(1, "New block tag %s %d dataSize %d", tag2str(tag), size, _dataSize);
switch (tag) {
case MKID_BE('FRAM'):
handleFRAM(dataStream, size);
break;
case MKID_BE('LZSS'):
if (handleLZSS(dataStream, size) && _outLzssBufSize != 0) {
Common::MemoryReadStream memoryStream(_outLzssBufData, _outLzssBufSize);
parseNextBlockTag(memoryStream);
}
break;
case MKID_BE('RATE'):
handleRATE(dataStream, size);
break;
case MKID_BE('RGBS'):
handleRGBS(dataStream, size);
break;
case MKID_BE('SNDE'):
handleSNDE(dataStream, size);
break;
case MKID_BE('TOIL'):
handleTOIL(dataStream, size);
break;
case MKID_BE('SRLE'):
handleSRLE(dataStream, size);
break;
case MKID_BE('BLOK'):
_dataSize -= size + 8;
return false;
case MKID_BE('WRLE'):
// this is never triggered
default:
warning("Unhandled tag %s", tag2str(tag));
break;
}
dataStream.seek(next);
return true;
}
void Waypoint::load(const Aurora::GFFStruct &waypoint) {
Common::UString temp = waypoint.getString("TemplateResRef");
Aurora::GFFFile *utw = 0;
if (!temp.empty()) {
try {
utw = new Aurora::GFFFile(temp, Aurora::kFileTypeUTW, MKID_BE('UTW '));
} catch (...) {
delete utw;
}
}
load(waypoint, utw ? &utw->getTopLevel() : 0);
delete utw;
}
void GUI::load(const Common::UString &resref, float width, float height) {
_name = resref;
Aurora::GFFFile *gff = 0;
try {
gff = new Aurora::GFFFile(resref, Aurora::kFileTypeGUI, MKID_BE('GUI '));
loadWidget(gff->getTopLevel(), 0, width, height);
} catch (Common::Exception &e) {
delete gff;
e.add("Can't load GUI \"%s\"", resref.c_str());
throw;
}
delete gff;
}
Common::WriteStream *KyraEngine_v1::openSaveForWriting(const char *filename, const char *saveName, const Graphics::Surface *thumbnail) const {
if (shouldQuit())
return 0;
Common::WriteStream *out = 0;
if (!(out = _saveFileMan->openForSaving(filename))) {
warning("Can't create file '%s', game not saved", filename);
return 0;
}
// Savegame version
out->writeUint32BE(MKID_BE('WWSV'));
out->writeByte(_flags.gameID);
out->writeUint32BE(CURRENT_SAVE_VERSION);
out->write(saveName, strlen(saveName)+1);
if (_flags.isTalkie)
out->writeUint32BE(GF_TALKIE);
else if (_flags.platform == Common::kPlatformFMTowns || _flags.platform == Common::kPlatformPC98)
out->writeUint32BE(GF_FMTOWNS);
else
out->writeUint32BE(GF_FLOPPY);
if (out->err()) {
warning("Can't write file '%s'. (Disk full?)", filename);
delete out;
return 0;
}
Graphics::Surface *genThumbnail = 0;
if (!thumbnail)
thumbnail = genThumbnail = generateSaveThumbnail();
if (thumbnail)
Graphics::saveThumbnail(*out, *thumbnail);
else
Graphics::saveThumbnail(*out);
if (genThumbnail) {
genThumbnail->free();
delete genThumbnail;
}
return out;
}
