EventHandler: Add media input events

src/eventhandler/EventHandler.cpp

@@ -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)) {

src/eventhandler/EventHandler.h

@@ -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);
 };

src/eventhandler/EventHandler_MediaInputs.cpp

@@ -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);
+}