libobs, frontend: Update monitoring to bool and add hotkey

docs/sphinx/reference-sources.rst

@@ -1210,6 +1210,9 @@ General Source Functions
 .. function:: void obs_source_set_monitoring_type(obs_source_t *source, enum obs_monitoring_type type)
               enum obs_monitoring_type obs_source_get_monitoring_type(obs_source_t *source)
 
+   .. deprecated:: 33.0
+   Use :c:func:`obs_source_set_monitoring_enabled` and :c:func:`obs_source_get_monitoring_enabled` instead.
+
    Sets/gets the desktop audio monitoring type.
 
    :param order: | OBS_MONITORING_TYPE_NONE - Do not monitor
@@ -1218,6 +1221,16 @@ General Source Functions
 
 ---------------------
 
+.. function:: void obs_source_set_monitoring_enabled(obs_source_t *source, bool enable)
+              bool obs_source_get_monitoring_enabled(const obs_source_t *source)
+
+
+   Sets/gets the audio monitoring enabled state for the source.
+
+   .. versionadded:: 33.0
+
+---------------------
+
 .. function:: void obs_source_set_audio_active(obs_source_t *source, bool active)
               bool obs_source_audio_active(const obs_source_t *source)
 

frontend/components/OBSAdvAudioCtrl.cpp

@@ -40,9 +40,8 @@ OBSAdvAudioCtrl::OBSAdvAudioCtrl(QGridLayout *, obs_source_t *source_) : source(
 	percent = new QSpinBox();
 	forceMono = new QCheckBox();
 	balance = new BalanceSlider();
-	if (obs_audio_monitoring_available()) {
-		monitoringType = new QComboBox();
-	}
+	monitoringCheckBox = new QCheckBox();
+
 	syncOffset = new QSpinBox();
 	mixer1 = new QCheckBox();
 	mixer2 = new QCheckBox();
@@ -58,9 +57,7 @@ OBSAdvAudioCtrl::OBSAdvAudioCtrl(QGridLayout *, obs_source_t *source_) : source(
 	sigs.emplace_back(handler, "volume", OBSSourceVolumeChanged, this);
 	sigs.emplace_back(handler, "audio_sync", OBSSourceSyncChanged, this);
 	sigs.emplace_back(handler, "update_flags", OBSSourceFlagsChanged, this);
-	if (obs_audio_monitoring_available()) {
-		sigs.emplace_back(handler, "audio_monitoring", OBSSourceMonitoringTypeChanged, this);
-	}
+	sigs.emplace_back(handler, "monitor", OBSSourceMonitoringChanged, this);
 	sigs.emplace_back(handler, "audio_mixers", OBSSourceMixersChanged, this);
 	sigs.emplace_back(handler, "audio_balance", OBSSourceBalanceChanged, this);
 	sigs.emplace_back(handler, "rename", OBSSourceRenamed, this);
@@ -152,19 +149,11 @@ OBSAdvAudioCtrl::OBSAdvAudioCtrl(QGridLayout *, obs_source_t *source_) : source(
 	syncOffset->setFixedWidth(100);
 	syncOffset->setAccessibleName(QTStr("Basic.AdvAudio.SyncOffsetSource").arg(sourceName));
 
-	int idx;
-	if (obs_audio_monitoring_available()) {
-		monitoringType->addItem(QTStr("Basic.AdvAudio.Monitoring.None"), (int)OBS_MONITORING_TYPE_NONE);
-		monitoringType->addItem(QTStr("Basic.AdvAudio.Monitoring.MonitorOnly"),
-					(int)OBS_MONITORING_TYPE_MONITOR_ONLY);
-		monitoringType->addItem(QTStr("Basic.AdvAudio.Monitoring.Both"),
-					(int)OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT);
-		int mt = (int)obs_source_get_monitoring_type(source);
-		idx = monitoringType->findData(mt);
-		monitoringType->setCurrentIndex(idx);
-		monitoringType->setAccessibleName(QTStr("Basic.AdvAudio.MonitoringSource").arg(sourceName));
-		monitoringType->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
-	}
+	monitoringCheckBox->setEnabled(obs_audio_monitoring_available());
+	monitoringCheckBox->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
+	monitoringCheckBox->setText(QTStr("Enable"));
+	monitoringCheckBox->setChecked(obs_source_get_monitoring_enabled(source));
+	monitoringCheckBox->setAccessibleName(QTStr("Basic.AdvAudio.MonitoringSource").arg(sourceName));
 
 	mixer1->setText("1");
 	mixer1->setChecked(mixers & (1 << 0));
@@ -209,9 +198,7 @@ OBSAdvAudioCtrl::OBSAdvAudioCtrl(QGridLayout *, obs_source_t *source_) : source(
 	connect(balance, &BalanceSlider::valueChanged, this, &OBSAdvAudioCtrl::balanceChanged);
 	connect(balance, &BalanceSlider::doubleClicked, this, &OBSAdvAudioCtrl::ResetBalance);
 	connect(syncOffset, &QSpinBox::valueChanged, this, &OBSAdvAudioCtrl::syncOffsetChanged);
-	if (obs_audio_monitoring_available()) {
-		connect(monitoringType, &QComboBox::currentIndexChanged, this, &OBSAdvAudioCtrl::monitoringTypeChanged);
-	}
+	connect(monitoringCheckBox, &QCheckBox::toggled, this, &OBSAdvAudioCtrl::monitoringChanged);
 
 	auto connectMixer = [this](QCheckBox *mixer, int num) {
 		connect(mixer, &QCheckBox::clicked, this,
@@ -236,9 +223,7 @@ OBSAdvAudioCtrl::~OBSAdvAudioCtrl()
 	forceMono->deleteLater();
 	balanceContainer->deleteLater();
 	syncOffset->deleteLater();
-	if (obs_audio_monitoring_available()) {
-		monitoringType->deleteLater();
-	}
+	monitoringCheckBox->deleteLater();
 	mixerContainer->deleteLater();
 }
 
@@ -254,9 +239,7 @@ void OBSAdvAudioCtrl::ShowAudioControl(QGridLayout *layout)
 	layout->addWidget(forceMono, lastRow, idx++);
 	layout->addWidget(balanceContainer, lastRow, idx++);
 	layout->addWidget(syncOffset, lastRow, idx++);
-	if (obs_audio_monitoring_available()) {
-		layout->addWidget(monitoringType, lastRow, idx++);
-	}
+	layout->addWidget(monitoringCheckBox, lastRow, idx++);
 	layout->addWidget(mixerContainer, lastRow, idx++);
 	layout->layout()->setAlignment(mixerContainer, Qt::AlignVCenter);
 	layout->setHorizontalSpacing(15);
@@ -293,11 +276,11 @@ void OBSAdvAudioCtrl::OBSSourceSyncChanged(void *param, calldata_t *calldata)
 	QMetaObject::invokeMethod(static_cast<OBSAdvAudioCtrl *>(param), "SourceSyncChanged", Q_ARG(int64_t, offset));
 }
 
-void OBSAdvAudioCtrl::OBSSourceMonitoringTypeChanged(void *param, calldata_t *calldata)
+void OBSAdvAudioCtrl::OBSSourceMonitoringChanged(void *param, calldata_t *calldata)
 {
-	int type = calldata_int(calldata, "type");
-	QMetaObject::invokeMethod(static_cast<OBSAdvAudioCtrl *>(param), "SourceMonitoringTypeChanged",
-				  Q_ARG(int, type));
+	bool enabled = calldata_bool(calldata, "monitor");
+	QMetaObject::invokeMethod(static_cast<OBSAdvAudioCtrl *>(param), "SourceMonitoringChanged",
+				  Q_ARG(bool, enabled));
 }
 
 void OBSAdvAudioCtrl::OBSSourceMixersChanged(void *param, calldata_t *calldata)
@@ -371,12 +354,11 @@ void OBSAdvAudioCtrl::SourceSyncChanged(int64_t offset)
 	syncOffset->blockSignals(false);
 }
 
-void OBSAdvAudioCtrl::SourceMonitoringTypeChanged(int type)
+void OBSAdvAudioCtrl::SourceMonitoringChanged(bool enabled)
 {
-	int idx = monitoringType->findData(type);
-	monitoringType->blockSignals(true);
-	monitoringType->setCurrentIndex(idx);
-	monitoringType->blockSignals(false);
+	monitoringCheckBox->blockSignals(true);
+	monitoringCheckBox->setChecked(enabled);
+	monitoringCheckBox->blockSignals(false);
 }
 
 void OBSAdvAudioCtrl::SourceMixersChanged(uint32_t mixers)
@@ -531,39 +513,25 @@ void OBSAdvAudioCtrl::syncOffsetChanged(int milliseconds)
 					   std::bind(undo_redo, std::placeholders::_1, val), uuid, uuid, true);
 }
 
-void OBSAdvAudioCtrl::monitoringTypeChanged(int index)
+void OBSAdvAudioCtrl::monitoringChanged(bool enabled)
 {
-	obs_monitoring_type prev = obs_source_get_monitoring_type(source);
+	bool prev = obs_source_get_monitoring_enabled(source);
 
-	obs_monitoring_type mt = (obs_monitoring_type)monitoringType->itemData(index).toInt();
-	obs_source_set_monitoring_type(source, mt);
-
-	const char *type = nullptr;
-
-	switch (mt) {
-	case OBS_MONITORING_TYPE_NONE:
-		type = "none";
-		break;
-	case OBS_MONITORING_TYPE_MONITOR_ONLY:
-		type = "monitor only";
-		break;
-	case OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT:
-		type = "monitor and output";
-		break;
-	}
+	obs_source_set_monitoring_enabled(source, enabled);
 
 	const char *name = obs_source_get_name(source);
-	blog(LOG_INFO, "User changed audio monitoring for source '%s' to: %s", name ? name : "(null)", type);
+	blog(LOG_INFO, "User changed audio monitoring for source '%s' to: %s", name ? name : "(null)",
+	     enabled ? "true" : " false");
 
-	auto undo_redo = [](const std::string &uuid, obs_monitoring_type val) {
+	auto undo_redo = [](const std::string &uuid, bool val) {
 		OBSSourceAutoRelease source = obs_get_source_by_uuid(uuid.c_str());
-		obs_source_set_monitoring_type(source, val);
+		obs_source_set_monitoring_enabled(source, val);
 	};
 
 	const char *uuid = obs_source_get_uuid(source);
 	OBSBasic::Get()->undo_s.add_action(QTStr("Undo.MonitoringType.Change").arg(name),
 					   std::bind(undo_redo, std::placeholders::_1, prev),
-					   std::bind(undo_redo, std::placeholders::_1, mt), uuid, uuid);
+					   std::bind(undo_redo, std::placeholders::_1, enabled), uuid, uuid);
 }
 
 static inline void setMixer(obs_source_t *source, const int mixerIdx, const bool checked)

frontend/components/OBSAdvAudioCtrl.hpp

@@ -40,7 +40,7 @@ class OBSAdvAudioCtrl : public QObject {
 	QPointer<QLabel> labelL;
 	QPointer<QLabel> labelR;
 	QPointer<QSpinBox> syncOffset;
-	QPointer<QComboBox> monitoringType;
+	QPointer<QCheckBox> monitoringCheckBox;
 	QPointer<QCheckBox> mixer1;
 	QPointer<QCheckBox> mixer2;
 	QPointer<QCheckBox> mixer3;
@@ -55,7 +55,7 @@ class OBSAdvAudioCtrl : public QObject {
 	static void OBSSourceFlagsChanged(void *param, calldata_t *calldata);
 	static void OBSSourceVolumeChanged(void *param, calldata_t *calldata);
 	static void OBSSourceSyncChanged(void *param, calldata_t *calldata);
-	static void OBSSourceMonitoringTypeChanged(void *param, calldata_t *calldata);
+	static void OBSSourceMonitoringChanged(void *param, calldata_t *calldata);
 	static void OBSSourceMixersChanged(void *param, calldata_t *calldata);
 	static void OBSSourceBalanceChanged(void *param, calldata_t *calldata);
 	static void OBSSourceRenamed(void *param, calldata_t *calldata);
@@ -75,7 +75,7 @@ public slots:
 	void SourceFlagsChanged(uint32_t flags);
 	void SourceVolumeChanged(float volume);
 	void SourceSyncChanged(int64_t offset);
-	void SourceMonitoringTypeChanged(int type);
+	void SourceMonitoringChanged(bool enabled);
 	void SourceMixersChanged(uint32_t mixers);
 	void SourceBalanceChanged(int balance);
 	void SetSourceName(QString newName);
@@ -85,6 +85,6 @@ public slots:
 	void downmixMonoChanged(bool checked);
 	void balanceChanged(int val);
 	void syncOffsetChanged(int milliseconds);
-	void monitoringTypeChanged(int index);
+	void monitoringChanged(bool enabled);
 	void ResetBalance();
 };

frontend/components/VolumeControl.cpp

@@ -16,9 +16,8 @@ namespace {
 bool isSourceUnassigned(obs_source_t *source)
 {
 	uint32_t mixes = (obs_source_get_audio_mixers(source) & ((1 << MAX_AUDIO_MIXES) - 1));
-	obs_monitoring_type mt = obs_source_get_monitoring_type(source);
 
-	return mixes == 0 && mt != OBS_MONITORING_TYPE_MONITOR_ONLY;
+	return mixes == 0;
 }
 
 void showUnassignedWarning(const char *name)
@@ -97,7 +96,7 @@ VolumeControl::VolumeControl(obs_source_t *source, QWidget *parent, bool vertica
 
 	obsMuted = obs_source_muted(source);
 	bool unassigned = isSourceUnassigned(source);
-	obsMonitoringType = obs_source_get_monitoring_type(source);
+	obsMonitoring = obs_source_get_monitoring_enabled(source);
 
 	volumeMeter->setMuted(obsMuted || unassigned);
 
@@ -109,7 +108,7 @@ VolumeControl::VolumeControl(obs_source_t *source, QWidget *parent, bool vertica
 	obsSignals.reserve(9);
 	obsSignals.emplace_back(obs_source_get_signal_handler(source), "mute", obsVolumeMuted, this);
 	obsSignals.emplace_back(obs_source_get_signal_handler(source), "audio_mixers", obsMixersChanged, this);
-	obsSignals.emplace_back(obs_source_get_signal_handler(source), "audio_monitoring", obsMonitoringChanged, this);
+	obsSignals.emplace_back(obs_source_get_signal_handler(source), "monitor", obsMonitoringChanged, this);
 	obsSignals.emplace_back(obs_source_get_signal_handler(source), "activate", VolumeControl::obsSourceActivated,
 				this);
 	obsSignals.emplace_back(obs_source_get_signal_handler(source), "deactivate",
@@ -218,9 +217,9 @@ void VolumeControl::obsMixersChanged(void *data, calldata_t *)
 void VolumeControl::obsMonitoringChanged(void *data, calldata_t *params)
 {
 	VolumeControl *volControl = static_cast<VolumeControl *>(data);
-	auto type = static_cast<int>(calldata_int(params, "type"));
+	bool enable = calldata_bool(params, "monitor");
 
-	QMetaObject::invokeMethod(volControl, "onMonitoringChanged", Qt::QueuedConnection, Q_ARG(int, type));
+	QMetaObject::invokeMethod(volControl, "onMonitoringChanged", Qt::QueuedConnection, Q_ARG(bool, enable));
 }
 
 void VolumeControl::obsSourceActivated(void *data, calldata_t *)
@@ -608,9 +607,9 @@ void VolumeControl::onMuteChanged(bool muted)
 	processMixerState();
 }
 
-void VolumeControl::onMonitoringChanged(int type)
+void VolumeControl::onMonitoringChanged(bool enabled)
 {
-	obsMonitoringType = static_cast<obs_monitoring_type>(type);
+	obsMonitoring = enabled;
 	processMixerState();
 }
 
@@ -719,27 +718,26 @@ void VolumeControl::setMuted(bool mute)
 					   std::bind(undo_redo, std::placeholders::_1, mute), uuid, uuid);
 }
 
-void VolumeControl::setMonitoring(obs_monitoring_type type)
+void VolumeControl::setMonitoring(bool enabled)
 {
 	OBSSource source = OBSGetStrongRef(weakSource());
 	if (!source) {
 		return;
 	}
 
-	obs_monitoring_type prevMonitoringType = obs_source_get_monitoring_type(source);
-	obs_source_set_monitoring_type(source, type);
+	bool prevMonitoring = obs_source_get_monitoring_enabled(source);
+	obs_source_set_monitoring_enabled(source, enabled);
 
-	auto undo_redo = [](const std::string &uuid, obs_monitoring_type val) {
+	auto undo_redo = [](const std::string &uuid, bool val) {
 		OBSSourceAutoRelease source = obs_get_source_by_uuid(uuid.c_str());
-		obs_source_set_monitoring_type(source, val);
+		obs_source_set_monitoring_enabled(source, val);
 	};
 
 	QString text = QTStr("Undo.MonitoringType.Change");
 
 	const char *name = obs_source_get_name(source);
-	OBSBasic::Get()->undo_s.add_action(text.arg(name),
-					   std::bind(undo_redo, std::placeholders::_1, prevMonitoringType),
-					   std::bind(undo_redo, std::placeholders::_1, type), uuid, uuid);
+	OBSBasic::Get()->undo_s.add_action(text.arg(name), std::bind(undo_redo, std::placeholders::_1, prevMonitoring),
+					   std::bind(undo_redo, std::placeholders::_1, enabled), uuid, uuid);
 }
 
 void VolumeControl::onSourceActiveChanged(bool active)
@@ -770,8 +768,8 @@ void VolumeControl::processMixerState()
 	QSignalBlocker blockMute(muteButton);
 	QSignalBlocker blockMonitor(monitorButton);
 
-	bool showAsMuted = obsMuted || obsMonitoringType == OBS_MONITORING_TYPE_MONITOR_ONLY;
-	bool showAsMonitored = obsMonitoringType != OBS_MONITORING_TYPE_NONE;
+	bool showAsMuted = obsMuted;
+	bool showAsMonitored = obsMonitoring;
 	bool showAsUnassigned = !obsMuted && unassigned;
 
 	volumeMeter->setMuted((showAsMuted || showAsUnassigned) && !showAsMonitored);
@@ -817,28 +815,11 @@ void VolumeControl::processMixerState()
 void VolumeControl::handleMuteButton(bool mute)
 {
 	setMuted(mute);
-
-	if (obsMonitoringType != OBS_MONITORING_TYPE_NONE) {
-		if (mute) {
-			setMonitoring(OBS_MONITORING_TYPE_MONITOR_ONLY);
-		} else {
-			setMonitoring(OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT);
-		}
-	}
 }
 
 void VolumeControl::handleMonitorButton(bool enableMonitoring)
 {
-	if (!enableMonitoring) {
-		setMonitoring(OBS_MONITORING_TYPE_NONE);
-		return;
-	}
-
-	if (obsMuted) {
-		setMonitoring(OBS_MONITORING_TYPE_MONITOR_ONLY);
-	} else {
-		setMonitoring(OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT);
-	}
+	setMonitoring(enableMonitoring);
 }
 
 void VolumeControl::sliderChanged(int vol)

frontend/components/VolumeControl.hpp

@@ -71,7 +71,7 @@ class VolumeControl : public QFrame {
 	OBSWeakSource weakSource_;
 	const char *uuid;
 	std::vector<OBSSignal> obsSignals;
-	obs_monitoring_type obsMonitoringType;
+	bool obsMonitoring;
 	bool obsMuted;
 
 	QBoxLayout *mainLayout;
@@ -112,7 +112,7 @@ class VolumeControl : public QFrame {
 	void updatePeakMeterType();
 
 	void setMuted(bool mute);
-	void setMonitoring(obs_monitoring_type type);
+	void setMonitoring(bool enabled);
 
 public slots:
 	void setUseDisabledColors(bool greyscale);
@@ -131,7 +131,7 @@ private slots:
 
 	void onSourceActiveChanged(bool active);
 	void onMuteChanged(bool muted);
-	void onMonitoringChanged(int type);
+	void onMonitoringChanged(bool enabled);
 	void onSourceDestroyed() { deleteLater(); }
 
 signals:

frontend/data/locale/en-US.ini

@@ -1452,6 +1452,8 @@ Mute="Mute"
 Unmute="Unmute"
 Push-to-mute="Push-to-mute"
 Push-to-talk="Push-to-talk"
+MonitorOn="Enable Monitoring"
+MonitorOff="Disable Monitoring"
 
 # scene item hotkeys
 SceneItemShow="Show '%1'"

frontend/widgets/OBSBasic_Hotkeys.cpp

@@ -67,8 +67,8 @@ void OBSBasic::InitHotkeys()
 	t.escape = Str("Hotkeys.Escape");
 	obs_hotkeys_set_translations(&t);
 
-	obs_hotkeys_set_audio_hotkeys_translations(Str("Mute"), Str("Unmute"), Str("Push-to-mute"),
-						   Str("Push-to-talk"));
+	obs_hotkeys_set_audio_hotkeys_translations(Str("Mute"), Str("Unmute"), Str("Push-to-mute"), Str("Push-to-talk"),
+						   Str("MonitorOn"), Str("MonitorOff"));
 
 	obs_hotkeys_set_sceneitem_hotkeys_translations(Str("SceneItemShow"), Str("SceneItemHide"));