Talon/voice-cat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(windows): list all user-session apps in the app-audio picker

Browse Source 
The picker gated its list on visible-window processes plus audio sessions
on only the default render device. That both showed non-audio apps (any
window) and missed real ones (windowless or routed to a secondary device).
Process loopback targets a PID and its child tree regardless of whether the
app is currently playing, so the gate fought the capture layer.

Now enumerate every process in the user's interactive session (windowed or
not), deduped by executable with the windowed tree-root as the capture PID;
scan all active render endpoints to flag currently-playing apps with a > and
sort them first. Adds a filter box and persists checks across filtering.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Talon
2026-06-24 00:24:20 +02:00
parent 04bdb70d47
commit 47124b15a2
2 changed files with 233 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
clients/windows/VoiceCat.App/Audio/AudioSessionEnumerator.cs
View File

@@ -13,87 +13,154 @@ public sealed record EntireDesktop(bool ExcludeSelf = false) : AppAudioScope;
public sealed record OnlyApps(IReadOnlyList<int> Pids, IReadOnlyList<string> Names) : AppAudioScope;
public sealed record AllExceptApps(IReadOnlyList<int> Pids, IReadOnlyList<string> Names) : AppAudioScope;
public sealed record AudioAppInfo(int Pid, string DisplayName);
// IsPlaying = a process in this app's executable group currently has an *active* audio
// session on some render endpoint. Purely informational for the picker — capture works
// on any PID regardless (process-loopback yields silence until the app plays).
public sealed record AudioAppInfo(int Pid, string DisplayName, bool IsPlaying);
// ── Enumerator ─────────────────────────────────────────────────────────────────
public static class AudioSessionEnumerator
{
// Returns all user-facing apps: visible-window processes (primary, like macOS
// SCShareableContent.current) plus any background audio-session-only processes
// (e.g. Spotify in mini-player). Excludes VoiceCat itself and system processes.
// Returns every app in the user's interactive session — windowed or not — so any of
// them can be picked for capture even before it starts producing audio. Process
// loopback (see ProcessLoopbackCapture) targets a PID and its child tree, so a silent
// selection simply starts working the moment that app plays.
//
// Apps are deduped by executable (multiple PIDs of the same program collapse to one
// row whose PID is the process-tree root). Session-0 services and VoiceCat itself are
// excluded. Apps currently producing audio are flagged IsPlaying and sorted first.
public static IReadOnlyList<AudioAppInfo> GetAudioApps()
{
var seen = new HashSet<int>();
var result = new List<AudioAppInfo>();
int selfPid = Environment.ProcessId;
int selfPid = Environment.ProcessId;
int sessionId = SafeCurrentSessionId();
var playingPids = GetActiveAudioPids();
// ── 1. Visible-window processes (EnumWindows) ─────────────────────────
// Same set macOS ScreenCaptureKit exposes: all apps with at least one
// visible top-level window. Shows apps even when not currently producing audio.
EnumWindows((hWnd, _) =>
// Group by executable name; keep the best representative PID per group.
var groups = new Dictionary<string, AppGroup>(StringComparer.OrdinalIgnoreCase);
foreach (var proc in Process.GetProcesses())
{
if (!IsWindowVisible(hWnd)) return true;
GetWindowThreadProcessId(hWnd, out uint pid);
if (pid == 0 || pid == (uint)selfPid || !seen.Add((int)pid)) return true;
try
{
var proc = Process.GetProcessById((int)pid);
string name = proc.MainWindowTitle.Length > 0
? $"{proc.ProcessName} — {proc.MainWindowTitle}"
: proc.ProcessName;
if (!string.IsNullOrEmpty(proc.ProcessName))
result.Add(new AudioAppInfo((int)pid, name));
if (proc.Id == selfPid) continue;
if (proc.SessionId != sessionId) continue; // drop session-0 services
string name = proc.ProcessName;
if (string.IsNullOrEmpty(name)) continue;
bool hasWindow = proc.MainWindowHandle != IntPtr.Zero;
bool playing = playingPids.Contains(proc.Id);
string title = hasWindow ? SafeWindowTitle(proc) : "";
string display = title.Length > 0 ? $"{name} — {title}" : name;
if (groups.TryGetValue(name, out var g))
{
g.AnyPlaying |= playing;
// Prefer a windowed PID (the process-tree root) as the capture target;
// among non-windowed, prefer a currently-playing PID.
bool better = (hasWindow && !g.HasWindow)
|| (!g.HasWindow && !hasWindow && playing && !g.RepPlaying);
if (better)
{
g.Pid = proc.Id;
g.Display = display;
g.HasWindow = hasWindow;
g.RepPlaying = playing;
}
}
else
{
groups[name] = new AppGroup
{
Pid = proc.Id,
Display = display,
HasWindow = hasWindow,
RepPlaying = playing,
AnyPlaying = playing,
};
}
}
catch { /* process exited between EnumWindows and GetProcessById */ }
catch { /* protected/exited process — skip */ }
finally { proc.Dispose(); }
}
return true; // continue enumeration
}, IntPtr.Zero);
// ── 2. Background audio-session processes (WASAPI, supplement) ────────
// Catches apps that produce audio but have no visible window (screen reader,
// background music player, etc.). Silently skipped if WASAPI is unavailable.
AppendAudioSessionApps(seen, selfPid, result);
return result.OrderBy(a => a.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
return groups.Values
.Select(g => new AudioAppInfo(g.Pid, g.Display, g.AnyPlaying))
.OrderByDescending(a => a.IsPlaying)
.ThenBy(a => a.DisplayName, StringComparer.OrdinalIgnoreCase)
.ToList();
}
// ── EnumWindows P/Invoke ──────────────────────────────────────────────────
private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
[DllImport("user32.dll")]
private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
[DllImport("user32.dll")]
private static extern bool IsWindowVisible(IntPtr hWnd);
[DllImport("user32.dll")]
private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
// ── WASAPI audio session supplement ──────────────────────────────────────
private static void AppendAudioSessionApps(HashSet<int> seen, int selfPid,
List<AudioAppInfo> result)
private sealed class AppGroup
{
public int Pid;
public string Display = "";
public bool HasWindow;
public bool RepPlaying; // representative PID is playing
public bool AnyPlaying; // any PID in the group is playing
}
private static int SafeCurrentSessionId()
{
try { using var me = Process.GetCurrentProcess(); return me.SessionId; }
catch { return 1; } // typical interactive session fallback
}
private static string SafeWindowTitle(Process proc)
{
try { return proc.MainWindowTitle; }
catch { return ""; }
}
// ── WASAPI: PIDs with an active render session (any endpoint) ─────────────
// Scans ALL active render endpoints, not just the default — an app routed to a
// secondary device still counts as "playing now".
private static HashSet<int> GetActiveAudioPids()
{
var pids = new HashSet<int>();
IMMDeviceEnumerator? enumerator = null;
IMMDevice? device = null;
IAudioSessionManager2? manager = null;
IAudioSessionEnumerator? sessions = null;
IMMDeviceCollection? devices = null;
try
{
enumerator = (IMMDeviceEnumerator)Activator.CreateInstance(
Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"))!)!;
enumerator.GetDefaultAudioEndpoint(0 /*eRender*/, 1 /*eMultimedia*/, out device);
if (enumerator.EnumAudioEndpoints(0 /*eRender*/, 0x1 /*DEVICE_STATE_ACTIVE*/,
out devices) < 0 || devices == null)
return pids;
devices.GetCount(out int devCount);
for (int d = 0; d < devCount; d++)
CollectActivePids(devices, d, pids);
}
catch { /* no audio device or WASAPI unavailable — ignore */ }
finally
{
if (devices != null) Marshal.ReleaseComObject(devices);
if (enumerator != null) Marshal.ReleaseComObject(enumerator);
}
return pids;
}
private static void CollectActivePids(IMMDeviceCollection devices, int index, HashSet<int> pids)
{
IMMDevice? device = null;
IAudioSessionManager2? manager = null;
IAudioSessionEnumerator? sessions = null;
try
{
if (devices.Item(index, out device) < 0 || device == null) return;
var mgr2Iid = new Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F");
device.Activate(ref mgr2Iid, 0x17 /*CLSCTX_ALL*/, IntPtr.Zero, out object mgr);
if (device.Activate(ref mgr2Iid, 0x17 /*CLSCTX_ALL*/, IntPtr.Zero, out object mgr) < 0)
return;
manager = (IAudioSessionManager2)mgr;
manager.GetSessionEnumerator(out sessions);
if (manager.GetSessionEnumerator(out sessions) < 0 || sessions == null) return;
sessions.GetCount(out int count);
for (int i = 0; i < count; i++)
@@ -101,32 +168,24 @@ public static class AudioSessionEnumerator
IAudioSessionControl? ctrl = null;
try
{
sessions.GetSession(i, out ctrl);
if (sessions.GetSession(i, out ctrl) < 0 || ctrl == null) continue;
ctrl.GetState(out int state);
if (state != 1 /*AudioSessionStateActive*/) continue;
var ctrl2 = (IAudioSessionControl2)ctrl;
ctrl2.GetProcessId(out uint pid);
int ipid = (int)pid;
if (pid == 0 || ipid == selfPid || !seen.Add(ipid)) continue;
try
{
var proc = Process.GetProcessById(ipid);
if (!string.IsNullOrEmpty(proc.ProcessName))
result.Add(new AudioAppInfo(ipid, proc.ProcessName));
}
catch { /* exited */ }
if (pid != 0) pids.Add((int)pid);
}
catch { /* stale session */ }
finally { if (ctrl != null) Marshal.ReleaseComObject(ctrl); }
}
}
catch { /* no audio device or WASAPI unavailable — ignore */ }
catch { /* device went away */ }
finally
{
if (sessions != null) Marshal.ReleaseComObject(sessions);
if (manager != null) Marshal.ReleaseComObject(manager);
if (device != null) Marshal.ReleaseComObject(device);
if (enumerator != null) Marshal.ReleaseComObject(enumerator);
if (sessions != null) Marshal.ReleaseComObject(sessions);
if (manager != null) Marshal.ReleaseComObject(manager);
if (device != null) Marshal.ReleaseComObject(device);
}
}
@@ -136,13 +195,21 @@ public static class AudioSessionEnumerator
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IMMDeviceEnumerator
{
[PreserveSig] int EnumAudioEndpoints(int dataFlow, int stateMask, out IntPtr devices);
[PreserveSig] int EnumAudioEndpoints(int dataFlow, int stateMask, out IMMDeviceCollection devices);
[PreserveSig] int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice endpoint);
[PreserveSig] int GetDevice([MarshalAs(UnmanagedType.LPWStr)] string id, out IMMDevice device);
[PreserveSig] int RegisterEndpointNotificationCallback(IntPtr client);
[PreserveSig] int UnregisterEndpointNotificationCallback(IntPtr client);
}
[ComImport, Guid("0BD7A1BE-7A1A-44DB-8397-CC5392387B5E"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IMMDeviceCollection
{
[PreserveSig] int GetCount(out int count);
[PreserveSig] int Item(int index, out IMMDevice device);
}
[ComImport, Guid("D666063F-1587-4E43-81F1-B948E807363F"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IMMDevice