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

Protocol: add Replay Buffer Events and Requests (#104)

Browse Source
This commit is contained in:
Logan S
2017-08-19 06:05:42 -07:00
committed by Stéphane L
parent 37dde278cb
commit 9ce2b1983a
7 changed files with 280 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
CMakeLists.txt
View File

@ -65,6 +65,18 @@ if(WIN32)
message(FATAL_ERROR "Could not find OBS Frontend API\'s library !")
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(ARCH_NAME "64bit")
set(OBS_BUILDDIR_ARCH "build64")
else()
set(ARCH_NAME "32bit")
set(OBS_BUILDDIR_ARCH "build32")
endif()
include_directories(
"${LIBOBS_INCLUDE_DIR}/../${OBS_BUILDDIR_ARCH}/UI"
)
target_link_libraries(obs-websocket
"${OBS_FRONTEND_LIB}")
@ -84,14 +96,6 @@ if(WIN32)
# The "release" folder has a structure similar OBS' one on Windows
set(RELEASE_DIR "${PROJECT_SOURCE_DIR}/release")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(ARCH_NAME "64bit")
set(OBS_BUILDDIR_ARCH "build64")
else()
set(ARCH_NAME "32bit")
set(OBS_BUILDDIR_ARCH "build32")
endif()
add_custom_command(TARGET obs-websocket POST_BUILD
COMMAND if $<CONFIG:Release>==1 (
"${CMAKE_COMMAND}" -E make_directory

56
Utils.cpp
View File

@ -432,12 +432,12 @@ QString* Utils::ParseDataToQueryString(obs_data_t* data) {
do {
if (!obs_data_item_has_user_value(item))
continue;
if (!isFirst)
query->append('&');
else
isFirst = false;
const char* attrName = obs_data_item_get_name(item);
query->append(attrName).append("=");
@ -473,3 +473,55 @@ QString* Utils::ParseDataToQueryString(obs_data_t* data) {
}
return query;
}
obs_hotkey_t* Utils::FindHotkeyByName(const char* name) {
struct current_search {
const char* query;
obs_hotkey_t* result;
};
current_search search;
search.query = name;
search.result = nullptr;
obs_enum_hotkeys([](void* data, obs_hotkey_id id, obs_hotkey_t* hotkey) {
current_search* search = static_cast<current_search*>(data);
const char* hk_name = obs_hotkey_get_name(hotkey);
if (strcmp(hk_name, search->query) == 0) {
search->result = hotkey;
blog(LOG_INFO, "Utils::FindHotkeyByName: found %s", hk_name);
return false;
}
return true;
}, &search);
return search.result;
}
bool Utils::ReplayBufferEnabled() {
config_t* profile = obs_frontend_get_profile_config();
const char* outputMode = config_get_string(profile, "Output", "Mode");
if (strcmp(outputMode, "Simple") == 0) {
return config_get_bool(profile, "SimpleOutput", "RecRB");
}
return false;
}
bool Utils::RPHotkeySet() {
obs_output_t* rp_output = obs_frontend_get_replay_buffer_output();
obs_data_t *hotkeys = obs_hotkeys_save_output(rp_output);
obs_data_array_t *bindings = obs_data_get_array(hotkeys,
"ReplayBuffer.Save");
size_t count = obs_data_array_count(bindings);
obs_data_array_release(bindings);
obs_data_release(hotkeys);
obs_output_release(rp_output);
return (count > 0);
}

5
Utils.h
View File

@ -76,8 +76,11 @@ class Utils {
static QString FormatIPAddress(QHostAddress &addr);
static const char* GetRecordingFolder();
static bool SetRecordingFolder(const char* path);
static QString* ParseDataToQueryString(obs_data_t * data);
static obs_hotkey_t* FindHotkeyByName(const char* name);
static bool ReplayBufferEnabled();
static bool RPHotkeySet();
};
#endif // UTILS_H

56
WSEvents.cpp
View File

@ -164,6 +164,18 @@ void WSEvents::FrontendEventHandler(enum obs_frontend_event event, void* private
owner->_recording_active = false;
owner->OnRecordingStopped();
}
else if (event == OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING) {
owner->OnReplayStarting();
}
else if (event == OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED) {
owner->OnReplayStarted();
}
else if (event == OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING) {
owner->OnReplayStopping();
}
else if (event == OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED) {
owner->OnReplayStopped();
}
else if (event == OBS_FRONTEND_EVENT_EXIT) {
owner->OnExit();
}
@ -500,6 +512,50 @@ void WSEvents::OnRecordingStopped() {
broadcastUpdate("RecordingStopped");
}
/**
* A request to start the replay buffer has been issued.
*
* @api events
* @name ReplayStarting
* @category replay buffer
*/
void WSEvents::OnReplayStarting() {
broadcastUpdate("ReplayStarting");
}
/**
* Replay Buffer started successfully
*
* @api events
* @name ReplayStarted
* @category replay buffer
*/
void WSEvents::OnReplayStarted() {
broadcastUpdate("ReplayStarted");
}
/**
* A request to start the replay buffer has been issued.
*
* @api events
* @name ReplayStopping
* @category replay buffer
*/
void WSEvents::OnReplayStopping() {
broadcastUpdate("ReplayStopping");
}
/**
* Replay Buffer stopped successfully
*
* @api events
* @name ReplayStopped
* @category replay buffer
*/
void WSEvents::OnReplayStopped() {
broadcastUpdate("ReplayStopped");
}
/**
* OBS is exiting.
*

5
WSEvents.h
View File

@ -87,6 +87,11 @@ class WSEvents : public QObject {
void OnRecordingStopping();
void OnRecordingStopped();
void OnReplayStarting();
void OnReplayStarted();
void OnReplayStopping();
void OnReplayStopped();
void OnExit();
static void OnTransitionBegin(void* param, calldata_t* data);

190
WSRequestHandler.cpp
View File

@ -20,6 +20,7 @@
#include <obs-data.h>
#include <QList>
#include <QObject>
#include <QString>
#include "WSEvents.h"
@ -63,6 +64,11 @@ WSRequestHandler::WSRequestHandler(QWebSocket* client) :
messageMap["StartRecording"] = WSRequestHandler::HandleStartRecording;
messageMap["StopRecording"] = WSRequestHandler::HandleStopRecording;
messageMap["StartStopReplayBuffer"] = WSRequestHandler::HandleStartStopReplayBuffer;
messageMap["StartReplayBuffer"] = WSRequestHandler::HandleStartReplayBuffer;
messageMap["StopReplayBuffer"] = WSRequestHandler::HandleStopReplayBuffer;
messageMap["SaveReplayBuffer"] = WSRequestHandler::HandleSaveReplayBuffer;
messageMap["SetRecordingFolder"] = WSRequestHandler::HandleSetRecordingFolder;
messageMap["GetRecordingFolder"] = WSRequestHandler::HandleGetRecordingFolder;
@ -184,7 +190,7 @@ void WSRequestHandler::SendResponse(obs_data_t* response) {
_client->sendTextMessage(json);
if (Config::Current()->DebugEnabled)
blog(LOG_DEBUG, "Response << '%s'", json);
obs_data_release(response);
}
@ -505,23 +511,23 @@ void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req)
if (obs_frontend_streaming_active() == false) {
obs_data_t* streamData = obs_data_get_obj(req->data, "stream");
obs_service_t* currentService = nullptr;
if (streamData) {
currentService = obs_frontend_get_streaming_service();
obs_service_addref(currentService);
obs_service_t* service = _service;
const char* currentServiceType = obs_service_get_type(currentService);
const char* requestedType =
obs_data_has_user_value(streamData, "type") ? obs_data_get_string(streamData, "type") : currentServiceType;
const char* serviceType =
service != nullptr ? obs_service_get_type(service) : currentServiceType;
obs_data_t* settings = obs_data_get_obj(streamData, "settings");
obs_data_t* metadata = obs_data_get_obj(streamData, "metadata");
QString* query = Utils::ParseDataToQueryString(metadata);
if (strcmp(requestedType, serviceType) != 0) {
if (settings) {
obs_service_release(service);
@ -534,20 +540,20 @@ void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req)
//if type isn't changing we should overlay the settings we got with the existing settings
obs_data_t* existingSettings = obs_service_get_settings(currentService);
obs_data_t* newSettings = obs_data_create(); //by doing this you can send a request to the websocket that only contains a setting you want to change instead of having to do a get and then change them
obs_data_apply(newSettings, existingSettings); //first apply the existing settings
obs_data_apply(newSettings, settings); //then apply the settings from the request should they exist
obs_data_release(settings);
settings = newSettings;
obs_data_release(existingSettings);
}
if (!service){
service = obs_service_create(requestedType, "websocket_custom_service", settings, nullptr);
}
//Supporting adding metadata parameters to key query string
if (query && query->length() > 0) {
const char* key = obs_data_get_string(settings, "key");
@ -568,7 +574,7 @@ void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req)
key = query->toUtf8();
obs_data_set_string(settings, "key", key);
}
obs_service_update(service, settings);
obs_data_release(settings);
obs_data_release(metadata);
@ -579,13 +585,13 @@ void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req)
obs_service_release(_service);
_service = nullptr;
}
obs_frontend_streaming_start();
if (_service != nullptr) {
obs_frontend_set_streaming_service(currentService);
}
req->SendOKResponse();
obs_service_release(currentService);
} else {
@ -644,6 +650,98 @@ void WSRequestHandler::HandleStopRecording(WSRequestHandler* req) {
}
}
/**
* Toggle the Replay Buffer on/off.
*
* @api requests
* @name StartStopReplayBuffer
* @category replay buffer
*/
void WSRequestHandler::HandleStartStopReplayBuffer(WSRequestHandler* req) {
if (obs_frontend_replay_buffer_active()) {
obs_frontend_replay_buffer_stop();
} else {
if (!Utils::RPHotkeySet()) {
req->SendErrorResponse("replay buffer hotkey not set");
return;
}
obs_frontend_replay_buffer_start();
}
req->SendOKResponse();
}
/**
* Start recording into the Replay Buffer.
* Will return an `error` if the Replay Buffer is already active or if the
* "Save Replay Buffer" hotkey is not set in OBS' settings.
* Setting this hotkey is mandatory, even when triggering saves only
* through obs-websocket.
*
* @api requests
* @name StartReplayBuffer
* @category replay buffer
*/
void WSRequestHandler::HandleStartReplayBuffer(WSRequestHandler* req) {
if (!Utils::ReplayBufferEnabled()) {
req->SendErrorResponse("replay buffer disabled in settings");
return;
}
if (obs_frontend_replay_buffer_active() == true) {
req->SendErrorResponse("replay buffer already active");
return;
}
if (!Utils::RPHotkeySet()) {
req->SendErrorResponse("replay buffer hotkey not set");
return;
}
obs_frontend_replay_buffer_start();
req->SendOKResponse();
}
/**
* Stop recording into the Replay Buffer.
* Will return an `error` if the Replay Buffer is not active.
*
* @api requests
* @name StopReplayBuffer
* @category replay buffer
*/
void WSRequestHandler::HandleStopReplayBuffer(WSRequestHandler* req) {
if (obs_frontend_replay_buffer_active() == true) {
obs_frontend_replay_buffer_stop();
req->SendOKResponse();
} else {
req->SendErrorResponse("replay buffer not active");
}
}
/**
* Save and flush the contents of the Replay Buffer to disk. This is
* basically the same as triggering the "Save Replay Buffer" hotkey.
* Will return an `error` if the Replay Buffer is not active.
*
* @api requests
* @name SaveReplayBuffer
* @category replay buffer
*/
void WSRequestHandler::HandleSaveReplayBuffer(WSRequestHandler* req) {
if (!obs_frontend_replay_buffer_active()) {
req->SendErrorResponse("replay buffer not active");
return;
}
obs_hotkey_t* hk = Utils::FindHotkeyByName("ReplayBuffer.Save");
if (hk) {
obs_hotkey_trigger_routed_callback(obs_hotkey_get_id(hk), true);
req->SendOKResponse();
} else {
req->SendErrorResponse("failed to save replay buffer");
}
}
/**
* List of all transitions available in the frontend's dropdown menu.
*
@ -1298,13 +1396,13 @@ void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler* req) {
*/
void WSRequestHandler::HandleSetStreamSettings(WSRequestHandler* req) {
obs_service_t* service = obs_frontend_get_streaming_service();
obs_data_t* settings = obs_data_get_obj(req->data, "settings");
if (!settings) {
req->SendErrorResponse("'settings' are required'");
return;
}
const char* serviceType = obs_service_get_type(service);
const char* requestedType = obs_data_get_string(req->data, "type");
if (requestedType != nullptr && strcmp(requestedType, serviceType) != 0) {
@ -1316,27 +1414,27 @@ void WSRequestHandler::HandleSetStreamSettings(WSRequestHandler* req) {
//if type isn't changing we should overlay the settings we got with the existing settings
obs_data_t* existingSettings = obs_service_get_settings(service);
//by doing this you can send a request to the websocket that only contains a setting you want to change instead of having to do a get and then change them
obs_data_t* newSettings = obs_data_create();
obs_data_t* newSettings = obs_data_create();
obs_data_apply(newSettings, existingSettings); //first apply the existing settings
obs_data_apply(newSettings, settings); //then apply the settings from the request
obs_data_release(settings);
obs_data_release(existingSettings);
obs_service_update(service, settings);
settings = newSettings;
}
//if save is specified we should immediately save the streaming service
if (obs_data_get_bool(req->data, "save")) {
obs_frontend_save_streaming_service();
}
obs_data_t* response = obs_data_create();
obs_data_set_string(response, "type", requestedType);
obs_data_set_obj(response, "settings", settings);
req->SendOKResponse(response);
obs_data_release(settings);
obs_data_release(response);
@ -1361,11 +1459,11 @@ void WSRequestHandler::HandleGetStreamSettings(WSRequestHandler* req) {
obs_service_t* service = obs_frontend_get_streaming_service();
const char* serviceType = obs_service_get_type(service);
obs_data_t* settings = obs_service_get_settings(service);
obs_data_t* response = obs_data_create();
obs_data_set_string(response, "type", serviceType);
obs_data_set_obj(response, "settings", settings);
req->SendOKResponse(response);
obs_data_release(settings);
obs_data_release(response);
@ -1638,7 +1736,7 @@ void WSRequestHandler::HandleSetRecordingFolder(WSRequestHandler* req) {
/**
* Get the path of the current recording folder.
*
* @return {Stsring} `rec-folder` Path of the recording folder.
* @return {String} `rec-folder` Path of the recording folder.
*
* @api requests
* @name GetRecordingFolder
@ -1799,37 +1897,37 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
obs_data_t* settings = obs_source_get_settings(sceneItemSource);
if (req->hasField("align")) {
obs_data_set_string(settings, "align",
obs_data_set_string(settings, "align",
obs_data_get_string(req->data, "align"));
}
if (req->hasField("bk_color")) {
obs_data_set_int(settings, "bk_color",
obs_data_set_int(settings, "bk_color",
obs_data_get_int(req->data, "bk_color"));
}
if (req->hasField("bk-opacity")) {
obs_data_set_int(settings, "bk_opacity",
obs_data_set_int(settings, "bk_opacity",
obs_data_get_int(req->data, "bk_opacity"));
}
if (req->hasField("chatlog")) {
obs_data_set_bool(settings, "chatlog",
obs_data_set_bool(settings, "chatlog",
obs_data_get_bool(req->data, "chatlog"));
}
if (req->hasField("chatlog_lines")) {
obs_data_set_int(settings, "chatlog_lines",
obs_data_get_int(req->data, "chatlog_lines"));
}
if (req->hasField("color")) {
obs_data_set_int(settings, "color",
obs_data_set_int(settings, "color",
obs_data_get_int(req->data, "color"));
}
if (req->hasField("extents")) {
obs_data_set_bool(settings, "extents",
obs_data_set_bool(settings, "extents",
obs_data_get_bool(req->data, "extents"));
}
@ -1849,7 +1947,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
}
if (req->hasField("file")) {
obs_data_set_string(settings, "file",
obs_data_set_string(settings, "file",
obs_data_get_string(req->data, "file"));
}
@ -1869,7 +1967,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
}
if (obs_data_has_user_value(req_font_obj, "size")) {
obs_data_set_int(font_obj, "size",
obs_data_set_int(font_obj, "size",
obs_data_get_int(req_font_obj, "size"));
}
@ -1884,7 +1982,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
}
if (req->hasField("gradient")) {
obs_data_set_bool(settings, "gradient",
obs_data_set_bool(settings, "gradient",
obs_data_get_bool(req->data, "gradient"));
}
@ -1904,7 +2002,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
}
if (req->hasField("outline")) {
obs_data_set_bool(settings, "outline",
obs_data_set_bool(settings, "outline",
obs_data_get_bool(req->data, "outline"));
}
@ -1919,34 +2017,34 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
}
if (req->hasField("outline_opacity")) {
obs_data_set_int(settings, "outline_opacity",
obs_data_set_int(settings, "outline_opacity",
obs_data_get_int(req->data, "outline_opacity"));
}
if (req->hasField("read_from_file")) {
obs_data_set_bool(settings, "read_from_file",
obs_data_set_bool(settings, "read_from_file",
obs_data_get_bool(req->data, "read_from_file"));
}
if (req->hasField("text")) {
obs_data_set_string(settings, "text",
obs_data_set_string(settings, "text",
obs_data_get_string(req->data, "text"));
}
if (req->hasField("valign")) {
obs_data_set_string(settings, "valign",
obs_data_set_string(settings, "valign",
obs_data_get_string(req->data, "valign"));
}
if (req->hasField("vertical")) {
obs_data_set_bool(settings, "vertical",
obs_data_set_bool(settings, "vertical",
obs_data_get_bool(req->data, "vertical"));
}
obs_source_update(sceneItemSource, settings);
if (req->hasField("render")) {
obs_sceneitem_set_visible(sceneItem,
obs_sceneitem_set_visible(sceneItem,
obs_data_get_bool(req->data, "render"));
}
@ -1959,7 +2057,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req) {
} else {
req->SendErrorResponse("specified scene item doesn't exist");
}
obs_source_release(scene);
}
@ -2100,7 +2198,7 @@ void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req) {
obs_data_set_int(settings, "height",
obs_data_get_int(req->data, "height"));
}
if (req->hasField("fps")) {
obs_data_set_int(settings, "fps",
obs_data_get_int(req->data, "fps"));

5
WSRequestHandler.h
View File

@ -71,6 +71,11 @@ class WSRequestHandler : public QObject {
static void HandleStartRecording(WSRequestHandler* req);
static void HandleStopRecording(WSRequestHandler* req);
static void HandleStartStopReplayBuffer(WSRequestHandler* req);
static void HandleStartReplayBuffer(WSRequestHandler* req);
static void HandleStopReplayBuffer(WSRequestHandler* req);
static void HandleSaveReplayBuffer(WSRequestHandler* req);
static void HandleSetRecordingFolder(WSRequestHandler* req);
static void HandleGetRecordingFolder(WSRequestHandler* req);