Merge branch 'main' into test-recorder-coverage

Author: sudip-mondal-2002

.github/workflows/label-pr-from-issues.yml

@@ -0,0 +1,96 @@
+---
+name: Label PR from Linked Issues
+
+# Trigger whenever a PR is opened, reopened, or its body is edited.
+on:
+  pull_request:
+    types: [opened, reopened, edited]
+
+# Minimal permissions: read issues to get their labels, write PR labels.
+permissions:
+  contents: read
+  issues: read
+  pull-requests: write
+
+jobs:
+  label-pr:
+    name: Copy labels from linked issues to PR
+    runs-on: ubuntu-latest
+    steps:
+      - name: Apply issue labels to PR
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const body = context.payload.pull_request.body || '';
+            const prNumber = context.payload.pull_request.number;
+            const { owner, repo } = context.repo;
+
+            // Collect issue numbers from
+            // "Fixes/Closes/Resolves #NNN" (case-insensitive).
+            const pattern = /(?:fixes|closes|resolves)\s+#(\d+)/gi;
+            const issueNumbers = [];
+            let match;
+            while ((match = pattern.exec(body)) !== null) {
+              issueNumbers.push(parseInt(match[1], 10));
+            }
+
+            if (issueNumbers.length === 0) {
+              core.info('No linked issues found in PR body — nothing to do.');
+              return;
+            }
+
+            core.info(`Linked issues: ${issueNumbers.join(', ')}`);
+
+            // Fetch labels from every referenced issue;
+            // ignore missing/invalid ones.
+            const labelSet = new Set();
+            for (const issueNumber of issueNumbers) {
+              try {
+                const { data: issue } = await github.rest.issues.get({
+                  owner,
+                  repo,
+                  issue_number: issueNumber,
+                });
+                for (const label of issue.labels) {
+                  labelSet.add(typeof label === 'string' ? label : label.name);
+                }
+              } catch (err) {
+                // Non-existent or inaccessible issue — skip gracefully.
+                core.warning(
+                  `Could not fetch issue #${issueNumber}: ${err.message}`
+                );
+              }
+            }
+
+            if (labelSet.size === 0) {
+              core.info(
+                'Referenced issues carry no labels — nothing to apply.'
+              );
+              return;
+            }
+
+            // Determine which labels the PR does not already have.
+            const { data: prData } = await github.rest.pulls.get({
+              owner,
+              repo,
+              pull_number: prNumber,
+            });
+            const existingLabels = new Set(
+              prData.labels.map((l) => (typeof l === 'string' ? l : l.name))
+            );
+            const toAdd = [...labelSet].filter((l) => !existingLabels.has(l));
+
+            if (toAdd.length === 0) {
+              core.info('PR already has all issue labels — nothing to add.');
+              return;
+            }
+
+            core.info(
+              `Adding labels to PR #${prNumber}: ${toAdd.join(', ')}`
+            );
+            await github.rest.issues.addLabels({
+              owner,
+              repo,
+              issue_number: prNumber,
+              labels: toAdd,
+            });

src/audio/effects/pitch_shifter.cpp

@@ -14,6 +14,12 @@ static constexpr int P_MIX   = 2;
 // Grain window size in seconds (~23 ms at 48kHz = 1024 samples)
 static constexpr float GRAIN_WINDOW_SEC = 0.023f;
 
+static float wrap_phase(float phase, int buf_size) {
+    phase = std::fmod(phase, static_cast<float>(buf_size));
+    if (phase < 0.0f) phase += static_cast<float>(buf_size);
+    return phase;
+}
+
 PitchShifter::PitchShifter() {
     params_ = {
         {"Shift", 0.0f, -12.0f, 12.0f, 0.0f, "st",
@@ -35,9 +41,7 @@ void PitchShifter::set_sample_rate(int sample_rate) {
 }
 
 float PitchShifter::read_linear(float phase) const {
-    // Wrap phase into [0, buf_size_)
-    phase = std::fmod(phase, static_cast<float>(buf_size_));
-    if (phase < 0.0f) phase += buf_size_;
+    phase = wrap_phase(phase, buf_size_);
 
     int pos0 = static_cast<int>(phase);
     int pos1 = (pos0 + 1) % buf_size_;
@@ -77,11 +81,9 @@ void PitchShifter::process(float* buffer, int num_samples) {
         read_phase_a_ += drift;
         read_phase_b_ += drift;
 
-        // Wrap phases into [0, buf_size_)
-        while (read_phase_a_ < 0.0f) read_phase_a_ += buf_size_;
-        while (read_phase_a_ >= buf_size_) read_phase_a_ -= buf_size_;
-        while (read_phase_b_ < 0.0f) read_phase_b_ += buf_size_;
-        while (read_phase_b_ >= buf_size_) read_phase_b_ -= buf_size_;
+        // Wrap phases into [0, buf_size_) in constant time.
+        read_phase_a_ = wrap_phase(read_phase_a_, buf_size_);
+        read_phase_b_ = wrap_phase(read_phase_b_, buf_size_);
 
         // Compute absolute read positions in the buffer
         float pos_a = static_cast<float>(write_pos_) - read_phase_a_;

tests/test_audio_engine.cpp

@@ -367,3 +367,132 @@ TEST(AudioEngineProcess_FullCoverageSweep) {
     engine.toggle_metronome();
     engine.process_audio(in.data(), out.data(), 64);
 }
+TEST(audio_engine_commit_graph_changes_stability) {
+  AudioEngine engine;
+
+  for (int i = 0; i < 50; ++i) {
+    engine.commit_graph_changes();
+  }
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_multiple_commit_graph_changes) {
+  AudioEngine engine;
+
+  engine.commit_graph_changes();
+  engine.commit_graph_changes();
+  engine.commit_graph_changes();
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_set_buffer_size_clamps_values) {
+  AudioEngine engine;
+
+  engine.set_buffer_size(-1);
+  ASSERT_TRUE(engine.get_buffer_size() > 0);
+
+  engine.set_buffer_size(999999);
+  ASSERT_TRUE(engine.get_buffer_size() <= 8192);
+}
+TEST(audio_engine_set_sample_rate_updates_state) {
+  AudioEngine engine;
+
+  engine.set_sample_rate(44100);
+  ASSERT_TRUE(engine.get_sample_rate() == 44100);
+
+  engine.set_sample_rate(48000);
+  ASSERT_TRUE(engine.get_sample_rate() == 48000);
+
+  engine.set_sample_rate(96000);
+  ASSERT_TRUE(engine.get_sample_rate() == 96000);
+}
+TEST(audio_engine_commit_graph_changes_with_empty_graph) {
+  AudioEngine engine;
+
+  engine.commit_graph_changes();
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_repeated_graph_commits) {
+  AudioEngine engine;
+
+  for (int i = 0; i < 100; ++i) {
+    engine.commit_graph_changes();
+  }
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_graph_commit_after_node_removal) {
+  AudioEngine engine;
+
+  auto& graph = engine.graph();
+
+  int n1 =
+      graph.add_node("A", NodeRoutingType::StandardEffect);
+
+  int n2 =
+      graph.add_node("B", NodeRoutingType::StandardEffect);
+
+  auto nodes = graph.get_nodes();
+
+  graph.add_link(nodes[0].output_pin_ids[0],
+                 nodes[1].input_pin_ids[0]);
+
+  ASSERT_TRUE(graph.remove_node(n2));
+
+  engine.commit_graph_changes();
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_serialize_deserialize_roundtrip) {
+  AudioEngine engine;
+
+  auto serialized = engine.serialize();
+
+  AudioEngine loaded;
+
+  loaded.deserialize(serialized);
+
+  auto reserialized = loaded.serialize();
+
+  ASSERT_FALSE(serialized.empty());
+  ASSERT_FALSE(reserialized.empty());
+
+  ASSERT_TRUE(reserialized.contains("effects"));
+}
+TEST(audio_engine_multiple_sample_rate_changes) {
+  AudioEngine engine;
+
+  std::vector<int> rates = {
+      22050,
+      44100,
+      48000,
+      88200,
+      96000
+  };
+
+  for (int rate : rates) {
+    engine.set_sample_rate(rate);
+  }
+
+  ASSERT_TRUE(true);
+}
+TEST(audio_engine_multiple_buffer_size_changes) {
+  AudioEngine engine;
+
+  std::vector<int> sizes = {
+      16,
+      32,
+      64,
+      128,
+      256,
+      512,
+      1024
+  };
+
+  for (int size : sizes) {
+    engine.set_buffer_size(size);
+  }
+
+  ASSERT_TRUE(true);
+}