native_audio 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f5b017594ea0c5b0b94f2e3c36c057ccdd55275c133f5ffc77ef9dfca5a4b7c
-  data.tar.gz: a42b15d0bdf8fa4bfd6f673d3b0f638409653d061e640eb559f433bad2ae6f18
+  metadata.gz: a9a953a3fe6e4bd23e99278c28dbd273bc08268105382a4dae34854e3917aa64
+  data.tar.gz: af2a5c84a91fa2957984d4c36637bbe914f38fab7d26903406051eb2456dbc96
 SHA512:
-  metadata.gz: cb6eb51f84784da896c21258f32393014845d5dcf47109e0ddc83f972c43e3353431c0addb42a8b9c14fed5397f9a8aaf1ce372549e7a321961a715afa577ceb
-  data.tar.gz: 82fe331ea3a1adb7a6281afe2978c62f7b9fc37c9836ed7ededda965034237af0a7acd54ca313973bb12ed1b22127d504981c70391ce0377ccf51898da99399a
+  metadata.gz: '094beb2919f1a5e0b9e18ea7ac5e5776f5f5ed5eb213f9aac5c976ec3e74cb740ba73632f3bab2acb589afc4d2f12a1fe8485b3ddd59b5bc71d8d21fa758f357'
+  data.tar.gz: b0c335b765410df6cfbae2a730f921388e5761639f96b329113ef398527dd46f9067680a55e0fb7541cf801784158f07b744f07e9570251ea0485503b573c81f

data/README.md

@@ -1,6 +1,6 @@
 # What is native_audio?
 
-Native audio is a thin wrapper around miniaudio for simple audio playback from Ruby.
+Native audio is a thin wrapper around miniaudio for simple audio playback from Ruby, with built-in support for delay and reverb effects.
 
 ## Installation
 
@@ -25,26 +25,91 @@ clip = NativeAudio::Clip.new('path/to/sound.wav')
 clip.duration  # => seconds
 
 # Create an audio source to manage playback
-audio_source = NativeAudio::AudioSource.new(clip)
+source = NativeAudio::AudioSource.new(clip)
 
 # Play the clip
-audio_source.play
+source.play
 
 # Pause and resume
-audio_source.pause
-audio_source.resume
+source.pause
+source.resume
 
 # Set pitch (1.0 = normal, 0.5 = octave down, 2.0 = octave up)
-audio_source.set_pitch(1.5)
+source.set_pitch(1.5)
 
 # Set position relative to listener (angle: 0-360, distance: 0-255)
-audio_source.set_pos(90, 200)  # right side, mid distance
+source.set_pos(90, 200)  # right side, mid distance
 
 # Set volume (0-128)
-audio_source.set_volume(64)
+source.set_volume(64)
+
+# Loop playback
+source.set_looping(true)
 
 # Stop the clip
-audio_source.stop
+source.stop
+```
+
+## Effects
+
+Each audio source has a built-in effects chain:
+
+```
+sound ──▶ delay ──▶ reverb ──▶ output
+```
+
+### Delay Taps
+
+Add discrete echo effects with up to 16 taps per source:
+
+```ruby
+source.play
+
+# Add delay taps (returns a DelayTap object)
+tap1 = source.add_delay_tap(time_ms: 200, volume: 0.5)
+tap2 = source.add_delay_tap(time_ms: 400, volume: 0.3)
+
+# Modify taps at runtime
+tap1.volume = 0.4
+tap1.time_ms = 250
+
+# Remove a tap
+tap2.remove
+
+# Query active taps
+source.delay_taps  # => [tap1]
+```
+
+### Reverb
+
+Add room ambience with a Schroeder reverb:
+
+```ruby
+source.play
+
+# Enable reverb with custom settings
+source.set_reverb(
+  room_size: 0.7,  # 0.0 = small room, 1.0 = large hall
+  damping: 0.5,    # 0.0 = bright, 1.0 = muffled
+  wet: 0.4,        # reverb signal level
+  dry: 1.0         # original signal level
+)
+
+# Or just enable with defaults
+source.enable_reverb
+source.enable_reverb(false)  # disable
+```
+
+### Combining Effects
+
+Delay and reverb work together - each echo gets reverb applied:
+
+```ruby
+source.play
+
+# Slapback echo with room reverb
+source.add_delay_tap(time_ms: 150, volume: 0.4)
+source.set_reverb(room_size: 0.5, wet: 0.3, dry: 1.0)
 ```
 
 ## Environment Variables

data/ext/audio/audio.c

@@ -1,5 +1,5 @@
 // ============================================================================
-// native_audio - Ruby audio library using miniaudio
+// audio.c - Main entry point and Ruby bindings for native_audio
 // ============================================================================
 
 #include <ruby.h>
@@ -9,22 +9,22 @@
 
 #define MINIAUDIO_IMPLEMENTATION
 #include "miniaudio.h"
+#include "audio.h"
 
 // ============================================================================
-// Constants & Globals
+// Global Definitions
 // ============================================================================
 
-#define MAX_SOUNDS 1024
-#define MAX_CHANNELS 1024
-
-static ma_engine engine;
-static ma_context context;
-static ma_sound *sounds[MAX_SOUNDS];      // Loaded audio clips
-static ma_sound *channels[MAX_CHANNELS];  // Playback instances
-static int sound_count = 0;
-static int engine_initialized = 0;
-static int context_initialized = 0;
-static int using_null_backend = 0;
+ma_engine engine;
+ma_context context;
+ma_sound *sounds[MAX_SOUNDS];
+ma_sound *channels[MAX_CHANNELS];
+multi_tap_delay_node *delay_nodes[MAX_CHANNELS];
+reverb_node *reverb_nodes[MAX_CHANNELS];
+int sound_count = 0;
+int engine_initialized = 0;
+int context_initialized = 0;
+int using_null_backend = 0;
 
 // ============================================================================
 // Cleanup (called on Ruby exit)
@@ -38,7 +38,6 @@ static void cleanup_audio(VALUE unused)
         return;
     }
 
-    // Stop and clean up all channels
     for (int i = 0; i < MAX_CHANNELS; i++) {
         if (channels[i] != NULL) {
             ma_sound_stop(channels[i]);
@@ -46,9 +45,20 @@ static void cleanup_audio(VALUE unused)
             free(channels[i]);
             channels[i] = NULL;
         }
+
+        if (delay_nodes[i] != NULL) {
+            multi_tap_delay_uninit(delay_nodes[i]);
+            free(delay_nodes[i]);
+            delay_nodes[i] = NULL;
+        }
+
+        if (reverb_nodes[i] != NULL) {
+            reverb_uninit(reverb_nodes[i]);
+            free(reverb_nodes[i]);
+            reverb_nodes[i] = NULL;
+        }
     }
 
-    // Stop and clean up all loaded sounds
     for (int i = 0; i < sound_count; i++) {
         if (sounds[i] != NULL) {
             ma_sound_stop(sounds[i]);
@@ -58,8 +68,6 @@ static void cleanup_audio(VALUE unused)
         }
     }
 
-    // On Windows, ma_engine_uninit crashes with the null backend
-    // Since null backend has no real resources, we can skip cleanup
 #ifdef _WIN32
     if (using_null_backend) {
         engine_initialized = 0;
@@ -77,11 +85,55 @@ static void cleanup_audio(VALUE unused)
     }
 }
 
+// ============================================================================
+// Engine Initialization
+// ============================================================================
+
+VALUE audio_init(VALUE self)
+{
+    if (engine_initialized) {
+        return Qnil;
+    }
+
+    const char *driver = getenv("NATIVE_AUDIO_DRIVER");
+    int use_null = (driver != NULL && strcmp(driver, "null") == 0);
+
+    ma_engine_config config = ma_engine_config_init();
+    config.listenerCount = 1;
+
+    if (use_null) {
+        ma_backend backends[] = { ma_backend_null };
+        ma_result ctx_result = ma_context_init(backends, 1, NULL, &context);
+        if (ctx_result != MA_SUCCESS) {
+            rb_raise(rb_eRuntimeError, "Failed to initialize null audio context");
+            return Qnil;
+        }
+        context_initialized = 1;
+        using_null_backend = 1;
+        config.pContext = &context;
+    }
+
+    ma_result result = ma_engine_init(&config, &engine);
+
+    if (result != MA_SUCCESS) {
+        if (context_initialized) {
+            ma_context_uninit(&context);
+            context_initialized = 0;
+        }
+        rb_raise(rb_eRuntimeError, "Failed to initialize audio engine");
+        return Qnil;
+    }
+
+    engine_initialized = 1;
+    rb_set_end_proc(cleanup_audio, Qnil);
+
+    return Qnil;
+}
+
 // ============================================================================
 // Audio Loading
 // ============================================================================
 
-// Audio.load(path) - Load an audio file, returns clip ID
 VALUE audio_load(VALUE self, VALUE file)
 {
     const char *path = StringValueCStr(file);
@@ -106,7 +158,6 @@ VALUE audio_load(VALUE self, VALUE file)
     return rb_int2inum(id);
 }
 
-// Audio.duration(clip) - Get duration of clip in seconds
 VALUE audio_duration(VALUE self, VALUE clip)
 {
     int clip_id = NUM2INT(clip);
@@ -129,7 +180,6 @@ VALUE audio_duration(VALUE self, VALUE clip)
 // Playback Controls
 // ============================================================================
 
-// Audio.play(channel, clip) - Play a clip on a channel
 VALUE audio_play(VALUE self, VALUE channel_id, VALUE clip)
 {
     int channel = NUM2INT(channel_id);
@@ -145,7 +195,7 @@ VALUE audio_play(VALUE self, VALUE channel_id, VALUE clip)
         return Qnil;
     }
 
-    // Clean up existing sound on this channel
+    // Clean up existing resources on this channel
     if (channels[channel] != NULL) {
         ma_sound_stop(channels[channel]);
         ma_sound_uninit(channels[channel]);
@@ -153,27 +203,89 @@ VALUE audio_play(VALUE self, VALUE channel_id, VALUE clip)
         channels[channel] = NULL;
     }
 
-    // Create a copy of the sound for playback
+    if (delay_nodes[channel] != NULL) {
+        multi_tap_delay_uninit(delay_nodes[channel]);
+        free(delay_nodes[channel]);
+        delay_nodes[channel] = NULL;
+    }
+
+    if (reverb_nodes[channel] != NULL) {
+        reverb_uninit(reverb_nodes[channel]);
+        free(reverb_nodes[channel]);
+        reverb_nodes[channel] = NULL;
+    }
+
+    // Create sound copy for playback
     ma_sound *playback = (ma_sound *)malloc(sizeof(ma_sound));
     if (playback == NULL) {
         rb_raise(rb_eRuntimeError, "Failed to allocate memory for playback");
         return Qnil;
     }
 
-    ma_result result = ma_sound_init_copy(&engine, sounds[clip_id], 0, NULL, playback);
+    ma_result result = ma_sound_init_copy(&engine, sounds[clip_id], MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT, NULL, playback);
     if (result != MA_SUCCESS) {
         free(playback);
         rb_raise(rb_eRuntimeError, "Failed to create sound copy for playback");
         return Qnil;
     }
 
+    // Create delay node
+    ma_uint32 sampleRate = ma_engine_get_sample_rate(&engine);
+    ma_uint32 numChannels = ma_engine_get_channels(&engine);
+
+    multi_tap_delay_node *delayNode = (multi_tap_delay_node *)malloc(sizeof(multi_tap_delay_node));
+    if (delayNode == NULL) {
+        ma_sound_uninit(playback);
+        free(playback);
+        rb_raise(rb_eRuntimeError, "Failed to allocate memory for delay node");
+        return Qnil;
+    }
+
+    result = multi_tap_delay_init(delayNode, ma_engine_get_node_graph(&engine), sampleRate, numChannels);
+    if (result != MA_SUCCESS) {
+        free(delayNode);
+        ma_sound_uninit(playback);
+        free(playback);
+        rb_raise(rb_eRuntimeError, "Failed to initialize delay node");
+        return Qnil;
+    }
+
+    // Create reverb node
+    reverb_node *reverbNode = (reverb_node *)malloc(sizeof(reverb_node));
+    if (reverbNode == NULL) {
+        multi_tap_delay_uninit(delayNode);
+        free(delayNode);
+        ma_sound_uninit(playback);
+        free(playback);
+        rb_raise(rb_eRuntimeError, "Failed to allocate memory for reverb node");
+        return Qnil;
+    }
+
+    result = reverb_init(reverbNode, ma_engine_get_node_graph(&engine), sampleRate, numChannels);
+    if (result != MA_SUCCESS) {
+        free(reverbNode);
+        multi_tap_delay_uninit(delayNode);
+        free(delayNode);
+        ma_sound_uninit(playback);
+        free(playback);
+        rb_raise(rb_eRuntimeError, "Failed to initialize reverb node");
+        return Qnil;
+    }
+
+    // Route: sound -> delay_node -> reverb_node -> endpoint
+    ma_node *endpoint = ma_engine_get_endpoint(&engine);
+    ma_node_attach_output_bus(&reverbNode->base, 0, endpoint, 0);
+    ma_node_attach_output_bus(&delayNode->base, 0, &reverbNode->base, 0);
+    ma_node_attach_output_bus((ma_node *)playback, 0, &delayNode->base, 0);
+
+    delay_nodes[channel] = delayNode;
+    reverb_nodes[channel] = reverbNode;
     channels[channel] = playback;
     ma_sound_start(playback);
 
     return rb_int2inum(channel);
 }
 
-// Audio.stop(channel) - Stop playback and rewind
 VALUE audio_stop(VALUE self, VALUE channel_id)
 {
     int channel = NUM2INT(channel_id);
@@ -188,7 +300,6 @@ VALUE audio_stop(VALUE self, VALUE channel_id)
     return Qnil;
 }
 
-// Audio.pause(channel) - Pause playback
 VALUE audio_pause(VALUE self, VALUE channel_id)
 {
     int channel = NUM2INT(channel_id);
@@ -202,7 +313,6 @@ VALUE audio_pause(VALUE self, VALUE channel_id)
     return Qnil;
 }
 
-// Audio.resume(channel) - Resume playback
 VALUE audio_resume(VALUE self, VALUE channel_id)
 {
     int channel = NUM2INT(channel_id);
@@ -217,10 +327,9 @@ VALUE audio_resume(VALUE self, VALUE channel_id)
 }
 
 // ============================================================================
-// Audio Effects
+// Sound Effects
 // ============================================================================
 
-// Audio.set_volume(channel, volume) - Set volume (0-128)
 VALUE audio_set_volume(VALUE self, VALUE channel_id, VALUE volume)
 {
     int channel = NUM2INT(channel_id);
@@ -230,13 +339,11 @@ VALUE audio_set_volume(VALUE self, VALUE channel_id, VALUE volume)
         return Qnil;
     }
 
-    float normalized_volume = vol / 128.0f;
-    ma_sound_set_volume(channels[channel], normalized_volume);
+    ma_sound_set_volume(channels[channel], vol / 128.0f);
 
     return Qnil;
 }
 
-// Audio.set_pitch(channel, pitch) - Set pitch (1.0 = normal)
 VALUE audio_set_pitch(VALUE self, VALUE channel_id, VALUE pitch)
 {
     int channel = NUM2INT(channel_id);
@@ -251,9 +358,6 @@ VALUE audio_set_pitch(VALUE self, VALUE channel_id, VALUE pitch)
     return Qnil;
 }
 
-// Audio.set_pos(channel, angle, distance) - Set 3D position
-// angle: 0=front, 90=right, 180=back, 270=left
-// distance: 0=close, 255=far
 VALUE audio_set_pos(VALUE self, VALUE channel_id, VALUE angle, VALUE distance)
 {
     int channel = NUM2INT(channel_id);
@@ -264,7 +368,6 @@ VALUE audio_set_pos(VALUE self, VALUE channel_id, VALUE angle, VALUE distance)
         return Qnil;
     }
 
-    // Convert polar to cartesian
     float rad = ang * (MA_PI / 180.0f);
     float normalized_dist = dist / 255.0f;
     float x = normalized_dist * sinf(rad);
@@ -275,54 +378,157 @@ VALUE audio_set_pos(VALUE self, VALUE channel_id, VALUE angle, VALUE distance)
     return Qnil;
 }
 
+VALUE audio_set_looping(VALUE self, VALUE channel_id, VALUE looping)
+{
+    int channel = NUM2INT(channel_id);
+    ma_bool32 loop = RTEST(looping) ? MA_TRUE : MA_FALSE;
+
+    if (channel < 0 || channel >= MAX_CHANNELS || channels[channel] == NULL) {
+        return Qnil;
+    }
+
+    ma_sound_set_looping(channels[channel], loop);
+
+    return Qnil;
+}
+
 // ============================================================================
-// Engine Initialization
+// Delay Tap Controls
 // ============================================================================
 
-// Audio.init - Initialize the audio engine
-VALUE audio_init(VALUE self)
+VALUE audio_add_delay_tap(VALUE self, VALUE channel_id, VALUE time_ms, VALUE volume)
 {
-    if (engine_initialized) {
+    int channel = NUM2INT(channel_id);
+    float ms = (float)NUM2DBL(time_ms);
+    float vol = (float)NUM2DBL(volume);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || delay_nodes[channel] == NULL) {
+        rb_raise(rb_eArgError, "Invalid channel or no delay node: %d", channel);
         return Qnil;
     }
 
-    // Check for null driver (for CI environments without audio devices)
-    // Usage: NATIVE_AUDIO_DRIVER=null ruby script.rb
-    const char *driver = getenv("NATIVE_AUDIO_DRIVER");
-    int use_null = (driver != NULL && strcmp(driver, "null") == 0);
+    int tap_id = multi_tap_delay_add_tap(delay_nodes[channel], ms, vol);
+    if (tap_id < 0) {
+        rb_raise(rb_eRuntimeError, "Failed to add delay tap (max taps reached)");
+        return Qnil;
+    }
 
-    ma_engine_config config = ma_engine_config_init();
-    config.listenerCount = 1;
+    return rb_int2inum(tap_id);
+}
 
-    if (use_null) {
-        ma_backend backends[] = { ma_backend_null };
-        ma_result ctx_result = ma_context_init(backends, 1, NULL, &context);
-        if (ctx_result != MA_SUCCESS) {
-            rb_raise(rb_eRuntimeError, "Failed to initialize null audio context");
-            return Qnil;
-        }
-        context_initialized = 1;
-        using_null_backend = 1;
-        config.pContext = &context;
+VALUE audio_remove_delay_tap(VALUE self, VALUE channel_id, VALUE tap_id)
+{
+    int channel = NUM2INT(channel_id);
+    int tap = NUM2INT(tap_id);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || delay_nodes[channel] == NULL) {
+        return Qnil;
     }
 
-    ma_result result = ma_engine_init(&config, &engine);
+    multi_tap_delay_remove_tap(delay_nodes[channel], tap);
 
-    if (result != MA_SUCCESS) {
-        if (context_initialized) {
-            ma_context_uninit(&context);
-            context_initialized = 0;
-        }
-        rb_raise(rb_eRuntimeError, "Failed to initialize audio engine");
+    return Qnil;
+}
+
+VALUE audio_set_delay_tap_volume(VALUE self, VALUE channel_id, VALUE tap_id, VALUE volume)
+{
+    int channel = NUM2INT(channel_id);
+    int tap = NUM2INT(tap_id);
+    float vol = (float)NUM2DBL(volume);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || delay_nodes[channel] == NULL) {
         return Qnil;
     }
 
-    engine_initialized = 1;
-    rb_set_end_proc(cleanup_audio, Qnil);
+    multi_tap_delay_set_volume(delay_nodes[channel], tap, vol);
 
     return Qnil;
 }
 
+VALUE audio_set_delay_tap_time(VALUE self, VALUE channel_id, VALUE tap_id, VALUE time_ms)
+{
+    int channel = NUM2INT(channel_id);
+    int tap = NUM2INT(tap_id);
+    float ms = (float)NUM2DBL(time_ms);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || delay_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    multi_tap_delay_set_time(delay_nodes[channel], tap, ms);
+
+    return Qnil;
+}
+
+// ============================================================================
+// Reverb Controls
+// ============================================================================
+
+VALUE audio_enable_reverb(VALUE self, VALUE channel_id, VALUE enabled)
+{
+    int channel = NUM2INT(channel_id);
+    ma_bool32 en = RTEST(enabled) ? MA_TRUE : MA_FALSE;
+
+    if (channel < 0 || channel >= MAX_CHANNELS || reverb_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    reverb_set_enabled(reverb_nodes[channel], en);
+    return Qnil;
+}
+
+VALUE audio_set_reverb_room_size(VALUE self, VALUE channel_id, VALUE size)
+{
+    int channel = NUM2INT(channel_id);
+    float s = (float)NUM2DBL(size);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || reverb_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    reverb_set_room_size(reverb_nodes[channel], s);
+    return Qnil;
+}
+
+VALUE audio_set_reverb_damping(VALUE self, VALUE channel_id, VALUE damp)
+{
+    int channel = NUM2INT(channel_id);
+    float d = (float)NUM2DBL(damp);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || reverb_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    reverb_set_damping(reverb_nodes[channel], d);
+    return Qnil;
+}
+
+VALUE audio_set_reverb_wet(VALUE self, VALUE channel_id, VALUE wet)
+{
+    int channel = NUM2INT(channel_id);
+    float w = (float)NUM2DBL(wet);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || reverb_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    reverb_set_wet(reverb_nodes[channel], w);
+    return Qnil;
+}
+
+VALUE audio_set_reverb_dry(VALUE self, VALUE channel_id, VALUE dry)
+{
+    int channel = NUM2INT(channel_id);
+    float d = (float)NUM2DBL(dry);
+
+    if (channel < 0 || channel >= MAX_CHANNELS || reverb_nodes[channel] == NULL) {
+        return Qnil;
+    }
+
+    reverb_set_dry(reverb_nodes[channel], d);
+    return Qnil;
+}
+
 // ============================================================================
 // Ruby Module Setup
 // ============================================================================
@@ -330,7 +536,11 @@ VALUE audio_init(VALUE self)
 void Init_audio(void)
 {
     for (int i = 0; i < MAX_SOUNDS; i++) sounds[i] = NULL;
-    for (int i = 0; i < MAX_CHANNELS; i++) channels[i] = NULL;
+    for (int i = 0; i < MAX_CHANNELS; i++) {
+        channels[i] = NULL;
+        delay_nodes[i] = NULL;
+        reverb_nodes[i] = NULL;
+    }
 
     VALUE mAudio = rb_define_module("Audio");
 
@@ -351,4 +561,18 @@ void Init_audio(void)
     rb_define_singleton_method(mAudio, "set_volume", audio_set_volume, 2);
     rb_define_singleton_method(mAudio, "set_pitch", audio_set_pitch, 2);
     rb_define_singleton_method(mAudio, "set_pos", audio_set_pos, 3);
+    rb_define_singleton_method(mAudio, "set_looping", audio_set_looping, 2);
+
+    // Delay taps
+    rb_define_singleton_method(mAudio, "add_delay_tap", audio_add_delay_tap, 3);
+    rb_define_singleton_method(mAudio, "remove_delay_tap", audio_remove_delay_tap, 2);
+    rb_define_singleton_method(mAudio, "set_delay_tap_volume", audio_set_delay_tap_volume, 3);
+    rb_define_singleton_method(mAudio, "set_delay_tap_time", audio_set_delay_tap_time, 3);
+
+    // Reverb
+    rb_define_singleton_method(mAudio, "enable_reverb", audio_enable_reverb, 2);
+    rb_define_singleton_method(mAudio, "set_reverb_room_size", audio_set_reverb_room_size, 2);
+    rb_define_singleton_method(mAudio, "set_reverb_damping", audio_set_reverb_damping, 2);
+    rb_define_singleton_method(mAudio, "set_reverb_wet", audio_set_reverb_wet, 2);
+    rb_define_singleton_method(mAudio, "set_reverb_dry", audio_set_reverb_dry, 2);
 }

data/ext/audio/audio.h

@@ -0,0 +1,34 @@
+// ============================================================================
+// audio.h - Shared types, constants, and globals for native_audio
+// ============================================================================
+
+#ifndef NATIVE_AUDIO_H
+#define NATIVE_AUDIO_H
+
+#include "miniaudio.h"
+#include "delay_node.h"
+#include "reverb_node.h"
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+#define MAX_SOUNDS 1024
+#define MAX_CHANNELS 1024
+
+// ============================================================================
+// Globals (defined in audio.c)
+// ============================================================================
+
+extern ma_engine engine;
+extern ma_context context;
+extern ma_sound *sounds[MAX_SOUNDS];
+extern ma_sound *channels[MAX_CHANNELS];
+extern multi_tap_delay_node *delay_nodes[MAX_CHANNELS];
+extern reverb_node *reverb_nodes[MAX_CHANNELS];
+extern int sound_count;
+extern int engine_initialized;
+extern int context_initialized;
+extern int using_null_backend;
+
+#endif // NATIVE_AUDIO_H

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/reverb_node.c

@@ -0,0 +1,224 @@
+// ============================================================================
+// reverb_node.c - Schroeder reverb node implementation
+// ============================================================================
+
+#include <stdlib.h>
+#include <string.h>
+#include "reverb_node.h"
+
+// ============================================================================
+// Delay Line Helpers
+// ============================================================================
+
+// Base delay times in seconds (Schroeder-style, prime-ish ratios)
+static const float COMB_DELAYS[NUM_COMBS] = { 0.0297f, 0.0371f, 0.0411f, 0.0437f };
+static const float ALLPASS_DELAYS[NUM_ALLPASSES] = { 0.005f, 0.0017f };
+
+static void delay_line_init(delay_line *dl, ma_uint32 size)
+{
+    dl->size = size;
+    dl->pos = 0;
+    dl->buffer = (float *)calloc(size, sizeof(float));
+}
+
+static void delay_line_free(delay_line *dl)
+{
+    if (dl->buffer) {
+        free(dl->buffer);
+        dl->buffer = NULL;
+    }
+}
+
+static inline float delay_line_read(delay_line *dl)
+{
+    return dl->buffer[dl->pos];
+}
+
+static inline void delay_line_write(delay_line *dl, float value)
+{
+    dl->buffer[dl->pos] = value;
+    dl->pos = (dl->pos + 1) % dl->size;
+}
+
+// ============================================================================
+// Filter Processing
+// ============================================================================
+
+// Comb filter: output = buffer[pos], then write input + feedback * output (with damping)
+static inline float comb_process(delay_line *dl, float input, float feedback,
+                                  float damp, float *damp_prev)
+{
+    float output = delay_line_read(dl);
+    // Low-pass filter on feedback for damping (high freq decay faster)
+    *damp_prev = output * (1.0f - damp) + (*damp_prev) * damp;
+    delay_line_write(dl, input + feedback * (*damp_prev));
+    return output;
+}
+
+// Allpass filter: output = -g*input + buffer[pos], write input + g*buffer[pos]
+static inline float allpass_process(delay_line *dl, float input, float feedback)
+{
+    float buffered = delay_line_read(dl);
+    float output = buffered - feedback * input;
+    delay_line_write(dl, input + feedback * buffered);
+    return output;
+}
+
+// ============================================================================
+// DSP Callback
+// ============================================================================
+
+static void reverb_process(ma_node *pNode, const float **ppFramesIn,
+                           ma_uint32 *pFrameCountIn, float **ppFramesOut,
+                           ma_uint32 *pFrameCountOut)
+{
+    reverb_node *node = (reverb_node *)pNode;
+    const float *pFramesIn = ppFramesIn[0];
+    float *pFramesOut = ppFramesOut[0];
+    ma_uint32 frameCount = *pFrameCountOut;
+    ma_uint32 numChannels = node->channels;
+
+    if (!node->enabled) {
+        // Bypass: copy input to output
+        memcpy(pFramesOut, pFramesIn, frameCount * numChannels * sizeof(float));
+        return;
+    }
+
+    for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame++) {
+        for (ma_uint32 iChannel = 0; iChannel < numChannels && iChannel < 2; iChannel++) {
+            ma_uint32 sampleIndex = iFrame * numChannels + iChannel;
+            float input = pFramesIn[sampleIndex];
+
+            // Sum of parallel comb filters
+            float combSum = 0.0f;
+            for (int c = 0; c < NUM_COMBS; c++) {
+                combSum += comb_process(&node->combs[iChannel][c], input,
+                                        node->comb_feedback, node->comb_damp,
+                                        &node->comb_damp_prev[iChannel][c]);
+            }
+            combSum *= 0.25f;  // Average the 4 combs
+
+            // Series allpass filters
+            float allpassOut = combSum;
+            for (int a = 0; a < NUM_ALLPASSES; a++) {
+                allpassOut = allpass_process(&node->allpasses[iChannel][a],
+                                             allpassOut, node->allpass_feedback);
+            }
+
+            // Mix dry and wet
+            pFramesOut[sampleIndex] = input * node->dry + allpassOut * node->wet;
+        }
+
+        // Handle mono->stereo or more channels by copying
+        for (ma_uint32 iChannel = 2; iChannel < numChannels; iChannel++) {
+            ma_uint32 sampleIndex = iFrame * numChannels + iChannel;
+            pFramesOut[sampleIndex] = pFramesIn[sampleIndex];
+        }
+    }
+}
+
+static ma_node_vtable g_reverb_vtable = {
+    reverb_process,
+    NULL,
+    1,
+    1,
+    0
+};
+
+// ============================================================================
+// Lifecycle
+// ============================================================================
+
+ma_result reverb_init(reverb_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->enabled = MA_FALSE;
+
+    // Default parameters
+    pNode->room_size = 0.5f;
+    pNode->comb_feedback = 0.7f;
+    pNode->comb_damp = 0.3f;
+    pNode->allpass_feedback = 0.5f;
+    pNode->wet = 0.3f;
+    pNode->dry = 1.0f;
+
+    // Initialize delay lines for up to 2 audio channels
+    ma_uint32 chans = numChannels < 2 ? numChannels : 2;
+    for (ma_uint32 ch = 0; ch < chans; ch++) {
+        for (int c = 0; c < NUM_COMBS; c++) {
+            ma_uint32 delaySize = (ma_uint32)(COMB_DELAYS[c] * pNode->room_size * 2.0f * sampleRate);
+            if (delaySize < 1) delaySize = 1;
+            delay_line_init(&pNode->combs[ch][c], delaySize);
+        }
+        for (int a = 0; a < NUM_ALLPASSES; a++) {
+            ma_uint32 delaySize = (ma_uint32)(ALLPASS_DELAYS[a] * sampleRate);
+            if (delaySize < 1) delaySize = 1;
+            delay_line_init(&pNode->allpasses[ch][a], delaySize);
+        }
+    }
+
+    // Set up node
+    ma_uint32 channelsArray[1] = { numChannels };
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable = &g_reverb_vtable;
+    nodeConfig.pInputChannels = channelsArray;
+    nodeConfig.pOutputChannels = channelsArray;
+
+    return ma_node_init(pNodeGraph, &nodeConfig, NULL, &pNode->base);
+}
+
+void reverb_uninit(reverb_node *pNode)
+{
+    if (pNode == NULL) return;
+
+    ma_node_uninit(&pNode->base, NULL);
+
+    for (int ch = 0; ch < 2; ch++) {
+        for (int c = 0; c < NUM_COMBS; c++) {
+            delay_line_free(&pNode->combs[ch][c]);
+        }
+        for (int a = 0; a < NUM_ALLPASSES; a++) {
+            delay_line_free(&pNode->allpasses[ch][a]);
+        }
+    }
+}
+
+// ============================================================================
+// Parameter Control
+// ============================================================================
+
+void reverb_set_enabled(reverb_node *pNode, ma_bool32 enabled)
+{
+    if (pNode) pNode->enabled = enabled;
+}
+
+void reverb_set_room_size(reverb_node *pNode, float size)
+{
+    if (pNode == NULL) return;
+    pNode->room_size = size;
+    // Note: changing room_size after init would require reallocating buffers
+    // For now, this affects feedback calculation
+    pNode->comb_feedback = 0.6f + size * 0.35f;  // 0.6 to 0.95
+}
+
+void reverb_set_damping(reverb_node *pNode, float damp)
+{
+    if (pNode) pNode->comb_damp = damp;
+}
+
+void reverb_set_wet(reverb_node *pNode, float wet)
+{
+    if (pNode) pNode->wet = wet;
+}
+
+void reverb_set_dry(reverb_node *pNode, float dry)
+{
+    if (pNode) pNode->dry = dry;
+}

data/ext/audio/reverb_node.h

@@ -0,0 +1,63 @@
+// ============================================================================
+// reverb_node.h - Schroeder reverb node for native_audio
+// ============================================================================
+
+#ifndef REVERB_NODE_H
+#define REVERB_NODE_H
+
+#include "miniaudio.h"
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+#define NUM_COMBS 4
+#define NUM_ALLPASSES 2
+
+// ============================================================================
+// Types
+// ============================================================================
+
+typedef struct {
+    float *buffer;
+    ma_uint32 size;
+    ma_uint32 pos;
+} delay_line;
+
+typedef struct {
+    ma_node_base base;
+    ma_uint32 channels;
+    ma_uint32 sample_rate;
+
+    // 4 parallel comb filters per audio channel
+    delay_line combs[2][NUM_COMBS];  // [audio_channel][comb_index]
+    float comb_feedback;
+    float comb_damp;
+    float comb_damp_prev[2][NUM_COMBS];
+
+    // 2 series allpass filters per audio channel
+    delay_line allpasses[2][NUM_ALLPASSES];
+    float allpass_feedback;
+
+    // Mix control
+    float wet;
+    float dry;
+    float room_size;
+    ma_bool32 enabled;
+} reverb_node;
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+ma_result reverb_init(reverb_node *pNode, ma_node_graph *pNodeGraph,
+                      ma_uint32 sampleRate, ma_uint32 numChannels);
+void reverb_uninit(reverb_node *pNode);
+
+void reverb_set_enabled(reverb_node *pNode, ma_bool32 enabled);
+void reverb_set_room_size(reverb_node *pNode, float size);
+void reverb_set_damping(reverb_node *pNode, float damp);
+void reverb_set_wet(reverb_node *pNode, float wet);
+void reverb_set_dry(reverb_node *pNode, float dry);
+
+#endif // REVERB_NODE_H

data/lib/dummy_audio.rb

@@ -4,6 +4,7 @@
 # Has the same interface as the Audio C extension but does nothing.
 module DummyAudio
   @sound_count = 0
+  @tap_counts = {}
 
   def self.init
     nil
@@ -20,6 +21,7 @@ module DummyAudio
   end
 
   def self.play(channel, clip)
+    @tap_counts[channel] = 0
     channel
   end
 
@@ -46,4 +48,47 @@ module DummyAudio
   def self.set_pos(channel, angle, distance)
     nil
   end
+
+  def self.set_looping(channel, looping)
+    nil
+  end
+
+  def self.add_delay_tap(channel, time_ms, volume)
+    @tap_counts[channel] ||= 0
+    tap_id = @tap_counts[channel]
+    @tap_counts[channel] += 1
+    tap_id
+  end
+
+  def self.remove_delay_tap(channel, tap_id)
+    nil
+  end
+
+  def self.set_delay_tap_volume(channel, tap_id, volume)
+    nil
+  end
+
+  def self.set_delay_tap_time(channel, tap_id, time_ms)
+    nil
+  end
+
+  def self.enable_reverb(channel, enabled)
+    nil
+  end
+
+  def self.set_reverb_room_size(channel, size)
+    nil
+  end
+
+  def self.set_reverb_damping(channel, damp)
+    nil
+  end
+
+  def self.set_reverb_wet(channel, wet)
+    nil
+  end
+
+  def self.set_reverb_dry(channel, dry)
+    nil
+  end
 end

data/lib/native_audio.rb

@@ -23,10 +23,39 @@ module NativeAudio
     end
   end
 
+  class DelayTap
+    attr_reader :id, :audio_source, :time_ms, :volume
+
+    def initialize(audio_source, id, time_ms, volume)
+      @audio_source = audio_source
+      @id = id
+      @time_ms = time_ms
+      @volume = volume
+    end
+
+    def volume=(val)
+      NativeAudio.audio_driver.set_delay_tap_volume(@audio_source.channel, @id, val)
+      @volume = val
+    end
+
+    def time_ms=(val)
+      NativeAudio.audio_driver.set_delay_tap_time(@audio_source.channel, @id, val)
+      @time_ms = val
+    end
+
+    def remove
+      NativeAudio.audio_driver.remove_delay_tap(@audio_source.channel, @id)
+      @audio_source.delay_taps.delete(self)
+    end
+  end
+
   class AudioSource
+    attr_reader :channel
+
     def initialize(clip)
       @clip = clip
       @channel = AudioSource.channels.count
+      @delay_taps = []
       AudioSource.channels << self
     end
 
@@ -58,6 +87,33 @@ module NativeAudio
       NativeAudio.audio_driver.set_pitch(@channel, pitch)
     end
 
+    def set_looping(looping)
+      NativeAudio.audio_driver.set_looping(@channel, looping)
+    end
+
+    def add_delay_tap(time_ms:, volume:)
+      tap_id = NativeAudio.audio_driver.add_delay_tap(@channel, time_ms, volume)
+      tap = DelayTap.new(self, tap_id, time_ms, volume)
+      @delay_taps << tap
+      tap
+    end
+
+    def enable_reverb(enabled = true)
+      NativeAudio.audio_driver.enable_reverb(@channel, enabled)
+    end
+
+    def set_reverb(room_size: 0.5, damping: 0.3, wet: 0.3, dry: 1.0)
+      NativeAudio.audio_driver.enable_reverb(@channel, true)
+      NativeAudio.audio_driver.set_reverb_room_size(@channel, room_size)
+      NativeAudio.audio_driver.set_reverb_damping(@channel, damping)
+      NativeAudio.audio_driver.set_reverb_wet(@channel, wet)
+      NativeAudio.audio_driver.set_reverb_dry(@channel, dry)
+    end
+
+    def delay_taps
+      @delay_taps
+    end
+
     def self.channels
       @channels ||= []
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: native_audio
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Max Hatfull
@@ -20,8 +20,13 @@ files:
 - LICENSE
 - README.md
 - ext/audio/audio.c
+- ext/audio/audio.h
+- ext/audio/delay_node.c
+- ext/audio/delay_node.h
 - ext/audio/extconf.rb
 - ext/audio/miniaudio.h
+- ext/audio/reverb_node.c
+- ext/audio/reverb_node.h
 - lib/dummy_audio.rb
 - lib/native_audio.rb
 homepage: https://github.com/rubyrpg/native_audio