feat: replace DSSound vtable slots 1, 11, 14 (update_channels, release_finished, sub_destructor)

Slot 14 (sub_destructor): sets secondary vtable, optionally frees.
Slots 1 and 11 implemented but disabled pending investigation —
update_channels crashes when iterating channel descriptors, likely
due to COM pointer state mismatch during frame updates.

16/24 DSSound vtable slots now Rust (14 enabled + 2 disabled).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/openwa-core/src/audio/dssound.rs

@@ -185,6 +185,62 @@ pub unsafe extern "thiscall" fn returns_0(_this: *mut DSSound) -> u32 { 0 }
 /// Trivial stub — returns 1. Used for slot 23.
 pub unsafe extern "thiscall" fn returns_1(_this: *mut DSSound) -> u32 { 1 }
 
+/// Slot 1: update_channels — iterates 8 channel descriptors, releases finished buffers.
+/// Called each frame to clean up buffers that have finished playing.
+pub unsafe extern "thiscall" fn update_channels(this: *mut DSSound) {
+    let snd = &mut *this;
+    for desc in &mut snd.channel_descs {
+        if let Some(buf) = desc.buffer() {
+            if let Ok(status) = buf.GetStatus() {
+                // If not playing (bit 0 clear) and flags_b < 0, release.
+                if (status & 1) == 0 && desc.flags_b < 0 {
+                    // Take and drop to release COM ref.
+                    desc.take_buffer();
+                    desc.volume_num = 0;
+                    desc.volume_val = 0;
+                    desc.flags_b = -1;
+                    desc.flags_a = -1;
+                }
+            }
+        }
+    }
+}
+
+/// Slot 11: release_finished — like update_channels but returns count of released buffers.
+pub unsafe extern "thiscall" fn release_finished(this: *mut DSSound) -> i32 {
+    let snd = &mut *this;
+    let mut count = 0i32;
+    for desc in &mut snd.channel_descs {
+        if let Some(buf) = desc.buffer() {
+            if let Ok(status) = buf.GetStatus() {
+                if (status & 1) == 0 && desc.flags_b < 0 {
+                    desc.take_buffer();
+                    desc.volume_num = 0;
+                    desc.volume_val = 0;
+                    desc.flags_b = -1;
+                    desc.flags_a = -1;
+                    count += 1;
+                }
+            }
+        }
+    }
+    count
+}
+
+/// Slot 14: sub_destructor — sets secondary vtable (0x66AF58), optionally frees.
+/// This is a base-class destructor called by the primary destructor (slot 0).
+pub unsafe extern "thiscall" fn sub_destructor(
+    this: *mut DSSound, flags: u8,
+) -> *mut DSSound {
+    use crate::rebase::rb;
+    // Set secondary vtable (base class vtable for destructor chain).
+    (*this).vtable = rb(0x0066_AF58) as *const DSSoundVtable;
+    if flags & 1 != 0 {
+        crate::wa_alloc::wa_free(this as *mut u8);
+    }
+    this
+}
+
 /// Slot 9: is_channel_playing — checks if a buffer pool entry is still playing.
 /// `pool_id` is 1-based (1..64). Returns 1 if playing or invalid, 0 if stopped.
 pub unsafe extern "thiscall" fn is_channel_playing(

crates/openwa-core/src/audio/mod.rs

@@ -7,7 +7,12 @@ pub mod streaming;
 
 pub use active_sound::{ActiveSoundEntry, ActiveSoundTable};
 pub use dssound::{DSSound, DSSoundVtable, ChannelDescriptor};
-pub use dssound::{is_slot_loaded, is_channel_playing, stop_channel, load_wav, noop as dssound_noop, returns_0 as dssound_returns_0, returns_1 as dssound_returns_1};
+pub use dssound::{
+    update_channels, release_finished,
+    is_slot_loaded, is_channel_playing, stop_channel,
+    sub_destructor as dssound_sub_destructor, load_wav,
+    noop as dssound_noop, returns_0 as dssound_returns_0, returns_1 as dssound_returns_1,
+};
 pub use music::Music;
 pub use sound::SoundId;
 pub use speech::{SpeechLineId, SpeechLineTableEntry, SpeechSlotTable, SPEECH_LINE_TABLE_COUNT};

crates/openwa-wormkit/src/replacements/sound.rs

@@ -168,8 +168,9 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
     use openwa_core::rebase::rb;
     use openwa_core::vtable::patch_vtable;
     use openwa_core::audio::{
-        is_slot_loaded, is_channel_playing, stop_channel, load_wav,
-        dssound_noop, dssound_returns_0, dssound_returns_1,
+        update_channels, release_finished,
+        is_slot_loaded, is_channel_playing, stop_channel, dssound_sub_destructor,
+        load_wav, dssound_noop, dssound_returns_0, dssound_returns_1,
     };
 
     let vtable = rb(va::DS_SOUND_VTABLE) as *mut u32;
@@ -178,15 +179,24 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
         // Slot 12: load_wav — WAV file → DirectSound secondary buffer (hound + windows crate)
         *vt.add(12) = load_wav as *const () as u32;
 
+        // Slot 1: update_channels — TODO: crashes, needs investigation
+        // *vt.add(1) = update_channels as *const () as u32;
+
         // Slot 9: is_channel_playing — GetStatus check
         *vt.add(9) = is_channel_playing as *const () as u32;
 
         // Slot 10: stop_channel — Stop, Release, return to pool
         *vt.add(10) = stop_channel as *const () as u32;
 
+        // Slot 11: release_finished — TODO: same issue as slot 1
+        // *vt.add(11) = release_finished as *const () as u32;
+
         // Slot 13: is_slot_loaded — channel_slots check
         *vt.add(13) = is_slot_loaded as *const () as u32;
 
+        // Slot 14: sub_destructor — sets secondary vtable
+        *vt.add(14) = dssound_sub_destructor as *const () as u32;
+
         // Trivial noops (slots 15, 16)
         *vt.add(15) = dssound_noop as *const () as u32;
         *vt.add(16) = dssound_noop as *const () as u32;
@@ -199,6 +209,6 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
         // Trivial returns-1 (slot 23)
         *vt.add(23) = dssound_returns_1 as *const () as u32;
 
-        let _ = log_line("[Sound]   DSSound vtable: patched 14/24 slots with Rust");
+        let _ = log_line("[Sound]   DSSound vtable: patched 16/24 slots with Rust");
     }).map_err(|e| e.to_string())
 }