AxioDL
/
amuse
mirror of https://github.com/AxioDL/amuse.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
amuse/lib/ContainerRegistry.cpp

1998 lines
62 KiB
C++
Raw Blame History

#include "amuse/ContainerRegistry.hpp"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <string>
#include <unordered_map>
#include "amuse/Common.hpp"
#include <zlib.h>
#include <lzokay.hpp>
#if __SWITCH__
/*-
* Copyright (c) 2005 Pascal Gloor <pascal.gloor@spale.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
static void* memmem(const void* l, size_t l_len, const void* s, size_t s_len) {
char *cur, *last;
const char* cl = (const char*)l;
const char* cs = (const char*)s;
/* we need something to compare */
if (l_len == 0 || s_len == 0)
return NULL;
/* "s" must be smaller or equal to "l" */
if (l_len < s_len)
return NULL;
/* special case where s_len == 1 */
if (s_len == 1)
return memchr(l, (int)*cs, l_len);
/* the last position where its possible to find "s" in "l" */
last = (char*)cl + l_len - s_len;
for (cur = (char*)cl; cur <= last; cur++)
if (cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
return cur;
return NULL;
}
#endif
#if _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <Stringapiset.h>
static void* memmem(const void* haystack, size_t hlen, const void* needle, size_t nlen) {
int needle_first;
const uint8_t* p = static_cast<const uint8_t*>(haystack);
size_t plen = hlen;
if (!nlen)
return NULL;
needle_first = *(unsigned char*)needle;
while (plen >= nlen && (p = static_cast<const uint8_t*>(memchr(p, needle_first, plen - nlen + 1)))) {
if (!memcmp(p, needle, nlen))
return (void*)p;
p++;
plen = hlen - (p - static_cast<const uint8_t*>(haystack));
}
return NULL;
}
static amuse::SystemString StrToSys(const std::string& str) {
std::wstring ret;
int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.size(), nullptr, 0);
ret.assign(len, L'\0');
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.size(), &ret[0], len);
return ret;
}
#else
static amuse::SystemString StrToSys(const std::string& str) { return str; }
#endif
namespace amuse {
const SystemChar* ContainerRegistry::TypeToName(Type tp) {
switch (tp) {
case Type::Invalid:
default:
return nullptr;
case Type::Raw4:
return _SYS_STR("4 RAW Chunks");
case Type::MetroidPrime:
return _SYS_STR("Metroid Prime (GCN)");
case Type::MetroidPrime2:
return _SYS_STR("Metroid Prime 2 (GCN)");
case Type::RogueSquadronPC:
return _SYS_STR("Star Wars - Rogue Squadron (PC)");
case Type::RogueSquadronN64:
return _SYS_STR("Star Wars - Rogue Squadron (N64)");
case Type::Factor5N64Rev:
return _SYS_STR("Factor5 Revision ROM (N64)");
case Type::RogueSquadron2:
return _SYS_STR("Star Wars - Rogue Squadron 2 (GCN)");
case Type::RogueSquadron3:
return _SYS_STR("Star Wars - Rogue Squadron 3 (GCN)");
}
}
static size_t FileLength(FILE* fp) {
FSeek(fp, 0, SEEK_END);
int64_t endPos = FTell(fp);
fseek(fp, 0, SEEK_SET);
return size_t(endPos);
}
static SystemString ReadString(FILE* fp) {
char byte;
SystemString ret;
while (fread(&byte, 1, 1, fp) == 1 && byte != 0)
ret.push_back(byte);
return ret;
}
static bool IsChunkExtension(const SystemChar* path, const SystemChar*& dotOut) {
const SystemChar* ext = StrRChr(path, _SYS_STR('.'));
if (ext) {
if (!CompareCaseInsensitive(ext, _SYS_STR(".poo")) || !CompareCaseInsensitive(ext, _SYS_STR(".pool")) ||
!CompareCaseInsensitive(ext, _SYS_STR(".pro")) || !CompareCaseInsensitive(ext, _SYS_STR(".proj")) ||
!CompareCaseInsensitive(ext, _SYS_STR(".sdi")) || !CompareCaseInsensitive(ext, _SYS_STR(".sdir")) ||
!CompareCaseInsensitive(ext, _SYS_STR(".sam")) || !CompareCaseInsensitive(ext, _SYS_STR(".samp"))) {
dotOut = ext;
return true;
}
}
return false;
}
static bool IsSongExtension(const SystemChar* path, const SystemChar*& dotOut) {
const SystemChar* ext = StrRChr(path, _SYS_STR('.'));
if (ext) {
if (!CompareCaseInsensitive(ext, _SYS_STR(".son")) || !CompareCaseInsensitive(ext, _SYS_STR(".sng")) ||
!CompareCaseInsensitive(ext, _SYS_STR(".song"))) {
dotOut = ext;
return true;
}
}
return false;
}
static bool ValidateMP1(FILE* fp) {
if (FileLength(fp) > 40 * 1024 * 1024)
return false;
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 8, SEEK_CUR);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
FSeek(fp, nameLen, SEEK_CUR);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
FSeek(fp, 4, SEEK_CUR);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
FSeek(fp, 8, SEEK_CUR);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x41475343) {
int64_t origPos = FTell(fp);
FSeek(fp, offset, SEEK_SET);
char testBuf[6];
if (fread(testBuf, 1, 6, fp) == 6) {
if (!memcmp(testBuf, "Audio/", 6))
return true;
else
return false;
}
FSeek(fp, origPos, SEEK_SET);
}
}
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadMP1(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
FileLength(fp);
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 8, SEEK_CUR);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
FSeek(fp, nameLen, SEEK_CUR);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
ret.reserve(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
FSeek(fp, 4, SEEK_CUR);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
FSeek(fp, 8, SEEK_CUR);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x41475343) {
int64_t origPos = FTell(fp);
FSeek(fp, offset, SEEK_SET);
char testBuf[6];
if (fread(testBuf, 1, 6, fp) == 6) {
if (!memcmp(testBuf, "Audio/", 6)) {
FSeek(fp, offset, SEEK_SET);
ReadString(fp);
SystemString name = ReadString(fp);
uint32_t poolLen;
fread(&poolLen, 1, 4, fp);
poolLen = SBig(poolLen);
std::unique_ptr<uint8_t[]> pool(new uint8_t[poolLen]);
fread(pool.get(), 1, poolLen, fp);
uint32_t projLen;
fread(&projLen, 1, 4, fp);
projLen = SBig(projLen);
std::unique_ptr<uint8_t[]> proj(new uint8_t[projLen]);
fread(proj.get(), 1, projLen, fp);
uint32_t sampLen;
fread(&sampLen, 1, 4, fp);
sampLen = SBig(sampLen);
std::unique_ptr<uint8_t[]> samp(new uint8_t[sampLen]);
fread(samp.get(), 1, sampLen, fp);
uint32_t sdirLen;
fread(&sdirLen, 1, 4, fp);
sdirLen = SBig(sdirLen);
std::unique_ptr<uint8_t[]> sdir(new uint8_t[sdirLen]);
fread(sdir.get(), 1, sdirLen, fp);
ret.emplace_back(std::move(name),
IntrusiveAudioGroupData{proj.release(), projLen, pool.release(), poolLen, sdir.release(),
sdirLen, samp.release(), sampLen, GCNDataTag{}});
}
}
FSeek(fp, origPos, SEEK_SET);
}
}
}
return ret;
}
static bool ValidateMP1Songs(FILE* fp) {
if (FileLength(fp) > 40 * 1024 * 1024)
return false;
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 8, SEEK_CUR);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
FSeek(fp, nameLen, SEEK_CUR);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
FSeek(fp, 4, SEEK_CUR);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
FSeek(fp, 8, SEEK_CUR);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x43534E47)
return true;
}
}
return false;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadMP1Songs(FILE* fp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
FileLength(fp);
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
std::unordered_map<uint32_t, SystemString> names;
names.reserve(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 4, SEEK_CUR);
uint32_t id;
fread(&id, 1, 4, fp);
id = SBig(id);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
std::string str(nameLen, '\0');
fread(&str[0], 1, nameLen, fp);
names[id] = StrToSys(str);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
ret.reserve(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
FSeek(fp, 4, SEEK_CUR);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
uint32_t id;
fread(&id, 1, 4, fp);
id = SBig(id);
uint32_t size;
fread(&size, 1, 4, fp);
size = SBig(size);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x43534E47) {
int64_t origPos = FTell(fp);
FSeek(fp, offset + 4, SEEK_SET);
uint32_t midiSetup;
fread(&midiSetup, 1, 4, fp);
midiSetup = SBig(midiSetup);
uint32_t groupId;
fread(&groupId, 1, 4, fp);
groupId = SBig(groupId);
FSeek(fp, 4, SEEK_CUR);
uint32_t sonLength;
fread(&sonLength, 1, 4, fp);
sonLength = SBig(sonLength);
std::unique_ptr<uint8_t[]> song(new uint8_t[sonLength]);
fread(song.get(), 1, sonLength, fp);
auto search = names.find(id);
if (search != names.end())
ret.emplace_back(std::move(search->second),
ContainerRegistry::SongData(std::move(song), sonLength, groupId, midiSetup));
else {
SystemString name = fmt::format(FMT_STRING(_SYS_STR("{:08X}")), id);
ret.emplace_back(std::move(name), ContainerRegistry::SongData(std::move(song), sonLength, groupId, midiSetup));
}
FSeek(fp, origPos, SEEK_SET);
}
}
}
return ret;
}
static bool ValidateMP2(FILE* fp) {
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 8, SEEK_CUR);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
FSeek(fp, nameLen, SEEK_CUR);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
uint32_t compressed;
fread(&compressed, 1, 4, fp);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
FSeek(fp, 8, SEEK_CUR);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x41475343) {
int64_t origPos = FTell(fp);
FSeek(fp, offset, SEEK_SET);
char testBuf[4];
if (!compressed) {
if (fread(testBuf, 1, 4, fp) != 4)
return false;
} else {
FSeek(fp, 4, SEEK_CUR);
uint16_t chunkSz;
fread(&chunkSz, 1, 2, fp);
chunkSz = SBig(chunkSz);
uint8_t compBuf[0x8000];
uint8_t destBuf[0x8000 * 2];
fread(compBuf, 1, chunkSz, fp);
size_t dsz;
lzokay::decompress(compBuf, chunkSz, destBuf, 0x8000 * 2, dsz);
memcpy(testBuf, destBuf, 4);
}
if (amuse::SBig(*reinterpret_cast<uint32_t*>(testBuf)) == 0x1)
return true;
else
return false;
FSeek(fp, origPos, SEEK_SET);
}
}
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadMP2(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
FileLength(fp);
uint32_t magic;
fread(&magic, 1, 4, fp);
magic = SBig(magic);
if (magic == 0x00030005) {
FSeek(fp, 8, SEEK_SET);
uint32_t nameCount;
fread(&nameCount, 1, 4, fp);
nameCount = SBig(nameCount);
for (uint32_t i = 0; i < nameCount; ++i) {
FSeek(fp, 8, SEEK_CUR);
uint32_t nameLen;
fread(&nameLen, 1, 4, fp);
nameLen = SBig(nameLen);
FSeek(fp, nameLen, SEEK_CUR);
}
uint32_t resCount;
fread(&resCount, 1, 4, fp);
resCount = SBig(resCount);
ret.reserve(resCount);
for (uint32_t i = 0; i < resCount; ++i) {
uint32_t compressed;
fread(&compressed, 1, 4, fp);
uint32_t type;
fread(&type, 1, 4, fp);
type = SBig(type);
FSeek(fp, 8, SEEK_CUR);
uint32_t offset;
fread(&offset, 1, 4, fp);
offset = SBig(offset);
if (type == 0x41475343) {
int64_t origPos = FTell(fp);
FSeek(fp, offset, SEEK_SET);
char testBuf[4];
FILE* old_fp = fp;
if (compressed) {
uint32_t decompSz;
fread(&decompSz, 1, 4, fp);
decompSz = SBig(decompSz);
uint8_t compBuf[0x8000];
uint8_t* buf = new uint8_t[decompSz];
uint8_t* bufCur = buf;
uint32_t rem = decompSz;
while (rem) {
uint16_t chunkSz;
fread(&chunkSz, 1, 2, fp);
chunkSz = SBig(chunkSz);
fread(compBuf, 1, chunkSz, fp);
size_t dsz;
lzokay::decompress(compBuf, chunkSz, bufCur, rem, dsz);
bufCur += dsz;
rem -= dsz;
}
fp = FOpen(_SYS_STR("amuse_tmp.dat"), _SYS_STR("rw"));
rewind(fp);
fwrite(buf, 1, decompSz, fp);
rewind(fp);
}
if (fread(testBuf, 1, 4, fp) == 4) {
if (amuse::SBig(*reinterpret_cast<uint32_t*>(testBuf)) == 0x1) {
FSeek(fp, offset + 4, SEEK_SET);
SystemString name = ReadString(fp);
FSeek(fp, 2, SEEK_CUR);
uint32_t poolSz;
fread(&poolSz, 1, 4, fp);
poolSz = SBig(poolSz);
uint32_t projSz;
fread(&projSz, 1, 4, fp);
projSz = SBig(projSz);
uint32_t sdirSz;
fread(&sdirSz, 1, 4, fp);
sdirSz = SBig(sdirSz);
uint32_t sampSz;
fread(&sampSz, 1, 4, fp);
sampSz = SBig(sampSz);
if (projSz && poolSz && sdirSz && sampSz) {
std::unique_ptr<uint8_t[]> pool(new uint8_t[poolSz]);
fread(pool.get(), 1, poolSz, fp);
std::unique_ptr<uint8_t[]> proj(new uint8_t[projSz]);
fread(proj.get(), 1, projSz, fp);
std::unique_ptr<uint8_t[]> sdir(new uint8_t[sdirSz]);
fread(sdir.get(), 1, sdirSz, fp);
std::unique_ptr<uint8_t[]> samp(new uint8_t[sampSz]);
fread(samp.get(), 1, sampSz, fp);
ret.emplace_back(std::move(name),
IntrusiveAudioGroupData{proj.release(), projSz, pool.release(), poolSz, sdir.release(),
sdirSz, samp.release(), sampSz, GCNDataTag{}});
}
}
}
if (compressed) {
fclose(fp);
Unlink(_SYS_STR("amuse_tmp.dat"));
}
fp = old_fp;
FSeek(fp, origPos, SEEK_SET);
}
}
}
return ret;
}
struct RS1FSTEntry {
uint32_t offset;
uint32_t decompSz;
uint32_t compSz;
uint16_t type;
uint16_t childCount;
char name[16];
void swapBig() {
offset = SBig(offset);
decompSz = SBig(decompSz);
compSz = SBig(compSz);
type = SBig(type);
childCount = SBig(childCount);
}
};
static void SwapN64Rom16(void* data, size_t size) {
uint16_t* words = reinterpret_cast<uint16_t*>(data);
for (size_t i = 0; i < size / 2; ++i)
words[i] = SBig(words[i]);
}
static void SwapN64Rom32(void* data, size_t size) {
uint32_t* words = reinterpret_cast<uint32_t*>(data);
for (size_t i = 0; i < size / 4; ++i)
words[i] = SBig(words[i]);
}
static const struct RS1SongMapping {
const char* name;
int songId;
} RS1Mappings[] = {{"logo1_SNG", 0}, {"roguetitle_SNG", 1},
{"roguetheme_SNG", 1}, {"title_SNG", 2},
{"hangar1_SNG", 3}, {"hangar2_SNG", 3},
{"hangar3_SNG", 3}, {"jingle01_SNG", 4},
{"jingle02_SNG", 4}, {"jingle03_SNG", 4},
{"jingle04_SNG", 4}, {"jingle05_SNG", 4},
{"jingle06_SNG", 4}, {"jingle07_SNG", 4},
{"jingle08_SNG", 4}, {"c1l1_theme_SNG", 4},
{"c1l1_prob1_SNG", 4}, {"c1l1_prob2_SNG", 4},
{"c1l1_spc01_SNG", 4}, {"c1l1_spc02_SNG", 4},
{"c1l2_theme_SNG", 5}, {"c1l2_spc01_SNG", 5},
{"c1l3_spc01_SNG", 6}, {"c1l3_theme_SNG", 6},
{"c1l4_spc01_SNG", 7}, {"c1l4_theme_SNG", 7},
{"action1_SNG", 7}, {"action1b_SNG", 7},
{"action2_SNG", 7}, {"action4_SNG", 7},
{"action5_SNG", 7}, {"action6_SNG", 7},
{"action7_SNG", 7}, {"c1l5_act01_SNG", 8},
{"c1l5_act02_SNG", 8}, {"c1l5_theme_SNG", 8},
{"c1l5_spc01_SNG", 8}, {"c2l1_theme_SNG", 9},
{"c2l1_spc01_SNG", 9}, {"imperial_SNG", 10},
{"c2l2_theme_SNG", 10}, {"c2l2_spc01_SNG", 10},
{"c3l5_theme_SNG", 10}, {"c2l3_theme_SNG", 11},
{"c2l3_spc01_SNG", 11}, {"c2l5_theme_SNG", 12},
{"c2l5_spc01_SNG", 12}, {"c5l1_start_SNG", 12},
{"c4l1_theme_SNG", 12}, {"c5l1_1_SNG", 12},
{"c5l1_2_SNG", 12}, {"c5l1_3_SNG", 12},
{"c3l1_theme_SNG", 13}, {"c5l2_theme_SNG", 13},
{"c5l2_spc01_SNG", 13}, {"c5l3_theme_SNG", 13},
{"c3l2_theme_SNG", 14}, {"silent01_SNG", 14},
{"silent02_SNG", 14}, {"c3l5_spc01_SNG", 14},
{"c3l4_theme_SNG", 14}, {"c3l4_spc01_SNG", 14},
{"credits_SNG", 20}, {"c1l1_cut1_SNG", 30},
{"c1l2_cut1_SNG", 30}, {"c1l3_cut1_SNG", 30},
{"c1l4_cut1_SNG", 30}, {"c1l5_cut1_SNG", 30},
{"c2l1_cut1_SNG", 30}, {"c2l2_cut1_SNG", 30},
{"c2l3_cut1_SNG", 30}, {"c2l5_cut1_SNG", 30},
{"c2l6_cut1_SNG", 30}, {"c3l1_cut1_SNG", 30},
{"c3l2_cut1_SNG", 30}, {"c3l3_cut1_SNG", 30},
{"c3l4_cut1_SNG", 30}, {"c3l5_cut1_SNG", 30},
{"c4l1_cut1_SNG", 30}, {"c5l1_cut1_SNG", 30},
{"c5l2_cut1_SNG", 30}, {"c5l3_cut1_SNG", 30},
{"extr_cut1_SNG", 30}, {"cut_jing1_SNG", 30},
{"cut_jing2_SNG", 30}, {"cut_seq1_SNG", 30},
{"cut_seq2_SNG", 30}, {"cut_seq3_SNG", 30},
{"cut_seq4_SNG", 30}, {"cut_seq5_SNG", 30},
{"cut_seq6_SNG", 30}, {"cut_seq7_SNG", 30},
{"cut_seq8_SNG", 30}, {}};
static int LookupRS1SongId(const char* name) {
const RS1SongMapping* map = RS1Mappings;
while (map->name) {
if (!strcmp(name, map->name))
return map->songId;
++map;
}
return -1;
}
static bool ValidateRS1PC(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 100 * 1024 * 1024)
return false;
uint32_t fstOff;
uint32_t fstSz;
if (fread(&fstOff, 1, 4, fp) == 4 && fread(&fstSz, 1, 4, fp) == 4) {
if (fstOff + fstSz <= endPos) {
FSeek(fp, fstOff, SEEK_SET);
uint32_t elemCount = fstSz / 32;
std::unique_ptr<RS1FSTEntry[]> entries(new RS1FSTEntry[elemCount]);
fread(entries.get(), fstSz, 1, fp);
uint8_t foundComps = 0;
for (uint32_t i = 0; i < elemCount; ++i) {
RS1FSTEntry& entry = entries[i];
if (!strncmp("proj_SND", entry.name, 16))
foundComps |= 1;
else if (!strncmp("pool_SND", entry.name, 16))
foundComps |= 2;
else if (!strncmp("sdir_SND", entry.name, 16))
foundComps |= 4;
else if (!strncmp("samp_SND", entry.name, 16))
foundComps |= 8;
}
if (foundComps == 0xf)
return true;
}
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadRS1PC(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
size_t endPos = FileLength(fp);
uint32_t fstOff;
uint32_t fstSz;
if (fread(&fstOff, 1, 4, fp) == 4 && fread(&fstSz, 1, 4, fp) == 4) {
if (fstOff + fstSz <= endPos) {
FSeek(fp, fstOff, SEEK_SET);
uint32_t elemCount = fstSz / 32;
std::unique_ptr<RS1FSTEntry[]> entries(new RS1FSTEntry[elemCount]);
fread(entries.get(), fstSz, 1, fp);
std::unique_ptr<uint8_t[]> proj;
size_t projSz = 0;
std::unique_ptr<uint8_t[]> pool;
size_t poolSz = 0;
std::unique_ptr<uint8_t[]> sdir;
size_t sdirSz = 0;
std::unique_ptr<uint8_t[]> samp;
size_t sampSz = 0;
for (uint32_t i = 0; i < elemCount; ++i) {
RS1FSTEntry& entry = entries[i];
if (!strncmp("proj_SND", entry.name, 16)) {
projSz = entry.decompSz;
proj.reset(new uint8_t[entry.decompSz]);
FSeek(fp, entry.offset, SEEK_SET);
fread(proj.get(), 1, entry.decompSz, fp);
} else if (!strncmp("pool_SND", entry.name, 16)) {
poolSz = entry.decompSz;
pool.reset(new uint8_t[entry.decompSz]);
FSeek(fp, entry.offset, SEEK_SET);
fread(pool.get(), 1, entry.decompSz, fp);
} else if (!strncmp("sdir_SND", entry.name, 16)) {
sdirSz = entry.decompSz;
sdir.reset(new uint8_t[entry.decompSz]);
FSeek(fp, entry.offset, SEEK_SET);
fread(sdir.get(), 1, entry.decompSz, fp);
} else if (!strncmp("samp_SND", entry.name, 16)) {
sampSz = entry.decompSz;
samp.reset(new uint8_t[entry.decompSz]);
FSeek(fp, entry.offset, SEEK_SET);
fread(samp.get(), 1, entry.decompSz, fp);
}
}
ret.emplace_back(_SYS_STR("Group"),
IntrusiveAudioGroupData{proj.release(), projSz, pool.release(), poolSz, sdir.release(), sdirSz,
samp.release(), sampSz, false, PCDataTag{}});
}
}
return ret;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadRS1PCSongs(FILE* fp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
size_t endPos = FileLength(fp);
uint32_t fstOff;
uint32_t fstSz;
if (fread(&fstOff, 1, 4, fp) == 4 && fread(&fstSz, 1, 4, fp) == 4) {
if (fstOff + fstSz <= endPos) {
FSeek(fp, fstOff, SEEK_SET);
uint32_t elemCount = fstSz / 32;
std::unique_ptr<RS1FSTEntry[]> entries(new RS1FSTEntry[elemCount]);
fread(entries.get(), fstSz, 1, fp);
for (uint32_t i = 0; i < elemCount; ++i) {
RS1FSTEntry& entry = entries[i];
if (strstr(entry.name, "SNG")) {
std::unique_ptr<uint8_t[]> song(new uint8_t[entry.decompSz]);
FSeek(fp, entry.offset, SEEK_SET);
fread(song.get(), 1, entry.decompSz, fp);
SystemString name = StrToSys(entry.name);
ret.emplace_back(
name, ContainerRegistry::SongData(std::move(song), entry.decompSz, -1, LookupRS1SongId(entry.name)));
}
}
}
}
return ret;
}
static bool ValidateRS1N64(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 32 * 1024 * 1024)
return false; /* N64 ROM definitely won't exceed 32MB */
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
#if 0
const uint32_t* gameId = reinterpret_cast<const uint32_t*>(&data[59]);
if (*gameId != 0x4553524e && *gameId != 0x4a53524e && *gameId != 0x5053524e)
return false; /* GameId not 'NRSE', 'NRSJ', or 'NRSP' */
#endif
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return false;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
uint8_t foundComps = 0;
for (; entry != lastEnt; ++entry) {
if (!strncmp("proj_SND", entry->name, 16))
foundComps |= 1;
else if (!strncmp("pool_SND", entry->name, 16))
foundComps |= 2;
else if (!strncmp("sdir_SND", entry->name, 16))
foundComps |= 4;
else if (!strncmp("samp_SND", entry->name, 16))
foundComps |= 8;
}
if (foundComps == 0xf)
return true;
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadRS1N64(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
size_t endPos = FileLength(fp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return ret;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
std::unique_ptr<uint8_t[]> proj;
size_t projSz = 0;
std::unique_ptr<uint8_t[]> pool;
size_t poolSz = 0;
std::unique_ptr<uint8_t[]> sdir;
size_t sdirSz = 0;
std::unique_ptr<uint8_t[]> samp;
size_t sampSz = 0;
for (; entry != lastEnt; ++entry) {
RS1FSTEntry ent = *entry;
ent.swapBig();
if (!strncmp("proj_SND", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
proj.reset(new uint8_t[ent.decompSz]);
memmove(proj.get(), dataSeg + ent.offset, ent.decompSz);
} else {
proj.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(proj.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
projSz = ent.decompSz;
} else if (!strncmp("pool_SND", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
pool.reset(new uint8_t[ent.decompSz]);
memmove(pool.get(), dataSeg + ent.offset, ent.decompSz);
} else {
pool.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(pool.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
poolSz = ent.decompSz;
} else if (!strncmp("sdir_SND", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
sdir.reset(new uint8_t[ent.decompSz]);
memmove(sdir.get(), dataSeg + ent.offset, ent.decompSz);
} else {
sdir.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(sdir.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
sdirSz = ent.decompSz;
} else if (!strncmp("samp_SND", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
samp.reset(new uint8_t[ent.decompSz]);
memmove(samp.get(), dataSeg + ent.offset, ent.decompSz);
} else {
samp.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(samp.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
sampSz = ent.decompSz;
}
}
ret.emplace_back(_SYS_STR("Group"),
IntrusiveAudioGroupData{proj.release(), projSz, pool.release(), poolSz, sdir.release(), sdirSz,
samp.release(), sampSz, false, N64DataTag{}});
}
return ret;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadRS1N64Songs(FILE* fp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
size_t endPos = FileLength(fp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return ret;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
for (; entry != lastEnt; ++entry) {
RS1FSTEntry ent = *entry;
ent.swapBig();
if (strstr(ent.name, "SNG")) {
std::unique_ptr<uint8_t[]> song(new uint8_t[ent.decompSz]);
if (ent.compSz == 0xffffffff) {
memmove(song.get(), dataSeg + ent.offset, ent.decompSz);
} else {
uLongf outSz = ent.decompSz;
uncompress(song.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
SystemString name = StrToSys(ent.name);
ret.emplace_back(name,
ContainerRegistry::SongData(std::move(song), ent.decompSz, -1, LookupRS1SongId(ent.name)));
}
}
}
return ret;
}
static bool ValidateFactor5N64Rev(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 32 * 1024 * 1024)
return false; /* N64 ROM definitely won't exceed 32MB */
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
#if 0
const uint32_t* gameId = reinterpret_cast<const uint32_t*>(&data[59]);
if (*gameId != 0x4553524e && *gameId != 0x4a53524e && *gameId != 0x5053524e)
return false; /* GameId not 'NRSE', 'NRSJ', or 'NRSP' */
#endif
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return false;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
uint8_t foundComps = 0;
for (; entry != lastEnt; ++entry) {
if (!strncmp("proj", entry->name, 16))
foundComps |= 1;
else if (!strncmp("pool", entry->name, 16))
foundComps |= 2;
else if (!strncmp("sdir", entry->name, 16))
foundComps |= 4;
else if (!strncmp("samp", entry->name, 16))
foundComps |= 8;
}
if (foundComps == 0xf)
return true;
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadFactor5N64Rev(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
size_t endPos = FileLength(fp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return ret;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
std::unique_ptr<uint8_t[]> proj;
size_t projSz = 0;
std::unique_ptr<uint8_t[]> pool;
size_t poolSz = 0;
std::unique_ptr<uint8_t[]> sdir;
size_t sdirSz = 0;
std::unique_ptr<uint8_t[]> samp;
size_t sampSz = 0;
for (; entry != lastEnt; ++entry) {
RS1FSTEntry ent = *entry;
ent.swapBig();
if (!strncmp("proj", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
proj.reset(new uint8_t[ent.decompSz]);
memmove(proj.get(), dataSeg + ent.offset, ent.decompSz);
} else {
proj.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(proj.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
projSz = ent.decompSz;
} else if (!strncmp("pool", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
pool.reset(new uint8_t[ent.decompSz]);
memmove(pool.get(), dataSeg + ent.offset, ent.decompSz);
} else {
pool.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(pool.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
poolSz = ent.decompSz;
} else if (!strncmp("sdir", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
sdir.reset(new uint8_t[ent.decompSz]);
memmove(sdir.get(), dataSeg + ent.offset, ent.decompSz);
} else {
sdir.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(sdir.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
sdirSz = ent.decompSz;
} else if (!strncmp("samp", ent.name, 16)) {
if (ent.compSz == 0xffffffff) {
samp.reset(new uint8_t[ent.decompSz]);
memmove(samp.get(), dataSeg + ent.offset, ent.decompSz);
} else {
samp.reset(new uint8_t[ent.decompSz]);
uLongf outSz = ent.decompSz;
uncompress(samp.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
sampSz = ent.decompSz;
}
}
ret.emplace_back(_SYS_STR("Group"),
IntrusiveAudioGroupData{proj.release(), projSz, pool.release(), poolSz, sdir.release(), sdirSz,
samp.release(), sampSz, true, N64DataTag{}});
}
return ret;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadFactor5N64RevSongs(FILE* fp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
size_t endPos = FileLength(fp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
if ((data[0] & 0x80) != 0x80 && (data[3] & 0x80) == 0x80)
SwapN64Rom32(data.get(), endPos);
else if ((data[0] & 0x80) != 0x80 && (data[1] & 0x80) == 0x80)
SwapN64Rom16(data.get(), endPos);
const uint8_t* dataSeg = reinterpret_cast<const uint8_t*>(memmem(data.get(), endPos, "dbg_data\0\0\0\0\0\0\0\0", 16));
if (dataSeg) {
dataSeg += 28;
size_t fstEnd = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
dataSeg += 4;
size_t fstOff = SBig(*reinterpret_cast<const uint32_t*>(dataSeg));
if (endPos <= size_t(dataSeg - data.get()) + fstOff || endPos <= size_t(dataSeg - data.get()) + fstEnd)
return ret;
const RS1FSTEntry* entry = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstOff);
const RS1FSTEntry* lastEnt = reinterpret_cast<const RS1FSTEntry*>(dataSeg + fstEnd);
for (; entry != lastEnt; ++entry) {
RS1FSTEntry ent = *entry;
ent.swapBig();
if (!strncmp(ent.name, "s_", 2)) {
long idx = strtol(ent.name + 2, nullptr, 10);
std::unique_ptr<uint8_t[]> song(new uint8_t[ent.decompSz]);
if (ent.compSz == 0xffffffff) {
memmove(song.get(), dataSeg + ent.offset, ent.decompSz);
} else {
uLongf outSz = ent.decompSz;
uncompress(song.get(), &outSz, dataSeg + ent.offset, ent.compSz);
}
SystemString name = StrToSys(ent.name);
ret.emplace_back(name, ContainerRegistry::SongData(std::move(song), ent.decompSz, -1, idx));
}
}
}
return ret;
}
struct RS2FSTEntry {
uint64_t offset;
uint64_t decompSz;
uint64_t compSz;
uint64_t type;
char name[32];
void swapBig() {
offset = SBig(offset);
decompSz = SBig(decompSz);
compSz = SBig(compSz);
type = SBig(type);
}
};
struct RS23GroupHead {
uint32_t projOff;
uint32_t projLen;
uint32_t poolOff;
uint32_t poolLen;
uint32_t sdirOff;
uint32_t sdirLen;
uint32_t sampOff;
uint32_t sampLen;
uint32_t unkOff;
uint32_t unkLen;
uint32_t sonCount;
uint32_t sonIdxBeginOff;
uint32_t sonIdxEndOff;
void swapBig() {
projOff = SBig(projOff);
projLen = SBig(projLen);
poolOff = SBig(poolOff);
poolLen = SBig(poolLen);
sdirOff = SBig(sdirOff);
sdirLen = SBig(sdirLen);
sampOff = SBig(sampOff);
sampLen = SBig(sampLen);
unkOff = SBig(unkOff);
unkLen = SBig(unkLen);
sonCount = SBig(sonCount);
sonIdxBeginOff = SBig(sonIdxBeginOff);
sonIdxEndOff = SBig(sonIdxEndOff);
}
};
struct RS23SONHead {
uint32_t offset;
uint32_t length;
uint16_t groupId;
uint16_t setupId;
void swapBig() {
offset = SBig(offset);
length = SBig(length);
groupId = SBig(groupId);
setupId = SBig(setupId);
}
};
static bool ValidateRS2(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 600 * 1024 * 1024)
return false;
uint64_t fstOff;
fread(&fstOff, 1, 8, fp);
fstOff = SBig(fstOff);
uint64_t fstSz;
fread(&fstSz, 1, 8, fp);
fstSz = SBig(fstSz);
if (fstOff + fstSz > endPos)
return false;
FSeek(fp, int64_t(fstOff), SEEK_SET);
for (size_t i = 0; i < fstSz / 64; ++i) {
RS2FSTEntry entry;
fread(&entry, 1, 64, fp);
entry.swapBig();
if (!entry.offset)
return false; /* This is to reject RS3 data */
if (!strncmp("data", entry.name, 32))
return true;
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadRS2(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
size_t endPos = FileLength(fp);
uint64_t fstOff;
fread(&fstOff, 1, 8, fp);
fstOff = SBig(fstOff);
uint64_t fstSz;
fread(&fstSz, 1, 8, fp);
fstSz = SBig(fstSz);
if (fstOff + fstSz > endPos)
return ret;
FSeek(fp, int64_t(fstOff), SEEK_SET);
for (size_t i = 0; i < fstSz / 64; ++i) {
RS2FSTEntry entry;
fread(&entry, 1, 64, fp);
entry.swapBig();
if (!strncmp("data", entry.name, 32)) {
FSeek(fp, int64_t(entry.offset), SEEK_SET);
std::unique_ptr<uint8_t[]> audData(new uint8_t[entry.decompSz]);
fread(audData.get(), 1, entry.decompSz, fp);
uint32_t indexOff = SBig(*reinterpret_cast<uint32_t*>(audData.get() + 4));
uint32_t groupCount = SBig(*reinterpret_cast<uint32_t*>(audData.get() + indexOff));
const uint32_t* groupOffs = reinterpret_cast<const uint32_t*>(audData.get() + indexOff + 4);
for (uint32_t j = 0; j < groupCount; ++j) {
const uint8_t* groupData = audData.get() + SBig(groupOffs[j]);
RS23GroupHead head = *reinterpret_cast<const RS23GroupHead*>(groupData);
head.swapBig();
std::unique_ptr<uint8_t[]> pool(new uint8_t[head.poolLen]);
memmove(pool.get(), audData.get() + head.poolOff, head.poolLen);
std::unique_ptr<uint8_t[]> proj(new uint8_t[head.projLen]);
memmove(proj.get(), audData.get() + head.projOff, head.projLen);
std::unique_ptr<uint8_t[]> sdir(new uint8_t[head.sdirLen]);
memmove(sdir.get(), audData.get() + head.sdirOff, head.sdirLen);
std::unique_ptr<uint8_t[]> samp(new uint8_t[head.sampLen]);
memmove(samp.get(), audData.get() + head.sampOff, head.sampLen);
if (head.projLen && head.poolLen && head.sdirLen && head.sampLen) {
SystemString name = fmt::format(FMT_STRING(_SYS_STR("GroupFile{:02d}")), j);
ret.emplace_back(std::move(name),
IntrusiveAudioGroupData{proj.release(), head.projLen, pool.release(), head.poolLen,
sdir.release(), head.sdirLen, samp.release(), head.sampLen,
GCNDataTag{}});
}
}
break;
}
}
return ret;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadRS2Songs(FILE* fp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
size_t endPos = FileLength(fp);
uint64_t fstOff;
fread(&fstOff, 1, 8, fp);
fstOff = SBig(fstOff);
uint64_t fstSz;
fread(&fstSz, 1, 8, fp);
fstSz = SBig(fstSz);
if (fstOff + fstSz > endPos)
return ret;
FSeek(fp, int64_t(fstOff), SEEK_SET);
for (size_t i = 0; i < fstSz / 64; ++i) {
RS2FSTEntry entry;
fread(&entry, 1, 64, fp);
entry.swapBig();
if (!strncmp("data", entry.name, 32)) {
FSeek(fp, int64_t(entry.offset), SEEK_SET);
std::unique_ptr<uint8_t[]> audData(new uint8_t[entry.decompSz]);
fread(audData.get(), 1, entry.decompSz, fp);
uint32_t indexOff = SBig(*reinterpret_cast<uint32_t*>(audData.get() + 4));
uint32_t groupCount = SBig(*reinterpret_cast<uint32_t*>(audData.get() + indexOff));
const uint32_t* groupOffs = reinterpret_cast<const uint32_t*>(audData.get() + indexOff + 4);
for (uint32_t j = 0; j < groupCount; ++j) {
const uint8_t* groupData = audData.get() + SBig(groupOffs[j]);
RS23GroupHead head = *reinterpret_cast<const RS23GroupHead*>(groupData);
head.swapBig();
if (!head.sonCount)
continue;
const RS23SONHead* sonData = reinterpret_cast<const RS23SONHead*>(audData.get() + head.sonIdxBeginOff);
for (uint32_t s = 0; s < head.sonCount; ++s) {
RS23SONHead sonHead = sonData[s];
sonHead.swapBig();
SystemString name = fmt::format(FMT_STRING(_SYS_STR("GroupFile{:02d}-{}")), j, s);
std::unique_ptr<uint8_t[]> song(new uint8_t[sonHead.length]);
memmove(song.get(), audData.get() + sonHead.offset, sonHead.length);
ret.emplace_back(std::move(name),
ContainerRegistry::SongData(std::move(song), sonHead.length, sonHead.groupId, sonHead.setupId));
}
}
break;
}
}
return ret;
}
struct RS3FSTEntry {
uint64_t offset;
uint64_t decompSz;
uint64_t compSz;
uint64_t type;
char name[128];
void swapBig() {
offset = SBig(offset);
decompSz = SBig(decompSz);
compSz = SBig(compSz);
type = SBig(type);
}
};
static bool ValidateRS3(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 600 * 1024 * 1024)
return false;
uint64_t fstOff;
fread(&fstOff, 1, 8, fp);
fstOff = SBig(fstOff);
uint64_t fstSz;
fread(&fstSz, 1, 8, fp);
fstSz = SBig(fstSz);
if (fstOff + fstSz > endPos)
return false;
FSeek(fp, int64_t(fstOff), SEEK_SET);
for (size_t i = 0; i < fstSz / 160; ++i) {
RS3FSTEntry entry;
fread(&entry, 1, 160, fp);
entry.swapBig();
if (!strncmp("data", entry.name, 128))
return true;
}
return false;
}
static std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> LoadRS3(FILE* fp) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
size_t endPos = FileLength(fp);
uint64_t fstOff;
fread(&fstOff, 1, 8, fp);
fstOff = SBig(fstOff);
uint64_t fstSz;
fread(&fstSz, 1, 8, fp);
fstSz = SBig(fstSz);
if (fstOff + fstSz > endPos)
return ret;
FSeek(fp, int64_t(fstOff), SEEK_SET);
for (size_t i = 0; i < fstSz / 160; ++i) {
RS3FSTEntry entry;
fread(&entry, 1, 160, fp);
entry.swapBig();
if (!strncmp("data", entry.name, 128)) {
FSeek(fp, int64_t(entry.offset), SEEK_SET);
std::unique_ptr<uint8_t[]> audData(new uint8_t[entry.decompSz]);
fread(audData.get(), 1, entry.decompSz, fp);
uint32_t indexOff = SBig(*reinterpret_cast<uint32_t*>(audData.get() + 4));
uint32_t groupCount = SBig(*reinterpret_cast<uint32_t*>(audData.get() + indexOff));
const uint32_t* groupOffs = reinterpret_cast<const uint32_t*>(audData.get() + indexOff + 4);
for (uint32_t j = 0; j < groupCount; ++j) {
const uint8_t* groupData = audData.get() + SBig(groupOffs[j]);
RS23GroupHead head = *reinterpret_cast<const RS23GroupHead*>(groupData);
head.swapBig();
std::unique_ptr<uint8_t[]> pool(new uint8_t[head.poolLen]);
memmove(pool.get(), audData.get() + head.poolOff, head.poolLen);
std::unique_ptr<uint8_t[]> proj(new uint8_t[head.projLen]);
memmove(proj.get(), audData.get() + head.projOff, head.projLen);
std::unique_ptr<uint8_t[]> sdir(new uint8_t[head.sdirLen]);
memmove(sdir.get(), audData.get() + head.sdirOff, head.sdirLen);
std::unique_ptr<uint8_t[]> samp(new uint8_t[head.sampLen]);
memmove(samp.get(), audData.get() + head.sampOff, head.sampLen);
if (head.projLen && head.poolLen && head.sdirLen && head.sampLen) {
SystemString name = fmt::format(FMT_STRING(_SYS_STR("GroupFile{:02d}")), j);
ret.emplace_back(std::move(name),
IntrusiveAudioGroupData{proj.release(), head.projLen, pool.release(), head.poolLen,
sdir.release(), head.sdirLen, samp.release(), head.sampLen,
GCNDataTag{}});
}
}
break;
}
}
return ret;
}
static bool ValidateStarFoxAdvSongs(FILE* fp) {
size_t endPos = FileLength(fp);
if (endPos > 2 * 1024 * 1024)
return false;
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
const uint32_t* lengths = reinterpret_cast<const uint32_t*>(data.get());
size_t totalLen = 0;
int i = 0;
for (; i < 128; ++i) {
uint32_t len = SBig(lengths[i]);
if (len == 0)
break;
totalLen += len;
totalLen = ((totalLen + 31) & ~31);
}
totalLen += (((i * 4) + 31) & ~31);
return totalLen == endPos;
}
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadStarFoxAdvSongs(FILE* midifp) {
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
size_t endPos = FileLength(midifp);
if (endPos > 2 * 1024 * 1024)
return {};
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, midifp);
const uint32_t* lengths = reinterpret_cast<const uint32_t*>(data.get());
size_t i = 0;
for (; i < 128; ++i) {
uint32_t len = SBig(lengths[i]);
if (len == 0)
break;
}
size_t sngCount = i;
size_t cur = (((sngCount * 4) + 31) & ~31);
for (i = 0; i < sngCount; ++i) {
uint32_t len = SBig(lengths[i]);
if (len == 0)
break;
SystemString name = fmt::format(FMT_STRING(_SYS_STR("Song{}")), unsigned(i));
std::unique_ptr<uint8_t[]> song(new uint8_t[len]);
memmove(song.get(), data.get() + cur, len);
ret.emplace_back(std::move(name), ContainerRegistry::SongData(std::move(song), len, -1, i));
cur += len;
cur = ((cur + 31) & ~31);
}
return ret;
}
static bool ValidatePaperMarioTTYDSongs(FILE* fp) {
size_t endPos = FileLength(fp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, fp);
uint32_t off = 0;
while (off < endPos) {
int32_t len = SBig(*(reinterpret_cast<int32_t*>(data.get() + off)));
if (len == -1)
break;
off += len;
}
return (off + 4) == endPos;
}
struct TTYDSongDesc {
char name[30];
uint8_t group;
uint8_t setup;
};
static std::vector<std::pair<SystemString, ContainerRegistry::SongData>> LoadPaperMarioTTYDSongs(FILE* midifp,
FILE* descFp) {
if (!descFp)
return {};
std::vector<TTYDSongDesc> songDescs;
/* We need at least 143 for the default song table */
songDescs.reserve(143);
while (true) {
TTYDSongDesc songDesc;
fread(&songDesc, sizeof(TTYDSongDesc), 1, descFp);
if (songDesc.name[0] == 0)
break;
songDescs.push_back(songDesc);
}
size_t endPos = FileLength(midifp);
std::unique_ptr<uint8_t[]> data(new uint8_t[endPos]);
fread(data.get(), 1, endPos, midifp);
uint32_t off = 0;
uint32_t song = 0;
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ret;
while (off < endPos) {
int32_t len = SBig(*(reinterpret_cast<int32_t*>(data.get() + off)));
if (len == -1)
break;
std::unique_ptr<uint8_t[]> songData(new uint8_t[len - 32]);
memcpy(songData.get(), (data.get() + off + 32), len - 32);
ret.emplace_back(
StrToSys(std::string(songDescs[song].name, 30)),
ContainerRegistry::SongData(std::move(songData), len - 32, songDescs[song].group, songDescs[song].setup));
off += len;
song++;
}
return ret;
}
ContainerRegistry::Type ContainerRegistry::DetectContainerType(const SystemChar* path) {
FILE* fp;
/* See if provided file is one of four raw chunks */
const SystemChar* dot = nullptr;
if (IsChunkExtension(path, dot)) {
SystemString newpath;
/* Project */
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.pro")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp) {
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.proj")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp)
return Type::Invalid;
}
fclose(fp);
/* Pool */
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.poo")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp) {
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.pool")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp)
return Type::Invalid;
}
fclose(fp);
/* Sample Directory */
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sdi")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp) {
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sdir")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp)
return Type::Invalid;
}
fclose(fp);
/* Sample */
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sam")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp) {
newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.samp")), path, int(dot - path));
fp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (!fp)
return Type::Invalid;
}
fclose(fp);
return Type::Raw4;
}
/* Now attempt single-file case */
fp = FOpen(path, _SYS_STR("rb"));
if (fp) {
if (ValidateMP1(fp)) {
fclose(fp);
return Type::MetroidPrime;
}
if (ValidateMP2(fp)) {
fclose(fp);
return Type::MetroidPrime2;
}
if (ValidateRS1PC(fp)) {
fclose(fp);
return Type::RogueSquadronPC;
}
if (ValidateRS1N64(fp)) {
fclose(fp);
return Type::RogueSquadronN64;
}
if (ValidateFactor5N64Rev(fp)) {
fclose(fp);
return Type::Factor5N64Rev;
}
if (ValidateRS2(fp)) {
fclose(fp);
return Type::RogueSquadron2;
}
if (ValidateRS3(fp)) {
fclose(fp);
return Type::RogueSquadron3;
}
fclose(fp);
}
return Type::Invalid;
}
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ContainerRegistry::LoadContainer(const SystemChar* path) {
Type typeOut;
return LoadContainer(path, typeOut);
};
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ContainerRegistry::LoadContainer(const SystemChar* path,
Type& typeOut) {
FILE* fp;
typeOut = Type::Invalid;
/* See if provided file is one of four raw chunks */
const SystemChar* dot = nullptr;
if (IsChunkExtension(path, dot)) {
std::vector<std::pair<SystemString, IntrusiveAudioGroupData>> ret;
SystemString baseName;
if (const SystemChar* sep = std::max(StrRChr(path, _SYS_STR('/')), StrRChr(path, _SYS_STR('\\'))))
baseName = SystemString(sep + 1, dot - sep - 1);
else
baseName = SystemString(path, dot - path);
/* Project */
SystemString projPath;
projPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.pro")), path, int(dot - path));
fp = FOpen(projPath.c_str(), _SYS_STR("rb"));
if (!fp) {
projPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.proj")), path, int(dot - path));
fp = FOpen(projPath.c_str(), _SYS_STR("rb"));
if (!fp)
return ret;
}
fclose(fp);
/* Pool */
SystemString poolPath;
poolPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.poo")), path, int(dot - path));
fp = FOpen(poolPath.c_str(), _SYS_STR("rb"));
if (!fp) {
poolPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.pool")), path, int(dot - path));
fp = FOpen(poolPath.c_str(), _SYS_STR("rb"));
if (!fp)
return ret;
}
fclose(fp);
/* Sample Directory */
SystemString sdirPath;
sdirPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sdi")), path, int(dot - path));
fp = FOpen(sdirPath.c_str(), _SYS_STR("rb"));
if (!fp) {
sdirPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sdir")), path, int(dot - path));
fp = FOpen(sdirPath.c_str(), _SYS_STR("rb"));
if (!fp)
return ret;
}
fclose(fp);
/* Sample */
SystemString sampPath;
sampPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.sam")), path, int(dot - path));
fp = FOpen(sampPath.c_str(), _SYS_STR("rb"));
if (!fp) {
sampPath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.samp")), path, int(dot - path));
fp = FOpen(sampPath.c_str(), _SYS_STR("rb"));
if (!fp)
return ret;
}
fclose(fp);
fp = FOpen(projPath.c_str(), _SYS_STR("rb"));
size_t projLen = FileLength(fp);
if (!projLen)
return ret;
std::unique_ptr<uint8_t[]> proj(new uint8_t[projLen]);
fread(proj.get(), 1, projLen, fp);
fp = FOpen(poolPath.c_str(), _SYS_STR("rb"));
size_t poolLen = FileLength(fp);
if (!poolLen)
return ret;
std::unique_ptr<uint8_t[]> pool(new uint8_t[poolLen]);
fread(pool.get(), 1, poolLen, fp);
fp = FOpen(sdirPath.c_str(), _SYS_STR("rb"));
size_t sdirLen = FileLength(fp);
if (!sdirLen)
return ret;
std::unique_ptr<uint8_t[]> sdir(new uint8_t[sdirLen]);
fread(sdir.get(), 1, sdirLen, fp);
fp = FOpen(sampPath.c_str(), _SYS_STR("rb"));
size_t sampLen = FileLength(fp);
if (!sampLen)
return ret;
std::unique_ptr<uint8_t[]> samp(new uint8_t[sampLen]);
fread(samp.get(), 1, sampLen, fp);
fclose(fp);
/* SDIR-based format detection */
if (*reinterpret_cast<uint32_t*>(sdir.get() + 8) == 0x0)
ret.emplace_back(baseName,
IntrusiveAudioGroupData{proj.release(), projLen, pool.release(), poolLen, sdir.release(),
sdirLen, samp.release(), sampLen, GCNDataTag{}});
else if (sdir[9] == 0x0)
ret.emplace_back(baseName,
IntrusiveAudioGroupData{proj.release(), projLen, pool.release(), poolLen, sdir.release(),
sdirLen, samp.release(), sampLen, false, N64DataTag{}});
else
ret.emplace_back(baseName,
IntrusiveAudioGroupData{proj.release(), projLen, pool.release(), poolLen, sdir.release(),
sdirLen, samp.release(), sampLen, false, PCDataTag{}});
typeOut = Type::Raw4;
return ret;
}
/* Now attempt single-file case */
fp = FOpen(path, _SYS_STR("rb"));
if (fp) {
if (ValidateMP1(fp)) {
auto ret = LoadMP1(fp);
fclose(fp);
typeOut = Type::MetroidPrime;
return ret;
}
if (ValidateMP2(fp)) {
auto ret = LoadMP2(fp);
fclose(fp);
typeOut = Type::MetroidPrime2;
return ret;
}
if (ValidateRS1PC(fp)) {
auto ret = LoadRS1PC(fp);
fclose(fp);
typeOut = Type::RogueSquadronPC;
return ret;
}
if (ValidateRS1N64(fp)) {
auto ret = LoadRS1N64(fp);
fclose(fp);
typeOut = Type::RogueSquadronN64;
return ret;
}
if (ValidateFactor5N64Rev(fp)) {
auto ret = LoadFactor5N64Rev(fp);
fclose(fp);
typeOut = Type::Factor5N64Rev;
return ret;
}
if (ValidateRS2(fp)) {
auto ret = LoadRS2(fp);
fclose(fp);
typeOut = Type::RogueSquadron2;
return ret;
}
if (ValidateRS3(fp)) {
auto ret = LoadRS3(fp);
fclose(fp);
typeOut = Type::RogueSquadron3;
return ret;
}
fclose(fp);
}
return {};
}
std::vector<std::pair<SystemString, ContainerRegistry::SongData>> ContainerRegistry::LoadSongs(const SystemChar* path) {
FILE* fp;
/* See if provided file is a raw song */
const SystemChar* dot = nullptr;
if (IsSongExtension(path, dot)) {
fp = FOpen(path, _SYS_STR("rb"));
size_t fLen = FileLength(fp);
if (!fLen) {
fclose(fp);
return {};
}
std::unique_ptr<uint8_t[]> song(new uint8_t[fLen]);
fread(song.get(), 1, fLen, fp);
fclose(fp);
std::vector<std::pair<SystemString, SongData>> ret;
ret.emplace_back(_SYS_STR("Song"), SongData(std::move(song), fLen, -1, -1));
return ret;
}
/* Now attempt archive-file case */
fp = FOpen(path, _SYS_STR("rb"));
if (fp) {
if (ValidateMP1Songs(fp)) {
auto ret = LoadMP1Songs(fp);
fclose(fp);
return ret;
}
if (ValidateRS1PC(fp)) {
auto ret = LoadRS1PCSongs(fp);
fclose(fp);
return ret;
}
if (ValidateRS1N64(fp)) {
auto ret = LoadRS1N64Songs(fp);
fclose(fp);
return ret;
}
if (ValidateFactor5N64Rev(fp)) {
auto ret = LoadFactor5N64RevSongs(fp);
fclose(fp);
return ret;
}
if (ValidateRS2(fp)) {
auto ret = LoadRS2Songs(fp);
fclose(fp);
return ret;
}
if (ValidateStarFoxAdvSongs(fp)) {
auto ret = LoadStarFoxAdvSongs(fp);
fclose(fp);
return ret;
}
if (ValidatePaperMarioTTYDSongs(fp)) {
/* Song Description */
dot = StrRChr(path, _SYS_STR('.'));
SystemString newpath = fmt::format(FMT_STRING(_SYS_STR("{:.{}}.stbl")), path, int(dot - path));
FILE* descFp = FOpen(newpath.c_str(), _SYS_STR("rb"));
if (descFp) {
auto ret = LoadPaperMarioTTYDSongs(fp, descFp);
fclose(fp);
fclose(descFp);
return ret;
}
}
fclose(fp);
}
return {};
}
} // namespace amuse
Reference in New Issue View Git Blame Copy Permalink