Merge pull request #26 from elgatosf/bugfixes/pre-1.0.0-fixes

Bugfixes/pre 1.0.0 fixes

Author: FiniteSingularity

buildspec.json

@@ -42,7 +42,7 @@
     "versionMinor": 0,
     "versionPatch": 0,
     "buildNumber": 0,
-    "releaseType": "rc9",
+    "releaseType": "rc11",
     "author": "Elgato",
     "website": "https://elgato.com",
     "email": "support@elgato.com",

data/locale/en-US.ini

@@ -15,7 +15,7 @@ MarketplaceWindow.LoginNeeded.Subtitle="First off, let's connect your Marketplac
 MarketplaceWindow.LoginError.Title="Sign in"
 MarketplaceWindow.LoginError.Subtitle="There was an issue signing you in. Please try signing in again to continue."
 MarketplaceWindow.LoggingIn.Title="Signing you in"
-MarketplaceWindow.LoggingIn.Subtitle="Please sign in using the browser window that should have appeared. If no browser window appeared, or you accidentally closed it, click below to try again."
+MarketplaceWindow.LoggingIn.Subtitle="Use the new browser window to sign into your account, or select Try again to reopen"
 MarketplaceWindow.LoggingIn.TryAgain="Try again"
 MarketplaceWindow.ConnectionError.Title="Connection error"
 MarketplaceWindow.ConnectionError.Subtitle="Could not connect to the server. (please check your network connection)"

data/plugins.json

@@ -25,7 +25,7 @@
             "name": "obs-shaderfilter",
             "url": "https://obsproject.com/forum/resources/obs-shaderfilter.1736/",
             "files" :[
-                "obs-shaderfilter"
+                "obs-shaderfilter.dll"
             ]
         },
         {

src/elgato-cloud-config.cpp

@@ -459,6 +459,16 @@ void SimpleVolumeMeter::paintEvent(QPaintEvent *event)
 
 ElgatoCloudConfig::ElgatoCloudConfig(QWidget *parent) : QDialog(parent)
 {
+
+	// Disable all video capture sources so that single-thread
+	// capture sources, such as the Elgato Facecam, can be properly
+	// selected in the wizard.  Will re-enable any disabled sources
+	// in the wizard destructor.
+	obs_enum_sources(
+		&ElgatoCloudConfig::
+		DisableVideoCaptureSources,
+		this);
+
 	configWindow = this;
 	std::string imageBaseDir = GetDataPath();
 	imageBaseDir += "/images/";
@@ -603,6 +613,50 @@ ElgatoCloudConfig::ElgatoCloudConfig(QWidget *parent) : QDialog(parent)
 	obs_data_release(config);
 }
 
+bool ElgatoCloudConfig::DisableVideoCaptureSources(void* data,
+	obs_source_t* source)
+{
+	auto config = static_cast<ElgatoCloudConfig*>(data);
+	std::string sourceType = obs_source_get_id(source);
+	if (sourceType == "dshow_input") {
+		auto settings = obs_source_get_settings(source);
+		bool active = obs_data_get_bool(settings, "active");
+		obs_data_release(settings);
+		if (active) {
+			calldata_t cd = {};
+			calldata_set_bool(&cd, "active", false);
+			proc_handler_t* ph =
+				obs_source_get_proc_handler(source);
+			proc_handler_call(ph, "activate", &cd);
+			calldata_free(&cd);
+			std::string id = obs_source_get_uuid(source);
+			config->_toEnable.push_back(id);
+		}
+	}
+	return true;
+}
+
+bool ElgatoCloudConfig::EnableVideoCaptureSources(void* data,
+	obs_source_t* source)
+{
+	auto config = static_cast<ElgatoCloudConfig*>(data);
+	std::string sourceType = obs_source_get_id(source);
+	if (sourceType == "dshow_input") {
+		auto settings = obs_source_get_settings(source);
+		std::string id = obs_source_get_uuid(source);
+		obs_data_release(settings);
+		if (std::find(config->_toEnable.begin(), config->_toEnable.end(), id) != config->_toEnable.end()) {
+			calldata_t cd = {};
+			calldata_set_bool(&cd, "active", true);
+			proc_handler_t* ph =
+				obs_source_get_proc_handler(source);
+			proc_handler_call(ph, "activate", &cd);
+			calldata_free(&cd);
+		}
+	}
+	return true;
+}
+
 void ElgatoCloudConfig::OpenConfigVideoSource()
 {
 	if (!_videoCaptureSource) {
@@ -700,6 +754,19 @@ void ElgatoCloudConfig::_save()
 
 ElgatoCloudConfig::~ElgatoCloudConfig()
 {
+	if (!_videoCaptureSource) {
+		calldata_t cd = {};
+		calldata_set_bool(&cd, "active", false);
+		proc_handler_t* ph =
+			obs_source_get_proc_handler(_videoCaptureSource);
+		proc_handler_call(ph, "activate", &cd);
+		calldata_free(&cd);
+	}
+
+	obs_enum_sources(
+		&ElgatoCloudConfig::
+		EnableVideoCaptureSources,
+		this);
 	configWindow = nullptr;
 }
 

src/elgato-cloud-config.hpp

@@ -123,6 +123,11 @@ class ElgatoCloudConfig : public QDialog {
 				   const float peak[MAX_AUDIO_CHANNELS],
 				   const float inputPeak[MAX_AUDIO_CHANNELS]);
 
+	static bool DisableVideoCaptureSources(void* data,
+				   obs_source_t* source);
+	static bool EnableVideoCaptureSources(void* data,
+				   obs_source_t* source);
+
 private:
 	void _save();
 	DefaultAVWidget *_avWidget;
@@ -134,6 +139,7 @@ class ElgatoCloudConfig : public QDialog {
 	OBSQTDisplay *_videoPreview = nullptr;
 	QCheckBox *_makerCheckbox = nullptr;
 	QLabel* _makerRestartMsg = nullptr;
+	std::vector<std::string> _toEnable;
 	std::string _installDirectory;
 
 signals:

src/elgato-cloud-data.cpp

@@ -498,8 +498,17 @@ void ElgatoCloud::_LoadUserData(bool loadData)
 
 void ElgatoCloud::_SaveState()
 {
-	obs_data_set_string(_config, "AccessToken", _accessToken.c_str());
-	obs_data_set_string(_config, "RefreshToken", _refreshToken.c_str());
+	std::string accessTokenEncrypted = "";
+	std::string refreshTokenEncrypted = "";
+	if (_accessToken != "") {
+		accessTokenEncrypted = encryptString(_accessToken);
+	}
+	if (_refreshToken != "") {
+		refreshTokenEncrypted = encryptString(_refreshToken);
+	}
+
+	obs_data_set_string(_config, "AccessToken", accessTokenEncrypted.c_str());
+	obs_data_set_string(_config, "RefreshToken", refreshTokenEncrypted.c_str());
 	obs_data_set_int(_config, "AccessTokenExpiration",
 			 _accessTokenExpiration);
 	obs_data_set_int(_config, "RefreshTokenExpiration",
@@ -510,14 +519,25 @@ void ElgatoCloud::_SaveState()
 
 void ElgatoCloud::_GetSavedState()
 {
-	_accessToken = obs_data_get_string(_config, "AccessToken");
-	_refreshToken = obs_data_get_string(_config, "RefreshToken");
+	std::string accessTokenEncrypted = obs_data_get_string(_config, "AccessToken");
+	std::string refreshTokenEncrypted = obs_data_get_string(_config, "RefreshToken");
+	if (accessTokenEncrypted.size() > 25) {
+		_accessToken = decryptString(accessTokenEncrypted);
+	} else {
+		_accessToken = "";
+	}
+
+	if (refreshTokenEncrypted.size() > 25) {
+		_refreshToken = decryptString(refreshTokenEncrypted);
+	} else {
+		_refreshToken = "";
+	}
+
 	_accessTokenExpiration =
 		obs_data_get_int(_config, "AccessTokenExpiration");
 	_refreshTokenExpiration =
 		obs_data_get_int(_config, "RefreshTokenExpiration");
 	_skipUpdate = obs_data_get_string(_config, "SkipUpdate");
-	_skipUpdate = "";
 }
 
 } // namespace elgatocloud

src/elgato-cloud-window.cpp

@@ -176,7 +176,7 @@ DownloadButton::DownloadButton(QWidget *parent) : QWidget(parent)
 	std::string downloadIconPath = imageBaseDir + "download.svg";
 	std::string downloadIconHoverPath = imageBaseDir + "download_hover.svg";
 	std::string downloadIconDisabledPath =
-		imageBaseDir + "download_hover.svg";
+		imageBaseDir + "download_disabled.svg";
 	QString buttonStyle = EIconHoverDisabledButtonStyle;
 	buttonStyle.replace("${img}", downloadIconPath.c_str());
 	buttonStyle.replace("${hover-img}", downloadIconHoverPath.c_str());

src/scene-bundle.cpp

@@ -86,6 +86,11 @@ bool SceneBundle::FromCollection(std::string collection_name)
 	for (auto &source : _collection["sources"]) {
 		_ProcessJsonObj(source);
 	}
+	if (_collection.contains("groups")) {
+		for (auto& group : _collection["groups"]) {
+			_ProcessJsonObj(group);
+		}
+	}
 	for (auto &transition : _collection["transitions"]) {
 		_ProcessJsonObj(transition);
 	}

src/util.cpp

@@ -39,6 +39,11 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "platform.h"
 #include "util.h"
 
+#pragma comment(lib, "crypt32.lib")
+#include <Windows.h>
+#include <Wincrypt.h>
+#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
+
 obs_data_t *get_module_config()
 {
 	const auto confPath = obs_module_config_path("config.json");
@@ -516,4 +521,116 @@ std::string releaseType()
 		c = tolower(c);
 	}
 	return rt == "release" ? "" : " " + rt;
-}
+}
+
+std::string binaryToString(const BYTE* binaryData, DWORD dataLen, DWORD flags = CRYPT_STRING_BASE64) {
+	DWORD stringLen = 0;
+	// Get the required string length, not including the null terminator.
+	if (!CryptBinaryToStringA(binaryData, dataLen, flags, nullptr, &stringLen)) {
+		obs_log(LOG_ERROR, "Could not convert binary data to string.");
+		return "";
+	}
+
+	// Allocate memory for the string, including the null terminator.
+	std::string encodedString;
+	encodedString.resize(stringLen);
+
+	// Perform the actual conversion.
+	if (!CryptBinaryToStringA(binaryData, dataLen, flags, encodedString.data(), &stringLen)) {
+		obs_log(LOG_ERROR, "Could not convert binary data to string.");
+		return "";
+	}
+	return encodedString;
+}
+
+DATA_BLOB stringToBinary(const std::string& input, DWORD flags = CRYPT_STRING_BASE64) {
+	DWORD binarySize = 0;
+	DATA_BLOB output;
+	output.pbData = nullptr;
+	output.cbData = 0;
+	// Get the required size for the binary data
+	if (!CryptStringToBinaryA(input.c_str(), (DWORD)input.length(), flags, nullptr, &binarySize, nullptr, nullptr)) {
+		obs_log(LOG_INFO, "Could not string to binary. Could not determine needed binary data size.");
+		return output;
+	}
+
+	// Allocate memory for the binary data
+	output.pbData = (BYTE*)LocalAlloc(LMEM_FIXED, binarySize);
+	if (output.pbData == nullptr) {
+		obs_log(LOG_INFO, "Could not convert string to binary. Memory allocation error.");
+		return output;
+	}
+	output.cbData = binarySize;
+	// Perform the actual conversion
+	if (!CryptStringToBinaryA(input.c_str(), (DWORD)input.length(), flags, output.pbData, &binarySize, nullptr, nullptr)) {
+		obs_log(LOG_INFO, "Could not string to binary. Invalid conversion.");
+		return output;
+	}
+	return output;
+}
+
+// Encrypts a string, and returns string of encrypted binary data
+// as a formatted BASE 64 encoded string.
+std::string encryptString(std::string input)
+{
+	DATA_BLOB DataIn;
+	DATA_BLOB DataOut;
+	BYTE* pbDataInput = (BYTE*)input.c_str();
+	DWORD cbDataInput = DWORD(strlen((char*)pbDataInput) + 1);
+	DataIn.pbData = pbDataInput;
+	DataIn.cbData = cbDataInput;
+	std::string encrypted = "";
+	if (CryptProtectData(
+		&DataIn,
+		L"",
+		NULL,
+		NULL,
+		NULL,
+		0,
+		&DataOut))
+	{
+		//convert binary to formatted base 64 encoded string.
+		encrypted = binaryToString(DataOut.pbData, DataOut.cbData);
+		LocalFree(DataOut.pbData);
+	} else {
+		obs_log(LOG_ERROR, "Could not encrypt string.");
+	}
+	return encrypted;
+}
+
+// Decrypts a formatted base64 encoded string.  First
+// converts string to binary blob, then uses windows
+// cryto API to decrypt the binary blob into a usable
+// string
+std::string decryptString(std::string input)
+{
+	DATA_BLOB ToDecrypt = stringToBinary(input);
+	if (ToDecrypt.pbData == nullptr) {
+		return "";
+	}
+	DATA_BLOB DataVerify;
+	LPWSTR pDescrOut = NULL;
+
+	std::string decrypted = "";
+
+	if (CryptUnprotectData(
+		&ToDecrypt,
+		&pDescrOut,
+		NULL,
+		NULL,
+		NULL,
+		0,
+		&DataVerify))
+	{
+		decrypted = std::string(reinterpret_cast<char*>(DataVerify.pbData), DataVerify.cbData);
+		LocalFree(DataVerify.pbData);
+		LocalFree(pDescrOut);
+		if (ToDecrypt.pbData != nullptr) {
+			LocalFree(ToDecrypt.pbData);
+		}
+	} else {
+		obs_log(LOG_ERROR, "Could not decrypt string.");
+	}
+	return decrypted;
+}
+

src/util.h

@@ -84,4 +84,7 @@ template<class T, class U> auto_closer<T, U> auto_close(T *self, U closer)
 bool generate_safe_path(std::string unsafe, std::string &safe);
 std::string versionNoBuild();
 std::string buildNumber();
-std::string releaseType();
+std::string releaseType();
+
+std::string encryptString(std::string input);
+std::string decryptString(std::string input);