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

EventHandler: Add media input events

Browse Source
This commit is contained in:
tt2468 2021-05-31 21:44:03 -07:00
parent 6c03b86514
commit 19375921d3
3 changed files with 175 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/eventhandler/EventHandler.cpp
View File

@ -72,6 +72,14 @@ void EventHandler::ConnectSourceSignals(obs_source_t *source) // These signals a
signal_handler_connect(sh, "volume", HandleInputVolumeChanged, this);
signal_handler_connect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
signal_handler_connect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
signal_handler_connect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
signal_handler_connect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
signal_handler_connect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
signal_handler_connect(sh, "media_play", SourceMediaPlayMultiHandler, this);
signal_handler_connect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
signal_handler_connect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
signal_handler_connect(sh, "media_next", SourceMediaNextMultiHandler, this);
signal_handler_connect(sh, "media_previous", SourceMediaPreviousMultiHandler, this);
}
void EventHandler::DisconnectSourceSignals(obs_source_t *source)
@ -90,6 +98,14 @@ void EventHandler::DisconnectSourceSignals(obs_source_t *source)
signal_handler_disconnect(sh, "volume", HandleInputVolumeChanged, this);
signal_handler_disconnect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
signal_handler_disconnect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
signal_handler_disconnect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
signal_handler_disconnect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
signal_handler_disconnect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
signal_handler_disconnect(sh, "media_play", SourceMediaPlayMultiHandler, this);
signal_handler_disconnect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
signal_handler_disconnect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
signal_handler_disconnect(sh, "media_next", SourceMediaNextMultiHandler, this);
signal_handler_disconnect(sh, "media_previous", SourceMediaPreviousMultiHandler, this);
}
void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_data)
@ -230,7 +246,7 @@ void EventHandler::SourceCreatedMultiHandler(void *param, calldata_t *data)
if (!source)
return;
// Connect all signals from the source
// Connect all signals to the source
eventHandler->ConnectSourceSignals(source);
switch (obs_source_get_type(source)) {

20
src/eventhandler/EventHandler.h
View File

@ -17,6 +17,15 @@ enum ObsOutputState {
OBS_WEBSOCKET_OUTPUT_RESUMED
};
enum ObsMediaInputAction {
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE,
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY,
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART,
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP,
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT,
OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS
};
template <typename T> T* GetCalldataPointer(const calldata_t *data, const char* name) {
void* ptr = nullptr;
calldata_get_ptr(data, name, &ptr);
@ -50,6 +59,12 @@ class EventHandler
// Signal handler: source
static void SourceRenamedMultiHandler(void *param, calldata_t *data);
static void SourceMediaPauseMultiHandler(void *param, calldata_t *data);
static void SourceMediaPlayMultiHandler(void *param, calldata_t *data);
static void SourceMediaRestartMultiHandler(void *param, calldata_t *data);
static void SourceMediaStopMultiHandler(void *param, calldata_t *data);
static void SourceMediaNextMultiHandler(void *param, calldata_t *data);
static void SourceMediaPreviousMultiHandler(void *param, calldata_t *data);
// General
@ -91,4 +106,9 @@ class EventHandler
void HandleRecordStateChanged(ObsOutputState state);
void HandleReplayBufferStateChanged(ObsOutputState state);
void HandleVirtualcamStateChanged(ObsOutputState state);
// Media Inputs
static void HandleMediaInputPlaybackStarted(void *param, calldata_t *data); // Direct callback
static void HandleMediaInputPlaybackEnded(void *param, calldata_t *data); // Direct callback
void HandleMediaInputActionTriggered(obs_source_t *source, ObsMediaInputAction action);
};

138
src/eventhandler/EventHandler_MediaInputs.cpp
View File

@ -1,3 +1,141 @@
#include "EventHandler.h"
#include "../plugin-macros.generated.h"
#define CASE(x) case x: return #x;
std::string GetMediaInputActionString(ObsMediaInputAction action) {
switch (action) {
default:
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE)
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY)
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART)
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP)
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT)
CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS)
}
}
void EventHandler::SourceMediaPauseMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE);
}
void EventHandler::SourceMediaPlayMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY);
}
void EventHandler::SourceMediaRestartMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART);
}
void EventHandler::SourceMediaStopMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP);
}
void EventHandler::SourceMediaNextMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT);
}
void EventHandler::SourceMediaPreviousMultiHandler(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
eventHandler->HandleMediaInputActionTriggered(source, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS);
}
void EventHandler::HandleMediaInputPlaybackStarted(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
json eventData;
eventData["inputName"] = obs_source_get_name(source);
eventHandler->_webSocketServer->BroadcastEvent(EventSubscription::MediaInputs, "MediaInputPlaybackStarted", eventData);
}
void EventHandler::HandleMediaInputPlaybackEnded(void *param, calldata_t *data)
{
auto eventHandler = reinterpret_cast<EventHandler*>(param);
OBSSource source = GetCalldataPointer<obs_source_t>(data, "source");
if (!source)
return;
if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
return;
json eventData;
eventData["inputName"] = obs_source_get_name(source);
eventHandler->_webSocketServer->BroadcastEvent(EventSubscription::MediaInputs, "MediaInputPlaybackEnded", eventData);
}
void EventHandler::HandleMediaInputActionTriggered(obs_source_t *source, ObsMediaInputAction action)
{
json eventData;
eventData["inputName"] = obs_source_get_name(source);
eventData["mediaAction"] = GetMediaInputActionString(action);
_webSocketServer->BroadcastEvent(EventSubscription::MediaInputs, "MediaInputActionTriggered", eventData);
}