feat: add session recorder

Author: schollz

clients/oooooooo/CMakeLists.txt

@@ -115,6 +115,7 @@ set(SRC
     src/DisplayRing.cpp
     src/DrawFunctions.cpp
     src/BufDiskWorker.cpp
+    src/SessionRecorder.cpp
     src/Window.cpp
 )
 

clients/oooooooo/src/Display.cpp

@@ -534,19 +534,21 @@ void Display::renderLoop() {
     SDL_DestroyTexture(cpuTextTexture);
     SDL_FreeSurface(cpuTextSurface);
 
-    // show the help text in the bottom left corner
-    std::string helpText = "Tab: toggle menu, h: toggle help";
-    int helpTextWidth, helpTextHeight;
-    TTF_SizeText(font, helpText.c_str(), &helpTextWidth, &helpTextHeight);
-    SDL_Surface* helpTextSurface = TTF_RenderText_Solid(
-        font, helpText.c_str(), {40, 40, 40, 255});  // Dark gray text
-    SDL_Texture* helpTextTexture =
-        SDL_CreateTextureFromSurface(renderer_, helpTextSurface);
-    SDL_Rect helpTextRect = {10, height_ - helpTextHeight - 10, helpTextWidth,
-                             helpTextHeight};
-    SDL_RenderCopy(renderer_, helpTextTexture, nullptr, &helpTextRect);
-    SDL_DestroyTexture(helpTextTexture);
-    SDL_FreeSurface(helpTextSurface);
+    // show recording indicator if session recording is active
+    if (softCutClient_ && softCutClient_->isSessionRecording()) {
+      std::string recText = "REC";
+      int recTextWidth, recTextHeight;
+      TTF_SizeText(font, recText.c_str(), &recTextWidth, &recTextHeight);
+      SDL_Surface* recTextSurface = TTF_RenderText_Solid(
+          font, recText.c_str(), {255, 0, 0, 255});  // Red text
+      SDL_Texture* recTextTexture =
+          SDL_CreateTextureFromSurface(renderer_, recTextSurface);
+      SDL_Rect recTextRect = {width_ - cpuTextWidth - recTextWidth - 20, 10,
+                              recTextWidth, recTextHeight};
+      SDL_RenderCopy(renderer_, recTextTexture, nullptr, &recTextRect);
+      SDL_DestroyTexture(recTextTexture);
+      SDL_FreeSurface(recTextSurface);
+    }
 
     // Update screen
     SDL_RenderPresent(renderer_);

clients/oooooooo/src/KeyboardHandler.cpp

@@ -244,6 +244,16 @@ void KeyboardHandler::handleKeyDown(SDL_Keycode key, bool isRepeat,
         params_[i].ToggleView();
       }
       break;
+    case SDLK_y:
+      if (!isRepeat) {
+        softcut_->toggleSessionRecording();
+        if (softcut_->isSessionRecording()) {
+          display_->SetMessage("Session recording started", 2);
+        } else {
+          display_->SetMessage("Session recording stopped", 2);
+        }
+      }
+      break;
     case SDLK_UP:
       params_[0].SelectedDelta(isRepeat ? -2 : -1);
       break;

clients/oooooooo/src/SessionRecorder.cpp

@@ -0,0 +1,242 @@
+#include "SessionRecorder.h"
+
+#include <chrono>
+#include <ctime>
+#include <filesystem>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+SessionRecorder::SessionRecorder() : recording_(false), writerRunning_(false) {}
+
+SessionRecorder::~SessionRecorder() {
+  if (recording_.load()) {
+    stopRecording();
+  }
+}
+
+std::string SessionRecorder::generateTimestamp() {
+  auto now = std::chrono::system_clock::now();
+  auto time_t_now = std::chrono::system_clock::to_time_t(now);
+  std::tm* tm_now = std::localtime(&time_t_now);
+
+  std::ostringstream oss;
+  oss << std::put_time(tm_now, "%Y%m%d-%H%M");
+  return oss.str();
+}
+
+std::string SessionRecorder::generateFilename(const std::string& voiceId) {
+  std::string folder = "oooooooo";
+  if (!std::filesystem::exists(folder)) {
+    std::filesystem::create_directory(folder);
+  }
+  return folder + "/oooooooo_" + sessionTimestamp_ + "_loop_" + voiceId +
+         ".wav";
+}
+
+void SessionRecorder::initializeBuffer(VoiceBuffer& buffer, int channels) {
+  buffer.buffer.resize(RING_BUFFER_SIZE * channels);
+  buffer.writePos.store(0);
+  buffer.readPos.store(0);
+  buffer.hasAudio.store(false);
+}
+
+void SessionRecorder::startRecording(int numVoices, float sampleRate) {
+  if (recording_.load()) {
+    return;  // Already recording
+  }
+
+  numVoices_ = numVoices;
+  sampleRate_ = sampleRate;
+  sessionTimestamp_ = generateTimestamp();
+
+  std::cout << "Starting session recording: " << sessionTimestamp_ << std::endl;
+
+  // Initialize main mix buffer (stereo)
+  initializeBuffer(mainMixBuffer_, 2);
+  std::string mainFilename = generateFilename("all");
+  mainMixBuffer_.file = std::make_unique<SndfileHandle>(
+      mainFilename, SFM_WRITE, SF_FORMAT_WAV | SF_FORMAT_PCM_16, 2,
+      static_cast<int>(sampleRate_));
+
+  if (mainMixBuffer_.file->error()) {
+    std::cerr << "Error creating main mix file: "
+              << mainMixBuffer_.file->strError() << std::endl;
+    return;
+  }
+
+  // Initialize voice buffers (stereo)
+  voiceBuffers_.resize(numVoices_);
+  for (int i = 0; i < numVoices_; i++) {
+    initializeBuffer(voiceBuffers_[i], 2);
+    std::string voiceFilename = generateFilename(std::to_string(i));
+    voiceBuffers_[i].file = std::make_unique<SndfileHandle>(
+        voiceFilename, SFM_WRITE, SF_FORMAT_WAV | SF_FORMAT_PCM_16, 2,
+        static_cast<int>(sampleRate_));
+
+    if (voiceBuffers_[i].file->error()) {
+      std::cerr << "Error creating voice " << i
+                << " file: " << voiceBuffers_[i].file->strError() << std::endl;
+    }
+  }
+
+  recording_.store(true);
+  writerRunning_.store(true);
+
+  // Start writer thread
+  writerThread_ =
+      std::make_unique<std::thread>(&SessionRecorder::writerThreadFunc, this);
+
+  std::cout << "Session recording started" << std::endl;
+}
+
+void SessionRecorder::stopRecording() {
+  if (!recording_.load()) {
+    return;
+  }
+
+  std::cout << "Stopping session recording..." << std::endl;
+
+  recording_.store(false);
+  writerRunning_.store(false);
+
+  // Wait for writer thread to finish
+  if (writerThread_ && writerThread_->joinable()) {
+    writerThread_->join();
+  }
+
+  // Flush remaining data and close files
+  writeAvailableData(mainMixBuffer_);
+  mainMixBuffer_.file.reset();
+
+  for (auto& voiceBuffer : voiceBuffers_) {
+    if (voiceBuffer.hasAudio.load()) {
+      writeAvailableData(voiceBuffer);
+    }
+    voiceBuffer.file.reset();
+  }
+
+  // Delete files for voices that had no audio
+  for (int i = 0; i < numVoices_; i++) {
+    if (!voiceBuffers_[i].hasAudio.load()) {
+      std::string filename = generateFilename(std::to_string(i));
+      std::filesystem::remove(filename);
+    }
+  }
+
+  voiceBuffers_.clear();
+
+  std::cout << "Session recording stopped" << std::endl;
+}
+
+void SessionRecorder::captureMainMix(const sample_t* left, const sample_t* right,
+                                     size_t numFrames) {
+  if (!recording_.load()) {
+    return;
+  }
+
+  size_t writePos = mainMixBuffer_.writePos.load(std::memory_order_relaxed);
+
+  for (size_t i = 0; i < numFrames; i++) {
+    size_t idx = (writePos * 2) % mainMixBuffer_.buffer.size();
+    mainMixBuffer_.buffer[idx] = static_cast<float>(left[i]);
+    mainMixBuffer_.buffer[idx + 1] = static_cast<float>(right[i]);
+    writePos++;
+  }
+
+  mainMixBuffer_.writePos.store(writePos, std::memory_order_release);
+  mainMixBuffer_.hasAudio.store(true);
+}
+
+void SessionRecorder::captureVoice(int voice, const sample_t* left,
+                                   const sample_t* right, size_t numFrames) {
+  if (!recording_.load() || voice < 0 || voice >= numVoices_) {
+    return;
+  }
+
+  auto& voiceBuffer = voiceBuffers_[voice];
+  size_t writePos = voiceBuffer.writePos.load(std::memory_order_relaxed);
+
+  // Check if there's actual audio (not just silence)
+  bool hasSignal = false;
+  for (size_t i = 0; i < numFrames; i++) {
+    float leftSample = static_cast<float>(left[i]);
+    float rightSample = static_cast<float>(right[i]);
+    if (std::abs(leftSample) > 0.0001f || std::abs(rightSample) > 0.0001f) {
+      hasSignal = true;
+    }
+    size_t idx = (writePos * 2) % voiceBuffer.buffer.size();
+    voiceBuffer.buffer[idx] = leftSample;
+    voiceBuffer.buffer[idx + 1] = rightSample;
+    writePos++;
+  }
+
+  voiceBuffer.writePos.store(writePos, std::memory_order_release);
+  if (hasSignal) {
+    voiceBuffer.hasAudio.store(true);
+  }
+}
+
+size_t SessionRecorder::writeAvailableData(VoiceBuffer& buffer) {
+  size_t writePos = buffer.writePos.load(std::memory_order_acquire);
+  size_t readPos = buffer.readPos.load(std::memory_order_relaxed);
+
+  if (writePos == readPos) {
+    return 0;  // No data to write
+  }
+
+  size_t available = writePos - readPos;
+  size_t bufferSize = buffer.buffer.size();
+  size_t channels = buffer.file->channels();
+
+  // Write in chunks to handle ring buffer wraparound
+  size_t totalWritten = 0;
+  while (available > 0) {
+    size_t startIdx = (readPos * channels) % bufferSize;
+    size_t endIdx = bufferSize;
+    size_t chunkFrames = std::min(available, (endIdx - startIdx) / channels);
+
+    sf_count_t written =
+        buffer.file->write(&buffer.buffer[startIdx], chunkFrames * channels);
+
+    if (written <= 0) {
+      std::cerr << "Error writing to file: " << buffer.file->strError()
+                << std::endl;
+      break;
+    }
+
+    size_t framesWritten = static_cast<size_t>(written) / channels;
+    readPos += framesWritten;
+    available -= framesWritten;
+    totalWritten += framesWritten;
+  }
+
+  buffer.readPos.store(readPos, std::memory_order_release);
+
+  if (totalWritten > 0) {
+    std::cout << "Wrote " << totalWritten << " frames" << std::endl;
+  }
+
+  return totalWritten;
+}
+
+void SessionRecorder::writerThreadFunc() {
+  std::cout << "Writer thread started" << std::endl;
+
+  while (writerRunning_.load()) {
+    // Write main mix
+    writeAvailableData(mainMixBuffer_);
+
+    // Write voices
+    for (auto& voiceBuffer : voiceBuffers_) {
+      if (voiceBuffer.hasAudio.load()) {
+        writeAvailableData(voiceBuffer);
+      }
+    }
+
+    // Sleep to avoid busy-waiting
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  std::cout << "Writer thread stopped" << std::endl;
+}

clients/oooooooo/src/SessionRecorder.h

@@ -0,0 +1,86 @@
+#ifndef SESSION_RECORDER_H
+#define SESSION_RECORDER_H
+
+#include <sndfile.hh>
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+// Use double as sample type to match softcut
+using sample_t = double;
+
+class SessionRecorder {
+ public:
+  SessionRecorder();
+  ~SessionRecorder();
+
+  // Start recording with timestamp-based filenames
+  void startRecording(int numVoices, float sampleRate);
+
+  // Stop recording and close files
+  void stopRecording();
+
+  // Check if currently recording
+  bool isRecording() const { return recording_.load(); }
+
+  // Called from audio thread - captures audio frames
+  void captureMainMix(const sample_t* left, const sample_t* right,
+                      size_t numFrames);
+  void captureVoice(int voice, const sample_t* left, const sample_t* right,
+                    size_t numFrames);
+
+ private:
+  std::atomic<bool> recording_;
+  std::string sessionTimestamp_;
+  int numVoices_;
+  float sampleRate_;
+
+  // Ring buffers for thread-safe audio capture
+  static const size_t RING_BUFFER_SIZE = 48000 * 10;  // 10 seconds at 48kHz
+  struct VoiceBuffer {
+    std::vector<float> buffer;
+    std::atomic<size_t> writePos;
+    std::atomic<size_t> readPos;
+    std::unique_ptr<SndfileHandle> file;
+    std::atomic<bool> hasAudio;
+
+    VoiceBuffer() : writePos(0), readPos(0), hasAudio(false) {}
+    VoiceBuffer(VoiceBuffer&& other) noexcept
+        : buffer(std::move(other.buffer)),
+          writePos(other.writePos.load()),
+          readPos(other.readPos.load()),
+          file(std::move(other.file)),
+          hasAudio(other.hasAudio.load()) {}
+    VoiceBuffer& operator=(VoiceBuffer&& other) noexcept {
+      if (this != &other) {
+        buffer = std::move(other.buffer);
+        writePos.store(other.writePos.load());
+        readPos.store(other.readPos.load());
+        file = std::move(other.file);
+        hasAudio.store(other.hasAudio.load());
+      }
+      return *this;
+    }
+    // Delete copy constructor and assignment
+    VoiceBuffer(const VoiceBuffer&) = delete;
+    VoiceBuffer& operator=(const VoiceBuffer&) = delete;
+  };
+
+  VoiceBuffer mainMixBuffer_;
+  std::vector<VoiceBuffer> voiceBuffers_;
+
+  // Worker thread for writing to disk
+  std::unique_ptr<std::thread> writerThread_;
+  std::atomic<bool> writerRunning_;
+
+  void writerThreadFunc();
+  std::string generateTimestamp();
+  std::string generateFilename(const std::string& voiceId);
+  void initializeBuffer(VoiceBuffer& buffer, int channels);
+  size_t writeAvailableData(VoiceBuffer& buffer);
+};
+
+#endif  // SESSION_RECORDER_H