SuperSonic - update, and follow Clockwork's rename of scope streams to taps

Author: samaaron

app/api/include/api/audio/audio_processor.h

@@ -62,7 +62,7 @@ class AudioProcessor
     // (the full mix); slots 1..N are fed by fx_scope_out / ScopeOut2 taps.
     // Invalid reader if the shm client is not connected or the index is out
     // of range. Like the audio tap reader, it keeps its mapping alive.
-    shm_scope_stream_reader GetScopeReader(unsigned int index);
+    shm_tap_stream_reader GetScopeReader(unsigned int index);
 
     // Seqlock snapshot of the engine sample clock (sample position ↔ DAC NTP);
     // invalid when disconnected or before the engine's first publish.
@@ -96,7 +96,7 @@ class AudioProcessor
     void AttachLocked();
 
     std::unique_ptr<shm_segment_client> m_shmClient;
-    shm_scope_stream_reader m_shmReader;
+    shm_tap_stream_reader m_shmReader;
 
     // Rate-limits Run()'s reattach attempts while unattached.
     std::chrono::steady_clock::time_point m_lastAttachAttempt{};

app/api/include/api/sonicpi_api.h

@@ -691,7 +691,7 @@ class SonicPiAPI
     // live-loop scopes, cards, the Examples jukebox). Invalid reader if the
     // audio processor hasn't connected. Combine with AudioProcessor_GetSampleClock
     // to window the stream on what the listener is currently hearing.
-    virtual shm_scope_stream_reader AudioProcessor_GetScopeReader(unsigned int scope_num);
+    virtual shm_tap_stream_reader AudioProcessor_GetScopeReader(unsigned int scope_num);
 
     // Seqlock-consistent snapshot of the engine's sample clock (sample
     // position ↔ wall-clock DAC time). `valid` is false until the engine has

app/api/src/audio/audio_processor.cpp

@@ -283,11 +283,11 @@ shm_audio_buffer_reader AudioProcessor::GetAudioBufferReader(unsigned int slot)
     return m_shmClient->get_audio_buffer_reader(slot);
 }
 
-shm_scope_stream_reader AudioProcessor::GetScopeReader(unsigned int index)
+shm_tap_stream_reader AudioProcessor::GetScopeReader(unsigned int index)
 {
     std::lock_guard<std::mutex> lock(m_mutex);
-    if (!m_shmClient) return shm_scope_stream_reader();
-    return m_shmClient->get_scope_stream_reader(index);
+    if (!m_shmClient) return shm_tap_stream_reader();
+    return m_shmClient->get_tap_stream_reader(index);
 }
 
 sample_clock_view AudioProcessor::GetSampleClock()
@@ -364,7 +364,7 @@ void AudioProcessor::AttachLocked()
         if (!detail_shm_segment::shm_handle_valid(handle))
             throw std::runtime_error("shm attach: " + err);
         m_shmClient.reset(new shm_segment_client(handle));
-        m_shmReader = m_shmClient->get_scope_stream_reader(0);
+        m_shmReader = m_shmClient->get_tap_stream_reader(0);
         m_lastAttachError.clear();   // a later recurrence is worth reporting again
     }
     catch (const std::exception& e)
@@ -391,7 +391,7 @@ void AudioProcessor::AttachLocked()
             m_lastAttachError = what;
         }
         m_shmClient.reset();
-        m_shmReader = shm_scope_stream_reader();
+        m_shmReader = shm_tap_stream_reader();
     }
     m_lastEndCursor = 0;
     m_stalledTicks = 0;
@@ -495,7 +495,7 @@ void AudioProcessor::Run()
             m_lastEndCursor = endCursor;
             // Scratch sized for the max stride; copy_window reports the one
             // it used (a separate channels() read would race re-activation).
-            m_windowScratch.resize(static_cast<size_t>(FrameSamples) * SHM_SCOPE_STREAM_CHANNELS);
+            m_windowScratch.resize(static_cast<size_t>(FrameSamples) * SHM_TAP_STREAM_CHANNELS);
             uint32_t ch = 1;
             m_shmReader.copy_window(endCursor, FrameSamples, m_windowScratch.data(), &ch);
 

app/api/src/osc/osc_handler.cpp

@@ -597,8 +597,8 @@ void OscHandler::oscMessage(std::vector<char> buffer)
                 ok = arg.isOk();
                 t.id = id; t.slot = slot; t.sendChannel = send; t.returnChannel = ret;
                 t.gain = gain; t.mute = mute != 0;
-                if (slot >= 0 && slot < SHM_SCOPE_TRACK_SLOTS)
-                    t.scopeSlot = SHM_SCOPE_TRACK_SLOT_BASE + slot;
+                if (slot >= 0 && slot < SHM_TAP_TRACK_SLOTS)
+                    t.scopeSlot = SHM_TAP_TRACK_SLOT_BASE + slot;
                 for (int32_t k = 0; ok && k < nodeCount; ++k)
                 {
                     TrackNodeInfo n;

app/api/src/sonicpi_api.cpp

@@ -1149,13 +1149,13 @@ shm_audio_buffer_reader SonicPiAPI::AudioProcessor_GetAudioBufferReader(unsigned
     return shm_audio_buffer_reader();
 }
 
-shm_scope_stream_reader SonicPiAPI::AudioProcessor_GetScopeReader(unsigned int scope_num)
+shm_tap_stream_reader SonicPiAPI::AudioProcessor_GetScopeReader(unsigned int scope_num)
 {
     if (m_spAudioProcessor)
     {
         return m_spAudioProcessor->GetScopeReader(scope_num);
     }
-    return shm_scope_stream_reader();
+    return shm_tap_stream_reader();
 }
 
 sample_clock_view SonicPiAPI::AudioProcessor_GetSampleClock()

app/external/supersonic

@@ -20,7 +20,7 @@
 
 #include <memory>
 
-#include <shm_scope_stream.hpp>
+#include <shm_tap_stream.hpp>
 
 #include "model/sonicpitheme.h"
 #include "utils/scintilla_api.h"
@@ -73,11 +73,11 @@ struct Editor
 // A scope-stream slot, as the engine's shared memory holds one.
 struct Slot
 {
-    std::unique_ptr<shm_scope_stream> mem = std::make_unique<shm_scope_stream>();
+    std::unique_ptr<shm_tap_stream> mem = std::make_unique<shm_tap_stream>();
     Slot() { mem->state.store(0); }
-    void live() { shm_scope_stream_writer(mem.get()).activate(2); }
+    void live() { shm_tap_stream_writer(mem.get()).activate(2); }
     void release() { mem->state.store(0); }
-    shm_scope_stream_reader reader() const { return shm_scope_stream_reader(mem.get()); }
+    shm_tap_stream_reader reader() const { return shm_tap_stream_reader(mem.get()); }
 };
 
 const QString kCode = QStringLiteral("live_loop :t do\n  play 60\n  sleep 1\nend\n");
@@ -281,7 +281,7 @@ void writeLoudWave(Slot& s, int frames = 16384)
     for (int i = 0; i < frames; i++)
         l[(size_t)i] = r[(size_t)i] = ((i / 256) % 2) ? 0.9f : -0.9f;
     const float* chans[2] = { l.data(), r.data() };
-    shm_scope_stream_writer(s.mem.get()).write(chans, (uint32_t)frames, 0);
+    shm_tap_stream_writer(s.mem.get()).write(chans, (uint32_t)frames, 0);
 }
 
 QImage rendered(QWidget* w)

app/gui-tests/loopscope_lifecycle.test.cpp

@@ -346,7 +346,7 @@ void ScopeWindow::DrawLevels(const ProcessedAudio& audio, QPainter& painter, Sco
         {
             m_preLimLastEnd = end;
             const uint32_t frames = 1024;
-            m_grScratch.resize(size_t(frames) * SHM_SCOPE_STREAM_CHANNELS);
+            m_grScratch.resize(size_t(frames) * SHM_TAP_STREAM_CHANNELS);
             uint32_t chans = 1;
             const uint32_t got = m_preLimReader.copy_window(end, frames, m_grScratch.data(), &chans);
             float p = 0.0f;

app/gui/visualizer/scope_window.cpp

@@ -214,7 +214,7 @@ public slots :
     // reserved scope slot (see etc/synthdefs/designs/supercollider/mixer.scd).
     // How far that input pushes past the ceiling is what the limiter must
     // take off — drawn as the bar's tip crossing into the hot zone.
-    shm_scope_stream_reader m_preLimReader;
+    shm_tap_stream_reader m_preLimReader;
     uint64_t m_preLimLastEnd = 0;
     std::vector<float> m_grScratch;
     float m_grTargetDb = 0.0f;    // latest window's dB past the ceiling

app/gui/visualizer/scope_window.h

@@ -40,7 +40,7 @@ class ScopeSampler : public QWidget
     {
         m_api = api;
         m_reader = api ? api->AudioProcessor_GetScopeReader(scopeNum)
-                       : shm_scope_stream_reader();
+                       : shm_tap_stream_reader();
         m_lastEnd = 0;
         // Display frame rate only — the stream is lossless at any poll rate.
         if (!m_timer->isActive())
@@ -50,7 +50,7 @@ class ScopeSampler : public QWidget
     void stopSampling()
     {
         m_timer->stop();
-        m_reader = shm_scope_stream_reader();
+        m_reader = shm_tap_stream_reader();
     }
 
     // Frames of stream history the subclass renders per tick.
@@ -81,14 +81,14 @@ class ScopeSampler : public QWidget
         // it used (sizing from a separate channels() read would race a slot
         // re-activation).
         const unsigned int frames = windowFrames();
-        m_scratch.resize((size_t)frames * SHM_SCOPE_STREAM_CHANNELS);
+        m_scratch.resize((size_t)frames * SHM_TAP_STREAM_CHANNELS);
         uint32_t ch = 1;
         m_reader.copy_window(end, frames, m_scratch.data(), &ch);
         storeWindow(m_scratch.data(), frames, ch);
         update();
     }
 
-    shm_scope_stream_reader m_reader;
+    shm_tap_stream_reader m_reader;
     SonicPi::SonicPiAPI* m_api = nullptr;
     QTimer* m_timer = nullptr;
     uint64_t m_lastEnd = 0;