private static void DumpDeviceManager(StringBuilder builder, IAudioDeviceManager manager)
{
foreach (var device in manager.Devices)
{
DumpDevice(builder, device);
}
}
public AudioDevice(IAudioDeviceManager deviceManager, IMMDevice device, Dispatcher foregroundDispatcher)
{
_device = device;
_deviceManager = new WeakReference <IAudioDeviceManager>(deviceManager);
_dispatcher = foregroundDispatcher;
_id = device.GetId();
Trace.WriteLine($"AudioDevice Create {_id}");
if (_device.GetState() == DeviceState.ACTIVE)
{
_deviceVolume = device.Activate <IAudioEndpointVolume>();
_deviceVolume.RegisterControlChangeNotify(this);
_deviceVolume.GetMasterVolumeLevelScalar(out _volume);
_isMuted = _deviceVolume.GetMute() != 0;
_isRegistered = true;
_meter = device.Activate <IAudioMeterInformation>();
_channels = new AudioDeviceChannelCollection(_deviceVolume, _dispatcher);
_sessions = new AudioDeviceSessionCollection(this, _device, _dispatcher);
_sessionFilter = new FilteredCollectionChain <IAudioDeviceSession>(_sessions.Sessions, _dispatcher);
Groups = _sessionFilter.Items;
}
else
{
Groups = new ObservableCollection <IAudioDeviceSession>();
}
ReadProperties();
}
public RecordFileTest()
{
videoEncoder = Resolve <IVideoEncoder>();
videoDeviceManager = Resolve <IVideoDeviceManager>();
aacEncoder = Resolve <IAacEncoder>();
audioDeviceManager = Resolve <IAudioDeviceManager>();
}
protected HardwareAppBinding(DeviceCollectionViewModel deviceViewModel, IAudioDeviceManager audioDeviceManager)
{
_deviceCollectionViewModel = deviceViewModel;
_audioDeviceManager = audioDeviceManager;
_commandControlMappings = new List <CommandControlMappingElement>();
_settings = StorageFactory.GetSettings();
}
public SettingsViewModel(SystemConfig config,
IAudioDeviceManager audioDeviceManager,
CameraDeviceService cameraDeviceService,
VideoDeviceAliasService videoDeviceAliasService)
{
_config = config;
_audioDeviceManager = audioDeviceManager;
_cameraDeviceService = cameraDeviceService;
_videoDeviceAliasService = videoDeviceAliasService;
}
public HardwareManager(DeviceCollectionViewModel deviceCollectionViewModel,
IAudioDeviceManager audioDeviceManager)
{
bindings = new Dictionary <Type, HardwareAppBinding>();
RegisterAppBinding(new MidiAppBinding(deviceCollectionViewModel, audioDeviceManager));
RegisterAppBinding(new DeejAppBinding(deviceCollectionViewModel, audioDeviceManager));
Current = this;
}
static string DumpDevices(IAudioDeviceManager manager)
{
StringBuilder sb = new StringBuilder();
foreach (var device in manager.Devices)
{
sb.Append(device == manager.Default ? $"[Default {manager.Kind}] " : "");
sb.AppendLine(DumpDevice(device));
}
return(sb.ToString());
}
static string DumpDevices(IAudioDeviceManager manager)
{
StringBuilder sb = new StringBuilder();
foreach (var device in manager.Devices)
{
sb.Append(device == manager.DefaultPlaybackDevice ? "[Playback Default] " : "");
sb.Append(device == manager.DefaultCommunicationDevice ? "[Communications Default] " : "");
sb.AppendLine(DumpDevice(device));
}
return(sb.ToString());
}
public App()
{
MidiDevices.Manager = new Midi.ManagedMidi.MidiManager();
audioDeviceManager = new NAudioDeviceManager();
deviceViewModel = new DeviceViewModel();
logViewModel = new LogViewModel();
DispatcherUnhandledException += (sender, args) =>
{
logViewModel.Logger.LogError(args.Exception, "Unhandled exception");
args.Handled = true;
};
}
public DeviceCollectionViewModel(IAudioDeviceManager deviceManager, AppSettings settings)
{
_settings = settings;
_deviceManager = deviceManager;
_deviceManager.DefaultChanged += OnDefaultChanged;
_deviceManager.Devices.CollectionChanged += OnCollectionChanged;
OnCollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
_peakMeterTimer = new Timer(1000 / 30); // 30 fps
_peakMeterTimer.AutoReset = true;
_peakMeterTimer.Elapsed += PeakMeterTimer_Elapsed;
}
public DeviceCollectionViewModel(IAudioDeviceManager deviceManager)
{
AllDevices = new ObservableCollection <DeviceViewModel>();
_deviceManager = deviceManager;
_deviceManager.DefaultChanged += DeviceManager_DefaultDeviceChanged;
_deviceManager.Loaded += DeviceManager_Loaded;
_deviceManager.Devices.CollectionChanged += Devices_CollectionChanged;
Devices_CollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
_peakMeterTimer = new Timer(1000 / 30); // 30 fps
_peakMeterTimer.AutoReset = true;
_peakMeterTimer.Elapsed += PeakMeterTimer_Elapsed;
}
// Constructors
public DefaultAudioSwitch(IDisplayManager displayManager,
IAudioDeviceManager audioDeviceManager,
IConfigurationReader configurationReader,
IConfigurationWriter configurationWriter)
{
_displayManager = displayManager;
_audioDeviceManager = audioDeviceManager;
_configurationReader = configurationReader;
_configurationWriter = configurationWriter;
_configuration = CreateDefaultConfigurationIfNecessary(displayManager);
_lastDisplayNode = _displayManager.GetCurrentDisplayMode();
_displayManager.DisplayModeChanged += DisplayModeChanged;
_displayManager.StartPolling(1000);
}
public AudioTriggerManager()
{
_playbackManager = PlaybackDataModelHost.Current;
_playbackManager.AppPropertyChanged += OnAppPropertyChanged;
_playbackManager.AppAdded += (a) => OnAppAddOrRemove(a, AudioAppEventKind.Added);
_playbackManager.AppRemoved += (a) => OnAppAddOrRemove(a, AudioAppEventKind.Removed);
_playbackManager.DeviceAdded += (d) => OnDeviceAddOrRemove(d, AudioDeviceEventKind.Added);
_playbackManager.DeviceRemoved += (d) => OnDeviceAddOrRemove(d, AudioDeviceEventKind.Removed);
_playbackManager.DeviceManager.DefaultChanged += PlaybackDeviceManager_DefaultChanged;
_defaultPlaybackDevice = _playbackManager.DeviceManager.Default;
_recordingManager = WindowsAudioFactory.Create(AudioDeviceKind.Recording);
_recordingManager.DefaultChanged += RecordingMgr_DefaultChanged;
_defaultRecordingDevice = _recordingManager.Default;
}
public DeejAppBinding(DeviceCollectionViewModel deviceViewModel, IAudioDeviceManager audioDeviceManager) :
base(deviceViewModel, audioDeviceManager)
{
Current = this;
lastValues = new Dictionary <CommandControlMappingElement, int>();
DeejIn.AddGeneralCallback(DeejCallback);
LoadSettings(SAVEKEY);
foreach (var command in _commandControlMappings)
{
var config = (DeejConfiguration)command.hardwareConfiguration;
DeejIn._StartListening(config.Port);
}
}
internal DeviceViewModel(IAudioDeviceManager deviceManager, IAudioDevice device) : base(device)
{
_deviceManager = deviceManager;
_device = device;
Apps = new ObservableCollection <IAppItemViewModel>();
_device.PropertyChanged += Device_PropertyChanged;
_device.Groups.CollectionChanged += Sessions_CollectionChanged;
foreach (var session in _device.Groups)
{
Apps.AddSorted(new AppItemViewModel(session), AppItemViewModel.CompareByExeName);
}
UpdateMasterVolumeIcon();
}
internal MainViewModel(IAudioDeviceManager deviceManager)
{
Debug.Assert(Instance == null);
Instance = this;
AllDevices = new ObservableCollection <DeviceViewModel>();
_deviceManager = deviceManager;
_deviceManager.DefaultPlaybackDeviceChanged += DeviceManager_DefaultPlaybackDeviceChanged;
_deviceManager.PlaybackDevicesLoaded += DeviceManager_PlaybackDevicesLoaded;
_deviceManager.Devices.CollectionChanged += Devices_CollectionChanged;
Devices_CollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
_peakMeterTimer = new Timer(1000 / 30); // 30 fps
_peakMeterTimer.AutoReset = true;
_peakMeterTimer.Elapsed += PeakMeterTimer_Elapsed;
}
public VideoLiveAndRecordProvider(ILoggerFacade logger, IAudioDeviceManager audioDeviceManager, int defaultMicrophoneID)
{
_logger = logger;
_aacEncoder = new AacEncoder();
_videoEncoder = new H264VideoEncoder();
_audioDeviceManager = audioDeviceManager;
_useAudioDevice = _audioDeviceManager.GetAudioDeviceById(defaultMicrophoneID);
if (_useAudioDevice == null)
{
_useAudioDevice = _audioDeviceManager.GetAudioDevices().First();
}
_aacEncoder.SetAudioDataSource(_useAudioDevice);
_videoRecord = new Record.Record(_videoEncoder, _aacEncoder);
_videoLiveBroadcast = new LiveBroadcast.LiveBroadcast(_videoEncoder, _aacEncoder);
_videoLiveBroadcast.OnNetworkInterruption += _videoLiveBroadcast_OnNetworkInterruption;
_videoLiveBroadcast.OnNetworkReconnectionFailed += _videoLiveBroadcast_OnNetworkReconnectionFailed;
_videoLiveBroadcast.OnNetworkReconnectionSucceeded += _videoLiveBroadcast_OnNetworkReconnectionSucceeded;
}
public MidiAppBinding(DeviceCollectionViewModel deviceCollectionViewModel,
IAudioDeviceManager audioDeviceManager) : base(deviceCollectionViewModel, audioDeviceManager)
{
Current = this;
MidiIn.AddGeneralCallback(MidiCallback);
LoadSettings(SAVEKEY);
_deviceMapping = new ConcurrentDictionary <string, string>();
foreach (var device in MidiIn.GetAllDevices())
{
_deviceMapping[device.Id] = device.Name;
}
SubscribeToDevices();
}
public static IAudioDeviceManager CreateAudioDeviceManager(AudioDeviceKind kind)
{
if (kind == AudioDeviceKind.Playback)
{
if (s_playbackDevices == null)
{
s_playbackDevices = new AudioDeviceManager(AudioDeviceKind.Playback);
}
return(s_playbackDevices);
}
else
{
if (s_recordingDevices == null)
{
s_recordingDevices = new AudioDeviceManager(AudioDeviceKind.Recording);
}
return(s_recordingDevices);
}
}
public AudioDevice(IAudioDeviceManager deviceManager, IMMDevice device)
{
_device = device;
_deviceManager = new WeakReference <IAudioDeviceManager>(deviceManager);
_dispatcher = App.Current.Dispatcher;
_id = device.GetId();
Trace.WriteLine($"AudioDevice Create {_id}");
_deviceVolume = device.Activate <IAudioEndpointVolume>();
_deviceVolume.RegisterControlChangeNotify(this);
_isRegistered = true;
_meter = device.Activate <IAudioMeterInformation>();
_sessions = new AudioDeviceSessionCollection(this, _device);
_deviceVolume.GetMasterVolumeLevelScalar(out _volume);
_isMuted = _deviceVolume.GetMute() != 0;
ReadDisplayName();
}
public InstrumentAudioRecorderSettingsViewModel(IViewServices viewServices, IAudioDeviceManager deviceManager, ModuleSchema schema, string midiName)
{
this.viewServices = viewServices;
this.schema = schema;
var groups = schema.InstrumentGroups
.Where(ig => ig.Preset)
.Select(ig => ig.Description)
.ToList();
groups.Insert(0, "(All)");
InstrumentGroups = groups;
selectedInstrumentGroup = groups[0];
InputDevices = deviceManager.GetInputs();
// Try to guess at a reasonable input based on known inputs including the MIDI name.
var expectedInputDevices = new[] { $"MASTER ({midiName})", $"IN ({midiName})", $"KICK ({midiName})" };
SelectedInputDevice = InputDevices.FirstOrDefault(input => expectedInputDevices.Contains(input.Name));
kitNumber = schema.Kits;
SelectOutputFileCommand = new DelegateCommand(SelectOutputFile, true);
}
// Constructors
public MainViewModel(IDisplayManager displayManager,
IAudioDeviceManager audioDeviceManager,
IAudioSwitch audioSwitch)
{
_audioSwitch = audioSwitch;
_selectorPanelViewModels = new ObservableCollection <SelectorPanelViewModel>();
_displayManager = displayManager;
var audioDevices = audioDeviceManager.GetAllDevices();
UndoCommand = new RelayCommand <Object>(UndoChanges);
ApplyChangesCommand = new RelayCommand <Object>(ApplyChanges);
var mapping = _audioSwitch.GetConfigMapping();
foreach (var current in _displayManager.GetAllDisplayModes())
{
var currentAudioDeviceId = mapping[current.PresentationDisplayMode];
var selectorViewModel = new SelectorPanelViewModel(current, audioDevices.ToArray(), audioDevices.First(x => currentAudioDeviceId.AudioDeviceId == x.DeviceId));
selectorViewModel.IsDirtyChanged += CheckIfAnySelectorIsDirty;
_selectorPanelViewModels.Add(selectorViewModel);
}
}
public VideoLiveAndRecordBaseProvider(SystemConfig config, ILoggerFacade logger, IAudioDeviceManager audioDeviceManager, EventSubscriptionManager eventSubscriptionManager)
: base(logger, audioDeviceManager, config.UseMicrophoneID)
{
_config = config;
SetViedoEncoderParams(true);
eventSubscriptionManager.Subscribe <ConfigSaveEvent, bool>(null, SetViedoEncoderParams, null);
}
public DesktopWindowCollectorTest()
{
videoEncoder = Resolve <IVideoEncoder>();
aacEncoder = Resolve <IAacEncoder>();
audioDeviceManager = Resolve <IAudioDeviceManager>();
}
public InstrumentAudioRecorderViewModel(IViewServices viewServices, ILogger logger, DeviceViewModel deviceViewModel, IAudioDeviceManager deviceManager)
{
this.logger = logger;
device = deviceViewModel.ConnectedDevice ?? throw new InvalidOperationException("Cannot record audio without a connected device");
schema = device.Schema;
Settings = new InstrumentAudioRecorderSettingsViewModel(viewServices, deviceManager, schema, device.InputName);
Progress = new InstrumentAudioRecorderProgressViewModel();
Title = $"Instrument Audio Recorder ({schema.Identifier.Name})";
StartRecordingCommand = new DelegateCommand(StartRecording, false);
CancelCommand = new DelegateCommand(Cancel, false);
Settings.PropertyChanged += (sender, args) => UpdateButtonStatus();
}
public static void Advise(IAudioDeviceManager deviceManager)
{
_deviceManager = deviceManager;
}
public TeacherVideoLiveAndRecordProvider(SystemConfig config, ILoggerFacade logger, IAudioDeviceManager audioDeviceManager, ILiveStreamAddressProvider liveStreamAddressProvider, EventSubscriptionManager eventSubscriptionManager)
: base(config, logger, audioDeviceManager, eventSubscriptionManager)
{
_liveStreamAddressProvider = liveStreamAddressProvider;
}
public AudioDevice(string id, IAudioDeviceManager parent)
{
Parent = parent;
Id = id;
}
