/// <summary>
/// Creates a new Obs audio encoder with default settings.
/// </summary>
/// <returns></returns>
public static ObsEncoder CreateAudioEncoder()
{
// mf_aac for W8 and later, ffmpeg_aac for W7
string encoderId = "mf_aac";
// Windows 7 is Version 6.1. Check if version 6.1 and below. We don't support anything below Windows 7.
if (System.Environment.OSVersion.Platform == PlatformID.Win32NT &&
((System.Environment.OSVersion.Version.Major == 6 && System.Environment.OSVersion.Version.Minor <= 1) ||
System.Environment.OSVersion.Version.Major < 6)
)
{
encoderId = "ffmpeg_aac";
}
ObsEncoder obsAudioEncoder = new ObsEncoder(ObsEncoderType.Audio, encoderId, "simple_aac");
obsAudioEncoder.SetAudio(Obs.GetAudio());
ObsData audioEncoderSettings = new ObsData();
audioEncoderSettings.SetInt("bitrate", Constants.Audio.ENCODER_BITRATE);
audioEncoderSettings.SetString("rate_control", Constants.Audio.RATE_CONTROL);
audioEncoderSettings.SetInt("samplerate", Constants.Audio.SAMPLES_PER_SEC);
audioEncoderSettings.SetBoolDefault("allow he-aac", true);
obsAudioEncoder.Update(audioEncoderSettings);
audioEncoderSettings.Dispose();
return(obsAudioEncoder);
}
/// <summary>
/// Creates a new file output.
/// </summary>
/// <returns></returns>
public static ObsOutput CreateOutput()
{
string videoDirectory = $"{FolderService.GetPath(KnownFolder.Videos)}\\{Store.Data.Record.VideoOutputFolder}";
if (Store.Data.Record.RecordedFiles.Count == 0)
{
Store.Data.Record.LastVideoName = $"ScreenRecording {DateTime.Now:yyyy-MM-dd HH.mm.ss}";
}
string videoFileName = Store.Data.Record.LastVideoName + "_part " + (Store.Data.Record.RecordedFiles.Count + 1) + ".mp4";
string videoFilePath = $"{videoDirectory}\\{videoFileName}";
Store.Data.Record.RecordedFiles.Add(new FileInfo(videoFilePath));
Directory.CreateDirectory(videoDirectory);
videoFilePath = videoFilePath.Replace("\\", "/"); // OBS uses forward slashes
ObsOutput obsOutput = new ObsOutput(ObsOutputType.Dummy, "ffmpeg_muxer", "simple_file_output");
ObsData outputSettings = new ObsData();
outputSettings.SetString("path", videoFilePath);
outputSettings.SetString("muxer_settings", "movflags=faststart");
obsOutput.Update(outputSettings);
outputSettings.Dispose();
return(obsOutput);
}
/// <summary>
/// Sets the audio output to the device with the given audio output id.
/// </summary>
/// <param name="savedAudioOutputId"></param>
/// <returns></returns>
public static string SetAudioOutput(string savedAudioOutputId)
{
ObsData aoSettings = new ObsData();
aoSettings.SetBool(Constants.Audio.SettingKeys.UseDeviceTiming, false);
Store.Data.Audio.OutputSource = Store.Data.Obs.Presentation.CreateSource(Constants.Audio.SettingKeys.WasapiOutputCapture, Constants.Audio.Settings.WasapiOutputCaptureName, aoSettings);
aoSettings.Dispose();
Store.Data.Audio.OutputSource.AudioOffset = Constants.Audio.DELAY_OUTPUT; // For some reason, this offset needs to be here before presentation.CreateSource is called again to take affect
Store.Data.Obs.Presentation.AddSource(Store.Data.Audio.OutputSource);
Store.Data.Audio.OutputItem = Store.Data.Obs.Presentation.CreateItem(Store.Data.Audio.OutputSource);
Store.Data.Audio.OutputItem.Name = Constants.Audio.Settings.WasapiOutputCaptureName;
Store.Data.Audio.OutputMeter = new VolMeter();
Store.Data.Audio.OutputMeter.Level = float.NegativeInfinity;
Store.Data.Audio.OutputMeter.AttachSource(Store.Data.Audio.OutputSource);
Store.Data.Audio.OutputMeter.AddCallBack(MagnitudeService.OutputVolumeCallback);
List <AudioDevice> allAudioOutputs = GetAudioOutputDevices();
bool savedIsInAvailableOutputs = allAudioOutputs.Any(x => x.id == savedAudioOutputId);
var usedAudioOutputId = string.Empty;
if (savedAudioOutputId != null && savedIsInAvailableOutputs)
{
UpdateAudioOutput(savedAudioOutputId);
usedAudioOutputId = savedAudioOutputId;
}
else
{
UpdateAudioOutput(Constants.Audio.NO_DEVICE_ID);
usedAudioOutputId = Constants.Audio.NO_DEVICE_ID;
}
return(usedAudioOutputId);
}
/// <summary>
/// Updates the current audio output device.
/// </summary>
/// <param name="deviceId"></param>
public static void UpdateAudioOutput(string deviceId)
{
Store.Data.Audio.CurrentOutputId = deviceId;
ObsData aoSettings = new ObsData();
aoSettings.SetString(Constants.Audio.SettingKeys.DeviceId, deviceId.Equals(Constants.Audio.NO_DEVICE_ID) ? Constants.Audio.DEFAULT_DEVICE_ID : deviceId);
Store.Data.Audio.OutputSource.Update(aoSettings);
aoSettings.Dispose();
Store.Data.Audio.OutputSource.Enabled = !deviceId.Equals(Constants.Audio.NO_DEVICE_ID);
Store.Data.Audio.OutputSource.Muted = deviceId.Equals(Constants.Audio.NO_DEVICE_ID); // Muted is used to update audio meter
}
/// <summary>
/// Creates a new Obs video encoder with default settings.
/// </summary>
/// <returns></returns>
public static ObsEncoder CreateVideoEncoder()
{
ObsEncoder obsVideoEncoder = new ObsEncoder(ObsEncoderType.Video, "obs_x264", "simple_h264_stream");
IntPtr obsVideoPointer = Obs.GetVideo();
obsVideoEncoder.SetVideo(obsVideoPointer);
ObsData videoEncoderSettings = new ObsData();
videoEncoderSettings.SetInt("bitrate", Constants.Video.ENCODER_BITRATE);
videoEncoderSettings.SetString("rate_control", Constants.Video.RATE_CONTROL);
obsVideoEncoder.Update(videoEncoderSettings);
videoEncoderSettings.Dispose();
return(obsVideoEncoder);
}
private void EditableListChanged(ListBox listBox, ObsProperty property, ObsData setting)
{
string propertyName = property.Name;
ObsDataArray array = new ObsDataArray();
foreach (string item in listBox.Items)
{
ObsData itemArray = new ObsData();
itemArray.SetString("value", item);
array.Add(itemArray);
itemArray.Dispose();
}
setting.SetArray(propertyName, array);
array.Dispose();
}
/// <summary>
/// Sets the audio input to the device with the given audio input id.
/// </summary>
/// <param name="savedAudioInputId"></param>
/// <returns></returns>
public static string SetAudioInput(string savedAudioInputId)
{
ObsData aiSettings = new ObsData();
aiSettings.SetBool(Constants.Audio.SettingKeys.UseDeviceTiming, false);
Store.Data.Audio.InputSource = Store.Data.Obs.Presentation.CreateSource(Constants.Audio.SettingKeys.WasapiInputCapture, Constants.Audio.Settings.WasapiInputCaptureName, aiSettings);
aiSettings.Dispose();
Store.Data.Audio.InputSource.AudioOffset = Constants.Audio.DELAY_INPUT;
Store.Data.Obs.Presentation.AddSource(Store.Data.Audio.InputSource);
Store.Data.Audio.InputItem = Store.Data.Obs.Presentation.CreateItem(Store.Data.Audio.InputSource);
Store.Data.Audio.InputItem.Name = Constants.Audio.Settings.WasapiInputCaptureName;
Store.Data.Audio.InputMeter = new VolMeter();
Store.Data.Audio.InputMeter.Level = float.NegativeInfinity;
Store.Data.Audio.InputMeter.AttachSource(Store.Data.Audio.InputSource);
Store.Data.Audio.InputMeter.AddCallBack(MagnitudeService.InputVolumeCallback);
List <AudioDevice> allAudioInputs = GetAudioInputDevices();
bool savedIsInAvailableInputs = allAudioInputs.Any(x => x.id == savedAudioInputId);
var usedAudioInputId = string.Empty;
if (savedAudioInputId != null && savedIsInAvailableInputs)
{
UpdateAudioInput(savedAudioInputId);
usedAudioInputId = savedAudioInputId;
}
else
{
string defaultDeviceId = Constants.Audio.NO_DEVICE_ID;
IEnumerable <AudioDevice> availableInputs = allAudioInputs.Where(x => x.id != Constants.Audio.NO_DEVICE_ID);
if (availableInputs.Any())
{
defaultDeviceId = availableInputs.First().id;
}
UpdateAudioInput(defaultDeviceId);
usedAudioInputId = defaultDeviceId;
}
return(usedAudioInputId);
}
private void SetWebcamSourceSettings()
{
// Start a timer to see when the webcam resolution has changed
webcamWidthBeforeChange = (int)Store.Data.Webcam.Source.Width;
webcamHeightBeforeChange = (int)Store.Data.Webcam.Source.Height;
ObsData webcamSettings = CreateWebcamSettings();
Store.Data.Webcam.Source.Update(webcamSettings);
webcamSettings.Dispose();
InitializeWebcamPreview();
changeResolutionTimer?.Stop();
changeResolutionTimer = new SystemTimer();
changeResolutionTimer.Interval = 100;
changeResolutionTimer.Elapsed += new ElapsedEventHandler(CheckIfWebcamResolutionChanged);
changeResolutionTimer.Enabled = true;
changeResolutionTimer.Start();
changeResolutionTimer.Disposed += delegate(object sender, EventArgs e)
{
elapsedTimerTime = 0;
};
}
/// <summary>
/// Resets and updates the video settings for video output.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public static bool ResetVideoInfo(ResetVideoInfoParameters parameters)
{
if (Store.Data.Obs.Presentation != null)
{
if (Store.Data.Obs.Presentation.SelectedScene.GetName().ToLowerInvariant() != "main")
{
Store.Data.Obs.Presentation.SetScene(0);
}
}
Store.Data.Record.AppliedCrop = new obs_sceneitem_crop
{
left = parameters.CropLeft,
top = parameters.CropTop,
right = parameters.CropRight,
bottom = parameters.CropBottom
};
Store.Data.Record.ActiveScreen = ScreenHelper.GetScreen(parameters.ScreenX, parameters.ScreenY);
//Set the proper display source
if (Store.Data.Display.DisplaySource != null)
{
ObsData displaySettings = new ObsData();
displaySettings.SetBool("capture_cursor", true);
displaySettings.SetInt("monitor", ObsHelper.GetObsDisplayValueFromScreen(Store.Data.Display.DisplaySource, Store.Data.Record.ActiveScreen));
Store.Data.Display.DisplaySource.Update(displaySettings);
displaySettings.Dispose();
}
//Set the proper display bounds and crop
if (Store.Data.Display.DisplayItem != null)
{
Store.Data.Display.DisplayItem.SetBounds(new Vector2(0, 0), ObsBoundsType.None, ObsAlignment.Top);
Store.Data.Display.DisplayItem.SetCrop(Store.Data.Record.AppliedCrop);
}
WebcamService.CalculateItemPosition();
var obsVideoInfo = new GenerateObsVideoInfoParameters
{
BaseWidth = (uint)parameters.CanvasWidth,
OutputWidth = (uint)parameters.OutputWidth,
BaseHeight = (uint)parameters.CanvasHeight,
OutputHeight = (uint)parameters.OutputHeight,
FrameRate = GetFrameRate(parameters.FrameRate)
};
obs_video_info ovi = ObsHelper.GenerateObsVideoInfoObject(obsVideoInfo);
if (!Obs.ResetVideo(ovi))
{
return(false);
}
Store.Data.Record.CanvasHeight = parameters.CanvasHeight;
Store.Data.Record.CanvasWidth = parameters.CanvasWidth;
return(true);
}