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

General: code style refresh

Browse Source
This commit is contained in:
Palakis
2017-06-06 09:30:07 +02:00
parent 781eaec683
commit f49980350a
10 changed files with 308 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
Utils.cpp
View File

@ -30,14 +30,14 @@ obs_data_array_t* string_list_to_array(char** strings, char* key)
if (!strings) if (!strings)
return obs_data_array_create(); return obs_data_array_create();
obs_data_array_t *list = obs_data_array_create(); obs_data_array_t* list = obs_data_array_create();
char* value = ""; char* value = "";
for (int i = 0; value != nullptr; i++) for (int i = 0; value != nullptr; i++)
{ {
value = strings[i]; value = strings[i];
obs_data_t *item = obs_data_create(); obs_data_t* item = obs_data_create();
obs_data_set_string(item, key, value); obs_data_set_string(item, key, value);
if (value) if (value)
@ -49,17 +49,19 @@ obs_data_array_t* string_list_to_array(char** strings, char* key)
return list; return list;
} }
obs_data_array_t* Utils::GetSceneItems(obs_source_t *source) { obs_data_array_t* Utils::GetSceneItems(obs_source_t* source)
obs_data_array_t *items = obs_data_array_create(); {
obs_scene_t *scene = obs_scene_from_source(source); obs_data_array_t* items = obs_data_array_create();
if (scene == NULL) { obs_scene_t* scene = obs_scene_from_source(source);
return NULL;
}
obs_scene_enum_items(scene, [](obs_scene_t *scene, obs_sceneitem_t *currentItem, void *param) { if (!scene)
obs_data_array_t *data = static_cast<obs_data_array_t *>(param); return nullptr;
obs_data_t *item_data = GetSceneItemData(currentItem); obs_scene_enum_items(scene, [](obs_scene_t* scene, obs_sceneitem_t* currentItem, void* param)
{
obs_data_array_t* data = static_cast<obs_data_array_t* >(param);
obs_data_t* item_data = GetSceneItemData(currentItem);
obs_data_array_insert(data, 0, item_data); obs_data_array_insert(data, 0, item_data);
obs_data_release(item_data); obs_data_release(item_data);
@ -69,10 +71,10 @@ obs_data_array_t* Utils::GetSceneItems(obs_source_t *source) {
return items; return items;
} }
obs_data_t* Utils::GetSceneItemData(obs_sceneitem_t *item) { obs_data_t* Utils::GetSceneItemData(obs_sceneitem_t* item)
if (!item) { {
return NULL; if (!item)
} return nullptr;
vec2 pos; vec2 pos;
obs_sceneitem_get_pos(item, &pos); obs_sceneitem_get_pos(item, &pos);
@ -84,7 +86,7 @@ obs_data_t* Utils::GetSceneItemData(obs_sceneitem_t *item) {
float item_width = float(obs_source_get_width(item_source)); float item_width = float(obs_source_get_width(item_source));
float item_height = float(obs_source_get_height(item_source)); float item_height = float(obs_source_get_height(item_source));
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_string(data, "name", obs_data_set_string(data, "name",
obs_source_get_name(obs_sceneitem_get_source(item))); obs_source_get_name(obs_sceneitem_get_source(item)));
obs_data_set_string(data, "type", obs_data_set_string(data, "type",
@ -95,14 +97,15 @@ obs_data_t* Utils::GetSceneItemData(obs_sceneitem_t *item) {
obs_data_set_double(data, "y", pos.y); obs_data_set_double(data, "y", pos.y);
obs_data_set_int(data, "source_cx", (int)item_width); obs_data_set_int(data, "source_cx", (int)item_width);
obs_data_set_int(data, "source_cy", (int)item_height); obs_data_set_int(data, "source_cy", (int)item_height);
obs_data_set_double(data, "cx", item_width * scale.x); obs_data_set_double(data, "cx", item_width* scale.x);
obs_data_set_double(data, "cy", item_height * scale.y); obs_data_set_double(data, "cy", item_height* scale.y);
obs_data_set_bool(data, "render", obs_sceneitem_visible(item)); obs_data_set_bool(data, "render", obs_sceneitem_visible(item));
return data; return data;
} }
obs_sceneitem_t* Utils::GetSceneItemFromName(obs_source_t* source, const char* name) { obs_sceneitem_t* Utils::GetSceneItemFromName(obs_source_t* source, const char* name)
{
struct current_search { struct current_search {
const char* query; const char* query;
obs_sceneitem_t* result; obs_sceneitem_t* result;
@ -110,20 +113,21 @@ obs_sceneitem_t* Utils::GetSceneItemFromName(obs_source_t* source, const char* n
current_search search; current_search search;
search.query = name; search.query = name;
search.result = NULL; search.result = nullptr;
obs_scene_t *scene = obs_scene_from_source(source); obs_scene_t* scene = obs_scene_from_source(source);
if (scene == NULL) { if (scene == nullptr)
return NULL; return nullptr;
}
obs_scene_enum_items(scene, [](obs_scene_t* scene, obs_sceneitem_t* currentItem, void* param)
{
current_search* search = static_cast<current_search* >(param);
obs_scene_enum_items(scene, [](obs_scene_t *scene, obs_sceneitem_t *currentItem, void *param) {
current_search *search = static_cast<current_search *>(param);
const char* currentItemName = const char* currentItemName =
obs_source_get_name(obs_sceneitem_get_source(currentItem)); obs_source_get_name(obs_sceneitem_get_source(currentItem));
if (strcmp(currentItemName, search->query) == 0) { if (strcmp(currentItemName, search->query) == 0)
{
search->result = currentItem; search->result = currentItem;
obs_sceneitem_addref(search->result); obs_sceneitem_addref(search->result);
return false; return false;
@ -135,17 +139,20 @@ obs_sceneitem_t* Utils::GetSceneItemFromName(obs_source_t* source, const char* n
return search.result; return search.result;
} }
obs_source_t* Utils::GetTransitionFromName(const char *search_name) { obs_source_t* Utils::GetTransitionFromName(const char* search_name)
obs_source_t *found_transition = NULL; {
obs_source_t* found_transition = NULL;
obs_frontend_source_list transition_list = {}; obs_frontend_source_list transition_list = {};
obs_frontend_get_transitions(&transition_list); obs_frontend_get_transitions(&transition_list);
for (size_t i = 0; i < transition_list.sources.num; i++) { for (size_t i = 0; i < transition_list.sources.num; i++)
obs_source_t *transition = transition_list.sources.array[i]; {
obs_source_t* transition = transition_list.sources.array[i];
const char *transition_name = obs_source_get_name(transition); const char* transition_name = obs_source_get_name(transition);
if (strcmp(transition_name, search_name) == 0) { if (strcmp(transition_name, search_name) == 0)
{
found_transition = transition; found_transition = transition;
obs_source_addref(found_transition); obs_source_addref(found_transition);
break; break;
@ -157,44 +164,47 @@ obs_source_t* Utils::GetTransitionFromName(const char *search_name) {
return found_transition; return found_transition;
} }
obs_source_t* Utils::GetSceneFromNameOrCurrent(const char *scene_name) { obs_source_t* Utils::GetSceneFromNameOrCurrent(const char* scene_name)
obs_source_t* scene; {
if (!scene_name || !strlen(scene_name)) { obs_source_t* scene = nullptr;
if (!scene_name || !strlen(scene_name))
scene = obs_frontend_get_current_scene(); scene = obs_frontend_get_current_scene();
} else
else {
scene = obs_get_source_by_name(scene_name); scene = obs_get_source_by_name(scene_name);
}
return scene; return scene;
} }
obs_data_array_t* Utils::GetScenes() { obs_data_array_t* Utils::GetScenes()
{
obs_frontend_source_list sceneList = {}; obs_frontend_source_list sceneList = {};
obs_frontend_get_scenes(&sceneList); obs_frontend_get_scenes(&sceneList);
obs_data_array_t* scenes = obs_data_array_create(); obs_data_array_t* scenes = obs_data_array_create();
for (size_t i = 0; i < sceneList.sources.num; i++) { for (size_t i = 0; i < sceneList.sources.num; i++)
obs_source_t *scene = sceneList.sources.array[i]; {
obs_source_t* scene = sceneList.sources.array[i];
obs_data_t *scene_data = GetSceneData(scene);
obs_data_t* scene_data = GetSceneData(scene);
obs_data_array_push_back(scenes, scene_data); obs_data_array_push_back(scenes, scene_data);
obs_data_release(scene_data); obs_data_release(scene_data);
} }
obs_frontend_source_list_free(&sceneList); obs_frontend_source_list_free(&sceneList);
return scenes; return scenes;
} }
obs_data_t* Utils::GetSceneData(obs_source *source) { obs_data_t* Utils::GetSceneData(obs_source* source)
obs_data_array_t *scene_items = GetSceneItems(source); {
obs_data_array_t* scene_items = GetSceneItems(source);
obs_data_t* sceneData = obs_data_create(); obs_data_t* sceneData = obs_data_create();
obs_data_set_string(sceneData, "name", obs_source_get_name(source)); obs_data_set_string(sceneData, "name", obs_source_get_name(source));
obs_data_set_array(sceneData, "sources", scene_items); obs_data_set_array(sceneData, "sources", scene_items);
obs_data_array_release(scene_items); obs_data_array_release(scene_items);
return sceneData; return sceneData;
} }
@ -202,7 +212,7 @@ obs_data_t* Utils::GetSceneData(obs_source *source) {
obs_data_array_t* Utils::GetSceneCollections() obs_data_array_t* Utils::GetSceneCollections()
{ {
char** scene_collections = obs_frontend_get_scene_collections(); char** scene_collections = obs_frontend_get_scene_collections();
obs_data_array_t *list = string_list_to_array(scene_collections, "sc-name"); obs_data_array_t* list = string_list_to_array(scene_collections, "sc-name");
bfree(scene_collections); bfree(scene_collections);
return list; return list;
@ -211,7 +221,7 @@ obs_data_array_t* Utils::GetSceneCollections()
obs_data_array_t* Utils::GetProfiles() obs_data_array_t* Utils::GetProfiles()
{ {
char** profiles = obs_frontend_get_profiles(); char** profiles = obs_frontend_get_profiles();
obs_data_array_t *list = string_list_to_array(profiles, "profile-name"); obs_data_array_t* list = string_list_to_array(profiles, "profile-name");
bfree(profiles); bfree(profiles);
return list; return list;
@ -219,7 +229,7 @@ obs_data_array_t* Utils::GetProfiles()
QSpinBox* Utils::GetTransitionDurationControl() QSpinBox* Utils::GetTransitionDurationControl()
{ {
QMainWindow *window = (QMainWindow*)obs_frontend_get_main_window(); QMainWindow* window = (QMainWindow*)obs_frontend_get_main_window();
return window->findChild<QSpinBox*>("transitionDuration"); return window->findChild<QSpinBox*>("transitionDuration");
} }
@ -227,13 +237,9 @@ int Utils::GetTransitionDuration()
{ {
QSpinBox* control = GetTransitionDurationControl(); QSpinBox* control = GetTransitionDurationControl();
if (control) if (control)
{
return control->value(); return control->value();
}
else else
{
return -1; return -1;
}
} }
void Utils::SetTransitionDuration(int ms) void Utils::SetTransitionDuration(int ms)
@ -241,14 +247,12 @@ void Utils::SetTransitionDuration(int ms)
QSpinBox* control = GetTransitionDurationControl(); QSpinBox* control = GetTransitionDurationControl();
if (control && ms >= 0) if (control && ms >= 0)
{
control->setValue(ms); control->setValue(ms);
}
} }
bool Utils::SetTransitionByName(const char* transition_name) bool Utils::SetTransitionByName(const char* transition_name)
{ {
obs_source_t *transition = GetTransitionFromName(transition_name); obs_source_t* transition = GetTransitionFromName(transition_name);
if (transition) if (transition)
{ {
@ -335,7 +339,7 @@ obs_scene_t* Utils::GetPreviewScene()
obs_scene_addref(scene); obs_scene_addref(scene);
return scene; return scene;
} }
return nullptr; return nullptr;
} }
@ -344,7 +348,7 @@ bool Utils::SetPreviewScene(const char* name)
if (IsPreviewModeActive()) if (IsPreviewModeActive())
{ {
QListWidget* sceneList = GetSceneListControl(); QListWidget* sceneList = GetSceneListControl();
QList<QListWidgetItem*> matchingItems = QList<QListWidgetItem*> matchingItems =
sceneList->findItems(name, Qt::MatchExactly); sceneList->findItems(name, Qt::MatchExactly);
if (matchingItems.count() > 0) if (matchingItems.count() > 0)
@ -374,7 +378,7 @@ void Utils::TransitionToProgram()
// The program options widget is the second item in the left-to-right layout // The program options widget is the second item in the left-to-right layout
QWidget* programOptions = GetPreviewLayout()->itemAt(1)->widget(); QWidget* programOptions = GetPreviewLayout()->itemAt(1)->widget();
// The "Transition" button lies in the mainButtonLayout // The "Transition" button lies in the mainButtonLayout
// which is the first itemin the program options' layout // which is the first itemin the program options' layout
QLayout* mainButtonLayout = programOptions->layout()->itemAt(1)->layout(); QLayout* mainButtonLayout = programOptions->layout()->itemAt(1)->layout();
QWidget* transitionBtnWidget = mainButtonLayout->itemAt(0)->widget(); QWidget* transitionBtnWidget = mainButtonLayout->itemAt(0)->widget();
@ -394,7 +398,7 @@ const char* Utils::OBSVersionString() {
minor = (version >> 16) & 0xFF; minor = (version >> 16) & 0xFF;
patch = version & 0xFF; patch = version & 0xFF;
char *result = (char*)bmalloc(sizeof(char) * 12); char* result = (char*)bmalloc(sizeof(char) * 12);
sprintf(result, "%d.%d.%d", major, minor, patch); sprintf(result, "%d.%d.%d", major, minor, patch);
return result; return result;
@ -412,7 +416,6 @@ void Utils::SysTrayNotify(QString &text, QSystemTrayIcon::MessageIcon icon, QStr
return; return;
QSystemTrayIcon* trayIcon = GetTrayIcon(); QSystemTrayIcon* trayIcon = GetTrayIcon();
if (trayIcon) if (trayIcon)
trayIcon->showMessage(title, text, icon); trayIcon->showMessage(title, text, icon);
} }
@ -420,9 +423,7 @@ void Utils::SysTrayNotify(QString &text, QSystemTrayIcon::MessageIcon icon, QStr
QString Utils::FormatIPAddress(QHostAddress &addr) QString Utils::FormatIPAddress(QHostAddress &addr)
{ {
if (addr.protocol() == QAbstractSocket::IPv4Protocol) if (addr.protocol() == QAbstractSocket::IPv4Protocol)
{
QString v4addr = addr.toString().replace("::fff:", ""); QString v4addr = addr.toString().replace("::fff:", "");
}
return addr.toString(); return addr.toString();
} }

12
Utils.h
View File

@ -32,15 +32,15 @@ with this program. If not, see <https://www.gnu.org/licenses/>
class Utils class Utils
{ {
public: public:
static obs_data_array_t* GetSceneItems(obs_source_t *source); static obs_data_array_t* GetSceneItems(obs_source_t* source);
static obs_data_t* GetSceneItemData(obs_scene_item *item); static obs_data_t* GetSceneItemData(obs_scene_item* item);
static obs_sceneitem_t* GetSceneItemFromName( static obs_sceneitem_t* GetSceneItemFromName(
obs_source_t *source, const char *name); obs_source_t* source, const char* name);
static obs_source_t* GetTransitionFromName(const char *search_name); static obs_source_t* GetTransitionFromName(const char* search_name);
static obs_source_t* GetSceneFromNameOrCurrent(const char *scene_name); static obs_source_t* GetSceneFromNameOrCurrent(const char* scene_name);
static obs_data_array_t* GetScenes(); static obs_data_array_t* GetScenes();
static obs_data_t* GetSceneData(obs_source *source); static obs_data_t* GetSceneData(obs_source* source);
static obs_data_array_t* GetSceneCollections(); static obs_data_array_t* GetSceneCollections();
static obs_data_array_t* GetProfiles(); static obs_data_array_t* GetProfiles();

80
WSEvents.cpp
View File

@ -24,12 +24,12 @@ with this program. If not, see <https://www.gnu.org/licenses/>
#include "WSEvents.h" #include "WSEvents.h"
#include "obs-websocket.h" #include "obs-websocket.h"
bool transition_is_cut(obs_source_t *transition) bool transition_is_cut(obs_source_t* transition)
{ {
if (!transition) if (!transition)
return false; return false;
if (obs_source_get_type(transition) == OBS_SOURCE_TYPE_TRANSITION if (obs_source_get_type(transition) == OBS_SOURCE_TYPE_TRANSITION
&& strcmp(obs_source_get_id(transition), "cut_transition") == 0) && strcmp(obs_source_get_id(transition), "cut_transition") == 0)
{ {
return true; return true;
@ -58,17 +58,17 @@ const char* ns_to_timestamp(uint64_t ns)
WSEvents* WSEvents::Instance = nullptr; WSEvents* WSEvents::Instance = nullptr;
WSEvents::WSEvents(WSServer *srv) WSEvents::WSEvents(WSServer* srv)
{ {
_srv = srv; _srv = srv;
obs_frontend_add_event_callback(WSEvents::FrontendEventHandler, this); obs_frontend_add_event_callback(WSEvents::FrontendEventHandler, this);
QSpinBox* duration_control = Utils::GetTransitionDurationControl(); QSpinBox* duration_control = Utils::GetTransitionDurationControl();
connect(duration_control, SIGNAL(valueChanged(int)), connect(duration_control, SIGNAL(valueChanged(int)),
this, SLOT(TransitionDurationChanged(int))); this, SLOT(TransitionDurationChanged(int)));
QTimer *statusTimer = new QTimer(); QTimer* statusTimer = new QTimer();
connect(statusTimer, SIGNAL(timeout()), connect(statusTimer, SIGNAL(timeout()),
this, SLOT(StreamStatus())); this, SLOT(StreamStatus()));
statusTimer->start(2000); // equal to frontend's constant BITRATE_UPDATE_SECONDS statusTimer->start(2000); // equal to frontend's constant BITRATE_UPDATE_SECONDS
@ -107,9 +107,9 @@ void WSEvents::deferredInitOperations()
obs_source_release(scene); obs_source_release(scene);
} }
void WSEvents::FrontendEventHandler(enum obs_frontend_event event, void *private_data) void WSEvents::FrontendEventHandler(enum obs_frontend_event event, void* private_data)
{ {
WSEvents *owner = static_cast<WSEvents *>(private_data); WSEvents* owner = static_cast<WSEvents*>(private_data);
if (!owner->_srv) if (!owner->_srv)
return; return;
@ -190,11 +190,11 @@ void WSEvents::FrontendEventHandler(enum obs_frontend_event event, void *private
} }
} }
void WSEvents::broadcastUpdate(const char *updateType, obs_data_t *additionalFields = NULL) void WSEvents::broadcastUpdate(const char* updateType, obs_data_t* additionalFields = NULL)
{ {
obs_data_t *update = obs_data_create(); obs_data_t* update = obs_data_create();
obs_data_set_string(update, "update-type", updateType); obs_data_set_string(update, "update-type", updateType);
const char* ts = nullptr; const char* ts = nullptr;
if (_streaming_active) if (_streaming_active)
{ {
@ -209,10 +209,9 @@ void WSEvents::broadcastUpdate(const char *updateType, obs_data_t *additionalFie
obs_data_set_string(update, "rec-timecode", ts); obs_data_set_string(update, "rec-timecode", ts);
bfree((void*)ts); bfree((void*)ts);
} }
if (additionalFields != NULL) { if (additionalFields != NULL)
obs_data_apply(update, additionalFields); obs_data_apply(update, additionalFields);
}
_srv->broadcast(obs_data_get_json(update)); _srv->broadcast(obs_data_get_json(update));
@ -231,7 +230,8 @@ void WSEvents::connectTransitionSignals(obs_source_t* transition)
{ {
transition_handler = obs_source_get_signal_handler(transition); transition_handler = obs_source_get_signal_handler(transition);
signal_handler_connect(transition_handler, signal_handler_connect(transition_handler,
"transition_start", OnTransitionBegin, this); } "transition_start", OnTransitionBegin, this);
}
else else
{ {
transition_handler = nullptr; transition_handler = nullptr;
@ -293,7 +293,7 @@ const char* WSEvents::GetRecordingTimecode()
void WSEvents::OnSceneChange() void WSEvents::OnSceneChange()
{ {
// Implements an existing update type from bilhamil's OBS Remote // Implements an existing update type from bilhamil's OBS Remote
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_source_t* current_scene = obs_frontend_get_current_scene(); obs_source_t* current_scene = obs_frontend_get_current_scene();
obs_data_array_t* scene_items = Utils::GetSceneItems(current_scene); obs_data_array_t* scene_items = Utils::GetSceneItems(current_scene);
@ -346,12 +346,12 @@ void WSEvents::OnTransitionChange()
obs_source_t* current_transition = obs_frontend_get_current_transition(); obs_source_t* current_transition = obs_frontend_get_current_transition();
connectTransitionSignals(current_transition); connectTransitionSignals(current_transition);
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_string(data, "transition-name", obs_data_set_string(data, "transition-name",
obs_source_get_name(current_transition)); obs_source_get_name(current_transition));
broadcastUpdate("SwitchTransition", data); broadcastUpdate("SwitchTransition", data);
obs_data_release(data); obs_data_release(data);
obs_source_release(current_transition); obs_source_release(current_transition);
} }
@ -374,7 +374,7 @@ void WSEvents::OnProfileListChange()
void WSEvents::OnStreamStarting() void WSEvents::OnStreamStarting()
{ {
// Implements an existing update type from bilhamil's OBS Remote // Implements an existing update type from bilhamil's OBS Remote
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_bool(data, "preview-only", false); obs_data_set_bool(data, "preview-only", false);
broadcastUpdate("StreamStarting", data); broadcastUpdate("StreamStarting", data);
@ -393,7 +393,7 @@ void WSEvents::OnStreamStarted()
void WSEvents::OnStreamStopping() void WSEvents::OnStreamStopping()
{ {
// Implements an existing update type from bilhamil's OBS Remote // Implements an existing update type from bilhamil's OBS Remote
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_bool(data, "preview-only", false); obs_data_set_bool(data, "preview-only", false);
broadcastUpdate("StreamStopping", data); broadcastUpdate("StreamStopping", data);
@ -445,25 +445,25 @@ void WSEvents::StreamStatus()
bool streaming_active = obs_frontend_streaming_active(); bool streaming_active = obs_frontend_streaming_active();
bool recording_active = obs_frontend_recording_active(); bool recording_active = obs_frontend_recording_active();
obs_output_t *stream_output = obs_frontend_get_streaming_output(); obs_output_t* stream_output = obs_frontend_get_streaming_output();
if (!stream_output || !streaming_active) { if (!stream_output || !streaming_active)
if (stream_output) { {
if (stream_output)
obs_output_release(stream_output); obs_output_release(stream_output);
}
return; return;
} }
uint64_t bytes_sent = obs_output_get_total_bytes(stream_output); uint64_t bytes_sent = obs_output_get_total_bytes(stream_output);
uint64_t bytes_sent_time = os_gettime_ns(); uint64_t bytes_sent_time = os_gettime_ns();
if (bytes_sent < _lastBytesSent) { if (bytes_sent < _lastBytesSent)
bytes_sent = 0; bytes_sent = 0;
}
if (bytes_sent == 0) { if (bytes_sent == 0)
_lastBytesSent = 0; _lastBytesSent = 0;
}
uint64_t bytes_between = bytes_sent - _lastBytesSent; uint64_t bytes_between = bytes_sent - _lastBytesSent;
double time_passed = double time_passed =
double(bytes_sent_time - _lastBytesSentTime) / 1000000000.0; double(bytes_sent_time - _lastBytesSentTime) / 1000000000.0;
@ -481,7 +481,7 @@ void WSEvents::StreamStatus()
float strain = obs_output_get_congestion(stream_output); float strain = obs_output_get_congestion(stream_output);
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_bool(data, "streaming", streaming_active); obs_data_set_bool(data, "streaming", streaming_active);
obs_data_set_bool(data, "recording", recording_active); obs_data_set_bool(data, "recording", recording_active);
obs_data_set_int(data, "bytes-per-sec", bytes_per_sec); obs_data_set_int(data, "bytes-per-sec", bytes_per_sec);
@ -519,23 +519,23 @@ void WSEvents::OnTransitionBegin(void* param, calldata_t* data)
blog(LOG_INFO, "transition begin"); blog(LOG_INFO, "transition begin");
} }
void WSEvents::OnSceneReordered(void *param, calldata_t *data) void WSEvents::OnSceneReordered(void* param, calldata_t* data)
{ {
WSEvents* instance = static_cast<WSEvents*>(param); WSEvents* instance = static_cast<WSEvents*>(param);
obs_scene_t* scene = nullptr; obs_scene_t* scene = nullptr;
calldata_get_ptr(data, "scene", &scene); calldata_get_ptr(data, "scene", &scene);
obs_data_t *fields = obs_data_create(); obs_data_t* fields = obs_data_create();
obs_data_set_string(fields, "scene-name", obs_data_set_string(fields, "scene-name",
obs_source_get_name(obs_scene_get_source(scene))); obs_source_get_name(obs_scene_get_source(scene)));
instance->broadcastUpdate("SourceOrderChanged", fields); instance->broadcastUpdate("SourceOrderChanged", fields);
obs_data_release(fields); obs_data_release(fields);
} }
void WSEvents::OnSceneItemAdd(void *param, calldata_t *data) void WSEvents::OnSceneItemAdd(void* param, calldata_t* data)
{ {
WSEvents* instance = static_cast<WSEvents*>(param); WSEvents* instance = static_cast<WSEvents*>(param);
@ -559,7 +559,7 @@ void WSEvents::OnSceneItemAdd(void *param, calldata_t *data)
obs_data_release(fields); obs_data_release(fields);
} }
void WSEvents::OnSceneItemDelete(void *param, calldata_t *data) void WSEvents::OnSceneItemDelete(void* param, calldata_t* data)
{ {
WSEvents* instance = static_cast<WSEvents*>(param); WSEvents* instance = static_cast<WSEvents*>(param);
@ -583,7 +583,7 @@ void WSEvents::OnSceneItemDelete(void *param, calldata_t *data)
obs_data_release(fields); obs_data_release(fields);
} }
void WSEvents::OnSceneItemVisibilityChanged(void *param, calldata_t *data) void WSEvents::OnSceneItemVisibilityChanged(void* param, calldata_t* data)
{ {
WSEvents* instance = static_cast<WSEvents*>(param); WSEvents* instance = static_cast<WSEvents*>(param);
@ -611,7 +611,7 @@ void WSEvents::OnSceneItemVisibilityChanged(void *param, calldata_t *data)
obs_data_release(fields); obs_data_release(fields);
} }
void WSEvents::SelectedSceneChanged(QListWidgetItem *current, QListWidgetItem *prev) void WSEvents::SelectedSceneChanged(QListWidgetItem* current, QListWidgetItem* prev)
{ {
if (Utils::IsPreviewModeActive()) if (Utils::IsPreviewModeActive())
{ {

28
WSEvents.h
View File

@ -24,15 +24,15 @@ with this program. If not, see <https://www.gnu.org/licenses/>
#include <QListWidgetItem> #include <QListWidgetItem>
#include "WSServer.h" #include "WSServer.h"
class WSEvents : public QObject class WSEvents : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit WSEvents(WSServer *srv); explicit WSEvents(WSServer* srv);
~WSEvents(); ~WSEvents();
static void FrontendEventHandler( static void FrontendEventHandler(
enum obs_frontend_event event, void *private_data); enum obs_frontend_event event, void* private_data);
void connectTransitionSignals(obs_source_t* transition); void connectTransitionSignals(obs_source_t* transition);
void connectSceneSignals(obs_source_t* scene); void connectSceneSignals(obs_source_t* scene);
static WSEvents* Instance; static WSEvents* Instance;
@ -47,13 +47,13 @@ class WSEvents : public QObject
void StreamStatus(); void StreamStatus();
void TransitionDurationChanged(int ms); void TransitionDurationChanged(int ms);
void SelectedSceneChanged( void SelectedSceneChanged(
QListWidgetItem *current, QListWidgetItem *prev); QListWidgetItem* current, QListWidgetItem* prev);
void ModeSwitchClicked(bool checked); void ModeSwitchClicked(bool checked);
private: private:
WSServer *_srv; WSServer* _srv;
signal_handler_t *transition_handler; signal_handler_t* transition_handler;
signal_handler_t *scene_handler; signal_handler_t* scene_handler;
bool _streaming_active; bool _streaming_active;
bool _recording_active; bool _recording_active;
@ -64,8 +64,8 @@ class WSEvents : public QObject
uint64_t _lastBytesSent; uint64_t _lastBytesSent;
uint64_t _lastBytesSentTime; uint64_t _lastBytesSentTime;
void broadcastUpdate(const char *updateType, void broadcastUpdate(const char* updateType,
obs_data_t *additionalFields); obs_data_t* additionalFields);
void OnSceneChange(); void OnSceneChange();
void OnSceneListChange(); void OnSceneListChange();
@ -90,12 +90,12 @@ class WSEvents : public QObject
void OnExit(); void OnExit();
static void OnTransitionBegin(void *param, calldata_t *data); static void OnTransitionBegin(void* param, calldata_t* data);
static void OnSceneReordered(void *param, calldata_t *data); static void OnSceneReordered(void* param, calldata_t* data);
static void OnSceneItemAdd(void *param, calldata_t *data); static void OnSceneItemAdd(void* param, calldata_t* data);
static void OnSceneItemDelete(void *param, calldata_t *data); static void OnSceneItemDelete(void* param, calldata_t* data);
static void OnSceneItemVisibilityChanged(void *param, calldata_t *data); static void OnSceneItemVisibilityChanged(void* param, calldata_t* data);
}; };
#endif // WSEVENTS_H #endif // WSEVENTS_H

204
WSRequestHandler.cpp
View File

@ -28,7 +28,7 @@ bool str_valid(const char* str)
return (str != nullptr && strlen(str) > 0); return (str != nullptr && strlen(str) > 0);
} }
WSRequestHandler::WSRequestHandler(QWebSocket *client) : WSRequestHandler::WSRequestHandler(QWebSocket* client) :
_messageId(0), _messageId(0),
_requestType(""), _requestType(""),
data(nullptr) data(nullptr)
@ -94,15 +94,13 @@ WSRequestHandler::WSRequestHandler(QWebSocket *client) :
void WSRequestHandler::processIncomingMessage(QString textMessage) void WSRequestHandler::processIncomingMessage(QString textMessage)
{ {
QByteArray msgData = textMessage.toUtf8(); QByteArray msgData = textMessage.toUtf8();
const char *msg = msgData; const char* msg = msgData;
data = obs_data_create_from_json(msg); data = obs_data_create_from_json(msg);
if (!data) if (!data)
{ {
if (!msg) if (!msg)
{
msg = "<null pointer>"; msg = "<null pointer>";
}
blog(LOG_ERROR, "invalid JSON payload received for '%s'", msg); blog(LOG_ERROR, "invalid JSON payload received for '%s'", msg);
SendErrorResponse("invalid JSON payload"); SendErrorResponse("invalid JSON payload");
@ -141,9 +139,9 @@ WSRequestHandler::~WSRequestHandler()
{ {
} }
void WSRequestHandler::SendOKResponse(obs_data_t *additionalFields) void WSRequestHandler::SendOKResponse(obs_data_t* additionalFields)
{ {
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "status", "ok"); obs_data_set_string(response, "status", "ok");
obs_data_set_string(response, "message-id", _messageId); obs_data_set_string(response, "message-id", _messageId);
@ -155,9 +153,9 @@ void WSRequestHandler::SendOKResponse(obs_data_t *additionalFields)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::SendErrorResponse(const char *errorMessage) void WSRequestHandler::SendErrorResponse(const char* errorMessage)
{ {
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "status", "error"); obs_data_set_string(response, "status", "error");
obs_data_set_string(response, "error", errorMessage); obs_data_set_string(response, "error", errorMessage);
obs_data_set_string(response, "message-id", _messageId); obs_data_set_string(response, "message-id", _messageId);
@ -175,11 +173,11 @@ bool WSRequestHandler::hasField(const char* name)
return obs_data_has_user_value(data, name); return obs_data_has_user_value(data, name);
} }
void WSRequestHandler::HandleGetVersion(WSRequestHandler *req) void WSRequestHandler::HandleGetVersion(WSRequestHandler* req)
{ {
const char* obs_version = Utils::OBSVersionString(); const char* obs_version = Utils::OBSVersionString();
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_double(data, "version", API_VERSION); obs_data_set_double(data, "version", API_VERSION);
obs_data_set_string(data, "obs-websocket-version", OBS_WEBSOCKET_VERSION); obs_data_set_string(data, "obs-websocket-version", OBS_WEBSOCKET_VERSION);
obs_data_set_string(data, "obs-studio-version", obs_version); obs_data_set_string(data, "obs-studio-version", obs_version);
@ -190,11 +188,11 @@ void WSRequestHandler::HandleGetVersion(WSRequestHandler *req)
bfree((void*)obs_version); bfree((void*)obs_version);
} }
void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler *req) void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler* req)
{ {
bool authRequired = Config::Current()->AuthRequired; bool authRequired = Config::Current()->AuthRequired;
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_bool(data, "authRequired", authRequired); obs_data_set_bool(data, "authRequired", authRequired);
if (authRequired) if (authRequired)
@ -210,7 +208,7 @@ void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler *req)
obs_data_release(data); obs_data_release(data);
} }
void WSRequestHandler::HandleAuthenticate(WSRequestHandler *req) void WSRequestHandler::HandleAuthenticate(WSRequestHandler* req)
{ {
if (!req->hasField("auth")) if (!req->hasField("auth"))
{ {
@ -218,14 +216,14 @@ void WSRequestHandler::HandleAuthenticate(WSRequestHandler *req)
return; return;
} }
const char *auth = obs_data_get_string(req->data, "auth"); const char* auth = obs_data_get_string(req->data, "auth");
if (!str_valid(auth)) if (!str_valid(auth))
{ {
req->SendErrorResponse("auth not specified!"); req->SendErrorResponse("auth not specified!");
return; return;
} }
if ((req->_client->property(PROP_AUTHENTICATED).toBool() == false) if ((req->_client->property(PROP_AUTHENTICATED).toBool() == false)
&& Config::Current()->CheckAuth(auth)) && Config::Current()->CheckAuth(auth))
{ {
req->_client->setProperty(PROP_AUTHENTICATED, true); req->_client->setProperty(PROP_AUTHENTICATED, true);
@ -237,7 +235,7 @@ void WSRequestHandler::HandleAuthenticate(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler *req) void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler* req)
{ {
if (!req->hasField("scene-name")) if (!req->hasField("scene-name"))
{ {
@ -245,8 +243,8 @@ void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler *req)
return; return;
} }
const char *sceneName = obs_data_get_string(req->data, "scene-name"); const char* sceneName = obs_data_get_string(req->data, "scene-name");
obs_source_t *source = obs_get_source_by_name(sceneName); obs_source_t* source = obs_get_source_by_name(sceneName);
if (source) if (source)
{ {
@ -261,14 +259,14 @@ void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler *req)
obs_source_release(source); obs_source_release(source);
} }
void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler *req) void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler* req)
{ {
obs_source_t *current_scene = obs_frontend_get_current_scene(); obs_source_t* current_scene = obs_frontend_get_current_scene();
const char *name = obs_source_get_name(current_scene); const char* name = obs_source_get_name(current_scene);
obs_data_array_t *scene_items = Utils::GetSceneItems(current_scene); obs_data_array_t* scene_items = Utils::GetSceneItems(current_scene);
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_string(data, "name", name); obs_data_set_string(data, "name", name);
obs_data_set_array(data, "sources", scene_items); obs_data_set_array(data, "sources", scene_items);
@ -279,12 +277,12 @@ void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler *req)
obs_source_release(current_scene); obs_source_release(current_scene);
} }
void WSRequestHandler::HandleGetSceneList(WSRequestHandler *req) void WSRequestHandler::HandleGetSceneList(WSRequestHandler* req)
{ {
obs_source_t *current_scene = obs_frontend_get_current_scene(); obs_source_t* current_scene = obs_frontend_get_current_scene();
obs_data_array_t *scenes = Utils::GetScenes(); obs_data_array_t* scenes = Utils::GetScenes();
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_string(data, "current-scene", obs_data_set_string(data, "current-scene",
obs_source_get_name(current_scene)); obs_source_get_name(current_scene));
obs_data_set_array(data, "scenes", scenes); obs_data_set_array(data, "scenes", scenes);
@ -296,7 +294,7 @@ void WSRequestHandler::HandleGetSceneList(WSRequestHandler *req)
obs_source_release(current_scene); obs_source_release(current_scene);
} }
void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler *req) void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler* req)
{ {
if (!req->hasField("source") || if (!req->hasField("source") ||
!req->hasField("render")) !req->hasField("render"))
@ -305,23 +303,23 @@ void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler *req)
return; return;
} }
const char *itemName = obs_data_get_string(req->data, "source"); const char* itemName = obs_data_get_string(req->data, "source");
bool isVisible = obs_data_get_bool(req->data, "render"); bool isVisible = obs_data_get_bool(req->data, "render");
if (!itemName) if (!itemName)
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
return; return;
} }
const char *sceneName = obs_data_get_string(req->data, "scene-name"); const char* sceneName = obs_data_get_string(req->data, "scene-name");
obs_source_t *scene = Utils::GetSceneFromNameOrCurrent(sceneName); obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (scene == NULL) { if (scene == NULL) {
req->SendErrorResponse("requested scene doesn't exist"); req->SendErrorResponse("requested scene doesn't exist");
return; return;
} }
obs_sceneitem_t *sceneItem = Utils::GetSceneItemFromName(scene, itemName); obs_sceneitem_t* sceneItem = Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem != NULL) if (sceneItem != NULL)
{ {
obs_sceneitem_set_visible(sceneItem, isVisible); obs_sceneitem_set_visible(sceneItem, isVisible);
@ -336,9 +334,9 @@ void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler *req)
obs_source_release(scene); obs_source_release(scene);
} }
void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler *req) void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler* req)
{ {
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_bool(data, "streaming", obs_frontend_streaming_active()); obs_data_set_bool(data, "streaming", obs_frontend_streaming_active());
obs_data_set_bool(data, "recording", obs_frontend_recording_active()); obs_data_set_bool(data, "recording", obs_frontend_recording_active());
obs_data_set_bool(data, "preview-only", false); obs_data_set_bool(data, "preview-only", false);
@ -362,7 +360,7 @@ void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler *req)
obs_data_release(data); obs_data_release(data);
} }
void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler *req) void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler* req)
{ {
if (obs_frontend_streaming_active()) if (obs_frontend_streaming_active())
obs_frontend_streaming_stop(); obs_frontend_streaming_stop();
@ -372,7 +370,7 @@ void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler *req)
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleStartStopRecording(WSRequestHandler *req) void WSRequestHandler::HandleStartStopRecording(WSRequestHandler* req)
{ {
if (obs_frontend_recording_active()) if (obs_frontend_recording_active())
obs_frontend_recording_stop(); obs_frontend_recording_stop();
@ -382,7 +380,7 @@ void WSRequestHandler::HandleStartStopRecording(WSRequestHandler *req)
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleStartStreaming(WSRequestHandler *req) void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req)
{ {
if (obs_frontend_streaming_active() == false) if (obs_frontend_streaming_active() == false)
{ {
@ -395,7 +393,7 @@ void WSRequestHandler::HandleStartStreaming(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleStopStreaming(WSRequestHandler *req) void WSRequestHandler::HandleStopStreaming(WSRequestHandler* req)
{ {
if (obs_frontend_streaming_active() == true) if (obs_frontend_streaming_active() == true)
{ {
@ -408,7 +406,7 @@ void WSRequestHandler::HandleStopStreaming(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleStartRecording(WSRequestHandler *req) void WSRequestHandler::HandleStartRecording(WSRequestHandler* req)
{ {
if (obs_frontend_recording_active() == false) if (obs_frontend_recording_active() == false)
{ {
@ -421,7 +419,7 @@ void WSRequestHandler::HandleStartRecording(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleStopRecording(WSRequestHandler *req) void WSRequestHandler::HandleStopRecording(WSRequestHandler* req)
{ {
if (obs_frontend_recording_active() == true) if (obs_frontend_recording_active() == true)
{ {
@ -434,9 +432,9 @@ void WSRequestHandler::HandleStopRecording(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *req) void WSRequestHandler::HandleGetTransitionList(WSRequestHandler* req)
{ {
obs_source_t *current_transition = obs_frontend_get_current_transition(); obs_source_t* current_transition = obs_frontend_get_current_transition();
obs_frontend_source_list transitionList = {}; obs_frontend_source_list transitionList = {};
obs_frontend_get_transitions(&transitionList); obs_frontend_get_transitions(&transitionList);
@ -445,7 +443,7 @@ void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *req)
{ {
obs_source_t* transition = transitionList.sources.array[i]; obs_source_t* transition = transitionList.sources.array[i];
obs_data_t *obj = obs_data_create(); obs_data_t* obj = obs_data_create();
obs_data_set_string(obj, "name", obs_source_get_name(transition)); obs_data_set_string(obj, "name", obs_source_get_name(transition));
obs_data_array_push_back(transitions, obj); obs_data_array_push_back(transitions, obj);
@ -453,7 +451,7 @@ void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *req)
} }
obs_frontend_source_list_free(&transitionList); obs_frontend_source_list_free(&transitionList);
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "current-transition", obs_data_set_string(response, "current-transition",
obs_source_get_name(current_transition)); obs_source_get_name(current_transition));
obs_data_set_array(response, "transitions", transitions); obs_data_set_array(response, "transitions", transitions);
@ -465,18 +463,16 @@ void WSRequestHandler::HandleGetTransitionList(WSRequestHandler *req)
obs_source_release(current_transition); obs_source_release(current_transition);
} }
void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler *req) void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler* req)
{ {
obs_source_t *current_transition = obs_frontend_get_current_transition(); obs_source_t* current_transition = obs_frontend_get_current_transition();
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "name", obs_data_set_string(response, "name",
obs_source_get_name(current_transition)); obs_source_get_name(current_transition));
if (!obs_transition_fixed(current_transition)) if (!obs_transition_fixed(current_transition))
{
obs_data_set_int(response, "duration", Utils::GetTransitionDuration()); obs_data_set_int(response, "duration", Utils::GetTransitionDuration());
}
req->SendOKResponse(response); req->SendOKResponse(response);
@ -484,7 +480,7 @@ void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler *req)
obs_source_release(current_transition); obs_source_release(current_transition);
} }
void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler *req) void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler* req)
{ {
if (!req->hasField("transition-name")) if (!req->hasField("transition-name"))
{ {
@ -492,7 +488,7 @@ void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler *req)
return; return;
} }
const char *name = obs_data_get_string(req->data, "transition-name"); const char* name = obs_data_get_string(req->data, "transition-name");
bool success = Utils::SetTransitionByName(name); bool success = Utils::SetTransitionByName(name);
@ -502,7 +498,7 @@ void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler *req)
req->SendErrorResponse("requested transition does not exist"); req->SendErrorResponse("requested transition does not exist");
} }
void WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler *req) void WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler* req)
{ {
if (!req->hasField("duration")) if (!req->hasField("duration"))
{ {
@ -515,7 +511,7 @@ void WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler *req)
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleGetTransitionDuration(WSRequestHandler *req) void WSRequestHandler::HandleGetTransitionDuration(WSRequestHandler* req)
{ {
obs_data_t* response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_int(response, "transition-duration", obs_data_set_int(response, "transition-duration",
@ -525,7 +521,7 @@ void WSRequestHandler::HandleGetTransitionDuration(WSRequestHandler *req)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleSetVolume(WSRequestHandler *req) void WSRequestHandler::HandleSetVolume(WSRequestHandler* req)
{ {
if (!req->hasField("source") || if (!req->hasField("source") ||
!req->hasField("volume")) !req->hasField("volume"))
@ -534,7 +530,7 @@ void WSRequestHandler::HandleSetVolume(WSRequestHandler *req)
return; return;
} }
const char *source_name = obs_data_get_string(req->data, "source"); const char* source_name = obs_data_get_string(req->data, "source");
float source_volume = obs_data_get_double(req->data, "volume"); float source_volume = obs_data_get_double(req->data, "volume");
if (source_name == NULL || strlen(source_name) < 1 || if (source_name == NULL || strlen(source_name) < 1 ||
@ -557,7 +553,7 @@ void WSRequestHandler::HandleSetVolume(WSRequestHandler *req)
obs_source_release(source); obs_source_release(source);
} }
void WSRequestHandler::HandleGetVolume(WSRequestHandler *req) void WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
{ {
if (!req->hasField("source")) if (!req->hasField("source"))
{ {
@ -565,7 +561,7 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler *req)
return; return;
} }
const char *source_name = obs_data_get_string(req->data, "source"); const char* source_name = obs_data_get_string(req->data, "source");
if (str_valid(source_name)) if (str_valid(source_name))
{ {
@ -587,7 +583,7 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleToggleMute(WSRequestHandler *req) void WSRequestHandler::HandleToggleMute(WSRequestHandler* req)
{ {
if (!req->hasField("source")) if (!req->hasField("source"))
{ {
@ -595,7 +591,7 @@ void WSRequestHandler::HandleToggleMute(WSRequestHandler *req)
return; return;
} }
const char *source_name = obs_data_get_string(req->data, "source"); const char* source_name = obs_data_get_string(req->data, "source");
if (!str_valid(source_name)) if (!str_valid(source_name))
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
@ -615,7 +611,7 @@ void WSRequestHandler::HandleToggleMute(WSRequestHandler *req)
obs_source_release(source); obs_source_release(source);
} }
void WSRequestHandler::HandleSetMute(WSRequestHandler *req) void WSRequestHandler::HandleSetMute(WSRequestHandler* req)
{ {
if (!req->hasField("source") || if (!req->hasField("source") ||
!req->hasField("mute")) !req->hasField("mute"))
@ -624,7 +620,7 @@ void WSRequestHandler::HandleSetMute(WSRequestHandler *req)
return; return;
} }
const char *source_name = obs_data_get_string(req->data, "source"); const char* source_name = obs_data_get_string(req->data, "source");
bool mute = obs_data_get_bool(req->data, "mute"); bool mute = obs_data_get_bool(req->data, "mute");
if (!str_valid(source_name)) if (!str_valid(source_name))
@ -646,7 +642,7 @@ void WSRequestHandler::HandleSetMute(WSRequestHandler *req)
obs_source_release(source); obs_source_release(source);
} }
void WSRequestHandler::HandleGetMute(WSRequestHandler *req) void WSRequestHandler::HandleGetMute(WSRequestHandler* req)
{ {
if (!req->hasField("source")) if (!req->hasField("source"))
{ {
@ -654,7 +650,7 @@ void WSRequestHandler::HandleGetMute(WSRequestHandler *req)
return; return;
} }
const char *source_name = obs_data_get_string(req->data, "source"); const char* source_name = obs_data_get_string(req->data, "source");
if (!str_valid(source_name)) if (!str_valid(source_name))
{ {
@ -679,7 +675,7 @@ void WSRequestHandler::HandleGetMute(WSRequestHandler *req)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler *req) void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler* req)
{ {
if (!req->hasField("item") || if (!req->hasField("item") ||
!req->hasField("x") || !req->hasField("y")) !req->hasField("x") || !req->hasField("y"))
@ -688,21 +684,21 @@ void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler *req)
return; return;
} }
const char *item_name = obs_data_get_string(req->data, "item"); const char* item_name = obs_data_get_string(req->data, "item");
if (!str_valid(item_name)) if (!str_valid(item_name))
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
return; return;
} }
const char *scene_name = obs_data_get_string(req->data, "scene-name"); const char* scene_name = obs_data_get_string(req->data, "scene-name");
obs_source_t *scene = Utils::GetSceneFromNameOrCurrent(scene_name); obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(scene_name);
if (!scene) { if (!scene) {
req->SendErrorResponse("requested scene could not be found"); req->SendErrorResponse("requested scene could not be found");
return; return;
} }
obs_sceneitem_t *scene_item = Utils::GetSceneItemFromName(scene, item_name); obs_sceneitem_t* scene_item = Utils::GetSceneItemFromName(scene, item_name);
if (scene_item) if (scene_item)
{ {
@ -723,7 +719,7 @@ void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler *req)
obs_source_release(scene); obs_source_release(scene);
} }
void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler *req) void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler* req)
{ {
if (!req->hasField("item") || if (!req->hasField("item") ||
!req->hasField("x-scale") || !req->hasField("x-scale") ||
@ -734,14 +730,14 @@ void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler *req)
return; return;
} }
const char *item_name = obs_data_get_string(req->data, "item"); const char* item_name = obs_data_get_string(req->data, "item");
if (!str_valid(item_name)) if (!str_valid(item_name))
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
return; return;
} }
const char *scene_name = obs_data_get_string(req->data, "scene-name"); const char* scene_name = obs_data_get_string(req->data, "scene-name");
obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(scene_name); obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(scene_name);
if (!scene) { if (!scene) {
req->SendErrorResponse("requested scene doesn't exist"); req->SendErrorResponse("requested scene doesn't exist");
@ -754,13 +750,13 @@ void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler *req)
float rotation = obs_data_get_double(req->data, "rotation"); float rotation = obs_data_get_double(req->data, "rotation");
obs_sceneitem_t *scene_item = Utils::GetSceneItemFromName(scene, item_name); obs_sceneitem_t* scene_item = Utils::GetSceneItemFromName(scene, item_name);
if (scene_item) if (scene_item)
{ {
obs_sceneitem_set_scale(scene_item, &scale); obs_sceneitem_set_scale(scene_item, &scale);
obs_sceneitem_set_rot(scene_item, rotation); obs_sceneitem_set_rot(scene_item, rotation);
obs_sceneitem_release(scene_item); obs_sceneitem_release(scene_item);
req->SendOKResponse(); req->SendOKResponse();
} }
@ -772,7 +768,7 @@ void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler *req)
obs_source_release(scene); obs_source_release(scene);
} }
void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler *req) void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler* req)
{ {
if (!req->hasField("item")) if (!req->hasField("item"))
{ {
@ -780,21 +776,21 @@ void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler *req)
return; return;
} }
const char *item_name = obs_data_get_string(req->data, "item"); const char* item_name = obs_data_get_string(req->data, "item");
if (!str_valid(item_name)) if (!str_valid(item_name))
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
return; return;
} }
const char *scene_name = obs_data_get_string(req->data, "scene-name"); const char* scene_name = obs_data_get_string(req->data, "scene-name");
obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(scene_name); obs_source_t* scene = Utils::GetSceneFromNameOrCurrent(scene_name);
if (!scene) { if (!scene) {
req->SendErrorResponse("requested scene doesn't exist"); req->SendErrorResponse("requested scene doesn't exist");
return; return;
} }
obs_sceneitem_t *scene_item = Utils::GetSceneItemFromName(scene, item_name); obs_sceneitem_t* scene_item = Utils::GetSceneItemFromName(scene, item_name);
if (scene_item) if (scene_item)
{ {
@ -817,7 +813,7 @@ void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler *req)
obs_source_release(scene); obs_source_release(scene);
} }
void WSRequestHandler::HandleSetCurrentSceneCollection(WSRequestHandler *req) void WSRequestHandler::HandleSetCurrentSceneCollection(WSRequestHandler* req)
{ {
if (!req->hasField("sc-name")) if (!req->hasField("sc-name"))
{ {
@ -839,9 +835,9 @@ void WSRequestHandler::HandleSetCurrentSceneCollection(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler *req) void WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler* req)
{ {
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "sc-name", obs_data_set_string(response, "sc-name",
obs_frontend_get_current_scene_collection()); obs_frontend_get_current_scene_collection());
@ -850,11 +846,11 @@ void WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler *req)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleListSceneCollections(WSRequestHandler *req) void WSRequestHandler::HandleListSceneCollections(WSRequestHandler* req)
{ {
obs_data_array_t *scene_collections = Utils::GetSceneCollections(); obs_data_array_t* scene_collections = Utils::GetSceneCollections();
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_array(response, "scene-collections", scene_collections); obs_data_set_array(response, "scene-collections", scene_collections);
req->SendOKResponse(response); req->SendOKResponse(response);
@ -863,7 +859,7 @@ void WSRequestHandler::HandleListSceneCollections(WSRequestHandler *req)
obs_data_array_release(scene_collections); obs_data_array_release(scene_collections);
} }
void WSRequestHandler::HandleSetCurrentProfile(WSRequestHandler *req) void WSRequestHandler::HandleSetCurrentProfile(WSRequestHandler* req)
{ {
if (!req->hasField("profile-name")) if (!req->hasField("profile-name"))
{ {
@ -885,9 +881,9 @@ void WSRequestHandler::HandleSetCurrentProfile(WSRequestHandler *req)
} }
} }
void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler *req) void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler* req)
{ {
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_string(response, "profile-name", obs_data_set_string(response, "profile-name",
obs_frontend_get_current_profile()); obs_frontend_get_current_profile());
@ -896,11 +892,11 @@ void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler *req)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleListProfiles(WSRequestHandler *req) void WSRequestHandler::HandleListProfiles(WSRequestHandler* req)
{ {
obs_data_array_t *profiles = Utils::GetProfiles(); obs_data_array_t* profiles = Utils::GetProfiles();
obs_data_t *response = obs_data_create(); obs_data_t* response = obs_data_create();
obs_data_set_array(response, "profiles", profiles); obs_data_set_array(response, "profiles", profiles);
req->SendOKResponse(response); req->SendOKResponse(response);
@ -909,7 +905,7 @@ void WSRequestHandler::HandleListProfiles(WSRequestHandler *req)
obs_data_array_release(profiles); obs_data_array_release(profiles);
} }
void WSRequestHandler::HandleGetStudioModeStatus(WSRequestHandler *req) void WSRequestHandler::HandleGetStudioModeStatus(WSRequestHandler* req)
{ {
bool previewActive = Utils::IsPreviewModeActive(); bool previewActive = Utils::IsPreviewModeActive();
@ -921,7 +917,7 @@ void WSRequestHandler::HandleGetStudioModeStatus(WSRequestHandler *req)
obs_data_release(response); obs_data_release(response);
} }
void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler *req) void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler* req)
{ {
if (!Utils::IsPreviewModeActive()) if (!Utils::IsPreviewModeActive())
{ {
@ -931,11 +927,11 @@ void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler *req)
obs_scene_t* preview_scene = Utils::GetPreviewScene(); obs_scene_t* preview_scene = Utils::GetPreviewScene();
obs_source_t* source = obs_scene_get_source(preview_scene); obs_source_t* source = obs_scene_get_source(preview_scene);
const char *name = obs_source_get_name(source); const char* name = obs_source_get_name(source);
obs_data_array_t *scene_items = Utils::GetSceneItems(source); obs_data_array_t* scene_items = Utils::GetSceneItems(source);
obs_data_t *data = obs_data_create(); obs_data_t* data = obs_data_create();
obs_data_set_string(data, "name", name); obs_data_set_string(data, "name", name);
obs_data_set_array(data, "sources", scene_items); obs_data_set_array(data, "sources", scene_items);
@ -947,7 +943,7 @@ void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler *req)
obs_scene_release(preview_scene); obs_scene_release(preview_scene);
} }
void WSRequestHandler::HandleSetPreviewScene(WSRequestHandler *req) void WSRequestHandler::HandleSetPreviewScene(WSRequestHandler* req)
{ {
if (!Utils::IsPreviewModeActive()) if (!Utils::IsPreviewModeActive())
{ {
@ -970,7 +966,7 @@ void WSRequestHandler::HandleSetPreviewScene(WSRequestHandler *req)
req->SendErrorResponse("specified scene doesn't exist"); req->SendErrorResponse("specified scene doesn't exist");
} }
void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler *req) void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req)
{ {
if (!Utils::IsPreviewModeActive()) if (!Utils::IsPreviewModeActive())
{ {
@ -987,7 +983,7 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler *req)
{ {
const char* transitionName = const char* transitionName =
obs_data_get_string(transitionInfo, "name"); obs_data_get_string(transitionInfo, "name");
if (!str_valid(transitionName)) if (!str_valid(transitionName))
{ {
req->SendErrorResponse("invalid request parameters"); req->SendErrorResponse("invalid request parameters");
@ -1010,7 +1006,7 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler *req)
Utils::SetTransitionDuration(transitionDuration); Utils::SetTransitionDuration(transitionDuration);
} }
obs_data_release(transitionInfo); obs_data_release(transitionInfo);
} }
@ -1018,25 +1014,25 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler *req)
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleEnableStudioMode(WSRequestHandler *req) void WSRequestHandler::HandleEnableStudioMode(WSRequestHandler* req)
{ {
Utils::EnablePreviewMode(); Utils::EnablePreviewMode();
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleDisableStudioMode(WSRequestHandler *req) void WSRequestHandler::HandleDisableStudioMode(WSRequestHandler* req)
{ {
Utils::DisablePreviewMode(); Utils::DisablePreviewMode();
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleToggleStudioMode(WSRequestHandler *req) void WSRequestHandler::HandleToggleStudioMode(WSRequestHandler* req)
{ {
Utils::TogglePreviewMode(); Utils::TogglePreviewMode();
req->SendOKResponse(); req->SendOKResponse();
} }
void WSRequestHandler::HandleGetSpecialSources(WSRequestHandler *req) void WSRequestHandler::HandleGetSpecialSources(WSRequestHandler* req)
{ {
obs_data_t* response = obs_data_create(); obs_data_t* response = obs_data_create();

100
WSRequestHandler.h
View File

@ -29,73 +29,73 @@ class WSRequestHandler : public QObject
Q_OBJECT Q_OBJECT
public: public:
explicit WSRequestHandler(QWebSocket *client); explicit WSRequestHandler(QWebSocket* client);
~WSRequestHandler(); ~WSRequestHandler();
void processIncomingMessage(QString textMessage); void processIncomingMessage(QString textMessage);
bool hasField(const char* name); bool hasField(const char* name);
private: private:
QWebSocket *_client; QWebSocket* _client;
const char *_messageId; const char* _messageId;
const char *_requestType; const char* _requestType;
obs_data_t *data; obs_data_t* data;
QMap<QString, void(*)(WSRequestHandler*)> messageMap; QMap<QString, void(*)(WSRequestHandler*)> messageMap;
QSet<QString> authNotRequired; QSet<QString> authNotRequired;
void SendOKResponse(obs_data_t *additionalFields = NULL); void SendOKResponse(obs_data_t* additionalFields = NULL);
void SendErrorResponse(const char *errorMessage); void SendErrorResponse(const char* errorMessage);
static void HandleGetVersion(WSRequestHandler *req);
static void HandleGetAuthRequired(WSRequestHandler *req);
static void HandleAuthenticate(WSRequestHandler *req);
static void HandleSetCurrentScene(WSRequestHandler *req); static void HandleGetVersion(WSRequestHandler* req);
static void HandleGetCurrentScene(WSRequestHandler *req); static void HandleGetAuthRequired(WSRequestHandler* req);
static void HandleGetSceneList(WSRequestHandler *req); static void HandleAuthenticate(WSRequestHandler* req);
static void HandleSetSceneItemRender(WSRequestHandler *req);
static void HandleSetSceneItemPosition(WSRequestHandler *req);
static void HandleSetSceneItemTransform(WSRequestHandler *req);
static void HandleSetSceneItemCrop(WSRequestHandler *req);
static void HandleGetStreamingStatus(WSRequestHandler *req); static void HandleSetCurrentScene(WSRequestHandler* req);
static void HandleStartStopStreaming(WSRequestHandler *req); static void HandleGetCurrentScene(WSRequestHandler* req);
static void HandleStartStopRecording(WSRequestHandler *req); static void HandleGetSceneList(WSRequestHandler* req);
static void HandleStartStreaming(WSRequestHandler *req);
static void HandleStopStreaming(WSRequestHandler *req);
static void HandleStartRecording(WSRequestHandler *req);
static void HandleStopRecording(WSRequestHandler *req);
static void HandleGetTransitionList(WSRequestHandler *req); static void HandleSetSceneItemRender(WSRequestHandler* req);
static void HandleGetCurrentTransition(WSRequestHandler *req); static void HandleSetSceneItemPosition(WSRequestHandler* req);
static void HandleSetCurrentTransition(WSRequestHandler *req); static void HandleSetSceneItemTransform(WSRequestHandler* req);
static void HandleSetSceneItemCrop(WSRequestHandler* req);
static void HandleSetVolume(WSRequestHandler *req); static void HandleGetStreamingStatus(WSRequestHandler* req);
static void HandleGetVolume(WSRequestHandler *req); static void HandleStartStopStreaming(WSRequestHandler* req);
static void HandleToggleMute(WSRequestHandler *req); static void HandleStartStopRecording(WSRequestHandler* req);
static void HandleSetMute(WSRequestHandler *req); static void HandleStartStreaming(WSRequestHandler* req);
static void HandleGetMute(WSRequestHandler *req); static void HandleStopStreaming(WSRequestHandler* req);
static void HandleGetSpecialSources(WSRequestHandler *req); static void HandleStartRecording(WSRequestHandler* req);
static void HandleStopRecording(WSRequestHandler* req);
static void HandleSetCurrentSceneCollection(WSRequestHandler *req); static void HandleGetTransitionList(WSRequestHandler* req);
static void HandleGetCurrentSceneCollection(WSRequestHandler *req); static void HandleGetCurrentTransition(WSRequestHandler* req);
static void HandleListSceneCollections(WSRequestHandler *req); static void HandleSetCurrentTransition(WSRequestHandler* req);
static void HandleSetCurrentProfile(WSRequestHandler *req); static void HandleSetVolume(WSRequestHandler* req);
static void HandleGetCurrentProfile(WSRequestHandler *req); static void HandleGetVolume(WSRequestHandler* req);
static void HandleListProfiles(WSRequestHandler *req); static void HandleToggleMute(WSRequestHandler* req);
static void HandleSetMute(WSRequestHandler* req);
static void HandleGetMute(WSRequestHandler* req);
static void HandleGetSpecialSources(WSRequestHandler* req);
static void HandleSetTransitionDuration(WSRequestHandler *req); static void HandleSetCurrentSceneCollection(WSRequestHandler* req);
static void HandleGetTransitionDuration(WSRequestHandler *req); static void HandleGetCurrentSceneCollection(WSRequestHandler* req);
static void HandleListSceneCollections(WSRequestHandler* req);
static void HandleGetStudioModeStatus(WSRequestHandler *req); static void HandleSetCurrentProfile(WSRequestHandler* req);
static void HandleGetPreviewScene(WSRequestHandler *req); static void HandleGetCurrentProfile(WSRequestHandler* req);
static void HandleSetPreviewScene(WSRequestHandler *req); static void HandleListProfiles(WSRequestHandler* req);
static void HandleTransitionToProgram(WSRequestHandler *req);
static void HandleEnableStudioMode(WSRequestHandler *req); static void HandleSetTransitionDuration(WSRequestHandler* req);
static void HandleDisableStudioMode(WSRequestHandler *req); static void HandleGetTransitionDuration(WSRequestHandler* req);
static void HandleToggleStudioMode(WSRequestHandler *req);
static void HandleGetStudioModeStatus(WSRequestHandler* req);
static void HandleGetPreviewScene(WSRequestHandler* req);
static void HandleSetPreviewScene(WSRequestHandler* req);
static void HandleTransitionToProgram(WSRequestHandler* req);
static void HandleEnableStudioMode(WSRequestHandler* req);
static void HandleDisableStudioMode(WSRequestHandler* req);
static void HandleToggleStudioMode(WSRequestHandler* req);
}; };
#endif // WSPROTOCOL_H #endif // WSPROTOCOL_H

33
WSServer.cpp
View File

@ -30,7 +30,7 @@ QT_USE_NAMESPACE
WSServer* WSServer::Instance = nullptr; WSServer* WSServer::Instance = nullptr;
WSServer::WSServer(QObject *parent) : WSServer::WSServer(QObject* parent) :
QObject(parent), QObject(parent),
_wsServer(Q_NULLPTR), _wsServer(Q_NULLPTR),
_clients(), _clients(),
@ -49,7 +49,6 @@ WSServer::WSServer(QObject *parent) :
WSServer::~WSServer() WSServer::~WSServer()
{ {
Stop(); Stop();
delete _serverThread; delete _serverThread;
} }
@ -64,7 +63,7 @@ void WSServer::Start(quint16 port)
bool serverStarted = _wsServer->listen(QHostAddress::Any, port); bool serverStarted = _wsServer->listen(QHostAddress::Any, port);
if (serverStarted) if (serverStarted)
{ {
connect(_wsServer, &QWebSocketServer::newConnection, connect(_wsServer, &QWebSocketServer::newConnection,
this, &WSServer::onNewConnection); this, &WSServer::onNewConnection);
} }
} }
@ -72,7 +71,7 @@ void WSServer::Start(quint16 port)
void WSServer::Stop() void WSServer::Stop()
{ {
_clMutex.lock(); _clMutex.lock();
Q_FOREACH(QWebSocket *pClient, _clients) Q_FOREACH(QWebSocket* pClient, _clients)
{ {
pClient->close(); pClient->close();
} }
@ -85,7 +84,7 @@ void WSServer::broadcast(QString message)
{ {
_clMutex.lock(); _clMutex.lock();
Q_FOREACH(QWebSocket *pClient, _clients) Q_FOREACH(QWebSocket* pClient, _clients)
{ {
if (Config::Current()->AuthRequired if (Config::Current()->AuthRequired
&& (pClient->property(PROP_AUTHENTICATED).toBool() == false)) && (pClient->property(PROP_AUTHENTICATED).toBool() == false))
@ -102,13 +101,13 @@ void WSServer::broadcast(QString message)
void WSServer::onNewConnection() void WSServer::onNewConnection()
{ {
QWebSocket *pSocket = _wsServer->nextPendingConnection(); QWebSocket* pSocket = _wsServer->nextPendingConnection();
if (pSocket) if (pSocket)
{ {
connect(pSocket, &QWebSocket::textMessageReceived, connect(pSocket, &QWebSocket::textMessageReceived,
this, &WSServer::textMessageReceived); this, &WSServer::textMessageReceived);
connect(pSocket, &QWebSocket::disconnected, connect(pSocket, &QWebSocket::disconnected,
this, &WSServer::socketDisconnected); this, &WSServer::socketDisconnected);
pSocket->setProperty(PROP_AUTHENTICATED, false); pSocket->setProperty(PROP_AUTHENTICATED, false);
@ -119,22 +118,22 @@ void WSServer::onNewConnection()
QHostAddress clientAddr = pSocket->peerAddress(); QHostAddress clientAddr = pSocket->peerAddress();
QString clientIp = Utils::FormatIPAddress(clientAddr); QString clientIp = Utils::FormatIPAddress(clientAddr);
blog(LOG_INFO, "new client connection from %s:%d", blog(LOG_INFO, "new client connection from %s:%d",
clientIp.toUtf8().constData(), pSocket->peerPort()); clientIp.toUtf8().constData(), pSocket->peerPort());
QString msg = QString(obs_module_text("OBSWebsocket.ConnectNotify.ClientIP")) QString msg = QString(obs_module_text("OBSWebsocket.ConnectNotify.ClientIP"))
+ QString(" ") + QString(" ")
+ clientAddr.toString(); + clientAddr.toString();
Utils::SysTrayNotify(msg, Utils::SysTrayNotify(msg,
QSystemTrayIcon::Information, QSystemTrayIcon::Information,
QString(obs_module_text("OBSWebsocket.ConnectNotify.Connected"))); QString(obs_module_text("OBSWebsocket.ConnectNotify.Connected")));
} }
} }
void WSServer::textMessageReceived(QString message) void WSServer::textMessageReceived(QString message)
{ {
QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender()); QWebSocket* pSocket = qobject_cast<QWebSocket*>(sender());
if (pSocket) if (pSocket)
{ {
@ -145,7 +144,7 @@ void WSServer::textMessageReceived(QString message)
void WSServer::socketDisconnected() void WSServer::socketDisconnected()
{ {
QWebSocket *pSocket = qobject_cast<QWebSocket *>(sender()); QWebSocket* pSocket = qobject_cast<QWebSocket*>(sender());
if (pSocket) if (pSocket)
{ {
@ -154,13 +153,13 @@ void WSServer::socketDisconnected()
_clMutex.lock(); _clMutex.lock();
_clients.removeAll(pSocket); _clients.removeAll(pSocket);
_clMutex.unlock(); _clMutex.unlock();
pSocket->deleteLater(); pSocket->deleteLater();
QHostAddress clientAddr = pSocket->peerAddress(); QHostAddress clientAddr = pSocket->peerAddress();
QString clientIp = Utils::FormatIPAddress(clientAddr); QString clientIp = Utils::FormatIPAddress(clientAddr);
blog(LOG_INFO, "client %s:%d disconnected", blog(LOG_INFO, "client %s:%d disconnected",
clientIp.toUtf8().constData(), pSocket->peerPort()); clientIp.toUtf8().constData(), pSocket->peerPort());
QString msg = QString(obs_module_text("OBSWebsocket.ConnectNotify.ClientIP")) QString msg = QString(obs_module_text("OBSWebsocket.ConnectNotify.ClientIP"))

8
WSServer.h
View File

@ -33,7 +33,7 @@ class WSServer : public QObject
Q_OBJECT Q_OBJECT
public: public:
explicit WSServer(QObject *parent = Q_NULLPTR); explicit WSServer(QObject* parent = Q_NULLPTR);
virtual ~WSServer(); virtual ~WSServer();
void Start(quint16 port); void Start(quint16 port);
void Stop(); void Stop();
@ -46,10 +46,10 @@ class WSServer : public QObject
void socketDisconnected(); void socketDisconnected();
private: private:
QWebSocketServer *_wsServer; QWebSocketServer* _wsServer;
QList<QWebSocket *> _clients; QList<QWebSocket*> _clients;
QMutex _clMutex; QMutex _clMutex;
QThread *_serverThread; QThread* _serverThread;
}; };
#endif // WSSERVER_H #endif // WSSERVER_H

12
forms/settings-dialog.cpp
View File

@ -26,22 +26,22 @@ with this program. If not, see <https://www.gnu.org/licenses/>
#define CHANGE_ME "changeme" #define CHANGE_ME "changeme"
SettingsDialog::SettingsDialog(QWidget *parent) : SettingsDialog::SettingsDialog(QWidget* parent) :
QDialog(parent, Qt::Dialog), QDialog(parent, Qt::Dialog),
ui(new Ui::SettingsDialog) ui(new Ui::SettingsDialog)
{ {
ui->setupUi(this); ui->setupUi(this);
connect(ui->authRequired, &QCheckBox::stateChanged, connect(ui->authRequired, &QCheckBox::stateChanged,
this, &SettingsDialog::AuthCheckboxChanged); this, &SettingsDialog::AuthCheckboxChanged);
connect(ui->buttonBox, &QDialogButtonBox::accepted, connect(ui->buttonBox, &QDialogButtonBox::accepted,
this, &SettingsDialog::FormAccepted); this, &SettingsDialog::FormAccepted);
AuthCheckboxChanged(); AuthCheckboxChanged();
} }
void SettingsDialog::showEvent(QShowEvent *event) void SettingsDialog::showEvent(QShowEvent* event)
{ {
Config* conf = Config::Current(); Config* conf = Config::Current();
@ -84,7 +84,7 @@ void SettingsDialog::FormAccepted()
conf->SetPassword(new_password); conf->SetPassword(new_password);
} }
if (strcmp(Config::Current()->Secret, "") != 0) if (strcmp(Config::Current()->Secret, "") != 0)
conf->AuthRequired = true; conf->AuthRequired = true;
else else

6
forms/settings-dialog.h
View File

@ -30,9 +30,9 @@ class SettingsDialog : public QDialog
Q_OBJECT Q_OBJECT
public: public:
explicit SettingsDialog(QWidget *parent = 0); explicit SettingsDialog(QWidget* parent = 0);
~SettingsDialog(); ~SettingsDialog();
void showEvent(QShowEvent *event); void showEvent(QShowEvent* event);
void ToggleShowHide(); void ToggleShowHide();
private Q_SLOTS: private Q_SLOTS:
@ -40,7 +40,7 @@ private Q_SLOTS:
void FormAccepted(); void FormAccepted();
private: private:
Ui::SettingsDialog *ui; Ui::SettingsDialog* ui;
}; };
#endif // SETTINGSDIALOG_H #endif // SETTINGSDIALOG_H