public void UpdateProcessList()
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDeviceCollection outputDevices = null;
IMMDeviceCollection inputDevices = null;
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, STATE.ACTIVE, out outputDevices);
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eCapture, STATE.ACTIVE, out inputDevices);
uint inputDeviceCount = 0;
uint outputDeviceCount = 0;
inputDevices.GetCount(out inputDeviceCount);
outputDevices.GetCount(out outputDeviceCount);
// Loop over every output device
for (uint i = 0; i < outputDeviceCount; i++)
{
IMMDevice device;
outputDevices.Item(i, out device);
AudioDevice audioDevice = new AudioDevice(device);
Mapper.Mapper.DevicesAndProcesses[audioDevice] = audioDevice.GetAllSessions();
}
}
void RefreshDevices()
{
lock (this)
{
IMMDeviceCollection IMMDeviceCollection;
_IMMDeviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, 0xF, out IMMDeviceCollection);
uint deviceCount = 0;
IMMDeviceCollection.GetCount(out deviceCount);
for (uint n = 0; n < deviceCount; n++)
{
IMMDevice IMMDevice;
IMMDeviceCollection.Item(n, out IMMDevice);
string uid = "";
IMMDevice.GetId(out uid);
if (!_PlaybackDevices.ContainsKey(uid))
{
_PlaybackDevices.Add(uid, new PlaybackDevice_WindowsCoreApi(IMMDevice));
}
}
{
IMMDevice Default;
_IMMDeviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, 0x0, out Default);
string uid = "";
Default.GetId(out uid);
if (!_PlaybackDevices.ContainsKey(uid))
{
_PlaybackDevices.Add(uid, new PlaybackDevice_WindowsCoreApi(Default));
}
_PlaybackDevices[uid]._Default = true;
}
_IMMDeviceEnumerator.EnumAudioEndpoints(EDataFlow.eCapture, 0xF, out IMMDeviceCollection);
deviceCount = 0;
IMMDeviceCollection.GetCount(out deviceCount);
for (uint n = 0; n < deviceCount; n++)
{
IMMDevice IMMDevice;
IMMDeviceCollection.Item(n, out IMMDevice);
string uid = "";
IMMDevice.GetId(out uid);
if (!_RecordingDevices.ContainsKey(uid))
{
_RecordingDevices.Add(uid, new RecordingDevice_WindowsCoreApi(IMMDevice));
}
}
}
}
public AudioDeviceCollection GetAudioDevices(AudioDeviceKind kind, AudioDeviceState state)
{
IMMDeviceCollection result;
Marshal.ThrowExceptionForHR(_underlyingEnumerator.EnumAudioEndpoints(kind, state, out result));
return(new AudioDeviceCollection(result));
}
private IEnumerable <MMDevice> GetAllDevices(IMMDeviceEnumerator deviceEnumerator, DeviceStates deviceStates)
{
// Collect default devices
var communicationPlaybackId = GetDefaultDeviceId(deviceEnumerator, DataFlows.Render, DeviceRoles.Communication);
var communicationRecordingId = GetDefaultDeviceId(deviceEnumerator, DataFlows.Capture, DeviceRoles.Communication);
var multimediaPlaybackId = GetDefaultDeviceId(deviceEnumerator, DataFlows.Render, DeviceRoles.Multimedia);
var multimediaRecordingId = GetDefaultDeviceId(deviceEnumerator, DataFlows.Capture, DeviceRoles.Multimedia);
IMMDeviceCollection deviceCollection;
Marshal.ThrowExceptionForHR(deviceEnumerator.EnumAudioEndpoints(DataFlows.All, deviceStates, out deviceCollection));
uint count;
Marshal.ThrowExceptionForHR(deviceCollection.GetCount(out count));
for (uint i = 0; i < count; i++)
{
IMMDevice result;
deviceCollection.Item(i, out result);
var mmDevice = new MMDevice(result,
(int)i + 1,
communicationPlaybackId,
communicationRecordingId,
multimediaPlaybackId,
multimediaRecordingId);
yield return(mmDevice);
}
}
private static bool IsAudioInputDevice(string deviceId)
{
IMMDeviceCollection deviceCollection;
IMMDevice device;
string id;
bool result = false;
uint count;
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eCapture, (uint)DeviceState.All, out deviceCollection);
deviceCollection.GetCount(out count);
Marshal.ReleaseComObject(deviceEnumerator);
for (uint i = 0; i < count; i++)
{
deviceCollection.Item(i, out device);
device.GetId(out id);
Marshal.ReleaseComObject(device);
if (deviceId == id)
{
result = true;
break;
}
}
if (deviceCollection != null)
{
Marshal.ReleaseComObject(deviceCollection);
}
return(result);
}
/// <summary>
/// Enumerate Audio Endpoints
/// </summary>
/// <param name="dataFlow">Desired DataFlow</param>
/// <param name="dwStateMask">State Mask</param>
/// <returns>Device Collection</returns>
public IReadOnlyCollection <DeviceFullInfo> EnumerateAudioEndPoints(EDataFlow dataFlow, DeviceState dwStateMask)
{
IMMDeviceCollection result;
Marshal.ThrowExceptionForHR(_realEnumerator.EnumAudioEndpoints(dataFlow, dwStateMask, out result));
return(CreateDeviceList(new MMDeviceCollection(result)));
}
/// <summary>
/// Returns a list of the system's enabled audio output devices. Returns null if no enabled audio output devices are present. See also: Player.Audio.DeviceCount and Player.Audio.GetDefaultDevice.
/// </summary>
public AudioDevice[] GetDevices()
{
AudioDevice[] audioDevices = null;
_base._lastError = HResult.MF_E_NO_AUDIO_PLAYBACK_DEVICE;
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, (uint)DeviceState.Active, out IMMDeviceCollection deviceCollection);
Marshal.ReleaseComObject(deviceEnumerator);
if (deviceCollection != null)
{
deviceCollection.GetCount(out uint count);
if (count > 0)
{
audioDevices = new AudioDevice[count];
for (int i = 0; i < count; i++)
{
audioDevices[i] = new AudioDevice();
deviceCollection.Item((uint)i, out IMMDevice device);
Player.GetDeviceInfo(device, audioDevices[i]);
Marshal.ReleaseComObject(device);
}
_base._lastError = Player.NO_ERROR;
}
Marshal.ReleaseComObject(deviceCollection);
}
return(audioDevices);
}
public MMDeviceCollection EnumerateAudioEndPoints(EDataFlow dataFlow, EDeviceState dwStateMask)
{
IMMDeviceCollection result;
Marshal.ThrowExceptionForHR(_realEnumerator.EnumAudioEndpoints(dataFlow, dwStateMask, out result));
return(new MMDeviceCollection(result));
}
/// <summary>
/// Gets a collection of available devices.
/// </summary>
/// <param name="dataFlow">The data flow.</param>
/// <returns>A collection of available devices matching the supplied role.</returns>
internal static IMMDeviceCollection GetAvailableDevices(EDataFlow dataFlow)
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
IMMDeviceCollection deviceCollection = deviceEnumerator.EnumAudioEndpoints(dataFlow, DeviceStateActive);
Marshal.ReleaseComObject(deviceEnumerator);
return(deviceCollection);
}
/// <summary>
/// Constructor
/// </summary>
public Volume()
{
const uint CLSCTX_INPROC_SERVER = 1;
Guid clsid = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");
Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046");
oEnumerator = null;
uint hResult = CoCreateInstance(ref clsid, null, CLSCTX_INPROC_SERVER, ref IID_IUnknown, out oEnumerator);
if (hResult != 0 || oEnumerator == null)
{
throw new Exception("CoCreateInstance() pInvoke failed");
}
iMde = oEnumerator as IMMDeviceEnumerator;
if (iMde == null)
{
throw new Exception("COM cast failed to IMMDeviceEnumerator");
}
IntPtr pDevice = IntPtr.Zero;
int retVal = iMde.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole, ref pDevice);
if (retVal != 0)
{
throw new Exception("IMMDeviceEnumerator.GetDefaultAudioEndpoint()");
}
int dwStateMask = DEVICE_STATE_ACTIVE | DEVICE_STATE_NOTPRESENT | DEVICE_STATE_UNPLUGGED;
IntPtr pCollection = IntPtr.Zero;
retVal = iMde.EnumAudioEndpoints(EDataFlow.eRender, dwStateMask, ref pCollection);
if (retVal != 0)
{
throw new Exception("IMMDeviceEnumerator.EnumAudioEndpoints()");
}
oDevice = System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(pDevice);
imd = oDevice as IMMDevice;
if (imd == null)
{
throw new Exception("COM cast failed to IMMDevice");
}
Guid iid = new Guid("5CDF2C82-841E-4546-9722-0CF74078229A");
uint dwClsCtx = (uint)CLSCTX.CLSCTX_ALL;
IntPtr pActivationParams = IntPtr.Zero;
IntPtr pEndPoint = IntPtr.Zero;
retVal = imd.Activate(ref iid, dwClsCtx, pActivationParams, ref pEndPoint);
if (retVal != 0)
{
throw new Exception("IMMDevice.Activate()");
}
oEndPoint = System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(pEndPoint);
iAudioEndpoint = oEndPoint as IAudioEndpointVolume;
if (iAudioEndpoint == null)
{
throw new Exception("COM cast failed to IAudioEndpointVolume");
}
}
// Lists all devices, and for each device all processes that are currently playing sound using that device
public static List <SoundInfoDevice> getSoundInfo()
{
List <SoundInfoDevice> soundInfoDevices = new List <SoundInfoDevice>();
DeviceEnumerator enumerator = new DeviceEnumerator();
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)enumerator;
IMMDeviceCollection deviceCollection = deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, DeviceStatemask.DEVICE_STATE_ACTIVE);
uint deviceCount = deviceCollection.GetCount();
for (uint i = 0; i < deviceCount; i++)
{
SoundInfoDevice soundInfoDevice = new SoundInfoDevice();
soundInfoDevices.Add(soundInfoDevice);
IMMDevice device = deviceCollection.Item(i);
string deviceId = device.GetId();
soundInfoDevice.ID = deviceId;
IMMPropertyStore propertyStore = device.OpenPropertyStore(ProperyStoreMode.STGM_READ);
PropertyKey propertyKeyDeviceDesc = new PropertyKey();
propertyKeyDeviceDesc.fmtid = new Guid(0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0);
propertyKeyDeviceDesc.pid = 2;
PropVariant deviceNamePtr = propertyStore.GetValue(ref propertyKeyDeviceDesc);
string deviceName = Marshal.PtrToStringUni(deviceNamePtr.pszVal);
soundInfoDevice.name = deviceName;
Guid guidAudioSessionManager2 = new Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F");
IAudioSessionManager2 audioSessionManager = (IAudioSessionManager2)device.Activate(ref guidAudioSessionManager2, (int)ClsCtx.CLSCTX_ALL, IntPtr.Zero);
IAudioSessionEnumerator sessionEnumerator = audioSessionManager.GetSessionEnumerator();
int sessionCount = sessionEnumerator.GetCount();
for (int j = 0; j < sessionCount; j++)
{
IAudioSessionControl audioSessionControl = sessionEnumerator.GetSession(j);
IAudioSessionControl2 audioSessionControl2 = (IAudioSessionControl2)audioSessionControl;
AudioSessionState state = audioSessionControl.GetState();
if (state == AudioSessionState.AudioSessionStateActive)
{
SoundInfoSession soundInfoSession = new SoundInfoSession();
soundInfoDevice.sessions.Add(soundInfoSession);
string displayName = audioSessionControl.GetDisplayName();
string iconPath = audioSessionControl.GetIconPath();
int processId = audioSessionControl2.GetProcessId();
string processName = Process.GetProcessById(processId).MainWindowTitle;
soundInfoSession.pid = processId;
soundInfoSession.windowName = processName;
}
}
}
return(soundInfoDevices);
}
public AudioDeviceCollection GetAudioDevices(AudioDeviceKind kind, AudioDeviceState state)
{
int hr = _deviceEnumerator.EnumAudioEndpoints(kind, state, out IMMDeviceCollection underlyingCollection);
if (hr == HResult.OK)
{
return(new AudioDeviceCollection(underlyingCollection));
}
throw Marshal.GetExceptionForHR(hr);
}
public static ISimpleAudioVolume GetVolumeObject(int pid)
{
// Get the speakers (1st render + multimedia) device
// ReSharper disable once SuspiciousTypeConversion.Global
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.ERender, ERole.EMultimedia, out IMMDevice speakers);
speakers.GetId(out string defaultDeviceId);
ISimpleAudioVolume volumeControl = GetVolumeObject(pid, speakers);
Marshal.ReleaseComObject(speakers);
if (volumeControl == null)
{
// If volumeControl is null, then the process's volume object might be on a different device.
// This happens if the process doesn't use the default device.
//
// As far as Spotify is concerned, if using the "--enable-audio-graph" command line argument,
// a new option becomes available in the Settings that makes it possible to change the playback device.
deviceEnumerator.EnumAudioEndpoints(EDataFlow.ERender, EDeviceState.Active, out IMMDeviceCollection deviceCollection);
deviceCollection.GetCount(out int count);
for (int i = 0; i < count; i++)
{
deviceCollection.Item(i, out IMMDevice device);
device.GetId(out string deviceId);
try
{
if (deviceId == defaultDeviceId)
{
continue;
}
volumeControl = GetVolumeObject(pid, device);
if (volumeControl != null)
{
break;
}
}
finally
{
Marshal.ReleaseComObject(device);
}
}
}
Marshal.ReleaseComObject(deviceEnumerator);
return(volumeControl);
}
/// <summary>
/// Returns true if an active microphone session is found.
/// </summary>
public bool IsAnyMicInUse()
{
IMMDeviceEnumerator deviceEnumerator = null;
IMMDeviceCollection microphoneCollection = null;
try
{
deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eCapture, DEVICE_STATE_XXX.DEVICE_STATE_ACTIVE, out microphoneCollection);
microphoneCollection.GetCount(out uint microphoneCount);
for (uint i = 0; i < microphoneCount; i++)
{
IMMDevice microphone = null;
try
{
microphoneCollection.Item(i, out microphone);
if (microphoneHasActiveSession(microphone))
{
return(true);
}
}
finally
{
if (microphone != null)
{
Marshal.ReleaseComObject(microphone);
}
}
}
}
finally
{
if (microphoneCollection != null)
{
Marshal.ReleaseComObject(microphoneCollection);
}
if (deviceEnumerator != null)
{
Marshal.ReleaseComObject(deviceEnumerator);
}
}
return(false);
}
private void RefreshSystemDevices()
{
ComThread.Invoke(() =>
{
_deviceCache = new HashSet <CoreAudioDevice>();
IMMDeviceCollection collection;
_innerEnumerator.EnumAudioEndpoints(EDataFlow.All, EDeviceState.All, out collection);
using (var coll = new MMDeviceCollection(collection))
{
foreach (var mDev in coll)
{
CacheDevice(mDev);
}
}
});
}
public static IEnumerable <IMMDevice> CreateIMMDeviceCollection(IMMDeviceEnumerator deviceEnumerator, EDataFlow direction = EDataFlow.eAll, DEVICE_STATE stateMasks = DEVICE_STATE.DEVICE_STATEMASK_ALL)
{
using var deviceCollection = ComReleaserFactory.Create(deviceEnumerator.EnumAudioEndpoints(direction, stateMasks));
var deviceList = new List <IMMDevice>();
var cnt = deviceCollection.Item.GetCount();
if (cnt == 0)
{
Assert.Inconclusive("No devices were found.");
}
for (uint i = 0; i < cnt; i++)
{
deviceCollection.Item.Item(i, out var dev).ThrowIfFailed();
deviceList.Add(dev);
}
return(deviceList);
}
/// <summary>
/// tries to get an IMMDevice by its PKEY_DEVICE_FRIENDLY_NAME
/// </summary>
/// <param name="pDeviceFriendlyName">PKEY_DEVICE_FRIENDLY_NAME of sound output device</param>
/// <returns>true if succesful, false if not</returns>
private static IMMDevice GetIMMDeviceByName(string pDeviceFriendlyName)
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDeviceCollection deviceCollection;
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, EDeviceState.Active, out deviceCollection);
IMMDevice targetDevice = null;
uint deviceCount;
deviceCollection.GetCount(out deviceCount);
for (uint i = 0; i < deviceCount; i++)
{
IMMDevice device;
deviceCollection.Item(i, out device);
IPropertyStore propertyStore;
device.OpenPropertyStore(StorageAccessMode.Read, out propertyStore);
PropertyKey propertyKey = PropertyKeys.PKEY_DEVICE_FRIENDLY_NAME;
PropVariant propVariant;
propertyStore.GetValue(ref propertyKey, out propVariant);
object propValue = propVariant.Value;
if (propValue.ToString() == pDeviceFriendlyName)
{
targetDevice = device;
Marshal.ReleaseComObject(propertyStore);
break;
}
Marshal.ReleaseComObject(device);
Marshal.ReleaseComObject(propertyStore);
}
Marshal.ReleaseComObject(deviceEnumerator);
Marshal.ReleaseComObject(deviceCollection);
return(targetDevice);
}
public AudioDeviceManager(AudioDeviceKind kind)
{
_kind = kind;
_dispatcher = Dispatcher.CurrentDispatcher;
_devices = new AudioDeviceCollection();
_policyConfigService = new AudioPolicyConfigService(Flow);
TraceLine($"Create");
Task.Factory.StartNew(() =>
{
try
{
_enumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
_enumerator.RegisterEndpointNotificationCallback(this);
var devices = _enumerator.EnumAudioEndpoints(Flow, DeviceState.ACTIVE);
uint deviceCount = devices.GetCount();
for (uint i = 0; i < deviceCount; i++)
{
((IMMNotificationClient)this).OnDeviceAdded(devices.Item(i).GetId());
}
_dispatcher.Invoke((Action)(() =>
{
QueryDefaultDevice();
Loaded?.Invoke(this, null);
}));
}
catch (Exception ex)
{
// Even through we're going to be broken, show the tray icon so the user can collect debug data.
AppTrace.LogWarning(ex);
_dispatcher.Invoke((Action)(() =>
{
Loaded?.Invoke(this, null);
}));
}
});
TraceLine($"Create Exit");
}
/// <summary>
/// Get HID Audio Device UUID
/// </summary>
/// <param name="dataFlow"></param>
/// <param name="pid"></param>
/// <param name="vid"></param>
/// <returns></returns>
private string GetHIDAudioDeviceUUID(AudioDataFlow dataFlow, string pid, string vid)
{
COMResult result = COMResult.E_FAIL;
PropertyKey proKey;
PropVariant proVar;
result = _deviceEnumerator.EnumAudioEndpoints(dataFlow, AudioDeviceState.DEVICE_STATE_ACTIVE, out IMMDeviceCollection devCollect);
result = devCollect.GetCount(out int devCnt);
for (int i = 0; i < devCnt; i++)
{
result = devCollect.Item(i, out IMMDevice tDev);
tDev.GetId(out string devID);
tDev.OpenPropertyStore(StorageAccessMode.STGM_READ, out IPropertyStore ppt);
ppt.GetCount(out int ppCnt);
for (int j = 0; j < ppCnt; j++)
{
result = ppt.GetAt(j, out proKey);
result = ppt.GetValue(ref proKey, out proVar);
if (proVar.DataType == System.Runtime.InteropServices.VarEnum.VT_LPWSTR ||
proVar.DataType == System.Runtime.InteropServices.VarEnum.VT_LPSTR)
{
if (proKey.formatId.ToString().Equals(PKEY_AUDIOENDPOINT_HWID.formatId.ToString()) &&
proKey.propertyId == PKEY_AUDIOENDPOINT_HWID.propertyId)
{
string hwID = proVar.Value.ToString();
if (!GetPIDVIDFromHWIDString(hwID, out string hwPid, out string hwVid))
{
continue;
}
if (vid.Equals(hwVid, StringComparison.CurrentCultureIgnoreCase) &&
pid.Equals(hwPid, StringComparison.CurrentCultureIgnoreCase))
{
return(devID);
}
}
}
}
}
return(string.Empty);
}
public static IList <AudioDevice> GetAllDevices()
{
List <AudioDevice> list = new List <AudioDevice>();
IMMDeviceEnumerator deviceEnumerator = null;
try
{
deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
}
catch
{
}
if (deviceEnumerator == null)
{
return(list);
}
IMMDeviceCollection collection;
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eAll, DEVICE_STATE.MASK_ALL, out collection);
if (collection == null)
{
return(list);
}
int count;
collection.GetCount(out count);
for (int i = 0; i < count; i++)
{
IMMDevice dev;
collection.Item(i, out dev);
if (dev != null)
{
list.Add(CreateDevice(dev));
}
}
return(list);
}
//Get all the playback audio devices
public static List <AudioDeviceSummary> ListAudioDevices()
{
try
{
List <AudioDeviceSummary> deviceListSummary = new List <AudioDeviceSummary>();
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
IMMDeviceCollection deviceCollection = deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, DeviceState.ACTIVE);
uint deviceCount = deviceCollection.GetCount();
for (uint deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
{
IMMDevice.IMMDevice deviceItem = deviceCollection.Item(deviceIndex);
//Get the audio device id
string deviceId = deviceItem.GetId();
//Get the audio device name
PropertyVariant propertyVariant = new PropertyVariant();
IPropertyStore propertyStore = deviceItem.OpenPropertyStore(STGM.STGM_READ);
propertyStore.GetValue(ref PKEY_Device_FriendlyName, out propertyVariant);
string deviceName = Marshal.PtrToStringUni(propertyVariant.pwszVal);
//Add device to summary list
deviceListSummary.Add(new AudioDeviceSummary()
{
Identifier = deviceId, Name = deviceName
});
}
return(deviceListSummary);
}
catch
{
Debug.WriteLine("Failed to get audio devices.");
return(null);
}
}
public AudioDeviceManager(Dispatcher dispatcher)
{
Trace.WriteLine("AudioDeviceManager Create");
_dispatcher = dispatcher;
_devices = new AudioDeviceCollection();
_policyConfigService = new AudioPolicyConfigService();
Task.Factory.StartNew(() =>
{
try
{
_enumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
_enumerator.RegisterEndpointNotificationCallback(this);
var devices = _enumerator.EnumAudioEndpoints(EDataFlow.eRender, DeviceState.ACTIVE);
uint deviceCount = devices.GetCount();
for (uint i = 0; i < deviceCount; i++)
{
((IMMNotificationClient)this).OnDeviceAdded(devices.Item(i).GetId());
}
// Trigger default logic to register for volume change
_dispatcher.BeginInvoke((Action)(() =>
{
QueryDefaultPlaybackDevice();
Loaded?.Invoke(this, null);
}));
}
catch (Exception ex) when(ex.Is(Error.AUDCLNT_E_DEVICE_INVALIDATED))
{
// Expected in some cases.
}
});
Trace.WriteLine("AudioDeviceManager Create Exit");
}
internal WasApiAudioContext(IMMDeviceEnumerator enumerator)
{
_enumerator = enumerator;
int error = _enumerator.EnumAudioEndpoints(DataFlow.Render, DeviceState.Active, out IMMDeviceCollection collection);
if (error != 0)
{
Win32Platform.CheckError("Couldn't detect audio devices.", true);
return;
}
// Get initial devices.
error = collection.GetCount(out int count);
if (error != 0)
{
Win32Platform.CheckError("Couldn't detect the number of audio devices.", true);
return;
}
for (var i = 0; i < count; i++)
{
error = collection.Item(i, out IMMDevice device);
if (error != 0)
{
Win32Platform.CheckError($"Couldn't retrieve audio device of index {i}.");
continue;
}
ParseDevice(device);
}
// Find the default device.
SetDefaultDevice();
// Register to audio device events.
_enumerator.RegisterEndpointNotificationCallback(this);
}
private void SystemDevicesChangedHandler(object sender, SystemAudioDevicesEventArgs e)
{
if (e.IsInputDevice)
{
return;
}
IMMDeviceCollection deviceCollection;
uint count;
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
deviceEnumerator.EnumAudioEndpoints(EDataFlow.eRender, (uint)DeviceState.Active, out deviceCollection);
deviceCollection.GetCount(out count);
Marshal.ReleaseComObject(deviceEnumerator);
if (deviceCollection != null)
{
Marshal.ReleaseComObject(deviceCollection);
}
if (e._notification == SystemAudioDevicesNotification.Activated)
{
if (count == 1)
{
if (_playing && !_paused)
{
// cannot resume playback
//if (pm_HasPeakMeter)
//{
// PeakMeter_Open(_audioDevice, true);
//}
// maybe this
Control control = _display;
if (control == null)
{
FormCollection forms = Application.OpenForms;
if (forms != null && forms.Count > 0)
{
control = forms[0];
}
}
if (control != null)
{
control.BeginInvoke(new MethodInvoker(delegate { AV_UpdateTopology(); }));
}
}
if (_mediaAudioDeviceChanged != null)
{
_mediaAudioDeviceChanged(this, EventArgs.Empty);
}
}
}
else if (_audioDevice == null)
{
if (pm_HasPeakMeter && e._notification == SystemAudioDevicesNotification.DefaultChanged)
{
if (count != 0)
{
PeakMeter_Open(_audioDevice, true);
}
else
{
pm_PeakMeterChannelCount = 0;
}
if (_mediaAudioDeviceChanged != null)
{
_mediaAudioDeviceChanged(this, EventArgs.Empty);
}
}
}
else
{
if (e._deviceId == _audioDevice.Id && (e._notification == SystemAudioDevicesNotification.Removed || e._notification == SystemAudioDevicesNotification.Disabled))
{
if (count != 0)
{
_audioDevice = null;
if (pm_HasPeakMeter)
{
PeakMeter_Open(_audioDevice, true);
}
}
else
{
pm_PeakMeterChannelCount = 0;
}
if (_mediaAudioDeviceChanged != null)
{
_mediaAudioDeviceChanged(this, EventArgs.Empty);
}
}
}
}
/// <summary>
/// Enumerate Audio Endpoints
/// </summary>
/// <param name="dataFlow">Desired DataFlow</param>
/// <param name="dwStateMask">State Mask</param>
/// <returns>Device Collection</returns>
public MMDeviceCollection EnumerateAudioEndPoints(DataFlow dataFlow, DeviceState stateMask)
{
Marshal.ThrowExceptionForHR(_mmDeviceEnumerator.EnumAudioEndpoints(dataFlow, stateMask, out var result));
return(new MMDeviceCollection(result));
}
public void EnumAudioEndpoints(DataFlow dataFlow, DeviceState deviceStates, out IMMDeviceCollection devices)
{
_inner.EnumAudioEndpoints(dataFlow, deviceStates, out devices);
}
//public event MixerChangedEventHandler MixerChanged;
#region Class Constructor and Dispose public methods
/// <summary>
/// Constructor
/// </summary>
public EndpointVolume()
{
const uint CLSCTX_INPROC_SERVER = 1;
Guid clsid = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");
Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046");
oEnumerator = null;
uint hResult = CoCreateInstance(ref clsid, null, CLSCTX_INPROC_SERVER, ref IID_IUnknown, out oEnumerator);
if (hResult != 0 || oEnumerator == null)
{
throw new Exception("CoCreateInstance() pInvoke failed");
}
iMde = oEnumerator as IMMDeviceEnumerator;
if (iMde == null)
{
throw new Exception("COM cast failed to IMMDeviceEnumerator");
}
IntPtr pDevice = IntPtr.Zero;
int retVal = iMde.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole, ref pDevice);
if (retVal != 0)
{
throw new Exception("IMMDeviceEnumerator.GetDefaultAudioEndpoint()");
}
int dwStateMask = DEVICE_STATE_ACTIVE | DEVICE_STATE_NOTPRESENT | DEVICE_STATE_UNPLUGGED;
IntPtr pCollection = IntPtr.Zero;
retVal = iMde.EnumAudioEndpoints(EDataFlow.eRender, dwStateMask, ref pCollection);
if (retVal != 0)
{
throw new Exception("IMMDeviceEnumerator.EnumAudioEndpoints()");
}
oDevice = System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(pDevice);
imd = oDevice as IMMDevice;
if (imd == null)
{
throw new Exception("COM cast failed to IMMDevice");
}
Guid iid = new Guid("5CDF2C82-841E-4546-9722-0CF74078229A");
uint dwClsCtx = (uint)CLSCTX.CLSCTX_ALL;
IntPtr pActivationParams = IntPtr.Zero;
IntPtr pEndPoint = IntPtr.Zero;
retVal = imd.Activate(ref iid, dwClsCtx, pActivationParams, ref pEndPoint);
if (retVal != 0)
{
throw new Exception("IMMDevice.Activate()");
}
oEndPoint = System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(pEndPoint);
iAudioEndpoint = oEndPoint as IAudioEndpointVolume;
if (iAudioEndpoint == null)
{
throw new Exception("COM cast failed to IAudioEndpointVolume");
}
/*
delMixerChange = new DelegateMixerChange(MixerChange);
retVal = iAudioEndpoint.RegisterControlChangeNotify(delMixerChange);
if (retVal != 0)
{
throw new Exception("iAudioEndpoint.RegisterControlChangeNotify(delMixerChange)");
}
*/
}
