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

937 lines
34 KiB
C++
Raw Blame History

#include "amuse/AudioGroupProject.hpp"
#include "amuse/AudioGroupPool.hpp"
#include "amuse/AudioGroupSampleDirectory.hpp"
#include "amuse/AudioGroupData.hpp"
#include <athena/MemoryReader.hpp>
#include <athena/FileReader.hpp>
#include <athena/FileWriter.hpp>
#include <athena/VectorWriter.hpp>
namespace amuse {
static bool AtEnd64(athena::io::IStreamReader& r) {
uint64_t v = r.readUint64Big();
r.seek(-8, athena::SeekOrigin::Current);
return v == 0xffffffffffffffff;
}
static bool AtEnd32(athena::io::IStreamReader& r) {
uint32_t v = r.readUint32Big();
r.seek(-4, athena::SeekOrigin::Current);
return v == 0xffffffff;
}
static bool AtEnd16(athena::io::IStreamReader& r) {
uint16_t v = r.readUint16Big();
r.seek(-2, athena::SeekOrigin::Current);
return v == 0xffff;
}
template <athena::Endian DNAE>
static void ReadRangedObjectIds(NameDB* db, athena::io::IStreamReader& r, NameDB::Type tp) {
uint16_t id;
athena::io::Read<athena::io::PropType::None>::Do<decltype(id), DNAE>({}, id, r);
if ((id & 0x8000) == 0x8000) {
uint16_t endId;
athena::io::Read<athena::io::PropType::None>::Do<decltype(endId), DNAE>({}, endId, r);
for (uint16_t i = uint16_t(id & 0x7fff); i <= uint16_t(endId & 0x7fff); ++i) {
ObjectId useId = i;
if (tp == NameDB::Type::Layer)
useId.id |= 0x8000;
else if (tp == NameDB::Type::Keymap)
useId.id |= 0x4000;
if (db)
db->registerPair(NameDB::generateName(useId, tp), useId);
}
} else {
if (tp == NameDB::Type::Layer)
id |= 0x8000;
else if (tp == NameDB::Type::Keymap)
id |= 0x4000;
if (db)
db->registerPair(NameDB::generateName(id, tp), id);
}
}
template <athena::Endian DNAE, class T>
static void WriteRangedObjectIds(athena::io::IStreamWriter& w, const T& list) {
if (list.cbegin() == list.cend())
return;
bool inRange = false;
uint16_t lastId = list.cbegin()->first.id & 0x3fff;
for (auto it = list.cbegin() + 1; it != list.cend(); ++it) {
uint16_t thisId = it->first.id & 0x3fff;
if (thisId == lastId + 1) {
if (!inRange) {
inRange = true;
lastId |= 0x8000;
athena::io::Write<athena::io::PropType::None>::Do<decltype(lastId), DNAE>({}, lastId, w);
}
} else {
inRange = false;
athena::io::Write<athena::io::PropType::None>::Do<decltype(lastId), DNAE>({}, lastId, w);
}
lastId = thisId;
}
athena::io::Write<athena::io::PropType::None>::Do<decltype(lastId), DNAE>({}, lastId, w);
uint16_t term = 0xffff;
athena::io::Write<athena::io::PropType::None>::Do<decltype(term), DNAE>({}, term, w);
}
AudioGroupProject::AudioGroupProject(athena::io::IStreamReader& r, GCNDataTag) {
while (!AtEnd32(r)) {
GroupHeader<athena::Endian::Big> header;
header.read(r);
if (GroupId::CurNameDB)
GroupId::CurNameDB->registerPair(NameDB::generateName(header.groupId, NameDB::Type::Group), header.groupId);
#if 0
/* Sound Macros */
r.seek(header.soundMacroIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(SoundMacroId::CurNameDB, r, NameDB::Type::SoundMacro);
}
/* Samples */
r.seek(header.samplIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(SampleId::CurNameDB, r, NameDB::Type::Sample);
}
/* Tables */
r.seek(header.tableIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(TableId::CurNameDB, r, NameDB::Type::Table);
}
/* Keymaps */
r.seek(header.keymapIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(KeymapId::CurNameDB, r, NameDB::Type::Keymap);
}
/* Layers */
r.seek(header.layerIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(LayersId::CurNameDB, r, NameDB::Type::Layer);
}
#endif
if (header.type == GroupType::Song) {
auto& idx = m_songGroups[header.groupId];
idx = MakeObj<SongGroupIndex>();
/* Normal pages */
r.seek(header.pageTableOff, athena::SeekOrigin::Begin);
while (!AtEnd64(r)) {
SongGroupIndex::PageEntryDNA<athena::Endian::Big> entry;
entry.read(r);
idx->m_normPages[entry.programNo] = entry;
}
/* Drum pages */
r.seek(header.drumTableOff, athena::SeekOrigin::Begin);
while (!AtEnd64(r)) {
SongGroupIndex::PageEntryDNA<athena::Endian::Big> entry;
entry.read(r);
idx->m_drumPages[entry.programNo] = entry;
}
/* MIDI setups */
r.seek(header.midiSetupsOff, athena::SeekOrigin::Begin);
while (r.position() < header.groupEndOff) {
uint16_t songId = r.readUint16Big();
r.seek(2, athena::SeekOrigin::Current);
std::array<SongGroupIndex::MIDISetup, 16>& setup = idx->m_midiSetups[songId];
for (int i = 0; i < 16; ++i) {
setup[i].read(r);
}
if (SongId::CurNameDB) {
SongId::CurNameDB->registerPair(NameDB::generateName(songId, NameDB::Type::Song), songId);
}
}
} else if (header.type == GroupType::SFX) {
auto& idx = m_sfxGroups[header.groupId];
idx = MakeObj<SFXGroupIndex>();
/* SFX entries */
r.seek(header.pageTableOff, athena::SeekOrigin::Begin);
uint16_t count = r.readUint16Big();
r.seek(2, athena::SeekOrigin::Current);
idx->m_sfxEntries.reserve(count);
for (int i = 0; i < count; ++i) {
SFXGroupIndex::SFXEntryDNA<athena::Endian::Big> entry;
entry.read(r);
idx->m_sfxEntries[entry.sfxId.id] = entry;
if (SFXId::CurNameDB)
SFXId::CurNameDB->registerPair(NameDB::generateName(entry.sfxId.id, NameDB::Type::SFX), entry.sfxId.id);
}
}
r.seek(header.groupEndOff, athena::SeekOrigin::Begin);
}
}
template <athena::Endian DNAE>
AudioGroupProject AudioGroupProject::_AudioGroupProject(athena::io::IStreamReader& r, bool absOffs) {
AudioGroupProject ret;
while (!AtEnd32(r)) {
atInt64 groupBegin = r.position();
atInt64 subDataOff = absOffs ? 0 : groupBegin + 8;
GroupHeader<DNAE> header;
header.read(r);
GroupId::CurNameDB->registerPair(NameDB::generateName(header.groupId, NameDB::Type::Group), header.groupId);
#if 0
/* Sound Macros */
r.seek(subDataOff + header.soundMacroIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(SoundMacroId::CurNameDB, r, NameDB::Type::SoundMacro);
}
/* Samples */
r.seek(subDataOff + header.samplIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(SampleId::CurNameDB, r, NameDB::Type::Sample);
}
/* Tables */
r.seek(subDataOff + header.tableIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(TableId::CurNameDB, r, NameDB::Type::Table);
}
/* Keymaps */
r.seek(subDataOff + header.keymapIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(KeymapId::CurNameDB, r, NameDB::Type::Keymap);
}
/* Layers */
r.seek(subDataOff + header.layerIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(LayersId::CurNameDB, r, NameDB::Type::Layer);
}
#endif
if (header.type == GroupType::Song) {
auto& idx = ret.m_songGroups[header.groupId];
idx = MakeObj<SongGroupIndex>();
if (absOffs) {
/* Normal pages */
r.seek(header.pageTableOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
SongGroupIndex::PageEntryDNA<DNAE> entry;
entry.read(r);
idx->m_normPages[entry.programNo] = entry;
}
/* Drum pages */
r.seek(header.drumTableOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
SongGroupIndex::PageEntryDNA<DNAE> entry;
entry.read(r);
idx->m_drumPages[entry.programNo] = entry;
}
/* MIDI setups */
r.seek(header.midiSetupsOff, athena::SeekOrigin::Begin);
while (r.position() < header.groupEndOff) {
uint16_t songId;
athena::io::Read<athena::io::PropType::None>::Do<decltype(songId), DNAE>({}, songId, r);
r.seek(2, athena::SeekOrigin::Current);
std::array<SongGroupIndex::MIDISetup, 16>& setup = idx->m_midiSetups[songId];
for (int i = 0; i < 16; ++i) {
setup[i].read(r);
}
SongId::CurNameDB->registerPair(NameDB::generateName(songId, NameDB::Type::Song), songId);
}
} else {
/* Normal pages */
r.seek(subDataOff + header.pageTableOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
SongGroupIndex::MusyX1PageEntryDNA<DNAE> entry;
entry.read(r);
idx->m_normPages[entry.programNo] = entry;
}
/* Drum pages */
r.seek(subDataOff + header.drumTableOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
SongGroupIndex::MusyX1PageEntryDNA<DNAE> entry;
entry.read(r);
idx->m_drumPages[entry.programNo] = entry;
}
/* MIDI setups */
r.seek(subDataOff + header.midiSetupsOff, athena::SeekOrigin::Begin);
while (atInt64(r.position() + 4) < groupBegin + header.groupEndOff) {
uint16_t songId;
athena::io::Read<athena::io::PropType::None>::Do<decltype(songId), DNAE>({}, songId, r);
r.seek(2, athena::SeekOrigin::Current);
std::array<SongGroupIndex::MIDISetup, 16>& setup = idx->m_midiSetups[songId];
for (int i = 0; i < 16; ++i) {
SongGroupIndex::MusyX1MIDISetup ent;
ent.read(r);
setup[i] = ent;
}
SongId::CurNameDB->registerPair(NameDB::generateName(songId, NameDB::Type::Song), songId);
}
}
} else if (header.type == GroupType::SFX) {
auto& idx = ret.m_sfxGroups[header.groupId];
idx = MakeObj<SFXGroupIndex>();
/* SFX entries */
r.seek(subDataOff + header.pageTableOff, athena::SeekOrigin::Begin);
uint16_t count;
athena::io::Read<athena::io::PropType::None>::Do<decltype(count), DNAE>({}, count, r);
r.seek(2, athena::SeekOrigin::Current);
idx->m_sfxEntries.reserve(count);
for (int i = 0; i < count; ++i) {
SFXGroupIndex::SFXEntryDNA<DNAE> entry;
entry.read(r);
r.seek(2, athena::SeekOrigin::Current);
idx->m_sfxEntries[entry.sfxId.id] = entry;
SFXId::CurNameDB->registerPair(NameDB::generateName(entry.sfxId.id, NameDB::Type::SFX), entry.sfxId.id);
}
}
if (absOffs)
r.seek(header.groupEndOff, athena::SeekOrigin::Begin);
else
r.seek(groupBegin + header.groupEndOff, athena::SeekOrigin::Begin);
}
return ret;
}
AudioGroupProject AudioGroupProject::CreateAudioGroupProject(const AudioGroupData& data) {
if (data.getProjSize() < 4)
return {};
athena::io::MemoryReader r(data.getProj(), data.getProjSize());
switch (data.getDataFormat()) {
case DataFormat::GCN:
default:
return AudioGroupProject(r, GCNDataTag{});
case DataFormat::N64:
return _AudioGroupProject<athena::Endian::Big>(r, data.getAbsoluteProjOffsets());
case DataFormat::PC:
return _AudioGroupProject<athena::Endian::Little>(r, data.getAbsoluteProjOffsets());
}
}
std::string ParseStringSlashId(const std::string& str, uint16_t& idOut) {
size_t slashPos = str.find('/');
if (slashPos == std::string::npos)
return {};
idOut = uint16_t(strtoul(str.data() + slashPos + 1, nullptr, 0));
return {str.begin(), str.begin() + slashPos};
}
void SongGroupIndex::fromYAML(athena::io::YAMLDocReader& r) {
if (auto __v2 = r.enterSubRecord("normPages")) {
m_normPages.reserve(r.getCurNode()->m_mapChildren.size());
for (const auto& pg : r.getCurNode()->m_mapChildren)
if (auto __r2 = r.enterSubRecord(pg.first.c_str()))
m_normPages[strtoul(pg.first.c_str(), nullptr, 0)].read(r);
}
if (auto __v2 = r.enterSubRecord("drumPages")) {
m_drumPages.reserve(r.getCurNode()->m_mapChildren.size());
for (const auto& pg : r.getCurNode()->m_mapChildren)
if (auto __r2 = r.enterSubRecord(pg.first.c_str()))
m_drumPages[strtoul(pg.first.c_str(), nullptr, 0)].read(r);
}
if (auto __v2 = r.enterSubRecord("songs")) {
m_midiSetups.reserve(r.getCurNode()->m_mapChildren.size());
for (const auto& song : r.getCurNode()->m_mapChildren) {
size_t chanCount;
if (auto __v3 = r.enterSubVector(song.first.c_str(), chanCount)) {
uint16_t songId;
std::string songName = ParseStringSlashId(song.first, songId);
if (songName.empty() || songId == 0xffff)
continue;
SongId::CurNameDB->registerPair(songName, songId);
std::array<SongGroupIndex::MIDISetup, 16>& setup = m_midiSetups[songId];
for (size_t i = 0; i < 16 && i < chanCount; ++i)
if (auto __r2 = r.enterSubRecord())
setup[i].read(r);
}
}
}
}
void SFXGroupIndex::fromYAML(athena::io::YAMLDocReader& r) {
for (const auto& sfx : r.getCurNode()->m_mapChildren)
if (auto __r2 = r.enterSubRecord(sfx.first.c_str())) {
uint16_t sfxId;
std::string sfxName = ParseStringSlashId(sfx.first, sfxId);
if (sfxName.empty() || sfxId == 0xffff)
continue;
SFXId::CurNameDB->registerPair(sfxName, sfxId);
m_sfxEntries[sfxId].read(r);
}
}
AudioGroupProject AudioGroupProject::CreateAudioGroupProject(SystemStringView groupPath) {
AudioGroupProject ret;
SystemString projPath(groupPath);
projPath += _SYS_STR("/!project.yaml");
athena::io::FileReader fi(projPath, 32 * 1024, false);
if (!fi.hasError()) {
athena::io::YAMLDocReader r;
if (r.parse(&fi) && r.readString("DNAType") == "amuse::Project") {
if (auto __v = r.enterSubRecord("songGroups")) {
ret.m_songGroups.reserve(r.getCurNode()->m_mapChildren.size());
for (const auto& grp : r.getCurNode()->m_mapChildren) {
if (auto __r = r.enterSubRecord(grp.first.c_str())) {
uint16_t groupId;
std::string groupName = ParseStringSlashId(grp.first, groupId);
if (groupName.empty() || groupId == 0xffff)
continue;
GroupId::CurNameDB->registerPair(groupName, groupId);
auto& idx = ret.m_songGroups[groupId];
idx = MakeObj<SongGroupIndex>();
idx->fromYAML(r);
}
}
}
if (auto __v = r.enterSubRecord("sfxGroups")) {
ret.m_sfxGroups.reserve(r.getCurNode()->m_mapChildren.size());
for (const auto& grp : r.getCurNode()->m_mapChildren) {
if (auto __r = r.enterSubRecord(grp.first.c_str())) {
uint16_t groupId;
std::string groupName = ParseStringSlashId(grp.first, groupId);
if (groupName.empty() || groupId == 0xffff)
continue;
GroupId::CurNameDB->registerPair(groupName, groupId);
auto& idx = ret.m_sfxGroups[groupId];
idx = MakeObj<SFXGroupIndex>();
idx->fromYAML(r);
}
}
}
}
}
return ret;
}
static ObjectId RegisterDedupedName(ObjectId origId, amuse::NameDB* db, NameDB::Type tp) {
std::string dupeName = std::string(db->resolveNameFromId(origId)) + "-copy";
std::string useName = dupeName;
int dupeIdx = 1;
while (db->m_stringToId.find(useName) != db->m_stringToId.cend())
useName = fmt::format(fmt("{}{}"), dupeName, dupeIdx++);
ObjectId ret = db->generateId(tp);
db->registerPair(useName, ret);
return ret;
}
SFXGroupIndex::SFXGroupIndex(const SFXGroupIndex& other) {
for (const auto& sfx : other.m_sfxEntries)
m_sfxEntries[RegisterDedupedName(sfx.first, SFXId::CurNameDB, NameDB::Type::SFX)] = sfx.second;
}
AudioGroupProject AudioGroupProject::CreateAudioGroupProject(const AudioGroupProject& oldProj) {
AudioGroupProject ret;
for (const auto& grp : oldProj.songGroups())
ret.m_songGroups[RegisterDedupedName(grp.first, GroupId::CurNameDB, NameDB::Type::Group)] =
MakeObj<SongGroupIndex>(*grp.second);
for (const auto& grp : oldProj.sfxGroups())
ret.m_sfxGroups[RegisterDedupedName(grp.first, GroupId::CurNameDB, NameDB::Type::Group)] =
MakeObj<SFXGroupIndex>(*grp.second);
return ret;
}
void AudioGroupProject::BootstrapObjectIDs(athena::io::IStreamReader& r, GCNDataTag) {
while (!AtEnd32(r)) {
GroupHeader<athena::Endian::Big> header;
header.read(r);
GroupId::CurNameDB->registerPair(NameDB::generateName(header.groupId, NameDB::Type::Group), header.groupId);
/* Sound Macros */
r.seek(header.soundMacroIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r))
ReadRangedObjectIds<athena::Endian::Big>(SoundMacroId::CurNameDB, r, NameDB::Type::SoundMacro);
/* Samples */
r.seek(header.samplIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(SampleId::CurNameDB, r, NameDB::Type::Sample);
}
/* Tables */
r.seek(header.tableIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(TableId::CurNameDB, r, NameDB::Type::Table);
}
/* Keymaps */
r.seek(header.keymapIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(KeymapId::CurNameDB, r, NameDB::Type::Keymap);
}
/* Layers */
r.seek(header.layerIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<athena::Endian::Big>(LayersId::CurNameDB, r, NameDB::Type::Layer);
}
if (header.type == GroupType::Song) {
/* MIDI setups */
r.seek(header.midiSetupsOff, athena::SeekOrigin::Begin);
while (r.position() < header.groupEndOff) {
uint16_t id = r.readUint16Big();
SongId::CurNameDB->registerPair(NameDB::generateName(id, NameDB::Type::Song), id);
r.seek(2 + 5 * 16, athena::SeekOrigin::Current);
}
} else if (header.type == GroupType::SFX) {
/* SFX entries */
r.seek(header.pageTableOff, athena::SeekOrigin::Begin);
uint16_t count = r.readUint16Big();
r.seek(2, athena::SeekOrigin::Current);
for (int i = 0; i < count; ++i) {
SFXGroupIndex::SFXEntryDNA<athena::Endian::Big> entry;
entry.read(r);
SFXId::CurNameDB->registerPair(NameDB::generateName(entry.sfxId.id, NameDB::Type::SFX), entry.sfxId.id);
}
}
r.seek(header.groupEndOff, athena::SeekOrigin::Begin);
}
}
template <athena::Endian DNAE>
void AudioGroupProject::BootstrapObjectIDs(athena::io::IStreamReader& r, bool absOffs) {
while (!AtEnd32(r)) {
atInt64 groupBegin = r.position();
atInt64 subDataOff = absOffs ? 0 : groupBegin + 8;
GroupHeader<DNAE> header;
header.read(r);
GroupId::CurNameDB->registerPair(NameDB::generateName(header.groupId, NameDB::Type::Group), header.groupId);
/* Sound Macros */
r.seek(subDataOff + header.soundMacroIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(SoundMacroId::CurNameDB, r, NameDB::Type::SoundMacro);
}
/* Samples */
r.seek(subDataOff + header.samplIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(SampleId::CurNameDB, r, NameDB::Type::Sample);
}
/* Tables */
r.seek(subDataOff + header.tableIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(TableId::CurNameDB, r, NameDB::Type::Table);
}
/* Keymaps */
r.seek(subDataOff + header.keymapIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(KeymapId::CurNameDB, r, NameDB::Type::Keymap);
}
/* Layers */
r.seek(subDataOff + header.layerIdsOff, athena::SeekOrigin::Begin);
while (!AtEnd16(r)) {
ReadRangedObjectIds<DNAE>(LayersId::CurNameDB, r, NameDB::Type::Layer);
}
if (header.type == GroupType::Song) {
/* MIDI setups */
if (absOffs) {
r.seek(header.midiSetupsOff, athena::SeekOrigin::Begin);
while (r.position() < header.groupEndOff) {
uint16_t id;
athena::io::Read<athena::io::PropType::None>::Do<decltype(id), DNAE>({}, id, r);
SongId::CurNameDB->registerPair(NameDB::generateName(id, NameDB::Type::Song), id);
r.seek(2 + 5 * 16, athena::SeekOrigin::Current);
}
} else {
r.seek(subDataOff + header.midiSetupsOff, athena::SeekOrigin::Begin);
while (atInt64(r.position()) < groupBegin + header.groupEndOff) {
uint16_t id;
athena::io::Read<athena::io::PropType::None>::Do<decltype(id), DNAE>({}, id, r);
SongId::CurNameDB->registerPair(NameDB::generateName(id, NameDB::Type::Song), id);
r.seek(2 + 8 * 16, athena::SeekOrigin::Current);
}
}
} else if (header.type == GroupType::SFX) {
/* SFX entries */
r.seek(subDataOff + header.pageTableOff, athena::SeekOrigin::Begin);
uint16_t count;
athena::io::Read<athena::io::PropType::None>::Do<decltype(count), DNAE>({}, count, r);
r.seek(2, athena::SeekOrigin::Current);
for (int i = 0; i < count; ++i) {
SFXGroupIndex::SFXEntryDNA<DNAE> entry;
entry.read(r);
r.seek(2, athena::SeekOrigin::Current);
SFXId::CurNameDB->registerPair(NameDB::generateName(entry.sfxId.id, NameDB::Type::SFX), entry.sfxId.id);
}
}
if (absOffs) {
r.seek(header.groupEndOff, athena::SeekOrigin::Begin);
} else {
r.seek(groupBegin + header.groupEndOff, athena::SeekOrigin::Begin);
}
}
}
void AudioGroupProject::BootstrapObjectIDs(const AudioGroupData& data) {
athena::io::MemoryReader r(data.getProj(), data.getProjSize());
switch (data.getDataFormat()) {
case DataFormat::GCN:
default:
BootstrapObjectIDs(r, GCNDataTag{});
break;
case DataFormat::N64:
BootstrapObjectIDs<athena::Endian::Big>(r, data.getAbsoluteProjOffsets());
break;
case DataFormat::PC:
BootstrapObjectIDs<athena::Endian::Little>(r, data.getAbsoluteProjOffsets());
break;
}
}
const SongGroupIndex* AudioGroupProject::getSongGroupIndex(GroupId groupId) const {
auto search = m_songGroups.find(groupId);
if (search != m_songGroups.cend())
return search->second.get();
return nullptr;
}
const SFXGroupIndex* AudioGroupProject::getSFXGroupIndex(GroupId groupId) const {
auto search = m_sfxGroups.find(groupId);
if (search != m_sfxGroups.cend())
return search->second.get();
return nullptr;
}
void SongGroupIndex::toYAML(athena::io::YAMLDocWriter& w) const {
if (!m_normPages.empty()) {
if (auto __v2 = w.enterSubRecord("normPages")) {
for (const auto& pg : SortUnorderedMap(m_normPages)) {
if (auto __r2 = w.enterSubRecord(fmt::format(fmt("{}"), pg.first))) {
w.setStyle(athena::io::YAMLNodeStyle::Flow);
pg.second.get().write(w);
}
}
}
}
if (!m_drumPages.empty()) {
if (auto __v2 = w.enterSubRecord("drumPages")) {
for (const auto& pg : SortUnorderedMap(m_drumPages)) {
if (auto __r2 = w.enterSubRecord(fmt::format(fmt("{}"), pg.first))) {
w.setStyle(athena::io::YAMLNodeStyle::Flow);
pg.second.get().write(w);
}
}
}
}
if (!m_midiSetups.empty()) {
if (auto __v2 = w.enterSubRecord("songs")) {
for (const auto& song : SortUnorderedMap(m_midiSetups)) {
std::string songString = fmt::format(fmt("{}/0x{}"),
SongId::CurNameDB->resolveNameFromId(song.first), song.first);
if (auto __v3 = w.enterSubVector(songString))
for (int i = 0; i < 16; ++i)
if (auto __r2 = w.enterSubRecord()) {
w.setStyle(athena::io::YAMLNodeStyle::Flow);
song.second.get()[i].write(w);
}
}
}
}
}
void SFXGroupIndex::toYAML(athena::io::YAMLDocWriter& w) const {
for (const auto& sfx : SortUnorderedMap(m_sfxEntries)) {
std::string sfxString = fmt::format(fmt("{}/0x{}"),
SFXId::CurNameDB->resolveNameFromId(sfx.first), sfx.first);
if (auto __r2 = w.enterSubRecord(sfxString)) {
w.setStyle(athena::io::YAMLNodeStyle::Flow);
sfx.second.get().write(w);
}
}
}
std::vector<uint8_t> AudioGroupProject::toYAML() const {
athena::io::YAMLDocWriter w("amuse::Project");
if (!m_songGroups.empty()) {
if (auto __v = w.enterSubRecord("songGroups")) {
for (const auto& p : SortUnorderedMap(m_songGroups)) {
std::string groupString = fmt::format(fmt("{}/0x{}"),
GroupId::CurNameDB->resolveNameFromId(p.first), p.first);
if (auto __r = w.enterSubRecord(groupString)) {
p.second.get()->toYAML(w);
}
}
}
}
if (!m_sfxGroups.empty()) {
if (auto __v = w.enterSubRecord("sfxGroups")) {
for (const auto& p : SortUnorderedMap(m_sfxGroups)) {
std::string groupString = fmt::format(fmt("{}/0x{}"),
GroupId::CurNameDB->resolveNameFromId(p.first), p.first);
if (auto __r = w.enterSubRecord(groupString)) {
p.second.get()->toYAML(w);
}
}
}
}
athena::io::VectorWriter fo;
w.finish(&fo);
return fo.data();
}
#if 0
struct ObjectIdPool
{
std::unordered_set<SoundMacroId> soundMacros;
std::unordered_set<SampleId> samples;
std::unordered_set<TableId> tables;
std::unordered_set<KeymapId> keymaps;
std::unordered_set<LayersId> layers;
void _recursiveAddSoundMacro(SoundMacroId id, const AudioGroupPool& pool)
{
if (soundMacros.find(id) != soundMacros.cend())
return;
const SoundMacro* macro = pool.soundMacro(id);
if (!macro)
return;
soundMacros.insert(id);
for (const auto& cmd : macro->m_cmds)
{
switch (cmd->Isa())
{
case SoundMacro::CmdOp::StartSample:
samples.insert(static_cast<SoundMacro::CmdStartSample*>(cmd.get())->sample);
break;
case SoundMacro::CmdOp::SetAdsr:
tables.insert(static_cast<SoundMacro::CmdSetAdsr*>(cmd.get())->table);
break;
case SoundMacro::CmdOp::ScaleVolume:
tables.insert(static_cast<SoundMacro::CmdScaleVolume*>(cmd.get())->table);
break;
case SoundMacro::CmdOp::Envelope:
tables.insert(static_cast<SoundMacro::CmdEnvelope*>(cmd.get())->table);
break;
case SoundMacro::CmdOp::FadeIn:
tables.insert(static_cast<SoundMacro::CmdFadeIn*>(cmd.get())->table);
break;
case SoundMacro::CmdOp::SetPitchAdsr:
tables.insert(static_cast<SoundMacro::CmdSetPitchAdsr*>(cmd.get())->table);
break;
case SoundMacro::CmdOp::SplitKey:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdSplitKey*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::SplitVel:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdSplitVel*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::Goto:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdGoto*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::PlayMacro:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdPlayMacro*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::SplitMod:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdSplitMod*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::SplitRnd:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdSplitRnd*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::GoSub:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdGoSub*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::TrapEvent:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdTrapEvent*>(cmd.get())->macro, pool);
break;
case SoundMacro::CmdOp::SendMessage:
_recursiveAddSoundMacro(static_cast<SoundMacro::CmdSendMessage*>(cmd.get())->macro, pool);
break;
default:
break;
}
}
}
void addRootId(ObjectId id, const AudioGroupPool& pool)
{
if (id & 0x8000)
{
if (const std::vector<LayerMapping>* lms = pool.layer(id))
{
layers.insert(id);
for (const auto& lm : *lms)
_recursiveAddSoundMacro(lm.macro, pool);
}
}
else if (id & 0x4000)
{
if (const auto* kms = pool.keymap(id))
{
keymaps.insert(id);
for (int i = 0; i < 128; ++i)
_recursiveAddSoundMacro(kms[i].macro, pool);
}
}
else
{
_recursiveAddSoundMacro(id, pool);
}
}
void cleanup()
{
soundMacros.erase(SoundMacroId{});
samples.erase(SampleId{});
tables.erase(TableId{});
keymaps.erase(KeymapId{});
layers.erase(LayersId{});
}
};
#endif
std::vector<uint8_t> AudioGroupProject::toGCNData(const AudioGroupPool& pool,
const AudioGroupSampleDirectory& sdir) const {
constexpr athena::Endian DNAE = athena::Endian::Big;
athena::io::VectorWriter fo;
std::vector<GroupId> groupIds;
groupIds.reserve(m_songGroups.size() + m_sfxGroups.size());
for (auto& p : m_songGroups)
groupIds.push_back(p.first);
for (auto& p : m_sfxGroups)
groupIds.push_back(p.first);
std::sort(groupIds.begin(), groupIds.end());
const uint64_t term64 = 0xffffffffffffffff;
const uint16_t padding = 0;
for (GroupId id : groupIds) {
auto search = m_songGroups.find(id);
if (search != m_songGroups.end()) {
const SongGroupIndex& index = *search->second;
auto groupStart = fo.position();
GroupHeader<DNAE> header = {};
header.write(fo);
header.groupId = id;
header.type = GroupType::Song;
header.soundMacroIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.soundMacros()));
header.samplIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(sdir.sampleEntries()));
header.tableIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.tables()));
header.keymapIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.keymaps()));
header.layerIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.layers()));
header.pageTableOff = fo.position();
for (auto& p : SortUnorderedMap(index.m_normPages)) {
SongGroupIndex::PageEntryDNA<DNAE> entry = p.second.get().toDNA<DNAE>(p.first);
entry.write(fo);
}
athena::io::Write<athena::io::PropType::None>::Do<decltype(term64), DNAE>({}, term64, fo);
header.drumTableOff = fo.position();
for (auto& p : SortUnorderedMap(index.m_drumPages)) {
SongGroupIndex::PageEntryDNA<DNAE> entry = p.second.get().toDNA<DNAE>(p.first);
entry.write(fo);
}
athena::io::Write<athena::io::PropType::None>::Do<decltype(term64), DNAE>({}, term64, fo);
header.midiSetupsOff = fo.position();
for (auto& p : SortUnorderedMap(index.m_midiSetups)) {
uint16_t songId = p.first.id;
athena::io::Write<athena::io::PropType::None>::Do<decltype(songId), DNAE>({}, songId, fo);
athena::io::Write<athena::io::PropType::None>::Do<decltype(padding), DNAE>({}, padding, fo);
const std::array<SongGroupIndex::MIDISetup, 16>& setup = p.second.get();
for (int i = 0; i < 16; ++i)
setup[i].write(fo);
}
header.groupEndOff = fo.position();
fo.seek(groupStart, athena::SeekOrigin::Begin);
header.write(fo);
fo.seek(header.groupEndOff, athena::SeekOrigin::Begin);
} else {
auto search2 = m_sfxGroups.find(id);
if (search2 != m_sfxGroups.end()) {
const SFXGroupIndex& index = *search2->second;
auto groupStart = fo.position();
GroupHeader<DNAE> header = {};
header.write(fo);
header.groupId = id;
header.type = GroupType::SFX;
header.soundMacroIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.soundMacros()));
header.samplIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(sdir.sampleEntries()));
header.tableIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.tables()));
header.keymapIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.keymaps()));
header.layerIdsOff = fo.position();
WriteRangedObjectIds<DNAE>(fo, SortUnorderedMap(pool.layers()));
header.pageTableOff = fo.position();
uint16_t count = index.m_sfxEntries.size();
athena::io::Write<athena::io::PropType::None>::Do<decltype(count), DNAE>({}, count, fo);
athena::io::Write<athena::io::PropType::None>::Do<decltype(padding), DNAE>({}, padding, fo);
for (auto& p : SortUnorderedMap(index.m_sfxEntries)) {
SFXGroupIndex::SFXEntryDNA<DNAE> entry = p.second.get().toDNA<DNAE>(p.first);
entry.write(fo);
}
header.groupEndOff = fo.position();
fo.seek(groupStart, athena::SeekOrigin::Begin);
header.write(fo);
fo.seek(header.groupEndOff, athena::SeekOrigin::Begin);
}
}
}
const uint32_t finalTerm = 0xffffffff;
athena::io::Write<athena::io::PropType::None>::Do<decltype(finalTerm), DNAE>({}, finalTerm, fo);
return fo.data();
}
} // namespace amuse
Reference in New Issue View Git Blame Copy Permalink