uint8_t const* Zip::cacheLump(int lumpIdx) { LOG_AS("Zip::cacheLump"); if(!isValidIndex(lumpIdx)) throw NotFoundError("Zip::cacheLump", invalidIndexMessage(lumpIdx, lastIndex())); ZipFile& file = reinterpret_cast<ZipFile&>(lump(lumpIdx)); LOG_TRACE("\"%s:%s\" (%u bytes%s)") << de::NativePath(composePath()).pretty() << de::NativePath(file.composePath()).pretty() << (unsigned long) file.info().size << (file.info().isCompressed()? ", compressed" : ""); // Time to create the cache? if(!d->lumpCache) { d->lumpCache = new LumpCache(lumpCount()); } uint8_t const* data = d->lumpCache->data(lumpIdx); if(data) return data; uint8_t* region = (uint8_t*) Z_Malloc(file.info().size, PU_APPSTATIC, 0); if(!region) throw Error("Zip::cacheLump", QString("Failed on allocation of %1 bytes for cache copy of lump #%2").arg(file.info().size).arg(lumpIdx)); readLump(lumpIdx, region, false); d->lumpCache->insert(lumpIdx, region); return region; }
BOOL export dolLoad (void) { dolUnload(); dolphin = LoadLibrary(composePath("dolapi.dll")); if (!dolphin) return FALSE; DolAccess_GetSystem = GetProcAddress(dolphin, "_DolAccess_GetSystem@0"); DolAccess_Action = GetProcAddress(dolphin, "_DolAccess_Action@4"); DolAccess_Command = GetProcAddress(dolphin, "_DolAccess_Command@12"); return TRUE; }
size_t Zip::readLump(int lumpIdx, uint8_t* buffer, size_t startOffset, size_t length, bool tryCache) { LOG_AS("Zip::readLump"); ZipFile const& file = reinterpret_cast<ZipFile&>(lump(lumpIdx)); LOG_TRACE("\"%s:%s\" (%u bytes%s) [%u +%u]") << de::NativePath(composePath()).pretty() << de::NativePath(file.composePath()).pretty() << (unsigned long) file.size() << (file.isCompressed()? ", compressed" : "") << startOffset << length; // Try to avoid a file system read by checking for a cached copy. if(tryCache) { uint8_t const* data = d->lumpCache? d->lumpCache->data(lumpIdx) : 0; LOG_TRACE("Cache %s on #%i") << (data? "hit" : "miss") << lumpIdx; if(data) { size_t readBytes = MIN_OF(file.size(), length); memcpy(buffer, data + startOffset, readBytes); return readBytes; } } size_t readBytes; if(!startOffset && length == file.size()) { // Read it straight to the caller's data buffer. readBytes = d->bufferLump(file, buffer); } else { // Allocate a temporary buffer and read the whole lump into it(!). uint8_t* lumpData = (uint8_t*) M_Malloc(file.size()); if(!lumpData) throw Error("Zip::readLumpSection", QString("Failed on allocation of %1 bytes for work buffer").arg(file.size())); if(d->bufferLump(file, lumpData)) { readBytes = MIN_OF(file.size(), length); memcpy(buffer, lumpData + startOffset, readBytes); } else { readBytes = 0; } M_Free(lumpData); } /// @todo Do not check the read length here. if(readBytes < MIN_OF(file.size(), length)) throw Error("Zip::readLumpSection", QString("Only read %1 of %2 bytes of lump #%3").arg(readBytes).arg(length).arg(lumpIdx)); return readBytes; }
void Zip::unlockLump(int lumpIdx) { LOG_AS("Zip::unlockLump"); LOG_TRACE("\"%s:%s\"") << de::NativePath(composePath()).pretty() << lump(lumpIdx).composePath(); if(isValidIndex(lumpIdx)) { if(d->lumpCache) { d->lumpCache->unlock(lumpIdx); } else { LOG_DEBUG("LumpCache not in use, ignoring."); } } else { QString msg = invalidIndexMessage(lumpIdx, lastIndex()); LOG_DEBUG(msg + ", ignoring."); } }
File1& File1::container() const { if(!container_) throw NotContainedError("File1::container", "File \"" + NativePath(composePath()).pretty() + " is not contained"); return *container_; }