obs-websocket/src/eventhandler/EventHandler.cpp

/*
obs-websocket
Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program. If not, see <https://www.gnu.org/licenses/>
*/

#include "EventHandler.h"

EventHandler::EventHandler()
	: _obsLoaded(false),
	  _inputVolumeMetersRef(0),
	  _inputActiveStateChangedRef(0),
	  _inputShowStateChangedRef(0),
	  _sceneItemTransformChangedRef(0)
{
	blog_debug("[EventHandler::EventHandler] Setting up...");

	obs_frontend_add_event_callback(OnFrontendEvent, this);

	signal_handler_t *coreSignalHandler = obs_get_signal_handler();
	if (coreSignalHandler) {
		signal_handler_connect(coreSignalHandler, "source_create",
				       SourceCreatedMultiHandler, this);
		signal_handler_connect(coreSignalHandler, "source_destroy",
				       SourceDestroyedMultiHandler, this);
		signal_handler_connect(coreSignalHandler, "source_remove",
				       SourceRemovedMultiHandler, this);
		signal_handler_connect(coreSignalHandler, "source_rename",
				       SourceRenamedMultiHandler, this);
	} else {
		blog(LOG_ERROR,
		     "[EventHandler::EventHandler] Unable to get libobs signal handler!");
	}

	blog_debug("[EventHandler::EventHandler] Finished.");
}

EventHandler::~EventHandler()
{
	blog_debug("[EventHandler::~EventHandler] Shutting down...");

	obs_frontend_remove_event_callback(OnFrontendEvent, this);

	signal_handler_t *coreSignalHandler = obs_get_signal_handler();
	if (coreSignalHandler) {
		signal_handler_disconnect(coreSignalHandler, "source_create",
					  SourceCreatedMultiHandler, this);
		signal_handler_disconnect(coreSignalHandler, "source_destroy",
					  SourceDestroyedMultiHandler, this);
		signal_handler_disconnect(coreSignalHandler, "source_remove",
					  SourceRemovedMultiHandler, this);
		signal_handler_disconnect(coreSignalHandler, "source_rename",
					  SourceRenamedMultiHandler, this);
	} else {
		blog(LOG_ERROR,
		     "[EventHandler::~EventHandler] Unable to get libobs signal handler!");
	}

	blog_debug("[EventHandler::~EventHandler] Finished.");
}

void EventHandler::SetBroadcastCallback(EventHandler::BroadcastCallback cb)
{
	_broadcastCallback = cb;
}

void EventHandler::SetObsLoadedCallback(EventHandler::ObsLoadedCallback cb)
{
	_obsLoadedCallback = cb;
}

// Function to increment refcounts for high volume event subscriptions
void EventHandler::ProcessSubscription(uint64_t eventSubscriptions)
{
	if ((eventSubscriptions & EventSubscription::InputVolumeMeters) != 0) {
		if (_inputVolumeMetersRef.fetch_add(1) == 0) {
			if (_inputVolumeMetersHandler)
				blog(LOG_WARNING,
				     "[EventHandler::ProcessSubscription] Input volume meter handler already exists!");
			else
				_inputVolumeMetersHandler = std::make_unique<
					Utils::Obs::VolumeMeter::Handler>(
					std::bind(
						&EventHandler::
							HandleInputVolumeMeters,
						this, std::placeholders::_1));
		}
	}
	if ((eventSubscriptions & EventSubscription::InputActiveStateChanged) !=
	    0)
		_inputActiveStateChangedRef++;
	if ((eventSubscriptions & EventSubscription::InputShowStateChanged) !=
	    0)
		_inputShowStateChangedRef++;
	if ((eventSubscriptions &
	     EventSubscription::SceneItemTransformChanged) != 0)
		_sceneItemTransformChangedRef++;
}

// Function to decrement refcounts for high volume event subscriptions
void EventHandler::ProcessUnsubscription(uint64_t eventSubscriptions)
{
	if ((eventSubscriptions & EventSubscription::InputVolumeMeters) != 0) {
		if (_inputVolumeMetersRef.fetch_sub(1) == 1)
			_inputVolumeMetersHandler.reset();
	}
	if ((eventSubscriptions & EventSubscription::InputActiveStateChanged) !=
	    0)
		_inputActiveStateChangedRef--;
	if ((eventSubscriptions & EventSubscription::InputShowStateChanged) !=
	    0)
		_inputShowStateChangedRef--;
	if ((eventSubscriptions &
	     EventSubscription::SceneItemTransformChanged) != 0)
		_sceneItemTransformChangedRef--;
}

// Function required in order to use default arguments
void EventHandler::BroadcastEvent(uint64_t requiredIntent,
				  std::string eventType, json eventData,
				  uint8_t rpcVersion)
{
	if (!_broadcastCallback)
		return;

	_broadcastCallback(requiredIntent, eventType, eventData, rpcVersion);
}

// Connect source signals for Inputs, Scenes, and Transitions. Filters are automatically connected.
void EventHandler::ConnectSourceSignals(
	obs_source_t *source) // Applies to inputs and scenes
{
	if (!source || obs_source_removed(source))
		return;

	// Disconnect all existing signals from the source to prevent multiple connections
	DisconnectSourceSignals(source);

	signal_handler_t *sh = obs_source_get_signal_handler(source);

	obs_source_type sourceType = obs_source_get_type(source);

	// Inputs
	if (sourceType == OBS_SOURCE_TYPE_INPUT) {
		signal_handler_connect(sh, "activate",
				       HandleInputActiveStateChanged, this);
		signal_handler_connect(sh, "deactivate",
				       HandleInputActiveStateChanged, this);
		signal_handler_connect(sh, "show", HandleInputShowStateChanged,
				       this);
		signal_handler_connect(sh, "hide", HandleInputShowStateChanged,
				       this);
		signal_handler_connect(sh, "mute", HandleInputMuteStateChanged,
				       this);
		signal_handler_connect(sh, "volume", HandleInputVolumeChanged,
				       this);
		signal_handler_connect(sh, "audio_balance",
				       HandleInputAudioBalanceChanged, this);
		signal_handler_connect(sh, "audio_sync",
				       HandleInputAudioSyncOffsetChanged, this);
		signal_handler_connect(sh, "audio_mixers",
				       HandleInputAudioTracksChanged, this);
		signal_handler_connect(sh, "audio_monitoring",
				       HandleInputAudioMonitorTypeChanged,
				       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);
	}

	// Scenes
	if (sourceType == OBS_SOURCE_TYPE_SCENE) {
		signal_handler_connect(sh, "item_add", HandleSceneItemCreated,
				       this);
		signal_handler_connect(sh, "item_remove",
				       HandleSceneItemRemoved, this);
		signal_handler_connect(sh, "reorder",
				       HandleSceneItemListReindexed, this);
		signal_handler_connect(sh, "item_visible",
				       HandleSceneItemEnableStateChanged, this);
		signal_handler_connect(sh, "item_locked",
				       HandleSceneItemLockStateChanged, this);
		signal_handler_connect(sh, "item_select",
				       HandleSceneItemSelected, this);
		signal_handler_connect(sh, "item_transform",
				       HandleSceneItemTransformChanged, this);
	}

	// Scenes and Inputs
	if (sourceType == OBS_SOURCE_TYPE_INPUT ||
	    sourceType == OBS_SOURCE_TYPE_SCENE) {
		signal_handler_connect(sh, "reorder_filters",
				       HandleSourceFilterListReindexed, this);
		signal_handler_connect(sh, "filter_add", FilterAddMultiHandler,
				       this);
		signal_handler_connect(sh, "filter_remove",
				       FilterRemoveMultiHandler, this);
		auto enumFilters = [](obs_source_t *, obs_source_t *filter,
				      void *param) {
			auto eventHandler = static_cast<EventHandler *>(param);
			eventHandler->ConnectSourceSignals(filter);
		};
		obs_source_enum_filters(source, enumFilters, this);
	}

	// Transitions
	if (sourceType == OBS_SOURCE_TYPE_TRANSITION) {
		signal_handler_connect(sh, "transition_start",
				       HandleSceneTransitionStarted, this);
		signal_handler_connect(sh, "transition_stop",
				       HandleSceneTransitionEnded, this);
		signal_handler_connect(sh, "transition_video_stop",
				       HandleSceneTransitionVideoEnded, this);
	}

	// Filters
	if (sourceType == OBS_SOURCE_TYPE_FILTER) {
		signal_handler_connect(sh, "enable",
				       HandleSourceFilterEnableStateChanged,
				       this);
		signal_handler_connect(sh, "rename",
				       HandleSourceFilterNameChanged, this);
	}
}

// Disconnect source signals for Inputs, Scenes, and Transitions. Filters are automatically disconnected.
void EventHandler::DisconnectSourceSignals(obs_source_t *source)
{
	if (!source)
		return;

	signal_handler_t *sh = obs_source_get_signal_handler(source);

	obs_source_type sourceType = obs_source_get_type(source);

	// Inputs
	if (sourceType == OBS_SOURCE_TYPE_INPUT) {
		signal_handler_disconnect(sh, "activate",
					  HandleInputActiveStateChanged, this);
		signal_handler_disconnect(sh, "deactivate",
					  HandleInputActiveStateChanged, this);
		signal_handler_disconnect(sh, "show",
					  HandleInputShowStateChanged, this);
		signal_handler_disconnect(sh, "hide",
					  HandleInputShowStateChanged, this);
		signal_handler_disconnect(sh, "mute",
					  HandleInputMuteStateChanged, this);
		signal_handler_disconnect(sh, "volume",
					  HandleInputVolumeChanged, this);
		signal_handler_disconnect(sh, "audio_balance",
					  HandleInputAudioBalanceChanged, this);
		signal_handler_disconnect(sh, "audio_sync",
					  HandleInputAudioSyncOffsetChanged,
					  this);
		signal_handler_disconnect(sh, "audio_mixers",
					  HandleInputAudioTracksChanged, this);
		signal_handler_disconnect(sh, "audio_monitoring",
					  HandleInputAudioMonitorTypeChanged,
					  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);
	}

	// Scenes
	if (sourceType == OBS_SOURCE_TYPE_SCENE) {
		signal_handler_disconnect(sh, "item_add",
					  HandleSceneItemCreated, this);
		signal_handler_disconnect(sh, "item_remove",
					  HandleSceneItemRemoved, this);
		signal_handler_disconnect(sh, "reorder",
					  HandleSceneItemListReindexed, this);
		signal_handler_disconnect(sh, "item_visible",
					  HandleSceneItemEnableStateChanged,
					  this);
		signal_handler_disconnect(sh, "item_locked",
					  HandleSceneItemLockStateChanged,
					  this);
		signal_handler_disconnect(sh, "item_select",
					  HandleSceneItemSelected, this);
		signal_handler_disconnect(sh, "item_transform",
					  HandleSceneItemTransformChanged,
					  this);
	}

	// Inputs and Scenes
	if (sourceType == OBS_SOURCE_TYPE_INPUT ||
	    sourceType == OBS_SOURCE_TYPE_SCENE) {
		signal_handler_disconnect(sh, "reorder_filters",
					  HandleSourceFilterListReindexed,
					  this);
		signal_handler_disconnect(sh, "filter_add",
					  FilterAddMultiHandler, this);
		signal_handler_disconnect(sh, "filter_remove",
					  FilterRemoveMultiHandler, this);
		auto enumFilters = [](obs_source_t *, obs_source_t *filter,
				      void *param) {
			auto eventHandler = static_cast<EventHandler *>(param);
			eventHandler->DisconnectSourceSignals(filter);
		};
		obs_source_enum_filters(source, enumFilters, this);
	}

	// Transitions
	if (sourceType == OBS_SOURCE_TYPE_TRANSITION) {
		signal_handler_disconnect(sh, "transition_start",
					  HandleSceneTransitionStarted, this);
		signal_handler_disconnect(sh, "transition_stop",
					  HandleSceneTransitionEnded, this);
		signal_handler_disconnect(sh, "transition_video_stop",
					  HandleSceneTransitionVideoEnded,
					  this);
	}

	// Filters
	if (sourceType == OBS_SOURCE_TYPE_FILTER) {
		signal_handler_disconnect(sh, "enable",
					  HandleSourceFilterEnableStateChanged,
					  this);
		signal_handler_disconnect(sh, "rename",
					  HandleSourceFilterNameChanged, this);
	}
}

void EventHandler::OnFrontendEvent(enum obs_frontend_event event,
				   void *private_data)
{
	auto eventHandler = static_cast<EventHandler *>(private_data);

	if (!eventHandler->_obsLoaded.load() &&
	    event != OBS_FRONTEND_EVENT_FINISHED_LOADING)
		return;

	switch (event) {
	// General
	case OBS_FRONTEND_EVENT_FINISHED_LOADING:
		blog_debug(
			"[EventHandler::OnFrontendEvent] OBS has finished loading. Connecting final handlers and enabling events...");

		// Connect source signals and enable events only after OBS has fully loaded (to reduce extra logging).
		eventHandler->_obsLoaded.store(true);

		// In the case that plugins become hotloadable, this will have to go back into `EventHandler::EventHandler()`
		// Enumerate inputs and connect each one
		{
			auto enumInputs = [](void *param,
					     obs_source_t *source) {
				auto eventHandler =
					static_cast<EventHandler *>(param);
				eventHandler->ConnectSourceSignals(source);
				return true;
			};
			obs_enum_sources(enumInputs, private_data);
		}

		// Enumerate scenes and connect each one
		{
			auto enumScenes = [](void *param,
					     obs_source_t *source) {
				auto eventHandler =
					static_cast<EventHandler *>(param);
				eventHandler->ConnectSourceSignals(source);
				return true;
			};
			obs_enum_scenes(enumScenes, private_data);
		}

		// Enumerate all scene transitions and connect each one
		{
			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);
			for (size_t i = 0; i < transitions.sources.num; i++) {
				obs_source_t *transition =
					transitions.sources.array[i];
				eventHandler->ConnectSourceSignals(transition);
			}
			obs_frontend_source_list_free(&transitions);
		}

		blog_debug("[EventHandler::OnFrontendEvent] Finished.");

		if (eventHandler->_obsLoadedCallback)
			eventHandler->_obsLoadedCallback();

		break;
	case OBS_FRONTEND_EVENT_EXIT:
		eventHandler->HandleExitStarted();

		blog_debug(
			"[EventHandler::OnFrontendEvent] OBS is unloading. Disabling events...");
		// Disconnect source signals and disable events when OBS starts unloading (to reduce extra logging).
		eventHandler->_obsLoaded.store(false);

		// In the case that plugins become hotloadable, this will have to go back into `EventHandler::~EventHandler()`
		// Enumerate inputs and disconnect each one
		{
			auto enumInputs = [](void *param,
					     obs_source_t *source) {
				auto eventHandler =
					static_cast<EventHandler *>(param);
				eventHandler->DisconnectSourceSignals(source);
				return true;
			};
			obs_enum_sources(enumInputs, private_data);
		}

		// Enumerate scenes and disconnect each one
		{
			auto enumScenes = [](void *param,
					     obs_source_t *source) {
				auto eventHandler =
					static_cast<EventHandler *>(param);
				eventHandler->DisconnectSourceSignals(source);
				return true;
			};
			obs_enum_scenes(enumScenes, private_data);
		}

		// Enumerate all scene transitions and disconnect each one
		{
			obs_frontend_source_list transitions = {};
			obs_frontend_get_transitions(&transitions);
			for (size_t i = 0; i < transitions.sources.num; i++) {
				obs_source_t *transition =
					transitions.sources.array[i];
				eventHandler->DisconnectSourceSignals(
					transition);
			}
			obs_frontend_source_list_free(&transitions);
		}

		blog_debug("[EventHandler::OnFrontendEvent] Finished.");

		break;
	case OBS_FRONTEND_EVENT_STUDIO_MODE_ENABLED:
		eventHandler->HandleStudioModeStateChanged(true);
		break;
	case OBS_FRONTEND_EVENT_STUDIO_MODE_DISABLED:
		eventHandler->HandleStudioModeStateChanged(false);
		break;

	// Config
	case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING: {
		obs_frontend_source_list transitions = {};
		obs_frontend_get_transitions(&transitions);
		for (size_t i = 0; i < transitions.sources.num; i++) {
			obs_source_t *transition = transitions.sources.array[i];
			eventHandler->DisconnectSourceSignals(transition);
		}
		obs_frontend_source_list_free(&transitions);
	}
		eventHandler->HandleCurrentSceneCollectionChanging();
		break;
	case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED: {
		obs_frontend_source_list transitions = {};
		obs_frontend_get_transitions(&transitions);
		for (size_t i = 0; i < transitions.sources.num; i++) {
			obs_source_t *transition = transitions.sources.array[i];
			eventHandler->ConnectSourceSignals(transition);
		}
		obs_frontend_source_list_free(&transitions);
	}
		eventHandler->HandleCurrentSceneCollectionChanged();
		break;
	case OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED:
		eventHandler->HandleSceneCollectionListChanged();
		break;
	case OBS_FRONTEND_EVENT_PROFILE_CHANGING:
		eventHandler->HandleCurrentProfileChanging();
		break;
	case OBS_FRONTEND_EVENT_PROFILE_CHANGED:
		eventHandler->HandleCurrentProfileChanged();
		break;
	case OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED:
		eventHandler->HandleProfileListChanged();
		break;

	// Scenes
	case OBS_FRONTEND_EVENT_SCENE_CHANGED:
		eventHandler->HandleCurrentProgramSceneChanged();
		break;
	case OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED:
		eventHandler->HandleCurrentPreviewSceneChanged();
		break;
	case OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED:
		eventHandler->HandleSceneListChanged();
		break;

	// Transitions
	case OBS_FRONTEND_EVENT_TRANSITION_CHANGED:
		eventHandler->HandleCurrentSceneTransitionChanged();
		break;
	case OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED: {
		obs_frontend_source_list transitions = {};
		obs_frontend_get_transitions(&transitions);
		for (size_t i = 0; i < transitions.sources.num; i++) {
			obs_source_t *transition = transitions.sources.array[i];
			eventHandler->ConnectSourceSignals(transition);
		}
		obs_frontend_source_list_free(&transitions);
	} break;
	case OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED:
		eventHandler->HandleCurrentSceneTransitionDurationChanged();
		break;

	// Outputs
	case OBS_FRONTEND_EVENT_STREAMING_STARTING:
		eventHandler->HandleStreamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTING);
		break;
	case OBS_FRONTEND_EVENT_STREAMING_STARTED:
		eventHandler->HandleStreamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTED);
		break;
	case OBS_FRONTEND_EVENT_STREAMING_STOPPING:
		eventHandler->HandleStreamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPING);
		break;
	case OBS_FRONTEND_EVENT_STREAMING_STOPPED:
		eventHandler->HandleStreamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPED);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_STARTING:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTING);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_STARTED:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTED);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_STOPPING:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPING);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPED);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_PAUSED:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_PAUSED);
		break;
	case OBS_FRONTEND_EVENT_RECORDING_UNPAUSED:
		eventHandler->HandleRecordStateChanged(
			OBS_WEBSOCKET_OUTPUT_RESUMED);
		break;
	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING:
		eventHandler->HandleReplayBufferStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTING);
		break;
	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED:
		eventHandler->HandleReplayBufferStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTED);
		break;
	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING:
		eventHandler->HandleReplayBufferStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPING);
		break;
	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED:
		eventHandler->HandleReplayBufferStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPED);
		break;
	case OBS_FRONTEND_EVENT_VIRTUALCAM_STARTED:
		eventHandler->HandleVirtualcamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STARTED);
		break;
	case OBS_FRONTEND_EVENT_VIRTUALCAM_STOPPED:
		eventHandler->HandleVirtualcamStateChanged(
			OBS_WEBSOCKET_OUTPUT_STOPPED);
		break;
	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED:
		eventHandler->HandleReplayBufferSaved();
		break;

	default:
		break;
	}
}

// Only called for creation of a public source
void EventHandler::SourceCreatedMultiHandler(void *param, calldata_t *data)
{
	auto eventHandler = static_cast<EventHandler *>(param);

	// Don't react to signals until OBS has finished loading
	if (!eventHandler->_obsLoaded.load())
		return;

	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
	if (!source)
		return;

	eventHandler->ConnectSourceSignals(source);

	switch (obs_source_get_type(source)) {
	case OBS_SOURCE_TYPE_INPUT:
		eventHandler->HandleInputCreated(source);
		break;
	case OBS_SOURCE_TYPE_SCENE:
		eventHandler->HandleSceneCreated(source);
		break;
	default:
		break;
	}
}

// Only called for destruction of a public sourcs
// Used as a fallback if an input/scene is not explicitly removed
void EventHandler::SourceDestroyedMultiHandler(void *param, calldata_t *data)
{
	auto eventHandler = static_cast<EventHandler *>(param);

	// We can't use any smart types here because releasing the source will cause infinite recursion
	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
	if (!source)
		return;

	// Disconnect all signals from the source
	eventHandler->DisconnectSourceSignals(source);

	// Don't react to signals if OBS is unloading
	if (!eventHandler->_obsLoaded.load())
		return;

	switch (obs_source_get_type(source)) {
	case OBS_SOURCE_TYPE_INPUT:
		// Only emit removed if the input has not already been removed. This is the case when removing the last scene item of an input.
		if (!obs_source_removed(source))
			eventHandler->HandleInputRemoved(source);
		break;
	case OBS_SOURCE_TYPE_SCENE:
		// Only emit removed if the scene has not already been removed.
		if (!obs_source_removed(source))
			eventHandler->HandleSceneRemoved(source);
		break;
	default:
		break;
	}
}

// We prefer remove signals over destroy signals because they are more time-accurate.
// For example, if an input is "removed" but there is a dangling ref, you still want to know that it shouldn't exist, but it's not guaranteed to be destroyed.
void EventHandler::SourceRemovedMultiHandler(void *param, calldata_t *data)
{
	auto eventHandler = static_cast<EventHandler *>(param);

	if (!eventHandler->_obsLoaded.load())
		return;

	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
	if (!source)
		return;

	switch (obs_source_get_type(source)) {
	case OBS_SOURCE_TYPE_INPUT:
		eventHandler->HandleInputRemoved(source);
		break;
	case OBS_SOURCE_TYPE_SCENE:
		eventHandler->HandleSceneRemoved(source);
		break;
	default:
		break;
	}
}

void EventHandler::SourceRenamedMultiHandler(void *param, calldata_t *data)
{
	auto eventHandler = static_cast<EventHandler *>(param);

	if (!eventHandler->_obsLoaded.load())
		return;

	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
	if (!source)
		return;

	std::string oldSourceName = calldata_string(data, "prev_name");
	std::string sourceName = calldata_string(data, "new_name");
	if (oldSourceName.empty() || sourceName.empty())
		return;

	switch (obs_source_get_type(source)) {
	case OBS_SOURCE_TYPE_INPUT:
		eventHandler->HandleInputNameChanged(source, oldSourceName,
						     sourceName);
		break;
	case OBS_SOURCE_TYPE_TRANSITION:
		break;
	case OBS_SOURCE_TYPE_SCENE:
		eventHandler->HandleSceneNameChanged(source, oldSourceName,
						     sourceName);
		break;
	default:
		break;
	}
}