void CDdsImage::Read(Framework::CStream& inputStream)
{
uint32 signature = inputStream.Read32();
if(signature != ' SDD')
{
assert(0);
throw std::runtime_error("Invalid DDS image (Invalid signature).");
}
inputStream.Read(&m_header, sizeof(DDS_HEADER));
if(m_header.size != sizeof(DDS_HEADER))
{
assert(0);
throw std::runtime_error("Invalid DDS image (Invalid header size).");
}
if(m_header.ddspf.size != sizeof(DDS_PIXELFORMAT))
{
assert(0);
throw std::runtime_error("Invalid DDS image (Invalid header size).");
}
const uint32 mandatoryFlags = DDS_HEADER_FLAG_CAPS | DDS_HEADER_FLAG_HEIGHT | DDS_HEADER_FLAG_WIDTH | DDS_HEADER_FLAG_PIXELFORMAT;
if((m_header.flags & mandatoryFlags) != mandatoryFlags)
{
assert(0);
throw std::runtime_error("Invalid DDS image (Missing flags).");
}
assert((m_header.ddspf.flags & (DDS_PIXELFORMAT_FLAG_RGB | DDS_PIXELFORMAT_FLAG_ALPHAPIXELS)) != 0);
uint32 surfaceSize = (m_header.ddspf.rgbBitCount / 8) * m_header.width * m_header.height;
if(m_header.caps2 & DDS_HEADER_CAP2_CUBEMAP)
{
const uint32 fullCubeMapFlags =
DDS_HEADER_CAP2_CUBEMAP_POSITIVE_X | DDS_HEADER_CAP2_CUBEMAP_NEGATIVE_X |
DDS_HEADER_CAP2_CUBEMAP_POSITIVE_Y | DDS_HEADER_CAP2_CUBEMAP_NEGATIVE_Y |
DDS_HEADER_CAP2_CUBEMAP_POSITIVE_Z | DDS_HEADER_CAP2_CUBEMAP_NEGATIVE_Z;
assert((m_header.caps2 & fullCubeMapFlags) == fullCubeMapFlags);
for(unsigned int i = 0; i < 6; i++)
{
SurfaceByteArray surface(surfaceSize);
inputStream.Read(surface.data(), surfaceSize);
m_surfaces.push_back(std::move(surface));
}
}
}
void CTextureSection::Read(Framework::CStream& inputStream)
{
CBaseSection::Read(inputStream);
inputStream.Read(m_header, sizeof(m_header));
auto gtex = std::make_shared<CGtexData>();
AddChild(gtex);
gtex->Read(inputStream);
}
CDialog::DIALOGTEMPLATE CDialog::ReadDialogTemplate(Framework::CStream& stream)
{
DIALOGTEMPLATE dialog;
dialog.dlgVer = stream.Read16();
dialog.signature = stream.Read16();
assert(dialog.dlgVer == 1);
assert(dialog.signature == 0xFFFF);
dialog.helpID = stream.Read32();
dialog.exStyle = stream.Read32();
dialog.style = stream.Read32();
dialog.cDlgItems = stream.Read16();
dialog.x = stream.Read16();
dialog.y = stream.Read16();
dialog.cx = stream.Read16();
dialog.cy = stream.Read16();
assert((stream.Tell() & 0x01) == 0);
dialog.menu = ReadSzOrOrd(stream);
assert((stream.Tell() & 0x01) == 0);
dialog.windowClass = ReadSzOrOrd(stream);
assert((stream.Tell() & 0x01) == 0);
dialog.title = ReadString(stream);
dialog.pointsize = stream.Read16();
dialog.weight = stream.Read16();
dialog.italic = stream.Read8();
dialog.charset = stream.Read8();
assert((stream.Tell() & 0x01) == 0);
dialog.typeface = ReadString(stream);
//Struct has padding for alignment to DWORD boundary (only if there's other items to read)
if(stream.GetRemainingLength() != 0)
{
auto currentBytePos = stream.Tell() & 0x3;
if(currentBytePos != 0)
{
stream.Seek(4 - currentBytePos, Framework::STREAM_SEEK_CUR);
}
assert((stream.Tell() & 0x03) == 0);
}
uint32 itemDataLength = static_cast<uint32>(stream.GetRemainingLength());
if(itemDataLength != 0)
{
dialog.dialogItemData.resize(itemDataLength);
stream.Read(&dialog.dialogItemData[0], itemDataLength);
}
return dialog;
}
CBspFile::CBspFile(Framework::CStream& inputStream)
{
uint8 signature[4];
inputStream.Read(signature, 4);
if(memcmp(signature, "IBSP", 4))
{
throw std::runtime_error("Invalid BSP. Bad signature.");
}
uint32 version = inputStream.Read32();
assert(version == 0x2E);
DIRENTRY dirEntries[DIRENTRY_COUNT];
for(unsigned int i = 0; i < DIRENTRY_COUNT; i++)
{
dirEntries[i].offset = inputStream.Read32();
dirEntries[i].length = inputStream.Read32();
}
ReadLumpData(inputStream, dirEntries[LUMP_ENTITIES], m_entities);
ReadLumpData(inputStream, dirEntries[LUMP_PLANES], m_planes);
ReadLumpData(inputStream, dirEntries[LUMP_NODES], m_nodes);
ReadLumpData(inputStream, dirEntries[LUMP_LEAVES], m_leaves);
ReadLumpData(inputStream, dirEntries[LUMP_LEAFFACES], m_leafFaces);
ReadLumpData(inputStream, dirEntries[LUMP_TEXTURES], m_textures);
ReadLumpData(inputStream, dirEntries[LUMP_VERTICES], m_vertices);
ReadLumpData(inputStream, dirEntries[LUMP_MESHVERTICES], m_meshVertices);
ReadLumpData(inputStream, dirEntries[LUMP_EFFECTS], m_effects);
ReadLumpData(inputStream, dirEntries[LUMP_FACES], m_faces);
ReadLumpData(inputStream, dirEntries[LUMP_LIGHTMAPS], m_lightMaps);
//Read VISDATA
{
inputStream.Seek(dirEntries[LUMP_VISDATA].offset, Framework::STREAM_SEEK_SET);
m_visData.vectorCount = inputStream.Read32();
m_visData.vectorSize = inputStream.Read32();
uint32 visDataSize = m_visData.vectorCount * m_visData.vectorSize;
m_visData.vectors.resize(visDataSize);
inputStream.Read(&m_visData.vectors[0], visDataSize);
}
}
void CPatchFile::ExtractCompressed(Framework::CStream& outputStream, Framework::CStream& inputStream, uint32 compressedSize)
{
z_stream zStream;
zStream.zalloc = Z_NULL;
zStream.zfree = Z_NULL;
zStream.opaque = Z_NULL;
zStream.avail_in = 0;
zStream.next_in = Z_NULL;
if(inflateInit(&zStream) != Z_OK)
{
throw std::runtime_error("zlib stream initialization error.");
}
const uint32 bufferSize = 0x4000;
uint8 inBuffer[bufferSize];
uint8 outBuffer[bufferSize];
while(1)
{
if(zStream.avail_in == 0)
{
if(compressedSize == 0)
{
//EOF
break;
}
uint32 toRead = std::min<uint32>(bufferSize, compressedSize);
inputStream.Read(inBuffer, toRead);
compressedSize -= toRead;
zStream.avail_in = toRead;
zStream.next_in = inBuffer;
}
zStream.avail_out = bufferSize;
zStream.next_out = outBuffer;
int ret = inflate(&zStream, Z_NO_FLUSH);
if(ret < 0)
{
throw std::runtime_error("Error occured while inflating.");
break;
}
int have = bufferSize - zStream.avail_out;
outputStream.Write(outBuffer, have);
if(ret == Z_STREAM_END)
{
break;
}
}
inflateEnd(&zStream);
}
void CPatchFile::ExtractUncompressed(Framework::CStream& outputStream, Framework::CStream& inputStream, uint32 compressedSize)
{
const uint32 bufferSize = 0x4000;
uint8 buffer[bufferSize];
while(compressedSize != 0)
{
uint32 toRead = std::min<uint32>(bufferSize, compressedSize);
inputStream.Read(buffer, toRead);
outputStream.Write(buffer, toRead);
compressedSize -= toRead;
}
}
void CPatchFile::ExecuteDELD(Framework::CStream& stream)
{
uint32 pathSize = stream.Read32_MSBF();
std::vector<char> pathData(pathSize);
stream.Read(pathData.data(), pathSize);
std::string path(std::begin(pathData), std::end(pathData));
uint32 otherData[4];
stream.Read(otherData, sizeof(otherData));
auto fullDirPath = m_gameLocationPath / path;
fullDirPath.make_preferred();
if(!boost::filesystem::exists(fullDirPath))
{
m_result.messages.push_back(string_format("Warning: Directory '%s' deletion requested but directory doesn't exist.",
fullDirPath.string().c_str()
));
}
else
{
boost::filesystem::remove_all(fullDirPath);
}
}
uint32 CIoman::Read(uint32 handle, uint32 size, void* buffer)
{
CLog::GetInstance().Print(LOG_NAME, "Read(handle = %d, size = 0x%X, buffer = ptr);\r\n", handle, size);
uint32 result = 0xFFFFFFFF;
try
{
Framework::CStream* stream = GetFileStream(handle);
result = static_cast<uint32>(stream->Read(buffer, size));
}
catch(const std::exception& except)
{
CLog::GetInstance().Print(LOG_NAME, "%s: Error occured while trying to read file : %s\r\n", __FUNCTION__, except.what());
}
return result;
}
void CPatchFile::DoExecute(Framework::CStream& stream)
{
uint8 patchHeader[0x10];
stream.Read(patchHeader, sizeof(patchHeader));
if(
patchHeader[0] != 0x91 &&
patchHeader[1] != 'Z' &&
patchHeader[2] != 'I' &&
patchHeader[3] != 'P' &&
patchHeader[4] != 'A' &&
patchHeader[5] != 'T' &&
patchHeader[6] != 'C' &&
patchHeader[7] != 'H')
{
throw std::runtime_error("Invalid patch file.");
}
while(1)
{
char command[5];
stream.Read(command, 4);
command[4] = 0;
if(stream.IsEOF()) break;
if(!strcmp(command, "FHDR"))
{
ExecuteFHDR(stream);
}
else if(!strcmp(command, "DIFF"))
{
ExecuteDIFF(stream);
}
else if(!strcmp(command, "HIST"))
{
ExecuteHIST(stream);
}
else if(!strcmp(command, "APLY"))
{
ExecuteAPLY(stream);
}
else if(!strcmp(command, "ADIR"))
{
ExecuteADIR(stream);
}
else if(!strcmp(command, "DELD"))
{
ExecuteDELD(stream);
}
else if(!strcmp(command, "ETRY"))
{
ExecuteETRY(stream);
}
else
{
throw std::runtime_error("Unhandled command encountered.");
}
if(stream.IsEOF()) break;
}
m_result.succeeded = true;
}
void CPatchFile::ExecuteETRY(Framework::CStream& inputStream)
{
uint32 pathSize = inputStream.Read32_MSBF();
std::vector<char> pathData(pathSize);
inputStream.Read(pathData.data(), pathSize);
std::string path(std::begin(pathData), std::end(pathData));
auto fullFilePath = m_gameLocationPath / path;
auto fullFileDirectory = fullFilePath;
fullFileDirectory.remove_leaf();
fullFileDirectory.make_preferred();
fullFilePath.make_preferred();
if(!boost::filesystem::exists(fullFileDirectory))
{
m_result.messages.push_back(string_format("Warning: Directory '%s' doesn't exist. Creating.",
fullFileDirectory.string().c_str()
));
boost::filesystem::create_directories(fullFileDirectory);
}
if(!boost::filesystem::exists(fullFilePath))
{
m_result.messages.push_back(string_format("Warning: File '%s' doesn't exist. Creating.", fullFilePath.string().c_str()));
}
uint32 itemCount = inputStream.Read32_MSBF();
for(unsigned int i = 0; i < itemCount; i++)
{
//0x41 = last hash, 0x44 = first hash, 0x4D = both hashes?
uint32 hashMode = inputStream.Read32();
assert(hashMode == 0x41 || hashMode == 0x44 || hashMode == 0x4D);
uint8 srcFileHash[0x14];
uint8 dstFileHash[0x14];
inputStream.Read(srcFileHash, sizeof(srcFileHash));
inputStream.Read(dstFileHash, sizeof(dstFileHash));
//4E is no compression
//5A is zlib compression
uint32 compressionMode = inputStream.Read32();
assert((compressionMode == 0x4E) || (compressionMode == 0x5A));
uint32 compressedFileSize = inputStream.Read32_MSBF();
uint32 previousFileSize = inputStream.Read32_MSBF();
uint32 newFileSize = inputStream.Read32_MSBF();
if(i != (itemCount - 1))
{
assert(compressedFileSize == 0);
}
if(compressedFileSize == 0) continue;
//Data starts here
{
//Retrying here because explorer.exe can sometimes open the ffxiv*.exe files to load
//the icons making the open operation fail if we need to patch it again.
auto outputStream = CreateOutputStdStreamWithRetry(fullFilePath.native());
if(compressionMode == 0x4E)
{
ExtractUncompressed(outputStream, inputStream, compressedFileSize);
}
else if(compressionMode == 0x5A)
{
ExtractCompressed(outputStream, inputStream, compressedFileSize);
}
else
{
throw std::runtime_error("Unknown compression type.");
}
}
}
inputStream.Seek(0x08, Framework::STREAM_SEEK_CUR);
}
void CPatchFile::ExecuteAPLY(Framework::CStream& stream)
{
uint32 values[5];
stream.Read(values, sizeof(values));
}
void CBaseSection::Read(Framework::CStream& inputStream)
{
inputStream.Read(&m_header, sizeof(SEDB_HEADER));
assert(m_header.sectionId == 'BDES');
}
void CStreamChunk::ReadStream(Framework::CStream& inputStream)
{
m_data.resize(m_vertexCount * m_bytesPerVertex);
inputStream.Read(m_data.data(), m_vertexCount * m_bytesPerVertex);
}
void CResourceSection::Read(Framework::CStream& inputStream)
{
CBaseSection::Read(inputStream);
SEDBRES_HEADER header = {};
inputStream.Read(&header, sizeof(SEDBRES_HEADER));
std::vector<SEDBRES_ENTRY> entries;
entries.resize(header.resourceCount);
inputStream.Read(entries.data(), header.resourceCount * sizeof(SEDBRES_ENTRY));
uint64 basePosition = inputStream.Tell();
assert(header.resourceCount >= 2);
const auto& resourceTypeEntry = entries[header.resourceCount - 2];
const auto& resourceIdEntry = entries[header.resourceCount - 1];
std::vector<uint32> resourceTypes;
resourceTypes.resize(header.resourceCount);
inputStream.Seek(basePosition + resourceTypeEntry.offset, Framework::STREAM_SEEK_SET);
inputStream.Read(resourceTypes.data(), sizeof(uint32) * header.resourceCount);
//Read resource ids
std::vector<std::string> resourceIds;
for(unsigned int i = 0; i < header.resourceCount; i++)
{
inputStream.Seek(basePosition + resourceIdEntry.offset + (i * 0x10), Framework::STREAM_SEEK_SET);
resourceIds.push_back(inputStream.ReadString());
}
//Read string table
inputStream.Seek(basePosition + header.stringsOffset, Framework::STREAM_SEEK_SET);
std::vector<std::string> strings;
for(unsigned int i = 0; i < header.stringCount; i++)
{
strings.push_back(inputStream.ReadString());
}
for(unsigned int i = 0; i < header.resourceCount; i++)
{
const auto& entry = entries[i];
if(entry.type == 0 || entry.size == 0) continue;
uint32 resourceType = resourceTypes[i];
inputStream.Seek(basePosition + entry.offset, Framework::STREAM_SEEK_SET);
SectionPtr section;
switch(resourceType)
{
case '\0trb':
case '\0bin':
section = std::make_shared<CResourceSection>();
break;
case 'sdrb':
section = std::make_shared<CShaderSection>();
break;
case '\0wrb':
section = std::make_shared<CModelSection>();
break;
case '\0skl':
section = std::make_shared<CSkeletonSection>();
break;
case '\0phb':
section = std::make_shared<CPhbSection>();
break;
case '\0txb':
section = std::make_shared<CTextureSection>();
break;
default:
assert(0);
break;
}
if(section)
{
AddChild(section);
section->Read(inputStream);
section->SetResourceId(resourceIds[i]);
section->SetResourcePath(strings[i]);
}
}
inputStream.Seek(basePosition, Framework::STREAM_SEEK_SET);
}
void CSave::ReadName(Framework::CStream& inputStream)
{
char sNameSJIS[68];
inputStream.Read(sNameSJIS, 68);
m_sName = string_cast_sjis(sNameSJIS);
}
