native_audio 0.3.0 → 0.5.0

data/ext/audio/delay_node.c

@@ -0,0 +1,185 @@
+// ============================================================================
+// delay_node.c - Multi-tap delay node implementation
+// ============================================================================
+
+#include <stdlib.h>
+#include <string.h>
+#include "delay_node.h"
+
+// ============================================================================
+// DSP Callback
+// ============================================================================
+
+static void multi_tap_delay_process(ma_node *pNode, const float **ppFramesIn,
+                                     ma_uint32 *pFrameCountIn, float **ppFramesOut,
+                                     ma_uint32 *pFrameCountOut)
+{
+    multi_tap_delay_node *node = (multi_tap_delay_node *)pNode;
+    const float *pFramesIn = ppFramesIn[0];
+    float *pFramesOut = ppFramesOut[0];
+    ma_uint32 frameCount = *pFrameCountOut;
+    ma_uint32 numChannels = node->channels;
+
+    for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame++) {
+        for (ma_uint32 iChannel = 0; iChannel < numChannels; iChannel++) {
+            ma_uint32 sampleIndex = iFrame * numChannels + iChannel;
+            float inputSample = pFramesIn[sampleIndex];
+
+            // Write to circular buffer
+            ma_uint32 writeIndex = (node->write_pos * numChannels) + iChannel;
+            node->buffer[writeIndex] = inputSample;
+
+            // Start with dry signal
+            float outputSample = inputSample;
+
+            // Mix in all active taps
+            for (ma_uint32 iTap = 0; iTap < MAX_TAPS_PER_CHANNEL; iTap++) {
+                if (node->taps[iTap].active) {
+                    ma_uint32 delayFrames = node->taps[iTap].delay_frames;
+                    if (delayFrames > 0 && delayFrames <= node->buffer_size) {
+                        ma_uint32 readPos = (node->write_pos + node->buffer_size - delayFrames) % node->buffer_size;
+                        ma_uint32 readIndex = (readPos * numChannels) + iChannel;
+                        outputSample += node->buffer[readIndex] * node->taps[iTap].volume;
+                    }
+                }
+            }
+
+            pFramesOut[sampleIndex] = outputSample;
+        }
+
+        // Advance write position
+        node->write_pos = (node->write_pos + 1) % node->buffer_size;
+    }
+}
+
+static ma_node_vtable g_multi_tap_delay_vtable = {
+    multi_tap_delay_process,
+    NULL,  // onGetRequiredInputFrameCount
+    1,     // inputBusCount
+    1,     // outputBusCount
+    0      // flags
+};
+
+// ============================================================================
+// Lifecycle
+// ============================================================================
+
+ma_result multi_tap_delay_init(multi_tap_delay_node *pNode, ma_node_graph *pNodeGraph,
+                                ma_uint32 sampleRate, ma_uint32 numChannels)
+{
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    memset(pNode, 0, sizeof(*pNode));
+
+    pNode->sample_rate = sampleRate;
+    pNode->channels = numChannels;
+    pNode->buffer_size = (ma_uint32)(sampleRate * MAX_DELAY_SECONDS);
+    pNode->write_pos = 0;
+    pNode->tap_count = 0;
+
+    // Allocate circular buffer (frames * channels)
+    pNode->buffer = (float *)calloc(pNode->buffer_size * numChannels, sizeof(float));
+    if (pNode->buffer == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    // Initialize all taps as inactive
+    for (int i = 0; i < MAX_TAPS_PER_CHANNEL; i++) {
+        pNode->taps[i].active = MA_FALSE;
+        pNode->taps[i].delay_frames = 0;
+        pNode->taps[i].volume = 0.0f;
+    }
+
+    // Set up node configuration
+    ma_uint32 channelsArray[1] = { numChannels };
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable = &g_multi_tap_delay_vtable;
+    nodeConfig.pInputChannels = channelsArray;
+    nodeConfig.pOutputChannels = channelsArray;
+
+    return ma_node_init(pNodeGraph, &nodeConfig, NULL, &pNode->base);
+}
+
+void multi_tap_delay_uninit(multi_tap_delay_node *pNode)
+{
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(&pNode->base, NULL);
+
+    if (pNode->buffer != NULL) {
+        free(pNode->buffer);
+        pNode->buffer = NULL;
+    }
+}
+
+// ============================================================================
+// Tap Management
+// ============================================================================
+
+int multi_tap_delay_add_tap(multi_tap_delay_node *pNode, float time_ms, float volume)
+{
+    if (pNode == NULL) {
+        return -1;
+    }
+
+    // Find first inactive tap slot
+    for (int i = 0; i < MAX_TAPS_PER_CHANNEL; i++) {
+        if (!pNode->taps[i].active) {
+            ma_uint32 delayFrames = (ma_uint32)((time_ms / 1000.0f) * pNode->sample_rate);
+            if (delayFrames > pNode->buffer_size) {
+                delayFrames = pNode->buffer_size;
+            }
+            pNode->taps[i].delay_frames = delayFrames;
+            pNode->taps[i].volume = volume;
+            pNode->taps[i].active = MA_TRUE;
+            pNode->tap_count++;
+            return i;
+        }
+    }
+
+    return -1;  // No slots available
+}
+
+void multi_tap_delay_remove_tap(multi_tap_delay_node *pNode, int tap_id)
+{
+    if (pNode == NULL || tap_id < 0 || tap_id >= MAX_TAPS_PER_CHANNEL) {
+        return;
+    }
+
+    if (pNode->taps[tap_id].active) {
+        pNode->taps[tap_id].active = MA_FALSE;
+        pNode->taps[tap_id].delay_frames = 0;
+        pNode->taps[tap_id].volume = 0.0f;
+        pNode->tap_count--;
+    }
+}
+
+void multi_tap_delay_set_volume(multi_tap_delay_node *pNode, int tap_id, float volume)
+{
+    if (pNode == NULL || tap_id < 0 || tap_id >= MAX_TAPS_PER_CHANNEL) {
+        return;
+    }
+
+    if (pNode->taps[tap_id].active) {
+        pNode->taps[tap_id].volume = volume;
+    }
+}
+
+void multi_tap_delay_set_time(multi_tap_delay_node *pNode, int tap_id, float time_ms)
+{
+    if (pNode == NULL || tap_id < 0 || tap_id >= MAX_TAPS_PER_CHANNEL) {
+        return;
+    }
+
+    if (pNode->taps[tap_id].active) {
+        ma_uint32 delayFrames = (ma_uint32)((time_ms / 1000.0f) * pNode->sample_rate);
+        if (delayFrames > pNode->buffer_size) {
+            delayFrames = pNode->buffer_size;
+        }
+        pNode->taps[tap_id].delay_frames = delayFrames;
+    }
+}

data/ext/audio/delay_node.h

@@ -0,0 +1,51 @@
+// ============================================================================
+// delay_node.h - Multi-tap delay node for native_audio
+// ============================================================================
+
+#ifndef DELAY_NODE_H
+#define DELAY_NODE_H
+
+#include "miniaudio.h"
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+#define MAX_TAPS_PER_CHANNEL 16
+#define MAX_DELAY_SECONDS 2.0f
+
+// ============================================================================
+// Types
+// ============================================================================
+
+typedef struct {
+    ma_uint32 delay_frames;
+    float volume;
+    ma_bool32 active;
+} delay_tap;
+
+typedef struct {
+    ma_node_base base;
+    float *buffer;
+    ma_uint32 buffer_size;      // Size in frames
+    ma_uint32 write_pos;
+    ma_uint32 channels;         // Audio channels (stereo = 2)
+    delay_tap taps[MAX_TAPS_PER_CHANNEL];
+    ma_uint32 tap_count;
+    ma_uint32 sample_rate;
+} multi_tap_delay_node;
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+ma_result multi_tap_delay_init(multi_tap_delay_node *pNode, ma_node_graph *pNodeGraph,
+                                ma_uint32 sampleRate, ma_uint32 numChannels);
+void multi_tap_delay_uninit(multi_tap_delay_node *pNode);
+
+int multi_tap_delay_add_tap(multi_tap_delay_node *pNode, float time_ms, float volume);
+void multi_tap_delay_remove_tap(multi_tap_delay_node *pNode, int tap_id);
+void multi_tap_delay_set_volume(multi_tap_delay_node *pNode, int tap_id, float volume);
+void multi_tap_delay_set_time(multi_tap_delay_node *pNode, int tap_id, float time_ms);
+
+#endif // DELAY_NODE_H

data/ext/audio/extconf.rb

@@ -1,115 +1,17 @@
 require 'mkmf'
 
-# Get the root directory of the gem (two levels up from ext/audio/)
-ROOT_DIR = File.expand_path('../..', __dir__)
-ASSETS_DIR = File.join(ROOT_DIR, 'assets')
-
-# Detect platform
-PLATFORM = case RUBY_PLATFORM
-when /darwin/ then :macos
-when /linux/  then :linux
-when /mingw/  then :windows
-end
-
-def add_flags(type, flags)
-  case type
-  when :c  then $CFLAGS << " #{flags} "
-  when :ld then $LDFLAGS << " #{flags} "
-  end
+# miniaudio linking requirements per platform:
+# - macOS:   CoreFoundation, CoreAudio, AudioToolbox frameworks
+# - Linux:   pthread, dl, m (math)
+# - Windows: uses native APIs via runtime linking, no extra libs needed
+
+case RUBY_PLATFORM
+when /darwin/
+  $LDFLAGS << " -framework CoreFoundation -framework CoreAudio -framework AudioToolbox "
+when /linux/
+  $LDFLAGS << " -ldl -lpthread -lm "
+when /mingw|mswin/
+  # Windows uses runtime linking to native audio APIs
 end
 
-def check_sdl
-  return if have_library('SDL2') && have_library('SDL2_mixer')
-
-  msg = ["SDL2 libraries not found."]
-
-  if PLATFORM == :linux
-    if system('which apt >/dev/null 2>&1')
-      msg << "Install with: sudo apt install libsdl2-dev libsdl2-mixer-dev"
-    elsif system('which dnf >/dev/null 2>&1') || system('which yum >/dev/null 2>&1')
-      msg << "Install with: sudo dnf install SDL2-devel SDL2_mixer-devel"
-    elsif system('which pacman >/dev/null 2>&1')
-      msg << "Install with: sudo pacman -S sdl2 sdl2_mixer"
-    elsif system('which zypper >/dev/null 2>&1')
-      msg << "Install with: sudo zypper install libSDL2-devel libSDL2_mixer-devel"
-    end
-  end
-
-  abort msg.join("\n")
-end
-
-def set_linux_flags
-  check_sdl
-  add_flags(:ld, "-lSDL2 -lSDL2_mixer -lm")
-end
-
-def use_dev_libs
-  case PLATFORM
-  when :macos
-    add_flags(:c, `sdl2-config --cflags`)
-    add_flags(:c, '-I/opt/homebrew/include')
-    add_flags(:ld, `sdl2-config --libs`)
-    add_flags(:ld, '-lSDL2 -lSDL2_mixer')
-  when :windows
-    add_flags(:ld, '-lSDL2 -lSDL2_mixer')
-  when :linux
-    set_linux_flags
-  end
-end
-
-def use_bundled_libs
-  add_flags(:c, '-std=c11')
-
-  case PLATFORM
-  when :macos
-    add_flags(:c, "-I#{ASSETS_DIR}/include")
-    ldir = "#{ASSETS_DIR}/macos/universal/lib"
-
-    add_flags(:ld, "#{ldir}/libSDL2.a #{ldir}/libSDL2_mixer.a")
-    add_flags(:ld, "#{ldir}/libmpg123.a #{ldir}/libogg.a #{ldir}/libFLAC.a")
-    add_flags(:ld, "#{ldir}/libvorbis.a #{ldir}/libvorbisfile.a #{ldir}/libmodplug.a")
-    add_flags(:ld, "-lz -liconv -lstdc++")
-
-    frameworks = %w[Cocoa Carbon GameController ForceFeedback
-                    AudioToolbox CoreAudio IOKit CoreHaptics CoreVideo Metal]
-    add_flags(:ld, frameworks.map { |f| "-Wl,-framework,#{f}" }.join(' '))
-
-  when :windows
-    add_flags(:c, "-I#{ASSETS_DIR}/include")
-
-    ldir = if RUBY_PLATFORM =~ /ucrt/
-      "#{ASSETS_DIR}/windows/mingw-w64-ucrt-x86_64/lib"
-    else
-      "#{ASSETS_DIR}/windows/mingw-w64-x86_64/lib"
-    end
-
-    add_flags(:ld, "-Wl,--start-group")
-    add_flags(:ld, "#{ldir}/libSDL2.a #{ldir}/libSDL2_mixer.a")
-    add_flags(:ld, "#{ldir}/libmpg123.a #{ldir}/libFLAC.a #{ldir}/libvorbis.a")
-    add_flags(:ld, "#{ldir}/libvorbisfile.a #{ldir}/libogg.a #{ldir}/libmodplug.a")
-    add_flags(:ld, "#{ldir}/libopus.a #{ldir}/libopusfile.a #{ldir}/libsndfile.a")
-    add_flags(:ld, "#{ldir}/libstdc++.a #{ldir}/libz.a")
-    add_flags(:ld, '-lmingw32 -lole32 -loleaut32 -limm32')
-    add_flags(:ld, '-lversion -lwinmm -lrpcrt4 -mwindows -lsetupapi -ldwrite')
-    add_flags(:ld, "-Wl,--end-group")
-
-  when :linux
-    set_linux_flags
-
-  else
-    use_dev_libs
-  end
-end
-
-# Main configuration
-if ARGV.include?('dev')
-  use_dev_libs
-else
-  use_bundled_libs
-end
-
-$CFLAGS.gsub!(/\n/, ' ')
-$LDFLAGS.gsub!(/\n/, ' ')
-
-create_header
 create_makefile('audio')