bool SaveContainer::write(Common::WriteStream &stream) const {
// Write the header
if (!_header.write(stream))
return false;
// Write the part count
stream.writeUint32LE(_partCount);
// Iterate over all parts
for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it) {
// Part doesn't actually exist => error
if (!*it)
return false;
// Write the part's size
stream.writeUint32LE((*it)->size);
}
if (!flushStream(stream))
return false;
// Iterate over all parts
for (PartConstIterator it = _parts.begin(); it != _parts.end(); ++it) {
Part * const &p = *it;
// Write the part
if (stream.write(p->data, p->size) != p->size)
return false;
}
return flushStream(stream);
}
static void
writeLogRecord (const char *record) {
if (logFile) {
lockStream(logFile);
{
TimeValue now;
char buffer[0X20];
size_t length;
unsigned int milliseconds;
getCurrentTime(&now);
length = formatSeconds(buffer, sizeof(buffer), "%Y-%m-%d@%H:%M:%S", now.seconds);
milliseconds = now.nanoseconds / NSECS_PER_MSEC;
fprintf(logFile, "%.*s.%03u ", (int)length, buffer, milliseconds);
}
{
char name[0X40];
size_t length = formatThreadName(name, sizeof(name));
if (length) fprintf(logFile, "[%s] ", name);
}
fputs(record, logFile);
fputc('\n', logFile);
flushStream(logFile);
unlockStream(logFile);
}
}
int mpegFlushStream (SceMpeg *mp,SceMpegStream *pStream){
int ret,*au,*str;
if ((ret = checkMpegLib (mp)))return ret;
waitSema(mp->sys[411]);
if ((au = checkAu ((void*)pStream->qStreamId, mp->sys, 1)) == (void*)-1){
signalSema (mp->sys[411]);
return 0x806101FE;
}
if (au[2] != -1){
au[3] = 0;
au[0] = -1;
au[1] = -1;
if ((str=pStream->m_pRAPICtrlStream) != (void*)-1){
str[3] = 0;
str[1] = -1;
str[0] = -1;
}
}
int tmp[2];
int* id = (int*)(tmp[0] << 3) + 0x00007594;//0x00009FCC
flushStream (id[1], &tmp[1] ,pStream->qStreamId);
pStream->m_iAuNum = 0x7FFF;
pStream->m_iPesPacketForwardSize = id[1];
pStream->m_iPesPacketForwardFlag = 1;
pStream->m_iPesPacketNum = 0;
pStream->m_iBoundarySize = id[0];
pStream->m_iAuSizeOfProceed = 0;
pStream->m_iGetAuMode &= -5;
pStream->m_iPayloadHeaderRemainderFlag = 0;
pStream->m_iPayloadHeaderRemainderSize = 0;
pStream->unk64 = 0;
return signalSema(mp->sys[411]);
}
//Runs StreamStop and flushStream low-level functions to flush out the streaming
//buffer. This function is useful for stopping streaming and clearing it after
//a Comm buffer overflow.
int doFlush(int socketFDA)
{
printf("Flushing stream.\n");
StreamStop(socketFDA, 0);
flushStream(socketFDA);
return 0;
}
bool SavePartVars::write(Common::WriteStream &stream) const {
if (!_header.write(stream))
return false;
if (stream.write(_data, _size) != _size)
return false;
return flushStream(stream);
}
bool SaveHeader::write(Common::WriteStream &stream) const {
stream.writeUint32BE(kID1);
stream.writeUint32BE(kID2);
stream.writeUint32BE(_type);
stream.writeUint32LE(_version);
stream.writeUint32LE(_size);
return flushStream(stream);
}
//////////////////////////////////////////////////////////////////////////
// Init
//////////////////////////////////////////////////////////////////////////
void SaveLoad::create(GameId id) {
initStream();
Common::Serializer ser(NULL, _savegame);
SavegameMainHeader header;
header.saveLoadWithSerializer(ser);
flushStream(id);
}
//Runs StreamStop and flushStream low-level functions to flush out the streaming buffer. Also
//reads 128 bytes from streaming endpoint to clear any left over data. If there is nothing to
//read from the streaming endpoint, then there will be a timeout delay. This function is
//useful for stopping streaming and clearing it after a Comm buffer overflow.
int doFlush(HANDLE hDevice)
{
uint8 recBuff[128];
printf("Flushing stream and reading left over data.\n");
StreamStop(hDevice);
flushStream(hDevice);
LJUSB_Stream(hDevice, recBuff, 128);
return 0;
}
bool SavePartInfo::write(Common::WriteStream &stream) const {
if (!_header.write(stream))
return false;
stream.writeUint32LE(_gameID);
stream.writeUint32LE(_gameVersion);
stream.writeByte(_endian);
stream.writeUint32LE(_varCount);
stream.writeUint32LE(_descMaxLength);
if (stream.write(_desc, _descMaxLength) != _descMaxLength)
return false;
return flushStream(stream);
}
bool SavePartSprite::write(Common::WriteStream &stream) const {
if (!_header.write(stream))
return false;
// The sprite's dimensions
stream.writeUint32LE(_width);
stream.writeUint32LE(_height);
stream.writeByte(_trueColor);
// Sprite data
if (stream.write(_dataSprite, _spriteSize) != _spriteSize)
return false;
// Palette data
if (stream.write(_dataPalette, 768) != 768)
return false;
return flushStream(stream);
}
void
logData (int level, LogDataFormatter *formatLogData, const void *data) {
const char *prefix = NULL;
if (level & LOG_FLG_CATEGORY) {
int category = level & LOG_MSK_CATEGORY;
if (!logCategoryFlags[category]) return;
level = categoryLogLevel;
{
const LogCategoryEntry *ctg = &logCategoryTable[category];
prefix = ctg->prefix;
}
}
{
int write = level <= systemLogLevel;
int print = level <= stderrLogLevel;
if (write || print) {
int oldErrno = errno;
char record[0X1000];
STR_BEGIN(record, sizeof(record));
if (prefix) STR_PRINTF("%s: ", prefix);
{
size_t sublength = formatLogData(STR_NEXT, STR_LEFT, data);
STR_ADJUST(sublength);
}
STR_END
if (write) {
writeLogRecord(record);
#if defined(WINDOWS)
if (windowsEventLog != INVALID_HANDLE_VALUE) {
const char *strings[] = {record};
ReportEvent(windowsEventLog, toWindowsEventType(level), 0, 0, NULL,
ARRAY_COUNT(strings), 0, strings, NULL);
}
#elif defined(__MSDOS__)
#elif defined(__ANDROID__)
__android_log_write(toAndroidLogPriority(level), PACKAGE_TARNAME, record);
#elif defined(HAVE_SYSLOG_H)
if (syslogOpened) syslog(level, "%s", record);
#endif /* write system log */
}
if (print) {
FILE *stream = stderr;
lockStream(stream);
if (logPrefixStack) {
const char *prefix = logPrefixStack->prefix;
if (*prefix) {
fputs(prefix, stream);
fputs(": ", stream);
}
}
fputs(record, stream);
fputc('\n', stream);
flushStream(stream);
unlockStream(stream);
}
errno = oldErrno;
}
}
// Save game
void SaveLoad::saveGame(SavegameType type, EntityIndex entity, uint32 value) {
if (getState()->scene <= kSceneIntro)
return;
// Validate main header
SavegameMainHeader header;
if (!loadMainHeader(_savegame, &header)) {
debugC(2, kLastExpressDebugSavegame, "SaveLoad::saveGame - Cannot load main header: %s", getFilename(getMenu()->getGameId()).c_str());
return;
}
if (!_savegame)
error("SaveLoad::saveGame: savegame stream is invalid");
// Validate the current entry if it exists
if (header.count > 0) {
_savegame->seek(header.offsetEntry);
// Load entry header
SavegameEntryHeader entry;
Common::Serializer ser(_savegame, NULL);
entry.saveLoadWithSerializer(ser);
if (!entry.isValid()) {
warning("SaveLoad::saveGame: Invalid entry. This savegame might be corrupted!");
_savegame->seek(header.offset);
} else if (getState()->time < entry.time || (type == kSavegameTypeTickInterval && getState()->time == entry.time)) {
// Not ready to save a game, skipping!
return;
} else if ((type == kSavegameTypeTime || type == kSavegameTypeEvent)
&& (entry.type == kSavegameTypeTickInterval && (getState()->time - entry.time) < 450)) {
_savegame->seek(header.offsetEntry);
--header.count;
} else {
_savegame->seek(header.offset);
}
} else {
// Seek to the next savegame entry
_savegame->seek(header.offset);
}
if (type != kSavegameTypeEvent2 && type != kSavegameTypeAuto)
header.offsetEntry = (uint32)_savegame->pos();
// Write the savegame entry
writeEntry(type, entity, value);
if (!header.keepIndex)
++header.count;
if (type == kSavegameTypeEvent2 || type == kSavegameTypeAuto) {
header.keepIndex = 1;
} else {
header.keepIndex = 0;
header.offset = (uint32)_savegame->pos();
// Save ticks
_gameTicksLastSavegame = getState()->timeTicks;
}
// Validate the main header
if (!header.isValid())
error("SaveLoad::saveGame: main game header is invalid!");
// Write the main header
_savegame->seek(0);
Common::Serializer ser(NULL, _savegame);
header.saveLoadWithSerializer(ser);
flushStream(getMenu()->getGameId());
}
SINT4
storageSelfTest1(StgMode in_stgModeOpen, StgMode in_stgModeCreate)
{
SINT4 iRet = SSTG_OK;
RootStorage* pRoot = NULL;
Storage* pStorage1 = NULL;
Storage* pStorage2 = NULL;
Storage* pStorage3 = NULL;
Stream* pStream1 = NULL;
Stream* pStream2 = NULL;
Stream* pStream3 = NULL;
Stream* pStream4 = NULL;
int cch = 0;
unsigned long cchL = 0;
wchar_t pwchBuf[] = L"Stuff to write into streams";
wchar_t pwchBuf2[60];
/* The main thing being tested here is the open list. If the calling
* application fails to close some streams and storages before closing
* the structured storage file, the structured storage library is supposed
* to clean everything up automatically.
*/
/* Create a bunch of streams and storages */
iRet = createStructuredStorageEx (WSZ_TEST_FILENAME, in_stgModeCreate, &pRoot, 0);
ASSERT (iRet == SSTG_OK && pRoot != NULL);
iRet = getStorageFromRoot (pRoot, &pStorage1);
ASSERT (iRet == SSTG_OK && pStorage1 != NULL);
iRet = createStream (pStorage1, WSZ_TEST_STREAM_1, &pStream1);
ASSERT (iRet == SSTG_OK && pStream1 != NULL);
cch = 0;
ASSERT (writeLEwstring(pStream1, pwchBuf, &cch) == SSTG_OK && cch == 28);
iRet = createStorage (pStorage1, WSZ_TEST_STORAGE_2, &pStorage2);
ASSERT (iRet == SSTG_OK && pStorage2 != NULL);
iRet = createStorage (pStorage2, WSZ_TEST_STORAGE_3, &pStorage3);
ASSERT (iRet == SSTG_OK && pStorage3 != NULL);
iRet = createStream (pStorage2, WSZ_TEST_STREAM_2, &pStream2);
ASSERT (iRet == SSTG_OK && pStream2 != NULL);
cch = 0;
ASSERT (writeLEwstring(pStream2, pwchBuf, &cch) == SSTG_OK && cch == 28);
cchL = 28 * sizeof(wchar_t);
iRet = flushStream(pStorage2, WSZ_TEST_STREAM_3, pwchBuf, &cchL);
ASSERT(iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t)));
/* Test to ensure that destroying a mini stream works */
cchL = 28 * sizeof(wchar_t);
iRet = flushStream(pStorage2, WSZ_TEST_STREAM_4, pwchBuf, &cchL);
ASSERT(iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t)));
iRet = destroy(pStorage2, WSZ_TEST_STREAM_4);
ASSERT(iRet == SSTG_OK);
/* Test to make sure duplicates are not allowed */
iRet = createStream(pStorage2, WSZ_TEST_STREAM_3, &pStream4);
ASSERT (iRet != SSTG_OK && pStream4 == NULL);
/* Now close the entire compound file without closing any of the open
* children */
iRet = closeStructuredStorage(&pRoot);
ASSERT (iRet == SSTG_OK && pRoot == NULL);
pStorage1 = NULL;
pStorage2 = NULL;
pStorage3 = NULL;
pStream1 = NULL;
pStream2 = NULL;
pStream3 = NULL;
/* Now do the same thing for reading. */
/* Open a bunch of streams and storages for reading. */
iRet = openStructuredStorageEx (WSZ_TEST_FILENAME, in_stgModeOpen, &pRoot);
ASSERT (iRet == SSTG_OK);
iRet = getStorageFromRoot (pRoot, &pStorage1);
ASSERT (iRet == SSTG_OK && pStorage1 != NULL);
iRet = openStream (pStorage1, WSZ_TEST_STREAM_1, &pStream1);
ASSERT (iRet == SSTG_OK && pStream1 != NULL);
cch = 28;
iRet = readLEwstring(pStream1, &cch, pwchBuf2);
ASSERT (iRet == SSTG_OK && cch == 28);
ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0);
memset(pwchBuf2, 0, sizeof(pwchBuf2));
iRet = openStorage (pStorage1, WSZ_TEST_STORAGE_2, &pStorage2);
ASSERT (iRet == SSTG_OK && pStorage2 != NULL);
iRet = openStorage (pStorage2, WSZ_TEST_STORAGE_3, &pStorage3);
ASSERT (iRet == SSTG_OK && pStorage3 != NULL);
iRet = openStream (pStorage2, WSZ_TEST_STREAM_2, &pStream2);
ASSERT (iRet == SSTG_OK && pStream2 != NULL);
cch = 28;
ASSERT (readLEwstring(pStream2, &cch, pwchBuf2) == SSTG_OK && cch == 28);
ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0);
memset(pwchBuf2, 0, sizeof(pwchBuf2));
iRet = openStream (pStorage2, WSZ_TEST_STREAM_3, &pStream3);
ASSERT (iRet == SSTG_OK && pStream3 != NULL);
cch = 28 * sizeof(wchar_t);
iRet = streamRead(pStream3, pwchBuf2, &cchL);
ASSERT (iRet == SSTG_OK && cchL == (28 * sizeof(wchar_t)));
ASSERT (memcmp(pwchBuf, pwchBuf2, wcslen(pwchBuf) + 1) == 0);
memset(pwchBuf2, 0, sizeof(pwchBuf2));
/* Close the entire compound file without closing any of the open
* children */
iRet = closeStructuredStorage(&pRoot);
ASSERT (iRet == SSTG_OK && pRoot == NULL);
/* Remove test file */
SSRW_WREMOVE (WSZ_TEST_FILENAME);
return iRet;
}
