1 files changed, 148 insertions, 8 deletions

diff --git a/src/factories/AudioFactory.cpp b/src/factories/AudioFactory.cpp
index d1d2111..a6c5364 100644
--- a/src/factories/AudioFactory.cpp
+++ b/src/factories/AudioFactory.cpp
@@ -2,7 +2,7 @@
 
 #include <vector>
 #include "audio/AudioManager.h"
-#include "audio/AIFCDecode.h"
+#include "audio/samples_table.h"
 #include "binarytools/BinaryReader.h"
 
 bool AudioFactory::process(LUS::BinaryWriter* writer, nlohmann::json& data, std::vector<uint8_t>& buffer) {
@@ -22,16 +22,156 @@ bool AudioFactory::process(LUS::BinaryWriter* writer, nlohmann::json& data, std:
         return true;
 	}
 
-    if(!metadata[1].contains("us")){
+    if(path.find("sound/banks") != std::string::npos){
+        auto banks = AudioManager::Instance->get_banks();
+        auto bankId = metadata["us"][0];
+        auto bank = banks[bankId];
+
+        if(bankId == 10){
+            int bp = 1;
+        }
+
+        WRITE_HEADER(LUS::ResourceType::Bank, 0);
+
+        if(path.find("sound/banks/us/20_bank") != std::string::npos){
+            int bp = 0;
+        }
+
+        WRITE_U32(bank.insts.size());
+        for(auto &instrument : bank.insts){
+            WRITE_U8(instrument.valid);
+            if(!instrument.valid){
+                continue;
+            }
+            WRITE_U8(instrument.releaseRate);
+            WRITE_U8(instrument.normalRangeLo);
+            WRITE_U8(instrument.normalRangeHi);
+
+            auto envelope = bank.envelopes[instrument.envelope];
+            if(!envelope.entries.empty()){
+                WRITE_U32(envelope.entries.size());
+                for(auto &entry : envelope.entries){
+                    writer->Write(entry.delay);
+                    writer->Write(entry.arg);
+                }
+            } else {
+                WRITE_U32(0);
+            }
+
+            uint32_t soundFlags = 0;
+            bool hasLo = instrument.soundLo.has_value();
+            bool hasMed = instrument.soundMed.has_value();
+            bool hasHi = instrument.soundHi.has_value();
+            if(hasLo){
+                soundFlags |= (1 << 0);
+            }
+            if(hasMed){
+                soundFlags |= (1 << 1);
+            }
+            if(hasHi){
+                soundFlags |= (1 << 2);
+            }
+
+            WRITE_U32(soundFlags);
+            if(hasLo){
+                auto value = instrument.soundLo.value();
+                uint32_t idx = AudioManager::Instance->get_index(bank.samples[value.offset]);
+                writer->Write(std::string(gSampleTable[idx]));
+                writer->Write(value.tuning);
+            }
+            if(hasMed){
+                auto value = instrument.soundMed.value();
+                uint32_t idx = AudioManager::Instance->get_index(bank.samples[value.offset]);
+                writer->Write(std::string(gSampleTable[idx]));
+                writer->Write(value.tuning);
+            }
+            if(hasHi){
+                auto value = instrument.soundHi.value();
+                uint32_t idx = AudioManager::Instance->get_index(bank.samples[value.offset]);
+                writer->Write(std::string(gSampleTable[idx]));
+                writer->Write(value.tuning);
+            }
+
+        }
+
+        WRITE_U32(bank.drums.size());
+        for(auto &drum : bank.drums){
+            WRITE_U8(drum.releaseRate);
+            WRITE_U8(drum.pan);
+            auto envelope = bank.envelopes[drum.envelope];
+            if(!envelope.entries.empty()){
+                std::cout << "Envelope entries: " << envelope.entries.size() << std::endl;
+                WRITE_U32(envelope.entries.size());
+                for(auto &entry : envelope.entries){
+                    writer->Write(entry.delay);
+                    writer->Write(entry.arg);
+                }
+            } else {
+                WRITE_U32(0);
+            }
+
+            uint32_t idx = AudioManager::Instance->get_index(bank.samples[drum.sound.offset]);
+            std::string out = std::string(gSampleTable[idx]);
+            writer->Write(out);
+            writer->Write(drum.sound.tuning);
+        }
+
+        return true;
+    }
+
+    if(metadata.size() < 2 || !metadata[1].contains("us")){
         return false;
     }
 
-    LUS::BinaryWriter aifcWriter;
-    AudioManager::Instance->create_aifc(metadata[1]["us"][1], aifcWriter);
-    std::vector<char> aifcData = aifcWriter.ToVector();
-    aifcWriter.Close();
+    /*
+     * HINT: Uncomment this to write the aiff to a file
+     LUS::BinaryWriter aifcWriter;
+     AudioManager::Instance->create_aifc(metadata[1]["us"][1], aifcWriter);
+     std::vector<char> aifcData = aifcWriter.ToVector();
+     aifcWriter.Close();
+     write_aiff(aifcData, *writer);
+    */
+
+    WRITE_HEADER(LUS::ResourceType::Audio, 0);
+
+    AudioBankSample entry = AudioManager::Instance->get_aifc(metadata[1]["us"][1]);
+
+    if(path.find("00_mario_waaaooow") != std::string::npos){
+        int bp = 0;
+    }
+
+    // Write AdpcmLoop
+    WRITE_U32(entry.loop.start);
+    WRITE_U32(entry.loop.end);
+    WRITE_I32(entry.loop.count);
+    WRITE_U32(entry.loop.pad);
+
+    if(entry.loop.state.has_value()){
+        std::vector<int16_t> state = entry.loop.state.value();
+        WRITE_U32(state.size());
+        for(auto &value : state){
+            writer->Write(value);
+        }
+    } else {
+        WRITE_U32(0);
+    }
+
+    // Write AdpcmBook
+    WRITE_I32(entry.book.order);
+    WRITE_I32(entry.book.npredictors);
+
+    WRITE_U32(entry.book.table.size());
+    for(auto &value : entry.book.table){
+        writer->Write(value);
+    }
+
+    // Write sample
+    WRITE_I32(entry.data.size());
+    for(auto &value : entry.data){
+        WRITE_U8(value);
+    }
 
-    write_aiff(aifcData, *writer);
+    writer->Write(entry.name);
 
     return true;
-}
+}
\ No newline at end of file