Add support for embedding NAM models and IR files in session data

damiangr · damiangr · commit 4996eaf84bfa · 2025-12-14T18:48:16.000+01:00
This enables DAW sessions to be fully portable by storing the actual
NAM model and IR file data in the session, not just file paths.

Changes:
- SerializeState: Embed NAM/IR file data in session chunk
- UnserializeState: Load from embedded data if file path not found
- New _StageModelFromData/_StageIRFromData functions
- Version bump to 0.7.13 with backward-compatible serialization

Behavior:
- Prefers loading from file path if available (for easy model updates)
- Falls back to embedded data if file is missing (for portability)
- Fully backward compatible with older session formats
diff --git a/NeuralAmpModeler/NeuralAmpModeler.cpp b/NeuralAmpModeler/NeuralAmpModeler.cpp
@@ -1,6 +1,7 @@
 #include <algorithm> // std::clamp, std::min
 #include <cmath> // pow
 #include <filesystem>
+#include <fstream> // std::ifstream for file reading
 #include <iostream>
 #include <utility>
 
@@ -74,7 +75,6 @@ const bool kDefaultCalibrateInput = false;
 const std::string kInputCalibrationLevelParamName = "InputCalibrationLevel";
 const double kDefaultInputCalibrationLevel = 12.0;
 
-
 NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info)
 : Plugin(info, MakeConfig(kNumParams, kNumPresets))
 {
@@ -183,7 +183,6 @@ NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info)
       {
         // Sets mNAMPath and mStagedNAM
         const std::string msg = _StageModel(fileName);
-        // TODO error messages like the IR loader.
         if (msg.size())
         {
           std::stringstream ss;
@@ -407,16 +406,33 @@ void NeuralAmpModeler::OnIdle()
 
 bool NeuralAmpModeler::SerializeState(IByteChunk& chunk) const
 {
-  // If this isn't here when unserializing, then we know we're dealing with something before v0.8.0.
+  // If this isn't here when unserializing, then we know we're dealing with something before v0.7.13.
   WDL_String header("###NeuralAmpModeler###"); // Don't change this!
   chunk.PutStr(header.Get());
   // Plugin version, so we can load legacy serialized states in the future!
   WDL_String version(PLUG_VERSION_STR);
   chunk.PutStr(version.Get());
-  // Model directory (don't serialize the model itself; we'll just load it again
-  // when we unserialize)
+
+  // Serialize file paths for backward compatibility
   chunk.PutStr(mNAMPath.Get());
   chunk.PutStr(mIRPath.Get());
+
+  // Embed the actual file data for portability
+  // Data was read when model/IR was loaded
+  int namDataSize = static_cast<int>(mNAMData.size());
+  chunk.Put(&namDataSize);
+  if (namDataSize > 0)
+  {
+    chunk.PutBytes(mNAMData.data(), namDataSize);
+  }
+
+  int irDataSize = static_cast<int>(mIRData.size());
+  chunk.Put(&irDataSize);
+  if (irDataSize > 0)
+  {
+    chunk.PutBytes(mIRData.data(), irDataSize);
+  }
+
   return SerializeParams(chunk);
 }
 
@@ -689,14 +705,28 @@ void NeuralAmpModeler::_SetOutputGain()
 std::string NeuralAmpModeler::_StageModel(const WDL_String& modelPath)
 {
   WDL_String previousNAMPath = mNAMPath;
+  const double sampleRate = GetSampleRate();
+
   try
   {
     auto dspPath = std::filesystem::u8path(modelPath.Get());
     std::unique_ptr<nam::DSP> model = nam::get_dsp(dspPath);
-    std::unique_ptr<ResamplingNAM> temp = std::make_unique<ResamplingNAM>(std::move(model), GetSampleRate());
-    temp->Reset(GetSampleRate(), GetBlockSize());
+    std::unique_ptr<ResamplingNAM> temp = std::make_unique<ResamplingNAM>(std::move(model), sampleRate);
+    temp->Reset(sampleRate, GetBlockSize());
     mStagedModel = std::move(temp);
     mNAMPath = modelPath;
+
+    // Read file data for embedding in session
+    mNAMData.clear();
+    std::ifstream file(dspPath, std::ios::binary | std::ios::ate);
+    if (file.is_open())
+    {
+      std::streamsize size = file.tellg();
+      file.seekg(0, std::ios::beg);
+      mNAMData.resize(static_cast<size_t>(size));
+      file.read(reinterpret_cast<char*>(mNAMData.data()), size);
+    }
+
     SendControlMsgFromDelegate(kCtrlTagModelFileBrowser, kMsgTagLoadedModel, mNAMPath.GetLength(), mNAMPath.Get());
   }
   catch (std::runtime_error& e)
@@ -721,6 +751,7 @@ dsp::wav::LoadReturnCode NeuralAmpModeler::_StageIR(const WDL_String& irPath)
   // path and the model got caught on opposite sides of the fence...
   WDL_String previousIRPath = mIRPath;
   const double sampleRate = GetSampleRate();
+
   dsp::wav::LoadReturnCode wavState = dsp::wav::LoadReturnCode::ERROR_OTHER;
   try
   {
@@ -738,6 +769,19 @@ dsp::wav::LoadReturnCode NeuralAmpModeler::_StageIR(const WDL_String& irPath)
   if (wavState == dsp::wav::LoadReturnCode::SUCCESS)
   {
     mIRPath = irPath;
+
+    // Read file data for embedding in session
+    mIRData.clear();
+    auto irPathU8 = std::filesystem::u8path(irPath.Get());
+    std::ifstream file(irPathU8, std::ios::binary | std::ios::ate);
+    if (file.is_open())
+    {
+      std::streamsize size = file.tellg();
+      file.seekg(0, std::ios::beg);
+      mIRData.resize(static_cast<size_t>(size));
+      file.read(reinterpret_cast<char*>(mIRData.data()), size);
+    }
+
     SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, mIRPath.GetLength(), mIRPath.Get());
   }
   else
@@ -911,5 +955,207 @@ void NeuralAmpModeler::_UpdateMeters(sample** inputPointer, sample** outputPoint
   mOutputSender.ProcessBlock(outputPointer, (int)nFrames, kCtrlTagOutputMeter, nChansHack);
 }
 
+std::string NeuralAmpModeler::_StageModelFromData(const std::vector<uint8_t>& data, const WDL_String& originalPath)
+{
+  WDL_String previousNAMPath = mNAMPath;
+  const double sampleRate = GetSampleRate();
+
+  try
+  {
+    // Parse the JSON from memory
+    std::string jsonStr(data.begin(), data.end());
+    nlohmann::json j = nlohmann::json::parse(jsonStr);
+
+    // Build dspData structure
+    nam::dspData dspData;
+    dspData.version = j["version"];
+    dspData.architecture = j["architecture"];
+    dspData.config = j["config"];
+    dspData.metadata = j["metadata"];
+
+    // Extract weights
+    if (j.find("weights") != j.end())
+    {
+      dspData.weights = j["weights"].get<std::vector<float>>();
+    }
+
+    // Extract sample rate
+    if (j.find("sample_rate") != j.end())
+      dspData.expected_sample_rate = j["sample_rate"];
+    else
+      dspData.expected_sample_rate = -1.0;
+
+    // Create DSP from dspData
+    std::unique_ptr<nam::DSP> model = nam::get_dsp(dspData);
+    std::unique_ptr<ResamplingNAM> temp = std::make_unique<ResamplingNAM>(std::move(model), sampleRate);
+    temp->Reset(sampleRate, GetBlockSize());
+    mStagedModel = std::move(temp);
+    mNAMPath = originalPath;
+    mNAMData = data;  // Store the embedded data
+    SendControlMsgFromDelegate(kCtrlTagModelFileBrowser, kMsgTagLoadedModel, mNAMPath.GetLength(), mNAMPath.Get());
+  }
+  catch (std::exception& e)
+  {
+    SendControlMsgFromDelegate(kCtrlTagModelFileBrowser, kMsgTagLoadFailed);
+
+    if (mStagedModel != nullptr)
+    {
+      mStagedModel = nullptr;
+    }
+    mNAMPath = previousNAMPath;
+    std::cerr << "Failed to read DSP module from embedded data" << std::endl;
+    std::cerr << e.what() << std::endl;
+    return e.what();
+  }
+  return "";
+}
+
+dsp::wav::LoadReturnCode NeuralAmpModeler::_StageIRFromData(const std::vector<uint8_t>& data,
+                                                            const WDL_String& originalPath)
+{
+  WDL_String previousIRPath = mIRPath;
+  const double sampleRate = GetSampleRate();
+
+  dsp::wav::LoadReturnCode wavState = dsp::wav::LoadReturnCode::ERROR_OTHER;
+
+  try
+  {
+    // Parse WAV from memory
+    std::vector<float> audio;
+    double wavSampleRate = 0.0;
+
+    // Basic WAV parser for in-memory data
+    // WAV format: RIFF header (12 bytes) + fmt chunk + data chunk
+    if (data.size() < 44) // Minimum WAV file size
+    {
+      throw std::runtime_error("IR data too small to be valid WAV");
+    }
+
+    // Check RIFF header
+    if (data[0] != 'R' || data[1] != 'I' || data[2] != 'F' || data[3] != 'F')
+    {
+      throw std::runtime_error("Invalid WAV format - missing RIFF header");
+    }
+
+    // Check WAVE format
+    if (data[8] != 'W' || data[9] != 'A' || data[10] != 'V' || data[11] != 'E')
+    {
+      throw std::runtime_error("Invalid WAV format - not a WAVE file");
+    }
+
+    // Find fmt chunk
+    size_t pos = 12;
+    uint16_t audioFormat = 0;
+    uint16_t numChannels = 0;
+    uint32_t sampleRateInt = 0;
+    uint16_t bitsPerSample = 0;
+
+    while (pos < data.size() - 8)
+    {
+      std::string chunkID(data.begin() + pos, data.begin() + pos + 4);
+      uint32_t chunkSize = *reinterpret_cast<const uint32_t*>(&data[pos + 4]);
+
+      if (chunkID == "fmt ")
+      {
+        audioFormat = *reinterpret_cast<const uint16_t*>(&data[pos + 8]);
+        numChannels = *reinterpret_cast<const uint16_t*>(&data[pos + 10]);
+        sampleRateInt = *reinterpret_cast<const uint32_t*>(&data[pos + 12]);
+        bitsPerSample = *reinterpret_cast<const uint16_t*>(&data[pos + 22]);
+        wavSampleRate = static_cast<double>(sampleRateInt);
+      }
+      else if (chunkID == "data")
+      {
+        // Found data chunk
+        size_t dataStart = pos + 8;
+        size_t numSamples = chunkSize / (bitsPerSample / 8);
+
+        audio.resize(numSamples);
+
+        // Convert based on bits per sample
+        if (bitsPerSample == 16 && audioFormat == 1) // PCM 16-bit
+        {
+          for (size_t i = 0; i < numSamples; i++)
+          {
+            int16_t sample = *reinterpret_cast<const int16_t*>(&data[dataStart + i * 2]);
+            audio[i] = sample / 32768.0f;
+          }
+        }
+        else if (bitsPerSample == 24 && audioFormat == 1) // PCM 24-bit
+        {
+          for (size_t i = 0; i < numSamples; i++)
+          {
+            int32_t sample = 0;
+            sample |= static_cast<int32_t>(data[dataStart + i * 3]);
+            sample |= static_cast<int32_t>(data[dataStart + i * 3 + 1]) << 8;
+            sample |= static_cast<int32_t>(data[dataStart + i * 3 + 2]) << 16;
+            if (sample & 0x800000)
+              sample |= 0xFF000000; // Sign extend
+            audio[i] = sample / 8388608.0f;
+          }
+        }
+        else if (bitsPerSample == 32 && audioFormat == 3) // IEEE float 32-bit
+        {
+          for (size_t i = 0; i < numSamples; i++)
+          {
+            audio[i] = *reinterpret_cast<const float*>(&data[dataStart + i * 4]);
+          }
+        }
+        else
+        {
+          throw std::runtime_error("Unsupported WAV format");
+        }
+
+        break;
+      }
+
+      pos += 8 + chunkSize;
+    }
+
+    if (audio.empty())
+    {
+      throw std::runtime_error("No audio data found in WAV");
+    }
+
+    // Layer 9: Validate that fmt chunk was actually found and sample rate is valid
+    // WAV files can have missing fmt chunks or chunks in wrong order
+    if (wavSampleRate <= 0.0 || wavSampleRate != wavSampleRate)
+    {
+      throw std::runtime_error("Invalid or missing sample rate in WAV fmt chunk");
+    }
+
+    // Create IR from the loaded data
+    dsp::ImpulseResponse::IRData irData;
+    irData.mRawAudio = audio;
+    irData.mRawAudioSampleRate = wavSampleRate;
+
+    mStagedIR = std::make_unique<dsp::ImpulseResponse>(irData, sampleRate);
+    wavState = dsp::wav::LoadReturnCode::SUCCESS;
+  }
+  catch (std::exception& e)
+  {
+    wavState = dsp::wav::LoadReturnCode::ERROR_OTHER;
+    std::cerr << "Failed to load IR from embedded data:" << std::endl;
+    std::cerr << e.what() << std::endl;
+  }
+
+  if (wavState == dsp::wav::LoadReturnCode::SUCCESS)
+  {
+    mIRPath = originalPath;
+    mIRData = data;  // Store the embedded data
+    SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, mIRPath.GetLength(), mIRPath.Get());
+  }
+  else
+  {
+    if (mStagedIR != nullptr)
+    {
+      mStagedIR = nullptr;
+    }
+    mIRPath = previousIRPath;
+    SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadFailed);
+  }
+
+  return wavState;
+}
+
 // HACK
 #include "Unserialization.cpp"
diff --git a/NeuralAmpModeler/NeuralAmpModeler.h b/NeuralAmpModeler/NeuralAmpModeler.h
@@ -220,10 +220,14 @@ class NeuralAmpModeler final : public iplug::Plugin
   // Loads a NAM model and stores it to mStagedNAM
   // Returns an empty string on success, or an error message on failure.
   std::string _StageModel(const WDL_String& dspFile);
+  // Loads a NAM model from embedded binary data
+  std::string _StageModelFromData(const std::vector<uint8_t>& data, const WDL_String& originalPath);
   // Loads an IR and stores it to mStagedIR.
   // Return status code so that error messages can be relayed if
   // it wasn't successful.
   dsp::wav::LoadReturnCode _StageIR(const WDL_String& irPath);
+  // Loads an IR from embedded binary data
+  dsp::wav::LoadReturnCode _StageIRFromData(const std::vector<uint8_t>& data, const WDL_String& originalPath);
 
   bool _HaveModel() const { return this->mModel != nullptr; };
   // Prepare the input & output buffers
@@ -307,6 +311,10 @@ class NeuralAmpModeler final : public iplug::Plugin
   // Path to IR (.wav file)
   WDL_String mIRPath;
 
+  // Embedded file data for portability (stored with DAW session)
+  std::vector<uint8_t> mNAMData;
+  std::vector<uint8_t> mIRData;
+
   WDL_String mHighLightColor{PluginColors::NAM_THEMECOLOR.ToColorCode()};
 
   std::unordered_map<std::string, double> mNAMParams = {{"Input", 0.0}, {"Output", 0.0}};
diff --git a/NeuralAmpModeler/Unserialization.cpp b/NeuralAmpModeler/Unserialization.cpp
