// 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);
}
/// <summary>
/// Gets a pointer to the audio session enumerator object.
/// <seealso cref="RegisterDuckNotification"/>
/// </summary>
/// <param name="sessionEnumerator">Retrieves a session enumerator object that the client can use to enumerate audio sessions on the audio device.</param>
/// <returns>HRESULT</returns>
/// <remarks>The client is responsible for releasing the <paramref name="sessionEnumerator"/>.</remarks>
public unsafe int GetSessionEnumeratorNative(out AudioSessionEnumerator sessionEnumerator)
{
IntPtr ptr = IntPtr.Zero;
int result = InteropCalls.CallI(UnsafeBasePtr, &ptr, ((void**)(*(void**)UnsafeBasePtr))[5]);
sessionEnumerator = ptr != IntPtr.Zero ? new AudioSessionEnumerator(ptr) : null;
return result;
}
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());
}
}
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();
}
private static AudioSessionEnumerator EnumerateSessions()
{
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
return(sessionEnumerator);
}
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);
}
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);
}
}
private static float getHighestVol() // finds process with the highest volume
{
if (sessmgr == null)
{
return(0);
}
if (sessenum == null)
{
sessenum = sessmgr.GetSessionEnumerator();
}
float highest = 0;
foreach (var session in sessenum)
{
using (var audioMeterInformation = session.QueryInterface <AudioMeterInformation>())
{
float peak = audioMeterInformation.GetPeakValue();
if (peak > highest)
{
highest = peak;
}
}
}
return(highest);
}
/// <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++;
}
}
/// <summary>
/// The GetSessionEnumerator method gets a pointer to the audio session enumerator object.
/// </summary>
/// <returns>HRESULT</returns>
public unsafe int GetSessionEnumeratorNative(out AudioSessionEnumerator sessionEnumerator)
{
IntPtr ptr = IntPtr.Zero;
int result = InteropCalls.CallI(_basePtr, &ptr, ((void**)(*(void**)_basePtr))[5]);
if (ptr != IntPtr.Zero)
sessionEnumerator = new AudioSessionEnumerator(ptr);
else
sessionEnumerator = null;
return result;
}
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);
}
}
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);
}
/// <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 static void SetVolumePID(int PID, int volume)
{
Process[] AllProcess = Process.GetProcesses();
if (DoesPIDExist(AllProcess, PID))
{
AudioSessionEnumerator sessions = EnumerateSessions();
foreach (AudioSessionControl session in sessions)
{
if (PID == GetSessionPID(session))
{
AudioVolume(session, volume);
}
}
}
}
private static void AudioSessionManage(object sender, EventArgs e)
{
AudioSessionManager2 sessionManager = GetDefaultAudioSessionManager2(DataFlow.Render);
AudioSessionEnumerator sessionEnumerator = sessionManager.GetSessionEnumerator();
foreach (AudioSessionControl session in sessionEnumerator)
{
AudioVolume(session, 100);
AudioSession(session);
}
SetVolumePID(13160, 100);
SetDefaultMasterVolume(21);
AudioDevices test = new AudioDevices();
test.UpdateAudioDevices();
test.SetDefaultAudioDevice(0);
}
public void FindSpotifyAdvertMuter(Object stateInfo)
{
Boolean found = false;
// If we don't have Spotify
if (programGUI.getSpotifyAdvertMuter() == null)
{
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(System.IO.Path.GetFileName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)))
{
spotifyAdvertMuterControl = sessionControl;
programGUI.setSpotifyAdvertMuter(session);
found = true;
break;
}
}
}
if (found)
{
using var spotifyAdvertMuterVolume = spotifyAdvertMuterControl.QueryInterface <SimpleAudioVolume>();
spotifyAdvertMuterVolume.MasterVolume = 0.25f;
}
else
{
programGUI.setSpotifyAdvertMuter(null);
spotifyAdvertMuterControl = null;
}
}
public static void UpdateProgram(RPIProgramData RPIData)
{
Process[] AllProcess = Process.GetProcesses();
if (DoesPIDExist(AllProcess, RPIData.PID))
{
AudioSessionEnumerator sessions = EnumerateSessions();
foreach (AudioSessionControl session in sessions)
{
if (RPIData.PID == GetSessionPID(session))
{
SimpleAudioVolume simpleVolume = session.QueryInterface <SimpleAudioVolume>();
simpleVolume.MasterVolume = (float)RPIData.Volume / 100;
simpleVolume.IsMuted = RPIData.IsMute;
}
}
}
}
public void FindSpotify(Object stateInfo)
{
Boolean found = false;
// If we don't have Spotify
if (programGUI.getSpotify() == null)
{
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.setDisplayBypass("Running...");
}
else
{
programGUI.setSpotify(null);
sessionControl = null;
programGUI.setDisplayVariable(null);
}
}
private void checkSound_start()
{
checkSound.Interval = 250;
checkSound.Tick += new EventHandler(checkSound_tick);
checkSound.Start();
AudioSessionEnumerator sesenum = getDefaultAudioSessionManager2(DataFlow.Render).GetSessionEnumerator();
foreach (AudioSessionControl s in sesenum)
{
if (s.QueryInterface <AudioSessionControl2>().Process.MainWindowTitle.Contains("Adobe Media Encoder"))
{
session = s.QueryInterface <AudioSessionControl2>();
}
}
if (set.writeLog)
{
logger.log("Audio system check timer initialized and started", set.logFileDir);
}
}
private static void FindAudioSources()
{
using (AudioSessionManager2 audioSessionManager2 = Program.GetDefaultAudioSessionManager2(DataFlow.Render))
{
using (AudioSessionEnumerator sessionEnumerator = audioSessionManager2.GetSessionEnumerator())
{
foreach (AudioSessionControl audioSessionControl in sessionEnumerator)
{
AudioSessionControl2 session = audioSessionControl.QueryInterface <AudioSessionControl2>();
if (!Program.audioSessions.ContainsKey(session.ProcessID))
{
AudioSessionInformation sessionInformation1 = new AudioSessionInformation(session);
Program.audioSessions.Add(session.ProcessID, sessionInformation1);
Program.audioLastVol.Add(session.ProcessID, sessionInformation1.volumeObject.MasterVolume * sessionInformation1.audioMeter.PeakValue);
Program.FormListDirty();
sessionInformation1.session.Process.Exited += (EventHandler)((sender, e) =>
{
Process process = sender as Process;
Program.audioSessions.TryGetValue(process.Id, out AudioSessionInformation sessionInformation);
sessionInformation.Dispose();
Program.audioSessions.Remove(process.Id);
Program.audioLastVol.Remove(process.Id);
Program.FormListDirty();
});
}
else
{
session.Dispose();
}
audioSessionControl.Dispose();
}
sessionEnumerator.Dispose();
}
audioSessionManager2.Dispose();
}
}
public VolumeMixer()
{
AudioSessionManager2 audioSessionManager = AudioSessionManager2.FromMMDevice(MMDeviceEnumerator.DefaultAudioEndpoint(DataFlow.Render, Role.Multimedia));
audioSessionEnumerator = audioSessionManager.GetSessionEnumerator();
}
public void SetEndpoint(int index)
{
AudioSessionManager2 audioSessionManager = AudioSessionManager2.FromMMDevice(MMDeviceEnumerator.EnumerateDevices(DataFlow.Render, DeviceState.Active)[index]);
audioSessionEnumerator = audioSessionManager.GetSessionEnumerator();
}
