sampler_runtime.cpp

#include "sampler_runtime.h"

void SamplerRuntime::applyDefaultSettings() {
  catalog_ = nullptr;
  SettingsStore::applyDefaults(settings_);
  classificationReport_ = SampleClassifier::ClassificationReport{};
  ramLoadReport_ = SampleRamManager::LoadReport{};
  activeRegistryReport_ = ActiveSampleRegistry::RegistryReport{};
}

bool SamplerRuntime::loadSettingsFromSd() {
  return SettingsStore::loadFromSd(settings_);
}

void SamplerRuntime::applyAssignmentsToUi(Ui &ui, const SampleLibrary::Catalog &catalog) const {
  if (settings_.panicNote >= 0 && settings_.panicNote <= 127) {
    ui.setPanicMidiNote(settings_.panicNote);
  }

  for (int i = 0; i < settings_.playbackModeCount; i++) {
    const SettingsStore::SamplePlaybackMode &mode = settings_.playbackModes[i];
    const int sampleIndex = SampleLibrary::findIndexByPath(catalog, mode.samplePath);
    if (sampleIndex < 0) {
      continue;
    }
    ui.setSamplePlaybackMode(sampleIndex,
                             mode.loopPlaybackEnabled ? Ui::PlaybackMode::Loop
                                                      : Ui::PlaybackMode::OneShot);
  }

  for (int i = 0; i < settings_.assignmentCount; i++) {
    const SettingsStore::MidiAssignment &assignment = settings_.assignments[i];
    const int sampleIndex = SampleLibrary::findIndexByPath(catalog, assignment.samplePath);
    if (sampleIndex < 0) {
      continue;
    }
    ui.setMidiAssignment(assignment.note, sampleIndex);
    ui.setSampleVolume(sampleIndex, assignment.volume);
    ui.setSamplePlaybackMode(sampleIndex,
                             assignment.loopPlaybackEnabled ? Ui::PlaybackMode::Loop
                                                            : Ui::PlaybackMode::OneShot);
  }
}

void SamplerRuntime::collectAssignmentsFromUi(const Ui &ui, const SampleLibrary::Catalog &catalog) {
  settings_.panicNote = static_cast<int16_t>(ui.panicMidiNote());

  settings_.playbackModeCount = 0;
  for (int sampleIndex = 0; sampleIndex < catalog.count; sampleIndex++) {
    if (settings_.playbackModeCount >= SettingsStore::SamplerSettings::kMaxPlaybackModes) {
      break;
    }

    if (!ui.sampleLoopPlaybackEnabled(sampleIndex)) {
      continue;
    }

    const String &samplePath = catalog.paths[sampleIndex];
    if (samplePath.length() == 0) {
      continue;
    }

    SettingsStore::SamplePlaybackMode &mode = settings_.playbackModes[settings_.playbackModeCount];
    mode.samplePath = samplePath;
    mode.loopPlaybackEnabled = true;
    settings_.playbackModeCount++;
  }

  settings_.assignmentCount = 0;
  for (int note = 0; note < 128; note++) {
    if (settings_.assignmentCount >= SettingsStore::SamplerSettings::kMaxAssignments) {
      break;
    }

    const int sampleIndex = ui.assignedSampleForMidiNote(note);
    if (sampleIndex < 0 || sampleIndex >= catalog.count) continue;

    SettingsStore::MidiAssignment &entry = settings_.assignments[settings_.assignmentCount];
    entry.note = static_cast<uint8_t>(note);
    entry.samplePath = catalog.paths[sampleIndex];
    entry.volume = static_cast<uint8_t>(ui.sampleVolumeForSample(sampleIndex));
    entry.loopPlaybackEnabled = ui.sampleLoopPlaybackEnabled(sampleIndex);
    settings_.assignmentCount++;
  }
}

void SamplerRuntime::rebuildPreparedSamples() {
  settings_.sampleRamBudgetBytes = SampleRamManager::budgetBytes();
  classifyAssignedSamplesAndLog();
  loadClassifiedRamSamplesAndLog();
  buildActiveRegistryAndLog();
}

bool SamplerRuntime::saveSettingsToSd() const {
  return SettingsStore::saveToSd(settings_);
}

const SettingsStore::SamplerSettings &SamplerRuntime::settings() const {
  return settings_;
}

int SamplerRuntime::assignedSamplesCount() const {
  return settings_.assignmentCount;
}

int SamplerRuntime::ramSampleCount() const {
  return classificationReport_.ramSampleCount;
}

int SamplerRuntime::streamSampleCount() const {
  return classificationReport_.streamSampleCount;
}

uint32_t SamplerRuntime::sampleRamUsedBytes() const {
  return ramLoadReport_.usedBytes;
}

int SamplerRuntime::ramUsagePercent() const {
  const uint32_t budgetBytes = settings_.sampleRamBudgetBytes;
  if (budgetBytes == 0) return 0;
  const uint32_t pct = (100UL * ramLoadReport_.usedBytes) / budgetBytes;
  return (pct > 100UL) ? 100 : static_cast<int>(pct);
}

const ActiveSampleRegistry::Entry *SamplerRuntime::findRegistryEntryForNote(int note) const {
  for (int i = 0; i < activeRegistryReport_.itemCount; i++) {
    if (activeRegistryReport_.items[i].note == static_cast<uint8_t>(note)) {
      return &activeRegistryReport_.items[i];
    }
  }
  return nullptr;
}

const SampleClassifier::AssignedSampleClassification *SamplerRuntime::findClassificationByPath(
    const String &path) const {
  for (int i = 0; i < classificationReport_.itemCount; i++) {
    const SampleClassifier::AssignedSampleClassification &item = classificationReport_.items[i];
    if (item.path == path) {
      return &item;
    }
  }
  return nullptr;
}

void SamplerRuntime::classifyAssignedSamplesAndLog() {
  if (catalog_) SampleClassifier::classifyAssignedSamples(settings_, *catalog_, classificationReport_);
}

void SamplerRuntime::loadClassifiedRamSamplesAndLog() {
  const uint32_t startMs = millis();
  SampleRamManager::prepare(settings_, classificationReport_, ramLoadReport_);
  Serial.printf("RAM: %d samples loaded (%lu of %lu KiB) in %lu ms, %d streamed from SD "
                "(%d with preloaded start), %d failed to load\n",
                ramLoadReport_.loadedRamCount,
                static_cast<unsigned long>(ramLoadReport_.usedBytes / 1024U),
                static_cast<unsigned long>(ramLoadReport_.effectiveBudgetBytes / 1024U),
                static_cast<unsigned long>(millis() - startMs),
                classificationReport_.streamSampleCount + ramLoadReport_.fallbackToStreamCount,
                ramLoadReport_.loadedHeadCount,
                ramLoadReport_.readErrorCount);
}

void SamplerRuntime::buildActiveRegistryAndLog() {
  ActiveSampleRegistry::build(classificationReport_, activeRegistryReport_);
}