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; }