static void Main(string[] args)
{
var deviceEnum = new MMDeviceEnumerator() as IMMDeviceEnumerator;
IMMDevice defaultDevice;
Marshal.ThrowExceptionForHR(deviceEnum.GetDefaultAudioEndpoint(0, 1, out defaultDevice));
IAudioEndpointVolume master;
var aevId = typeof(IAudioEndpointVolume).GUID;
Marshal.ThrowExceptionForHR(defaultDevice.Activate(ref aevId, 23, 0, out master));
var muting = !(args.Length > 0 && args[0] == "unmute");
Console.WriteLine(muting ? "Muting..." : "Unmuting...");
Marshal.ThrowExceptionForHR(master.SetMute(muting, Guid.Empty));
}
public ExclusiveAudioInput()
{
_devices = new MMDeviceEnumerator();
MMDevice dev = null;
if (_devices != null)
{
foreach (MMDevice device in _devices.EnumerateAudioEndPoints(EDataFlow.eCapture, DeviceState.DEVICE_STATE_ACTIVE))
{
dev = device;
break;
}
}
if (dev != null)
{
SelectDevice(dev.Id);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
progressBar1.Maximum = _progressTotal;
progressBar1.Value = _progress;
progressBar1.Refresh();
MMDeviceEnumerator de = new MMDeviceEnumerator();
MMDevice device = de.GetDevice(_activeDevice.DeviceId);
//var device = de.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Multimedia);
//<-- veikia Default input device
//var device = (MMDevice)de.GetDevice(DeviceName); // <-- niaveikia, crashina, jei nori pasirinkt device is comboBoxo
// greiciausiai nes neatitinka DeviceName gautas is WaveIn ir MMDevice ID.
peak_L.Value = (int)(device.AudioMeterInformation.MasterPeakValue * 50 + 0.25);
peak_R.Value = (int)(device.AudioMeterInformation.MasterPeakValue * 50 + 0.25);
peak_L.Refresh();
peak_R.Refresh();
}
private void InitialiseWasapiControls()
{
var enumerator = new MMDeviceEnumerator();
var endPoints = enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
var comboItems = new List <WasapiDeviceComboItem>();
foreach (var endPoint in endPoints)
{
var comboItem = new WasapiDeviceComboItem();
comboItem.Description = string.Format("{0} ({1})", endPoint.FriendlyName, endPoint.DeviceFriendlyName);
comboItem.Device = endPoint;
comboItems.Add(comboItem);
}
comboBoxWaspai.DisplayMemberPath = "Description";
comboBoxWaspai.SelectedValuePath = "Device";
comboBoxWaspai.ItemsSource = comboItems;
comboBoxWaspai.SelectedIndex = Preferences.WasapiOutDevice.Value;
checkBoxWasapiEventCallback.IsChecked = bool.Parse(Preferences.WasapiOutIsEventCallback);
checkBoxWasapiExclusiveMode.IsChecked = bool.Parse(Preferences.WasapiOutExclusiveMode);
}
public Ears(Manager manager)
{
m_manager = manager;
m_volumeQueue = new Queue <int>();
MMDeviceEnumerator SndDevEnum = new MMDeviceEnumerator();
if (Properties.Settings.Default.AudioDevice != "")
{
SndDevice = SndDevEnum.GetDevice(Properties.Settings.Default.AudioDevice);
}
else
{
SndDevice = SndDevEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
}
listenTimer = new Timer();
listenTimer.Interval = 500;
listenTimer.Tick += new EventHandler(ListenTimerTick);
listenTimer.Enabled = true;
}
public void CursorPosition()
{
MMDeviceEnumerator de = new MMDeviceEnumerator();
MMDevice device = de.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
Point cursor = new Point();
while (1 == 1)
{
GetCursorPos(ref cursor);
try
{
//d.Invoke("X: " + cursor.X + " Y: " + cursor.Y, (int)(device.AudioMeterInformation.MasterPeakValue * 100) );
}
catch
{ }
Thread.Sleep(500);
}
}
private void _tmex_Tick(object sender, EventArgs e)
{
MMDeviceEnumerator devEnum = new MMDeviceEnumerator();
MMDeviceCollection EnumDevice = devEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
MMDevice dd = devEnum.GetDevice(EnumDevice[0].ID);
float lvl = dd.AudioMeterInformation.MasterPeakValue;//EnumDevice[0].AudioMeterInformation.PeakValues[0];
if (lvl <= 0.01f)
{
wss.SendMsg("0:en-US");
wv_state = false;
label1.Text = wv_state.ToString();
_tmex.Stop();
}
else
{
_tmex.Stop();
}
}
private void UpdateRecoderProviders()
{
var devices = new MMDeviceEnumerator();
var builder = ImmutableArray.CreateBuilder <RecoderProvider>();
builder.Add(DefaultCaptureDeviceRecoderProvider.Default);
builder.AddRange(
devices.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active)
.Select(x => new CaptureDeviceRecoderProvider(x))
);
builder.Add(DefaultRenderDeviceRecoderProvider.Default);
builder.AddRange(
devices.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active)
.Select(x => new RenderDeviceRecoderProvider(x))
);
this._store.RecoderProviders = builder.ToImmutable();
}
public float GetMicrophoneVolumeLevel()
{
float volume = 0.0f;
MMDeviceEnumerator deviceEnumerator = (MMDeviceEnumerator)(new MMDeviceEnumerator());
foreach (MMDevice microphone in deviceEnumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active))
{
if (microphone.ID == this.MicrophoneId)
{
volume = microphone.AudioMeterInformation.MasterPeakValue;
microphone.Dispose();
break;
}
else
{
microphone.Dispose();
}
}
deviceEnumerator.Dispose();
return(volume * 100);
}
private void ChangeVolume(CompatibilityMode Mode, Method ChangeMethod)
{
if (Mode == CompatibilityMode.Compatible)
{
FaderMixerControl fmx = ((MixerLine)Mixer.OpenMixer(0).DestinationLines[0]).VolumeControl;
int iPercent = (fmx.Maximum / 100) * _Settings.Percent;
iPercent = ChangeMethod == Method.VolumeUp ? iPercent : -iPercent;
fmx.Values = fmx.Values.Select(i => i = GetCompatibleVolumeRange(i + iPercent, fmx.Minimum, fmx.Maximum)).ToArray();
}
else
{
MMDeviceEnumerator devEnum = new MMDeviceEnumerator();
MMDevice defaultDevice = devEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
float fPercent = (float)_Settings.Percent / 100F;
fPercent = ChangeMethod == Method.VolumeUp ? fPercent : -fPercent;
float newValue = defaultDevice.AudioEndpointVolume.MasterVolumeLevelScalar + fPercent;
defaultDevice.AudioEndpointVolume.MasterVolumeLevelScalar = GetCompatibleVolumeRange(newValue, 0F, 1F);
}
}
public MainWindow()
{
InitializeComponent();
//------------Hide App When starts-------------//
this.Hide();
//------------START NAUDIO DEVICES-------------//
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active).ToList();
//------------List Devices Naudio Library-------------//
comboBox1.ItemsSource = devices;
comboBox1.SelectedIndex = 0;
//------------Start AlienFX Controller-------------//
var lightFX = new LightFXController();
var result = lightFX.LFX_Initialize();
RadioWinTheme.IsChecked = true;
//dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
dispatcherTimer.Tick += new EventHandler((sender, e) => dispatcherTimer_Tick(sender, e, lightFX));
}
public void SetMute(IntPtr hWnd, bool isMute)
{
var deviceEnumerator = new MMDeviceEnumerator();
var device = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
GetWindowThreadProcessId(hWnd, out var processId);
var sessions = device.AudioSessionManager.Sessions;
var sessionCount = sessions.Count;
for (var i = 0; i < sessionCount; i++)
{
var session = device.AudioSessionManager.Sessions[i];
if (session.GetProcessID != processId)
{
continue;
}
session.SimpleAudioVolume.Mute = isMute;
}
}
/// <summary>
/// 获取所有麦克风设备(音频输入设备)
/// </summary>
/// <returns></returns>
public static List <SimpleModel> GetMicrophoneDevices()
{
var enumerator = new MMDeviceEnumerator();
var captureDevices = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToArray();
var microphoneList = new List <SimpleModel>();
if (captureDevices.Length > 0)
{
for (int i = 0; i < captureDevices.Length; i++)
{
SimpleModel microphone = new SimpleModel
{
Id = i + 1,
Value = captureDevices[i].FriendlyName
};
microphoneList.Add(microphone);
}
}
return(microphoneList);
}
private void EnumerateOutputDevices()
{
Console.WriteLine("EnumerateOutputDevices");
//create enumerator
var enumerator = new MMDeviceEnumerator();
//cycle trough all audio render devices
for (int i = 0; i < WaveOut.DeviceCount; i++)
{
Console.WriteLine($"==> {i} {enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active)[i]}");
}
//clean up
enumerator.Dispose();
Console.WriteLine("DirectSoundOut");
foreach (var dev in DirectSoundOut.Devices)
{
Console.WriteLine($"{dev.Guid} {dev.ModuleName} {dev.Description}");
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
windowVolume = new VolumeWindow();
windowVolume.Show();
new AltTab().HideAltTab(this);
DevEnum = new MMDeviceEnumerator();
device = DevEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
device.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
Layout.ResizeWindow(IconData.dictIcon.Count, 1);
Layout.RefreshPositionList(0);
AnimateWindow(0, true);
/*MMDeviceCollection collect = DevEnum.EnumerateAudioEndPoints(EDataFlow.eRender, EDeviceState.DEVICE_STATEMASK_ALL);
* for (int i = 0; i < collect.Count; i++) {
* collect[i].AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
* }
*/
}
private void Refresh()
{
var playbackTask = Task <ICollection <DeviceFullInfo> > .Factory.StartNew((() =>
{
using (var enumerator = new MMDeviceEnumerator())
{
return(CreateDeviceList(enumerator.EnumerateAudioEndPoints(DataFlow.Render, _state)));
}
}));
var recordingTask = Task <ICollection <DeviceFullInfo> > .Factory.StartNew((() =>
{
using (var enumerator = new MMDeviceEnumerator())
{
return(CreateDeviceList(enumerator.EnumerateAudioEndPoints(DataFlow.Capture, _state)));
}
}));
PlaybackDevices = playbackTask.Result;
RecordingDevices = recordingTask.Result;
}
public MainWindow()
{
InitializeComponent();
waveOut = new WaveOutEvent();
enumerator = new MMDeviceEnumerator();
enumerator.RegisterEndpointNotificationCallback(this);
var signalGenerator = new SignalGenerator()
{
Frequency = 15
};
waveOut.Init(signalGenerator);
// Start minimized
Hide();
PlaySignalToSpeaker();
}
private void Form1_Load(object sender, EventArgs e)
{
//var menu = new MenuStrip();
Console.WriteLine("Program By Scary Tiger (Mr Tiger)");
//console.ReadLine();
if (progressBar1.Value != 0)
{
progressBar1.Visible = false;
}
MMDeviceEnumerator names = new MMDeviceEnumerator();
var devices = names.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
foreach (var device in devices)
{
comboBox1.Items.Add(device.FriendlyName);
}
//(device.FriendlyName);
}
public void SetSkypeVolume(float delta)
{
if (skype != null)
{
// get the speakers (1st render + multimedia) device
MMDeviceEnumerator deviceEnumerator = (MMDeviceEnumerator)(new MMDeviceEnumerator());
MMDevice speakers = deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
for (int i = 0; i < speakers.AudioSessionManager.Sessions.Count; i++)
{
AudioSessionControl ctl = speakers.AudioSessionManager.Sessions[i];
if (ctl.ProcessID == skype.Id)
{
try
{
ctl.SimpleAudioVolume.MasterVolume += delta;
}
catch
{
try
{
if (delta > 0)
{
ctl.SimpleAudioVolume.MasterVolume += 0.005f;
}
else if (delta < 0)
{
ctl.SimpleAudioVolume.MasterVolume -= 0.005f;
}
}
catch
{
}
}
VolumeStatus.SetSkypeVol(ctl.SimpleAudioVolume.MasterVolume);
}
}
}
}
public void SetSpotifyVolume(float delta)
{
// get the speakers (1st render + multimedia) device
MMDeviceEnumerator deviceEnumerator = (MMDeviceEnumerator)(new MMDeviceEnumerator());
MMDevice speakers = deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
for (int i = 0; i < speakers.AudioSessionManager.Sessions.Count; i++)
{
AudioSessionControl ctl = speakers.AudioSessionManager.Sessions[i];
uint dn = ctl.ProcessID;
if (spotifies.Where(value => value.Id == dn).Count() > 0)
{
try
{
ctl.SimpleAudioVolume.MasterVolume += delta;
}
catch
{
try
{
if (delta > 0)
{
ctl.SimpleAudioVolume.MasterVolume += 0.005f;
}
else if (delta < 0)
{
ctl.SimpleAudioVolume.MasterVolume -= 0.005f;
}
}
catch
{
}
}
VolumeStatus.SetSpotifyVol(ctl.SimpleAudioVolume.MasterVolume);
//ctl.MasterVolume += delta;
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
try //extending visual threshold beyond limit
{
var value = device.AudioMeterInformation.MasterPeakValue * 100 * 1.5; //increasing data amplitude by 1.5x incase volume is very low
if (value > 100)
{
progressBar1.Value = 100;
progressBar2.Value = 100;
}
progressBar1.Value = (int)value;
progressBar2.Value = (int)value;
// get whatever track and playlist is playing
labelCurrentSong.Text = axWindowsMediaPlayer1.currentMedia.name;
labelCurrentPlaylist.Text = axWindowsMediaPlayer1.currentPlaylist.name;
}
catch
{
}
//networkpath + "\\" + mp3name
DirectoryInfo di = new DirectoryInfo(networkpath);
FileInfo[] fi = di.GetFiles("*.mp3", SearchOption.AllDirectories);
int filecount = fi.Length;
if (filecount == listBoxSongs.Items.Count)
{
return;//donothing if equal, sort it out if not
}
else
{
//allow all clients to keep track of SHAREMEDIA FILE updates
SongToList();
}
}
public AudioManagerImpl(ILogger logger, string mainAudioOut, int defaultSpeakersVolume, int defaultMicrophoneVolume)
{
_mainAudioOut = mainAudioOut;
_logger = logger;
if (Debugger.IsAttached)
{
return;
}
try
{
var enumerator = new MMDeviceEnumerator();
var devs = enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
foreach (var dev in devs)
{
dev.AudioEndpointVolume.MasterVolumeLevelScalar = 1.0f;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Print("Could not enumerate devices due to an excepion: " + ex.Message);
}
SpeakersVolume = defaultSpeakersVolume;
try
{
var enumerator = new MMDeviceEnumerator();
var dev = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
SpeakersVolume = (int)(dev.AudioEndpointVolume.MasterVolumeLevelScalar * 100);
dev.AudioEndpointVolume.Mute = false;
}
catch (Exception ex)
{
_logger.Error(this, "Could not enumerate devices due to an excepion: " + ex.Message);
}
MicrophoneVolume = defaultMicrophoneVolume;
}
public IEnumerable <string> GetSystemInfo()
{
var deviceEnumerator = new MMDeviceEnumerator();
var device = deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole);
var deviceCollection = deviceEnumerator.EnumerateAudioEndPoints(EDataFlow.eRender, DEVICE_STATE.DEVICE_STATE_ACTIVE);
var result = new List <string> {
"Machine Name: " + Environment.MachineName,
"Default Device: " + device.FriendlyName,
"", "All Devices",
};
var tempDeviceList = new List <MMDevice>();
for (int i = 0; i < deviceCollection.Count; i++)
{
MMDevice item = deviceCollection[i];
tempDeviceList.Add(item);
}
result.AddRange(tempDeviceList.OrderBy(d => d.FriendlyName).Select(d => d.FriendlyName).ToList());
Terminal.PrintOutput("GET: SystemInfo...Success");
return(result);
}
private void EnsureAudioDevice()
{
if (_audioDevice == null)
{
var devEnum = new MMDeviceEnumerator();
try
{
_audioDevice = devEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
}
catch (Exception ex)
{
_logger.ErrorException("Error attempting to discover default audio device", ex);
return;
}
_audioDevice.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
_lastMuteValue = _audioDevice.AudioEndpointVolume.Mute;
_lastVolumeValue = _audioDevice.AudioEndpointVolume.MasterVolumeLevelScalar;
}
}
//Get audio devices to play audio out
private void SetDevices()
{
using (var mmdeviceEnumerator = new MMDeviceEnumerator())
{
using (
var mmdeviceCollection = mmdeviceEnumerator.EnumAudioEndpoints(DataFlow.Render, DeviceState.Active))
{
foreach (var device in mmdeviceCollection)
{
audioDevice.Items.Add(device);
}
}
}
if (audioDevice.Items.Count <= 0)
{
throw new Exception("No audio devices found!");
}
audioDevice.SelectedIndex = 0;
activeDevice = (MMDevice)audioDevice.SelectedItem;
}
private void RestoreAudioVolume()
{
if (_AdjustAudioCarriedOut)
{
try
{
var deviceEnumerator = new MMDeviceEnumerator();
var device = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
var sess = device.AudioSessionManager.Sessions;
// restore master volume and mute status
device.AudioEndpointVolume.MasterVolumeLevelScalar = _LastMasterVolume;
device.AudioEndpointVolume.Mute = _LastMasterMuteStatus;
Thread.Sleep(200);
SendMuteCommandToSessions(false);
}
catch (Exception) { }
_AdjustAudioCarriedOut = false;
}
}
public override void UpdateLights(EffectFrame frame)
{
if (Global.Configuration.volume_overlay_settings.enabled)
{
Queue <EffectLayer> layers = new Queue <EffectLayer>();
EffectLayer volume_bar = new EffectLayer("Overlay - Volume Bar");
MMDeviceEnumerator devEnum = new MMDeviceEnumerator();
MMDevice defaultDevice = devEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
float currentVolume = defaultDevice.AudioEndpointVolume.MasterVolumeLevelScalar;
ColorSpectrum volume_spec = new ColorSpectrum(Global.Configuration.volume_overlay_settings.low_color, Global.Configuration.volume_overlay_settings.high_color);
volume_spec.SetColorAt(0.75f, Global.Configuration.volume_overlay_settings.med_color);
volume_bar.PercentEffect(volume_spec, Global.Configuration.volume_overlay_settings.sequence, currentVolume, 1.0f);
layers.Enqueue(volume_bar);
frame.AddOverlayLayers(layers.ToArray());
}
}
/// <summary>
/// Set the device volume.
/// </summary>
/// <param name="level">The volume level. (between 0.0 and 1.0)</param>
public static void SetSpeakerVolume(float level)
{
// Get the device.
MMDeviceEnumerator DevEnum = new MMDeviceEnumerator();
MMDeviceCollection devices = DevEnum.EnumerateAudioEndPoints(EDataFlow.Render, EDeviceState.Active);
for (int i = 0; i < devices.Count; i++)
{
MMDevice deviceAt = devices[i];
// Find the device.
if (deviceAt.FriendlyName.ToLower().Contains("speakers") || deviceAt.DataFlow == EDataFlow.Render)
{
// If device found.
if (deviceAt != null)
{
// Mute or un mute the device.
deviceAt.AudioEndpointVolume.MasterVolumeLevelScalar = level;
}
}
}
}
/// <summary>
/// Mute all microphones.
/// </summary>
/// <param name="mute">True to mute; else false.</param>
public static void MuteMicrophone(bool mute)
{
// Get the device.
MMDeviceEnumerator DevEnum = new MMDeviceEnumerator();
MMDeviceCollection devices = DevEnum.EnumerateAudioEndPoints(EDataFlow.Capture, EDeviceState.Active);
for (int i = 0; i < devices.Count; i++)
{
MMDevice deviceAt = devices[i];
// Find the device.
if (deviceAt.FriendlyName.ToLower().Contains("microphone") || deviceAt.DataFlow == EDataFlow.Capture)
{
// If device found.
if (deviceAt != null)
{
// Mute or un mute the device.
deviceAt.AudioEndpointVolume.Mute = mute;
}
}
}
}
/// <summary>
/// Mute all output devices.
/// </summary>
/// <param name="mute">True to mute; else false.</param>
public static void MuteVolume(bool mute)
{
// Get the device.
MMDeviceEnumerator DevEnum = new MMDeviceEnumerator();
MMDeviceCollection devices = DevEnum.EnumerateAudioEndPoints(EDataFlow.Render, EDeviceState.Active);
for (int i = 0; i < devices.Count; i++)
{
MMDevice deviceAt = devices[i];
// If device found.
if (deviceAt != null)
{
try
{
// Mute or un mute the device.
deviceAt.AudioEndpointVolume.Mute = mute;
}
catch { }
}
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
if (devices != null)
{
microphone = devices.FirstOrDefault();
}
if (microphone == null)
{
deviceEnumerator = new MMDeviceEnumerator();
devices = deviceEnumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
if (devices != null)
{
microphone = devices.FirstOrDefault();
}
if (microphone == null)
{
Application.Exit();
}
}
while (microphone != null)
{
_dbLevel = microphone.AudioMeterInformation.MasterPeakValue;
if (_dbLevel > _threshold)
{
loopWorker.ReportProgress((int)(_dbLevel * 100));
System.Threading.Thread.Sleep((int)inputDelay.Value);
}
else
{
loopWorker.ReportProgress(0);
}
System.Threading.Thread.Sleep(5);
}
}
/// <summary>
/// Locate all connected audio devices based on the given state.
/// </summary>
/// <param name="deviceState"></param>
/// <returns></returns>
public IReadOnlyCollection <AudioDevice> LocateConnectedAudioDevices(DeviceState deviceState = DeviceState.Active)
{
var enumerator = new MMDeviceEnumerator();
var relatedAudioDevices = new ConcurrentDictionary <string, List <MMDevice> >();
var audioDevices = new List <AudioDevice>();
// Locate all connected audio devices.
foreach (var device in enumerator.EnumerateAudioEndPoints(DataFlow.All, deviceState))
{
// Gets the DataFlow and DeviceID from the connected audio device.
var index = device.ID.LastIndexOf('.');
var dataFlow = device.ID.Substring(0, index).Contains("0.0.0") ? DataFlow.Render : DataFlow.Capture;
var deviceId = device.ID.Substring(index + 1);
// Gets the unique hardware token.
var hardwareToken = GetHardwareToken(dataFlow, deviceId);
var audioDevice = relatedAudioDevices.GetOrAdd(hardwareToken, o => new List <MMDevice>());
audioDevice.Add(device);
}
// Combines the related devices into a headset object.
foreach (var devicePair in relatedAudioDevices)
{
var capture = devicePair.Value.FirstOrDefault(o => o.ID.Contains("0.0.1"));
var render = devicePair.Value.FirstOrDefault(o => o.ID.Contains("0.0.0"));
if (capture != null && render != null)
{
audioDevices.Add(new Headset("Headset", render.DeviceFriendlyName, capture, render));
}
else if (render != null)
{
audioDevices.Add(new AudioDevice("Headset", render.DeviceFriendlyName, render));
}
}
return(new ReadOnlyCollection <AudioDevice>(audioDevices));
}
public SharedAudioInput()
{
_devices = new MMDeviceEnumerator();
_devices.OnDeviceAdded += (s, e) => { UpdateDeviceInfo(); };
_devices.OnDeviceRemoved += (s, e) => { UpdateDeviceInfo(true); };
_devices.OnDeviceStateChanged += (s, e) => { UpdateDeviceInfo(); };
_devices.OnPropertyValueChanged += (s, e) => { UpdateDeviceInfo(); };
_devices.OnDefaultDeviceChanged += (s, e) => { UpdateDeviceInfo(); };
_thread = new Thread(new ThreadStart(mainThread));
_thread.Start();
}
