Mirrored_Repos/obs-websocket
1
0
Fork 0
mirror of https://github.com/Palakis/obs-websocket.git synced 2024-08-30 18:12:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

RequestHandler: Lots of code cleanup

Browse Source
This commit is contained in:
tt2468 2021-06-22 15:24:48 -07:00
parent 5cf2b50b63
commit 33137496a7
5 changed files with 80 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/requesthandler/RequestHandler_Config.cpp
View File

@ -7,10 +7,8 @@
RequestResult RequestHandler::GetSceneCollectionList(const Request& request)
{
json responseData;
responseData["currentSceneCollectionName"] = Utils::Obs::StringHelper::GetCurrentSceneCollection();
responseData["sceneCollections"] = Utils::Obs::ListHelper::GetSceneCollectionList();
return RequestResult::Success(responseData);
}
@ -18,17 +16,16 @@ RequestResult RequestHandler::SetCurrentSceneCollection(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneCollectionName", statusCode, comment)) {
if (!request.ValidateString("sceneCollectionName", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
std::string currentSceneCollectionName = Utils::Obs::StringHelper::GetCurrentSceneCollection();
std::string sceneCollectionName = request.RequestData["sceneCollectionName"];
auto sceneCollections = Utils::Obs::ListHelper::GetSceneCollectionList();
if (std::find(sceneCollections.begin(), sceneCollections.end(), sceneCollectionName) == sceneCollections.end())
return RequestResult::Error(RequestStatus::SceneCollectionNotFound, "Your specified scene collection was not found.");
return RequestResult::Error(RequestStatus::SceneCollectionNotFound);
std::string currentSceneCollectionName = Utils::Obs::StringHelper::GetCurrentSceneCollection();
// Avoid queueing tasks if nothing will change
if (currentSceneCollectionName != sceneCollectionName) {
obs_queue_task(OBS_TASK_UI, [](void* param) {
@ -42,10 +39,8 @@ RequestResult RequestHandler::SetCurrentSceneCollection(const Request& request)
RequestResult RequestHandler::GetProfileList(const Request& request)
{
json responseData;
responseData["currentProfileName"] = Utils::Obs::StringHelper::GetCurrentProfile();
responseData["profiles"] = Utils::Obs::ListHelper::GetProfileList();
return RequestResult::Success(responseData);
}
@ -53,17 +48,16 @@ RequestResult RequestHandler::SetCurrentProfile(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("profileName", statusCode, comment)) {
if (!request.ValidateString("profileName", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
std::string currentProfileName = Utils::Obs::StringHelper::GetCurrentProfile();
std::string profileName = request.RequestData["profileName"];
auto profiles = Utils::Obs::ListHelper::GetProfileList();
if (std::find(profiles.begin(), profiles.end(), profileName) == profiles.end())
return RequestResult::Error(RequestStatus::ProfileNotFound, "Your specified profile was not found.");
return RequestResult::Error(RequestStatus::ProfileNotFound);
std::string currentProfileName = Utils::Obs::StringHelper::GetCurrentProfile();
// Avoid queueing tasks if nothing will change
if (currentProfileName != profileName) {
obs_queue_task(OBS_TASK_UI, [](void* param) {
@ -78,9 +72,8 @@ RequestResult RequestHandler::GetProfileParameter(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("parameterCategory", statusCode, comment) || !request.ValidateString("parameterName", statusCode, comment)) {
if (!(request.ValidateString("parameterCategory", statusCode, comment) && request.ValidateString("parameterName", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
}
std::string parameterCategory = request.RequestData["parameterCategory"];
std::string parameterName = request.RequestData["parameterName"];
@ -88,16 +81,8 @@ RequestResult RequestHandler::GetProfileParameter(const Request& request)
config_t* profile = obs_frontend_get_profile_config();
json responseData;
if (config_has_default_value(profile, parameterCategory.c_str(), parameterName.c_str())) {
responseData["parameterValue"] =
responseData["defaultParameterValue"] = config_get_default_string(profile, parameterCategory.c_str(), parameterName.c_str());
} else {
if (config_has_user_value(profile, parameterCategory.c_str(), parameterName.c_str()))
responseData["parameterValue"] = config_get_string(profile, parameterCategory.c_str(), parameterName.c_str());
else
responseData["parameterValue"] = nullptr;
responseData["defaultParameterValue"] = nullptr;
}
responseData["parameterValue"] = config_get_string(profile, parameterCategory.c_str(), parameterName.c_str());
responseData["defaultParameterValue"] = config_get_default_string(profile, parameterCategory.c_str(), parameterName.c_str());
return RequestResult::Success(responseData);
}
@ -106,10 +91,9 @@ RequestResult RequestHandler::SetProfileParameter(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("parameterCategory", statusCode, comment) ||
!request.ValidateString("parameterName", statusCode, comment)) {
if (!(request.ValidateString("parameterCategory", statusCode, comment) &&
request.ValidateString("parameterName", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
}
std::string parameterCategory = request.RequestData["parameterCategory"];
std::string parameterName = request.RequestData["parameterName"];

55
src/requesthandler/RequestHandler_General.cpp
View File

@ -1,16 +1,15 @@
#include <QImageWriter>
#include "../obs-websocket.h"
#include "../WebSocketServer.h"
#include "RequestHandler.h"
#include "../plugin-macros.generated.h"
#include "../eventhandler/types/EventSubscription.h"
#include "../obs-websocket.h"
#include "../WebSocketServer.h"
RequestResult RequestHandler::GetVersion(const Request& request)
{
json responseData;
responseData["obsVersion"] = Utils::Obs::StringHelper::GetObsVersionString();
responseData["obsWebSocketVersion"] = OBS_WEBSOCKET_VERSION;
responseData["rpcVersion"] = OBS_WEBSOCKET_RPC_VERSION;
@ -30,15 +29,14 @@ RequestResult RequestHandler::BroadcastCustomEvent(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateObject("eventData", statusCode, comment)) {
if (!request.ValidateObject("eventData", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
auto webSocketServer = GetWebSocketServer();
if (!webSocketServer)
return RequestResult::Error(RequestStatus::RequestProcessingFailed, "Unable to send event.");
webSocketServer->BroadcastEvent((1 << 0), "CustomEvent", request.RequestData["eventData"]);
webSocketServer->BroadcastEvent(EventSubscription::General, "CustomEvent", request.RequestData["eventData"]);
return RequestResult::Success();
}
@ -46,9 +44,7 @@ RequestResult RequestHandler::BroadcastCustomEvent(const Request& request)
RequestResult RequestHandler::GetHotkeyList(const Request& request)
{
json responseData;
responseData["hotkeys"] = Utils::Obs::ListHelper::GetHotkeyNameList();
return RequestResult::Success(responseData);
}
@ -56,13 +52,12 @@ RequestResult RequestHandler::TriggerHotkeyByName(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("hotkeyName", statusCode, comment)) {
if (!request.ValidateString("hotkeyName", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
obs_hotkey_t *hotkey = Utils::Obs::SearchHelper::GetHotkeyByName(request.RequestData["hotkeyName"]);
if (!hotkey)
return RequestResult::Error(RequestStatus::HotkeyNotFound, "Unable to find a hotkey by that name.");
return RequestResult::Error(RequestStatus::HotkeyNotFound);
obs_hotkey_trigger_routed_callback(obs_hotkey_get_id(hotkey), true);
@ -75,27 +70,31 @@ RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request& request)
RequestStatus::RequestStatus statusCode = RequestStatus::NoError;
std::string comment;
if (request.ValidateString("keyId", statusCode, comment)) {
if (request.RequestData.contains("keyId") && !request.RequestData["keyId"].is_null()) {
if (!request.ValidateString("keyId", statusCode, comment))
return RequestResult::Error(statusCode, comment);
std::string keyId = request.RequestData["keyId"];
combo.key = obs_key_from_name(keyId.c_str());
} else if (statusCode != RequestStatus::MissingRequestParameter) {
return RequestResult::Error(statusCode, comment);
}
statusCode = RequestStatus::NoError;
if (request.ValidateObject("keyModifiers", statusCode, comment, true)) {
if (request.RequestData.contains("keyModifiers") && !request.RequestData["keyModifiers"].is_null()) {
if (!request.ValidateObject("keyModifiers", statusCode, comment, true))
return RequestResult::Error(statusCode, comment);
const json keyModifiersJson = request.RequestData["keyModifiers"];
uint32_t keyModifiers = 0;
if (request.RequestData["keyModifiers"].contains("shift") && request.RequestData["keyModifiers"]["shift"].is_boolean() && request.RequestData["keyModifiers"]["shift"].get<bool>())
if (keyModifiersJson.contains("shift") && keyModifiersJson["shift"].is_boolean() && keyModifiersJson["shift"].get<bool>())
keyModifiers |= INTERACT_SHIFT_KEY;
if (request.RequestData["keyModifiers"].contains("control") && request.RequestData["keyModifiers"]["control"].is_boolean() && request.RequestData["keyModifiers"]["control"].get<bool>())
if (keyModifiersJson.contains("control") && keyModifiersJson["control"].is_boolean() && keyModifiersJson["control"].get<bool>())
keyModifiers |= INTERACT_CONTROL_KEY;
if (request.RequestData["keyModifiers"].contains("alt") && request.RequestData["keyModifiers"]["alt"].is_boolean() && request.RequestData["keyModifiers"]["alt"].get<bool>())
if (keyModifiersJson.contains("alt") && keyModifiersJson["alt"].is_boolean() && keyModifiersJson["alt"].get<bool>())
keyModifiers |= INTERACT_ALT_KEY;
if (request.RequestData["keyModifiers"].contains("command") && request.RequestData["keyModifiers"]["command"].is_boolean() && request.RequestData["keyModifiers"]["command"].get<bool>())
if (keyModifiersJson.contains("command") && keyModifiersJson["command"].is_boolean() && keyModifiersJson["command"].get<bool>())
keyModifiers |= INTERACT_COMMAND_KEY;
combo.modifiers = keyModifiers;
} else if (statusCode != RequestStatus::MissingRequestParameter) {
return RequestResult::Error(statusCode, comment);
}
if (!combo.modifiers && (combo.key == OBS_KEY_NONE || combo.key >= OBS_KEY_LAST_VALUE))
@ -112,9 +111,7 @@ RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request& request)
RequestResult RequestHandler::GetStudioModeEnabled(const Request& request)
{
json responseData;
responseData["studioModeEnabled"] = obs_frontend_preview_program_mode_active();
return RequestResult::Success(responseData);
}
@ -122,17 +119,16 @@ RequestResult RequestHandler::SetStudioModeEnabled(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateBoolean("studioModeEnabled", statusCode, comment)) {
if (!request.ValidateBoolean("studioModeEnabled", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
// Avoid queueing tasks if nothing will change
if (obs_frontend_preview_program_mode_active() != request.RequestData["studioModeEnabled"]) {
// (Bad) Create a boolean on the stack, then free it after the task is completed. Requires `wait` in obs_queue_task() to be true
// (Bad) Create a boolean then pass it as a reference to the task. Requires `wait` in obs_queue_task() to be true, else undefined behavior
bool studioModeEnabled = request.RequestData["studioModeEnabled"];
// Queue the task inside of the UI thread to prevent race conditions
obs_queue_task(OBS_TASK_UI, [](void* param) {
bool *studioModeEnabled = (bool*)param;
auto studioModeEnabled = (bool*)param;
obs_frontend_set_preview_program_mode(*studioModeEnabled);
}, &studioModeEnabled, true);
}
@ -144,9 +140,8 @@ RequestResult RequestHandler::Sleep(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateNumber("sleepMillis", statusCode, comment, 0, 50000)) {
if (!request.ValidateNumber("sleepMillis", statusCode, comment, 0, 50000))
return RequestResult::Error(statusCode, comment);
}
int64_t sleepMillis = request.RequestData["sleepMillis"];
std::this_thread::sleep_for(std::chrono::milliseconds(sleepMillis));

30
src/requesthandler/RequestHandler_Inputs.cpp
View File

@ -9,9 +9,8 @@ RequestResult RequestHandler::GetInputList(const Request& request)
if (request.RequestData.contains("inputKind") && !request.RequestData["inputKind"].is_null()) {
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("inputKind", statusCode, comment)) {
if (!request.ValidateString("inputKind", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
inputKind = request.RequestData["inputKind"];
}
@ -28,9 +27,8 @@ RequestResult RequestHandler::GetInputKindList(const Request& request)
if (request.RequestData.contains("unversioned") && !request.RequestData["unversioned"].is_null()) {
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateBoolean("unversioned", statusCode, comment)) {
if (!request.ValidateBoolean("unversioned", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
unversioned = request.RequestData["unversioned"];
}
@ -79,14 +77,13 @@ RequestResult RequestHandler::SetInputSettings(const Request& request)
RequestStatus::RequestStatus statusCode;
std::string comment;
OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
if (!input || !request.ValidateObject("inputSettings", statusCode, comment, true))
if (!(input && request.ValidateObject("inputSettings", statusCode, comment, true)))
return RequestResult::Error(statusCode, comment);
bool overlay = true;
if (request.RequestData.contains("overlay") && !request.RequestData["overlay"].is_null()) {
if (!request.ValidateBoolean("overlay", statusCode, comment)) {
if (!request.ValidateBoolean("overlay", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
overlay = request.RequestData["overlay"];
}
@ -128,7 +125,7 @@ RequestResult RequestHandler::SetInputMute(const Request& request)
RequestStatus::RequestStatus statusCode;
std::string comment;
OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
if (!input || !request.ValidateBoolean("inputMuted", statusCode, comment))
if (!(input && request.ValidateBoolean("inputMuted", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
obs_source_set_muted(input, request.RequestData["inputMuted"]);
@ -209,7 +206,7 @@ RequestResult RequestHandler::SetInputName(const Request& request)
RequestStatus::RequestStatus statusCode;
std::string comment;
OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
if (!input || !request.ValidateString("newInputName", statusCode, comment))
if (!(input && request.ValidateString("newInputName", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
std::string newInputName = request.RequestData["newInputName"];
@ -225,30 +222,25 @@ RequestResult RequestHandler::SetInputName(const Request& request)
RequestResult RequestHandler::CreateInput(const Request& request)
{
// Initial validation
RequestStatus::RequestStatus statusCode;
std::string comment;
OBSSourceAutoRelease sceneSource = request.ValidateScene("sceneName", statusCode, comment);
if (!request.ValidateString("inputName", statusCode, comment) ||
!request.ValidateString("inputKind", statusCode, comment) ||
!sceneSource)
{
if (!(request.ValidateString("inputName", statusCode, comment) &&
request.ValidateString("inputKind", statusCode, comment) &&
sceneSource))
return RequestResult::Error(statusCode, comment);
}
// Verify that no other inputs share the name
std::string inputName = request.RequestData["inputName"];
OBSSourceAutoRelease existingInput = obs_get_source_by_name(inputName.c_str());
if (existingInput)
return RequestResult::Error(RequestStatus::SourceAlreadyExists, "A source already exists by that input name.");
// Verify that the input kind is valid
std::string inputKind = request.RequestData["inputKind"];
auto kinds = Utils::Obs::ListHelper::GetInputKindList();
if (std::find(kinds.begin(), kinds.end(), inputKind) == kinds.end())
return RequestResult::Error(RequestStatus::InvalidInputKind, "Your specified input kind is not supported by OBS. Check that your specified kind is properly versioned and that any necessary plugins are loaded.");
// Get input settings if they exist
OBSDataAutoRelease inputSettings = nullptr;
if (request.RequestData.contains("inputSettings") && !request.RequestData["inputSettings"].is_null()) {
if (!request.ValidateObject("inputSettings", statusCode, comment, true))
@ -257,10 +249,8 @@ RequestResult RequestHandler::CreateInput(const Request& request)
inputSettings = Utils::Json::JsonToObsData(request.RequestData["inputSettings"]);
}
// Get the destination scene
OBSScene scene = obs_scene_from_source(sceneSource);
// Get scene item enable state if it exists
bool sceneItemEnabled = true;
if (request.RequestData.contains("sceneItemEnabled") && !request.RequestData["sceneItemEnabled"].is_null()) {
if (!request.ValidateBoolean("sceneItemEnabled", statusCode, comment))

73
src/requesthandler/RequestHandler_Scenes.cpp
View File

@ -9,7 +9,6 @@ RequestResult RequestHandler::GetSceneList(const Request& request)
OBSSourceAutoRelease currentProgramScene = obs_frontend_get_current_scene();
responseData["currentProgramSceneName"] = obs_source_get_name(currentProgramScene);
OBSSourceAutoRelease currentPreviewScene = obs_frontend_get_current_preview_scene();
if (currentPreviewScene)
responseData["currentPreviewSceneName"] = obs_source_get_name(currentPreviewScene);
@ -24,10 +23,8 @@ RequestResult RequestHandler::GetSceneList(const Request& request)
RequestResult RequestHandler::GetCurrentProgramScene(const Request& request)
{
json responseData;
OBSSourceAutoRelease currentProgramScene = obs_frontend_get_current_scene();
responseData["currentProgramSceneName"] = obs_source_get_name(currentProgramScene);
return RequestResult::Success(responseData);
}
@ -35,18 +32,9 @@ RequestResult RequestHandler::SetCurrentProgramScene(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneName", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string sceneName = request.RequestData["sceneName"];
OBSSourceAutoRelease scene = obs_get_source_by_name(sceneName.c_str());
OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
if (!scene)
return RequestResult::Error(RequestStatus::SceneNotFound);
if (obs_source_get_type(scene) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not a scene.");
return RequestResult::Error(statusCode, comment);
obs_frontend_set_current_scene(scene);
@ -55,17 +43,13 @@ RequestResult RequestHandler::SetCurrentProgramScene(const Request& request)
RequestResult RequestHandler::GetCurrentPreviewScene(const Request& request)
{
json responseData;
if (!obs_frontend_preview_program_mode_active())
return RequestResult::Error(RequestStatus::StudioModeNotActive);
OBSSourceAutoRelease currentPreviewScene = obs_frontend_get_current_preview_scene();
if (currentPreviewScene) {
responseData["currentPreviewSceneName"] = obs_source_get_name(currentPreviewScene);
} else if (request.IgnoreNonFatalRequestChecks) {
responseData["currentPreviewSceneName"] = nullptr;
} else {
return RequestResult::Error(RequestStatus::StudioModeNotActive);
}
json responseData;
responseData["currentPreviewSceneName"] = obs_source_get_name(currentPreviewScene);
return RequestResult::Success(responseData);
}
@ -76,18 +60,9 @@ RequestResult RequestHandler::SetCurrentPreviewScene(const Request& request)
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneName", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string sceneName = request.RequestData["sceneName"];
OBSSourceAutoRelease scene = obs_get_source_by_name(sceneName.c_str());
OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
if (!scene)
return RequestResult::Error(RequestStatus::SceneNotFound);
if (obs_source_get_type(scene) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not a scene.");
return RequestResult::Error(statusCode, comment);
obs_frontend_set_current_preview_scene(scene);
@ -98,24 +73,12 @@ RequestResult RequestHandler::SetSceneName(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneName", statusCode, comment)) {
OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
if (!(scene && request.ValidateString("newSceneName", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
}
if (!request.ValidateString("newSceneName", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string sceneName = request.RequestData["sceneName"];
std::string newSceneName = request.RequestData["newSceneName"];
OBSSourceAutoRelease scene = obs_get_source_by_name(sceneName.c_str());
if (!scene)
return RequestResult::Error(RequestStatus::SceneNotFound);
if (obs_source_get_type(scene) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not a scene.");
OBSSourceAutoRelease existingSource = obs_get_source_by_name(newSceneName.c_str());
if (existingSource)
return RequestResult::Error(RequestStatus::SourceAlreadyExists, "A source already exists by that new scene name.");
@ -129,9 +92,8 @@ RequestResult RequestHandler::CreateScene(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneName", statusCode, comment)) {
if (!request.ValidateString("sceneName", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
std::string sceneName = request.RequestData["sceneName"];
@ -149,18 +111,9 @@ RequestResult RequestHandler::RemoveScene(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sceneName", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string sceneName = request.RequestData["sceneName"];
OBSSourceAutoRelease scene = obs_get_source_by_name(sceneName.c_str());
OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
if (!scene)
return RequestResult::Error(RequestStatus::SceneNotFound);
if (obs_source_get_type(scene) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not a scene.");
return RequestResult::Error(statusCode, comment);
obs_source_remove(scene);

61
src/requesthandler/RequestHandler_Sources.cpp
View File

@ -95,9 +95,8 @@ RequestResult RequestHandler::GetSourceActive(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sourceName", statusCode, comment)) {
if (!request.ValidateString("sourceName", statusCode, comment))
return RequestResult::Error(statusCode, comment);
}
std::string sourceName = request.RequestData["sourceName"];
@ -118,9 +117,8 @@ RequestResult RequestHandler::GetSourceScreenshot(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sourceName", statusCode, comment)) {
if (!(request.ValidateString("sourceName", statusCode, comment) && request.ValidateString("imageFormat", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
}
std::string sourceName = request.RequestData["sourceName"];
@ -131,30 +129,32 @@ RequestResult RequestHandler::GetSourceScreenshot(const Request& request)
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT && obs_source_get_type(source) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not an input or a scene.");
std::string imageFormat = request.RequestData["imageFormat"];
if (!IsImageFormatValid(imageFormat))
return RequestResult::Error(RequestStatus::InvalidRequestParameter, "Your specified image format is invalid or not supported by this system.");
uint32_t requestedWidth{0};
uint32_t requestedHeight{0};
int compressionQuality{-1};
if (request.RequestData.contains("imageWidth") && !request.RequestData["imageWidth"].is_null()) {
if (!request.ValidateNumber("imageWidth", statusCode, comment, 8, 4096)) {
if (!request.ValidateNumber("imageWidth", statusCode, comment, 8, 4096))
return RequestResult::Error(statusCode, comment);
}
requestedWidth = request.RequestData["imageWidth"];
}
if (request.RequestData.contains("imageHeight") && !request.RequestData["imageHeight"].is_null()) {
if (!request.ValidateNumber("imageHeight", statusCode, comment, 8, 4096)) {
if (!request.ValidateNumber("imageHeight", statusCode, comment, 8, 4096))
return RequestResult::Error(statusCode, comment);
}
requestedHeight = request.RequestData["imageHeight"];
}
if (request.RequestData.contains("imageCompressionQuality") && !request.RequestData["imageCompressionQuality"].is_null()) {
if (!request.ValidateNumber("imageCompressionQuality", statusCode, comment, -1, 100)) {
if (!request.ValidateNumber("imageCompressionQuality", statusCode, comment, -1, 100))
return RequestResult::Error(statusCode, comment);
}
compressionQuality = request.RequestData["imageCompressionQuality"];
}
@ -165,21 +165,13 @@ RequestResult RequestHandler::GetSourceScreenshot(const Request& request)
if (!success)
return RequestResult::Error(RequestStatus::ScreenshotRenderFailed);
if (!request.ValidateString("imageFormat", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string imageFormat = request.RequestData["imageFormat"];
if (!IsImageFormatValid(imageFormat))
return RequestResult::Error(RequestStatus::InvalidRequestParameter, "Your specified image format is invalid or not supported by this system.");
QByteArray encodedImgBytes;
QBuffer buffer(&encodedImgBytes);
buffer.open(QBuffer::WriteOnly);
if (!renderedImage.save(&buffer, imageFormat.c_str(), compressionQuality))
return RequestResult::Error(RequestStatus::ScreenshotEncodeFailed);
buffer.close();
QString encodedPicture = QString("data:image/%1;base64,").arg(imageFormat.c_str()).append(encodedImgBytes.toBase64());
@ -193,16 +185,10 @@ RequestResult RequestHandler::SaveSourceScreenshot(const Request& request)
{
RequestStatus::RequestStatus statusCode;
std::string comment;
if (!request.ValidateString("sourceName", statusCode, comment)) {
if (!(request.ValidateString("sourceName", statusCode, comment) && request.ValidateString("imageFilePath", statusCode, comment) && request.ValidateString("imageFormat", statusCode, comment)))
return RequestResult::Error(statusCode, comment);
}
if (!request.ValidateString("imageFilePath", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string sourceName = request.RequestData["sourceName"];
std::string imageFilePath = request.RequestData["imageFilePath"];
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.c_str());
if (!source)
@ -211,30 +197,32 @@ RequestResult RequestHandler::SaveSourceScreenshot(const Request& request)
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT && obs_source_get_type(source) != OBS_SOURCE_TYPE_SCENE)
return RequestResult::Error(RequestStatus::InvalidSourceType, "The specified source is not an input or a scene.");
std::string imageFormat = request.RequestData["imageFormat"];
if (!IsImageFormatValid(imageFormat))
return RequestResult::Error(RequestStatus::InvalidRequestParameter, "Your specified image format is invalid or not supported by this system.");
uint32_t requestedWidth{0};
uint32_t requestedHeight{0};
int compressionQuality{-1};
if (request.RequestData.contains("imageWidth") && !request.RequestData["imageWidth"].is_null()) {
if (!request.ValidateNumber("imageWidth", statusCode, comment, 8, 4096)) {
if (!request.ValidateNumber("imageWidth", statusCode, comment, 8, 4096))
return RequestResult::Error(statusCode, comment);
}
requestedWidth = request.RequestData["imageWidth"];
}
if (request.RequestData.contains("imageHeight") && !request.RequestData["imageHeight"].is_null()) {
if (!request.ValidateNumber("imageHeight", statusCode, comment, 8, 4096)) {
if (!request.ValidateNumber("imageHeight", statusCode, comment, 8, 4096))
return RequestResult::Error(statusCode, comment);
}
requestedHeight = request.RequestData["imageHeight"];
}
if (request.RequestData.contains("imageCompressionQuality") && !request.RequestData["imageCompressionQuality"].is_null()) {
if (!request.ValidateNumber("imageCompressionQuality", statusCode, comment, -1, 100)) {
if (!request.ValidateNumber("imageCompressionQuality", statusCode, comment, -1, 100))
return RequestResult::Error(statusCode, comment);
}
compressionQuality = request.RequestData["imageCompressionQuality"];
}
@ -245,14 +233,7 @@ RequestResult RequestHandler::SaveSourceScreenshot(const Request& request)
if (!success)
return RequestResult::Error(RequestStatus::ScreenshotRenderFailed);
if (!request.ValidateString("imageFormat", statusCode, comment)) {
return RequestResult::Error(statusCode, comment);
}
std::string imageFormat = request.RequestData["imageFormat"];
if (!IsImageFormatValid(imageFormat))
return RequestResult::Error(RequestStatus::InvalidRequestParameter, "Your specified image format is invalid or not supported by this system.");
std::string imageFilePath = request.RequestData["imageFilePath"];
QFileInfo filePathInfo(QString::fromStdString(imageFilePath));
if (!filePathInfo.absoluteDir().exists())