Move basic mode configuration to a separate file

Having everything in global.ini meant that if you wanted different
settings for studio mode, that it would also overwrite it for basic
mode.  This way, the settings for each mode are separate, and you can
use different settings for each mode.

obs/obs-app.cpp

@@ -56,51 +56,14 @@ static void do_log(int log_level, const char *msg, va_list args)
 bool OBSApp::InitGlobalConfigDefaults()
 {
 	config_set_default_string(globalConfig, "General", "Language", "en");
-	config_set_default_int(globalConfig, "Window", "PosX",  -1);
-	config_set_default_int(globalConfig, "Window", "PosY",  -1);
-	config_set_default_int(globalConfig, "Window", "SizeX", -1);
-	config_set_default_int(globalConfig, "Window", "SizeY", -1);
-
-	vector<MonitorInfo> monitors;
-	GetMonitors(monitors);
-
-	if (!monitors.size()) {
-		OBSErrorBox(NULL, "There appears to be no monitors.  Er, this "
-		                  "technically shouldn't be possible.");
-		return false;
-	}
-
-	uint32_t cx = monitors[0].cx;
-	uint32_t cy = monitors[0].cy;
 
 #if _WIN32
 	config_set_default_string(globalConfig, "Video", "Renderer",
 			"Direct3D 11");
 #else
-	config_set_default_string(globalConfig, "Video", "Renderer",
-			"OpenGL");
+	config_set_default_string(globalConfig, "Video", "Renderer", "OpenGL");
 #endif
 
-	config_set_default_uint(globalConfig, "Video", "BaseCX",   cx);
-	config_set_default_uint(globalConfig, "Video", "BaseCY",   cy);
-
-	cx = cx * 10 / 15;
-	cy = cy * 10 / 15;
-	config_set_default_uint(globalConfig, "Video", "OutputCX", cx);
-	config_set_default_uint(globalConfig, "Video", "OutputCY", cy);
-
-	config_set_default_uint(globalConfig, "Video", "FPSType", 0);
-	config_set_default_string(globalConfig, "Video", "FPSCommon", "30");
-	config_set_default_uint(globalConfig, "Video", "FPSInt", 30);
-	config_set_default_uint(globalConfig, "Video", "FPSNum", 30);
-	config_set_default_uint(globalConfig, "Video", "FPSDen", 1);
-	config_set_default_uint(globalConfig, "Video", "FPSNS", 33333333);
-
-	config_set_default_uint(globalConfig, "Audio", "SampleRate", 44100);
-	config_set_default_string(globalConfig, "Audio", "ChannelSetup",
-			"Stereo");
-	config_set_default_uint(globalConfig, "Audio", "BufferingTime", 1000);
-
 	return true;
 }
 
@@ -116,8 +79,21 @@ static bool do_mkdir(const char *path)
 
 static bool MakeUserDirs()
 {
-	BPtr<char> configPath(os_get_config_path("obs-studio"));
-	return do_mkdir(configPath);
+	BPtr<char> configPath;
+
+	configPath = os_get_config_path("obs-studio");
+	if (!do_mkdir(configPath))
+		return false;
+
+	configPath = os_get_config_path("obs-studio/basic");
+	if (!do_mkdir(configPath))
+		return false;
+
+	configPath = os_get_config_path("obs-studio/studio");
+	if (!do_mkdir(configPath))
+		return false;
+
+	return true;
 }
 
 bool OBSApp::InitGlobalConfig()
@@ -189,69 +165,6 @@ OBSApp::OBSApp(int &argc, char **argv)
 	mainWindow = move(unique_ptr<OBSBasic>(new OBSBasic()));
 }
 
-void OBSApp::GetFPSCommon(uint32_t &num, uint32_t &den) const
-{
-	const char *val = config_get_string(globalConfig, "Video", "FPSCommon");
-
-	if (strcmp(val, "10") == 0) {
-		num = 10;
-		den = 1;
-	} else if (strcmp(val, "20") == 0) {
-		num = 20;
-		den = 1;
-	} else if (strcmp(val, "25") == 0) {
-		num = 25;
-		den = 1;
-	} else if (strcmp(val, "29.97") == 0) {
-		num = 30000;
-		den = 1001;
-	} else if (strcmp(val, "48") == 0) {
-		num = 48;
-		den = 1;
-	} else if (strcmp(val, "59.94") == 0) {
-		num = 60000;
-		den = 1001;
-	} else if (strcmp(val, "60") == 0) {
-		num = 60;
-		den = 1;
-	} else {
-		num = 30;
-		den = 1;
-	}
-}
-
-void OBSApp::GetFPSInteger(uint32_t &num, uint32_t &den) const
-{
-	num = (uint32_t)config_get_uint(globalConfig, "Video", "FPSInt");
-	den = 1;
-}
-
-void OBSApp::GetFPSFraction(uint32_t &num, uint32_t &den) const
-{
-	num = (uint32_t)config_get_uint(globalConfig, "Video", "FPSNum");
-	den = (uint32_t)config_get_uint(globalConfig, "Video", "FPSDen");
-}
-
-void OBSApp::GetFPSNanoseconds(uint32_t &num, uint32_t &den) const
-{
-	num = 1000000000;
-	den = (uint32_t)config_get_uint(globalConfig, "Video", "FPSNS");
-}
-
-void OBSApp::GetConfigFPS(uint32_t &num, uint32_t &den) const
-{
-	uint32_t type = config_get_uint(globalConfig, "Video", "FPSType");
-
-	if (type == 1) //"Integer"
-		GetFPSInteger(num, den);
-	else if (type == 2) //"Fraction"
-		GetFPSFraction(num, den);
-	else if (false) //"Nanoseconds", currently not implemented
-		GetFPSNanoseconds(num, den);
-	else
-		GetFPSCommon(num, den);
-}
-
 const char *OBSApp::GetRenderModule() const
 {
 	const char *renderer = config_get_string(globalConfig, "Video",

obs/obs-app.hpp

@@ -35,14 +35,8 @@ private:
 
 	bool InitGlobalConfig();
 	bool InitGlobalConfigDefaults();
-	bool InitConfigDefaults();
 	bool InitLocale();
 
-	void GetFPSCommon(uint32_t &num, uint32_t &den) const;
-	void GetFPSInteger(uint32_t &num, uint32_t &den) const;
-	void GetFPSFraction(uint32_t &num, uint32_t &den) const;
-	void GetFPSNanoseconds(uint32_t &num, uint32_t &den) const;
-
 public:
 	OBSApp(int &argc, char **argv);
 
@@ -62,7 +56,6 @@ public:
 		return textLookup.GetString(lookupVal);
 	}
 
-	void GetConfigFPS(uint32_t &num, uint32_t &den) const;
 	const char *GetRenderModule() const;
 };
 

obs/window-basic-main.cpp

@@ -21,7 +21,11 @@
 #include <QShowEvent>
 #include <QFileDialog>
 
+#include <util/util.hpp>
+#include <util/platform.h>
+
 #include "obs-app.hpp"
+#include "platform.hpp"
 #include "window-basic-settings.hpp"
 #include "window-namedialog.hpp"
 #include "window-basic-main.hpp"
@@ -43,6 +47,60 @@ OBSBasic::OBSBasic(QWidget *parent)
 	ui->setupUi(this);
 }
 
+bool OBSBasic::InitBasicConfigDefaults()
+{
+	config_set_default_int(basicConfig, "Window", "PosX",  -1);
+	config_set_default_int(basicConfig, "Window", "PosY",  -1);
+	config_set_default_int(basicConfig, "Window", "SizeX", -1);
+	config_set_default_int(basicConfig, "Window", "SizeY", -1);
+
+	vector<MonitorInfo> monitors;
+	GetMonitors(monitors);
+
+	if (!monitors.size()) {
+		OBSErrorBox(NULL, "There appears to be no monitors.  Er, this "
+		                  "technically shouldn't be possible.");
+		return false;
+	}
+
+	uint32_t cx = monitors[0].cx;
+	uint32_t cy = monitors[0].cy;
+
+	config_set_default_uint  (basicConfig, "Video", "BaseCX",   cx);
+	config_set_default_uint  (basicConfig, "Video", "BaseCY",   cy);
+
+	cx = cx * 10 / 15;
+	cy = cy * 10 / 15;
+	config_set_default_uint  (basicConfig, "Video", "OutputCX", cx);
+	config_set_default_uint  (basicConfig, "Video", "OutputCY", cy);
+
+	config_set_default_uint  (basicConfig, "Video", "FPSType", 0);
+	config_set_default_string(basicConfig, "Video", "FPSCommon", "30");
+	config_set_default_uint  (basicConfig, "Video", "FPSInt", 30);
+	config_set_default_uint  (basicConfig, "Video", "FPSNum", 30);
+	config_set_default_uint  (basicConfig, "Video", "FPSDen", 1);
+
+	config_set_default_uint  (basicConfig, "Audio", "SampleRate", 44100);
+	config_set_default_string(basicConfig, "Audio", "ChannelSetup",
+			"Stereo");
+	config_set_default_uint  (basicConfig, "Audio", "BufferingTime", 1000);
+
+	return true;
+}
+
+bool OBSBasic::InitBasicConfig()
+{
+	BPtr<char> configPath(os_get_config_path("obs-studio/basic/basic.ini"));
+
+	int errorcode = basicConfig.Open(configPath, CONFIG_OPEN_ALWAYS);
+	if (errorcode != CONFIG_SUCCESS) {
+		OBSErrorBox(NULL, "Failed to open basic.ini: %d", errorcode);
+		return false;
+	}
+
+	return InitBasicConfigDefaults();
+}
+
 void OBSBasic::OBSInit()
 {
 	/* make sure it's fully displayed before doing any initialization */
@@ -51,6 +109,8 @@ void OBSBasic::OBSInit()
 
 	if (!obs_startup())
 		throw "Failed to initialize libobs";
+	if (!InitBasicConfig())
+		throw "Failed to load basic.ini";
 	if (!ResetVideo())
 		throw "Failed to initialize video";
 	if (!ResetAudio())
@@ -294,16 +354,16 @@ bool OBSBasic::ResetVideo()
 {
 	struct obs_video_info ovi;
 
-	App()->GetConfigFPS(ovi.fps_num, ovi.fps_den);
+	GetConfigFPS(ovi.fps_num, ovi.fps_den);
 
 	ovi.graphics_module = App()->GetRenderModule();
-	ovi.base_width     = (uint32_t)config_get_uint(GetGlobalConfig(),
+	ovi.base_width     = (uint32_t)config_get_uint(basicConfig,
 			"Video", "BaseCX");
-	ovi.base_height    = (uint32_t)config_get_uint(GetGlobalConfig(),
+	ovi.base_height    = (uint32_t)config_get_uint(basicConfig,
 			"Video", "BaseCY");
-	ovi.output_width   = (uint32_t)config_get_uint(GetGlobalConfig(),
+	ovi.output_width   = (uint32_t)config_get_uint(basicConfig,
 			"Video", "OutputCX");
-	ovi.output_height  = (uint32_t)config_get_uint(GetGlobalConfig(),
+	ovi.output_height  = (uint32_t)config_get_uint(basicConfig,
 			"Video", "OutputCY");
 	ovi.output_format  = VIDEO_FORMAT_I420;
 	ovi.adapter        = 0;
@@ -331,10 +391,10 @@ bool OBSBasic::ResetAudio()
 	ai.name = "Main Audio Track";
 	ai.format = AUDIO_FORMAT_FLOAT;
 
-	ai.samples_per_sec = config_get_uint(GetGlobalConfig(), "Audio",
+	ai.samples_per_sec = config_get_uint(basicConfig, "Audio",
 			"SampleRate");
 
-	const char *channelSetupStr = config_get_string(GetGlobalConfig(),
+	const char *channelSetupStr = config_get_string(basicConfig,
 			"Audio", "ChannelSetup");
 
 	if (strcmp(channelSetupStr, "Mono") == 0)
@@ -342,8 +402,7 @@ bool OBSBasic::ResetAudio()
 	else
 		ai.speakers = SPEAKERS_STEREO;
 
-	ai.buffer_ms = config_get_uint(GetGlobalConfig(), "Audio",
-			"BufferingTime");
+	ai.buffer_ms = config_get_uint(basicConfig, "Audio", "BufferingTime");
 
 	return obs_reset_audio(&ai);
 }
@@ -636,3 +695,71 @@ void OBSBasic::on_settingsButton_clicked()
 	OBSBasicSettings settings(this);
 	settings.exec();
 }
+
+void OBSBasic::GetFPSCommon(uint32_t &num, uint32_t &den) const
+{
+	const char *val = config_get_string(basicConfig, "Video", "FPSCommon");
+
+	if (strcmp(val, "10") == 0) {
+		num = 10;
+		den = 1;
+	} else if (strcmp(val, "20") == 0) {
+		num = 20;
+		den = 1;
+	} else if (strcmp(val, "25") == 0) {
+		num = 25;
+		den = 1;
+	} else if (strcmp(val, "29.97") == 0) {
+		num = 30000;
+		den = 1001;
+	} else if (strcmp(val, "48") == 0) {
+		num = 48;
+		den = 1;
+	} else if (strcmp(val, "59.94") == 0) {
+		num = 60000;
+		den = 1001;
+	} else if (strcmp(val, "60") == 0) {
+		num = 60;
+		den = 1;
+	} else {
+		num = 30;
+		den = 1;
+	}
+}
+
+void OBSBasic::GetFPSInteger(uint32_t &num, uint32_t &den) const
+{
+	num = (uint32_t)config_get_uint(basicConfig, "Video", "FPSInt");
+	den = 1;
+}
+
+void OBSBasic::GetFPSFraction(uint32_t &num, uint32_t &den) const
+{
+	num = (uint32_t)config_get_uint(basicConfig, "Video", "FPSNum");
+	den = (uint32_t)config_get_uint(basicConfig, "Video", "FPSDen");
+}
+
+void OBSBasic::GetFPSNanoseconds(uint32_t &num, uint32_t &den) const
+{
+	num = 1000000000;
+	den = (uint32_t)config_get_uint(basicConfig, "Video", "FPSNS");
+}
+
+void OBSBasic::GetConfigFPS(uint32_t &num, uint32_t &den) const
+{
+	uint32_t type = config_get_uint(basicConfig, "Video", "FPSType");
+
+	if (type == 1) //"Integer"
+		GetFPSInteger(num, den);
+	else if (type == 2) //"Fraction"
+		GetFPSFraction(num, den);
+	else if (false) //"Nanoseconds", currently not implemented
+		GetFPSNanoseconds(num, den);
+	else
+		GetFPSCommon(num, den);
+}
+
+config_t OBSBasic::Config() const
+{
+	return basicConfig;
+}

obs/window-basic-main.hpp

@@ -22,6 +22,8 @@
 #include <memory>
 #include "window-main.hpp"
 
+#include <util/util.hpp>
+
 class QListWidgetItem;
 
 #include "ui_OBSBasic.h"
@@ -34,6 +36,17 @@ private:
 	obs_output_t outputTest;
 	bool         sceneChanging;
 
+	ConfigFile   basicConfig;
+
+	void GetFPSCommon(uint32_t &num, uint32_t &den) const;
+	void GetFPSInteger(uint32_t &num, uint32_t &den) const;
+	void GetFPSFraction(uint32_t &num, uint32_t &den) const;
+	void GetFPSNanoseconds(uint32_t &num, uint32_t &den) const;
+	void GetConfigFPS(uint32_t &num, uint32_t &den) const;
+
+	bool         InitBasicConfigDefaults();
+	bool         InitBasicConfig();
+
 	OBSScene     GetCurrentScene();
 	OBSSceneItem GetCurrentSceneItem();
 
@@ -103,6 +116,8 @@ public:
 
 	virtual void OBSInit() override;
 
+	virtual config_t Config() const override;
+
 private:
 	std::unique_ptr<Ui::OBSBasic> ui;
 };

obs/window-basic-settings.cpp

@@ -80,6 +80,7 @@ static bool ConvertResText(const char *res, uint32_t &cx, uint32_t &cy)
 
 OBSBasicSettings::OBSBasicSettings(QWidget *parent)
 	: QDialog        (parent),
+	  main           (qobject_cast<OBSBasic*>(parent)),
 	  ui             (new Ui::OBSBasicSettings),
 	  generalChanged (false),
 	  outputsChanged (false),
@@ -193,8 +194,8 @@ void OBSBasicSettings::ResetDownscales(uint32_t cx, uint32_t cy)
 
 void OBSBasicSettings::LoadResolutionLists()
 {
-	uint32_t cx = config_get_uint(GetGlobalConfig(), "Video", "BaseCX");
-	uint32_t cy = config_get_uint(GetGlobalConfig(), "Video", "BaseCY");
+	uint32_t cx = config_get_uint(main->Config(), "Video", "BaseCX");
+	uint32_t cy = config_get_uint(main->Config(), "Video", "BaseCY");
 	vector<MonitorInfo> monitors;
 
 	ui->baseResolution->clear();
@@ -210,15 +211,15 @@ void OBSBasicSettings::LoadResolutionLists()
 
 	ui->baseResolution->lineEdit()->setText(ResString(cx, cy).c_str());
 
-	cx = config_get_uint(GetGlobalConfig(), "Video", "OutputCX");
-	cy = config_get_uint(GetGlobalConfig(), "Video", "OutputCY");
+	cx = config_get_uint(main->Config(), "Video", "OutputCX");
+	cy = config_get_uint(main->Config(), "Video", "OutputCY");
 
 	ui->outputResolution->lineEdit()->setText(ResString(cx, cy).c_str());
 }
 
-static inline void LoadFPSCommon(Ui::OBSBasicSettings *ui)
+static inline void LoadFPSCommon(OBSBasic *main, Ui::OBSBasicSettings *ui)
 {
-	const char *val = config_get_string(GetGlobalConfig(), "Video",
+	const char *val = config_get_string(main->Config(), "Video",
 			"FPSCommon");
 
 	int idx = ui->fpsCommon->findText(val);
@@ -226,16 +227,16 @@ static inline void LoadFPSCommon(Ui::OBSBasicSettings *ui)
 	ui->fpsCommon->setCurrentIndex(idx);
 }
 
-static inline void LoadFPSInteger(Ui::OBSBasicSettings *ui)
+static inline void LoadFPSInteger(OBSBasic *main, Ui::OBSBasicSettings *ui)
 {
-	uint32_t val = config_get_uint(GetGlobalConfig(), "Video", "FPSInt");
+	uint32_t val = config_get_uint(main->Config(), "Video", "FPSInt");
 	ui->fpsInteger->setValue(val);
 }
 
-static inline void LoadFPSFraction(Ui::OBSBasicSettings *ui)
+static inline void LoadFPSFraction(OBSBasic *main, Ui::OBSBasicSettings *ui)
 {
-	uint32_t num = config_get_uint(GetGlobalConfig(), "Video", "FPSNum");
-	uint32_t den = config_get_uint(GetGlobalConfig(), "Video", "FPSDen");
+	uint32_t num = config_get_uint(main->Config(), "Video", "FPSNum");
+	uint32_t den = config_get_uint(main->Config(), "Video", "FPSDen");
 
 	ui->fpsNumerator->setValue(num);
 	ui->fpsDenominator->setValue(den);
@@ -243,11 +244,11 @@ static inline void LoadFPSFraction(Ui::OBSBasicSettings *ui)
 
 void OBSBasicSettings::LoadFPSData()
 {
-	LoadFPSCommon(ui.get());
-	LoadFPSInteger(ui.get());
-	LoadFPSFraction(ui.get());
+	LoadFPSCommon(main, ui.get());
+	LoadFPSInteger(main, ui.get());
+	LoadFPSFraction(main, ui.get());
 
-	uint32_t fpsType = config_get_uint(GetGlobalConfig(), "Video",
+	uint32_t fpsType = config_get_uint(main->Config(), "Video",
 			"FPSType");
 	if (fpsType > 2) fpsType = 0;
 
@@ -324,11 +325,11 @@ void OBSBasicSettings::LoadAudioDevices()
 
 void OBSBasicSettings::LoadAudioSettings()
 {
-	uint32_t sampleRate = config_get_uint(GetGlobalConfig(), "Audio",
+	uint32_t sampleRate = config_get_uint(main->Config(), "Audio",
 			"SampleRate");
-	const char *speakers = config_get_string(GetGlobalConfig(), "Audio",
+	const char *speakers = config_get_string(main->Config(), "Audio",
 			"ChannelSetup");
-	uint32_t bufferingTime = config_get_uint(GetGlobalConfig(), "Audio",
+	uint32_t bufferingTime = config_get_uint(main->Config(), "Audio",
 			"BufferingTime");
 
 	loading = true;
@@ -397,25 +398,23 @@ void OBSBasicSettings::SaveVideoSettings()
 			QT_TO_UTF8(renderer));
 
 	if (ConvertResText(QT_TO_UTF8(baseResolution), cx, cy)) {
-		config_set_uint(GetGlobalConfig(), "Video", "BaseCX", cx);
-		config_set_uint(GetGlobalConfig(), "Video", "BaseCY", cy);
+		config_set_uint(main->Config(), "Video", "BaseCX", cx);
+		config_set_uint(main->Config(), "Video", "BaseCY", cy);
 	}
 
 	if (ConvertResText(QT_TO_UTF8(outputResolution), cx, cy)) {
-		config_set_uint(GetGlobalConfig(), "Video", "OutputCX", cx);
-		config_set_uint(GetGlobalConfig(), "Video", "OutputCY", cy);
+		config_set_uint(main->Config(), "Video", "OutputCX", cx);
+		config_set_uint(main->Config(), "Video", "OutputCY", cy);
 	}
 
-	config_set_uint(GetGlobalConfig(), "Video", "FPSType", fpsType);
-	config_set_string(GetGlobalConfig(), "Video", "FPSCommon",
+	config_set_uint(main->Config(), "Video", "FPSType", fpsType);
+	config_set_string(main->Config(), "Video", "FPSCommon",
 			QT_TO_UTF8(fpsCommon));
-	config_set_uint(GetGlobalConfig(), "Video", "FPSInt", fpsInteger);
-	config_set_uint(GetGlobalConfig(), "Video", "FPSNum", fpsNumerator);
-	config_set_uint(GetGlobalConfig(), "Video", "FPSDen", fpsDenominator);
+	config_set_uint(main->Config(), "Video", "FPSInt", fpsInteger);
+	config_set_uint(main->Config(), "Video", "FPSNum", fpsNumerator);
+	config_set_uint(main->Config(), "Video", "FPSDen", fpsDenominator);
 
-	OBSBasic *window = qobject_cast<OBSBasic*>(parent());
-	if (window)
-		window->ResetVideo();
+	main->ResetVideo();
 }
 
 void OBSBasicSettings::SaveAudioSettings()
@@ -436,10 +435,10 @@ void OBSBasicSettings::SaveAudioSettings()
 	else if (sampleRateStr == "48khz")
 		sampleRate = 48000;
 
-	config_set_uint(GetGlobalConfig(), "Audio", "SampleRate", sampleRate);
-	config_set_string(GetGlobalConfig(), "Audio", "ChannelSetup",
+	config_set_uint(main->Config(), "Audio", "SampleRate", sampleRate);
+	config_set_string(main->Config(), "Audio", "ChannelSetup",
 			channelSetup);
-	config_set_uint(GetGlobalConfig(), "Audio", "BufferingTime",
+	config_set_uint(main->Config(), "Audio", "BufferingTime",
 			bufferingTime);
 }
 
@@ -454,6 +453,7 @@ void OBSBasicSettings::SaveSettings()
 	if (videoChanged)
 		SaveVideoSettings();
 
+	config_save(main->Config());
 	config_save(GetGlobalConfig());
 }
 

obs/window-basic-settings.hpp

@@ -21,6 +21,7 @@
 #include <QDialog>
 #include <memory>
 
+class OBSBasic;
 class QAbstractButton;
 
 #include "ui_OBSBasicSettings.h"
@@ -29,6 +30,8 @@ class OBSBasicSettings : public QDialog {
 	Q_OBJECT
 
 private:
+	OBSBasic *main;
+
 	std::unique_ptr<Ui::OBSBasicSettings> ui;
 	ConfigFile localeIni;
 	bool generalChanged;

obs/window-main.hpp

@@ -2,11 +2,14 @@
 
 #include <QMainWindow>
 
+#include <util/config-file.h>
+
 class OBSMainWindow : public QMainWindow {
 	Q_OBJECT
 
 public:
 	inline OBSMainWindow(QWidget *parent) : QMainWindow(parent) {}
 
+	virtual config_t Config() const=0;
 	virtual void OBSInit()=0;
 };