public bool UpdateVoiceInputDevice(string device)
{
if (string.IsNullOrEmpty(device))
{
return(false);
}
if (targetInputDevice is not null && targetInputDevice.FriendlyName == device)
{
//Tried to set to current device
return(true);
}
MMDevice newInputDevice = GetInputDevice(device);
if (newInputDevice is null)
{
//Device not found
return(false);
}
CleanUpActiveStream();
//Switch devices
targetInputDevice?.Dispose();
targetInputDevice = newInputDevice;
ResetVoiceStream();
return(true);
}
public void Dispose()
{
foreach (var session in _sessions.Values)
{
session.SessionEnded -= OnSessionEnded;
session.VolumeChanged -= OnSessionVolumeChanged;
session.Dispose();
}
_sessions.Clear();
_callback.NotifyRecived -= OnEndpointVolumeChanged;
_sessionManager.SessionCreated -= OnSessionCreated;
_endpointVolume?.UnregisterControlChangeNotify(_callback);
_endpointVolume?.Dispose();
_endpointVolume = null;
_callback = null;
_sessionManager?.Dispose();
_sessionManager = null;
_device?.Dispose();
_device = null;
}
/// <summary>
/// フェードアウトを実行するタスク
/// </summary>
private void FadeOutThread()
{
//自分自身のプロセスを取得する
System.Diagnostics.Process p = System.Diagnostics.Process.GetCurrentProcess();
int pid = p.Id;
MMDevice device = null;
try
{
using (MMDeviceEnumerator DevEnum = new MMDeviceEnumerator())
{
device = DevEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
}
AudioSessionManager sessionManager = device.AudioSessionManager;
for (float i = 100; i >= 0; i -= 1f)
{
foreach (var item in sessionManager.Sessions)
{
if (item.ProcessID != (uint)pid)
{
item.SimpleAudioVolume.MasterVolume = (i / 100.0f);
}
}
Thread.Sleep(100);
}
}
finally
{
if (device != null)
{
device.Dispose();
}
}
}
protected override void Dispose(bool disposing)
{
endpointVolume.Dispose();
device.Dispose();
base.Dispose(disposing);
}
/// <inheritdoc />
public override bool CheckForChanges()
{
using (var enumer = new MMDeviceEnumerator())
{
var outputList = enumer.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active).ToList();
var output = enumer.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
var inputList = enumer.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active).ToList();
var input = enumer.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
var changedOutput = Set(ref _outputDevice, output.FriendlyName);
var changedInput = Set(ref _inputDevice, input.FriendlyName);
var changes = new[]
{
changedOutput,
Set(ref _outputVolume, (int)(output.AudioEndpointVolume.MasterVolumeLevelScalar * 100)),
Set(ref _outputIsMuted, output.AudioEndpointVolume.Mute),
SetList(ref _outputDeviceList, outputList.Select(x => x.FriendlyName)),
changedInput,
Set(ref _inputVolume, (int)(input.AudioEndpointVolume.MasterVolumeLevelScalar * 100)),
Set(ref _inputIsMuted, output.AudioEndpointVolume.Mute),
SetList(ref _inputDeviceList, inputList.Select(x => x.FriendlyName)),
};
if (!changes.Any(x => x))
{
return(false);
}
if (changedOutput)
{
if (_output != null)
{
_output.AudioEndpointVolume.OnVolumeNotification -= OutputOnOnVolumeNotification;
}
_output?.Dispose();
_output = output;
if (_output != null)
{
_output.AudioEndpointVolume.OnVolumeNotification += OutputOnOnVolumeNotification;
}
}
if (changedInput)
{
if (_input != null)
{
_input.AudioEndpointVolume.OnVolumeNotification -= InputOnOnVolumeNotification;
}
_input?.Dispose();
_input = input;
if (_input != null)
{
_input.AudioEndpointVolume.OnVolumeNotification += InputOnOnVolumeNotification;
}
}
}
RaiseChanged();
return(true);
}
/// <summary>
/// ウマ娘ウィンドウの音量が０になって再び０以上になるまで待機します。
/// </summary>
/// <param name="timeOutMillisecond">タイムアウト時間ミリ秒</param>
private void WaitUmaWindowAvailable(Process process, int timeOutMillisecond)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
MMDevice device = null;
try
{
//ウマ娘セッションの検索
AudioSessionControl umamusumeSession = null;
while (umamusumeSession == null)
{
using (MMDeviceEnumerator DevEnum = new MMDeviceEnumerator())
{
device?.Dispose();
device = DevEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
}
AudioSessionManager sessionManager = device.AudioSessionManager;
var sessions = sessionManager.Sessions;
for (int j = 0; j < sessions.Count; j++)
{
if (sessions[j].GetProcessID == process.Id)
{
umamusumeSession = sessions[j];
break;
}
}
}
//0になるまで待機(0以外の間ループ)
while (umamusumeSession.AudioMeterInformation.MasterPeakValue > 0.005)
{
Thread.Sleep(10);
if (stopwatch.ElapsedMilliseconds > timeOutMillisecond)
{
return;
}
}
//0以上になるまで待機(0の間ループ)
while (umamusumeSession.AudioMeterInformation.MasterPeakValue < 0.1)
{
Thread.Sleep(10);
if (stopwatch.ElapsedMilliseconds > timeOutMillisecond)
{
return;
}
}
}
finally
{
if (device != null)
{
device.Dispose();
}
}
}
private void disposeDevice(MMDevice device)
{
if (device != null)
{
device.AudioEndpointVolume.Dispose();
device.Dispose();
}
}
public void Dispose()
{
if (_Device != null)
{
_Device.AudioEndpointVolume.OnVolumeNotification -= AudioEndpointVolume_OnVolumeNotification;
_Device.Dispose();
_Device = null;
}
}
private void FreePlaybackDevice()
{
string disposingPlaybackDeviceFriendlyName = _playbackDevice?.FriendlyName ?? "Unknown";
_audioEndpointVolume?.Dispose();
_playbackDevice?.Dispose();
_playbackDevice = null;
_logger.Information(string.Format("Playback device {0} unregistered as source device to fill Playback volume data model", disposingPlaybackDeviceFriendlyName));
}
private static void DisposeDevice(MMDevice device)
{
if (device == null)
{
return;
}
device.AudioEndpointVolume.Dispose();
device.Dispose();
}
private void OutputDeviceStop()
{
if (play_device_ == null)
{
return;
}
play_device_.Dispose();
play_device_ = null;
}
public void Dispose()
{
// Don't dispose the enumerator as it is part of a service and have to be alive
// while the Plugin is enabled.
_capture?.Dispose();
_endpoint?.Dispose();
_capture = null;
_endpoint = null;
}
public void Dispose()
{
// Client up our MM objects in reverse order
if (iAudioEndpointVolumeMixerCallback != null && iAudioEndpointVolume != null)
{
iAudioEndpointVolume.UnregisterControlChangeNotify(iAudioEndpointVolumeMixerCallback);
}
if (iAudioEndpointVolumeMixerCallback != null)
{
iAudioEndpointVolumeMixerCallback.NotifyRecived -= iVolumeChangedHandler;
iAudioEndpointVolumeMixerCallback = null;
}
if (iAudioEndpointVolume != null)
{
iAudioEndpointVolume.Dispose();
iAudioEndpointVolume = null;
}
if (_mMdevice != null)
{
_mMdevice.Dispose();
_mMdevice = null;
}
if (iMultiMediaNotificationClient != null)
{
iMultiMediaNotificationClient.DefaultDeviceChanged -= iDefaultDeviceChangedHandler;
iMultiMediaNotificationClient.Dispose();
iMultiMediaNotificationClient = null;
}
if (_mMdeviceEnumerator != null)
{
_mMdeviceEnumerator.Dispose();
_mMdeviceEnumerator = null;
}
Stop();
Close();
}
public void Dispose()
{
if (!_disposing)
{
_disposing = true;
_capture?.Dispose();
_inputDevice?.Dispose();
_localOutput?.Dispose();
_localOutput = null;
}
}
private static AudioSessionManager2 GetDefaultAudioSessionManager2(
DataFlow dataFlow)
{
using (MMDeviceEnumerator deviceEnumerator = new MMDeviceEnumerator())
{
using (MMDevice defaultAudioEndpoint = deviceEnumerator.GetDefaultAudioEndpoint(dataFlow, Role.Multimedia))
{
AudioSessionManager2 audioSessionManager2 = AudioSessionManager2.FromMMDevice(defaultAudioEndpoint);
deviceEnumerator.Dispose();
defaultAudioEndpoint.Dispose();
return(audioSessionManager2);
}
}
}
static void Main(string[] args)
{
//自分自身のプロセスを取得する
System.Diagnostics.Process p = System.Diagnostics.Process.GetCurrentProcess();
int pid = p.Id;
MMDevice device = null;
try
{
using (MMDeviceEnumerator DevEnum = new MMDeviceEnumerator())
{
device = DevEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
}
float MasterVolumeLevel = device.AudioEndpointVolume.MasterVolumeLevelScalar;
AudioSessionManager sessionManager = device.AudioSessionManager;
for (float i = 100; i >= 0; i -= 1f)
{
foreach (var item in sessionManager.Sessions)
{
if (item.ProcessID != (uint)pid)
{
item.SimpleAudioVolume.MasterVolume = ((float)i / 100.0f);
}
}
System.Threading.Thread.Sleep(50);
}
//元の音量に戻す
foreach (var item in sessionManager.Sessions)
{
if (item.ProcessID != (uint)pid)
{
item.SimpleAudioVolume.MasterVolume = ((float)100 / 100.0f);
}
}
device.AudioEndpointVolume.MasterVolumeLevelScalar = MasterVolumeLevel;
}
finally
{
//後処理
if (device != null)
{
device.Dispose();
}
}
}
private void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
_defaultEndpointVolumeController.AudioEndpointVolume.OnVolumeNotification -=
AudioEndpointVolume_OnVolumeNotification;
_defaultEndpointVolumeController.Dispose();
AudioMMDevices.Dispose();
AudioMMDevices = null;
}
_disposed = true;
}
private void CheckForDeviceChange()
{
MMDevice current_device = audio_device_enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
if (((WasapiLoopbackCapture)waveIn)?.CaptureState == CaptureState.Stopped ||
default_device == null ||
default_device.ID != current_device.ID ||
(((WasapiLoopbackCapture)waveIn)?.CaptureState != CaptureState.Capturing && (Time.GetSecondsSinceEpoch() - startTime) > 20)) //Check if it has taken over 20 seconds to start the capture which may indicate that there has been an issue
{
Global.logger.LogLine($"CaptureState is {((WasapiLoopbackCapture)waveIn)?.CaptureState}");
UpdateAudioCapture(current_device);
}
else
{
current_device.Dispose();
}
current_device = null;
}
protected virtual void Dispose(bool cleanup)
{
if (disposed)
{
return;
}
if (cleanup)
{
socket?.Dispose();
audioIeee?.Dispose();
inFileWriter?.Dispose();
outFileWriter?.Dispose();
capture?.Dispose();
device?.Dispose();
}
disposed = true;
}
private void UpdateAudioCapture(MMDevice defaultDevice)
{
if (waveIn != null)
{
waveIn.StopRecording();
waveIn.Dispose();
}
default_device?.Dispose();
default_device = defaultDevice;
// Here you decide what you want to use as the waveIn.
// There are many options in NAudio and you can use other streams/files.
// Note that the code varies for each different source.
waveIn = new WasapiLoopbackCapture(default_device);
waveIn.DataAvailable += OnDataAvailable;
waveIn.StartRecording();
}
private void CleanUp()
{
logger.Debug("AudioSource::CleanUp()");
if (captureDevice != null)
{
captureDevice.Dispose();
captureDevice = null;
}
if (audioClient != null)
{
audioClient.Dispose();
audioClient = null;
}
if (frameEventWaitHandle != null)
{
frameEventWaitHandle.Dispose();
frameEventWaitHandle = null;
}
}
private void buttonAudioSetup_Click(object sender, EventArgs e)
{
try
{
MMDevice device = null;
var deviceEnum = new MMDeviceEnumerator();
if (deviceEnum.HasDefaultAudioEndpoint(DataFlow.Render, Role.Console))
{
device = deviceEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console);
}
string deviceId = device.ID;
NAudio.Wave.WaveFormat deviceFormat = device.AudioClient.MixFormat;
device.Dispose();
signalGenerator = new SignalGenerator(16000, 2);
var signalFormat = signalGenerator.WaveFormat;
audioRenderer = new MfAudioRenderer();
AudioRendererArgs audioArgs = new AudioRendererArgs
{
DeviceId = "",
SampleRate = signalFormat.SampleRate,
BitsPerSample = signalFormat.BitsPerSample,
Encoding = (WaveEncodingTag)signalFormat.Encoding,
Channels = signalFormat.Channels,
};
audioRenderer.Setup(audioArgs);
}
catch (Exception ex)
{
logger.Error(ex);
}
}
public void Dispose()
{
channelMemoryA?.Clear();
channelMemoryB?.Clear();
channelWriterA?.Dispose();
channelWriterB?.Dispose();
channelStreamA?.Dispose();
channelStreamB?.Dispose();
channelCapture?.Dispose();
channelDevice?.Dispose();
deviceList?.ForEach(device => device.Dispose());
deviceList?.Clear();
fileTimer?.Stop();
fileTimer?.Dispose();
propertiesWindow?.Dispose();
GC.SuppressFinalize(this);
}
public void Dispose()
{
Recorder?.Dispose();
_mmDevice?.Dispose();
}
public void Dispose()
{
_capture.Dispose();
_renderFix?.Dispose();
Device.Dispose();
}
static void Main(string[] args)
{
MMDevice device = null;
try
{
//ウマ娘セッションの検索
using (MMDeviceEnumerator DevEnum = new MMDeviceEnumerator())
{
device = DevEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
}
//master情報
Console.WriteLine("FriendlyName:" + device.FriendlyName);
Console.WriteLine("DeviceFriendlyName:" + device.DeviceFriendlyName);
Console.WriteLine("IconPathRaw:" + Environment.ExpandEnvironmentVariables(device.IconPath));
//アイコンパス文字列の取得
string[] iconPathSplited = device.IconPath.Split(',');
if (iconPathSplited.Length >= 2)
{
string expandPath = Environment.ExpandEnvironmentVariables(iconPathSplited.First());
int IDraw = int.Parse(iconPathSplited.Last());
uint ID = (uint)Math.Abs(IDraw);
Console.WriteLine("IconPath:" + GetStringFromDll(expandPath, ID));
int err = Marshal.GetLastWin32Error();
}
Console.WriteLine("");
AudioSessionManager sessionManager = device.AudioSessionManager;
var sessions = sessionManager.Sessions;
for (int j = 0; j < sessions.Count; j++)
{
if (string.IsNullOrEmpty(sessions[j].DisplayName))
{
AudioSessionControl aaa = sessions[j];
continue;
}
if (sessions[j].DisplayName.First() == '@')
{
string[] displayNameSplited = sessions[j].DisplayName.Split(',');
string expandPath = Environment.ExpandEnvironmentVariables(displayNameSplited.First().Substring(1));
int IDraw = int.Parse(displayNameSplited.Last());
uint ID = (uint)Math.Abs(IDraw);
Console.WriteLine("DisplayName:" + GetStringFromDll(expandPath, ID));
int err = Marshal.GetLastWin32Error();
}
else
{
Console.WriteLine("DisplayName:" + sessions[j].DisplayName);
}
Console.WriteLine("IconPath:" + sessions[j].IconPath);
Console.WriteLine("");
}
}
finally
{
if (device != null)
{
device.Dispose();
}
}
Console.Read();
}
private void FinalizeAudioDevice()
{
audioDevice.AudioEndpointVolume.OnVolumeNotification -= AudioEndpointVolume_OnVolumeNotification;
audioDevice.Dispose();
logger.Info("Stopped monitoring the audio device.");
}
public override void Disable()
{
_playbackDevice.Dispose();
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
_musicPlayer.Dispose();
_audioDevice.Dispose();
_audioDevice = null;
}
public override EffectLayer Render(IGameState gamestate)
{
try
{
//if (current_device != null)
//current_device.Dispose();
MMDevice current_device = audio_device_enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
if (((WasapiLoopbackCapture)waveIn)?.CaptureState == CaptureState.Stopped || default_device == null || default_device.ID != current_device.ID)
{
UpdateAudioCapture(current_device);
}
else
{
current_device.Dispose();
}
current_device = null;
// The system sound as a value between 0.0 and 1.0
float system_sound_normalized = default_device.AudioEndpointVolume.MasterVolumeLevelScalar;
// Scale the Maximum amplitude with the system sound if enabled, so that at 100% volume the max_amp is unchanged.
// Replaces all Properties.MaxAmplitude calls with the scaled value
float scaled_max_amplitude = Properties.MaxAmplitude * (Properties.ScaleWithSystemVolume ? system_sound_normalized : 1);
float[] freqs = Properties.Frequencies.ToArray(); //Defined Frequencies
double[] freq_results = new double[freqs.Length];
if (previous_freq_results == null || previous_freq_results.Length < freqs.Length)
{
previous_freq_results = new float[freqs.Length];
}
//Maintain local copies of fft, to prevent data overwrite
Complex[] _local_fft = new List <Complex>(_ffts).ToArray();
Complex[] _local_fft_previous = new List <Complex>(_ffts_prev).ToArray();
EffectLayer equalizer_layer = new EffectLayer();
if (Properties.DimBackgroundOnSound)
{
bool hasSound = false;
foreach (var bin in _local_fft)
{
if (bin.X > 0.0005 || bin.X < -0.0005)
{
hasSound = true;
break;
}
}
if (hasSound)
{
equalizer_layer.Fill(Properties.DimColor);
}
}
using (Graphics g = equalizer_layer.GetGraphics())
{
int wave_step_amount = _local_fft.Length / Effects.canvas_width;
switch (Properties.EQType)
{
case EqualizerType.Waveform:
for (int x = 0; x < Effects.canvas_width; x++)
{
float fft_val = _local_fft.Length > x * wave_step_amount ? _local_fft[x * wave_step_amount].X : 0.0f;
Brush brush = GetBrush(fft_val, x, Effects.canvas_width);
g.DrawLine(new Pen(brush), x, Effects.canvas_height_center, x, Effects.canvas_height_center - fft_val / scaled_max_amplitude * 500.0f);
}
break;
case EqualizerType.Waveform_Bottom:
for (int x = 0; x < Effects.canvas_width; x++)
{
float fft_val = _local_fft.Length > x * wave_step_amount ? _local_fft[x * wave_step_amount].X : 0.0f;
Brush brush = GetBrush(fft_val, x, Effects.canvas_width);
g.DrawLine(new Pen(brush), x, Effects.canvas_height, x, Effects.canvas_height - Math.Abs(fft_val / scaled_max_amplitude) * 1000.0f);
}
break;
case EqualizerType.PowerBars:
//Perform FFT again to get frequencies
FastFourierTransform.FFT(false, (int)Math.Log(fftLength, 2.0), _local_fft);
while (flux_array.Count < freqs.Length)
{
flux_array.Add(0.0f);
}
int startF = 0;
int endF = 0;
float threshhold = 300.0f;
for (int x = 0; x < freqs.Length - 1; x++)
{
startF = freqToBin(freqs[x]);
endF = freqToBin(freqs[x + 1]);
float flux = 0.0f;
for (int j = startF; j <= endF; j++)
{
float curr_fft = (float)Math.Sqrt(_local_fft[j].X * _local_fft[j].X + _local_fft[j].Y * _local_fft[j].Y);
float prev_fft = (float)Math.Sqrt(_local_fft_previous[j].X * _local_fft_previous[j].X + _local_fft_previous[j].Y * _local_fft_previous[j].Y);
float value = curr_fft - prev_fft;
float flux_calc = (value + Math.Abs(value)) / 2;
if (flux < flux_calc)
{
flux = flux_calc;
}
flux = flux > threshhold ? 0.0f : flux;
}
flux_array[x] = flux;
}
//System.Diagnostics.Debug.WriteLine($"flux max: {flux_array.Max()}");
float bar_width = Effects.canvas_width / (float)(freqs.Length - 1);
for (int f_x = 0; f_x < freq_results.Length - 1; f_x++)
{
float fft_val = flux_array[f_x] / scaled_max_amplitude;
fft_val = Math.Min(1.0f, fft_val);
if (previous_freq_results[f_x] - fft_val > 0.10)
{
fft_val = previous_freq_results[f_x] - 0.15f;
}
float x = f_x * bar_width;
float y = Effects.canvas_height;
float width = bar_width;
float height = fft_val * Effects.canvas_height;
previous_freq_results[f_x] = fft_val;
Brush brush = GetBrush(-(f_x % 2), f_x, freq_results.Length - 1);
g.FillRectangle(brush, x, y - height, width, height);
}
break;
}
}
var hander = NewLayerRender;
if (hander != null)
{
hander.Invoke(equalizer_layer.GetBitmap());
}
return(equalizer_layer);
}
catch (Exception exc)
{
Global.logger.Error("Error encountered in the Equalizer layer. Exception: " + exc.ToString());
return(new EffectLayer());
}
}