public WindowsAudio() { var device = new MMDeviceEnumerator().GetDefaultAudioEndpoint(DataFlow.Render, Role.Console); _volume = AudioEndpointVolume.FromDevice(device); _meter = AudioMeterInformation.FromDevice(device); }
public static void Main() { using (MMDeviceEnumerator enumerator = new MMDeviceEnumerator()) using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console)) using (AudioEndpointVolume endpointVolume = AudioEndpointVolume.FromDevice(device)) using (AudioSessionManager2 sessionManager2 = AudioSessionManager2.FromMMDevice(device)) using (AudioSessionEnumerator sessionEnumerator = sessionManager2.GetSessionEnumerator()) { Console.WriteLine("Default Render Device: " + device.FriendlyName); Console.WriteLine("Master Volume Scalar: " + endpointVolume.GetMasterVolumeLevelScalar()); Console.WriteLine("\nGetting audio sessions..."); foreach (AudioSessionControl sessionControl in sessionEnumerator) { PrintSessionName(sessionControl); Console.WriteLine("\t- State: " + sessionControl.SessionState.ToString()); using (SimpleAudioVolume sessionSimpleVolume = sessionControl.QueryInterface <SimpleAudioVolume>()) { Console.WriteLine("\t- Volume: " + sessionSimpleVolume.MasterVolume); sessionSimpleVolume.MasterVolume = 1.0f; } sessionControl.Dispose(); } } Console.WriteLine("\nVolumes reset!"); Console.ReadLine(); }
private void OnAudioDeviceChanged(object sender, AudioDeviceChangedEventArgs e) { if (e.DefaultPlayback != null) { _endPointVolume = AudioEndpointVolume.FromDevice(e.DefaultPlayback); } }
public void CreateDevice(EventHandler <DefaultDeviceChangedEventArgs> aDefaultDeviceChangedHandler, EventHandler <AudioEndpointVolumeCallbackEventArgs> aVolumeChangedHandler) { try { //Create device and register default device change notification _mMdeviceEnumerator = new MMDeviceEnumerator(); iMultiMediaNotificationClient = new MMNotificationClient(_mMdeviceEnumerator); iMultiMediaNotificationClient.DefaultDeviceChanged += iDefaultDeviceChangedHandler = aDefaultDeviceChangedHandler; var mMdeviceList = _mMdeviceEnumerator.EnumAudioEndpoints(DataFlow.Render, DeviceState.Active); if (mMdeviceList != null && mMdeviceList.Count > 0) { _mMdevice = _mMdeviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia); GUIGraphicsContext.CurrentAudioRendererDevice = _mMdevice.FriendlyName; //Register to get volume modifications if (_mMdevice != null) { iAudioEndpointVolume = AudioEndpointVolume.FromDevice(_mMdevice); } iAudioEndpointVolumeMixerCallback = new CSCore.CoreAudioAPI.AudioEndpointVolumeCallback(); iAudioEndpointVolumeMixerCallback.NotifyRecived += iVolumeChangedHandler = aVolumeChangedHandler; iAudioEndpointVolume?.RegisterControlChangeNotify(iAudioEndpointVolumeMixerCallback); } // For audio session Stop(); //DispatchingTimerStart(); // Disable because the check will be done in IsMuted code } catch (Exception) { // When no device available } }
public void CanCreateAudioEndpointVolume() { using (var device = Utils.GetDefaultRenderDevice()) using (var endpointVolume = AudioEndpointVolume.FromDevice(device)) { } }
public CsCoreEngine() { using (var enumerator = new MMDeviceEnumerator()) { device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console); } endpointVolume = AudioEndpointVolume.FromDevice(device); }
public SysVolumeConfigurator() // Объявление { using (var enumerator = new MMDeviceEnumerator()) { device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console); } endpointVolume = AudioEndpointVolume.FromDevice(device); }
public void CanGetAudioEndpointVolumeChannelCount() { using (var device = Utils.GetDefaultRenderDevice()) using (var endpointVolume = AudioEndpointVolume.FromDevice(device)) { Debug.WriteLine(endpointVolume.GetChannelCount()); } }
public void CanGetAudioEndpointVolume() { using (var device = Utils.GetDefaultRenderDevice()) using (var endpointVolume = AudioEndpointVolume.FromDevice(device)) { var volume = endpointVolume.GetMasterVolumeLevelScalar(); Debug.WriteLine("Volume: {0}", volume); endpointVolume.SetMasterVolumeLevelScalar(0.5f, Guid.Empty); } }
public static void SetMicMute(bool muted) { var endpoint = AudioEndpointVolume.FromDevice(microphone); if (endpoint.GetMute() != muted) { endpoint.SetMute(muted, eventguid); Plugin.Log.Info($"Microphone muted: {muted}"); } }
private static AudioEndpointVolume GetDefaultAudioEndpointVolume() { using (var enumerator = new MMDeviceEnumerator()) { using (var device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia)) { return(AudioEndpointVolume.FromDevice(device)); } } }
static AudioSessionManager2 DefaultAudioSessionManager(DataFlow dataFlow) { using (var enumerator = new MMDeviceEnumerator()) { using (var device = enumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia)) { AudioVolume = AudioEndpointVolume.FromDevice(device); return(AudioSessionManager2.FromMMDevice(device)); } } }
public static DefaultDevice GetPCDataDefaultDevice() { DefaultDevice device = new DefaultDevice(); MMDevice Defaultdevice = GetDefaultDevice(); AudioEndpointVolume Endpointvolume = AudioEndpointVolume.FromDevice(Defaultdevice); device.IsMute = Endpointvolume.GetMute(); device.Name = Defaultdevice.FriendlyName; device.Volume = (int)(Endpointvolume.MasterVolumeLevelScalar * 100); device.Icon = null; return(device); }
public AudioDevice(MMDevice device, bool visibleSystemSounds = false) { _device = device; _visibleSystemSounds = visibleSystemSounds; _sessionManager = AudioSessionManager2.FromMMDevice(_device); _endpointVolume = AudioEndpointVolume.FromDevice(_device); _endpointVolume.RegisterControlChangeNotify(_callback); _callback.NotifyRecived += OnEndpointVolumeChanged; _sessionManager.SessionCreated += OnSessionCreated; }
private static void SetMasterMute(bool isMute, ref RPIData data) { MMDevice device = GetDefaultDevice(); AudioEndpointVolume Endpointvolume = AudioEndpointVolume.FromDevice(device); Endpointvolume.SetMuteNative(isMute, new Guid()); if (isMute == false) { for (int i = 0; i < data.Programs.Count; i++) { data.Programs[i].IsMute = false; } } }
private void RadioButton_Checked(object sender, RoutedEventArgs e) { var button = (RadioButton)sender; using (var device = GetDefaultRenderDevice()) using (var endpointVolume = AudioEndpointVolume.FromDevice(device)) { var volume = endpointVolume.GetMasterVolumeLevelScalar(); Console.WriteLine("Volume is {0}", volume); endpointVolume.SetMasterVolumeLevelScalar(float.Parse(button.Content.ToString()) / 100, Guid.Empty); } }
public AudioDevice(MMDevice device) { Device = device; _deviceEnumerator = new MMDeviceEnumerator(); _deviceEnumerator.DefaultDeviceChanged += OnDefaultDeviceChanged; _deviceEnumerator.DeviceRemoved += OnDeviceRemoved; _deviceEnumerator.DeviceStateChanged += OnDeviceStateChanged; _endpointVolume = AudioEndpointVolume.FromDevice(Device); _endpointVolume.RegisterControlChangeNotify(_callback); _callback.NotifyRecived += OnEndpointVolumeChanged; UpdateDisplayName(); }
public void Initialize(MMDevice captureDevice) { //BLARG 01.14.2020: Don't need the default when we're given an Audio Enpoint //MMDevice captureDevice = MMDeviceEnumerator.DefaultAudioEndpoint(DataFlow.Render, Role.Console); WaveFormat deviceFormat = captureDevice.DeviceFormat; _audioEndpointVolume = AudioEndpointVolume.FromDevice(captureDevice); //DarthAffe 07.02.2018: This is a really stupid workaround to (hopefully) finally fix the surround driver issues for (int i = 1; i < 13; i++) { try { _capture = new WasapiLoopbackCapture(100, new WaveFormat(deviceFormat.SampleRate, deviceFormat.BitsPerSample, i)); } catch { /* We're just trying ... */ } } if (_capture == null) { throw new NullReferenceException("Failed to initialize WasapiLoopbackCapture"); } //BLARG: Actually setting the Device _capture.Device = captureDevice; _capture.Initialize(); _soundInSource = new SoundInSource(_capture) { FillWithZeros = false }; _source = _soundInSource.WaveFormat.SampleRate == 44100 ? _soundInSource.ToStereo() : _soundInSource.ChangeSampleRate(44100).ToStereo(); _stream = new SingleBlockNotificationStream(_source.ToSampleSource()); _stream.SingleBlockRead += StreamOnSingleBlockRead; _source = _stream.ToWaveSource(); byte[] buffer = new byte[_source.WaveFormat.BytesPerSecond / 2]; _soundInSource.DataAvailable += (s, aEvent) => { while ((_source.Read(buffer, 0, buffer.Length)) > 0) { ; } }; _capture.Start(); }
public OverlayProfileModel(DeviceManager deviceManager, LuaManager luaManager, AudioCaptureManager audioCaptureManager) : base(deviceManager, luaManager) { Settings = SettingsProvider.Load <OverlayProfileSettings>(); DataModel = new OverlayProfileDataModel(); var defaultPlayback = MMDeviceEnumerator.TryGetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia); if (defaultPlayback != null) { _endPointVolume = AudioEndpointVolume.FromDevice(defaultPlayback); } audioCaptureManager.AudioDeviceChanged += OnAudioDeviceChanged; Enable(); }
public static bool IsAudioPlaying(MMDevice device) { // Value ranges: // .3 to .6 is listening to music from an app at high volume. // .06 to .07 will be that same music at half the app volume level. // ~.022 will be that same music at quarter app volume level. // ~.007 will be that same music at 1/8th app volume level. // ~.001 will be barely audible. // // Take the average of the last 5 audio level samples and make sure // audio levels are consistently over the threshold // // Just to make things more complicated, for the user to actually be // listening to something, then the master volume should be at a decent // level. So at half level (0.6 to 0.7), and a .2 system volume level, // we are roughly at the .005 to .001 range of actual hearing levels. // rather than do the math, i opted for manually setting those by halving // audioVolumeThreshold when master volume < .5 using (var meter = AudioMeterInformation.FromDevice(device)) { var masterVolume = AudioEndpointVolume.FromDevice(device).GetMasterVolumeLevelScalar(); float modifiedAudioVolumeThreshold = audioVolumeThreshold; // Look at last 5 samples and average them. audioVolumeTracker.Add(meter.PeakValue); if (audioVolumeTracker.Count > 5) { audioVolumeTracker.RemoveAt(0); } float audioVolumeAverage = audioVolumeTracker.Average(); if (masterVolume < .50) { modifiedAudioVolumeThreshold = modifiedAudioVolumeThreshold * 1.5f; } FileLogger.Log("-----------------+ Audio Debug Logs +----------------------------", 2); FileLogger.Log("Audio Meter Value : " + meter.PeakValue, 2); FileLogger.Log("Audio Meter Average: " + audioVolumeAverage, 2); FileLogger.Log("Master Volume Level: " + masterVolume, 2); FileLogger.Log("Modified Threshold: " + modifiedAudioVolumeThreshold, 2); return(audioVolumeAverage > modifiedAudioVolumeThreshold); } }
private void SetupDefaultEndpoint() { if (_endpointVolume != null) { _endpointVolume.UnregisterControlChangeNotify(_endpointVolumeCallback); _endpointVolume.Dispose(); } try { var defaultDevice = _deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console); _endpointVolume = AudioEndpointVolume.FromDevice(defaultDevice); _endpointVolume.RegisterControlChangeNotify(_endpointVolumeCallback); } catch (Exception ex) { _logger.Error(ex); } }
private void SetPlaybackDevice() { _playbackDevice = _enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console); if (_playbackDevice == null) { _logger.Warning("No audio device found with Console role"); return; } _audioEndpointVolume = AudioEndpointVolume.FromDevice(_playbackDevice); AudioEndpointVolumeCallback audioEndpointVolumeCallback = new AudioEndpointVolumeCallback(); audioEndpointVolumeCallback.NotifyRecived += (s, e) => { UpdateVolumeDataModel(); }; _audioEndpointVolume.RegisterControlChangeNotify(audioEndpointVolumeCallback); DataModel.DefaultDeviceName = _playbackDevice.FriendlyName; _logger.Information(string.Format("Playback device {0} registered to to fill Playback volume data model", _playbackDevice.FriendlyName)); }
/// <summary> /// Creates a new instance of the recorder. Captured data will be forwarded via the supplied data handler, if any. /// </summary> /// <param name="sampleRate">the target sample rate</param> /// <param name="bitsPerSample">the target bits per sample</param> /// <param name="handler">captured data handler (optional)</param> /// <see cref="DataHandler"/> public WasapiRecorder(int sampleRate, int bitsPerSample, DataHandler handler = null) { _capture = new WasapiLoopbackCapture(); _capture.Initialize(); _volume = AudioEndpointVolume.FromDevice(_capture.Device); _soundInSource = new SoundInSource(_capture) { FillWithZeros = false }; //defines the source conversion _convertedSource = _soundInSource .ChangeSampleRate(sampleRate) .ToSampleSource() .ToWaveSource(bitsPerSample) .ToStereo(); WithDataHandler(handler); }
private void GetMMD() { M.D(1000, "GetMMD"); L.MMD = CSCore.CoreAudioAPI.MMDeviceEnumerator.TryGetDefaultAudioEndpoint(CSCore.CoreAudioAPI.DataFlow.Render, CSCore.CoreAudioAPI.Role.Multimedia); if (L.MMD == null) { M.D(1001, M.Kind.ER, "MMD=null"); return; } AEV = AudioEndpointVolume.FromDevice(L.MMD); AEVC = new AudioEndpointVolumeCallback(); AEVC.NotifyRecived += AEV_NotifyRecived; AEV.RegisterControlChangeNotify(AEVC); L.MSD = new MasterData(AEV.IsMuted, AEV.MasterVolumeLevelScalar); AMI = AudioMeterInformation.FromDevice(L.MMD); //M.D(1008); //TryGetSs(); M.D(1009); }
private void GetMMD() { DW(1000); L.MMD = CSCore.CoreAudioAPI.MMDeviceEnumerator.TryGetDefaultAudioEndpoint(CSCore.CoreAudioAPI.DataFlow.Render, CSCore.CoreAudioAPI.Role.Multimedia); if (L.MMD == null) { return; } AEV = AudioEndpointVolume.FromDevice(L.MMD); var aevc = new AudioEndpointVolumeCallback(); aevc.NotifyRecived += Mepv_NotifyRecived; AEV.RegisterControlChangeNotify(aevc); L.MD = new MasterData(AEV.IsMuted, AEV.MasterVolumeLevelScalar); AMI = AudioMeterInformation.FromDevice(L.MMD); TryGetSs(); }
/// <summary> /// /// </summary> /// <param name="aDefaultDeviceChangedHandler"></param> /// <param name="aVolumeChangedHandler"></param> public void Open(EventHandler <DefaultDeviceChangedEventArgs> aDefaultDeviceChangedHandler, EventHandler <AudioEndpointVolumeCallbackEventArgs> aVolumeChangedHandler) { //Create device and register default device change notification iMultiMediaDeviceEnumerator = new MMDeviceEnumerator(); iMultiMediaNotificationClient = new MMNotificationClient(iMultiMediaDeviceEnumerator); iMultiMediaNotificationClient.DefaultDeviceChanged += iDefaultDeviceChangedHandler = aDefaultDeviceChangedHandler; iMultiMediaDevice = iMultiMediaDeviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia); //Register to get volume modifications iAudioEndpointVolume = AudioEndpointVolume.FromDevice(iMultiMediaDevice); iAudioEndpointVolumeCallback = new AudioEndpointVolumeCallback(); iAudioEndpointVolumeCallback.NotifyRecived += iVolumeChangedHandler = aVolumeChangedHandler; iAudioEndpointVolume.RegisterControlChangeNotify(iAudioEndpointVolumeCallback); if (iVisualizerCount > 0) { // We probably got restarted, make sure visualization is running if needed StartAudioVisualization(); } }
public void CanCreateAudioEndpointVolumeNotification() { using (var device = Utils.GetDefaultRenderDevice()) using (var endpointVolume = AudioEndpointVolume.FromDevice(device)) { AudioEndpointVolumeCallback callback = new AudioEndpointVolumeCallback(); callback.NotifyRecived += (s, e) => { Debug.WriteLine("Notification1"); //Debug.Assert(e.Channels == endpointVolume.ChannelCount); }; endpointVolume.RegisterControlChangeNotify(callback); var vol = endpointVolume.GetChannelVolumeLevelScalar(0); endpointVolume.SetChannelVolumeLevelScalar(0, 1f, Guid.Empty); endpointVolume.SetChannelVolumeLevelScalar(0, vol, Guid.Empty); endpointVolume.UnregisterControlChangeNotify(callback); System.Threading.Thread.Sleep(1000); } }
private IEnumerable <AudioDevice> GetAudioDevices(MMDeviceCollection mmDeviceCollection, string defaultDeviceId, AudioEndpointType audioEndpointType) { lock (_listsLock) { foreach (var device in mmDeviceCollection) { var audioEndpointVolume = AudioEndpointVolume.FromDevice(device); int id; if (_deviceList.Contains(device.DeviceID)) { id = _deviceList.IndexOf(device.DeviceID); } else { id = _deviceList.Count; _deviceList.Add(device.DeviceID); } using (audioEndpointVolume) using (device) yield return new AudioDevice { DeviceId = id, Name = device.FriendlyName, IsDefault = device.DeviceID == defaultDeviceId, CurrentVolume = audioEndpointVolume.MasterVolumeLevelScalar, AudioEndpointType = audioEndpointType, AudioChannels = audioEndpointVolume.Channels.Select( x => new AudioChannel { ChannelIndex = x.ChannelIndex, Volume = x.VolumeScalar }) .ToList() }; } } }
public AudioDevice(MMDevice device) { Device = device; _deviceEnumerator = new MMDeviceEnumerator(); _deviceEnumerator.DefaultDeviceChanged += OnDefaultDeviceChanged; _deviceEnumerator.DeviceStateChanged += OnDeviceStateChanged; _deviceEnumerator.DeviceRemoved += OnDeviceRemoved; _endpointVolume = AudioEndpointVolume.FromDevice(Device); _endpointVolume.RegisterControlChangeNotify(_callback); _callback.NotifyRecived += OnEndpointVolumeChanged; UpdateDisplayName(); Flow = Device.DataFlow.ToDeviceFlow(); DeviceId = Device.DeviceID; Id = DeviceId.GetHashCode(); // This is kinda silly... var defaultDevice = _deviceEnumerator.GetDefaultAudioEndpoint(Device.DataFlow, Role.Console); // Multimedia? Communications? IsDefault = defaultDevice.DeviceID == DeviceId; }
public void Initialize() { MMDevice captureDevice = MMDeviceEnumerator.DefaultAudioEndpoint(DataFlow.Render, Role.Console); WaveFormat deviceFormat = captureDevice.DeviceFormat; _audioEndpointVolume = AudioEndpointVolume.FromDevice(captureDevice); //DarthAffe 07.02.2018: This is a really stupid workaround to (hopefully) finally fix the surround driver issues for (int i = 1; i < 13; i++) { try { _capture = new WasapiLoopbackCapture(100, new WaveFormat(deviceFormat.SampleRate, deviceFormat.BitsPerSample, i)); } catch { } } if (_capture == null) { throw new NullReferenceException("Failed to initialize WasapiLoopbackCapture"); } _capture.Initialize(); _soundInSource = new SoundInSource(_capture) { FillWithZeros = false }; _stream = _soundInSource.WaveFormat.SampleRate == 44100 ? new SingleBlockNotificationStream(_soundInSource.ToStereo().ToSampleSource()) : new SingleBlockNotificationStream(_soundInSource.ChangeSampleRate(44100).ToStereo().ToSampleSource()); _soundInSource.DataAvailable += OnSoundDataAvailable; _capture.Start(); }