public FormSwitcher()
{
InitializeComponent();
var winVer = FileVersionInfo.GetVersionInfo(Environment.GetEnvironmentVariable("windir") + "\\explorer.exe");
IsWin10 = winVer.ProductMajorPart == 10;
if (IsWin10)
FormBorderStyle = FormBorderStyle.FixedToolWindow;
SetWindowTheme(listDevices.Handle, "explorer", null);
ledLeft.OldStyle = Program.settings.ColorVU;
ledLeft.SetValue((float)0.1);
ledRight.OldStyle = Program.settings.ColorVU;
ledRight.SetValue((float)0.1);
using (var gr = CreateGraphics())
DpiFactor = gr.DpiX / 96;
var tile = new Size(listDevices.ClientSize.Width + 2, (int)(listDevices.TileSize.Height * DpiFactor));
DeviceIcons.InitImageLists(DpiFactor);
listDevices.TileSize = tile;
listDevices.Scroll += VolBar.DoScroll;
ledLeft.DoScroll += VolBar.DoScroll;
ledRight.DoScroll += VolBar.DoScroll;
listDevices.LargeImageList = DeviceIcons.ActiveIcons;
if (DpiFactor <= 1)
{
DefaultTrayIcons.Add(getIcon(Resources.mute));
DefaultTrayIcons.Add(getIcon(Resources.zero));
DefaultTrayIcons.Add(getIcon(Resources._1_33));
DefaultTrayIcons.Add(getIcon(Resources._33_66));
DefaultTrayIcons.Add(getIcon(Resources._66_100));
}
else
{
DefaultTrayIcons.Add(getIcon(Resources.mute_highDPI));
DefaultTrayIcons.Add(getIcon(Resources.zero_highDPI));
DefaultTrayIcons.Add(getIcon(Resources._1_33_highDPI));
DefaultTrayIcons.Add(getIcon(Resources._33_66_highDPI));
DefaultTrayIcons.Add(getIcon(Resources._66_100_highDPI));
}
RenderType = Program.settings.DefaultDataFlow;
RefreshDevices(RenderType);
SetTrayIcons();
VolBar.VolumeMuteChanged += IconChanged;
VolBar.RegisterDevice(RenderType);
EndPoints.NotifyClient.DefaultChanged += DefaultChanged;
EndPoints.NotifyClient.DeviceAdded += DeviceAdded;
EndPoints.NotifyClient.DeviceRemoved += DeviceRemoved;
GlobalHotkeys.Handle = Handle;
GlobalHotkeys.RegisterAll();
ScrollVolume.VolumeScroll += ScrollTheVolume;
ScrollVolume.RegisterVolScroll(Program.settings.VolumeScroll.Enabled);
}
public MMDeviceCollection EnumerateAudioEndPoints(EDataFlow dataFlow, EDeviceState dwStateMask)
{
IMMDeviceCollection result;
//Marshal.ThrowExceptionForHR(_realEnumerator.EnumAudioEndpoints(dataFlow, dwStateMask, out result));
_realEnumerator.EnumAudioEndpoints(dataFlow, dwStateMask, out result);
return new MMDeviceCollection(result, dataFlow, dwStateMask);
}
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice result;
Marshal.ThrowExceptionForHR(_deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out result));
return(new MMDevice(result));
}
public MorphicResult <MMDevice, WindowsComError> GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice?immDevice;
var result = _mmDeviceEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out immDevice);
if (result != ExtendedPInvoke.S_OK)
{
if (result == ExtendedPInvoke.E_NOTFOUND)
{
throw new NoDeviceIsAvailableException();
}
else
{
// TODO: consider throwing more granular exceptions here
var comException = new COMException("IMMDeviceEnumerator.GetDefaultAudioEndpoint failed", Marshal.GetExceptionForHR(result));
return(MorphicResult.ErrorResult(WindowsComError.ComException(comException)));
}
}
if (immDevice is null)
{
// NOTE: this code should never be executed since GetDefaultAudioEndpoint should have returned an HRESULT of E_POINTER if it failed
var comException = new COMException("IMMDeviceEnumerator.GetDefaultAudioEndpoint returned a null pointer", new NullReferenceException());
return(MorphicResult.ErrorResult(WindowsComError.ComException(comException)));
}
var mmDevice = MMDevice.CreateFromIMMDevice(immDevice !);
return(MorphicResult.OkResult(mmDevice));
}
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice _Device = null;
//Marshal.ThrowExceptionForHR(((IMMDeviceEnumerator)_realEnumerator).GetDefaultAudioEndpoint(dataFlow, role, out _Device));
_realEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out _Device);
return new MMDevice(_Device);
}
public bool IsDefault(string deviceId, EDataFlow flow, Role role)
{
if (string.IsNullOrWhiteSpace(deviceId))
{
return(false);
}
if (role == Role.All)
{
var result = true;
result &= IsDefault(deviceId, flow, Role.Communications);
result &= IsDefault(deviceId, flow, Role.Console);
result &= IsDefault(deviceId, flow, Role.Multimedia);
return(result);
}
try
{
MMDevice defaultDevice = _enumerator.GetDefaultAudioEndpoint((EDataFlow)flow, (Role)role);
return(deviceId == defaultDevice.ID);
}
catch (Exception)
{
//Happens if there is no default device for the given Data Flow and/or role
// See issue #401
return(false);
}
}
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice?immDevice;
var result = _mmDeviceEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out immDevice);
if (result != WindowsApi.S_OK)
{
if (result == WindowsApi.E_NOTFOUND)
{
throw new NoDeviceIsAvailableException();
}
else
{
// TODO: consider throwing more granular exceptions here
throw new COMException("IMMDeviceEnumerator.GetDefaultAudioEndpoint failed", Marshal.GetExceptionForHR(result));
}
}
if (immDevice == null)
{
// NOTE: this code should never be executed since GetDefaultAudioEndpoint should have returned an HRESULT of E_POINTER if it failed
throw new COMException("IMMDeviceEnumerator.GetDefaultAudioEndpoint returned a null pointer", new NullReferenceException());
}
var mmDevice = MMDevice.CreateFromIMMDevice(immDevice !);
return(mmDevice);
}
public DeviceInfo(string deviceId, string name, EDataFlow flow, EDeviceState state)
{
_deviceId = deviceId;
_friendlyName = name;
_dataFlow = flow;
_state = state;
}
/*/
* /// <summary>
* /// IMMNotificationClient : OnDeviceStateChanged
* /// </summary>
* /// <param name="deviceId"></param>
* /// <param name="newState"></param>
* public void OnDeviceStateChanged(
* [MarshalAs(UnmanagedType.LPWStr)] string deviceId,
* [MarshalAs(UnmanagedType.U4)] EDeviceState newState)
* {
* // Console.WriteLine("OnDeviceStateChanged: deviceId="+ deviceId +", state=" + newState);
*
* if (newState == EDeviceState.Active)
* {
* //Console.WriteLine("Active");
* }
* else if (newState == EDeviceState.NotPresent)
* {
* // Console.WriteLine("NotPresent");
* }
* //releaseDevice();
* //initDevice();
* }
*
* /// <summary>
* /// IMMNotificationClient : OnDeviceAdded
* /// </summary>
* /// <param name="deviceId"></param>
* public void OnDeviceAdded([MarshalAs(UnmanagedType.LPWStr)] string deviceId)
* {
* //Console.WriteLine("OnDeviceAdded:" + deviceId);
* }
*
* /// <summary>
* /// IMMNotificationClient : OnDeviceRemoved
* /// </summary>
* /// <param name="deviceId"></param>
* public void OnDeviceRemoved(
* [MarshalAs(UnmanagedType.LPWStr)] string deviceId)
* {
* //Console.WriteLine("OnDeviceRemoved:" + deviceId);
* }
* /// <summary>
* /// IMMNotificationClient : OnPropertyValueChanged
* /// </summary>
* /// <param name="deviceId"></param>
* /// <param name="propertyKey"></param>
* public void OnPropertyValueChanged(
* [MarshalAs(UnmanagedType.LPWStr)] string deviceId, PropertyKey propertyKey)
* {
* //Console.WriteLine("OnPropertyValueChanged:" + deviceId);
* }
* //*/
/// <summary>
/// IMMNotificationClient : OnDefaultDeviceChanged
/// </summary>
/// <param name="dataFlow"></param>
/// <param name="deviceRole"></param>
/// <param name="defaultDeviceId"></param>
public void OnDefaultDeviceChanged(
[MarshalAs(UnmanagedType.I4)] EDataFlow dataFlow,
[MarshalAs(UnmanagedType.I4)] ERole deviceRole,
[MarshalAs(UnmanagedType.LPWStr)] string defaultDeviceId)
{
//Console.WriteLine("OnDefaultDeviceChanged: DeviceId:[" + defaultDeviceId + "] EDataFlow:[" + dataFlow+ "] ERole:[" + deviceRole+"]");
if (dataFlow != monitor.DataFlow || deviceRole != monitor.Role)
{
return;
}
var dispatcher = Application.Current.Dispatcher;
//dispatcher.Invoke(DispatcherPriority.Normal, (Action)delegate () {
dispatcher.Invoke((Action) delegate()
{
monitor.updateDevice(defaultDeviceId);
// if (monitor.listener == null)
// {
// return;
//}
//
//monitor.listener.OnDeviceChanged(monitor.device);
Debug.WriteLine($"OnDefaultDeviceChanged flow={dataFlow} role={deviceRole} device={defaultDeviceId} list={(_OnAudioDeviceChanged?.GetInvocationList().Length ?? 0)}");
_OnAudioDeviceChanged?.Invoke(monitor.device);
});
}
public MMDeviceCollection EnumerateAudioEndPoints(EDataFlow dataFlow, EDeviceState dwStateMask)
{
IMMDeviceCollection result;
Marshal.ThrowExceptionForHR(_realEnumerator.EnumAudioEndpoints(dataFlow, dwStateMask, out result));
return(new MMDeviceCollection(result));
}
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice _Device;
Marshal.ThrowExceptionForHR(_realEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out _Device));
return(new MMDevice(_Device));
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
if (Program.settings.QuickSwitchEnabled && !DeactivatedOnIcon)
{
notifyIcon.ContextMenuStrip = null;
QuickSwitchDevice(false, Program.settings.DefaultDataFlow, Program.settings.QuickSwitchShowOSD);
}
else
{
notifyIcon.ContextMenuStrip = trayMenu;
}
return;
}
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
{
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
}
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
{
return;
}
SetSizes();
}
/// <summary>
/// Creates the specified collection of the IMMDevice interfaces.
/// </summary>
/// <param name="direction">The data flow direction.</param>
/// <param name="stateMasks">The state masks.</param>
public static IEnumerable <IMMDevice> CreateIMMDeviceCollection(EDataFlow direction, UInt32 stateMasks)
{
var deviceEnumerator = CreateIMMDeviceEnumerator();
IMMDeviceCollection deviceCollection;
deviceEnumerator.EnumAudioEndpoints(direction, stateMasks, out deviceCollection);
UInt32 deviceCount;
deviceCollection.GetCount(out deviceCount);
var deviceList = new List <IMMDevice>();
for (uint i = 0; i < deviceCount; i++)
{
IMMDevice device;
deviceCollection.Item(i, out device);
deviceList.Add(device);
}
if (!deviceList.Any())
{
Assert.Inconclusive("The test cannot be run properly. No devices were found.");
}
return(deviceList);
}
/// <summary>
/// Switch the audio endpoint of the given process
/// </summary>
/// <param name="deviceId">Id of the device</param>
/// <param name="role">Which role to switch</param>
/// <param name="flow">Which flow to switch</param>
/// <param name="processId">ProcessID of the process</param>
public void SwitchProcessTo(string deviceId, ERole role, EDataFlow flow, uint processId)
{
var roles = new[]
{
ERole.eConsole,
ERole.eCommunications,
ERole.eMultimedia
};
if (role != ERole.ERole_enum_count)
{
roles = new[]
{
role
};
}
ComThread.Invoke((() =>
{
var currentEndpoint = roles.Select(eRole => ExtendPolicyClient.GetDefaultEndPoint(flow, eRole, processId)).FirstOrDefault(endpoint => !string.IsNullOrEmpty(endpoint));
if (deviceId.Equals(currentEndpoint))
{
Trace.WriteLine($"Default endpoint for {processId} already {deviceId}");
return;
}
ExtendPolicyClient.SetDefaultEndPoint(deviceId, flow, roles, processId);
}));
}
/// <summary>
/// Find audio endpoint by name
/// </summary>
/// <param name="name">the name of the endpint</param>
/// <param name="deviceflow">whenever it is input or output or both</param>
/// <param name="state">whenever it is enabled,disabled unpluged or both</param>
/// <returns>the desired endpoint</returns>
public MMDevice FindEndpointByName(string name, EDataFlow deviceflow,
EDeviceState state)
{
try
{
MMDevice device = null;
MMDeviceCollection devices = this.GetAllAudioEndPoints(deviceflow, state);
if (devices != null)
{
for (int i = 0; i < devices.Count; i++)
{
MMDevice deviceAt = devices[i];
if (deviceAt.FriendlyName.ToLower() == name)
{
device = deviceAt;
break;
}
}
}
return(device);
}
catch (Exception e)
{
Program.Bugtracking(e);
return(null);
}
}
public int OnDefaultDeviceChanged(EDataFlow flow, ERole role, string strDefaultDeviceId)
{
DefaultDeviceChangedEventArgs arg = new DefaultDeviceChangedEventArgs(flow, role, strDefaultDeviceId);
_DeviceEnumerator.FireDefaultDeviceChangedEvent(arg);
return(0);
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
return;
}
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
{
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
}
if (ModifierKeys.HasFlag(Keys.Alt))
{
ChangeDeviceState(rType, true, 0, true);
}
else
{
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
{
return;
}
SetSizes();
}
}
void DeviceChanged(
[MarshalAs(UnmanagedType.I4)] EDataFlow dataFlow,
[MarshalAs(UnmanagedType.I4)] ERole deviceRole,
[MarshalAs(UnmanagedType.LPWStr)] string defaultDeviceId)
{
if (deviceRole != this.Role)
{
return;
}
var dispatcher = Application.Current.Dispatcher;
//dispatcher.Invoke(DispatcherPriority.Normal, (Action)delegate () {
dispatcher.BeginInvoke((Action) delegate()
{
if (!Initialized)
{
return;
}
Debug.WriteLine($"MicPlayter Stop(DeviceChanged) Role={deviceRole} Flow={dataFlow} ID={defaultDeviceId}");
Stop();
Dispose();
//var newDevice = deviceEnumerator.GetDevice(defaultDeviceId);
});
}
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role)
{
IMMDevice ppEndpoint = null;
Marshal.ThrowExceptionForHR(this._realEnumerator.GetDefaultAudioEndpoint(dataFlow, role, out ppEndpoint));
return(new MMDevice(ppEndpoint));
}
internal void RegisterDevice(EDataFlow RenderType)
{
if (Device != null)
{
try
{
Device.AudioEndpointVolume.OnVolumeNotification -= VolNotify;
if (volEvents != null)
{
Device.AudioSessionManager.Sessions[0].UnregisterAudioSessionNotification(volEvents);
}
volEvents = null;
}
catch { }
Device = null;
}
Device = EndPoints.DeviceEnumerator.GetDefaultAudioEndpoint(RenderType, ERole.eMultimedia);
Value = Device.AudioEndpointVolume.MasterVolumeLevelScalar;
Mute = Device.AudioEndpointVolume.Mute;
Stereo = Device.AudioMeterInformation.Channels.GetCount() > 1;
volEvents = new VolEventsHandler(this);
Device.AudioSessionManager.Sessions[0].RegisterAudioSessionNotification(volEvents);
Device.AudioEndpointVolume.OnVolumeNotification += VolNotify;
}
internal static void RefreshDeviceList(EDataFlow renderType)
{
DeviceNames.Clear();
DeviceIDs.Clear();
var pDevices = DeviceEnumerator.EnumerateAudioEndPoints(renderType, EDeviceState.Active);
var defDeviceID = DeviceEnumerator.GetDefaultAudioEndpoint(renderType, ERole.eMultimedia).ID;
var devCount = pDevices.Count;
var newCount = 0;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
var devID = device.ID;
var devSettings = Program.settings.Device.Find(x => x.DeviceID == devID);
if (devSettings == null || !devSettings.HideFromList)
{
var devName = device.FriendlyName;
DeviceNames.Add(devID, devName);
DeviceIDs.Add(newCount, devID);
if (devID == defDeviceID)
{
DefaultDeviceID = newCount;
DefaultDeviceName = devName;
}
newCount++;
}
}
}
/// <summary>
/// Attempts to set active device to the specified name
/// </summary>
/// <param name="device"></param>
public static bool SetActiveDevice(string deviceId, EDataFlow deviceType)
{
AudioSwitcher switch1 = AudioSwitcher.Instance;
//Log.Information("Set Default device: {Device}", device);
if (!IsSwitchDefaultDevice)
{
switch1.SwitchTo(deviceId, Role.Console);
switch1.SwitchTo(deviceId, Role.Multimedia);
if (SwitchForegroundProgram)
{
switch1.ResetProcessDeviceConfiguration();
switch1.SwitchProcessTo(deviceId, Role.Console, deviceType);
switch1.SwitchProcessTo(deviceId, Role.Multimedia, deviceType);
}
}
else
{
//Log.Information("Set Default Communication device: {Device}", device);
switch1.SwitchTo(deviceId, Role.All);
if (SwitchForegroundProgram)
{
switch1.ResetProcessDeviceConfiguration();
switch1.SwitchProcessTo(deviceId, Role.All, deviceType);
}
}
return(true);
}
public void SetDefaultEndPoint(string deviceId, EDataFlow flow, IEnumerable <ERole> roles, uint processId)
{
Trace.WriteLine($"ExtendedPolicyClient SetDefaultEndPoint {deviceId} [{flow}] {processId}");
try
{
if (string.IsNullOrEmpty(deviceId))
{
return;
}
using var deviceIdStr = HSTRING.FromString(GenerateDeviceId(deviceId, flow));
foreach (var eRole in roles)
{
PolicyConfig.SetPersistedDefaultAudioEndpoint(processId, flow, eRole, deviceIdStr);
}
}
catch (COMException e) when((e.ErrorCode & ErrorConst.COM_ERROR_MASK) == ErrorConst.COM_ERROR_NOT_FOUND)
{
throw new DeviceNotFoundException($"Can't set default as {deviceId}", e, deviceId);
}
catch (Exception ex)
{
Trace.WriteLine($"{ex}");
}
}
public void OnDefaultDeviceChanged(EDataFlow dataFlow, ERole deviceRole, string defaultDeviceId)
{
if (DefaultChanged != null)
{
DefaultChanged(defaultDeviceId);
}
}
/// <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)));
}
internal static void RefreshDeviceList(EDataFlow renderType)
{
DeviceNames.Clear();
DeviceIDs.Clear();
var pDevices = DeviceEnumerator.EnumerateAudioEndPoints(renderType, EDeviceState.Active);
var defDeviceID = DeviceEnumerator.GetDefaultAudioEndpoint(renderType, ERole.eMultimedia).ID;
var devCount = pDevices.Count;
var newCount = 0;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
var devID = device.ID;
var devSettings = Program.settings.Device.Find(x => x.DeviceID == devID);
if (devSettings == null || !devSettings.HideFromList)
{
var devName = device.FriendlyName;
DeviceNames.Add(devID, devName);
DeviceIDs.Add(newCount, devID);
if (devID == defDeviceID)
{
DefaultDeviceID = newCount;
DefaultDeviceName = devName;
}
newCount++;
}
}
}
internal static void RefreshDevices(EDataFlow renderType, bool updateIcons)
{
DeviceNames.Clear();
DeviceIDs.Clear();
if (updateIcons)
{
DeviceIcons.Clear();
}
var pDevices = pEnum.EnumerateAudioEndPoints(renderType, EDeviceState.DEVICE_STATE_ACTIVE);
var devCount = pDevices.Count;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
DeviceNames.Add(device.FriendlyName);
DeviceIDs.Add(i, device.ID);
if (updateIcons)
{
DeviceIcons.Add(device.IconPath);
}
}
}
public void PostConstructor(EDataFlow dataFlow)
{
var devices = EDataFlow.eRender.Equals(dataFlow) ? DeviceRepository.FindPlayBackDevices() : DeviceRepository.FindCaptureDevices();
var cnt = 0;
foreach (var dev in devices)
{
var devID = dev.MMDevice.ID;
var lvitem = new ListViewItem {
Text = dev.MMDevice.FriendlyName, ImageIndex = cnt, Tag = devID
};
var devSettings = Program.settings.Device.Find(x => x.DeviceID == devID);
if (devSettings != null)
{
lvitem.Font = new Font(lvitem.Font, FontStyle.Bold);
if (devSettings.HideFromList)
{
lvitem.Font = new Font(lvitem.Font, FontStyle.Italic);
}
}
listDevices.LargeImageList.Images.Add(DeviceIcons.GetIcon(dev.MMDevice.IconPath));
listDevices.Items.Add(lvitem);
cnt++;
}
}
public void SetDefaultEndPoint(string deviceId, EDataFlow flow, IEnumerable <ERole> roles, uint processId)
{
Trace.WriteLine($"ExtendedPolicyClient SetDefaultEndPoint {deviceId} [{flow}] {processId}");
try
{
var stringPtrDeviceId = IntPtr.Zero;
if (!string.IsNullOrWhiteSpace(deviceId))
{
var str = GenerateDeviceId(deviceId, flow);
ComBase.WindowsCreateString(str, (uint)str.Length, out stringPtrDeviceId);
}
foreach (var eRole in roles)
{
PolicyConfig.SetPersistedDefaultAudioEndpoint(processId, flow, eRole, stringPtrDeviceId);
}
}
catch (COMException e) when((e.ErrorCode & ErrorConst.COM_ERROR_MASK) == ErrorConst.COM_ERROR_NOT_FOUND)
{
throw new DeviceNotFoundException($"Can't set default as {deviceId}", e, deviceId);
}
catch (Exception ex)
{
Trace.WriteLine($"{ex}");
}
}
public void OnDefaultDeviceChanged(
[MarshalAs(UnmanagedType.I4)] EDataFlow dataFlow,
[MarshalAs(UnmanagedType.I4)] ERole deviceRole,
[MarshalAs(UnmanagedType.LPWStr)] string defaultDeviceId)
{
parent.FireOnDefaultDeviceChanged(dataFlow, deviceRole, defaultDeviceId);
}
internal void FireOnDefaultDeviceChanged(
[MarshalAs(UnmanagedType.I4)] EDataFlow dataFlow,
[MarshalAs(UnmanagedType.I4)] ERole deviceRole,
[MarshalAs(UnmanagedType.LPWStr)] string defaultDeviceId)
{
//Debug.WriteLine($"OnDefaultDeviceChanged flow={dataFlow} role={deviceRole} device={defaultDeviceId} list={(_OnDefaultDeviceChanged?.GetInvocationList().Length??0)}");
_OnDefaultDeviceChanged?.Invoke(dataFlow, deviceRole, defaultDeviceId);
}
/// <summary>
/// Get Default Endpoint
/// </summary>
/// <param name="dataFlow">Data Flow</param>
/// <param name="role">Role</param>
/// <returns>Device</returns>
public MMDevice GetDefaultAudioEndpoint(EDataFlow dataFlow, Role role)
{
if (_enumerator.HasDefaultAudioEndpoint(dataFlow, role))
{
return(_enumerator.GetDefaultAudioEndpoint(dataFlow, role));
}
return(null);
}
internal void RegisterDevice(EDataFlow RenderType)
{
Device = EndPoints.DeviceEnumerator.GetDefaultAudioEndpoint(RenderType, ERole.eMultimedia);
Value = Device.AudioEndpointVolume.MasterVolumeLevelScalar;
Mute = Device.AudioEndpointVolume.Mute;
Stereo = Device.AudioMeterInformation.Channels.GetCount() > 1;
Device.AudioEndpointVolume.OnVolumeNotification += VolNotify;
}
/// <summary>
/// Called when the default Endpoint device for a given role changes
/// </summary>
/// <param name="flow">The dataflow direction</param>
/// <param name="role">The role</param>
/// <param name="deviceId">The ID of the Endpoint device that is now the default for the specified role</param>
public int OnDefaultDeviceChanged(EDataFlow flow, ERole role, string deviceId)
{
if (flow == EDataFlow.Render && role == ERole.Console)
{
this.DefaultDeviceChanged?.Invoke(deviceId);
}
return(0);
}
private void FormSwitcher_Deactivate(object sender, EventArgs e)
{
Hide();
timer1.Enabled = false;
VolBar.UnregisterDevice();
RenderType = EDataFlow.eRender;
RefreshDevices(false);
VolBar.RegisterDevice(RenderType);
}
internal static string SetPrevDefault(EDataFlow rType)
{
RefreshDeviceList(rType);
if (DefaultDeviceID == 0)
DefaultDeviceID = DeviceNames.Count - 1;
else
DefaultDeviceID--;
SetDefaultDeviceByID(DefaultDeviceID);
return DeviceNames[DeviceIDs[DefaultDeviceID]];
}
internal static string SetNextDefault(EDataFlow rType)
{
RefreshDeviceList(rType);
if (DefaultDeviceID == DeviceNames.Count - 1)
DefaultDeviceID = 0;
else
DefaultDeviceID++;
SetDefaultDeviceByID(DefaultDeviceID);
return DeviceNames[DeviceIDs[DefaultDeviceID]];
}
public void OnDefaultDeviceChanged(EDataFlow flow, ERole role, string defaultDeviceId)
{
try
{
if (DefaultDeviceChanged != null)
{
DefaultDeviceChanged(flow, role, defaultDeviceId);
}
}
catch (Exception ex)
{
}
}
private static void FindApplication(string appName)
{
EDataFlow flow = new EDataFlow();
MMDeviceEnumerator deviceEnum = new MMDeviceEnumerator();
devCol = deviceEnum.EnumerateAudioEndPoints(flow, DEVICE_STATE.DEVICE_STATE_ACTIVE);
for (int devIdx = 0; devIdx < devCol.Count; devIdx++)
{
for (int sesIdx = 0; sesIdx < devCol[devIdx].AudioSessionManager2.Sessions.Count; sesIdx++)
{
if (devCol[devIdx].AudioSessionManager2.Sessions[sesIdx].GetSessionIdentifier.Contains(appName))
devicesAndSessions.Add(new KeyValuePair<int, int>(devIdx, sesIdx));
}
}
}
public static List<string> GetListOfApplicationsWithAudio()
{
List<string> results = new List<string>();
EDataFlow flow = new EDataFlow();
MMDeviceEnumerator deviceEnum = new MMDeviceEnumerator();
devCol = deviceEnum.EnumerateAudioEndPoints(flow, DEVICE_STATE.DEVICE_STATE_ACTIVE);
for (int devIdx = 0; devIdx < devCol.Count; devIdx++)
{
for (int sesIdx = 0; sesIdx < devCol[devIdx].AudioSessionManager2.Sessions.Count; sesIdx++)
{
results.Add(devCol[devIdx].AudioSessionManager2.Sessions[sesIdx].GetSessionIdentifier);
}
}
return results;
}
internal static void RefreshDevices(EDataFlow renderType, bool updateIcons)
{
DeviceNames.Clear();
DeviceIDs.Clear();
if (updateIcons)
DeviceIcons.Clear();
var pDevices = pEnum.EnumerateAudioEndPoints(renderType, EDeviceState.DEVICE_STATE_ACTIVE);
var devCount = pDevices.Count;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
DeviceNames.Add(device.FriendlyName);
DeviceIDs.Add(i, device.ID);
if (updateIcons)
DeviceIcons.Add(device.IconPath);
}
}
private static void FindApplication(string appName)
{
LogHelper.Debug(null, "Finding any mixers that contain the word '{0}'", appName);
EDataFlow flow = new EDataFlow();
MMDeviceEnumerator deviceEnum = new MMDeviceEnumerator();
devCol = deviceEnum.EnumerateAudioEndPoints(flow, DEVICE_STATE.DEVICE_STATE_ACTIVE);
for (int devIdx = 0; devIdx < devCol.Count; devIdx++)
{
for (int sesIdx = 0; sesIdx < devCol[devIdx].AudioSessionManager2.Sessions.Count; sesIdx++)
{
if (devCol[devIdx].AudioSessionManager2.Sessions[sesIdx].GetSessionIdentifier.Contains(appName))
{
LogHelper.Debug(null, "Found {0}", devCol[devIdx].AudioSessionManager2.Sessions[sesIdx].GetSessionIdentifier);
devicesAndSessions.Add(new KeyValuePair<int, int>(devIdx, sesIdx));
}
}
}
}
internal static void RefreshDeviceList(EDataFlow renderType)
{
DeviceNames.Clear();
DeviceIDs.Clear();
var pDevices = DeviceEnumerator.EnumerateAudioEndPoints(renderType, EDeviceState.Active);
var defDeviceID = DeviceEnumerator.GetDefaultAudioEndpoint(renderType, ERole.eMultimedia).ID;
var devCount = pDevices.Count;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
var devID = device.ID;
var devName = device.FriendlyName;
DeviceNames.Add(devID, devName);
DeviceIDs.Add(i, devID);
if (devID == defDeviceID)
{
DefaultDeviceID = i;
DefaultDeviceName = devName;
}
}
}
private void ChangeDeviceState(EDataFlow rType, bool toggleMute, int volChange, bool showOSD)
{
var MMDevice = EndPoints.GetDefaultMMDevice(rType);
if (toggleMute)
{
var mute = MMDevice.AudioEndpointVolume.Mute = !MMDevice.AudioEndpointVolume.Mute;
if (showOSD)
Program.frmOSD.ChangeMute(mute, MMDevice.AudioEndpointVolume.MasterVolumeLevelScalar);
}
else if (volChange != 0)
{
var vol = CalcVol(MMDevice.AudioEndpointVolume.MasterVolumeLevelScalar, volChange);
MMDevice.AudioEndpointVolume.MasterVolumeLevelScalar = vol;
if (showOSD)
Program.frmOSD.ChangeVolume(vol);
}
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
if (Program.settings.QuickSwitchEnabled && !DeactivatedOnIcon)
{
notifyIcon.ContextMenuStrip = null;
QuickSwitchDevice(false, Program.settings.DefaultDataFlow, Program.settings.QuickSwitchShowOSD);
}
else
notifyIcon.ContextMenuStrip = trayMenu;
return;
}
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
return;
SetSizes();
}
private void RefreshDevices(EDataFlow renderType)
{
listDevices.Clear();
DeviceIcons.Clear();
listDevices.BeginUpdate();
var pDevices = EndPoints.DeviceEnumerator.EnumerateAudioEndPoints(renderType, EDeviceState.Active);
if (pDevices.Count > 0)
{
var defaultDev = EndPoints.DeviceEnumerator.GetDefaultAudioEndpoint(renderType, ERole.eMultimedia).ID;
var devCount = pDevices.Count;
for (var i = 0; i < devCount; i++)
{
var device = pDevices[i];
var devID = device.ID;
DeviceIcons.Add(device.IconPath);
var devSettings = Program.settings.Device.Find(x => x.DeviceID == devID);
if (devSettings == null || !devSettings.HideFromList)
{
var item = new ListViewItem
{
ImageIndex = i,
Text = device.FriendlyName,
Selected = devID == defaultDev,
Tag = devID,
};
listDevices.Items.Add(item);
if (devID == defaultDev)
{
SetDeviceIcon(i, true);
SetTrayIcons();
}
}
}
}
listDevices.EndUpdate();
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
return;
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
if (ModifierKeys.HasFlag(Keys.Alt))
{
ChangeDeviceState(rType, true, 0, true);
}
else
{
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
return;
SetSizes();
}
}
internal DeviceInfo(string deviceId, string name, EDataFlow flow, DeviceState state, WAVEFORMATEXTENSIBLE format)
{
_deviceId = deviceId;
_friendlyName = name;
_dataFlow = flow;
_state = state;
_format = new WAVEFORMATEXTENSIBLE(format);
}
public void OnDefaultDeviceChanged(EDataFlow flow, ERole role, string defaultDeviceId)
{
throw new NotImplementedException();
}
internal static MMDevice GetDefaultMMDevice(EDataFlow renderType)
{
return DeviceEnumerator.GetDefaultAudioEndpoint(renderType, ERole.eMultimedia);
}
internal void RegisterDevice(EDataFlow RenderType)
{
if (EndPoints.DeviceNames.Count == 0) return;
Device = EndPoints.pEnum.GetDefaultAudioEndpoint(RenderType, ERole.eMultimedia);
Value = Device.AudioEndpointVolume.MasterVolumeLevelScalar;
Mute = Device.AudioEndpointVolume.Mute;
Stereo = Device.AudioMeterInformation.Channels.GetCount() > 1;
Device.AudioSessionManager.Sessions[0].RegisterAudioSessionNotification(volEvents);
Device.AudioEndpointVolume.OnVolumeNotification += VolNotify;
}
internal void RegisterDevice(EDataFlow RenderType)
{
Device = EndPoints.DeviceEnumerator.GetDefaultAudioEndpoint(RenderType, ERole.eMultimedia);
Value = Device.AudioEndpointVolume.MasterVolumeLevelScalar;
Mute = Device.AudioEndpointVolume.Mute;
Stereo = Device.AudioMeterInformation.Channels.GetCount() > 1;
Device.AudioEndpointVolume.OnVolumeNotification += VolNotify;
}
public void loadFromXML(XmlTextReader aXMLTextReader)
{
var lReader = new XMLAttributeReader(aXMLTextReader);
var lChecker = new RepeatItemNameChecker();
string lItem = lReader.getAttribute<String>("ArrayItem");
lChecker.addItemName(lItem);
mArrayValueItemHandle = mItemBrowser.getItemHandleByName(lItem);
mDataFlow = (EDataFlow)Enum.Parse(typeof(EDataFlow), lReader.getAttribute<String>("DataFlow", mDataFlow.ToString()));
#region Elements
if (aXMLTextReader.IsEmptyElement == false)
{
aXMLTextReader.Read();
if (aXMLTextReader.Name.Equals("Elements", StringComparison.Ordinal))
{
if (aXMLTextReader.IsEmptyElement == false)
{
List<int> lIndexes = new List<int>();
List<int> lItems = new List<int>();
var lIndexSet = new HashSet<int>();
int lMaxIndex = -1;
int lIndex;
aXMLTextReader.Read();
while (aXMLTextReader.Name.Equals("Element", StringComparison.Ordinal))
{
lIndex = (int)lReader.getAttribute<UInt32>("Index");
if (lIndexSet.Add(lIndex) == false)
{
throw new ArgumentException("Index '" + lIndex.ToString() + "' already exists. ");
}
lIndexes.Add(lIndex);
if (lIndex > lMaxIndex)
{
lMaxIndex = lIndex;
}
lItem = lReader.getAttribute<String>("Item");
lChecker.addItemName(lItem);
lItems.Add(mItemBrowser.getItemHandleByName(lItem));
aXMLTextReader.Read();
}
if (lIndexes.Count != 0)
{
mElementItemHandles = new int[lMaxIndex + 1];
for (int i = 0; i < mElementItemHandles.Length; i++)
{
mElementItemHandles[i] = -1;
}
mElementValueChanged = new bool[mElementItemHandles.Length];
mArrayValue = new object[mElementItemHandles.Length];
int lCount = lIndexes.Count;
for (int i = 0; i < lCount; i++)
{
lIndex = lIndexes[i];
mElementItemHandles[lIndex] = lItems[i];
}
}
}
aXMLTextReader.Read();
}
}
#endregion
}
private void FormSwitcher_Deactivate(object sender, EventArgs e)
{
Hide();
timer1.Enabled = false;
RenderType = Program.settings.DefaultDataFlow;
RefreshDevices(RenderType);
VolBar.RegisterDevice(RenderType);
var iconpos = WindowPosition.GetNotifyIconArea(notifyIcon);
var iconrect = new Rectangle(iconpos.left, iconpos.top, iconpos.right - iconpos.left, iconpos.bottom - iconpos.top);
if (iconrect.Contains(Cursor.Position))
DeactivatedOnIcon = true;
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (ModifierKeys == Keys.Shift)
{
Close();
Application.Exit();
return;
}
VolBar.UnregisterDevice();
RenderType = ModifierKeys.HasFlag(Keys.Control) ? EDataFlow.eCapture : EDataFlow.eRender;
if (ModifierKeys.HasFlag(Keys.Alt))
{
RefreshDevices(false);
VolBar.RegisterDevice(RenderType);
VolBar.ChangeMute();
VolBar.UnregisterDevice();
if (RenderType == EDataFlow.eCapture && !Program.stfu)
{
var mutetxt = String.Format("Device {0}muted", VolBar.Mute ? "" : "un");
notifyIcon.ShowBalloonTip(0, mutetxt, EndPoints.DeviceNames[CurrentDevice], ToolTipIcon.Info);
}
RenderType = EDataFlow.eRender;
RefreshDevices(false);
VolBar.RegisterDevice(RenderType);
return;
}
RefreshDevices(true);
if (e.Button == MouseButtons.Left)
SetSizes();
}
internal MMDeviceCollection(IMMDeviceCollection parent, EDataFlow flow, EDeviceState state)
{
_MMDeviceCollection = parent;
DataFlow = flow;
DeviceState = state;
}
private void QuickSwitchDevice(bool previous, EDataFlow rType, bool showOSD)
{
var devName = previous ? EndPoints.SetPrevDefault(rType) : EndPoints.SetNextDefault(rType);
if (showOSD)
Program.frmOSD.ChangeDevice(devName);
}
private void HotKeyPressed()
{
if (Visible) return; // Let's not make it complicated here...
VolBar.UnregisterDevice();
RenderType = EDataFlow.eRender;
RefreshDevices(false);
if (EndPoints.DeviceNames.Count == 0) return;
CurrentDevice = CurrentDevice == EndPoints.DeviceNames.Count - 1 ? 0 : CurrentDevice + 1;
EndPoints.SetDefaultDevice(CurrentDevice);
if (!Program.stfu)
notifyIcon.ShowBalloonTip(0, "Audio device changed", EndPoints.DeviceNames[CurrentDevice], ToolTipIcon.Info);
}
private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (var cfg = new FormSettings())
{
RenderType = Program.settings.DefaultDataFlow;
RefreshDevices(RenderType);
cfg.ShowDialog();
ledLeft.OldStyle = Program.settings.ColorVU;
ledRight.OldStyle = Program.settings.ColorVU;
SetTrayIcons();
}
}
public void OnDefaultDeviceChanged(EDataFlow flow, ERole role, string defaultDeviceId)
{
var inner = GetInner();
if(inner != null)
inner.OnDefaultDeviceChanged(flow, role, defaultDeviceId);
}
