EonaCat
/
EonaCat.VolumeMixer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed com disposal

This commit is contained in:
Jeroen Saey 2025-09-01 16:00:13 +02:00
parent be67abaf64
commit 6f639622a5
4 changed files with 404 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
EonaCat.VolumeMixer.Tester/Program.cs
View File

@ -15,6 +15,29 @@ class Program
{
try
{
while (true)
{
var input = await volumeMixer.GetAudioDevicesAsync(DataFlow.Input);
var output = await volumeMixer.GetAudioDevicesAsync(DataFlow.Output);
var input2 = await volumeMixer.GetMicrophonesAsync();
foreach (var item in input)
{
item.Dispose();
}
foreach (var item in input2)
{
item.Dispose();
}
foreach (var item in output)
{
item.Dispose();
}
}
// Get all audio PLAYBACK devices
var devices = await volumeMixer.GetAudioDevicesAsync(DataFlow.Output);
Console.WriteLine($"Found {devices.Count} playback devices:");

13
EonaCat.VolumeMixer/Helpers/ComHelper.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
namespace EonaCat.VolumeMixer.Helpers
{
@ -31,12 +32,22 @@ namespace EonaCat.VolumeMixer.Helpers
}
}
public static void ReleaseComObject(object obj)
public static async Task ReleaseComObject(object obj)
{
if (obj != null && Marshal.IsComObject(obj))
{
if (obj == null || !Marshal.IsComObject(obj))
{
return;
}
Marshal.ReleaseComObject(obj);
obj = null;
}
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
}

497
EonaCat.VolumeMixer/Managers/VolumeMixerManager.cs
View File

@ -36,146 +36,123 @@ namespace EonaCat.VolumeMixer.Managers
}
}
public async Task<List<AudioDevice>> GetAudioDevicesAsync(DataFlow dataFlow = DataFlow.Output)
public Task<List<AudioDevice>> GetAudioDevicesAsync(DataFlow dataFlow = DataFlow.Output)
{
return await Task.Run(() =>
var devices = new List<AudioDevice>();
if (_deviceEnumerator == null)
{
var devices = new List<AudioDevice>();
return Task.FromResult(devices);
}
if (_deviceEnumerator == null)
lock (_syncLock)
{
IMultiMediaDeviceCollection deviceCollection = null;
IMultiMediaDevice defaultDevice = null;
try
{
return devices;
}
var result = _deviceEnumerator.EnumAudioEndpoints(dataFlow, DeviceState.Active, out deviceCollection);
if (result != 0 || deviceCollection == null)
{
return Task.FromResult(devices);
}
lock (_syncLock)
{
IMultiMediaDeviceCollection deviceCollection = null;
IMultiMediaDevice defaultDevice = null;
result = deviceCollection.GetCount(out var count);
if (result != 0)
{
return Task.FromResult(devices);
}
string defaultId = "";
try
{
var result = _deviceEnumerator.EnumAudioEndpoints(dataFlow, DeviceState.Active, out deviceCollection);
if (result != 0 || deviceCollection == null)
result = _deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia, out defaultDevice);
if (result == 0 && defaultDevice != null)
{
return devices;
defaultDevice.GetId(out defaultId);
}
}
catch
{
defaultId = "";
}
result = deviceCollection.GetCount(out var count);
if (result != 0)
{
return devices;
}
string defaultId = "";
for (uint i = 0; i < count; i++)
{
IMultiMediaDevice device = null;
try
{
result = _deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia, out defaultDevice);
if (result == 0 && defaultDevice != null)
result = deviceCollection.Item(i, out device);
if (result == 0 && device != null)
{
defaultDevice.GetId(out defaultId);
result = device.GetId(out var id);
if (result == 0 && !string.IsNullOrEmpty(id))
{
var name = GetDeviceName(device);
var type = GetDeviceType(device);
bool isDefault = id == defaultId;
devices.Add(new AudioDevice(device, id, name, isDefault, dataFlow, type));
device = null;
}
}
}
catch
{
defaultId = "";
// Do nothing
}
for (uint i = 0; i < count; i++)
{
IMultiMediaDevice device = null;
try
{
result = deviceCollection.Item(i, out device);
if (result == 0 && device != null)
{
result = device.GetId(out var id);
if (result == 0 && !string.IsNullOrEmpty(id))
{
var name = GetDeviceName(device);
var type = GetDeviceType(device);
bool isDefault = id == defaultId;
devices.Add(new AudioDevice(device, id, name, isDefault, dataFlow, type));
}
}
}
catch
{
// Do nothing
}
finally
{
if (device != null)
{
ComHelper.ReleaseComObject(device);
}
}
}
}
catch
{
// Do nothing
}
finally
{
if (deviceCollection != null)
{
ComHelper.ReleaseComObject(deviceCollection);
}
if (defaultDevice != null)
{
ComHelper.ReleaseComObject(defaultDevice);
}
}
}
return devices;
});
}
public async Task<AudioDevice> GetDefaultAudioDeviceAsync(DataFlow dataFlow = DataFlow.Output)
{
return await Task.Run(() =>
{
if (_deviceEnumerator == null)
{
return null;
}
lock (_syncLock)
{
IMultiMediaDevice device = null;
try
{
var result = _deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia, out device);
if (result == 0 && device != null)
{
result = device.GetId(out var id);
if (result == 0 && !string.IsNullOrEmpty(id))
{
var name = GetDeviceName(device);
var type = GetDeviceType(device);
return new AudioDevice(device, id, name, true, dataFlow, type);
}
}
}
catch
{
// Do nothing
}
finally
{
if (device != null)
finally
{
ComHelper.ReleaseComObject(device);
}
}
return null;
}
});
finally
{
ComHelper.ReleaseComObject(deviceCollection);
ComHelper.ReleaseComObject(defaultDevice);
}
}
return Task.FromResult(devices);
}
public Task<AudioDevice> GetDefaultAudioDeviceAsync(DataFlow dataFlow = DataFlow.Output)
{
if (_deviceEnumerator == null)
{
return Task.FromResult<AudioDevice>(null);
}
lock (_syncLock)
{
IMultiMediaDevice device = null;
try
{
var result = _deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia, out device);
if (result == 0 && device != null)
{
result = device.GetId(out var id);
if (result == 0 && !string.IsNullOrEmpty(id))
{
var name = GetDeviceName(device);
var type = GetDeviceType(device);
var audioDevice = new AudioDevice(device, id, name, true, dataFlow, type);
device = null; // ownership transferred
return Task.FromResult(audioDevice);
}
}
}
finally
{
ComHelper.ReleaseComObject(device);
}
return Task.FromResult<AudioDevice>(null);
}
}
[DllImport("ole32.dll")]
@ -183,7 +160,7 @@ namespace EonaCat.VolumeMixer.Managers
private string GetDeviceName(IMultiMediaDevice device)
{
IPropertyStore? propertyStore = null;
IPropertyStore propertyStore = null;
PropVariant propVariant = new PropVariant();
try
@ -193,33 +170,23 @@ namespace EonaCat.VolumeMixer.Managers
{
var propertyKey = PKEY_Device_FriendlyName;
result = propertyStore.GetValue(ref propertyKey, out propVariant);
if (result == 0)
if (result == 0 &&
(propVariant.vt == (ushort)VarEnum.VT_LPWSTR || propVariant.vt == (ushort)VarEnum.VT_BSTR))
{
// Get string
string name = Marshal.PtrToStringUni(propVariant.data1);
return !string.IsNullOrEmpty(name) ? name : "Unknown Device";
}
}
}
catch
{
// Do nothing
}
finally
{
// Clear memory
PropVariantClear(ref propVariant);
if (propertyStore != null)
{
ComHelper.ReleaseComObject(propertyStore);
}
ComHelper.ReleaseComObject(propertyStore);
}
return "Unknown Device";
}
private DeviceType GetDeviceType(IMultiMediaDevice device)
{
IPropertyStore propertyStore = null;
@ -230,65 +197,49 @@ namespace EonaCat.VolumeMixer.Managers
int result = device.OpenPropertyStore(0, out propertyStore);
if (result == 0 && propertyStore != null)
{
try
{
var propertyKey = PKEY_AudioEndpoint_FormFactor;
result = propertyStore.GetValue(ref propertyKey, out propVariant);
var propertyKey = PKEY_AudioEndpoint_FormFactor;
result = propertyStore.GetValue(ref propertyKey, out propVariant);
// 0x13 == VT_UI4
if (result == 0 && propVariant.vt == 0x13)
if (result == 0 && propVariant.vt == VT_UI4)
{
int formFactor = propVariant.data1.ToInt32();
return formFactor switch
{
int formFactor = propVariant.data1.ToInt32();
return formFactor switch
{
0 => DeviceType.Unknown,
1 => DeviceType.Speakers,
2 => DeviceType.LineLevel,
3 => DeviceType.Headphones,
4 => DeviceType.Microphone,
5 => DeviceType.Headset,
6 => DeviceType.Handset,
7 => DeviceType.UnknownDigitalPassthrough,
8 => DeviceType.SPDIF,
9 => DeviceType.DigitalAudioDisplayDevice,
10 => DeviceType.UnknownFormFactor,
11 => DeviceType.FMRadio,
12 => DeviceType.VideoPhone,
13 => DeviceType.RCA,
14 => DeviceType.Bluetooth,
15 => DeviceType.SPDIFOut,
16 => DeviceType.HDMI,
17 => DeviceType.DisplayAudio,
18 => DeviceType.UnknownFormFactor2,
19 => DeviceType.Other,
_ => DeviceType.Unknown,
};
}
}
finally
{
0 => DeviceType.Unknown,
1 => DeviceType.Speakers,
2 => DeviceType.LineLevel,
3 => DeviceType.Headphones,
4 => DeviceType.Microphone,
5 => DeviceType.Headset,
6 => DeviceType.Handset,
7 => DeviceType.UnknownDigitalPassthrough,
8 => DeviceType.SPDIF,
9 => DeviceType.DigitalAudioDisplayDevice,
10 => DeviceType.UnknownFormFactor,
11 => DeviceType.FMRadio,
12 => DeviceType.VideoPhone,
13 => DeviceType.RCA,
14 => DeviceType.Bluetooth,
15 => DeviceType.SPDIFOut,
16 => DeviceType.HDMI,
17 => DeviceType.DisplayAudio,
18 => DeviceType.UnknownFormFactor2,
19 => DeviceType.Other,
_ => DeviceType.Unknown,
};
}
}
}
catch
{
// Do nothing
}
finally
{
PropVariantClear(ref propVariant);
if (propertyStore != null)
{
ComHelper.ReleaseComObject(propertyStore);
}
ComHelper.ReleaseComObject(propertyStore);
}
return DeviceType.Unknown;
}
public async Task<bool> SetSystemVolumeAsync(float volume)
{
if (volume < 0f || volume > 1f)
@ -296,78 +247,31 @@ namespace EonaCat.VolumeMixer.Managers
return false;
}
AudioDevice defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
using var defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
if (defaultDevice == null)
{
return false;
}
try
{
return await defaultDevice.SetMasterVolumeAsync(volume);
}
finally
{
defaultDevice.Dispose();
}
return await defaultDevice.SetMasterVolumeAsync(volume);
}
public async Task<float> GetSystemVolumeAsync()
{
AudioDevice defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
if (defaultDevice == null)
{
return 0f;
}
try
{
return await defaultDevice.GetMasterVolumeAsync();
}
finally
{
defaultDevice.Dispose();
}
using var defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
return defaultDevice == null ? 0f : await defaultDevice.GetMasterVolumeAsync();
}
public async Task<bool> SetSystemMuteAsync(bool mute)
{
AudioDevice defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
if (defaultDevice == null)
{
return false;
}
try
{
return await defaultDevice.SetMasterMuteAsync(mute);
}
finally
{
defaultDevice.Dispose();
}
using var defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
return defaultDevice != null && await defaultDevice.SetMasterMuteAsync(mute);
}
public async Task<bool> GetSystemMuteAsync()
{
AudioDevice defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
if (defaultDevice == null)
{
return false;
}
try
{
return await defaultDevice.GetMasterMuteAsync();
}
finally
{
defaultDevice.Dispose();
}
using var defaultDevice = await GetDefaultAudioDeviceAsync(DataFlow.Output);
return defaultDevice != null && await defaultDevice.GetMasterMuteAsync();
}
public async Task<bool> SetMicrophoneVolumeAsync(float volume)
@ -377,78 +281,26 @@ namespace EonaCat.VolumeMixer.Managers
return false;
}
AudioDevice defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
if (defaultMic == null)
{
return false;
}
try
{
return await defaultMic.SetMasterVolumeAsync(volume);
}
finally
{
defaultMic.Dispose();
}
using var defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
return defaultMic != null && await defaultMic.SetMasterVolumeAsync(volume);
}
public async Task<float> GetMicrophoneVolumeAsync()
{
AudioDevice defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
if (defaultMic == null)
{
return 0f;
}
try
{
return await defaultMic.GetMasterVolumeAsync();
}
finally
{
defaultMic.Dispose();
}
using var defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
return defaultMic == null ? 0f : await defaultMic.GetMasterVolumeAsync();
}
public async Task<bool> SetMicrophoneMuteAsync(bool mute)
{
AudioDevice defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
if (defaultMic == null)
{
return false;
}
try
{
return await defaultMic.SetMasterMuteAsync(mute);
}
finally
{
defaultMic.Dispose();
}
using var defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
return defaultMic != null && await defaultMic.SetMasterMuteAsync(mute);
}
public async Task<bool> GetMicrophoneMuteAsync()
{
AudioDevice defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
if (defaultMic == null)
{
return false;
}
try
{
return await defaultMic.GetMasterMuteAsync();
}
finally
{
defaultMic.Dispose();
}
using var defaultMic = await GetDefaultAudioDeviceAsync(DataFlow.Input);
return defaultMic != null && await defaultMic.GetMasterMuteAsync();
}
public async Task<bool> SetMicrophoneVolumeByNameAsync(string microphoneName, float volume)
@ -458,20 +310,32 @@ namespace EonaCat.VolumeMixer.Managers
return false;
}
List<AudioDevice> microphones = await GetAudioDevicesAsync(DataFlow.Input);
List<AudioDevice> microphones = null;
foreach (var mic in microphones)
try
{
try
microphones = await GetAudioDevicesAsync(DataFlow.Input);
foreach (var mic in microphones)
{
if (mic.Name.IndexOf(microphoneName, StringComparison.OrdinalIgnoreCase) >= 0)
using (mic)
{
return await mic.SetMasterVolumeAsync(volume);
if (mic.Name.IndexOf(microphoneName, StringComparison.OrdinalIgnoreCase) >= 0)
{
return await mic.SetMasterVolumeAsync(volume);
}
}
}
finally
}
finally
{
// Release all resources
if (microphones != null)
{
mic.Dispose();
foreach (var mic in microphones)
{
mic.Dispose();
}
}
}
@ -480,13 +344,12 @@ namespace EonaCat.VolumeMixer.Managers
public async Task<List<AudioSession>> GetAllActiveSessionsAsync()
{
return await Task.Run(async () =>
var allSessions = new List<AudioSession>();
List<AudioDevice> devices = await GetAudioDevicesAsync(DataFlow.Output);
foreach (var device in devices)
{
var allSessions = new List<AudioSession>();
List<AudioDevice> devices = await GetAudioDevicesAsync(DataFlow.Output);
foreach (var device in devices)
using (device)
{
try
{
@ -496,24 +359,28 @@ namespace EonaCat.VolumeMixer.Managers
{
// Do nothing
}
finally
{
device.Dispose();
}
}
}
return allSessions;
});
// Release resources
foreach (var device in devices)
{
device.Dispose();
}
devices.Clear();
devices = null;
return allSessions;
}
public async Task<List<AudioDevice>> GetMicrophonesAsync()
public Task<List<AudioDevice>> GetMicrophonesAsync()
{
return await GetAudioDevicesAsync(DataFlow.Input);
return GetAudioDevicesAsync(DataFlow.Input);
}
public async Task<AudioDevice> GetDefaultMicrophoneAsync()
public Task<AudioDevice> GetDefaultMicrophoneAsync()
{
return await GetDefaultAudioDeviceAsync(DataFlow.Input);
return GetDefaultAudioDeviceAsync(DataFlow.Input);
}
public void Dispose()

8
EonaCat.VolumeMixer/Models/AudioSession.cs
View File

@ -258,11 +258,9 @@ namespace EonaCat.VolumeMixer.Models
return;
}
if (_audioVolume != null)
{
Marshal.ReleaseComObject(_audioVolume);
_audioVolume = null;
}
Marshal.ReleaseComObject(_audioVolume);
_audioVolume = null;
ComHelper.ReleaseComObject(_sessionControl);
_isDisposed = true;