[WIP] Audio Extractor

1 files changed, 333 insertions, 0 deletions

diff --git a/src/factories/AudioFactory.cpp b/src/factories/AudioFactory.cpp
new file mode 100644
index 0000000..62ff3d3
--- /dev/null
+++ b/src/factories/AudioFactory.cpp
@@ -0,0 +1,333 @@
+#include "AudioFactory.h"
+
+#include <vector>
+#include <iostream>
+#include <filesystem>
+#include <sstream>
+#include "Companion.h"
+#include "utils/MIODecoder.h"
+#include "binarytools/BinaryReader.h"
+
+namespace fs = std::filesystem;
+
+#define NONE 0xFFFF
+
+std::unordered_map<std::string, uint32_t> nameTable;
+
+struct ALSeqData {
+    uint8_t *offset;
+    uint32_t len;
+};
+
+struct Entry {
+    uint32_t offset;
+    uint32_t length;
+};
+
+struct SampleBank {
+	std::string name;
+	uint32_t offset;
+	std::vector<uint8_t> data;
+};
+
+struct TBLFile {
+	std::vector<SampleBank> banks;
+	std::vector<std::string> tbls;
+	std::unordered_map<std::string, uint32_t> map;
+};
+
+struct CTLHeader {
+    uint32_t instruments;
+    uint32_t numDrums;
+    uint32_t shared;
+};
+
+struct Sound {
+    int32_t offset;
+    float tuning;
+};
+
+struct Bank {
+    std::string name;
+    SampleBank sampleBank;
+};
+
+struct Inst {
+    std::string name;
+    uint32_t offset;
+    uint8_t releaseRate;
+    uint8_t normalRangeLo;
+    uint8_t normalRangeHi;
+    int32_t envelope;
+    std::optional<Sound> soundLo;
+    std::optional<Sound> soundMed;
+    std::optional<Sound> soundHi;
+};
+
+struct Drum {
+    std::string name;
+    uint32_t offset;
+    uint8_t releaseRate;
+    uint8_t pan;
+    int32_t envelope;
+    Sound sound;
+};
+
+template<typename T>
+std::vector<T> slice(std::vector<T> const &v, uint32_t m, uint32_t n) {
+	auto first = v.cbegin() + m;
+	auto last = v.cbegin() + n;
+
+	std::vector<T> vec(first, last);
+	return vec;
+}
+
+std::vector<uint32_t> range(uint32_t start, uint32_t end) {
+    std::vector<uint32_t> result;
+    for (uint32_t i = start; i < end; ++i) {
+        result.push_back(i);
+    }
+    return result;
+}
+
+template <typename T1, typename T2, typename T3>
+std::vector<std::tuple<size_t, T2, T3>> zip(const std::vector<T1>& container1, const std::vector<T2>& container2, const std::vector<T3>& container3) {
+    std::vector<std::tuple<size_t, T2, T3>> result;
+
+    size_t minSize = std::min({container1.size(), container2.size(), container3.size()});
+
+    for (size_t i = 0; i < minSize; ++i) {
+        result.emplace_back(container1[i], container2[i], container3[i]);
+    }
+
+    return result;
+}
+
+std::vector<Entry> parseSeqFile(std::vector<uint8_t>& buffer, int32_t offset){
+    std::vector<Entry> entries;
+    LUS::BinaryReader reader((char*) buffer.data(), buffer.size());
+    reader.SetEndianness(LUS::Endianness::Big);
+    reader.Seek(offset, LUS::SeekOffsetType::Start);
+
+    uint16_t magic = reader.ReadUInt16();
+    uint16_t num_entries = reader.ReadUInt16();
+
+    for (int i = 0; i < num_entries; ++i) {
+        reader.Seek((offset + 4) + (i * 8), LUS::SeekOffsetType::Start);
+        entries.push_back({reader.ReadUInt32(), reader.ReadUInt32()});
+    }
+
+    reader.Close();
+    return entries;
+}
+
+CTLHeader parseCTLHeader(std::vector<uint8_t>& data){
+    LUS::BinaryReader reader((char*) data.data(), data.size());
+    reader.SetEndianness(LUS::Endianness::Big);
+
+    CTLHeader header = { reader.ReadUInt32(), reader.ReadUInt32(), reader.ReadUInt32() };
+
+    reader.Close();
+    return header;
+}
+
+std::string gen_name(const std::string& prefix){
+    if(!nameTable.contains(prefix)){
+        nameTable[prefix] = 0;
+    }
+    nameTable[prefix] += 1;
+    return prefix + "-" + std::to_string(nameTable[prefix]);
+}
+
+std::optional<Sound> parseSound(std::vector<uint8_t> data) {
+    LUS::BinaryReader reader((char*) data.data(), data.size());
+    reader.SetEndianness(LUS::Endianness::Big);
+
+    int32_t addr = reader.ReadInt32();
+    float tuning = reader.ReadFloat();
+
+    if(addr == 0){
+        assert(tuning == 0.0f);
+        return std::nullopt;
+    }
+
+    Sound sound = { addr, tuning };
+
+    reader.Close();
+    return sound;
+}
+
+Drum parseDrum(std::vector<uint8_t>& data, uint32_t addr) {
+    LUS::BinaryReader reader((char*) data.data(), data.size());
+    reader.SetEndianness(LUS::Endianness::Big);
+    std::string name = gen_name("drum");
+
+    uint8_t releaseRate = reader.ReadInt8();
+    uint8_t pan = reader.ReadInt8();
+
+    reader.Seek(12, LUS::SeekOffsetType::Start);
+    Sound sound = parseSound(slice(data, 4, 12)).value();
+    int32_t envOffset = reader.ReadInt32();
+    assert(envOffset != 0);
+
+    Drum drum = { name, addr, releaseRate, pan, envOffset, sound };
+
+    return drum;
+}
+
+Inst parseInst(std::vector<uint8_t>& data, uint32_t addr) {
+    std::string name = gen_name("inst");
+    char* rawData = (char*) data.data();
+    uint8_t normalRangeLo = data[1];
+    uint8_t normalRangeHi = data[2];
+    uint8_t releaseRate = data[3];
+
+    int32_t envAddr;
+    memcpy(&envAddr, rawData + 4, 4);
+    envAddr = BSWAP32(envAddr);
+
+    auto soundLo = parseSound(slice(data, 8, 16));
+    auto soundMed = parseSound(slice(data, 16, 24));
+    auto soundHi = parseSound(slice(data, 24, 32));
+
+    if (soundLo == std::nullopt) {
+        assert(normalRangeLo == 0);
+    }
+    if (soundHi == std::nullopt) {
+        assert(normalRangeHi == 127);
+    }
+
+    Inst inst = { name, addr, releaseRate, normalRangeLo, normalRangeHi, envAddr, soundLo, soundMed, soundHi };
+    return inst;
+}
+
+void parseCTL(CTLHeader header, std::vector<uint8_t>& data, SampleBank bank, uint32_t index) {
+    nameTable.clear();
+    std::ostringstream ss;
+    ss << std::hex << std::setw(2) << std::setfill('0') << index;
+    std::string name = ss.str();
+    uint32_t numInstruments = header.instruments;
+    uint32_t numDrums = header.numDrums;
+    char* rawData = (char*) data.data();
+
+    uint32_t drumBaseAddr;
+    memcpy(&drumBaseAddr, rawData, 4);
+    drumBaseAddr = BSWAP32(drumBaseAddr);
+
+    std::vector<uint32_t> drumOffsets;
+
+    if(numDrums != 0){
+        for (size_t i = 0; i < numDrums; ++i) {
+            uint32_t drumOffset;
+            memcpy(&drumOffset, rawData + drumBaseAddr + (i * 4), 4);
+            drumOffsets.push_back(BSWAP32(drumOffset));
+        }
+    }
+
+    uint32_t instrumentBaseAddr = 4;
+    std::vector<uint32_t> instrumentOffsets;
+    std::vector<uint32_t> instrumentList;
+
+    for (size_t i = 0; i < numInstruments; ++i) {
+        uint32_t instOffset;
+        memcpy(&instOffset, rawData + instrumentBaseAddr + (i * 4), 4);
+        instOffset = BSWAP32(instOffset);
+        if(instOffset == 0){
+            instrumentList.push_back(NONE);
+        } else {
+            instrumentOffsets.push_back(instOffset);
+            instrumentList.push_back(instOffset);
+        }
+    }
+
+    std::sort(instrumentOffsets.begin(), instrumentOffsets.end());
+
+    std::vector<Inst> insts;
+    for(auto &offset : instrumentOffsets){
+        auto rInst = slice(data, offset, offset + 32);
+        Inst inst = parseInst(rInst, offset);
+        insts.push_back(inst);
+    }
+
+    std::vector<Drum> drums;
+    for(auto &offset : drumOffsets){
+        auto rDrum = slice(data, offset, offset + 16);
+        Drum drum = parseDrum(rDrum, offset);
+        drums.push_back(drum);
+    }
+}
+
+TBLFile parseTBL(std::vector<uint8_t>& data, std::vector<Entry>& entries) {
+	TBLFile tbl;
+	std::unordered_map<uint32_t, std::string> cache;
+	for(auto &entry : entries){
+		if(!cache.contains(entry.offset)){
+			std::string name = gen_name("sample_bank");
+			tbl.banks.push_back({name, entry.offset, slice(data, entry.offset, entry.offset + entry.length)});
+            tbl.map[name] = tbl.banks.size() - 1;
+			cache[entry.offset] = name;
+		}
+		tbl.tbls.push_back(cache[entry.offset]);
+	}
+	cache.clear();
+	return tbl;
+}
+
+bool AudioFactory::process(LUS::BinaryWriter* writer, nlohmann::json& data, std::vector<uint8_t>& buffer) {
+    auto metadata = data["offsets"];
+	std::string path = data["path"];
+
+	if(path.find("@sound") != std::string::npos){
+		auto offsets = metadata["us"];
+		std::vector<Entry> tbl = parseSeqFile(buffer, offsets["sound_tbl"][0]);
+		std::vector<Entry> ctl = parseSeqFile(buffer, offsets["sound_ctl"][0]);
+
+		std::cout << "Table entries: "   << tbl.size() << std::endl;
+		std::cout << "Control entries: " << ctl.size() << std::endl;
+
+		std::vector<uint8_t> tblData = slice(buffer, offsets["sound_tbl"][0], (size_t) offsets["sound_tbl"][0] + (size_t) offsets["sound_tbl"][1]);
+        std::vector<uint8_t> ctlData = slice(buffer, offsets["sound_ctl"][0], (size_t) offsets["sound_ctl"][0] + (size_t) offsets["sound_ctl"][1]);
+		TBLFile tblFile = parseTBL(tblData, tbl);
+
+        std::cout << "TBLs: " << tblFile.tbls.size() << std::endl;
+		std::cout << "Banks: " << tblFile.banks.size() << std::endl;
+		std::cout << "Map: " << tblFile.map.size() << std::endl;
+
+        auto zipped = zip(range(0, ctl.size()), ctl, tblFile.tbls);
+
+        for (const auto& item : zipped) {
+            auto [index, ctrl, sample_bank_name] = item;
+            auto sample_bank = tblFile.map[sample_bank_name];
+            auto entry = slice(ctlData, ctrl.offset, ctrl.offset + ctrl.length);
+            auto headerRaw = slice(entry, 0, 16);
+            auto header = parseCTLHeader(headerRaw);
+            std::cout << "Instruments: " << header.instruments << std::endl;
+            std::cout << "Drums: " << header.numDrums << std::endl;
+        }
+
+		exit(0);
+	}
+
+	if(path.find("bank_sets") != std::string::npos){
+		WRITE_HEADER(LUS::ResourceType::Blob, 0);
+		char* raw = (char*) (buffer.data() + metadata[1]["us"][0]);
+		WRITE_U32(metadata[0]);
+		for(int i = 0; i < 0x23; i++){
+			int16_t value;
+			memcpy(&value, raw + (i * 2), 2);
+			WRITE_I16(BSWAP16(value));
+		}
+		writer->Write(raw + 0x46, 0x5A);
+	}
+
+	if(path.find("sound_tbl") != std::string::npos){
+		// WRITE_HEADER(LUS::ResourceType::Blob, 0);
+		// std::vector<Entry> entries = parseSeqFile(buffer, metadata[1]["us"][0]);
+		// for(auto & entry : entries){
+		// 	   std::cout << "Offset: " << entrie.offset << std::endl;
+		// 	   std::cout << "Len: " << entrie.length << std::endl;
+		// }
+	}
+
+	return false;
+}