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