bool KArchive::close()
{
if ( !isOpen() )
return false; // already closed (return false or true? arguable...)
// moved by holger to allow kzip to write the zip central dir
// to the file in closeArchive()
// DF: added d->dev so that we skip closeArchive if saving aborted.
bool closeSucceeded = true;
if ( d->dev ) {
closeSucceeded = closeArchive();
if ( d->mode == QIODevice::WriteOnly && !closeSucceeded )
d->abortWriting();
}
// if d->saveFile is not null then it is equal to d->dev.
if ( d->saveFile ) {
closeSucceeded = d->saveFile->commit();
delete d->saveFile;
d->saveFile = 0;
} else {
d->dev->close();
}
if ( d->deviceOwned ) {
delete d->dev; // we created it ourselves in open()
}
delete d->rootDir;
d->rootDir = 0;
d->mode = QIODevice::NotOpen;
d->dev = 0;
return closeSucceeded;
}
// open from file
bool ZipIO::openArchive(const std::string &ArchiveName, OpenMode Mode) {
// first close last opened archive
_kaname = "";
closeArchive();
// inite object
memset(&_kzarchive, 0, sizeof(_kzarchive));
// open archive
mz_bool status;
if (Mode == OpenMode::READ) {
status = mz_zip_reader_init_file(&_kzarchive, ArchiveName.c_str(), 0);
} else if (Mode == OpenMode::WRITE){
remove(ArchiveName.c_str());
status = true;
} else if (Mode == OpenMode::APPEND){
status = true;
}
if (!status)
return false;
_kmode = Mode;
_kisopen = true;
_kaname = ArchiveName;
return true;
}
//----------------------------------------------------------------------------//
MinizipResourceProvider::~MinizipResourceProvider()
{
if (d_pimpl->d_zfile)
closeArchive();
delete d_pimpl;
}
bool KArchive::close()
{
if ( !isOpen() )
return false; // already closed (return false or true? arguable...)
// moved by holger to allow kzip to write the zip central dir
// to the file in closeArchive()
// DF: added d->dev so that we skip closeArchive if saving aborted.
bool closeSucceeded = true;
if ( d->dev ) {
closeSucceeded = closeArchive();
if ( d->mode == QIODevice::WriteOnly && !closeSucceeded )
d->abortWriting();
}
if ( d->dev )
d->dev->close();
if ( d->deviceOwned ) {
delete d->dev; // we created it ourselves in open()
}
// Disabled for Stellarium
// if ( d->saveFile ) {
// closeSucceeded = d->saveFile->finalize();
// delete d->saveFile;
// d->saveFile = 0;
// }
delete d->rootDir;
d->rootDir = 0;
d->mode = QIODevice::NotOpen;
d->dev = 0;
return closeSucceeded;
}
//----------------------------------------------------------------------------//
void MinizipResourceProvider::setArchive(const String& archive)
{
if (d_pimpl->d_zfile)
closeArchive();
d_pimpl->d_archive = archive;
openArchive();
}
void PimSettingsBackupRestore::backupFinished()
{
Q_EMIT addInfo(i18n("Backup in \'%1\' done.", mArchiveStorage->filename()));
//At the end
closeArchive();
Q_EMIT backupDone();
deleteLater();
}
bool ZipObject::openArchive(const char *filename, Zip::ZipArchive::AccessMode mode /* = Read */)
{
closeArchive();
mZipArchive = new Zip::ZipArchive;
if(mZipArchive->openArchive(filename, mode))
return true;
SAFE_DELETE(mZipArchive);
return false;
}
void initLoad(){
/*ファイルオープン*/
ARCHIVE archive;
openArchive(&archive,LOAD_ARCHIVE);
/*背景取得*/
SDL_RWops* bgData = getGraphixFile(&archive,LOAD_BG);
getSpriteFromOPS(&LoadBGSprite,bgData);
bgData->close(bgData); //メモリ開放は忘れずに
closeArchive(&archive);
}
bool ZipArchive::openArchive(const char *filename, AccessMode mode /* = Read */)
{
if(mode != Read && mode != Write && mode != ReadWrite)
return false;
closeArchive();
mDiskStream = new FileStream;
if(mDiskStream->open(filename, (Torque::FS::File::AccessMode)mode))
{
setFilename(filename);
if(openArchive(mDiskStream, mode))
return true;
}
// Cleanup just in case openArchive() failed
closeArchive();
return false;
}
void ArchiveItemModel::openArchive(QString filePath)
{
//TODO: make async; output status
closeArchive();
if (_archive.openArchive(filePath)) {
std::vector<ArchiveEntry> entries;
bool success;
_archive.readAllEntries(entries, success);
_archive.syncArchive();
if (success) populateModel(entries);
}
}
// -----------------------------------------------------------------------------
// Closes the specified archive and removes it from the list, if it exists in
// the list. Returns false if it doesn't exist, else true
// -----------------------------------------------------------------------------
bool ArchiveManager::closeArchive(Archive* archive)
{
// Go through all open archives
for (int a = 0; a < (int)open_archives_.size(); a++)
{
// If the archive exists in the list, remove it
if (open_archives_[a].archive == archive)
return closeArchive(a);
}
// If the archive isn't in the list, return false
return false;
}
// -----------------------------------------------------------------------------
// Finds the archive with a matching filename, deletes it and removes it from
// the list.
// Returns false if it doesn't exist or can't be removed, true otherwise
// -----------------------------------------------------------------------------
bool ArchiveManager::closeArchive(const string& filename)
{
// Go through all open archives
for (int a = 0; a < (int)open_archives_.size(); a++)
{
// If the filename matches, remove it
if (open_archives_[a].archive->filename().compare(filename) == 0)
return closeArchive(a);
}
// If no archive is found with a matching filename, return false
return false;
}
void KArchive::close()
{
if(!m_open)
return;
// moved by holger to allow kzip to write the zip central dir
// to the file in closeArchive()
d->closeSucceeded = closeArchive();
if(m_dev)
m_dev->close();
delete d->rootDir;
d->rootDir = 0;
m_open = false;
}
// open from memory
bool ZipIO::openArchive(const void *Memory, size_t Size) {
// first close last opened archive
_kaname = "";
closeArchive();
// inite object
memset(&_kzarchive, 0, sizeof(_kzarchive));
// open archive
mz_bool status = mz_zip_reader_init_mem(&_kzarchive, Memory, Size, 0);
if (!status) return false;
_kaname = "memory-block";
_kisopen = true;
return true;
}
bool QArchive::close()
{
if (!isOpen())
return false; // already closed (return false or true? arguable...)
// allow Qzip to write the zip central dir
// to the file in closeArchive()
// added m_dev so that we skip closeArchive if saving aborted.
bool closeSucceeded = true;
if (m_dev)
{
closeSucceeded = closeArchive();
if (m_mode == QIODevice::WriteOnly && !closeSucceeded)
abortWriting();
}
if (m_dev)
m_dev->close();
// if (m_dev && m_dev != d->saveFile) {
// m_dev->close();
// }
// if d->saveFile is not null then it is equal to d->dev.
// if (d->saveFile)
// {
// closeSucceeded = d->saveFile->commit();
// delete d->saveFile;
// d->saveFile = 0;
// }
if (m_deviceOwned)
delete m_dev; // we created it ourselves in open()
delete m_rootDir;
m_rootDir = 0;
m_mode = QIODevice::NotOpen;
m_dev = 0;
return closeSucceeded;
}
void ZipSoundArchive::openArchive(const char *path, const char *extension, SoundFormat format, int raw_frequency) {
closeArchive();
if ((format == RAW || format == RAW80) && !raw_frequency) {
error("openArchive() expects frequency for RAW data");
return;
}
debugCN(1, kDraciArchiverDebugLevel, "Trying to open ZIP archive %s: ", path);
_archive = Common::makeZipArchive(path);
_path = path;
_extension = extension;
_format = format;
_defaultFreq = raw_frequency;
if (_archive) {
Common::ArchiveMemberList files;
_archive->listMembers(files);
_sampleCount = files.size();
debugC(1, kDraciArchiverDebugLevel, "Capacity %d", _sampleCount);
} else {
debugC(1, kDraciArchiverDebugLevel, "Failed");
}
}
// -----------------------------------------------------------------------------
// Closes all opened archives
// -----------------------------------------------------------------------------
void ArchiveManager::closeAll()
{
// Close the first archive in the list until no archives are open
while (!open_archives_.empty())
closeArchive(0);
}
ZipArchive::~ZipArchive()
{
closeArchive();
}
ZipObject::~ZipObject()
{
closeArchive();
}
void BArchive::openArchive(const Common::String &path) {
byte buf[4];
byte *footer;
uint32 footerOffset, footerSize;
// Close previously opened archive (if any)
closeArchive();
debugCN(2, kDraciArchiverDebugLevel, "Loading archive %s: ", path.c_str());
_f.open(path);
if (_f.isOpen()) {
debugC(2, kDraciArchiverDebugLevel, "Success");
} else {
debugC(2, kDraciArchiverDebugLevel, "Error");
return;
}
// Save path for reading in files later on
_path = path;
// Read archive header
debugCN(2, kDraciArchiverDebugLevel, "Checking for BAR magic number: ");
_f.read(buf, 4);
if (memcmp(buf, _magicNumber, 4) == 0) {
debugC(2, kDraciArchiverDebugLevel, "Success");
// Indicate this archive is a BAR
_isDFW = false;
} else {
debugC(2, kDraciArchiverDebugLevel, "Not a BAR archive");
debugCN(2, kDraciArchiverDebugLevel, "Retrying as DFW: ");
_f.close();
// Try to open as DFW
openDFW(_path);
return;
}
_fileCount = _f.readUint16LE();
footerOffset = _f.readUint32LE();
footerSize = _f.size() - footerOffset;
debugC(2, kDraciArchiverDebugLevel, "Archive info: %d files, %d data bytes",
_fileCount, footerOffset - _archiveHeaderSize);
// Read in footer
footer = new byte[footerSize];
_f.seek(footerOffset);
_f.read(footer, footerSize);
Common::MemoryReadStream reader(footer, footerSize);
// Read in file headers, but do not read the actual data yet
// The data will be read on demand to save memory
_files = new BAFile[_fileCount];
for (uint i = 0; i < _fileCount; i++) {
uint32 fileOffset;
fileOffset = reader.readUint32LE();
_f.seek(fileOffset); // Seek to next file in archive
_files[i]._compLength = _f.readUint16LE(); // Compressed size
// should be the same as uncompressed
_files[i]._length = _f.readUint16LE(); // Original size
_files[i]._offset = fileOffset; // Offset of file from start
byte compressionType = _f.readByte();
assert(compressionType == 0 &&
"Compression type flag is non-zero (file is compressed)");
_files[i]._crc = _f.readByte(); // CRC checksum of the file
_files[i]._data = NULL; // File data will be read in on demand
_files[i]._stopper = 0; // Dummy value; not used in BAR files, needed in DFW
}
// Last footer item should be equal to footerOffset
uint32 footerOffset2 = reader.readUint32LE();
assert(footerOffset2 == footerOffset && "Footer offset mismatch");
// Indicate that the archive has been successfully opened
_opened = true;
delete[] footer;
}
void BladeRunnerEngine::shutdown() {
_mixer->stopAll();
// TODO: Write BLADE.INI
delete _vk;
_vk = nullptr;
delete _esper;
_esper = nullptr;
delete _mouse;
_mouse = nullptr;
for (uint i = 0; i != _shapes.size(); ++i) {
delete _shapes[i];
}
_shapes.clear();
// TODO: Shutdown Scene
delete _scene;
if (_chapters) {
if (_chapters->hasOpenResources())
_chapters->closeResources();
delete _chapters;
_chapters = nullptr;
}
delete _crimesDatabase;
_crimesDatabase = nullptr;
delete _sliceRenderer;
_sliceRenderer = nullptr;
delete _sliceAnimations;
_sliceAnimations = nullptr;
delete _textActorNames;
_textActorNames = nullptr;
delete _textCrimes;
_textCrimes = nullptr;
delete _textClueTypes;
_textClueTypes = nullptr;
delete _textKIA;
_textKIA = nullptr;
delete _textSpinnerDestinations;
_textSpinnerDestinations = nullptr;
delete _textVK;
_textVK = nullptr;
delete _textOptions;
_textOptions = nullptr;
delete _dialogueMenu;
_dialogueMenu = nullptr;
delete _ambientSounds;
_ambientSounds = nullptr;
delete _overlays;
_overlays = nullptr;
delete _audioSpeech;
_audioSpeech = nullptr;
delete _music;
_music = nullptr;
delete _audioPlayer;
_audioPlayer = nullptr;
delete _audioMixer;
_audioMixer = nullptr;
if (isArchiveOpen("MUSIC.MIX")) {
closeArchive("MUSIC.MIX");
}
if (isArchiveOpen("SFX.MIX")) {
closeArchive("SFX.MIX");
}
if (isArchiveOpen("SPCHSFX.TLK")) {
closeArchive("SPCHSFX.TLK");
}
if (_mainFont) {
_mainFont->close();
delete _mainFont;
_mainFont = nullptr;
}
delete _items;
_items = nullptr;
delete _gameFlags;
_gameFlags = nullptr;
delete _view;
_view = nullptr;
delete _sceneObjects;
_sceneObjects = nullptr;
delete _cosTable1024;
delete _sinTable1024;
delete _aiScripts;
_aiScripts = nullptr;
delete[] _gameVars;
_gameVars = nullptr;
delete _waypoints;
_waypoints = nullptr;
// TODO: Delete Cover waypoints
// TODO: Delete Flee waypoints
delete _scores;
_scores = nullptr;
delete _endCredits;
_endCredits = nullptr;
delete _elevator;
_elevator = nullptr;
delete _spinner;
_spinner = nullptr;
delete _kia;
_kia = nullptr;
delete _suspectsDatabase;
_suspectsDatabase = nullptr;
// TODO: Delete datetime - not used
int actorCount = (int)_gameInfo->getActorCount();
for (int i = 0; i != actorCount; ++i) {
delete _actors[i];
_actors[i] = nullptr;
}
delete _actors[kActorVoiceOver];
_actors[kActorVoiceOver] = nullptr;
_playerActor = nullptr;
delete _gameInfo;
_gameInfo = nullptr;
// TODO: Delete graphics surfaces here
_surface4.free();
_surfaceBack.free();
_surfaceFront.free();
if (isArchiveOpen("STARTUP.MIX")) {
closeArchive("STARTUP.MIX");
}
// TODO: Delete MIXArchives here
delete _gameTime;
_gameTime = nullptr;
// These are static objects in original game
delete _debugger;
_debugger = nullptr;
delete _zbuffer;
_zbuffer = nullptr;
delete _itemPickup;
_itemPickup = nullptr;
delete _policeMaze;
_policeMaze = nullptr;
delete _obstacles;
_obstacles = nullptr;
delete _actorDialogueQueue;
_actorDialogueQueue = nullptr;
delete _combat;
_combat = nullptr;
delete _screenEffects;
_screenEffects = nullptr;
delete _lights;
_lights = nullptr;
delete _settings;
_settings = nullptr;
delete _sceneScript;
_sceneScript = nullptr;
}
void
do_ar(int argc, const char ** argv)
{
const char * options;
const char * archiveName;
BOOL doExtract;
BOOL doTable;
BOOL doPrint;
BOOL verbose;
Archive arch;
verbose = FALSE;
doExtract = FALSE;
doTable = FALSE;
doPrint = FALSE;
if (argc < 3)
{
fprintf(stderr, "Too few arguments for ar\n");
return;
}
/*
* Get the option string and archive file name.
*/
options = argv[1];
archiveName = argv[2];
/*
* Advance the arguments to the list of file names (if any).
*/
argc -= 3;
argv += 3;
/*
* Parse the option characters.
*/
for (; *options; options++)
{
switch (*options)
{
case 't':
doTable = TRUE;
break;
case 'x':
doExtract = TRUE;
break;
case 'p':
doPrint = TRUE;
break;
case 'v':
verbose = TRUE;
break;
case 'd': case 'm': case 'q': case 'r':
fprintf(stderr, "Writing ar files is not supported\n");
return;
default:
fprintf(stderr, "Unknown ar flag: %c\n", *options);
return;
}
}
if (doExtract + doTable + doPrint != 1)
{
fprintf(stderr,
"Exactly one of 'x', 'p' or 't' must be specified\n");
return;
}
/*
* Open the archive file.
*/
initArchive(&arch);
if (!openArchive(archiveName, &arch))
return;
/*
* Read the first special member of the archive.
*/
if (!readSpecialMember(&arch))
return;
/*
* Read all of the normal members of the archive.
*/
while (readNormalMember(&arch))
{
/*
* If this file is not wanted then skip it.
*/
if (!wantMember(&arch, argc, argv))
{
if (!skipMember(&arch))
break;
continue;
}
/*
* This file is wanted.
*/
if (doTable)
{
if (verbose)
listMember(&arch);
else
puts(arch.name);
if (!skipMember(&arch))
break;
}
else if (doPrint)
{
if (verbose)
{
/*
* The verbose format makes me gag,
* but 4.4BSD, GNU and even V7 all
* have the same lossage.
*/
printf("\n<%s>\n\n", arch.name);
fflush(stdout);
}
if (!writeFile(&arch, STDOUT))
break;
}
else if (doExtract)
{
int outfd;
BOOL success;
if (verbose)
printf("x - %s\n", arch.name);
outfd = createFile(&arch);
if (outfd == -1)
break;
success = writeFile(&arch, outfd);
if (close(outfd) == -1)
{
fprintf(stderr, "Can't close %s: %s\n",
arch.name, strerror(errno));
break;
}
if (!success)
break;
}
else
{
fprintf(stderr, "Oops -- I don't know what to do\n");
break;
}
}
closeArchive(&arch);
}
void LegacySoundArchive::openArchive(const char *path) {
// Close previously opened archive (if any)
closeArchive();
debugCN(1, kDraciArchiverDebugLevel, "Loading samples %s: ", path);
_f = new Common::File();
_f->open(path);
if (_f->isOpen()) {
debugC(1, kDraciArchiverDebugLevel, "Success");
} else {
debugC(1, kDraciArchiverDebugLevel, "Error");
delete _f;
_f = NULL;
return;
}
// Save path for reading in files later on
_path = path;
// Read archive header
debugC(1, kDraciArchiverDebugLevel, "Loading header");
uint totalLength = _f->readUint32LE();
const uint kMaxSamples = 4095; // The no-sound file is exactly 16K bytes long, so don't fail on short reads
uint *sampleStarts = (uint *)malloc(kMaxSamples * sizeof(uint));
if (!sampleStarts)
error("[LegacySoundArchive::openArchive] Cannot allocate buffer for no-sound file");
for (uint i = 0; i < kMaxSamples; ++i) {
sampleStarts[i] = _f->readUint32LE();
}
// Fill the sample table
for (_sampleCount = 0; _sampleCount < kMaxSamples - 1; ++_sampleCount) {
int length = sampleStarts[_sampleCount + 1] - sampleStarts[_sampleCount];
if (length <= 0 && sampleStarts[_sampleCount] >= totalLength) // heuristics to detect the last sample
break;
}
if (_sampleCount > 0) {
debugC(1, kDraciArchiverDebugLevel, "Archive info: %d samples, %d total length",
_sampleCount, totalLength);
_samples = new SoundSample[_sampleCount];
for (uint i = 0; i < _sampleCount; ++i) {
_samples[i]._offset = sampleStarts[i];
_samples[i]._length = sampleStarts[i+1] - sampleStarts[i];
_samples[i]._frequency = 0; // set in getSample()
}
if (_samples[_sampleCount-1]._offset + _samples[_sampleCount-1]._length != totalLength &&
_samples[_sampleCount-1]._offset + _samples[_sampleCount-1]._length - _samples[0]._offset != totalLength) {
// WORKAROUND: the stored length is stored with the header for sounds and without the header for dubbing. Crazy.
debugC(1, kDraciArchiverDebugLevel, "Broken sound archive: %d != %d",
_samples[_sampleCount-1]._offset + _samples[_sampleCount-1]._length,
totalLength);
closeArchive();
free(sampleStarts);
return;
}
} else {
debugC(1, kDraciArchiverDebugLevel, "Archive info: empty");
}
free(sampleStarts);
// Indicate that the archive has been successfully opened
_opened = true;
}
void ArchiveItemModel::newArchive(QString filePath)
{
closeArchive();
_archive.createArchive(filePath);
}
/* ArchiveManager::closeArchive
* Closes the archive at index, and removes it from the list if the
* index is valid. Returns false on invalid index, true otherwise
*******************************************************************/
bool ArchiveManager::closeArchive(int index)
{
// Check for invalid index
if (index < 0 || index >= (int) open_archives.size())
return false;
// Announce archive closing
MemChunk mc;
int32_t temp = index;
mc.write(&temp, 4);
announce("archive_closing", mc);
// Delete any bookmarked entries contained in the archive
deleteBookmarksInArchive(open_archives[index].archive);
// Remove from resource manager
theResourceManager->removeArchive(open_archives[index].archive);
// Delete any embedded configuration
//theGameConfiguration->removeEmbeddedConfig(open_archives[index].archive->getFilename());
// Close any open child archives
// Clear out the open_children vector first, lest the children try to
// remove themselves from it
vector<Archive*> open_children = open_archives[index].open_children;
open_archives[index].open_children.clear();
for (size_t a = 0; a < open_children.size(); a++)
{
int ci = archiveIndex(open_children[a]);
if (ci >= 0)
closeArchive(ci);
}
// Remove ourselves from our parent's open-child list
ArchiveEntry* parent = open_archives[index].archive->getParent();
if (parent)
{
Archive* gp = parent->getParent();
if (gp)
{
int pi = archiveIndex(gp);
if (pi >= 0)
{
vector<Archive*>& children = open_archives[pi].open_children;
for (vector<Archive*>::iterator it = children.begin();
it < children.end();
it++)
{
if (*it == open_archives[index].archive)
{
children.erase(it, it + 1);
break;
}
}
}
}
}
// Close the archive
open_archives[index].archive->close();
// Delete the archive object
delete open_archives[index].archive;
// Remove the archive at index from the list
open_archives.erase(open_archives.begin() + index);
// Announce closed
announce("archive_closed", mc);
return true;
}
// -----------------------------------------------------------------------------
// Closes the archive at index, and removes it from the list if the index is
// valid. Returns false on invalid index, true otherwise
// -----------------------------------------------------------------------------
bool ArchiveManager::closeArchive(int index)
{
// Check for invalid index
if (index < 0 || index >= (int)open_archives_.size())
return false;
// Announce archive closing
MemChunk mc;
int32_t temp = index;
mc.write(&temp, 4);
announce("archive_closing", mc);
// Delete any bookmarked entries contained in the archive
deleteBookmarksInArchive(open_archives_[index].archive);
// Remove from resource manager
theResourceManager->removeArchive(open_archives_[index].archive);
// Close any open child archives
// Clear out the open_children vector first, lest the children try to remove themselves from it
auto open_children = open_archives_[index].open_children;
open_archives_[index].open_children.clear();
for (auto& archive : open_children)
{
int ci = archiveIndex(archive);
if (ci >= 0)
closeArchive(ci);
}
// Remove ourselves from our parent's open-child list
auto parent = open_archives_[index].archive->parentEntry();
if (parent)
{
auto gp = parent->parent();
if (gp)
{
int pi = archiveIndex(gp);
if (pi >= 0)
{
auto& children = open_archives_[pi].open_children;
for (auto it = children.begin(); it < children.end(); ++it)
{
if (*it == open_archives_[index].archive)
{
children.erase(it, it + 1);
break;
}
}
}
}
}
// Close the archive
open_archives_[index].archive->close();
// Delete the archive object
delete open_archives_[index].archive;
// Remove the archive at index from the list
open_archives_.erase(open_archives_.begin() + index);
// Announce closed
announce("archive_closed", mc);
return true;
}
/* ArchiveManager::closeAll
* Closes all opened archives
*******************************************************************/
void ArchiveManager::closeAll()
{
// Close the first archive in the list until no archives are open
while (open_archives.size() > 0)
closeArchive(0);
}
