public AudioSession[] GetAudioSessions()
{
if (Disposed)
{
throw new ObjectDisposedException(nameof(MixerWatcher));
}
lock (_disposeLock)
{
// Need to be disposed before enumerating again. The order matters.
_currentSessionEnumerator?.Dispose();
_currentSessionManager?.Dispose();
var results = new List <AudioSession>();
UpdateThread.RunSynchronizedAction(() =>
{
_currentSessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
_currentSessionEnumerator = _currentSessionManager.GetSessionEnumerator();
ProcessBuffer = Process.GetProcesses();
results.AddRange(_currentSessionEnumerator
.Select(x => new AudioSession(x, UpdateThread))
.Where(x => x.CheckSessionIsValid()));
});
return(results.ToArray());
}
}
private void RegisterSessionNotification(AudioSessionManager2 audioSessionManager2,
IAudioSessionNotification audioSessionNotification)
{
if (Thread.CurrentThread.GetApartmentState() == ApartmentState.MTA)
{
audioSessionManager2.RegisterSessionNotification(audioSessionNotification);
}
else
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
ThreadPool.QueueUserWorkItem(
(o) =>
{
try
{
audioSessionManager2.RegisterSessionNotification(audioSessionNotification);
}
finally
{
// ReSharper disable once AccessToDisposedClosure
waitHandle.Set();
}
});
waitHandle.WaitOne();
}
}
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
audioSessionManager2.GetSessionEnumerator().ToArray(); //necessary to make it work
}
// Break if one critera is true- if a Spotify audio session can no longer be found
public bool ToBreak()
{
// If we can no longer find Spotify as an audio session, return true
Boolean found = false;
sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
sessionEnumerator = sessionManager.GetSessionEnumerator();
Assert.IsNotNull(sessionEnumerator);
foreach (AudioSessionControl session in sessionEnumerator)
{
if (session == null)
{
break;
}
sessionControl = session.QueryInterface <AudioSessionControl2>();
if (sessionControl == null)
{
break;
}
if (sessionControl.SessionIdentifier.Contains("Spotify.exe"))
{
spotifyControl = sessionControl;
programGUI.setSpotify(session);
found = true;
break;
}
}
if (!found)
{
programGUI.setSpotify(null); sessionControl = null; return(true);
}
return(false);
}
public void Dispose()
{
foreach (var session in _sessions.Values)
{
session.SessionEnded -= OnSessionEnded;
session.VolumeChanged -= OnSessionVolumeChanged;
session.Dispose();
}
_sessions.Clear();
_callback.NotifyRecived -= OnEndpointVolumeChanged;
_sessionManager.SessionCreated -= OnSessionCreated;
_endpointVolume?.UnregisterControlChangeNotify(_callback);
_endpointVolume?.Dispose();
_endpointVolume = null;
_callback = null;
_sessionManager?.Dispose();
_sessionManager = null;
_device?.Dispose();
_device = null;
}
public static void Main()
{
using (MMDeviceEnumerator enumerator = new MMDeviceEnumerator())
using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
using (AudioEndpointVolume endpointVolume = AudioEndpointVolume.FromDevice(device))
using (AudioSessionManager2 sessionManager2 = AudioSessionManager2.FromMMDevice(device))
using (AudioSessionEnumerator sessionEnumerator = sessionManager2.GetSessionEnumerator())
{
Console.WriteLine("Default Render Device: " + device.FriendlyName);
Console.WriteLine("Master Volume Scalar: " + endpointVolume.GetMasterVolumeLevelScalar());
Console.WriteLine("\nGetting audio sessions...");
foreach (AudioSessionControl sessionControl in sessionEnumerator)
{
PrintSessionName(sessionControl);
Console.WriteLine("\t- State: " + sessionControl.SessionState.ToString());
using (SimpleAudioVolume sessionSimpleVolume = sessionControl.QueryInterface <SimpleAudioVolume>())
{
Console.WriteLine("\t- Volume: " + sessionSimpleVolume.MasterVolume);
sessionSimpleVolume.MasterVolume = 1.0f;
}
sessionControl.Dispose();
}
}
Console.WriteLine("\nVolumes reset!");
Console.ReadLine();
}
public static List <ProgramData> GetProgramsFirstTime()
{
List <ProgramData> programs = new List <ProgramData>();
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
foreach (AudioSessionControl session in sessionEnumerator)
{
if (programs.Count < 3)
{
programs = EnumerateProgram(programs, session);
}
if (programs.Count > 3)
{
break;
}
}
ProgramData nulldata = new ProgramData();
nulldata.Null = true;
while (programs.Count < 3)
{
programs.Add(nulldata);
}
return(programs);
}
/// <summary>
/// Registers the device with the service so it's aware
/// of events and they're handled properly.
/// </summary>
/// <param name="device"></param>
private void RegisterDevice(IAudioDevice device)
{
if (_devices.ContainsKey(device.Id))
{
device.Dispose();
return;
}
_devices.Add(device.Id, device);
device.DeviceDefaultChanged += OnDefaultDeviceChanged;
device.DeviceVolumeChanged += OnDeviceVolumeChanged;
var sessionManager = AudioSessionManager2.FromMMDevice(device.Device);
sessionManager.SessionCreated += OnSessionCreated;
_sessionManagers.Add(device.Id, sessionManager);
RaiseDeviceCreated(device.Id, device.DisplayName, device.Volume, device.IsMuted);
foreach (var session in sessionManager.GetSessionEnumerator())
{
if (ValidateSession(session))
{
OnSessionCreated(session);
}
}
}
private static List <VolumeObject> GetAllVolumeObjects()
{
List <VolumeObject> volumeObjects = new List <VolumeObject>();
// get the speakers (1st render + multimedia) device
using (MMDeviceEnumerator deviceEnumerator = new MMDeviceEnumerator())
{
// Find all the different "devices"/endpoints on PC
using (var endpoints = deviceEnumerator.EnumAudioEndpoints(DataFlow.Render, DeviceState.Active))
{
foreach (var endpoint in endpoints)
{
using (AudioSessionManager2 mgr = new AudioSessionManager2(endpoint.Activate(GUID_IAudioSessionManager2, CLSCTX.CLSCTX_ALL, IntPtr.Zero)))
{
using (var sessionEnumerator = mgr.GetSessionEnumerator())
{
foreach (var session in sessionEnumerator)
{
// Note: This means audioSession must be disposed of
AudioSessionControl2 audioSession = session.QueryInterface <AudioSessionControl2>();
volumeObjects.Add(new VolumeObject(audioSession.ProcessID, audioSession));
}
}
}
}
}
}
return(volumeObjects);
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
MMDevice device = GetDefaultDevice();
var sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
private static AudioSessionEnumerator EnumerateSessions()
{
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
return(sessionEnumerator);
}
private void Form1_Load(object sender, EventArgs e)
{
new Thread(() =>
{
sessmgr = GetDefaultAudioSessionManager2(DataFlow.Render); // get audio manager
}).Start();
}
/// <summary>
/// Registers the device with the service so it's aware
/// of events and they're handled properly.
/// </summary>
/// <param name="device"></param>
private void RegisterDevice(IAudioDevice device)
{
AppLogging.DebugLog(nameof(RegisterDevice), device.DeviceId, device.DisplayName, device.Device.DataFlow.ToString());
if (_devices.ContainsKey(device.Id))
{
device.Dispose();
return;
}
_devices.Add(device.Id, device);
device.DeviceDefaultChanged += OnDefaultDeviceChanged;
device.DeviceVolumeChanged += OnDeviceVolumeChanged;
device.DeviceRemoved += OnDeviceRemoved;
RaiseDeviceCreated(device.Id, device.DisplayName, device.Volume, device.IsMuted, device.Flow);
if (device.Flow == DeviceFlow.Output)
{
var sessionManager = AudioSessionManager2.FromMMDevice(device.Device);
sessionManager.SessionCreated += OnSessionCreated;
_sessionManagers.Add(device.Id, sessionManager);
foreach (var session in sessionManager.GetSessionEnumerator())
{
OnSessionCreated(session);
}
}
}
private void detectSoundVolume()
{
//AllocConsole();
try
{
float audio;
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
AudioSessionControl2 sessionControl;
foreach (AudioSessionControl session in sessionEnumerator)
{
sessionControl = session.QueryInterface <AudioSessionControl2>();
//Console.WriteLine(sessionControl.Process.MainWindowTitle);
if (sessionControl.Process.MainWindowTitle.Contains("Adobe Media Encoder"))
{
audio = session.QueryInterface <AudioMeterInformation>().PeakValue;
Console.WriteLine(audio.ToString());
if (audio > 0.1)
{
sound = true;
}
break;
}
}
}
catch (Exception exc)
{
Console.WriteLine("ERROR " + exc);
}
}
public AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
MMDevice = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia);
Debug.WriteLine("DefaultDevice: " + MMDevice.FriendlyName);
sessionManager = AudioSessionManager2.FromMMDevice(MMDevice);
return(sessionManager);
}
private AudioSessionManager2 GetActiveAudioDeviceManager()
{
using var device = _deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
Logger.Debug($"Found default audio device: {device.FriendlyName}");
return(AudioSessionManager2.FromMMDevice(device));
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
using CSCore.CoreAudioAPI.MMDeviceEnumerator enumerator = new CSCore.CoreAudioAPI.MMDeviceEnumerator();
using var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia);
var sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
using (var enumerator = new MMDeviceEnumerator()) {
using (var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia)) {
return(AudioSessionManager2.FromMMDevice(device));
}
}
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
MMDevice device = GetDefaultDevice();
// Console.WriteLine("DefaultDevice: " + device.FriendlyName);
var sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
/// <summary>
/// Add the programs outputting audio to the simple volume array
/// </summary>
private static void GetChannelVolumes()
{
//create array of channels
m_ChannelVolume = new SimpleAudioVolume[9];
//get processes outputting audio
AudioSessionManager2 sessionManager = null;
var thread = new Thread
(
() => { sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render); }
);
thread.Start();
thread.Join();
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
//loop through processes - clamp to number of channels
//skip the master channel
m_NumberOfOccupiedChannels = 0;
for (int i = 1; i < Math.Min(sessionEnumerator.Count, 10); i++)
{
//get the process and name
var process = sessionEnumerator[i].QueryInterface <AudioSessionControl2>().Process;
string name = process == null ? "Unnamed" : process.ProcessName;
//check if this process is valid for audio monitoring
bool flag = false;
for (int x = 0; x < m_ForbiddenProcesses.Length; x++)
{
if (name == m_ForbiddenProcesses[x])
{
flag = true;
}
}
if (flag)
{
continue;
}
//get process icon
Icon icon = Icon.ExtractAssociatedIcon(process.MainModule.FileName);
//set icon
m_Icons[m_NumberOfOccupiedChannels].Fill = new ImageBrush(icon.ToImageSource());
//get the simple volume
SimpleAudioVolume simpleVolume = sessionEnumerator[i].QueryInterface <SimpleAudioVolume>();
m_ChannelVolume[m_NumberOfOccupiedChannels] = simpleVolume;
//get the peak meter
m_PeakMeters[m_NumberOfOccupiedChannels] = sessionEnumerator[i].QueryInterface <AudioMeterInformation>();
m_NumberOfOccupiedChannels++;
}
}
private static bool IsUsingAudio()
{
//Music.UI is Groove. Additional options include chrome, spotify, etc
List <Process> candidates = new List <Process>();
foreach (string program in ValidPlayers)
{
if (EnabledClients.ContainsKey(program) && EnabledClients[program])
{
foreach (Process process in Process.GetProcessesByName(program))
{
candidates.Add(process);
}
}
}
if (candidates.Any())
{
AudioSessionManager2 sessionManager;
using (var enumerator = new MMDeviceEnumerator())
{
using (var device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia))
{
sessionManager = AudioSessionManager2.FromMMDevice(device);
}
}
using (var sessionEnumerator = sessionManager.GetSessionEnumerator())
{
foreach (var session in sessionEnumerator)
{
var process = session.QueryInterface <AudioSessionControl2>().Process;
try
{
if (ValidPlayers.Contains(process.ProcessName.ToLower()) &&
EnabledClients.ContainsKey(process.ProcessName.ToLower()) &&
EnabledClients[process.ProcessName.ToLower()] &&
session.QueryInterface <AudioMeterInformation>().GetPeakValue() > 0)
{
lastPlayer = playerName;
playerName = process.ProcessName.ToLower();
return(true);
}
}
catch (Exception e)
{
#if DEBUG
Console.WriteLine(e.StackTrace);
#else
Console.WriteLine(e.Message);
#endif
}
}
}
}
return(false);
}
private AudioSessionManager2 GetDefaultAudioSessionManager(DataFlow dataFlow)
{
AudioSessionManager2 sessionManager;
using (var enumerator = new MMDeviceEnumerator())
using (var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia))
sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
using (var enumerator = new MMDeviceEnumerator()) {
using (var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia)) {
// Console.WriteLine("DefaultDevice: " + device.FriendlyName);
var sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
}
}
private static void AudioSessionManage(object sender, EventArgs e)
{
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
foreach (AudioSessionControl session in sessionEnumerator)
{
AudioVolume(session);
AudioSession(session);
}
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(DataFlow dataFlow)
{
//todo: Let people choose their own device if they aren't using the default sound device for VLC/MPC.
using (var enumerator = new MMDeviceEnumerator())
{
using (var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia))
{
var sessionManager = AudioSessionManager2.FromMMDevice(device);
return(sessionManager);
}
}
}
private void UpdateActiveAudioDeviceManager()
{
Task.Run(() => {
// Must be called from an MTA thread.
_activeAudioDeviceManager = GetActiveAudioDeviceManager();
});
if (_service.Gw2IsRunning)
{
UpdateProcessMeterInformation();
}
}
public static List <ProgramData> GetAllPrograms()
{
List <ProgramData> programs = new List <ProgramData>();
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
foreach (AudioSessionControl session in sessionEnumerator)
{
programs = EnumerateProgram(programs, session);
}
return(programs);
}
public AudioDevice(MMDevice device, bool visibleSystemSounds = false)
{
_device = device;
_visibleSystemSounds = visibleSystemSounds;
_sessionManager = AudioSessionManager2.FromMMDevice(_device);
_endpointVolume = AudioEndpointVolume.FromDevice(_device);
_endpointVolume.RegisterControlChangeNotify(_callback);
_callback.NotifyRecived += OnEndpointVolumeChanged;
_sessionManager.SessionCreated += OnSessionCreated;
}
private static void muteAllButCurrent()
{
AudioSessionManager2 sm = AudioSessionManager2.FromMMDevice(_device);
foreach (var item in sm.GetSessionEnumerator())
{
if (item.AsAudioSessionControl2().ProcessID != getPIDOfCurrentWindow())
{
mute(item.AsAudioSessionControl2(), false);
}
}
}
/// <summary>
/// CSCore を用いたオーディオセッションの取得
/// </summary>
/// <param name="callback">各セッションに対し行う関数</param>
static void GetAudioSessions(EnumAudioSessionDelegation callback)
{
// デフォルトオーディオエンドポイントとイテレータの取得
MMDevice device = MMDeviceEnumerator.DefaultAudioEndpoint(CSCore.CoreAudioAPI.DataFlow.Render, CSCore.CoreAudioAPI.Role.Multimedia);
AudioSessionManager2 manager = AudioSessionManager2.FromMMDevice(device);
AudioSessionEnumerator enumerator = manager.GetSessionEnumerator();
foreach (AudioSessionControl sessionControl in enumerator)
{
// 関数呼び出し
callback(sessionControl);
}
}
private void GetSs()
{
if (ASM == null && L.MMD != null)
{
ASM = AudioSessionManager2.FromMMDevice(L.MMD);
}
ASM.SessionCreated += ASM_SessionCreated;
DW(2); DW(Thread.CurrentThread.GetHashCode());
foreach (var asc in ASM.GetSessionEnumerator())
{
AddSession(asc);
}
}
