private static ISimpleAudioVolume GetVolumeObject(string name)
{
IMMDeviceEnumerator devices = (IMMDeviceEnumerator) new MMDeviceEnumerator();
IMMDevice device = devices.GetDefaultAudioEndpoint(EDATAFLOW_RENDER, EROLE_MULTIMEDIA);
Guid sessionManagerGUID = typeof(IAudioSessionManager2).GUID;
IAudioSessionManager2 manager = (IAudioSessionManager2)device.Activate(ref sessionManagerGUID, 0, IntPtr.Zero);
IAudioSessionEnumerator sessions = manager.GetSessionEnumerator();
ISimpleAudioVolume volumeObj = null;
for (int index = sessions.GetCount() - 1; index >= 0; index--)
{
IAudioSessionControl2 ctl = sessions.GetSession(index) as IAudioSessionControl2;
if (ctl != null)
{
string identifier = ctl.GetSessionIdentifier();
if (identifier != null && identifier.Contains(name))
{
volumeObj = ctl as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
}
}
Marshal.ReleaseComObject(devices);
Marshal.ReleaseComObject(device);
Marshal.ReleaseComObject(manager);
Marshal.ReleaseComObject(sessions);
return(volumeObj);
}
internal AudioSessionManager(IAudioSessionManager2 realAudioSessionManager)
{
_AudioSessionManager = realAudioSessionManager;
IAudioSessionEnumerator _SessionEnum ;
Marshal.ThrowExceptionForHR(_AudioSessionManager.GetSessionEnumerator(out _SessionEnum));
_Sessions = new SessionCollection(_SessionEnum);
}
public static IEnumerable<string> EnumerateApplications()
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
string dn;
ctl.GetDisplayName(out dn);
yield return dn;
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
}
// Get an enumerator of all the current audio sessions from a session manager
public static IAudioSessionEnumerator GetAudioSessionEnumerator(IAudioSessionManager2 manager)
{
IAudioSessionEnumerator sessionEnumerator;
manager.GetSessionEnumerator(out sessionEnumerator);
return(sessionEnumerator);
}
internal AudioSessionManager(IAudioSessionManager2 realAudioSessionManager)
{
IAudioSessionEnumerator _SessionEnum;
Marshal.ThrowExceptionForHR(realAudioSessionManager.GetSessionEnumerator(out _SessionEnum));
_Sessions = new SessionCollection(_SessionEnum);
}
public IList<AudioProcess> GetAllSessions()
{
IAudioSessionManager2 mgr = GetDeviceManager();
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
IList<AudioProcess> processes = new List<AudioProcess>();
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
if (ctl == null)
continue;
IAudioSessionControl2 ctl2 = ctl as IAudioSessionControl2;
if (ctl2 != null)
{
processes.Add(new AudioProcess(this, ctl2));
}
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
return processes;
}
private bool microphoneHasActiveSession(IMMDevice microphone)
{
IAudioSessionManager2 sessionManager2 = null;
IAudioSessionEnumerator sessionEnumerator = null;
try
{
sessionManager2 = activateMicSessionManager(microphone);
sessionManager2.GetSessionEnumerator(out sessionEnumerator);
sessionEnumerator.GetCount(out int sessionCount);
for (int i = 0; i < sessionCount; i++)
{
if (sessionIsActive(sessionEnumerator, i))
{
return(true);
}
}
}
finally
{
if (sessionEnumerator != null)
{
Marshal.ReleaseComObject(sessionEnumerator);
}
if (sessionManager2 != null)
{
Marshal.ReleaseComObject(sessionManager2);
}
}
return(false);
}
private void RefreshSessions()
{
IAudioSessionEnumerator enumerator;
_audioSessionManager.GetSessionEnumerator(out enumerator);
if (enumerator == null)
{
return;
}
int count;
enumerator.GetCount(out count);
_sessionCache = new List <CoreAudioSession>(count);
for (var i = 0; i < count; i++)
{
IAudioSessionControl session;
enumerator.GetSession(i, out session);
var managedSession = CacheSessionWrapper(session);
OnSessionCreated(managedSession);
}
}
public AudioDeviceSessionCollection(IAudioDevice parent, IMMDevice device)
{
Trace.WriteLine($"AudioDeviceSessionCollection Create dev={device.GetId()}");
_parent = new WeakReference <IAudioDevice>(parent);
_dispatcher = App.Current.Dispatcher;
Task.Factory.StartNew(() =>
{
try
{
_sessionManager = device.Activate <IAudioSessionManager2>();
_sessionManager.RegisterSessionNotification(this);
var enumerator = _sessionManager.GetSessionEnumerator();
int count = enumerator.GetCount();
for (int i = 0; i < count; i++)
{
CreateAndAddSession(enumerator.GetSession(i));
}
}
catch (Exception ex)
{
Trace.TraceError($"{ex}");
}
});
}
private static IAudioSessionEnumerator GetOutputDeviceSessionEnumerator(IAudioSessionManager2 manager)
{
IAudioSessionEnumerator sessionEnumerator;
manager.GetSessionEnumerator(out sessionEnumerator);
return(sessionEnumerator);
}
public VolumeMaster()
{
// get the speakers (1st render + multimedia) device
List <AudioSession> list = new List <AudioSession>();
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
IMMDevice speakers;
IMMDevice SPDIF;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out SPDIF);
Guid GUID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
Guid GUID_IAudioEndpointVolume = typeof(IAudioEndpointVolume).GUID;
object o;
object o2;
int i1 = speakers.Activate(ref GUID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
int i2 = SPDIF.Activate(ref GUID_IAudioEndpointVolume, 0, IntPtr.Zero, out o2);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
audioEndpointVolume = (IAudioEndpointVolume)o2;
if (mgr == null)
{
Sessions = list;
return;
}
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
if (ctl == null)
{
continue;
}
IAudioSessionControl2 ctl2 = ctl as IAudioSessionControl2;
if (ctl2 != null)
{
list.Add(new AudioSession(ctl2));
}
}
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Sessions = list;
}
private static ISimpleAudioVolume GetVolumeObject(int pid)
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
// search for an audio session with the required name
// NOTE: we could also use the process id instead of the app name (with IAudioSessionControl2)
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
var processName = Process.GetProcessById(cpid).ProcessName;
Console.WriteLine(processName);
}
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
if (cpid == pid)
{
volumeControl = ctl as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(volumeControl);
}
// 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);
}
private static ISimpleAudioVolume GetVolumeObject(int pid)
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
// search for an audio session with the required pid
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
IAudioSessionControl2 ctl2 = ctl as IAudioSessionControl2;
//uint pid;
//ctl2.GetProcessId(out pid);
//Process p = Process.GetProcessById((int)pid);
// ctl2.SetDisplayName(p.ProcessName, Guid.Empty);
uint npid;
ctl2.GetProcessId(out npid);
if (pid == npid)
{
volumeControl = ctl2 as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
Marshal.ReleaseComObject(ctl2);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(volumeControl);
}
/// <summary>
/// Queries the volume controller for the process
/// </summary>
/// <returns>True if found</returns>
public bool Query()
{
if (!isSupported)
{
return(false);
}
IAudioSessionEnumerator sessionEnumerator = null;
try
{
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
if (cpid == processId)
{
volume = ctl as ISimpleAudioVolume;
return(true);
}
Marshal.ReleaseComObject(ctl);
}
}
finally
{
if (sessionEnumerator != null)
{
Marshal.ReleaseComObject(sessionEnumerator);
}
}
return(false);
}
public void RefreshSessions()
{
UnregisterNotifications();
IAudioSessionEnumerator _SessionEnum;
Marshal.ThrowExceptionForHR(_AudioSessionManager2.GetSessionEnumerator(out _SessionEnum));
_Sessions = new SessionCollection(_SessionEnum);
_AudioSessionNotification = new AudioSessionNotification(this);
Marshal.ThrowExceptionForHR(_AudioSessionManager2.RegisterSessionNotification(_AudioSessionNotification));
}
private void AdjustMixerVolume()
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
IMMDevice ppDevice;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole, out ppDevice);
Guid guid = typeof(IAudioSessionManager2).GUID;
object ppInterface;
ppDevice.Activate(ref guid, 0, IntPtr.Zero, out ppInterface);
IAudioSessionManager2 audioSessionManager2 = (IAudioSessionManager2)ppInterface;
IAudioSessionEnumerator SessionEnum;
audioSessionManager2.GetSessionEnumerator(out SessionEnum);
int SessionCount1;
SessionEnum.GetCount(out SessionCount1);
List <ISimpleAudioVolume> list = new List <ISimpleAudioVolume>();
for (int SessionCount2 = 0; SessionCount2 < SessionCount1; ++SessionCount2)
{
IAudioSessionControl2 Session;
SessionEnum.GetSession(SessionCount2, out Session);
ulong pRetVal;
Session.GetProcessId(out pRetVal);
if ((long)pRetVal == (long)Process.GetCurrentProcess().Id)
{
list.Add(Session as ISimpleAudioVolume);
}
}
float fLevel = 1f;
foreach (ISimpleAudioVolume simpleAudioVolume in list)
{
float pfLevel;
simpleAudioVolume.GetMasterVolume(out pfLevel);
if ((double)fLevel > (double)pfLevel)
{
fLevel = pfLevel;
}
}
foreach (ISimpleAudioVolume simpleAudioVolume in list)
{
Guid EventContext = Guid.Empty;
simpleAudioVolume.SetMasterVolume(fLevel, ref EventContext);
Marshal.ReleaseComObject(simpleAudioVolume);
}
Marshal.ReleaseComObject(SessionEnum);
Marshal.ReleaseComObject(audioSessionManager2);
Marshal.ReleaseComObject(ppDevice);
Marshal.ReleaseComObject(deviceEnumerator);
}
static Dictionary <ISimpleAudioVolume, Process> EnumerateApplications()
{
Dictionary <ISimpleAudioVolume, Process> result = new Dictionary <ISimpleAudioVolume, Process>();
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
uint dd = 0;
var r = ctl.GetProcessId(out dd);
if (r == 0)
{
var process = GetProcessById((int)dd);
if (process != null)
{
result.Add(ctl as ISimpleAudioVolume, process);
}
else
{
Marshal.ReleaseComObject(ctl);
}
}
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(result);
}
/// <summary>
/// Refresh session of current device.
/// </summary>
public void RefreshSessions()
{
UnregisterNotifications();
if (audioSessionInterface2 != null)
{
IAudioSessionEnumerator sessionEnum;
Marshal.ThrowExceptionForHR(audioSessionInterface2.GetSessionEnumerator(out sessionEnum));
sessions = new SessionCollection(sessionEnum);
audioSessionNotification = new AudioSessionNotification(this);
Marshal.ThrowExceptionForHR(audioSessionInterface2.RegisterSessionNotification(audioSessionNotification));
}
}
private static ISimpleAudioVolume GetVolumeObject(int pid)
{
IMMDeviceEnumerator iMMDeviceEnumerator = null;
IAudioSessionEnumerator SessionEnum = null;
IAudioSessionManager2 audioSessionManager = null;
IMMDevice ppDevice = null;
try
{
iMMDeviceEnumerator = (IMMDeviceEnumerator) new MMDeviceEnumerator();
iMMDeviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out ppDevice);
Guid iid = typeof(IAudioSessionManager2).GUID;
ppDevice.Activate(ref iid, 0, IntPtr.Zero, out object ppInterface);
audioSessionManager = (IAudioSessionManager2)ppInterface;
audioSessionManager.GetSessionEnumerator(out SessionEnum);
SessionEnum.GetCount(out int SessionCount);
ISimpleAudioVolume result = null;
for (int i = 0; i < SessionCount; i++)
{
IAudioSessionControl2 Session = null;
SessionEnum.GetSession(i, out Session);
Session.GetProcessId(out int pRetVal);
if (pRetVal == pid)
{
result = (Session as ISimpleAudioVolume);
break;
}
}
return(result);
}
finally
{
if (SessionEnum != null)
{
Marshal.ReleaseComObject(SessionEnum);
}
if (audioSessionManager != null)
{
Marshal.ReleaseComObject(audioSessionManager);
}
if (ppDevice != null)
{
Marshal.ReleaseComObject(ppDevice);
}
if (iMMDeviceEnumerator != null)
{
Marshal.ReleaseComObject(iMMDeviceEnumerator);
}
}
}
private static ISimpleAudioVolume GetVolumeObject(uint name)
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
// search for an audio session with the required name
// NOTE: we could also use the process id instead of the app name (with IAudioSessionControl2)
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl1;
sessionEnumerator.GetSession(i, out ctl1);
var ctl = ctl1 as IAudioSessionControl2;
uint id;
ctl.GetProcessId(out id);
//string dn;
//ctl.GetDisplayName(out dn);
//if (string.Compare(name, dn, StringComparison.OrdinalIgnoreCase) == 0)
if (id == name)
{
volumeControl = ctl as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(volumeControl);
}
public static AudioSessionControl [] GetAudioSessionControls()
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
AudioSessionControl[] audio_session_controls = new AudioSessionControl[count];
for (int control_index = 0; control_index < count; control_index++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(control_index, out ctl);
string display_name;
string icon_path;
int process_id;
string session_identifier;
string session_instance_identifier;
ctl.GetDisplayName(out display_name);
ctl.GetIconPath(out icon_path);
ctl.GetProcessId(out process_id);
ctl.GetSessionIdentifier(out session_identifier);
ctl.GetSessionInstanceIdentifier(out session_instance_identifier);
audio_session_controls[control_index] = new AudioSessionControl(display_name, icon_path, process_id, session_identifier, session_instance_identifier);
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(audio_session_controls);
}
private static ISimpleAudioVolume GetVolumeObject(int pid)
{
// get the speakers (1st render + multimedia) device
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
// activate the session manager. we need the enumerator
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
// enumerate sessions for on this device
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
uint val;
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
IAudioSessionControl2 ctl2 = (IAudioSessionControl2)ctl;
ctl2.GetProcessId(out val);
if (val == pid)
{
volumeControl = ctl as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
Marshal.ReleaseComObject(ctl2);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
return(volumeControl);
}
internal AudioSessionManager(IAudioSessionManager2 realAudioSessionManager)
{
try
{
_AudioSessionManager = realAudioSessionManager;
IAudioSessionEnumerator _SessionEnum;
Marshal.ThrowExceptionForHR(_AudioSessionManager.GetSessionEnumerator(out _SessionEnum));
_Sessions = new SessionCollection(_SessionEnum);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(DateTime.Now);
System.Diagnostics.Trace.WriteLine(ex);
}
}
internal AudioSessionManager(IAudioSessionManager2 realAudioSessionManager)
{
try
{
_AudioSessionManager = realAudioSessionManager;
IAudioSessionEnumerator _SessionEnum;
Marshal.ThrowExceptionForHR(_AudioSessionManager.GetSessionEnumerator(out _SessionEnum));
_Sessions = new SessionCollection(_SessionEnum);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(DateTime.Now);
System.Diagnostics.Trace.WriteLine(ex);
}
}
public AudioSessionCollection GetSessionCollection()
{
IAudioSessionEnumerator?sessionEnumerator = null;
try {
sessionEnumerator = sessionManager.GetSessionEnumerator();
return(new AudioSessionCollection(sessionEnumerator));
} catch {
if (sessionEnumerator != null)
{
Marshal.FinalReleaseComObject(sessionEnumerator);
}
throw;
}
}
/// <summary>
/// tries to get an instance of <see cref="ISimpleAudioVolume"/> by its process-id
/// </summary>
/// <param name="pProcessId">applications process-id</param>
/// <param name="pDeviceName">sound output device name</param>
/// <param name="oISimpleAudioVolume">instance of <see cref="ISimpleAudioVolume"/></param>
/// <returns>true if succesful, false if not</returns>
private static bool TryGetISimpleAudioVolumeByProcessId(int pProcessId, string pDeviceName, out ISimpleAudioVolume oISimpleAudioVolume)
{
oISimpleAudioVolume = null;
IMMDevice targetDevice = GetIMMDeviceByName(pDeviceName);
if (targetDevice == null)
{
return(false);
}
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
targetDevice.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
if (cpid == pProcessId)
{
volumeControl = ctl as ISimpleAudioVolume;
oISimpleAudioVolume = volumeControl;
break;
}
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(targetDevice);
return(volumeControl != null);
}
private static ISimpleAudioVolume GetVolumeObject(int pid)
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers = null;
IAudioSessionEnumerator sessionEnumerator = null;
IAudioSessionManager2 mgr = null;
try
{
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
mgr = (IAudioSessionManager2)o;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
if (cpid == pid)
{
volumeControl = ctl as ISimpleAudioVolume;
break;
}
Marshal.ReleaseComObject(ctl);
}
return(volumeControl);
}
finally
{
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
}
}
public AudioSessionControl FindSession(IAudioSessionManager2 session_manager, AudioSessionProc matchsession_proc, object data)
{
AudioSessionControl res = null;
IAudioSessionEnumerator sessionList = null;
session_manager.GetSessionEnumerator(out sessionList);
if (sessionList == null)
{
return(null);
}
int cnt = 0;
sessionList.GetCount(out cnt);
for (int index = 0; index < cnt; index++)
{
IAudioSessionControl session = null;
sessionList.GetSession(index, out session);
if (session == null)
{
continue;
}
bool quit = false;
AudioSessionControl control = null;
try
{
control = new AudioSessionControl(session);
quit = (matchsession_proc(control, data) == false);
if (quit)
{
res = control;
break;
}
control.Dispose();
Marshal.Release(Marshal.GetIUnknownForObject(session));
}
catch { }
{
}
}
Marshal.Release(Marshal.GetIUnknownForObject(sessionList));
GC.WaitForPendingFinalizers();
return(res);
}
public static void SetAllApplicationVolumes(float level)
{
IMMDeviceEnumerator deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
IMMDevice speakers;
deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
ISimpleAudioVolume volumeControl = null;
for (int i = 0; i < count; i++)
{
IAudioSessionControl ctl;
sessionEnumerator.GetSession(i, out ctl);
string dn;
ctl.GetDisplayName(out dn);
volumeControl = ctl as ISimpleAudioVolume;
if (volumeControl != null)
{
Guid guid = Guid.Empty;
volumeControl.SetMasterVolume(level / 100, ref guid);
}
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(speakers);
Marshal.ReleaseComObject(deviceEnumerator);
}
/// <summary>
/// tries to get all process-ids for a sound-output-device
/// </summary>
/// <param name="pDeviceName">sound output device name</param>
/// <param name="oProcessIds">all processes as <see cref="IList{T}"/></param>
/// <returns>true if succesful, false if not</returns>
public static bool TryGetProcessesForDevice(string pDeviceName, out IList <int> oProcessIds)
{
oProcessIds = new List <int>();
IMMDevice targetDevice = GetIMMDeviceByName(pDeviceName);
if (targetDevice == null)
{
return(false);
}
Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
object o;
targetDevice.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out o);
IAudioSessionManager2 mgr = (IAudioSessionManager2)o;
IAudioSessionEnumerator sessionEnumerator;
mgr.GetSessionEnumerator(out sessionEnumerator);
int count;
sessionEnumerator.GetCount(out count);
for (int i = 0; i < count; i++)
{
IAudioSessionControl2 ctl;
sessionEnumerator.GetSession(i, out ctl);
int cpid;
ctl.GetProcessId(out cpid);
oProcessIds.Add(cpid);
Marshal.ReleaseComObject(ctl);
}
Marshal.ReleaseComObject(sessionEnumerator);
Marshal.ReleaseComObject(mgr);
Marshal.ReleaseComObject(targetDevice);
return(true);
}
public static List <AudioSession> GetAllSessions()
{
List <AudioSession> sessions = new List <AudioSession>();
IAudioSessionManager2 manager2 = GetManager();
IAudioSessionEnumerator audioSession;
manager2.GetSessionEnumerator(out audioSession);
int NumberOfSession;
audioSession.GetCount(out NumberOfSession);
for (int count = 0; count < NumberOfSession; count++)
{
IAudioSessionControl2 control;
audioSession.GetSession(count, out control);
sessions.Add(new AudioSession(control));
}
Marshal.ReleaseComObject(manager2);
Marshal.ReleaseComObject(audioSession);
return(sessions);
}
