0103-UI-Add-support-for-OpenH264-as-the-worst-case-fallba.patch

From f26c32b97117273550b9dddea01b5b92684c6886 Mon Sep 17 00:00:00 2001
From: Neal Gompa <neal@gompa.dev>
Date: Tue, 28 Mar 2023 05:08:49 -0400
Subject: [PATCH 103/103] UI: Add support for OpenH264 as the worst-case
 fallback

OpenH264 exists as the codec of last resort, so it is implemented
such that it is only used as the software codec if x264 is not
available.
---
 UI/data/locale/en-US.ini             |  1 +
 UI/window-basic-auto-config-test.cpp | 50 +++++++++++++++++++---------
 UI/window-basic-auto-config.cpp      | 15 ++++++++-
 UI/window-basic-auto-config.hpp      |  3 ++
 UI/window-basic-main-outputs.cpp     |  6 ++--
 UI/window-basic-main-profiles.cpp    | 34 +++++++++++--------
 UI/window-basic-main.cpp             | 20 +++++++----
 UI/window-basic-main.hpp             |  3 +-
 UI/window-basic-settings-stream.cpp  | 16 ++++++---
 UI/window-basic-settings.cpp         | 23 ++++++++++---
 10 files changed, 123 insertions(+), 48 deletions(-)

diff --git a/UI/data/locale/en-US.ini b/UI/data/locale/en-US.ini
index 339ac4d86..ff8c649da 100644
--- a/UI/data/locale/en-US.ini
+++ b/UI/data/locale/en-US.ini
@@ -996,6 +996,7 @@ Basic.Settings.Output.Simple.Warn.Encoder="Warning: Recording with a software en
 Basic.Settings.Output.Simple.Warn.Lossless="Warning: Lossless quality generates tremendously large file sizes! Lossless quality can use upward of 7 gigabytes of disk space per minute at high resolutions and framerates. Lossless is not recommended for long recordings unless you have a very large amount of disk space available."
 Basic.Settings.Output.Simple.Warn.Lossless.Msg="Are you sure you want to use lossless quality?"
 Basic.Settings.Output.Simple.Warn.Lossless.Title="Lossless quality warning!"
+Basic.Settings.Output.Simple.Encoder.Software.OpenH264.H264="Software (OpenH264)"
 Basic.Settings.Output.Simple.Encoder.Software.X264.H264="Software (x264)"
 Basic.Settings.Output.Simple.Encoder.Hardware.QSV.H264="Hardware (QSV, H.264)"
 Basic.Settings.Output.Simple.Encoder.Hardware.QSV.AV1="Hardware (QSV, AV1)"
diff --git a/UI/window-basic-auto-config-test.cpp b/UI/window-basic-auto-config-test.cpp
index a8b5d884a..e68a33bb5 100644
--- a/UI/window-basic-auto-config-test.cpp
+++ b/UI/window-basic-auto-config-test.cpp
@@ -199,7 +199,8 @@ void AutoConfigTestPage::TestBandwidthThread()
 						   : "rtmp_common";
 
 	OBSEncoderAutoRelease vencoder = obs_video_encoder_create(
-		"obs_x264", "test_x264", nullptr, nullptr);
+		(wiz->x264Available ? "obs_x264" : "ffmpeg_openh264"),
+		"test_h264", nullptr, nullptr);
 	OBSEncoderAutoRelease aencoder = obs_audio_encoder_create(
 		"ffmpeg_aac", "test_aac", nullptr, 0, nullptr);
 	OBSServiceAutoRelease service = obs_service_create(
@@ -238,10 +239,11 @@ void AutoConfigTestPage::TestBandwidthThread()
 	obs_data_set_string(service_settings, "key", key.c_str());
 
 	obs_data_set_int(vencoder_settings, "bitrate", wiz->startingBitrate);
-	obs_data_set_string(vencoder_settings, "rate_control", "CBR");
-	obs_data_set_string(vencoder_settings, "preset", "veryfast");
-	obs_data_set_int(vencoder_settings, "keyint_sec", 2);
-
+	if (wiz->x264Available) {
+		obs_data_set_string(vencoder_settings, "rate_control", "CBR");
+		obs_data_set_string(vencoder_settings, "preset", "veryfast");
+		obs_data_set_int(vencoder_settings, "keyint_sec", 2);
+	}
 	obs_data_set_int(aencoder_settings, "bitrate", 32);
 
 	OBSBasic *main = reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
@@ -574,7 +576,8 @@ bool AutoConfigTestPage::TestSoftwareEncoding()
 	/* create obs objects                 */
 
 	OBSEncoderAutoRelease vencoder = obs_video_encoder_create(
-		"obs_x264", "test_x264", nullptr, nullptr);
+		(wiz->x264Available ? "obs_x264" : "ffmpeg_openh264"),
+		"test_h264", nullptr, nullptr);
 	OBSEncoderAutoRelease aencoder = obs_audio_encoder_create(
 		"ffmpeg_aac", "test_aac", nullptr, 0, nullptr);
 	OBSOutputAutoRelease output =
@@ -588,17 +591,25 @@ bool AutoConfigTestPage::TestSoftwareEncoding()
 	obs_data_set_int(aencoder_settings, "bitrate", 32);
 
 	if (wiz->type != AutoConfig::Type::Recording) {
-		obs_data_set_int(vencoder_settings, "keyint_sec", 2);
+		if (wiz->x264Available) {
+			obs_data_set_int(vencoder_settings, "keyint_sec", 2);
+			obs_data_set_string(vencoder_settings, "rate_control",
+					    "CBR");
+			obs_data_set_string(vencoder_settings, "preset",
+					    "veryfast");
+		}
 		obs_data_set_int(vencoder_settings, "bitrate",
 				 wiz->idealBitrate);
-		obs_data_set_string(vencoder_settings, "rate_control", "CBR");
 		obs_data_set_string(vencoder_settings, "profile", "main");
-		obs_data_set_string(vencoder_settings, "preset", "veryfast");
 	} else {
-		obs_data_set_int(vencoder_settings, "crf", 20);
-		obs_data_set_string(vencoder_settings, "rate_control", "CRF");
+		if (wiz->x264Available) {
+			obs_data_set_int(vencoder_settings, "crf", 20);
+			obs_data_set_string(vencoder_settings, "rate_control",
+					    "CRF");
+			obs_data_set_string(vencoder_settings, "preset",
+					    "veryfast");
+		}
 		obs_data_set_string(vencoder_settings, "profile", "high");
-		obs_data_set_string(vencoder_settings, "preset", "veryfast");
 	}
 
 	/* -----------------------------------*/
@@ -951,7 +962,10 @@ void AutoConfigTestPage::TestStreamEncoderThread()
 		else
 			wiz->streamingEncoder = AutoConfig::Encoder::AMD;
 	} else {
-		wiz->streamingEncoder = AutoConfig::Encoder::x264;
+		if (wiz->x264Available)
+			wiz->streamingEncoder = AutoConfig::Encoder::x264;
+		else
+			wiz->streamingEncoder = AutoConfig::Encoder::OpenH264;
 	}
 
 #ifdef __linux__
@@ -996,7 +1010,10 @@ void AutoConfigTestPage::TestRecordingEncoderThread()
 		else
 			wiz->recordingEncoder = AutoConfig::Encoder::AMD;
 	} else {
-		wiz->recordingEncoder = AutoConfig::Encoder::x264;
+		if (wiz->x264Available)
+			wiz->streamingEncoder = AutoConfig::Encoder::x264;
+		else
+			wiz->streamingEncoder = AutoConfig::Encoder::OpenH264;
 	}
 
 	if (wiz->recordingEncoder != AutoConfig::Encoder::NVENC) {
@@ -1010,6 +1027,7 @@ void AutoConfigTestPage::TestRecordingEncoderThread()
 }
 
 #define ENCODER_TEXT(x) "Basic.Settings.Output.Simple.Encoder." x
+#define ENCODER_OPENH264 ENCODER_TEXT("Software.OpenH264.H264")
 #define ENCODER_X264 ENCODER_TEXT("Software.X264.H264")
 #define ENCODER_NVENC ENCODER_TEXT("Hardware.NVENC.H264")
 #define ENCODER_QSV ENCODER_TEXT("Hardware.QSV.H264")
@@ -1049,6 +1067,8 @@ void AutoConfigTestPage::FinalizeResults()
 
 	auto encName = [](AutoConfig::Encoder enc) -> QString {
 		switch (enc) {
+		case AutoConfig::Encoder::OpenH264:
+			return QTStr(ENCODER_OPENH264);
 		case AutoConfig::Encoder::x264:
 			return QTStr(ENCODER_X264);
 		case AutoConfig::Encoder::NVENC:
@@ -1063,7 +1083,7 @@ void AutoConfigTestPage::FinalizeResults()
 			return QTStr(QUALITY_SAME);
 		}
 
-		return QTStr(ENCODER_X264);
+		return QTStr(ENCODER_OPENH264);
 	};
 
 	auto newLabel = [this](const char *str) -> QLabel * {
diff --git a/UI/window-basic-auto-config.cpp b/UI/window-basic-auto-config.cpp
index d8ddbfa44..4707a5644 100644
--- a/UI/window-basic-auto-config.cpp
+++ b/UI/window-basic-auto-config.cpp
@@ -979,6 +979,7 @@ AutoConfig::AutoConfig(QWidget *parent) : QWizard(parent)
 	streamPage->ui->bitrate->setValue(bitrate);
 	streamPage->ServiceChanged();
 
+	TestSoftwareEncoding();
 	TestHardwareEncoding();
 	if (!hardwareEncodingAvailable) {
 		delete streamPage->ui->preferHardware;
@@ -1007,6 +1008,16 @@ AutoConfig::~AutoConfig()
 	EnableThreadedMessageBoxes(false);
 }
 
+void AutoConfig::TestSoftwareEncoding()
+{
+	size_t idx = 0;
+	const char *id;
+	while (obs_enum_encoder_types(idx++, &id)) {
+		if (strcmp(id, "obs_x264") == 0)
+			x264Available = true;
+	}
+}
+
 void AutoConfig::TestHardwareEncoding()
 {
 	size_t idx = 0;
@@ -1086,8 +1097,10 @@ inline const char *AutoConfig::GetEncoderId(Encoder enc)
 		return SIMPLE_ENCODER_AMD;
 	case Encoder::Apple:
 		return SIMPLE_ENCODER_APPLE_H264;
-	default:
+	case Encoder::x264:
 		return SIMPLE_ENCODER_X264;
+	default:
+		return SIMPLE_ENCODER_OPENH264;
 	}
 };
 
diff --git a/UI/window-basic-auto-config.hpp b/UI/window-basic-auto-config.hpp
index 5d966c795..c17e32a85 100644
--- a/UI/window-basic-auto-config.hpp
+++ b/UI/window-basic-auto-config.hpp
@@ -43,6 +43,7 @@ class AutoConfig : public QWizard {
 	};
 
 	enum class Encoder {
+		OpenH264,
 		x264,
 		NVENC,
 		QSV,
@@ -91,6 +92,7 @@ class AutoConfig : public QWizard {
 	bool qsvAvailable = false;
 	bool vceAvailable = false;
 	bool appleAvailable = false;
+	bool x264Available = false;
 
 	int startingBitrate = 2500;
 	bool customServer = false;
@@ -106,6 +108,7 @@ class AutoConfig : public QWizard {
 	int specificFPSNum = 0;
 	int specificFPSDen = 0;
 
+	void TestSoftwareEncoding();
 	void TestHardwareEncoding();
 	bool CanTestServer(const char *server);
 
diff --git a/UI/window-basic-main-outputs.cpp b/UI/window-basic-main-outputs.cpp
index a283d0fcc..4b3f25371 100644
--- a/UI/window-basic-main-outputs.cpp
+++ b/UI/window-basic-main-outputs.cpp
@@ -547,7 +547,9 @@ void SimpleOutput::LoadStreamingPreset_Lossy(const char *encoderId)
 /* mistakes have been made to lead us to this. */
 const char *get_simple_output_encoder(const char *encoder)
 {
-	if (strcmp(encoder, SIMPLE_ENCODER_X264) == 0) {
+	if (strcmp(encoder, SIMPLE_ENCODER_OPENH264) == 0) {
+		return "ffmpeg_openh264";
+	} else if (strcmp(encoder, SIMPLE_ENCODER_X264) == 0) {
 		return "obs_x264";
 	} else if (strcmp(encoder, SIMPLE_ENCODER_X264_LOWCPU) == 0) {
 		return "obs_x264";
@@ -581,7 +583,7 @@ const char *get_simple_output_encoder(const char *encoder)
 #endif
 	}
 
-	return "obs_x264";
+	return "ffmpeg_openh264";
 }
 
 void SimpleOutput::LoadRecordingPreset()
diff --git a/UI/window-basic-main-profiles.cpp b/UI/window-basic-main-profiles.cpp
index f9d3f4ea1..27899efc4 100644
--- a/UI/window-basic-main-profiles.cpp
+++ b/UI/window-basic-main-profiles.cpp
@@ -806,7 +806,7 @@ void OBSBasic::ChangeProfile()
 		NewYouTubeAppDock();
 #endif
 
-	CheckForSimpleModeX264Fallback();
+	CheckForSimpleModeH264Fallback();
 
 	blog(LOG_INFO, "Switched to profile '%s' (%s)", newName, newDir);
 	blog(LOG_INFO, "------------------------------------------------");
@@ -827,12 +827,13 @@ void OBSBasic::ChangeProfile()
 	}
 }
 
-void OBSBasic::CheckForSimpleModeX264Fallback()
+void OBSBasic::CheckForSimpleModeH264Fallback()
 {
 	const char *curStreamEncoder =
 		config_get_string(basicConfig, "SimpleOutput", "StreamEncoder");
 	const char *curRecEncoder =
 		config_get_string(basicConfig, "SimpleOutput", "RecEncoder");
+	bool x264_supported = false;
 	bool qsv_supported = false;
 	bool qsv_av1_supported = false;
 	bool amd_supported = false;
@@ -849,7 +850,9 @@ void OBSBasic::CheckForSimpleModeX264Fallback()
 	const char *id;
 
 	while (obs_enum_encoder_types(idx++, &id)) {
-		if (strcmp(id, "h264_texture_amf") == 0)
+		if (strcmp(id, "obs_x264") == 0)
+			x264_supported = true;
+		else if (strcmp(id, "h264_texture_amf") == 0)
 			amd_supported = true;
 		else if (strcmp(id, "obs_qsv11") == 0)
 			qsv_supported = true;
@@ -877,68 +880,73 @@ void OBSBasic::CheckForSimpleModeX264Fallback()
 #endif
 	}
 
+	// Check to see whether x264 is available
+	const char *fallback_encoder_name = (x264_supported
+						     ? SIMPLE_ENCODER_X264
+						     : SIMPLE_ENCODER_OPENH264);
+
 	auto CheckEncoder = [&](const char *&name) {
 		if (strcmp(name, SIMPLE_ENCODER_QSV) == 0) {
 			if (!qsv_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_QSV_AV1) == 0) {
 			if (!qsv_av1_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_NVENC) == 0) {
 			if (!nve_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_NVENC_AV1) == 0) {
 			if (!nve_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 #ifdef ENABLE_HEVC
 		} else if (strcmp(name, SIMPLE_ENCODER_AMD_HEVC) == 0) {
 			if (!amd_hevc_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
 			if (!nve_hevc_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 #endif
 		} else if (strcmp(name, SIMPLE_ENCODER_AMD) == 0) {
 			if (!amd_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_AMD_AV1) == 0) {
 			if (!amd_av1_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 		} else if (strcmp(name, SIMPLE_ENCODER_APPLE_H264) == 0) {
 			if (!apple_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 #ifdef ENABLE_HEVC
 		} else if (strcmp(name, SIMPLE_ENCODER_APPLE_HEVC) == 0) {
 			if (!apple_hevc_supported) {
 				changed = true;
-				name = SIMPLE_ENCODER_X264;
+				name = fallback_encoder_name;
 				return false;
 			}
 #endif
diff --git a/UI/window-basic-main.cpp b/UI/window-basic-main.cpp
index 943e8cac1..09251de75 100644
--- a/UI/window-basic-main.cpp
+++ b/UI/window-basic-main.cpp
@@ -1449,6 +1449,8 @@ extern void CheckExistingCookieId();
 #define DEFAULT_CONTAINER "fragmented_mp4"
 #endif
 
+extern bool EncoderAvailable(const char *encoder);
+
 bool OBSBasic::InitBasicConfigDefaults()
 {
 	QList<QScreen *> screens = QGuiApplication::screens();
@@ -1619,7 +1621,10 @@ bool OBSBasic::InitBasicConfigDefaults()
 	config_set_default_bool(basicConfig, "AdvOut", "UseRescale", false);
 	config_set_default_uint(basicConfig, "AdvOut", "TrackIndex", 1);
 	config_set_default_uint(basicConfig, "AdvOut", "VodTrackIndex", 2);
-	config_set_default_string(basicConfig, "AdvOut", "Encoder", "obs_x264");
+
+	bool useX264 = EncoderAvailable("obs_x264");
+	config_set_default_string(basicConfig, "AdvOut", "Encoder",
+				  (useX264 ? "obs_x264" : "ffmpeg_openh264"));
 
 	config_set_default_string(basicConfig, "AdvOut", "RecType", "Standard");
 
@@ -1744,7 +1749,6 @@ bool OBSBasic::InitBasicConfigDefaults()
 	return true;
 }
 
-extern bool EncoderAvailable(const char *encoder);
 extern bool update_nvenc_presets(ConfigFile &config);
 
 void OBSBasic::InitBasicConfigDefaults2()
@@ -1753,12 +1757,14 @@ void OBSBasic::InitBasicConfigDefaults2()
 					      "Pre23Defaults");
 	bool useNV = EncoderAvailable("ffmpeg_nvenc") && !oldEncDefaults;
 
+	bool useX264 = EncoderAvailable("obs_x264");
+	const char *h264_fallback =
+		(useX264 ? SIMPLE_ENCODER_X264 : SIMPLE_ENCODER_OPENH264);
+
 	config_set_default_string(basicConfig, "SimpleOutput", "StreamEncoder",
-				  useNV ? SIMPLE_ENCODER_NVENC
-					: SIMPLE_ENCODER_X264);
+				  useNV ? SIMPLE_ENCODER_NVENC : h264_fallback);
 	config_set_default_string(basicConfig, "SimpleOutput", "RecEncoder",
-				  useNV ? SIMPLE_ENCODER_NVENC
-					: SIMPLE_ENCODER_X264);
+				  useNV ? SIMPLE_ENCODER_NVENC : h264_fallback);
 
 	const char *aac_default = "ffmpeg_aac";
 	if (EncoderAvailable("CoreAudio_AAC"))
@@ -2040,7 +2046,7 @@ void OBSBasic::OBSInit()
 
 	InitBasicConfigDefaults2();
 
-	CheckForSimpleModeX264Fallback();
+	CheckForSimpleModeH264Fallback();
 
 	blog(LOG_INFO, STARTUP_SEPARATOR);
 
diff --git a/UI/window-basic-main.hpp b/UI/window-basic-main.hpp
index b1eb39592..7d9e8d286 100644
--- a/UI/window-basic-main.hpp
+++ b/UI/window-basic-main.hpp
@@ -69,6 +69,7 @@ class OBSBasicVCamConfig;
 
 #define SIMPLE_ENCODER_X264 "x264"
 #define SIMPLE_ENCODER_X264_LOWCPU "x264_lowcpu"
+#define SIMPLE_ENCODER_OPENH264 "ffmpeg_openh264"
 #define SIMPLE_ENCODER_QSV "qsv"
 #define SIMPLE_ENCODER_QSV_AV1 "qsv_av1"
 #define SIMPLE_ENCODER_NVENC "nvenc"
@@ -446,7 +447,7 @@ private:
 	void DeleteProfile(const char *profile_name, const char *profile_dir);
 	void RefreshProfiles();
 	void ChangeProfile();
-	void CheckForSimpleModeX264Fallback();
+	void CheckForSimpleModeH264Fallback();
 
 	void SaveProjectNow();
 
diff --git a/UI/window-basic-settings-stream.cpp b/UI/window-basic-settings-stream.cpp
index e2ba4b677..a08c697d4 100644
--- a/UI/window-basic-settings-stream.cpp
+++ b/UI/window-basic-settings-stream.cpp
@@ -1437,7 +1437,9 @@ static QString get_adv_fallback(const QString &enc)
 		return "com.apple.videotoolbox.videoencoder.ave.avc";
 	if (enc == "obs_qsv11_av1")
 		return "obs_qsv11";
-	return "obs_x264";
+	if (EncoderAvailable("obs_x264"))
+		return "obs_x264";
+	return "ffmpeg_openh264";
 }
 
 static QString get_adv_audio_fallback(const QString &enc)
@@ -1466,7 +1468,9 @@ static QString get_simple_fallback(const QString &enc)
 		return SIMPLE_ENCODER_APPLE_H264;
 	if (enc == SIMPLE_ENCODER_QSV_AV1)
 		return SIMPLE_ENCODER_QSV;
-	return SIMPLE_ENCODER_X264;
+	if (EncoderAvailable("obs_x264"))
+		return SIMPLE_ENCODER_X264;
+	return SIMPLE_ENCODER_OPENH264;
 }
 
 bool OBSBasicSettings::ServiceSupportsCodecCheck()
@@ -1670,8 +1674,12 @@ void OBSBasicSettings::ResetEncoders(bool streamOnly)
 
 #define ENCODER_STR(str) QTStr("Basic.Settings.Output.Simple.Encoder." str)
 
-	ui->simpleOutStrEncoder->addItem(ENCODER_STR("Software.X264.H264"),
-					 QString(SIMPLE_ENCODER_X264));
+	ui->simpleOutStrEncoder->addItem(ENCODER_STR("Software.OpenH264.H264"),
+					 QString(SIMPLE_ENCODER_OPENH264));
+	if (service_supports_encoder(vcodecs, "obs_x264"))
+		ui->simpleOutStrEncoder->addItem(
+			ENCODER_STR("Software.X264.H264"),
+			QString(SIMPLE_ENCODER_X264));
 #ifdef _WIN32
 	if (service_supports_encoder(vcodecs, "obs_qsv11"))
 		ui->simpleOutStrEncoder->addItem(
diff --git a/UI/window-basic-settings.cpp b/UI/window-basic-settings.cpp
index ddf0adc56..9b7324ab9 100644
--- a/UI/window-basic-settings.cpp
+++ b/UI/window-basic-settings.cpp
@@ -3779,6 +3779,11 @@ void OBSBasicSettings::SaveOutputSettings()
          do. This only exists to make sure that the x264 preset doesn't
          get overwritten with empty data. */
 		presetType = "ApplePreset";
+	else if (encoder == SIMPLE_ENCODER_OPENH264)
+		/* The OpenH264 encoder does not have presets like the other encoders
+         do. This only exists to make sure that the x264 preset doesn't
+         get overwritten with empty data. */
+		presetType = "OpenH264Preset";
 	else
 		presetType = "Preset";
 
@@ -5237,11 +5242,16 @@ void OBSBasicSettings::FillSimpleRecordingValues()
 	ADD_QUALITY("HQ");
 	ADD_QUALITY("Lossless");
 
-	ui->simpleOutRecEncoder->addItem(ENCODER_STR("Software.X264.H264"),
-					 QString(SIMPLE_ENCODER_X264));
-	ui->simpleOutRecEncoder->addItem(
-		ENCODER_STR("SoftwareLowCPU.X264.H264"),
-		QString(SIMPLE_ENCODER_X264_LOWCPU));
+	ui->simpleOutRecEncoder->addItem(ENCODER_STR("Software.OpenH264.H264"),
+					 QString(SIMPLE_ENCODER_OPENH264));
+	if (EncoderAvailable("obs_x264")) {
+		ui->simpleOutRecEncoder->addItem(
+			ENCODER_STR("Software.X264.H264"),
+			QString(SIMPLE_ENCODER_X264));
+		ui->simpleOutRecEncoder->addItem(
+			ENCODER_STR("SoftwareLowCPU.X264.H264"),
+			QString(SIMPLE_ENCODER_X264_LOWCPU));
+	}
 	if (EncoderAvailable("obs_qsv11"))
 		ui->simpleOutRecEncoder->addItem(
 			ENCODER_STR("Hardware.QSV.H264"),
@@ -5414,6 +5424,9 @@ void OBSBasicSettings::SimpleStreamingEncoderChanged()
 
 		defaultPreset = "balanced";
 		preset = curAMDAV1Preset;
+	} else if (encoder == SIMPLE_ENCODER_OPENH264) {
+		ui->simpleOutPreset->setVisible(false);
+		ui->simpleOutPresetLabel->setVisible(false);
 	} else {
 
 #define PRESET_STR(val) \
-- 
2.41.0