public void Dispose()
{
try
{
// Do unregistration, can throw
if (_events != null)
{
_events.StateChanged -= OnStateChanged;
_events.SimpleVolumeChanged -= OnVolumeChanged;
Session.UnregisterAudioSessionNotification(_events);
}
}
catch { }
// Do disposal chains, each can throw
try { _session2.Dispose(); }
catch { }
try { Session.Dispose(); }
catch { }
// Set to null
_simpleAudio = null;
_session2 = null;
Session = null;
}
/// <summary>
/// アプリケーションの音量をdouble型で取得
/// </summary>
/// <param name="processId">プロセスID</param>
/// <returns>
/// 音量(0~1) as double.
/// -1 means no audio.
/// </returns>
public static double GetVolume(int processId)
{
double volume = -1;
Process process = Process.GetProcessById(processId);
// Call from a new thread.
Task.Run(() => GetAudioSessions((AudioSessionControl session) =>
{
try
{
AudioSessionControl2 session2 = session.QueryInterface <AudioSessionControl2>();
// // Ideal is branch if the process id is equal. (not working)
// if (session2.ProcessID == processId)
// モジュールのパスが同じであるか
if (process.MainModule != null && session2.Process.MainModule.FileName == process.MainModule.FileName)
{
SimpleAudioVolume audioVolume = session.QueryInterface <SimpleAudioVolume>();
volume = audioVolume.MasterVolume;
}
}
catch (Exception e)
{
// Usually Win32Exception.
Console.WriteLine(e.Message);
}
}));
return(volume);
}
public VolumeControl(SimpleAudioVolume simpleVol)
{
getVolume = () => simpleVol.MasterVolume;
setVolume = (volume) => simpleVol.MasterVolume = volume;
isMuted = () => simpleVol.Mute;
setMuted = (mute) => simpleVol.Mute = mute;
}
public void TestforAdvert(Object stateInfo)
{
// Stop executing if Spotify was closed
if (ToBreak())
{
return;
}
spotifyControl = programGUI.getSpotify().QueryInterface <AudioSessionControl2>();
if (spotifyControl == null)
{
return;
}
// Make sure display is null
programGUI.setDisplayVariable(null);
// If an advert is playing
if (spotifyControl.Process.MainWindowTitle.Equals("Advertisement") || spotifyControl.Process.MainWindowTitle.Equals("Spotify"))
{
spotifyVolume = spotifyControl.QueryInterface <SimpleAudioVolume>();
if (!spotifyVolume.IsMuted)
{
spotifyVolume.IsMuted = true;
}
if (!programGUI.getSongTitle().Equals(spotifyControl.Process.MainWindowTitle))
{
programGUI.setSongTitle(spotifyControl.Process.MainWindowTitle);
programGUI.setDisplayVariable("Advert detected...");
programGUI.playAudio();
}
programGUI.setToPause(true);
}
}
public async void TestToUnmuteAsync(Object stateInfo)
{
// If Spotify was closed, return
if (ToBreak())
{
return;
}
spotifyControl = programGUI.getSpotify().QueryInterface <AudioSessionControl2>();
spotifyVolume = spotifyControl.QueryInterface <SimpleAudioVolume>();
if (!spotifyControl.Process.MainWindowTitle.Equals("Advertisement") && !spotifyControl.Process.MainWindowTitle.Equals("Spotify"))
{
// If Spotify is muted
if (spotifyVolume.IsMuted)
{
// Save song name
programGUI.setSongTitle(spotifyControl.Process.MainWindowTitle);
// Wait for the presumed advert to completely stop playing
await programGUI.pauseAsync();
// Unmute the audio session
spotifyVolume.IsMuted = false;
// Display advert prevented & the song now playing
programGUI.setDisplayVariable("Advert prevented..." + System.Environment.NewLine + "Now playing... - " + programGUI.getSongTitle() + System.Environment.NewLine + "One song since an advert...");
programGUI.setSongsAfterAdvertChange(1);
}
}
}
private SimpleAudioVolume GetVolumeObject()
{
if (simpleAudioVolume == null)
{
var deviceEnumerator = new MMDeviceEnumerator();
MMDevice devices;
try
{
devices = deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
}
catch
{
return(null);
}
for (int i = 0; i < devices.AudioSessionManager.Sessions.Count; i++)
{
var session = devices.AudioSessionManager.Sessions[i];
if (session.ProcessID == ProcessID)
{
simpleAudioVolume = session.SimpleAudioVolume;
break;
}
}
}
return(simpleAudioVolume);
}
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 void InitializeInternal()
{
_audioClient = AudioClient.FromMMDevice(Device);
_outputFormat = SetupWaveFormat(_source.WaveFormat, _audioClient);
long latency = _latency * 10000;
if (!_eventSync)
{
_audioClient.Initialize(_shareMode, AudioClientStreamFlags.None, latency, 0, _outputFormat, Guid.Empty);
}
else //event sync
{
if (_shareMode == AudioClientShareMode.Exclusive) //exclusive
{
_audioClient.Initialize(_shareMode, AudioClientStreamFlags.StreamFlags_EventCallback, latency, latency, _outputFormat, Guid.Empty);
}
else //shared
{
_audioClient.Initialize(_shareMode, AudioClientStreamFlags.StreamFlags_EventCallback, 0, 0, _outputFormat, Guid.Empty);
_latency = (int)(_audioClient.StreamLatency / 10000);
}
_eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
_audioClient.SetEventHandle(_eventWaitHandle.SafeWaitHandle.DangerousGetHandle());
}
_renderClient = AudioRenderClient.FromAudioClient(_audioClient);
_simpleAudioVolume = SimpleAudioVolume.FromAudioClient(_audioClient);
_simpleAudioVolume.MasterVolume = 1f;
}
public static void Stop()
{
if (State == MediaState.Stopped)
{
return;
}
#if WINDOWS_MEDIA_ENGINE
_mediaEngineEx.Source = null;
#elif WINDOWS_MEDIA_SESSION
_session.ClearTopologies();
_session.Stop();
_volumeController.Dispose();
_volumeController = null;
_clock.Dispose();
_clock = null;
#else
// Loop through so that we reset the PlayCount as well
foreach (var song in Queue.Songs)
{
_queue.ActiveSong.Stop();
}
#endif
State = MediaState.Stopped;
}
private void PlatformPlay()
{
// Cleanup the last song first.
if (State != MediaState.Stopped)
{
_session.Stop();
_volumeController.Dispose();
_clock.Dispose();
}
// Set the new song.
_session.SetTopology(0, _currentVideo.Topology);
_volumeController = CppObject.FromPointer <SimpleAudioVolume>(GetVolumeObj(_session));
_volumeController.Mute = IsMuted;
_volumeController.MasterVolume = _volume;
// Get the clock.
_clock = _session.Clock.QueryInterface <PresentationClock>();
//create the callback if it hasn't been created yet
if (_callback == null)
{
_callback = new Callback();
_session.BeginGetEvent(_callback, null);
}
// Start playing.
var varStart = new Variant();
_session.Start(null, varStart);
}
private static void PlaySong(Song song)
{
#if WINDOWS_MEDIA_ENGINE
_mediaEngineEx.Source = song.FilePath;
_mediaEngineEx.Load();
_mediaEngineEx.Play();
#elif WINDOWS_MEDIA_SESSION
// Cleanup the last song first.
if (State != MediaState.Stopped)
{
_session.Stop();
_volumeController.Dispose();
_clock.Dispose();
}
// Set the new song.
_session.SetTopology(0, song.GetTopology());
// Get the volume interface.
IntPtr volumeObj;
try
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
catch (Exception e)
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
_volumeController = CppObject.FromPointer <SimpleAudioVolume>(volumeObj);
_volumeController.Mute = _isMuted;
_volumeController.MasterVolume = _volume;
// Get the clock.
_clock = _session.Clock.QueryInterface <PresentationClock>();
// Start playing.
var varStart = new Variant();
_session.Start(null, varStart);
#elif WINDOWS_PHONE
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
_mediaElement.Source = new Uri(song.FilePath, UriKind.Relative);
_mediaElement.Play();
// Ensure only one subscribe
_mediaElement.MediaEnded -= OnSongFinishedPlaying;
_mediaElement.MediaEnded += OnSongFinishedPlaying;
});
#else
song.SetEventHandler(OnSongFinishedPlaying);
song.Volume = _isMuted ? 0.0f : _volume;
song.Play();
#endif
State = MediaState.Playing;
}
public AudioSessionInformation(AudioSessionControl2 session)
{
this.session = session;
this.process = session.ProcessID;
this.volumeObject = session.QueryInterface <SimpleAudioVolume>();
this.audioMeter = session.QueryInterface <AudioMeterInformation>();
this.processName = session.Process.ProcessName;
}
private void GetNewSoundOut()
{
_soundOut.Stop();
_soundOut.WaitForStopped();
GetOutputSound();
_systemSimpleAudioVolume = GetSimpleAudioVolume();
_soundOut.Volume = AlarmVolume;
}
public void CanCreateSimpleAudioVolume()
{
using (var audioClient = Utils.CreateDefaultRenderClient())
{
audioClient.Initialize(AudioClientShareMode.Shared, AudioClientStreamFlags.None, 1000, 0, audioClient.GetMixFormat(), Guid.Empty);
SimpleAudioVolume.FromAudioClient(audioClient).Dispose();
}
}
/// <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++;
}
}
public void Dispose()
{
_events.StateChanged -= OnStateChanged;
_events.SimpleVolumeChanged -= OnVolumeChanged;
Session.UnregisterAudioSessionNotification(_events);
Session = null;
_session2 = null;
_simpleAudio = null;
}
private static void PlatformStop()
{
_session.ClearTopologies();
_session.Stop();
_session.Close();
_volumeController.Dispose();
_volumeController = null;
_clock.Dispose();
_clock = null;
}
private static void AudioVolume(AudioSessionControl session)
{
SimpleAudioVolume simpleVolume = session.QueryInterface <SimpleAudioVolume>();
simpleVolume.MasterVolume = 1.0f;
bool muted = simpleVolume.IsMuted;
simpleVolume.IsMuted = !muted;
simpleVolume.IsMuted = muted;
}
void IVolumeControl.SetMute(bool value)
{
_mute = value;
List <AudioSession> controls = GetSessions();
foreach (AudioSession session in controls)
{
SimpleAudioVolume volume = session.Session.SimpleAudioVolume;
volume.Mute = value;
}
}
private static void AudioVolume(AudioSessionControl session, int volume)
{
SimpleAudioVolume simpleVolume = session.QueryInterface <SimpleAudioVolume>();
simpleVolume.MasterVolume = (float)volume / 100;
bool muted = simpleVolume.IsMuted;
simpleVolume.IsMuted = !muted;
simpleVolume.IsMuted = muted;
}
public void Close()
{
Stop();
try {
_audioVolume?.Dispose();
_videoControl?.Dispose();
_mediaSession?.Close();
} catch (SharpDXException) { }
_audioVolume = null;
_videoControl = null;
}
private void KeepSystemVolume()
{
try
{
_systemSimpleAudioVolume.MasterVolume = _systemVolume;
_systemSimpleAudioVolume.IsMuted = false;
}
catch (CoreAudioAPIException exp)
{
Trace.TraceError(exp.Message);
_systemSimpleAudioVolume = GetSimpleAudioVolume();
}
}
public void CanMuteThroughSimpleAudioVolume()
{
using (var audioClient = Utils.CreateDefaultRenderClient())
{
audioClient.Initialize(AudioClientShareMode.Shared, AudioClientStreamFlags.None, 1000, 0, audioClient.GetMixFormat(), Guid.Empty);
using (var volume = SimpleAudioVolume.FromAudioClient(audioClient))
{
var muted = volume.IsMuted;
volume.IsMuted = !muted;
volume.IsMuted = muted;
}
}
}
public void CanSetVolumeThroughSimpleAudioVolume()
{
using (var audioClient = Utils.CreateDefaultRenderClient())
{
audioClient.Initialize(AudioClientShareMode.Shared, AudioClientStreamFlags.None, 1000, 0, audioClient.GetMixFormat(), Guid.Empty);
using (var volume = SimpleAudioVolume.FromAudioClient(audioClient))
{
for (float v = 0; v < 1.0; v += 0.01f)
{
volume.MasterVolume = v;
}
}
}
}
private void setMute(bool mute, uint windowPid)
{
for (int i = 0; i < device.AudioSessionManager2.Sessions.Count; i++)
{
AudioSessionControl2 session = device.AudioSessionManager2.Sessions[i];
uint pid = session.GetProcessID;
AudioMeterInformation mi = session.AudioMeterInformation;
SimpleAudioVolume vol = session.SimpleAudioVolume;
if (pid == windowPid)
{
vol.Mute = mute;
}
}
}
public void Dispose()
{
_events.StateChanged -= OnStateChanged;
_events.SimpleVolumeChanged -= OnVolumeChanged;
_session?.UnregisterAudioSessionNotification(_events);
_session?.Dispose();
_session = null;
_session2?.Dispose();
_session2 = null;
// Disposing of SimpleAudioVolume causes it to freeze.
_simpleAudio = null;
}
public async Task <bool> SetMuteAsync(bool muted, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (_isMuted == muted)
{
return(_isMuted);
}
ComThread.Invoke(() => SimpleAudioVolume.SetMute(muted, Guid.Empty));
await _muteResetEvent.WaitOneAsync(cancellationToken);
return(_isMuted);
}
private static void PlatformPlaySong(Song song)
{
// Cleanup the last song first.
if (State != MediaState.Stopped)
{
_session.Stop();
_session.ClearTopologies();
_session.Close();
_volumeController.Dispose();
_clock.Dispose();
}
// Set the new song.
_session.SetTopology(SessionSetTopologyFlags.Immediate, song.Topology);
// Get the volume interface.
IntPtr volumeObj;
try
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
catch
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
_volumeController = CppObject.FromPointer <SimpleAudioVolume>(volumeObj);
_volumeController.Mute = _isMuted;
_volumeController.MasterVolume = _volume;
// Get the clock.
_clock = _session.Clock.QueryInterface <PresentationClock>();
//create the callback if it hasn't been created yet
if (_callback == null)
{
_callback = new Callback();
_session.BeginGetEvent(_callback, null);
}
// Start playing.
var varStart = new Variant();
_session.Start(null, varStart);
}
public async Task <double> SetVolumeAsync(double volume, CancellationToken cancellationToken)
{
ThrowIfDisposed();
if (Math.Abs(_volume - volume) < 0.1)
{
return(_volume);
}
var normalizedVolume = volume.NormalizeVolume();
ComThread.Invoke(() => SimpleAudioVolume.SetMasterVolume(normalizedVolume, Guid.Empty));
await _volumeResetEvent.WaitOneAsync(cancellationToken);
return(_volume);
}
private void RefreshVolume()
{
if (_isDisposed)
{
return;
}
ComThread.Invoke(() =>
{
float vol;
SimpleAudioVolume.GetMasterVolume(out vol);
_volume = vol * 100;
bool isMuted;
SimpleAudioVolume.GetMute(out isMuted);
_isMuted = isMuted;
});
}
private void PlatformPlay()
{
// Cleanup the last song first.
if (State != MediaState.Stopped)
{
_session.Stop();
_volumeController.Dispose();
_clock.Dispose();
}
// Set the new song.
_session.SetTopology(0, _currentVideo.Topology);
_volumeController = CppObject.FromPointer<SimpleAudioVolume>(GetVolumeObj(_session));
_volumeController.Mute = IsMuted;
_volumeController.MasterVolume = _volume;
// Get the clock.
_clock = _session.Clock.QueryInterface<PresentationClock>();
//create the callback if it hasn't been created yet
if (_callback == null)
{
_callback = new Callback();
_session.BeginGetEvent(_callback, null);
}
// Start playing.
var varStart = new Variant();
_session.Start(null, varStart);
}
private static void PlatformStop()
{
_session.ClearTopologies();
_session.Stop();
_session.Close();
_volumeController.Dispose();
_volumeController = null;
_clock.Dispose();
_clock = null;
}
private static void PlatformPlaySong(Song song)
{
// Cleanup the last song first.
if (State != MediaState.Stopped)
{
_session.Stop();
_session.ClearTopologies();
_session.Close();
_volumeController.Dispose();
_clock.Dispose();
}
// Set the new song.
_session.SetTopology(SessionSetTopologyFlags.Immediate, song.Topology);
// Get the volume interface.
IntPtr volumeObj;
try
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
catch
{
MediaFactory.GetService(_session, MRPolicyVolumeService, SimpleAudioVolumeGuid, out volumeObj);
}
_volumeController = CppObject.FromPointer<SimpleAudioVolume>(volumeObj);
_volumeController.Mute = _isMuted;
_volumeController.MasterVolume = _volume;
// Get the clock.
_clock = _session.Clock.QueryInterface<PresentationClock>();
//create the callback if it hasn't been created yet
if (_callback == null)
{
_callback = new Callback();
_session.BeginGetEvent(_callback, null);
}
// Start playing.
var varStart = new Variant();
_session.Start(null, varStart);
}
