private void LoadAudioDevices()
{
try
{
//Instantiate an Enumerator to find audio devices
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDeviceCollection DevCol = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.All, NAudio.CoreAudioApi.DeviceState.All);
//Loop through all devices
foreach (NAudio.CoreAudioApi.MMDevice dev in DevCol)
{
try
{
//Get its audio volume
System.Diagnostics.Debug.Print("Volume of " + dev.FriendlyName + " is " + dev.AudioEndpointVolume.MasterVolumeLevel.ToString());
//Get its audio volume
System.Diagnostics.Debug.Print(dev.AudioEndpointVolume.MasterVolumeLevel.ToString());
cmbDeviceList.Items.Add(dev.FriendlyName);
devices.Add(dev);
}
catch (Exception ex)
{
//Do something with exception when an audio endpoint could not be muted
System.Diagnostics.Debug.Print(dev.FriendlyName + " could not be loaded");
}
}
cmbDeviceList.SelectedIndex = 0;
}
catch (Exception ex)
{
//When something happend that prevent us to iterate through the devices
System.Diagnostics.Debug.Print("Could not enumerate devices due to an exception: " + ex.Message);
}
}
private void initAudioDev()
{
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDeviceCollection DevCol = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.All, NAudio.CoreAudioApi.DeviceState.Active);
//Loop through all devices
foreach (NAudio.CoreAudioApi.MMDevice dev in DevCol)
{
try
{
if (dev.FriendlyName.Contains("Headphone") || dev.FriendlyName.Contains("Speakers"))
{
//Get its audio volume
System.Diagnostics.Debug.Print("Volume of " + dev.FriendlyName + " is " + dev.AudioEndpointVolume.MasterVolumeLevel.ToString());
audioDev = dev;
return;
}
}
catch (Exception ex)
{
//Do something with exception when an audio endpoint could not be muted
System.Diagnostics.Debug.Print(dev.FriendlyName + " could not be muted" + ex.Message);
}
}
}
static void Main(string[] args)
{
string driverName = "Stereo Mix"; // any device name you want to enable
MMDevice mMDevice;
using (var enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator())
{
mMDevice = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Disabled).ToList().Where(d => d.FriendlyName.ToLower().Contains(driverName.ToLower())).FirstOrDefault();
}
if (mMDevice != null)
{
driverName = mMDevice.FriendlyName;
int charLocation = driverName.IndexOf("(", StringComparison.Ordinal);
if (charLocation > 0)
{
driverName = driverName.Substring(0, charLocation);
driverName = driverName.Trim();
}
}
else
{
MessageBox.Show($"{driverName} Coudn't Found as Disabled Device.");
return;
}
TryEnable(driverName, mMDevice);
}
/// <summary>
/// Gets all system sound devices
/// </summary>
/// <returns></returns>
public static string[] GetOutputDevices()
{
var enumerator = new MMDeviceEnumerator();
return enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active).
Select(endpoint => endpoint.FriendlyName).ToArray();
}
public Form1()
{
InitializeComponent();
MMDeviceEnumerator deviceEnumerator = new MMDeviceEnumerator();
var devices = deviceEnumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
comboBox1.Items.AddRange(devices.ToArray());
BPPL1167 radio = new BPPL1167();
radio.Initialize("COM3");
PL1167Status currentState = radio.ReadStatusReg();
bool set = radio.SetRadioChannel(33);
int channel = radio.GetRadioChannel();
int syncword0 = radio.GetSyncWord0();
LyteController controller = new LyteController(radio);
lyte = new Lyte(0, TransmissionMode.Multicast);
controller.Add((short)0, lyte);
lyte.TurnOn();
timer1.Interval= 10;
timer1.Enabled = true;
}
public static bool ToggleMuteWindowsAudioDevices(bool muted = false)
{
//Instantiate an Enumerator to find audio devices
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDeviceCollection DevCol = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.All, NAudio.CoreAudioApi.DeviceState.All);
//Loop through all devices
foreach (NAudio.CoreAudioApi.MMDevice dev in DevCol)
{
try
{
//Show us the human understandable name of the device
//System.Diagnostics.Debug.Print(dev.FriendlyName);
if (dev.State == DeviceState.Active)
{
//[Un]Mute it
dev.AudioEndpointVolume.Mute = muted;
}
}
catch (Exception ex)
{
//Do something with exception when an audio endpoint could not be muted
return(false);
}
}
return(true);
}
public Array GetSourcesArray()
{
NAudio.CoreAudioApi.MMDeviceEnumerator enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.Capture, DeviceState.Active);
return(devices.ToArray());
}
private void LoadWasapiDevicesCombo()
{
var deviceEnum = new MMDeviceEnumerator();
var devices = deviceEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
comboWasapiDevices.DataSource = devices;
comboWasapiDevices.DisplayMember = "FriendlyName";
}
public void LoadWasapiDevices()
{
var deviceEnum = new MMDeviceEnumerator();
var devices = deviceEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
audioDeviceComboBox.DataSource = devices.Count == 0 ? null : devices;
audioDeviceComboBox.DisplayMember = "FriendlyName";
}
public List<AudioDevice> Get()
{
var result = new List<AudioDevice>();
var enumerator = new MMDeviceEnumerator();
for (var i = 0; i < enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active).Count; i++)
{
var endpoint = enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active)[i];
result.Add(new AudioDevice
{
Id = i,
Name = endpoint.FriendlyName
});
}
return result;
}
public MainWindowViewModel()
{
synchronizationContext = SynchronizationContext.Current;
var enumerator = new MMDeviceEnumerator();
CaptureDevices = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToArray();
var defaultDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
SelectedDevice = CaptureDevices.FirstOrDefault(c => c.ID == defaultDevice.ID);
}
public void CanEnumerateCaptureDevices()
{
OSUtils.RequireVista();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
foreach (MMDevice device in enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.All))
{
Debug.WriteLine(String.Format("{0}, {1}", device.FriendlyName, device.State));
}
}
public void CanEnumerateDevicesInVista()
{
OSUtils.RequireVista();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
foreach (MMDevice devices in enumerator.EnumerateAudioEndPoints(DataFlow.All,DeviceState.All))
{
Debug.WriteLine(devices);
}
}
public RealTimeSoundData() {
var enumerator = new MMDeviceEnumerator();
var captureDevices = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToArray();
var defaultDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
device = captureDevices.FirstOrDefault(c => c.ID == defaultDevice.ID);
capture = new WasapiCapture(device);
context = SynchronizationContext.Current;
capture.DataAvailable += Capture_DataAvailable;
}
private void Form1_Load(object sender, EventArgs e)
{
//Check windows
if (Environment.OSVersion.Version.Major < 6)
{
MessageBox.Show("You are using an unsupported version of Windows.\n\n" +
"audio-output-recorder requires Windows Vista or newer (which supports WASAPI).",
"Unsupported version of Windows", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Check for ffmpeg.exe
if (System.IO.File.Exists(Environment.CurrentDirectory + "\\ffmpeg.exe") == false)
{
if (MessageBox.Show("No ffmpeg.exe could not be found in the current directory." +
"\n\nWould you like to open up a web browser window with a website where you can download ffmpeg? " +
"Choose 32-bit static if you're unsure and put ffmpeg.exe in the same folder as audio-output-recorder.",
"Error", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
{
System.Diagnostics.Process.Start("http://ffmpeg.zeranoe.com/builds/");
Environment.Exit(0);
}
else
{
chkDownsample.Checked = false;
chkDownsample.Enabled = false;
chkEncode.Checked = false;
chkEncode.Enabled = false;
}
}
if (System.IO.Directory.Exists(Properties.Settings.Default.recordingPath))
{
txtOutput.Text = Properties.Settings.Default.recordingPath;
}
else
{
txtOutput.Text = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
}
NAudio.CoreAudioApi.MMDeviceEnumerator devEnum = new NAudio.CoreAudioApi.MMDeviceEnumerator();
NAudio.CoreAudioApi.MMDeviceCollection devColl = devEnum.EnumerateAudioEndPoints(
NAudio.CoreAudioApi.DataFlow.Render, NAudio.CoreAudioApi.DeviceState.Active);
foreach (NAudio.CoreAudioApi.MMDevice d in devColl)
{
cDevice.Items.Add(d.FriendlyName);
}
if (cDevice.Items.Count > 0)
{
cDevice.Text = cDevice.Items[0].ToString();
}
cBitrate.Text = "192k";
}
public void CanEnumerateCaptureDevices()
{
if (Environment.OSVersion.Version.Major >= 6)
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
foreach (MMDevice device in enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.All))
{
Console.WriteLine("{0}, {1}", device.FriendlyName, device.State);
}
}
}
public void CanEnumerateDevicesInVista()
{
if (Environment.OSVersion.Version.Major >= 6)
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
foreach (MMDevice devices in enumerator.EnumerateAudioEndPoints(DataFlow.All,DeviceState.All))
{
Console.WriteLine(devices);
}
}
}
public WasapiCaptureViewModel()
{
synchronizationContext = SynchronizationContext.Current;
var enumerator = new MMDeviceEnumerator();
CaptureDevices = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToArray();
var defaultDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
SelectedDevice = CaptureDevices.FirstOrDefault(c => c.ID == defaultDevice.ID);
RecordCommand = new DelegateCommand(Record);
StopCommand = new DelegateCommand(Stop) { IsEnabled = false };
RecordingsViewModel = new RecordingsViewModel();
}
public void MonitorDeviceChanges()
{
var enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
// Allows you to enumerate rendering devices in certain states
var endpoints = enumerator.EnumerateAudioEndPoints(
DataFlow.Render,
DeviceState.Unplugged | DeviceState.Active);
// Aswell as hook to the actual event
this.nt = new NotificationClient(this);
enumerator.RegisterEndpointNotificationCallback(nt);
// MessageBox.Show("Monitoring Devices");
}
void UI_Load(object sender, EventArgs e)
{
var deviceEnum = new MMDeviceEnumerator();
var deviceCol = deviceEnum.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
var deviceList = deviceCol.ToList();
AudioDeviceList.DataSource = deviceList;
AudioDeviceList.DisplayMember = "FriendlyName";
CodecListBox.DataSource = Codec.List;
CodecListBox.DisplayMember = "DisplayName";
}
private void LoadWasapiDevicesCombo()
{
var deviceEnum = new MMDeviceEnumerator();
var devices = deviceEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
comboWasapiDevices.DataSource = devices;
comboWasapiDevices.DisplayMember = "FriendlyName";
if (devices.Count == 0)
{
MessageBox.Show("Can't find any input devices! Recording won't work...");
btnStart.Enabled = false;
btnNext.Enabled = false;
}
}
public void MuteOrUnmute()
{
// Used http://stackoverflow.com/a/12534628/1454669
MMDeviceEnumerator MMDE = new MMDeviceEnumerator();
MMDeviceCollection devs = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.All, NAudio.CoreAudioApi.DeviceState.All);
foreach (MMDevice dev in devs) {
if (dev.FriendlyName.ToLower().IndexOf("speakers") > -1) {
try {
dev.AudioEndpointVolume.Mute = !dev.AudioEndpointVolume.Mute;
}
catch (Exception) {
}
}
}
}
private void LoadWasapiDevicesCombo()
{
MMDeviceEnumerator deviceEnum = new MMDeviceEnumerator();
MMDeviceCollection deviceCol = deviceEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
Collection<MMDevice> devices = new Collection<MMDevice>();
foreach (MMDevice device in deviceCol)
{
devices.Add(device);
}
this.comboDevices.DataSource = devices;
this.comboDevices.DisplayMember = "FriendlyName";
}
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.DisplayMember = "Description";
comboBoxWaspai.ValueMember = "Device";
comboBoxWaspai.DataSource = comboItems;
}
public ToolsAudioGrab()
{
DeviceEnumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
var devices = DeviceEnumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
// instantiate the sound recorder once in an attempt to reduce lag the first time used
try
{
SoundCardRecorder = new SoundCardRecorder((MMDevice)devices[0]);
SoundCardRecorder.Dispose();
SoundCardRecorder = null;
}
catch (Exception)
{
}
}
public static List <ZJAudioModel> getAudioDevice()
{
List <ZJAudioModel> audioList = new List <ZJAudioModel>();
var enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//允许你在某些状态下枚举渲染设备
var endpoints = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
foreach (var endpoint in endpoints)
{
ZJAudioModel audioModel = new ZJAudioModel();
audioModel.name = endpoint.FriendlyName;
audioModel.id = endpoint.ID;
audioList.Add(audioModel);
}
return(audioList);
}
/// <summary>
/// Initializes the softphone logic
/// Subscribes change events to get notifications.
/// Register info event
/// Incoming call event
/// </summary>
private void InitializeSoftPhone()
{
try
{
var devices = Devices.EnumerateAudioEndPoints(DataFlow.All,
NAudio.CoreAudioApi.DeviceState.Active);
arrayDevices = devices.ToArray();
string userAgent = "Snow";
_softPhone = SoftPhoneFactory.CreateSoftPhone(
SoftPhoneFactory.GetLocalIP(),
7000, 9000, userAgent);
InvokeGUIThread(() =>
{
lb_Log.Items.Add("Softphone created!");
});
_softPhone.IncomingCall += softPhone_inComingCall;
InvokeGUIThread(() =>
{
lb_Log.Items.Add("SIP account created!");
});
_phoneLine = _softPhone.CreatePhoneLine(accountSipInfo);
_phoneLine.RegistrationStateChanged += phoneLine_PhoneLineInformation;
InvokeGUIThread(() =>
{
lb_Log.Items.Add("Phoneline created.");
});
_softPhone.RegisterPhoneLine(_phoneLine);
_inComingCall = false;
ConnectMedia();
}
catch (Exception ex)
{
InvokeGUIThread(() =>
{
lb_Log.Items.Add("Local IP error! " + ex);
});
}
}
private void InitialiseWasapiControls()
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
MMDeviceCollection endPoints = enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
List<WasapiDeviceComboItem> comboItems = new List<WasapiDeviceComboItem>();
foreach (MMDevice endPoint in endPoints)
{
WasapiDeviceComboItem comboItem = new WasapiDeviceComboItem
{
Description = $"{endPoint.FriendlyName} ({endPoint.DeviceFriendlyName})",
Device = endPoint
};
comboItems.Add(comboItem);
}
comboBoxWaspai.DisplayMember = "Description";
comboBoxWaspai.ValueMember = "Device";
comboBoxWaspai.DataSource = comboItems;
}
private IEnumerable<MMDevice> GetDevices()
{
int targetState = (int)DeviceState.Active + (int)DeviceState.Disabled + (int)DeviceState.Unplugged;
MMDeviceEnumerator deviceEnumerator = new MMDeviceEnumerator();
MMDeviceCollection devices = deviceEnumerator.EnumerateAudioEndPoints(DeviceType, (DeviceState)targetState);
return devices.Where(device => {
try
{
device.AudioEndpointVolume.Mute = device.AudioEndpointVolume.Mute;
return true;
}
catch (Exception ex)
{
return false;
}
});
}
public void CanEnumerateDevicesInVista()
{
OSUtils.RequireVista();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(DataFlow.All, DeviceState.All);
foreach (MMDevice device in devices)
{
if (device.State != DeviceState.NotPresent)
{
Debug.WriteLine(String.Format("{0}, {1}", device.FriendlyName, device.State));
}
else
{
Debug.WriteLine(String.Format("{0}, {1}", device.ID, device.State));
}
}
}
public Sound2Play()
{
InitializeComponent();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active);
comboBox1.Items.AddRange(devices.ToArray());
canvasHeight = canvas.Height;
canvasWidth = canvas.Width;
ufoOriginalHeight = ufo.Height;
ufoOriginalWidth = ufo.Width;
sbSoundDivisor.Minimum = 1;
sbSoundDivisor.Maximum = 50;
sbSoundDivisor.Value = 15;
sbSoundThreshold.Minimum = 1;
sbSoundThreshold.Maximum = 50;
sbSoundThreshold.Value = 5;
sbGravity.Minimum = 0;
sbGravity.Maximum = 50;
sbGravity.Value = 8;
soundDivisor = sbSoundDivisor.Value;
soundThreshold = sbSoundThreshold.Value;
gravity = sbGravity.Value;
lbSoundDivisor.Text = (sbSoundDivisor.Value).ToString();
lbSoundThreshold.Text = (sbSoundThreshold.Value).ToString();
lbGravity.Text = (sbGravity.Value).ToString();
if (rbKeepGoing.Checked)
{
lbUfoGravity.Visible = false;
lbGravity.Visible = false;
sbGravity.Visible = false;
sbGravity.Value = 0;
gravity = 0;
}
else
{
sbGravity.Visible = true;
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FPinInRefresh[0] == true || FFirstRun)
{
FFirstRun = false;
MMDeviceEnumerator deviceEnum = new MMDeviceEnumerator();
MMDeviceCollection deviceCol = deviceEnum.EnumerateAudioEndPoints(getEndType(), DeviceState.Active);
int count = deviceCol.Count;
FPinOutDevices.SliceCount = count;
FPinOutDeviceNames.SliceCount = count;
FPinOutDeviceIDs.SliceCount = count;
for (int i = 0; i < count; i++)
{
FPinOutDevices[i] = deviceCol[i];
FPinOutDeviceNames[i] = deviceCol[i].DeviceFriendlyName;
FPinOutDeviceIDs[i] = deviceCol[i].ID;
}
}
}
public void Evaluate(int SpreadMax)
{
if (firstRun || FInRefresh[0] || FInDeviceType.IsChanged)
{
firstRun = false;
var enumerator = new MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(FInDeviceType[0], FInDeviceState[0]).ToArray();
FOutDevices.SliceCount = devices.Count();
FOutName.SliceCount = devices.Count();
FOutState.SliceCount = devices.Count();
int index = 0;
foreach (var device in devices)
{
FOutDevices[index] = device;
FOutName[index] = device.FriendlyName;
FOutState[index] = device.State.ToString();
index++;
}
}
}
private void LoadDevices()
{
_deviceEnumerator = _deviceEnumerator?? new MMDeviceEnumerator();
var defaultCapture = _deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
var defaultRender = _deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
_micDevices = new List<DeviceItem>();
foreach (var device in _deviceEnumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.All))
{
var item = new DeviceItem
{
Device = device,
Default = defaultCapture.ID == device.ID,
Index = _micDevices.Count
};
_micDevices.Add(item);
}
micphone_selector.BeginUpdate();
_micDevices.Sort((item1, item2) => item1.Default ? -1 : 1);
micphone_selector.DataSource = _micDevices;
micphone_selector.EndUpdate();
_speakerDevices = new List<DeviceItem>();
foreach (var device in _deviceEnumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.All))
{
var item = new DeviceItem
{
Device = device,
Default = defaultRender.ID == device.ID,
Index = _speakerDevices.Count
};
_speakerDevices.Add(item);
}
speaker_selector.BeginUpdate();
_speakerDevices.Sort((item1, item2) => item1.Default ? -1 : 1);
speaker_selector.DataSource = _speakerDevices;
speaker_selector.EndUpdate();
}
private float GetVol()
{
try
{
//Instantiate an Enumerator to find audio devices
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDeviceCollection DevCol = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.All, NAudio.CoreAudioApi.DeviceState.Active);
//Loop through all devices
foreach (NAudio.CoreAudioApi.MMDevice dev in DevCol)
{
try
{
if (dev.FriendlyName.Contains("Headphone") || dev.FriendlyName.Contains("Speakers"))
{
//Get its audio volume
System.Diagnostics.Debug.Print("Volume of " + dev.FriendlyName + " is " + dev.AudioEndpointVolume.MasterVolumeLevel.ToString());
return (dev.AudioEndpointVolume.MasterVolumeLevel - dev.AudioEndpointVolume.VolumeRange.MinDecibels) / (dev.AudioEndpointVolume.VolumeRange.MaxDecibels - dev.AudioEndpointVolume.VolumeRange.MinDecibels);
}
//Mute it
//dev.AudioEndpointVolume.Mute = true;
//System.Diagnostics.Debug.Print(dev.FriendlyName + " is muted");
//Get its audio volume
//System.Diagnostics.Debug.Print(dev.AudioEndpointVolume.MasterVolumeLevel.ToString());
}
catch (Exception ex)
{
//Do something with exception when an audio endpoint could not be muted
System.Diagnostics.Debug.Print(dev.FriendlyName + " could not be muted");
}
}
}
catch (Exception ex)
{
//When something happend that prevent us to iterate through the devices
System.Diagnostics.Debug.Print("Could not enumerate devices due to an excepion: " + ex.Message);
}
return 1.0f;
}
////////////////////////////////////////
//methods for background audio control//
////////////////////////////////////////
//Method for populating Devices combo box
private void PopulateCboDevices()
{
////
// Add sound cards to main selection menu at top
////
// Create arbitrary integer for numbering
var num = 0;
var deviceEnumeratior = new MMDeviceEnumerator();
var devices = deviceEnumeratior.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active);
foreach (var device in devices)
{
MenuItem soundCardSelect = new MenuItem();
MenuItem newMenuItem = (MenuItem)this.MainMenu.Items[2];
soundCardSelect.Header = device;
soundCardSelect.Click += cboDevices_SelectionChanged;
soundCardSelect.Tag = num;
soundCardSelect.IsCheckable = true;
soundCardSelect.Name = "SoundCard" + num;
newMenuItem.Items.Add(soundCardSelect);
// increase num value for .Tags
num++;
}
// Select / Check & Disable first selected soundcard
((MenuItem)SoundSelect.Items[0]).IsChecked = true;
((MenuItem)SoundSelect.Items[0]).IsEnabled = false;
}
/// <summary>
/// Get MMDevices for this system
/// </summary>
/// <param name="df">DataFlow.Capture for Input (Microphones), DataFlow.Render for Output (Soundcards), DataFlow.All for all</param>
/// <param name="ds">Which DeviceStates to show</param>
/// <returns></returns>
public List<MMDevice> GetDevices(DataFlow df = DataFlow.All, DeviceState ds = DeviceState.Active)
{
List<MMDevice> devices = new List<MMDevice>();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
foreach (MMDevice device in enumerator.EnumerateAudioEndPoints(df, ds))
{
devices.Add(device);
}
return devices;
}
public MainWindow()
{
InitializeComponent();
DataContext = this;
synchronizationContext = SynchronizationContext.Current;
var enumerator = new MMDeviceEnumerator();
CaptureDevices = enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToArray();
RunConnexion();
}
public Audio(bool muteIfZero = true)
{
_muteIfZero = muteIfZero;
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
activeDevices = MMDE.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.Render, NAudio.CoreAudioApi.DeviceState.Active);
}
