path: root/src/audio/tracker.cc

#include "tracker.h"
#include "audio.h"
#include "audio/synth.h"
#include "util/asset_manager.h"
#include "util/debug.h"
#include <cstring>
#include <vector>

static uint32_t g_last_trigger_idx = 0;

// Active pattern instance tracking
struct ActivePattern {
  uint16_t pattern_id;
  float start_music_time;  // When this pattern was triggered (music time)
  uint32_t next_event_idx; // Next event to trigger within this pattern
  bool active;
};

static ActivePattern g_active_patterns[MAX_SPECTROGRAMS];

struct ManagedSpectrogram {
  int synth_id;
  float* data;
  bool active;
};

// Simple pool for dynamic spectrograms (now for individual notes)
static ManagedSpectrogram g_spec_pool[MAX_SPECTROGRAMS];
static int g_next_pool_slot = 0; // Round-robin allocation

// CACHE: Pre-registered synth_ids for all samples (indexed by sample_id)
// This eliminates redundant spectrogram generation and registration
static int g_sample_synth_cache[256]; // Max 256 unique samples
static bool g_cache_initialized = false;

// Forward declarations
static int get_free_pool_slot();

void tracker_init() {
  g_last_trigger_idx = 0;
  g_next_pool_slot = 0;
  for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
    g_spec_pool[i].synth_id = -1;
    g_spec_pool[i].data = nullptr;
    g_spec_pool[i].active = false;
    g_active_patterns[i].active = false;
  }

  // Always re-initialize cache to ensure spectrograms are registered
  // This handles the case where synth_init() was called multiple times
  for (int i = 0; i < 256; ++i) {
    g_sample_synth_cache[i] = -1;
  }

  // Free any previously allocated generated note data to prevent leaks
  if (g_cache_initialized) {
    for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
      if (g_spec_pool[i].data != nullptr && g_spec_pool[i].active) {
        delete[] g_spec_pool[i].data;
        g_spec_pool[i].data = nullptr;
        g_spec_pool[i].active = false;
      }
    }
  }

  // Initialize sample cache
  {
    for (int i = 0; i < 256; ++i) {
      g_sample_synth_cache[i] = -1;
    }

    // Pre-register all unique samples (assets + generated notes)
    for (uint32_t sid = 0; sid < g_tracker_samples_count; ++sid) {
      AssetId aid = g_tracker_sample_assets[sid];

      if (aid != AssetId::ASSET_LAST_ID) {
        // ASSET sample: Load once and cache
        size_t size;
        const uint8_t* data = GetAsset(aid, &size);
        if (data && size >= sizeof(SpecHeader)) {
          const SpecHeader* header = (const SpecHeader*)data;
          const int note_frames = header->num_frames;
          const float* spectral_data =
              (const float*)(data + sizeof(SpecHeader));

          Spectrogram spec;
          spec.spectral_data_a = spectral_data;
          spec.spectral_data_b = spectral_data;
          spec.num_frames = note_frames;

          g_sample_synth_cache[sid] = synth_register_spectrogram(&spec);

#if defined(DEBUG_LOG_TRACKER)
          if (g_sample_synth_cache[sid] == -1) {
            DEBUG_TRACKER(
                "[TRACKER INIT] Failed to cache asset sample_id=%d (aid=%d)\n",
                sid, (int)aid);
          }
#endif /* defined(DEBUG_LOG_TRACKER) */
        }
      } else {
        // GENERATED note: Generate once and cache
        const NoteParams& params = g_tracker_samples[sid];
        int note_frames = 0;
        std::vector<float> note_data =
            generate_note_spectrogram(params, &note_frames);

        if (note_frames > 0) {
          // Allocate persistent storage for this note
          const int slot = get_free_pool_slot();
          g_spec_pool[slot].data = new float[note_data.size()];
          memcpy(g_spec_pool[slot].data, note_data.data(),
                 note_data.size() * sizeof(float));

          Spectrogram spec;
          spec.spectral_data_a = g_spec_pool[slot].data;
          spec.spectral_data_b = g_spec_pool[slot].data;
          spec.num_frames = note_frames;

          g_sample_synth_cache[sid] = synth_register_spectrogram(&spec);
          g_spec_pool[slot].synth_id = g_sample_synth_cache[sid];
          g_spec_pool[slot].active = true; // Mark as permanently allocated

#if defined(DEBUG_LOG_TRACKER)
          if (g_sample_synth_cache[sid] == -1) {
            DEBUG_TRACKER(
                "[TRACKER INIT] Failed to cache generated sample_id=%d "
                "(freq=%.2f)\n",
                sid, params.base_freq);
          }
#endif /* defined(DEBUG_LOG_TRACKER) */
        }
      }
    }

    g_cache_initialized = true;

#if defined(DEBUG_LOG_TRACKER)
    DEBUG_TRACKER("[TRACKER INIT] Cached %d unique samples\n",
                  g_tracker_samples_count);
#endif /* defined(DEBUG_LOG_TRACKER) */
  }
}

void tracker_reset() {
  g_last_trigger_idx = 0;
  for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
    g_active_patterns[i].active = false;
  }
}

static int get_free_pool_slot() {
  // Try to find an inactive slot first (unused slots)
  for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
    if (!g_spec_pool[i].active)
      return i;
  }

  // If all slots are active, reuse the oldest one (round-robin)
  // This automatically handles cleanup of old patterns
  const int slot = g_next_pool_slot;
  g_next_pool_slot = (g_next_pool_slot + 1) % MAX_SPECTROGRAMS;
  return slot;
}

static int get_free_pattern_slot() {
  for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
    if (!g_active_patterns[i].active)
      return i;
  }
  return -1; // No free slots
}

// Helper to trigger a single note event (OPTIMIZED with caching)
// start_offset_samples: How many samples into the future to trigger (for
// sample-accurate timing)
static void trigger_note_event(const TrackerEvent& event,
                               int start_offset_samples) {
#if defined(DEBUG_LOG_TRACKER)
  // VALIDATION: Check sample_id bounds
  if (event.sample_id >= g_tracker_samples_count) {
    DEBUG_TRACKER("[TRACKER ERROR] Invalid sample_id=%d (max=%d)\n",
                  event.sample_id, g_tracker_samples_count - 1);
    return;
  }
  // VALIDATION: Check volume and pan ranges
  if (event.volume < 0.0f || event.volume > 2.0f) {
    DEBUG_TRACKER("[TRACKER WARNING] Unusual volume=%.2f for sample_id=%d\n",
                  event.volume, event.sample_id);
  }
  if (event.pan < -1.0f || event.pan > 1.0f) {
    DEBUG_TRACKER("[TRACKER WARNING] Invalid pan=%.2f for sample_id=%d\n",
                  event.pan, event.sample_id);
  }
#endif /* defined(DEBUG_LOG_TRACKER) */

  // OPTIMIZED: Use cached synth_id instead of regenerating spectrogram
  const int cached_synth_id = g_sample_synth_cache[event.sample_id];

#if defined(DEBUG_LOG_TRACKER)
  if (cached_synth_id == -1) {
    DEBUG_TRACKER(
        "[TRACKER ERROR] No cached synth_id for sample_id=%d (init failed?)\n",
        event.sample_id);
    return;
  }
#endif /* defined(DEBUG_LOG_TRACKER) */

  if (cached_synth_id == -1) {
    return;
  }

  // Trigger voice with sample-accurate offset
  synth_trigger_voice(cached_synth_id, event.volume, event.pan,
                      start_offset_samples);
}

void tracker_update(float music_time_sec) {
  // Unit-less timing: 1 unit = 4 beats (by convention)
  const float BEATS_PER_UNIT = 4.0f;
  const float unit_duration_sec =
      (BEATS_PER_UNIT / g_tracker_score.bpm) * 60.0f;

  // Step 1: Process new pattern triggers
  while (g_last_trigger_idx < g_tracker_score.num_triggers) {
    const TrackerPatternTrigger& trigger =
        g_tracker_score.triggers[g_last_trigger_idx];

    const float trigger_time_sec = trigger.unit_time * unit_duration_sec;
    if (trigger_time_sec > music_time_sec)
      break;

    // Add this pattern to active patterns list
    const int slot = get_free_pattern_slot();
    if (slot != -1) {
      g_active_patterns[slot].pattern_id = trigger.pattern_id;
      g_active_patterns[slot].start_music_time = trigger_time_sec;
      g_active_patterns[slot].next_event_idx = 0;
      g_active_patterns[slot].active = true;
    }

    g_last_trigger_idx++;
  }

  // Step 2: Update all active patterns and trigger individual events
  // NOTE: We trigger events immediately when their time passes (no sample
  // offsets) This gives ~16ms quantization (60fps) which is acceptable Sample
  // offsets don't work with tempo scaling because music_time and render_time
  // are in different time domains (tempo-scaled vs physical)

  for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
    if (!g_active_patterns[i].active)
      continue;

    ActivePattern& active = g_active_patterns[i];
    const TrackerPattern& pattern = g_tracker_patterns[active.pattern_id];

    // Calculate elapsed unit-less time since pattern started
    const float elapsed_music_time = music_time_sec - active.start_music_time;
    const float elapsed_units = elapsed_music_time / unit_duration_sec;

    // Trigger all events that have passed their unit time
    while (active.next_event_idx < pattern.num_events) {
      const TrackerEvent& event = pattern.events[active.next_event_idx];

      if (event.unit_time > elapsed_units)
        break; // This event hasn't reached its time yet

      // Trigger this event immediately (no sample offset)
      // Timing quantization: ~16ms at 60fps, acceptable for rhythm
      trigger_note_event(event, 0);

      active.next_event_idx++;
    }

    // Pattern remains active until full duration elapses
    if (elapsed_units >= pattern.unit_length) {
      active.active = false;
    }
  }
}