feat(audio): Implement mock audio backend for testing (Task #51.2)

Created MockAudioBackend for deterministic audio event recording and
timing verification. Enables robust tracker synchronization testing.

Changes:
- Created VoiceTriggerEvent structure (timestamp, spec_id, volume, pan)
- Implemented MockAudioBackend with event recording capabilities
- Added time tracking: manual (advance_time) and automatic (on_frames_rendered)
- Created test_mock_backend.cc with 6 comprehensive test scenarios
- Verified synth integration and audio_render_silent compatibility
- Added to CMake test builds

All test infrastructure guarded by #if !defined(STRIP_ALL). Zero size
impact on production build. All 14 tests pass.

handoff(Claude): Task #51.2 complete, mock backend ready for tracker tests

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

5 files changed, 330 insertions, 1 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 03ce641..37d9459 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -286,6 +286,10 @@ if(DEMO_BUILD_TESTS)
     target_link_libraries(test_audio_backend PRIVATE audio util procedural ${DEMO_LIBS})
     add_dependencies(test_audio_backend generate_demo_assets)
 
+    add_demo_test(test_mock_backend MockAudioBackendTest src/tests/test_mock_backend.cc src/audio/mock_audio_backend.cc ${GEN_DEMO_CC})
+    target_link_libraries(test_mock_backend PRIVATE audio util procedural ${DEMO_LIBS})
+    add_dependencies(test_mock_backend generate_demo_assets)
+
     add_demo_test(test_tracker TrackerSystemTest src/tests/test_tracker.cc ${GEN_DEMO_CC} ${GENERATED_MUSIC_DATA_CC})
     target_link_libraries(test_tracker PRIVATE audio util procedural ${DEMO_LIBS})
     add_dependencies(test_tracker generate_tracker_music)
diff --git a/TODO.md b/TODO.md
index a981f8e..71ed4ff 100644
--- a/TODO.md
+++ b/TODO.md
@@ -3,6 +3,15 @@
 This file tracks prioritized tasks with detailed attack plans.
 
 ## Recently Completed (February 4, 2026)
+- [x] **Task #51.2: Mock Audio Backend**:
+    - [x] **Event Recording**: Created `VoiceTriggerEvent` structure to capture timestamp, spectrogram_id, volume, and pan.
+    - [x] **MockAudioBackend Class**: Implemented test-only backend with event recording and time tracking capabilities.
+    - [x] **Time Management**: Added `advance_time()`, `set_time()`, and `get_current_time()` for deterministic testing.
+    - [x] **Frame Rendering Hook**: Implemented `on_frames_rendered()` to automatically update time based on audio frames (32kHz).
+    - [x] **Synth Integration**: Verified mock backend correctly captures voice triggers from synth engine.
+    - [x] **Comprehensive Tests**: Created `test_mock_backend.cc` with 6 test scenarios covering all mock functionality.
+    - [x] **Build Integration**: Added mock backend to test builds, all 14 tests pass.
+
 - [x] **Task #51.1: Audio Backend Abstraction**:
     - [x] **Interface Created**: Defined `AudioBackend` interface in `src/audio/audio_backend.h` with hooks for voice triggering and frame rendering.
     - [x] **Production Backend**: Moved miniaudio implementation to `MiniaudioBackend` class, maintaining backward compatibility.
@@ -73,7 +82,7 @@ This file tracks prioritized tasks with detailed attack plans.
 
 - [ ] **Task #51: Tracker Timing Verification**
     - [x] **Task #51.1: Audio Backend Abstraction**: Create an interface to separate audio output from synth logic, enabling testable backends.
-    - [ ] **Task #51.2: Mock Audio Backend**: Implement a test backend that records voice trigger events with precise timestamps.
+    - [x] **Task #51.2: Mock Audio Backend**: Implement a test backend that records voice trigger events with precise timestamps.
     - [ ] **Task #51.3: Tracker Test Suite**: Create `test_tracker.cc` to verify pattern triggering, timing accuracy, and synchronization.
     - [ ] **Task #51.4: Integration with Build**: Wire up tests to CMake and ensure they run in CI.
 
diff --git a/src/audio/mock_audio_backend.cc b/src/audio/mock_audio_backend.cc
new file mode 100644
index 0000000..3f5a57a
--- /dev/null
+++ b/src/audio/mock_audio_backend.cc
@@ -0,0 +1,45 @@
+// This file is part of the 64k demo project.
+// It implements the mock audio backend for testing.
+// Records voice trigger events with precise timestamps.
+
+#include "mock_audio_backend.h"
+
+#if !defined(STRIP_ALL)
+
+MockAudioBackend::MockAudioBackend() : current_time_sec_(0.0f) {
+}
+
+MockAudioBackend::~MockAudioBackend() {
+}
+
+void MockAudioBackend::init() {
+  // No-op for mock backend
+}
+
+void MockAudioBackend::start() {
+  // No-op for mock backend
+}
+
+void MockAudioBackend::shutdown() {
+  // No-op for mock backend
+}
+
+void MockAudioBackend::on_voice_triggered(float timestamp, int spectrogram_id,
+                                           float volume, float pan) {
+  // Record the event with the timestamp provided by synth
+  VoiceTriggerEvent event;
+  event.timestamp_sec = timestamp;
+  event.spectrogram_id = spectrogram_id;
+  event.volume = volume;
+  event.pan = pan;
+  recorded_events_.push_back(event);
+}
+
+void MockAudioBackend::on_frames_rendered(int num_frames) {
+  // Update internal time based on frames rendered
+  // This is called by audio_render_silent() for seek/fast-forward simulation
+  const float delta_sec = (float)num_frames / (float)kSampleRate;
+  current_time_sec_ += delta_sec;
+}
+
+#endif /* !defined(STRIP_ALL) */
diff --git a/src/audio/mock_audio_backend.h b/src/audio/mock_audio_backend.h
new file mode 100644
index 0000000..963d9cb
--- /dev/null
+++ b/src/audio/mock_audio_backend.h
@@ -0,0 +1,56 @@
+// This file is part of the 64k demo project.
+// It implements a test-only mock audio backend for event recording.
+// Used for tracker timing verification and audio synchronization tests.
+
+#pragma once
+
+#if !defined(STRIP_ALL)
+
+#include "audio_backend.h"
+#include <vector>
+
+// Event structure for recorded voice triggers
+struct VoiceTriggerEvent {
+  float timestamp_sec;
+  int spectrogram_id;
+  float volume;
+  float pan;
+};
+
+// Mock audio backend that records all voice trigger events
+// Used for testing tracker timing and synchronization
+class MockAudioBackend : public AudioBackend {
+ public:
+  MockAudioBackend();
+  ~MockAudioBackend() override;
+
+  // AudioBackend interface (no-ops for mock)
+  void init() override;
+  void start() override;
+  void shutdown() override;
+
+  // Event recording hooks
+  void on_voice_triggered(float timestamp, int spectrogram_id, float volume,
+                          float pan) override;
+  void on_frames_rendered(int num_frames) override;
+
+  // Test interface methods
+  const std::vector<VoiceTriggerEvent>& get_events() const {
+    return recorded_events_;
+  }
+  void clear_events() { recorded_events_.clear(); }
+
+  // Manual time control for deterministic testing
+  void advance_time(float delta_sec) { current_time_sec_ += delta_sec; }
+  void set_time(float time_sec) { current_time_sec_ = time_sec; }
+  float get_current_time() const { return current_time_sec_; }
+
+  // Sample rate used for frame-to-time conversion
+  static const int kSampleRate = 32000;
+
+ private:
+  std::vector<VoiceTriggerEvent> recorded_events_;
+  float current_time_sec_;
+};
+
+#endif /* !defined(STRIP_ALL) */
diff --git a/src/tests/test_mock_backend.cc b/src/tests/test_mock_backend.cc
new file mode 100644
index 0000000..9173bb2
--- /dev/null
+++ b/src/tests/test_mock_backend.cc
@@ -0,0 +1,215 @@
+// This file is part of the 64k demo project.
+// It tests the MockAudioBackend implementation.
+// Verifies event recording, time tracking, and synth integration.
+
+#include "audio/mock_audio_backend.h"
+#include "audio/audio.h"
+#include "audio/synth.h"
+#include <assert.h>
+#include <stdio.h>
+#include <cmath>
+
+#if !defined(STRIP_ALL)
+
+void test_event_recording() {
+  MockAudioBackend backend;
+
+  // Initially no events
+  assert(backend.get_events().size() == 0);
+  assert(backend.get_current_time() == 0.0f);
+
+  // Simulate voice trigger
+  backend.on_voice_triggered(0.5f, 3, 0.75f, -0.25f);
+
+  // Verify event recorded
+  const auto& events = backend.get_events();
+  assert(events.size() == 1);
+  assert(events[0].timestamp_sec == 0.5f);
+  assert(events[0].spectrogram_id == 3);
+  assert(events[0].volume == 0.75f);
+  assert(events[0].pan == -0.25f);
+
+  // Record multiple events
+  backend.on_voice_triggered(1.0f, 5, 1.0f, 0.0f);
+  backend.on_voice_triggered(1.5f, 3, 0.5f, 0.5f);
+
+  assert(backend.get_events().size() == 3);
+  assert(events[1].timestamp_sec == 1.0f);
+  assert(events[2].timestamp_sec == 1.5f);
+
+  // Clear events
+  backend.clear_events();
+  assert(backend.get_events().size() == 0);
+
+  printf("Event recording test PASSED\n");
+}
+
+void test_time_tracking() {
+  MockAudioBackend backend;
+
+  // Test manual time advance
+  assert(backend.get_current_time() == 0.0f);
+
+  backend.advance_time(0.5f);
+  assert(backend.get_current_time() == 0.5f);
+
+  backend.advance_time(1.0f);
+  assert(backend.get_current_time() == 1.5f);
+
+  // Test time setting
+  backend.set_time(10.0f);
+  assert(backend.get_current_time() == 10.0f);
+
+  printf("Time tracking test PASSED\n");
+}
+
+void test_frame_rendering() {
+  MockAudioBackend backend;
+
+  // Simulate frame rendering (32000 Hz sample rate)
+  // 1 second = 32000 frames
+  backend.on_frames_rendered(16000); // 0.5 seconds
+  assert(std::abs(backend.get_current_time() - 0.5f) < 0.001f);
+
+  backend.on_frames_rendered(16000); // Another 0.5 seconds
+  assert(std::abs(backend.get_current_time() - 1.0f) < 0.001f);
+
+  backend.on_frames_rendered(32000); // 1 second
+  assert(std::abs(backend.get_current_time() - 2.0f) < 0.001f);
+
+  printf("Frame rendering test PASSED\n");
+}
+
+void test_synth_integration() {
+  MockAudioBackend backend;
+  audio_set_backend(&backend);
+
+  synth_init();
+
+  // Create dummy spectrogram
+  float data[DCT_SIZE * 10] = {0};
+  data[0] = 100.0f; // DC component
+
+  Spectrogram spec = {data, data, 10};
+  int spec_id = synth_register_spectrogram(&spec);
+  assert(spec_id >= 0);
+
+  // Trigger voice - should be recorded at time 0
+  synth_trigger_voice(spec_id, 0.8f, -0.3f);
+
+  // Verify event recorded
+  const auto& events = backend.get_events();
+  assert(events.size() == 1);
+  assert(events[0].timestamp_sec == 0.0f); // Before any rendering
+  assert(events[0].spectrogram_id == spec_id);
+  assert(events[0].volume == 0.8f);
+  assert(events[0].pan == -0.3f);
+
+  // Render some frames to advance time
+  float output[1024] = {0};
+  synth_render(output, 512); // ~0.016 sec at 32kHz
+
+  // Verify synth updated its time
+  // (Note: synth time is internal, mock doesn't track it from render)
+
+  // Trigger another voice after rendering
+  synth_trigger_voice(spec_id, 1.0f, 0.5f);
+
+  assert(events.size() == 2);
+  // Second trigger should have timestamp > 0
+  assert(events[1].timestamp_sec > 0.0f);
+  assert(events[1].timestamp_sec < 0.02f); // ~512 frames = ~0.016 sec
+
+  printf("Synth integration test PASSED\n");
+}
+
+void test_multiple_voices() {
+  MockAudioBackend backend;
+  audio_set_backend(&backend);
+
+  synth_init();
+
+  // Create multiple spectrograms
+  float data1[DCT_SIZE * 5] = {0};
+  float data2[DCT_SIZE * 5] = {0};
+  float data3[DCT_SIZE * 5] = {0};
+
+  Spectrogram spec1 = {data1, data1, 5};
+  Spectrogram spec2 = {data2, data2, 5};
+  Spectrogram spec3 = {data3, data3, 5};
+
+  int id1 = synth_register_spectrogram(&spec1);
+  int id2 = synth_register_spectrogram(&spec2);
+  int id3 = synth_register_spectrogram(&spec3);
+
+  // Trigger multiple voices at once
+  synth_trigger_voice(id1, 1.0f, -1.0f);
+  synth_trigger_voice(id2, 0.5f, 0.0f);
+  synth_trigger_voice(id3, 0.75f, 1.0f);
+
+  // Verify all recorded
+  const auto& events = backend.get_events();
+  assert(events.size() == 3);
+
+  // Verify each has correct properties
+  assert(events[0].spectrogram_id == id1);
+  assert(events[1].spectrogram_id == id2);
+  assert(events[2].spectrogram_id == id3);
+
+  assert(events[0].volume == 1.0f);
+  assert(events[1].volume == 0.5f);
+  assert(events[2].volume == 0.75f);
+
+  assert(events[0].pan == -1.0f);
+  assert(events[1].pan == 0.0f);
+  assert(events[2].pan == 1.0f);
+
+  printf("Multiple voices test PASSED\n");
+}
+
+void test_audio_render_silent_integration() {
+  MockAudioBackend backend;
+  audio_set_backend(&backend);
+
+  audio_init();
+  synth_init();
+
+  // Create a spectrogram
+  float data[DCT_SIZE * 5] = {0};
+  Spectrogram spec = {data, data, 5};
+  int spec_id = synth_register_spectrogram(&spec);
+
+  // Trigger at t=0
+  synth_trigger_voice(spec_id, 1.0f, 0.0f);
+
+  // Simulate 2 seconds of silent rendering (seek/fast-forward)
+  audio_render_silent(2.0f);
+
+  // Verify backend time advanced via on_frames_rendered
+  const float expected_time = 2.0f;
+  const float actual_time = backend.get_current_time();
+  assert(std::abs(actual_time - expected_time) < 0.01f); // 10ms tolerance
+
+  audio_shutdown();
+
+  printf("audio_render_silent integration test PASSED\n");
+}
+
+#endif /* !defined(STRIP_ALL) */
+
+int main() {
+#if !defined(STRIP_ALL)
+  printf("Running MockAudioBackend tests...\n");
+  test_event_recording();
+  test_time_tracking();
+  test_frame_rendering();
+  test_synth_integration();
+  test_multiple_voices();
+  test_audio_render_silent_integration();
+  printf("All MockAudioBackend tests PASSED\n");
+  return 0;
+#else
+  printf("MockAudioBackend tests skipped (STRIP_ALL enabled)\n");
+  return 0;
+#endif /* !defined(STRIP_ALL) */
+}