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);
}
private static MMDevice GetAudioMultiMediaEndpoint(DataFlow dataFlow, Role role)
{
using (var enumerator = new MMDeviceEnumerator())
{
return(enumerator.GetDefaultAudioEndpoint(dataFlow, role));
}
}
/// <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();
}
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);
}
}
/// <summary>
/// Create an input
/// </summary>
/// <param name="ID">The ID of the input to be created</param>
public Input(string ID)
{
// Set the device ID
deviceID = ID;
// Get Device from specified ID
MMDeviceEnumerator devices = new MMDeviceEnumerator();
device = devices.GetDevice(ID);
// Set wave in to WASAPI capture of the specified device
waveIn = new WasapiCapture(device);
// Set the number of bytes used by each sample
sampleByteSize = waveIn.WaveFormat.BitsPerSample / 8;
// Add event handler to retrieve samples from the device
waveIn.DataAvailable += waveIn_DataAvailable;
// Create buffered wave provider
bufferedWaveProvider = new BufferedWaveProvider(waveIn.WaveFormat);
bufferedWaveProvider.DiscardOnBufferOverflow = true;
// Create sample channel
sampleChannel = new SampleChannel(bufferedWaveProvider);
// Create sample provider
sampleChannel.PreVolumeMeter += sampleProvider_StreamVolume;
// Start recording
try
{
waveIn.StartRecording();
}
catch
{
throw new ArgumentException("This input device is not supported.");
}
}
static void trayMenu_Popup(object sender, EventArgs e)
{
AudioDevice[] deviceList = GetDevices();
MMDevice defaultDevice = new MMDeviceEnumerator().GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
trayMenu.MenuItems.Clear();
for (int i = 0; i < deviceList.Length; i++)
{
MenuItem mItem;
int localI = i; //We create a local int so that we don't have problems with the delegate inside the for loop.
mItem = new MenuItem(deviceList[i].DeviceName, (f, g) => deviceList[localI].SetDefault());
if (deviceList[i].DeviceID.GetHashCode() == defaultDevice.ID.GetHashCode())
{
mItem.RadioCheck = true;
mItem.Checked = true;
}
trayMenu.MenuItems.Add(mItem);
}
trayMenu.MenuItems.Add("-");
trayMenu.MenuItems.Add("Exit", (f, g) => Application.Exit());
}
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;
}
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);
}
public void CanGetDefaultAudioEndpoint()
{
OSUtils.RequireVista();
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
MMDevice defaultAudioEndpoint = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
Assert.IsNotNull(defaultAudioEndpoint);
}
public override void Update()
{
// TODO: Get from settings
var fps = 25;
if (VolumeDisplay == null)
return;
if (VolumeDisplay.Ttl < 1)
return;
var decreaseAmount = 500/fps;
VolumeDisplay.Ttl = VolumeDisplay.Ttl - decreaseAmount;
if (VolumeDisplay.Ttl < 128)
VolumeDisplay.Transparancy = (byte) (VolumeDisplay.Transparancy - 20);
try
{
var enumerator = new MMDeviceEnumerator();
var volumeFloat =
enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console)
.AudioEndpointVolume.MasterVolumeLevelScalar;
VolumeDisplay.Volume = (int) (volumeFloat*100);
}
catch (COMException)
{
}
}
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);
}
}
}
public void CanCreateMMDeviceEnumeratorInVista()
{
if (Environment.OSVersion.Version.Major >= 6)
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
}
}
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 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 static void SwitchMute()
{
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDevice dev = MMDE.GetDefaultAudioEndpoint(NAudio.CoreAudioApi.DataFlow.Render, NAudio.CoreAudioApi.Role.Communications);
dev.AudioEndpointVolume.Mute = !dev.AudioEndpointVolume.Mute;
}
/// <summary>
/// Constructor for device panel creation.
/// </summary>
public VolumePanel()
{
this.devicePanel = true;
var deviceEnumerator = new MMDeviceEnumerator();
device = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
InitializeComponent();
}
private void LoadWasapiDevicesCombo()
{
var deviceEnum = new MMDeviceEnumerator();
var devices = deviceEnum.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
comboWasapiDevices.DataSource = devices;
comboWasapiDevices.DisplayMember = "FriendlyName";
}
public static void VolumeDown(int parDownPercent)
{
NAudio.CoreAudioApi.MMDeviceEnumerator MMDE = new NAudio.CoreAudioApi.MMDeviceEnumerator();
//Get all the devices, no matter what condition or status
NAudio.CoreAudioApi.MMDevice dev = MMDE.GetDefaultAudioEndpoint(NAudio.CoreAudioApi.DataFlow.Render, NAudio.CoreAudioApi.Role.Communications);
dev.AudioEndpointVolume.VolumeStepDown();
}
public Array GetSourcesArray()
{
NAudio.CoreAudioApi.MMDeviceEnumerator enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
var devices = enumerator.EnumerateAudioEndPoints(NAudio.CoreAudioApi.DataFlow.Capture, DeviceState.Active);
return(devices.ToArray());
}
static MMDevice GetDefaultAudioEndpoint()
{
if (Environment.OSVersion.Version.Major < 6)
{
throw new NotSupportedException("WASAPI supported only on Windows Vista and above");
}
var enumerator = new MMDeviceEnumerator();
return enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
}
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 void CanGetDefaultAudioEndpoint()
{
if (Environment.OSVersion.Version.Major >= 6)
{
MMDeviceEnumerator enumerator = new MMDeviceEnumerator();
MMDevice defaultAudioEndpoint = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
Assert.IsNotNull(defaultAudioEndpoint);
}
}
public void SetAudioVolume(float volume)
{
// Instantiate an Enumerator to find audio devices
MMDE = new MMDeviceEnumerator();
// Get all the devices, no matter what condition or status
device = MMDE.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
previousVolume = device.AudioEndpointVolume.MasterVolumeLevelScalar;
device.AudioEndpointVolume.Mute = false;
device.AudioEndpointVolume.MasterVolumeLevelScalar = volume;
}
public Recorder()
{
wavein = new WaveIn();
wavein.DeviceNumber = 0;
wavein.WaveFormat = new WaveFormat();
devEnum = new MMDeviceEnumerator();
defaultDevice = devEnum.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Multimedia);
wavein.DataAvailable += Wavein_DataAvailable;
checkFolders();
}
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 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 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);
}
}
}
/// <summary>
/// Инициализация основного аудио устройства
/// </summary>
private void InitDevice()
{
try
{
var devEnum = new MMDeviceEnumerator();
_audioDevice = devEnum.GetDefaultAudioEndpoint(0, (Role) 1);
}
catch (Exception e)
{
MessageBox.Show("Error: " + e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public VolumeControl()
{
InitializeComponent();
MMDeviceEnumerator deviceEnumerator = new MMDeviceEnumerator();
device = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
tbVolume.Value = (int)(Math.Round(device.AudioEndpointVolume.MasterVolumeLevelScalar * 100));
if (device.AudioEndpointVolume.Mute)
{
btnMuteUnmute.Image = Properties.Resources.Mute;
}
}
private NAudioEngine()
{
sampleAggregator = new SampleAggregator(fftDataSize);
var deviceEnumerator = new MMDeviceEnumerator();
var defaultDevice = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
this.capture = new WasapiLoopbackCapture(defaultDevice);
capture.ShareMode = AudioClientShareMode.Shared;
capture.DataAvailable += CaptureOnDataAvailable;
capture.StartRecording();
}
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";
}
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");
}
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;
}
}
private static void LogAudioDevices()
{
Console.Out.WriteLine("Looking for audio capture devices:");
for (int n = 0; n < WaveIn.DeviceCount; n++)
{
var dev = WaveIn.GetCapabilities(n);
Console.Out.WriteLine(" Device: {0}, channels={1}", dev.ProductName, dev.Channels);
}
Console.Out.WriteLine("Looking for audio MMD:");
var mmd = new MMDeviceEnumerator();
var mddDev = mmd.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
Console.Out.WriteLine(" [default] {0} {1}", mddDev.ID, mddDev.FriendlyName);
}
public static bool IsMuted()
{
bool isMuted = false;
try
{
MMDeviceEnumerator DevEnum = new MMDeviceEnumerator();
MMDevice device = DevEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
isMuted = device.AudioEndpointVolume.Mute;
}
catch (Exception)
{
}
return isMuted;
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
ico_trayIcon.TrayMouseDoubleClick += Ico_trayIcon_TrayMouseDoubleClick;
NAudio.CoreAudioApi.MMDeviceEnumerator enumer = new NAudio.CoreAudioApi.MMDeviceEnumerator();
dev = enumer.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
dev.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
VolumeActual = (int)(dev.AudioEndpointVolume.MasterVolumeLevelScalar * 100);
VolumeMax = DEFAULT_MAX_VOL;
slider_maxVol.Value = VolumeMax;
}
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 FrmMain()
{
InitializeComponent();
//For USB devices and so on
HardwareNotification.RegisterUsbDeviceNotification(this.Handle);
//For MM EndPoints (not only USB)
var enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
enumerator.RegisterEndpointNotificationCallback(this);
//Initial fill lists
updateMMList();
updateUSBList();
}
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);
}
public void wasapiPlay()
{
ISampleProvider sampleProvider1;
VolumeSampleProvider volumeSampleProv1;
SmbPitchShiftingSampleProvider smbPitchSampleProv1;
OffsetSampleProvider offsetSampleProv1;
PanningSampleProvider panSampleProv1;
void funcForBuff(object sender, WaveInEventArgs waveInEventArgs)
{
buffWaveProv.AddSamples(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
}
var enumerator = new NAudio.CoreAudioApi.MMDeviceEnumerator();
wInput = enumerator.GetDevice(strInputDeviceID);
wOutput = enumerator.GetDevice(strOutputDeviceID);
wOut = new WasapiOut(wOutput, AudioClientShareMode.Shared, true, 10);
wCapture = new WasapiCapture(wInput, true, 10);
buffWaveProv = new BufferedWaveProvider(wCapture.WaveFormat);
wCapture.DataAvailable += funcForBuff;
sampleProvider1 = buffWaveProv.ToSampleProvider();
smbPitchSampleProv1 = new SmbPitchShiftingSampleProvider(sampleProvider1);
smbPitchSampleProv1.PitchFactor = fPitch;
offsetSampleProv1 = new OffsetSampleProvider(smbPitchSampleProv1);
offsetSampleProv1.DelayBy = new TimeSpan(0, 0, 0, 0, iLatency);
panSampleProv1 = new PanningSampleProvider(offsetSampleProv1.ToMono(1f, 1f));
panSampleProv1.Pan = fPanning;
volumeSampleProv1 = new VolumeSampleProvider(panSampleProv1);
volumeSampleProv1.Volume = fVolume;
wOut.Init(volumeSampleProv1);
wCapture.StartRecording();
wOut.Play();
}
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
float[] volume = new float[8];
for (int i = 0; i < 8; i++)
{
volume[i] = 0f;
for (int index = e.BytesRecorded * i / 8; index < e.BytesRecorded * (i + 1) / 8; index += 2)
{
short sample = (short)((e.Buffer[index + 1] << 8) | e.Buffer[index + 0]);
float val = Math.Abs(sample / 32768f);
if (val > volume[i])
{
volume[i] = val;
}
}
}
NAudio.CoreAudioApi.MMDeviceEnumerator devEnum = new NAudio.CoreAudioApi.MMDeviceEnumerator();
NAudio.CoreAudioApi.MMDevice defaultDevice = devEnum.GetDefaultAudioEndpoint(NAudio.CoreAudioApi.DataFlow.Render, NAudio.CoreAudioApi.Role.Multimedia);
VolumeBar.Value = (100 - (defaultDevice.AudioMeterInformation.MasterPeakValue * 100f));
VolumeBar.Value = (100 - (volume[3] * 100));
Provider.AddSamples(e.Buffer, 0, e.BytesRecorded);
}
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);
}
/// <summary>
/// Gets the default audio capture device
/// </summary>
/// <returns>The default audio capture device</returns>
public static MMDevice GetDefaultCaptureDevice()
{
var devices = new MMDeviceEnumerator();
return(devices.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console));
}
/// <summary>
/// Gets the default audio capture device
/// </summary>
/// <returns>The default audio capture device</returns>
public static MMDevice GetDefaultCaptureDevice()
{
MMDeviceEnumerator devices = new MMDeviceEnumerator();
return(devices.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia));
}
