/****************************************************************************** Copyright (C) 2013-2014 by Hugh Bailey Philippe Groarke 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 . ******************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "audio-encoders.hpp" #include "hotkey-edit.hpp" #include "source-label.hpp" #include "obs-app.hpp" #include "platform.hpp" #include "properties-view.hpp" #include "qt-wrappers.hpp" #include "window-basic-main.hpp" #include "window-basic-settings.hpp" #include "window-basic-main-outputs.hpp" #include "window-projector.hpp" #include #include #include "ui-config.h" using namespace std; class SettingsEventFilter : public QObject { QScopedPointer shortcutFilter; public: inline SettingsEventFilter() : shortcutFilter((OBSEventFilter *)CreateShortcutFilter()) { } protected: bool eventFilter(QObject *obj, QEvent *event) override { int key; switch (event->type()) { case QEvent::KeyPress: case QEvent::KeyRelease: key = static_cast(event)->key(); if (key == Qt::Key_Escape) { return false; } default: break; } return shortcutFilter->filter(obj, event); } }; // Used for QVariant in codec comboboxes namespace { static bool StringEquals(QString left, QString right) { return left == right; } struct FormatDesc { const char *name = nullptr; const char *mimeType = nullptr; const ff_format_desc *desc = nullptr; inline FormatDesc() = default; inline FormatDesc(const char *name, const char *mimeType, const ff_format_desc *desc = nullptr) : name(name), mimeType(mimeType), desc(desc) { } bool operator==(const FormatDesc &f) const { if (!StringEquals(name, f.name)) return false; return StringEquals(mimeType, f.mimeType); } }; struct CodecDesc { const char *name = nullptr; int id = 0; inline CodecDesc() = default; inline CodecDesc(const char *name, int id) : name(name), id(id) {} bool operator==(const CodecDesc &codecDesc) const { if (id != codecDesc.id) return false; return StringEquals(name, codecDesc.name); } }; } Q_DECLARE_METATYPE(FormatDesc) Q_DECLARE_METATYPE(CodecDesc) static inline bool ResTooHigh(uint32_t cx, uint32_t cy) { return cx > 16384 || cy > 16384; } static inline bool ResTooLow(uint32_t cx, uint32_t cy) { return cx < 8 || cy < 8; } /* parses "[width]x[height]", string, i.e. 1024x768 */ static bool ConvertResText(const char *res, uint32_t &cx, uint32_t &cy) { BaseLexer lex; base_token token; lexer_start(lex, res); /* parse width */ if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE)) return false; if (token.type != BASETOKEN_DIGIT) return false; cx = std::stoul(token.text.array); /* parse 'x' */ if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE)) return false; if (strref_cmpi(&token.text, "x") != 0) return false; /* parse height */ if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE)) return false; if (token.type != BASETOKEN_DIGIT) return false; cy = std::stoul(token.text.array); /* shouldn't be any more tokens after this */ if (lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE)) return false; if (ResTooHigh(cx, cy) || ResTooLow(cx, cy)) { cx = cy = 0; return false; } return true; } static inline bool WidgetChanged(QWidget *widget) { return widget->property("changed").toBool(); } static inline void SetComboByName(QComboBox *combo, const char *name) { int idx = combo->findText(QT_UTF8(name)); if (idx != -1) combo->setCurrentIndex(idx); } static inline bool SetComboByValue(QComboBox *combo, const char *name) { int idx = combo->findData(QT_UTF8(name)); if (idx != -1) { combo->setCurrentIndex(idx); return true; } return false; } static inline bool SetInvalidValue(QComboBox *combo, const char *name, const char *data = nullptr) { combo->insertItem(0, name, data); QStandardItemModel *model = dynamic_cast(combo->model()); if (!model) return false; QStandardItem *item = model->item(0); item->setFlags(Qt::NoItemFlags); combo->setCurrentIndex(0); return true; } static inline QString GetComboData(QComboBox *combo) { int idx = combo->currentIndex(); if (idx == -1) return QString(); return combo->itemData(idx).toString(); } static int FindEncoder(QComboBox *combo, const char *name, int id) { CodecDesc codecDesc(name, id); for (int i = 0; i < combo->count(); i++) { QVariant v = combo->itemData(i); if (!v.isNull()) { if (codecDesc == v.value()) { return i; break; } } } return -1; } static CodecDesc GetDefaultCodecDesc(const ff_format_desc *formatDesc, ff_codec_type codecType) { int id = 0; switch (codecType) { case FF_CODEC_AUDIO: id = ff_format_desc_audio(formatDesc); break; case FF_CODEC_VIDEO: id = ff_format_desc_video(formatDesc); break; default: return CodecDesc(); } return CodecDesc(ff_format_desc_get_default_name(formatDesc, codecType), id); } #ifdef _WIN32 void OBSBasicSettings::ToggleDisableAero(bool checked) { SetAeroEnabled(!checked); } #endif static void PopulateAACBitrates(initializer_list boxes) { auto &bitrateMap = GetAACEncoderBitrateMap(); if (bitrateMap.empty()) return; vector> pairs; for (auto &entry : bitrateMap) pairs.emplace_back( QString::number(entry.first), obs_encoder_get_display_name(entry.second.c_str())); for (auto box : boxes) { QString currentText = box->currentText(); box->clear(); for (auto &pair : pairs) { box->addItem(pair.first); box->setItemData(box->count() - 1, pair.second, Qt::ToolTipRole); } box->setCurrentText(currentText); } } static std::tuple aspect_ratio(int cx, int cy) { int common = std::gcd(cx, cy); int newCX = cx / common; int newCY = cy / common; if (newCX == 8 && newCY == 5) { newCX = 16; newCY = 10; } return std::make_tuple(newCX, newCY); } static inline void HighlightGroupBoxLabel(QGroupBox *gb, QWidget *widget, QString objectName) { QFormLayout *layout = qobject_cast(gb->layout()); if (!layout) return; QLabel *label = qobject_cast(layout->labelForField(widget)); if (label) { label->setObjectName(objectName); label->style()->unpolish(label); label->style()->polish(label); } } void RestrictResetBitrates(initializer_list boxes, int maxbitrate); void OBSBasicSettings::HookWidget(QWidget *widget, const char *signal, const char *slot) { QObject::connect(widget, signal, this, slot); widget->setProperty("changed", QVariant(false)); } /* clang-format off */ #define COMBO_CHANGED SIGNAL(currentIndexChanged(int)) #define EDIT_CHANGED SIGNAL(textChanged(const QString &)) #define CBEDIT_CHANGED SIGNAL(editTextChanged(const QString &)) #define CHECK_CHANGED SIGNAL(clicked(bool)) #define SCROLL_CHANGED SIGNAL(valueChanged(int)) #define DSCROLL_CHANGED SIGNAL(valueChanged(double)) #define TOGGLE_CHANGED SIGNAL(toggled(bool)) #define GENERAL_CHANGED SLOT(GeneralChanged()) #define STREAM1_CHANGED SLOT(Stream1Changed()) #define OUTPUTS_CHANGED SLOT(OutputsChanged()) #define AUDIO_RESTART SLOT(AudioChangedRestart()) #define AUDIO_CHANGED SLOT(AudioChanged()) #define VIDEO_RESTART SLOT(VideoChangedRestart()) #define VIDEO_RES SLOT(VideoChangedResolution()) #define VIDEO_CHANGED SLOT(VideoChanged()) #define A11Y_CHANGED SLOT(A11yChanged()) #define ADV_CHANGED SLOT(AdvancedChanged()) #define ADV_RESTART SLOT(AdvancedChangedRestart()) /* clang-format on */ OBSBasicSettings::OBSBasicSettings(QWidget *parent) : QDialog(parent), main(qobject_cast(parent)), ui(new Ui::OBSBasicSettings) { string path; EnableThreadedMessageBoxes(true); setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint); ui->setupUi(this); main->EnableOutputs(false); PopulateAACBitrates({ui->simpleOutputABitrate, ui->advOutTrack1Bitrate, ui->advOutTrack2Bitrate, ui->advOutTrack3Bitrate, ui->advOutTrack4Bitrate, ui->advOutTrack5Bitrate, ui->advOutTrack6Bitrate}); ui->listWidget->setAttribute(Qt::WA_MacShowFocusRect, false); /* clang-format off */ HookWidget(ui->language, COMBO_CHANGED, GENERAL_CHANGED); HookWidget(ui->theme, COMBO_CHANGED, GENERAL_CHANGED); HookWidget(ui->enableAutoUpdates, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->openStatsOnStartup, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->hideOBSFromCapture, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->warnBeforeStreamStart,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->warnBeforeStreamStop, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->warnBeforeRecordStop, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->hideProjectorCursor, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->projectorAlwaysOnTop, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->recordWhenStreaming, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->keepRecordStreamStops,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->replayWhileStreaming, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->keepReplayStreamStops,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->systemTrayEnabled, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->systemTrayWhenStarted,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->systemTrayAlways, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->saveProjectors, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->closeProjectors, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->snappingEnabled, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->screenSnapping, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->centerSnapping, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->sourceSnapping, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->snapDistance, DSCROLL_CHANGED,GENERAL_CHANGED); HookWidget(ui->overflowHide, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->overflowAlwaysVisible,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->overflowSelectionHide,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->previewSafeAreas, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->automaticSearch, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->previewSpacingHelpers,CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->doubleClickSwitch, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->studioPortraitLayout, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->prevProgLabelToggle, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->multiviewMouseSwitch, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->multiviewDrawNames, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->multiviewDrawAreas, CHECK_CHANGED, GENERAL_CHANGED); HookWidget(ui->multiviewLayout, COMBO_CHANGED, GENERAL_CHANGED); HookWidget(ui->service, COMBO_CHANGED, STREAM1_CHANGED); HookWidget(ui->server, COMBO_CHANGED, STREAM1_CHANGED); HookWidget(ui->customServer, EDIT_CHANGED, STREAM1_CHANGED); HookWidget(ui->key, EDIT_CHANGED, STREAM1_CHANGED); HookWidget(ui->bandwidthTestEnable, CHECK_CHANGED, STREAM1_CHANGED); HookWidget(ui->twitchAddonDropdown, COMBO_CHANGED, STREAM1_CHANGED); HookWidget(ui->useAuth, CHECK_CHANGED, STREAM1_CHANGED); HookWidget(ui->authUsername, EDIT_CHANGED, STREAM1_CHANGED); HookWidget(ui->authPw, EDIT_CHANGED, STREAM1_CHANGED); HookWidget(ui->ignoreRecommended, CHECK_CHANGED, STREAM1_CHANGED); HookWidget(ui->outputMode, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutputPath, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutRecFormat, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutputVBitrate, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutStrEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutputABitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutAdvanced, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutPreset, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutCustom, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutRecQuality, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutRecEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleOutMuxCustom, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleReplayBuf, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleRBSecMax, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->simpleRBMegsMax, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack1, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack2, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack3, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack4, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack5, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack6, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecType, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecPath, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecFormat, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutMuxCustom, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutSplitFile, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutSplitFileType, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutSplitFileTime, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutSplitFileSize, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack1, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack2, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack3, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack4, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack5, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutRecTrack6, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack1, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack2, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack3, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack4, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack5, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->flvTrack6, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFType, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFRecPath, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFURL, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFFormat, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFMCfg, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFVBitrate, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFVGOPSize, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFIgnoreCompat, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFVEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFVCfg, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFABitrate, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack1, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack2, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack3, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack4, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack5, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFTrack6, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFAEncoder, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutFFACfg, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack1Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack1Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack2Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack2Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack3Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack3Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack4Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack4Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack5Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack5Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack6Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advOutTrack6Name, EDIT_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advReplayBuf, CHECK_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advRBSecMax, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->advRBMegsMax, SCROLL_CHANGED, OUTPUTS_CHANGED); HookWidget(ui->channelSetup, COMBO_CHANGED, AUDIO_RESTART); HookWidget(ui->sampleRate, COMBO_CHANGED, AUDIO_RESTART); HookWidget(ui->meterDecayRate, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->peakMeterType, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->desktopAudioDevice1, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->desktopAudioDevice2, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->auxAudioDevice1, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->auxAudioDevice2, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->auxAudioDevice3, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->auxAudioDevice4, COMBO_CHANGED, AUDIO_CHANGED); HookWidget(ui->baseResolution, CBEDIT_CHANGED, VIDEO_RES); HookWidget(ui->outputResolution, CBEDIT_CHANGED, VIDEO_RES); HookWidget(ui->downscaleFilter, COMBO_CHANGED, VIDEO_CHANGED); HookWidget(ui->fpsType, COMBO_CHANGED, VIDEO_CHANGED); HookWidget(ui->fpsCommon, COMBO_CHANGED, VIDEO_CHANGED); HookWidget(ui->fpsInteger, SCROLL_CHANGED, VIDEO_CHANGED); HookWidget(ui->fpsNumerator, SCROLL_CHANGED, VIDEO_CHANGED); HookWidget(ui->fpsDenominator, SCROLL_CHANGED, VIDEO_CHANGED); HookWidget(ui->colorsGroupBox, CHECK_CHANGED, A11Y_CHANGED); HookWidget(ui->colorPreset, COMBO_CHANGED, A11Y_CHANGED); HookWidget(ui->renderer, COMBO_CHANGED, ADV_RESTART); HookWidget(ui->adapter, COMBO_CHANGED, ADV_RESTART); HookWidget(ui->colorFormat, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->colorSpace, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->colorRange, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->sdrWhiteLevel, SCROLL_CHANGED, ADV_CHANGED); HookWidget(ui->hdrNominalPeakLevel, SCROLL_CHANGED, ADV_CHANGED); HookWidget(ui->disableOSXVSync, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->resetOSXVSync, CHECK_CHANGED, ADV_CHANGED); if (obs_audio_monitoring_available()) HookWidget(ui->monitoringDevice, COMBO_CHANGED, ADV_CHANGED); #ifdef _WIN32 HookWidget(ui->disableAudioDucking, CHECK_CHANGED, ADV_CHANGED); #endif #if defined(_WIN32) || defined(__APPLE__) HookWidget(ui->browserHWAccel, CHECK_CHANGED, ADV_RESTART); #endif HookWidget(ui->filenameFormatting, EDIT_CHANGED, ADV_CHANGED); HookWidget(ui->overwriteIfExists, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->simpleRBPrefix, EDIT_CHANGED, ADV_CHANGED); HookWidget(ui->simpleRBSuffix, EDIT_CHANGED, ADV_CHANGED); HookWidget(ui->streamDelayEnable, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->streamDelaySec, SCROLL_CHANGED, ADV_CHANGED); HookWidget(ui->streamDelayPreserve, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->reconnectEnable, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->reconnectRetryDelay, SCROLL_CHANGED, ADV_CHANGED); HookWidget(ui->reconnectMaxRetries, SCROLL_CHANGED, ADV_CHANGED); HookWidget(ui->processPriority, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->confirmOnExit, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->bindToIP, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->enableNewSocketLoop, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->enableLowLatencyMode, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->hotkeyFocusType, COMBO_CHANGED, ADV_CHANGED); HookWidget(ui->autoRemux, CHECK_CHANGED, ADV_CHANGED); HookWidget(ui->dynBitrate, CHECK_CHANGED, ADV_CHANGED); /* clang-format on */ #define ADD_HOTKEY_FOCUS_TYPE(s) \ ui->hotkeyFocusType->addItem( \ QTStr("Basic.Settings.Advanced.Hotkeys." s), s) ADD_HOTKEY_FOCUS_TYPE("NeverDisableHotkeys"); ADD_HOTKEY_FOCUS_TYPE("DisableHotkeysInFocus"); ADD_HOTKEY_FOCUS_TYPE("DisableHotkeysOutOfFocus"); #undef ADD_HOTKEY_FOCUS_TYPE ui->simpleOutputVBitrate->setSingleStep(50); ui->simpleOutputVBitrate->setSuffix(" Kbps"); ui->advOutFFVBitrate->setSingleStep(50); ui->advOutFFVBitrate->setSuffix(" Kbps"); ui->advOutFFABitrate->setSuffix(" Kbps"); #if !defined(_WIN32) && !defined(__APPLE__) delete ui->enableAutoUpdates; ui->enableAutoUpdates = nullptr; #endif // Remove the Advanced Audio section if monitoring is not supported, as the monitoring device selection is the only item in the group box. if (!obs_audio_monitoring_available()) { delete ui->monitoringDeviceLabel; ui->monitoringDeviceLabel = nullptr; delete ui->monitoringDevice; ui->monitoringDevice = nullptr; } #ifdef _WIN32 uint32_t winVer = GetWindowsVersion(); if (winVer > 0 && winVer < 0x602) { // Older than Windows 8 toggleAero = new QCheckBox( QTStr("Basic.Settings.Video.DisableAero"), this); QFormLayout *videoLayout = reinterpret_cast( ui->videoPage->layout()); videoLayout->addRow(nullptr, toggleAero); HookWidget(toggleAero, CHECK_CHANGED, VIDEO_CHANGED); connect(toggleAero, &QAbstractButton::toggled, this, &OBSBasicSettings::ToggleDisableAero); } if (!SetDisplayAffinitySupported()) { delete ui->hideOBSFromCapture; ui->hideOBSFromCapture = nullptr; } #define PROCESS_PRIORITY(val) \ { \ "Basic.Settings.Advanced.General.ProcessPriority."##val, val \ } static struct ProcessPriority { const char *name; const char *val; } processPriorities[] = {PROCESS_PRIORITY("High"), PROCESS_PRIORITY("AboveNormal"), PROCESS_PRIORITY("Normal"), PROCESS_PRIORITY("BelowNormal"), PROCESS_PRIORITY("Idle")}; #undef PROCESS_PRIORITY for (ProcessPriority pri : processPriorities) ui->processPriority->addItem(QTStr(pri.name), pri.val); #else delete ui->rendererLabel; delete ui->renderer; delete ui->adapterLabel; delete ui->adapter; delete ui->processPriorityLabel; delete ui->processPriority; delete ui->enableNewSocketLoop; delete ui->enableLowLatencyMode; delete ui->hideOBSFromCapture; #ifdef __linux__ delete ui->browserHWAccel; delete ui->sourcesGroup; #endif delete ui->disableAudioDucking; ui->rendererLabel = nullptr; ui->renderer = nullptr; ui->adapterLabel = nullptr; ui->adapter = nullptr; ui->processPriorityLabel = nullptr; ui->processPriority = nullptr; ui->enableNewSocketLoop = nullptr; ui->enableLowLatencyMode = nullptr; ui->hideOBSFromCapture = nullptr; #ifdef __linux__ ui->browserHWAccel = nullptr; ui->sourcesGroup = nullptr; #endif ui->disableAudioDucking = nullptr; #endif #ifndef __APPLE__ delete ui->disableOSXVSync; delete ui->resetOSXVSync; ui->disableOSXVSync = nullptr; ui->resetOSXVSync = nullptr; #endif connect(ui->streamDelaySec, SIGNAL(valueChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->outputMode, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->simpleOutputVBitrate, SIGNAL(valueChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->simpleOutputABitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack1Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack2Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack3Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack4Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack5Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); connect(ui->advOutTrack6Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateStreamDelayEstimate())); //Apply button disabled until change. EnableApplyButton(false); // Initialize libff library ff_init(); installEventFilter(new SettingsEventFilter()); LoadColorRanges(); LoadColorSpaces(); LoadColorFormats(); LoadFormats(); auto ReloadAudioSources = [](void *data, calldata_t *param) { auto settings = static_cast(data); auto source = static_cast( calldata_ptr(param, "source")); if (!source) return; if (!(obs_source_get_output_flags(source) & OBS_SOURCE_AUDIO)) return; QMetaObject::invokeMethod(settings, "ReloadAudioSources", Qt::QueuedConnection); }; sourceCreated.Connect(obs_get_signal_handler(), "source_create", ReloadAudioSources, this); channelChanged.Connect(obs_get_signal_handler(), "channel_change", ReloadAudioSources, this); hotkeyConflictIcon = QIcon::fromTheme("obs", QIcon(":/res/images/warning.svg")); auto ReloadHotkeys = [](void *data, calldata_t *) { auto settings = static_cast(data); QMetaObject::invokeMethod(settings, "ReloadHotkeys"); }; hotkeyRegistered.Connect(obs_get_signal_handler(), "hotkey_register", ReloadHotkeys, this); auto ReloadHotkeysIgnore = [](void *data, calldata_t *param) { auto settings = static_cast(data); auto key = static_cast(calldata_ptr(param, "key")); QMetaObject::invokeMethod(settings, "ReloadHotkeys", Q_ARG(obs_hotkey_id, obs_hotkey_get_id(key))); }; hotkeyUnregistered.Connect(obs_get_signal_handler(), "hotkey_unregister", ReloadHotkeysIgnore, this); FillSimpleRecordingValues(); if (obs_audio_monitoring_available()) FillAudioMonitoringDevices(); connect(ui->channelSetup, SIGNAL(currentIndexChanged(int)), this, SLOT(SurroundWarning(int))); connect(ui->channelSetup, SIGNAL(currentIndexChanged(int)), this, SLOT(SpeakerLayoutChanged(int))); connect(ui->lowLatencyBuffering, SIGNAL(clicked(bool)), this, SLOT(LowLatencyBufferingChanged(bool))); connect(ui->simpleOutRecQuality, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingQualityChanged())); connect(ui->simpleOutRecQuality, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingQualityLosslessWarning(int))); connect(ui->simpleOutRecFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleOutStrEncoder, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleStreamingEncoderChanged())); connect(ui->simpleOutStrEncoder, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleOutRecEncoder, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleOutputVBitrate, SIGNAL(valueChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleOutputABitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleOutAdvanced, SIGNAL(toggled(bool)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->ignoreRecommended, SIGNAL(toggled(bool)), this, SLOT(SimpleRecordingEncoderChanged())); connect(ui->simpleReplayBuf, SIGNAL(toggled(bool)), this, SLOT(SimpleReplayBufferChanged())); connect(ui->simpleOutputVBitrate, SIGNAL(valueChanged(int)), this, SLOT(SimpleReplayBufferChanged())); connect(ui->simpleOutputABitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(SimpleReplayBufferChanged())); connect(ui->simpleRBSecMax, SIGNAL(valueChanged(int)), this, SLOT(SimpleReplayBufferChanged())); connect(ui->advOutSplitFile, SIGNAL(stateChanged(int)), this, SLOT(AdvOutSplitFileChanged())); connect(ui->advOutSplitFileType, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvOutSplitFileChanged())); connect(ui->advReplayBuf, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack1, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack2, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack3, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack4, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack5, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecTrack6, SIGNAL(toggled(bool)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack1Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack2Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack3Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack4Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack5Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutTrack6Bitrate, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecType, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advOutRecEncoder, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->advRBSecMax, SIGNAL(valueChanged(int)), this, SLOT(AdvReplayBufferChanged())); connect(ui->listWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SimpleRecordingEncoderChanged())); // Get Bind to IP Addresses obs_properties_t *ppts = obs_get_output_properties("rtmp_output"); obs_property_t *p = obs_properties_get(ppts, "bind_ip"); size_t count = obs_property_list_item_count(p); for (size_t i = 0; i < count; i++) { const char *name = obs_property_list_item_name(p, i); const char *val = obs_property_list_item_string(p, i); ui->bindToIP->addItem(QT_UTF8(name), val); } obs_properties_destroy(ppts); InitStreamPage(); LoadSettings(false); ui->advOutTrack1->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track1")); ui->advOutTrack2->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track2")); ui->advOutTrack3->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track3")); ui->advOutTrack4->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track4")); ui->advOutTrack5->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track5")); ui->advOutTrack6->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track6")); ui->advOutRecTrack1->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track1")); ui->advOutRecTrack2->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track2")); ui->advOutRecTrack3->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track3")); ui->advOutRecTrack4->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track4")); ui->advOutRecTrack5->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track5")); ui->advOutRecTrack6->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track6")); ui->advOutFFTrack1->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track1")); ui->advOutFFTrack2->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track2")); ui->advOutFFTrack3->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track3")); ui->advOutFFTrack4->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track4")); ui->advOutFFTrack5->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track5")); ui->advOutFFTrack6->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Audio.Track6")); ui->snappingEnabled->setAccessibleName( QTStr("Basic.Settings.General.Snapping")); ui->systemTrayEnabled->setAccessibleName( QTStr("Basic.Settings.General.SysTray")); ui->label_31->setAccessibleName( QTStr("Basic.Settings.Output.Adv.Recording.RecType")); ui->streamDelayEnable->setAccessibleName( QTStr("Basic.Settings.Advanced.StreamDelay")); ui->reconnectEnable->setAccessibleName( QTStr("Basic.Settings.Output.Reconnect")); // Add warning checks to advanced output recording section controls connect(ui->advOutRecTrack1, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecTrack2, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecTrack3, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecTrack4, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecTrack5, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecTrack6, SIGNAL(clicked()), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvOutRecCheckWarnings())); connect(ui->advOutRecEncoder, SIGNAL(currentIndexChanged(int)), this, SLOT(AdvOutRecCheckWarnings())); AdvOutRecCheckWarnings(); SimpleRecordingQualityChanged(); AdvOutSplitFileChanged(); UpdateAutomaticReplayBufferCheckboxes(); App()->DisableHotkeys(); channelIndex = ui->channelSetup->currentIndex(); sampleRateIndex = ui->sampleRate->currentIndex(); llBufferingEnabled = ui->lowLatencyBuffering->isChecked(); QRegularExpression rx("\\d{1,5}x\\d{1,5}"); QValidator *validator = new QRegularExpressionValidator(rx, this); ui->baseResolution->lineEdit()->setValidator(validator); ui->outputResolution->lineEdit()->setValidator(validator); connect(ui->useStreamKeyAdv, SIGNAL(clicked()), this, SLOT(UseStreamKeyAdvClicked())); UpdateAudioWarnings(); UpdateAdvNetworkGroup(); } OBSBasicSettings::~OBSBasicSettings() { delete ui->filenameFormatting->completer(); main->EnableOutputs(true); App()->UpdateHotkeyFocusSetting(); EnableThreadedMessageBoxes(false); } void OBSBasicSettings::SaveCombo(QComboBox *widget, const char *section, const char *value) { if (WidgetChanged(widget)) config_set_string(main->Config(), section, value, QT_TO_UTF8(widget->currentText())); } void OBSBasicSettings::SaveComboData(QComboBox *widget, const char *section, const char *value) { if (WidgetChanged(widget)) { QString str = GetComboData(widget); config_set_string(main->Config(), section, value, QT_TO_UTF8(str)); } } void OBSBasicSettings::SaveCheckBox(QAbstractButton *widget, const char *section, const char *value, bool invert) { if (WidgetChanged(widget)) { bool checked = widget->isChecked(); if (invert) checked = !checked; config_set_bool(main->Config(), section, value, checked); } } void OBSBasicSettings::SaveEdit(QLineEdit *widget, const char *section, const char *value) { if (WidgetChanged(widget)) config_set_string(main->Config(), section, value, QT_TO_UTF8(widget->text())); } void OBSBasicSettings::SaveSpinBox(QSpinBox *widget, const char *section, const char *value) { if (WidgetChanged(widget)) config_set_int(main->Config(), section, value, widget->value()); } #define CS_PARTIAL_STR QTStr("Basic.Settings.Advanced.Video.ColorRange.Partial") #define CS_FULL_STR QTStr("Basic.Settings.Advanced.Video.ColorRange.Full") void OBSBasicSettings::LoadColorRanges() { ui->colorRange->addItem(CS_PARTIAL_STR, "Partial"); ui->colorRange->addItem(CS_FULL_STR, "Full"); } #define CS_SRGB_STR QTStr("Basic.Settings.Advanced.Video.ColorSpace.sRGB") #define CS_709_STR QTStr("Basic.Settings.Advanced.Video.ColorSpace.709") #define CS_601_STR QTStr("Basic.Settings.Advanced.Video.ColorSpace.601") #define CS_2100PQ_STR QTStr("Basic.Settings.Advanced.Video.ColorSpace.2100PQ") #define CS_2100HLG_STR QTStr("Basic.Settings.Advanced.Video.ColorSpace.2100HLG") void OBSBasicSettings::LoadColorSpaces() { ui->colorSpace->addItem(CS_SRGB_STR, "sRGB"); ui->colorSpace->addItem(CS_709_STR, "709"); ui->colorSpace->addItem(CS_601_STR, "601"); ui->colorSpace->addItem(CS_2100PQ_STR, "2100PQ"); ui->colorSpace->addItem(CS_2100HLG_STR, "2100HLG"); } #define CF_NV12_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.NV12") #define CF_I420_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.I420") #define CF_I444_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.I444") #define CF_P010_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.P010") #define CF_I010_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.I010") #define CF_RGB_STR QTStr("Basic.Settings.Advanced.Video.ColorFormat.RGB") void OBSBasicSettings::LoadColorFormats() { ui->colorFormat->addItem(CF_NV12_STR, "NV12"); ui->colorFormat->addItem(CF_I420_STR, "I420"); ui->colorFormat->addItem(CF_I444_STR, "I444"); ui->colorFormat->addItem(CF_P010_STR, "P010"); ui->colorFormat->addItem(CF_I010_STR, "I010"); ui->colorFormat->addItem(CF_RGB_STR, "RGB"); } #define AV_FORMAT_DEFAULT_STR \ QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatDefault") #define AUDIO_STR QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatAudio") #define VIDEO_STR QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatVideo") void OBSBasicSettings::LoadFormats() { ui->advOutFFFormat->blockSignals(true); formats.reset(ff_format_supported()); const ff_format_desc *format = formats.get(); while (format != nullptr) { bool audio = ff_format_desc_has_audio(format); bool video = ff_format_desc_has_video(format); FormatDesc formatDesc(ff_format_desc_name(format), ff_format_desc_mime_type(format), format); if (audio || video) { QString itemText(ff_format_desc_name(format)); if (audio ^ video) itemText += QString(" (%1)").arg( audio ? AUDIO_STR : VIDEO_STR); ui->advOutFFFormat->addItem( itemText, QVariant::fromValue(formatDesc)); } format = ff_format_desc_next(format); } ui->advOutFFFormat->model()->sort(0); ui->advOutFFFormat->insertItem(0, AV_FORMAT_DEFAULT_STR); ui->advOutFFFormat->blockSignals(false); } static void AddCodec(QComboBox *combo, const ff_codec_desc *codec_desc) { QString itemText(ff_codec_desc_name(codec_desc)); if (ff_codec_desc_is_alias(codec_desc)) itemText += QString(" (%1)").arg( ff_codec_desc_base_name(codec_desc)); CodecDesc cd(ff_codec_desc_name(codec_desc), ff_codec_desc_id(codec_desc)); combo->addItem(itemText, QVariant::fromValue(cd)); } #define AV_ENCODER_DEFAULT_STR \ QTStr("Basic.Settings.Output.Adv.FFmpeg.AVEncoderDefault") static void AddDefaultCodec(QComboBox *combo, const ff_format_desc *formatDesc, ff_codec_type codecType) { CodecDesc cd = GetDefaultCodecDesc(formatDesc, codecType); int existingIdx = FindEncoder(combo, cd.name, cd.id); if (existingIdx >= 0) combo->removeItem(existingIdx); combo->addItem(QString("%1 (%2)").arg(cd.name, AV_ENCODER_DEFAULT_STR), QVariant::fromValue(cd)); } #define AV_ENCODER_DISABLE_STR \ QTStr("Basic.Settings.Output.Adv.FFmpeg.AVEncoderDisable") void OBSBasicSettings::ReloadCodecs(const ff_format_desc *formatDesc) { ui->advOutFFAEncoder->blockSignals(true); ui->advOutFFVEncoder->blockSignals(true); ui->advOutFFAEncoder->clear(); ui->advOutFFVEncoder->clear(); if (formatDesc == nullptr) return; bool ignore_compatability = ui->advOutFFIgnoreCompat->isChecked(); OBSFFCodecDesc codecDescs( ff_codec_supported(formatDesc, ignore_compatability)); const ff_codec_desc *codec = codecDescs.get(); while (codec != nullptr) { switch (ff_codec_desc_type(codec)) { case FF_CODEC_AUDIO: AddCodec(ui->advOutFFAEncoder, codec); break; case FF_CODEC_VIDEO: AddCodec(ui->advOutFFVEncoder, codec); break; default: break; } codec = ff_codec_desc_next(codec); } if (ff_format_desc_has_audio(formatDesc)) AddDefaultCodec(ui->advOutFFAEncoder, formatDesc, FF_CODEC_AUDIO); if (ff_format_desc_has_video(formatDesc)) AddDefaultCodec(ui->advOutFFVEncoder, formatDesc, FF_CODEC_VIDEO); ui->advOutFFAEncoder->model()->sort(0); ui->advOutFFVEncoder->model()->sort(0); QVariant disable = QVariant::fromValue(CodecDesc()); ui->advOutFFAEncoder->insertItem(0, AV_ENCODER_DISABLE_STR, disable); ui->advOutFFVEncoder->insertItem(0, AV_ENCODER_DISABLE_STR, disable); ui->advOutFFAEncoder->blockSignals(false); ui->advOutFFVEncoder->blockSignals(false); } void OBSBasicSettings::LoadLanguageList() { const char *currentLang = App()->GetLocale(); ui->language->clear(); for (const auto &locale : GetLocaleNames()) { int idx = ui->language->count(); ui->language->addItem(QT_UTF8(locale.second.c_str()), QT_UTF8(locale.first.c_str())); if (locale.first == currentLang) ui->language->setCurrentIndex(idx); } ui->language->model()->sort(0); } void OBSBasicSettings::LoadThemeList() { /* Save theme if user presses Cancel */ savedTheme = string(App()->GetTheme()); ui->theme->clear(); QSet uniqueSet; string themeDir; char userThemeDir[512]; int ret = GetConfigPath(userThemeDir, sizeof(userThemeDir), "obs-studio/themes/"); GetDataFilePath("themes/", themeDir); /* Check user dir first. */ if (ret > 0) { QDirIterator it(QString(userThemeDir), QStringList() << "*.qss", QDir::Files); while (it.hasNext()) { it.next(); QString name = it.fileInfo().completeBaseName(); ui->theme->addItem(name, name); uniqueSet.insert(name); } } /* Check shipped themes. */ QDirIterator uIt(QString(themeDir.c_str()), QStringList() << "*.qss", QDir::Files); while (uIt.hasNext()) { uIt.next(); QString name = uIt.fileInfo().completeBaseName(); QString value = name; if (name == DEFAULT_THEME) name += " " + QTStr("Default"); if (!uniqueSet.contains(value) && name != "Default") ui->theme->addItem(name, value); } int idx = ui->theme->findData(QT_UTF8(App()->GetTheme())); if (idx != -1) ui->theme->setCurrentIndex(idx); } void OBSBasicSettings::LoadGeneralSettings() { loading = true; LoadLanguageList(); LoadThemeList(); #if defined(_WIN32) || defined(__APPLE__) bool enableAutoUpdates = config_get_bool(GetGlobalConfig(), "General", "EnableAutoUpdates"); ui->enableAutoUpdates->setChecked(enableAutoUpdates); #endif bool openStatsOnStartup = config_get_bool(main->Config(), "General", "OpenStatsOnStartup"); ui->openStatsOnStartup->setChecked(openStatsOnStartup); #if defined(_WIN32) if (ui->hideOBSFromCapture) { bool hideWindowFromCapture = config_get_bool(GetGlobalConfig(), "BasicWindow", "HideOBSWindowsFromCapture"); ui->hideOBSFromCapture->setChecked(hideWindowFromCapture); connect(ui->hideOBSFromCapture, SIGNAL(stateChanged(int)), this, SLOT(HideOBSWindowWarning(int))); } #endif bool recordWhenStreaming = config_get_bool( GetGlobalConfig(), "BasicWindow", "RecordWhenStreaming"); ui->recordWhenStreaming->setChecked(recordWhenStreaming); bool keepRecordStreamStops = config_get_bool(GetGlobalConfig(), "BasicWindow", "KeepRecordingWhenStreamStops"); ui->keepRecordStreamStops->setChecked(keepRecordStreamStops); bool replayWhileStreaming = config_get_bool( GetGlobalConfig(), "BasicWindow", "ReplayBufferWhileStreaming"); ui->replayWhileStreaming->setChecked(replayWhileStreaming); bool keepReplayStreamStops = config_get_bool(GetGlobalConfig(), "BasicWindow", "KeepReplayBufferStreamStops"); ui->keepReplayStreamStops->setChecked(keepReplayStreamStops); bool systemTrayEnabled = config_get_bool( GetGlobalConfig(), "BasicWindow", "SysTrayEnabled"); ui->systemTrayEnabled->setChecked(systemTrayEnabled); bool systemTrayWhenStarted = config_get_bool( GetGlobalConfig(), "BasicWindow", "SysTrayWhenStarted"); ui->systemTrayWhenStarted->setChecked(systemTrayWhenStarted); bool systemTrayAlways = config_get_bool( GetGlobalConfig(), "BasicWindow", "SysTrayMinimizeToTray"); ui->systemTrayAlways->setChecked(systemTrayAlways); bool saveProjectors = config_get_bool(GetGlobalConfig(), "BasicWindow", "SaveProjectors"); ui->saveProjectors->setChecked(saveProjectors); bool closeProjectors = config_get_bool(GetGlobalConfig(), "BasicWindow", "CloseExistingProjectors"); ui->closeProjectors->setChecked(closeProjectors); bool snappingEnabled = config_get_bool(GetGlobalConfig(), "BasicWindow", "SnappingEnabled"); ui->snappingEnabled->setChecked(snappingEnabled); bool screenSnapping = config_get_bool(GetGlobalConfig(), "BasicWindow", "ScreenSnapping"); ui->screenSnapping->setChecked(screenSnapping); bool centerSnapping = config_get_bool(GetGlobalConfig(), "BasicWindow", "CenterSnapping"); ui->centerSnapping->setChecked(centerSnapping); bool sourceSnapping = config_get_bool(GetGlobalConfig(), "BasicWindow", "SourceSnapping"); ui->sourceSnapping->setChecked(sourceSnapping); double snapDistance = config_get_double(GetGlobalConfig(), "BasicWindow", "SnapDistance"); ui->snapDistance->setValue(snapDistance); bool warnBeforeStreamStart = config_get_bool( GetGlobalConfig(), "BasicWindow", "WarnBeforeStartingStream"); ui->warnBeforeStreamStart->setChecked(warnBeforeStreamStart); bool spacingHelpersEnabled = config_get_bool( GetGlobalConfig(), "BasicWindow", "SpacingHelpersEnabled"); ui->previewSpacingHelpers->setChecked(spacingHelpersEnabled); bool warnBeforeStreamStop = config_get_bool( GetGlobalConfig(), "BasicWindow", "WarnBeforeStoppingStream"); ui->warnBeforeStreamStop->setChecked(warnBeforeStreamStop); bool warnBeforeRecordStop = config_get_bool( GetGlobalConfig(), "BasicWindow", "WarnBeforeStoppingRecord"); ui->warnBeforeRecordStop->setChecked(warnBeforeRecordStop); bool hideProjectorCursor = config_get_bool( GetGlobalConfig(), "BasicWindow", "HideProjectorCursor"); ui->hideProjectorCursor->setChecked(hideProjectorCursor); bool projectorAlwaysOnTop = config_get_bool( GetGlobalConfig(), "BasicWindow", "ProjectorAlwaysOnTop"); ui->projectorAlwaysOnTop->setChecked(projectorAlwaysOnTop); bool overflowHide = config_get_bool(GetGlobalConfig(), "BasicWindow", "OverflowHidden"); ui->overflowHide->setChecked(overflowHide); bool overflowAlwaysVisible = config_get_bool( GetGlobalConfig(), "BasicWindow", "OverflowAlwaysVisible"); ui->overflowAlwaysVisible->setChecked(overflowAlwaysVisible); bool overflowSelectionHide = config_get_bool( GetGlobalConfig(), "BasicWindow", "OverflowSelectionHidden"); ui->overflowSelectionHide->setChecked(overflowSelectionHide); bool safeAreas = config_get_bool(GetGlobalConfig(), "BasicWindow", "ShowSafeAreas"); ui->previewSafeAreas->setChecked(safeAreas); bool automaticSearch = config_get_bool(GetGlobalConfig(), "General", "AutomaticCollectionSearch"); ui->automaticSearch->setChecked(automaticSearch); bool doubleClickSwitch = config_get_bool( GetGlobalConfig(), "BasicWindow", "TransitionOnDoubleClick"); ui->doubleClickSwitch->setChecked(doubleClickSwitch); bool studioPortraitLayout = config_get_bool( GetGlobalConfig(), "BasicWindow", "StudioPortraitLayout"); ui->studioPortraitLayout->setChecked(studioPortraitLayout); bool prevProgLabels = config_get_bool(GetGlobalConfig(), "BasicWindow", "StudioModeLabels"); ui->prevProgLabelToggle->setChecked(prevProgLabels); bool multiviewMouseSwitch = config_get_bool( GetGlobalConfig(), "BasicWindow", "MultiviewMouseSwitch"); ui->multiviewMouseSwitch->setChecked(multiviewMouseSwitch); bool multiviewDrawNames = config_get_bool( GetGlobalConfig(), "BasicWindow", "MultiviewDrawNames"); ui->multiviewDrawNames->setChecked(multiviewDrawNames); bool multiviewDrawAreas = config_get_bool( GetGlobalConfig(), "BasicWindow", "MultiviewDrawAreas"); ui->multiviewDrawAreas->setChecked(multiviewDrawAreas); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Horizontal.Top"), static_cast(MultiviewLayout::HORIZONTAL_TOP_8_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Horizontal.Bottom"), static_cast(MultiviewLayout::HORIZONTAL_BOTTOM_8_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Vertical.Left"), static_cast(MultiviewLayout::VERTICAL_LEFT_8_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Vertical.Right"), static_cast(MultiviewLayout::VERTICAL_RIGHT_8_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Horizontal.18Scene.Top"), static_cast(MultiviewLayout::HORIZONTAL_TOP_18_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.Horizontal.Extended.Top"), static_cast(MultiviewLayout::HORIZONTAL_TOP_24_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.4Scene"), static_cast(MultiviewLayout::SCENES_ONLY_4_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.9Scene"), static_cast(MultiviewLayout::SCENES_ONLY_9_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.16Scene"), static_cast(MultiviewLayout::SCENES_ONLY_16_SCENES)); ui->multiviewLayout->addItem( QTStr("Basic.Settings.General.MultiviewLayout.25Scene"), static_cast(MultiviewLayout::SCENES_ONLY_25_SCENES)); ui->multiviewLayout->setCurrentIndex(ui->multiviewLayout->findData( QVariant::fromValue(config_get_int( GetGlobalConfig(), "BasicWindow", "MultiviewLayout")))); prevLangIndex = ui->language->currentIndex(); if (obs_video_active()) ui->language->setEnabled(false); loading = false; } void OBSBasicSettings::LoadRendererList() { #ifdef _WIN32 const char *renderer = config_get_string(GetGlobalConfig(), "Video", "Renderer"); ui->renderer->addItem(QT_UTF8("Direct3D 11")); if (opt_allow_opengl || strcmp(renderer, "OpenGL") == 0) ui->renderer->addItem(QT_UTF8("OpenGL")); int idx = ui->renderer->findText(QT_UTF8(renderer)); if (idx == -1) idx = 0; // the video adapter selection is not currently implemented, hide for now // to avoid user confusion. was previously protected by // if (strcmp(renderer, "OpenGL") == 0) delete ui->adapter; delete ui->adapterLabel; ui->adapter = nullptr; ui->adapterLabel = nullptr; ui->renderer->setCurrentIndex(idx); #endif } static string ResString(uint32_t cx, uint32_t cy) { stringstream res; res << cx << "x" << cy; return res.str(); } /* some nice default output resolution vals */ static const double vals[] = {1.0, 1.25, (1.0 / 0.75), 1.5, (1.0 / 0.6), 1.75, 2.0, 2.25, 2.5, 2.75, 3.0}; static const size_t numVals = sizeof(vals) / sizeof(double); void OBSBasicSettings::ResetDownscales(uint32_t cx, uint32_t cy, bool ignoreAllSignals) { QString advRescale; QString advRecRescale; QString advFFRescale; QString oldOutputRes; string bestScale; int bestPixelDiff = 0x7FFFFFFF; uint32_t out_cx = outputCX; uint32_t out_cy = outputCY; advRescale = ui->advOutRescale->lineEdit()->text(); advRecRescale = ui->advOutRecRescale->lineEdit()->text(); advFFRescale = ui->advOutFFRescale->lineEdit()->text(); bool lockedOutputRes = !ui->outputResolution->isEditable(); if (!lockedOutputRes) { ui->outputResolution->blockSignals(true); ui->outputResolution->clear(); } if (ignoreAllSignals) { ui->advOutRescale->blockSignals(true); ui->advOutRecRescale->blockSignals(true); ui->advOutFFRescale->blockSignals(true); } ui->advOutRescale->clear(); ui->advOutRecRescale->clear(); ui->advOutFFRescale->clear(); if (!out_cx || !out_cy) { out_cx = cx; out_cy = cy; oldOutputRes = ui->baseResolution->lineEdit()->text(); } else { oldOutputRes = QString::number(out_cx) + "x" + QString::number(out_cy); } for (size_t idx = 0; idx < numVals; idx++) { uint32_t downscaleCX = uint32_t(double(cx) / vals[idx]); uint32_t downscaleCY = uint32_t(double(cy) / vals[idx]); uint32_t outDownscaleCX = uint32_t(double(out_cx) / vals[idx]); uint32_t outDownscaleCY = uint32_t(double(out_cy) / vals[idx]); downscaleCX &= 0xFFFFFFFC; downscaleCY &= 0xFFFFFFFE; outDownscaleCX &= 0xFFFFFFFE; outDownscaleCY &= 0xFFFFFFFE; string res = ResString(downscaleCX, downscaleCY); string outRes = ResString(outDownscaleCX, outDownscaleCY); if (!lockedOutputRes) ui->outputResolution->addItem(res.c_str()); ui->advOutRescale->addItem(outRes.c_str()); ui->advOutRecRescale->addItem(outRes.c_str()); ui->advOutFFRescale->addItem(outRes.c_str()); /* always try to find the closest output resolution to the * previously set output resolution */ int newPixelCount = int(downscaleCX * downscaleCY); int oldPixelCount = int(out_cx * out_cy); int diff = abs(newPixelCount - oldPixelCount); if (diff < bestPixelDiff) { bestScale = res; bestPixelDiff = diff; } } string res = ResString(cx, cy); if (!lockedOutputRes) { float baseAspect = float(cx) / float(cy); float outputAspect = float(out_cx) / float(out_cy); bool closeAspect = close_float(baseAspect, outputAspect, 0.01f); if (closeAspect) { ui->outputResolution->lineEdit()->setText(oldOutputRes); on_outputResolution_editTextChanged(oldOutputRes); } else { ui->outputResolution->lineEdit()->setText( bestScale.c_str()); on_outputResolution_editTextChanged(bestScale.c_str()); } ui->outputResolution->blockSignals(false); if (!closeAspect) { ui->outputResolution->setProperty("changed", QVariant(true)); videoChanged = true; } } if (advRescale.isEmpty()) advRescale = res.c_str(); if (advRecRescale.isEmpty()) advRecRescale = res.c_str(); if (advFFRescale.isEmpty()) advFFRescale = res.c_str(); ui->advOutRescale->lineEdit()->setText(advRescale); ui->advOutRecRescale->lineEdit()->setText(advRecRescale); ui->advOutFFRescale->lineEdit()->setText(advFFRescale); if (ignoreAllSignals) { ui->advOutRescale->blockSignals(false); ui->advOutRecRescale->blockSignals(false); ui->advOutFFRescale->blockSignals(false); } } void OBSBasicSettings::LoadDownscaleFilters() { QString downscaleFilter = ui->downscaleFilter->currentData().toString(); if (downscaleFilter.isEmpty()) downscaleFilter = config_get_string(main->Config(), "Video", "ScaleType"); ui->downscaleFilter->clear(); if (ui->baseResolution->currentText() == ui->outputResolution->currentText()) { ui->downscaleFilter->setEnabled(false); ui->downscaleFilter->addItem( QTStr("Basic.Settings.Video.DownscaleFilter.Unavailable"), downscaleFilter); } else { ui->downscaleFilter->setEnabled(true); ui->downscaleFilter->addItem( QTStr("Basic.Settings.Video.DownscaleFilter.Bilinear"), QT_UTF8("bilinear")); ui->downscaleFilter->addItem( QTStr("Basic.Settings.Video.DownscaleFilter.Area"), QT_UTF8("area")); ui->downscaleFilter->addItem( QTStr("Basic.Settings.Video.DownscaleFilter.Bicubic"), QT_UTF8("bicubic")); ui->downscaleFilter->addItem( QTStr("Basic.Settings.Video.DownscaleFilter.Lanczos"), QT_UTF8("lanczos")); if (downscaleFilter == "bilinear") ui->downscaleFilter->setCurrentIndex(0); else if (downscaleFilter == "lanczos") ui->downscaleFilter->setCurrentIndex(3); else if (downscaleFilter == "area") ui->downscaleFilter->setCurrentIndex(1); else ui->downscaleFilter->setCurrentIndex(2); } } void OBSBasicSettings::LoadResolutionLists() { uint32_t cx = config_get_uint(main->Config(), "Video", "BaseCX"); uint32_t cy = config_get_uint(main->Config(), "Video", "BaseCY"); uint32_t out_cx = config_get_uint(main->Config(), "Video", "OutputCX"); uint32_t out_cy = config_get_uint(main->Config(), "Video", "OutputCY"); ui->baseResolution->clear(); auto addRes = [this](int cx, int cy) { QString res = ResString(cx, cy).c_str(); if (ui->baseResolution->findText(res) == -1) ui->baseResolution->addItem(res); }; for (QScreen *screen : QGuiApplication::screens()) { QSize as = screen->size(); uint32_t as_width = as.width(); uint32_t as_height = as.height(); // Calculate physical screen resolution based on the virtual screen resolution // They might differ if scaling is enabled, e.g. for HiDPI screens as_width = round(as_width * screen->devicePixelRatio()); as_height = round(as_height * screen->devicePixelRatio()); addRes(as_width, as_height); } addRes(1920, 1080); addRes(1280, 720); string outputResString = ResString(out_cx, out_cy); ui->baseResolution->lineEdit()->setText(ResString(cx, cy).c_str()); RecalcOutputResPixels(outputResString.c_str()); ResetDownscales(cx, cy); ui->outputResolution->lineEdit()->setText(outputResString.c_str()); std::tuple aspect = aspect_ratio(cx, cy); ui->baseAspect->setText( QTStr("AspectRatio") .arg(QString::number(std::get<0>(aspect)), QString::number(std::get<1>(aspect)))); } static inline void LoadFPSCommon(OBSBasic *main, Ui::OBSBasicSettings *ui) { const char *val = config_get_string(main->Config(), "Video", "FPSCommon"); int idx = ui->fpsCommon->findText(val); if (idx == -1) idx = 4; ui->fpsCommon->setCurrentIndex(idx); } static inline void LoadFPSInteger(OBSBasic *main, Ui::OBSBasicSettings *ui) { uint32_t val = config_get_uint(main->Config(), "Video", "FPSInt"); ui->fpsInteger->setValue(val); } static inline void LoadFPSFraction(OBSBasic *main, Ui::OBSBasicSettings *ui) { uint32_t num = config_get_uint(main->Config(), "Video", "FPSNum"); uint32_t den = config_get_uint(main->Config(), "Video", "FPSDen"); ui->fpsNumerator->setValue(num); ui->fpsDenominator->setValue(den); } void OBSBasicSettings::LoadFPSData() { LoadFPSCommon(main, ui.get()); LoadFPSInteger(main, ui.get()); LoadFPSFraction(main, ui.get()); uint32_t fpsType = config_get_uint(main->Config(), "Video", "FPSType"); if (fpsType > 2) fpsType = 0; ui->fpsType->setCurrentIndex(fpsType); ui->fpsTypes->setCurrentIndex(fpsType); } void OBSBasicSettings::LoadVideoSettings() { loading = true; if (obs_video_active()) { ui->videoPage->setEnabled(false); ui->videoMsg->setText( QTStr("Basic.Settings.Video.CurrentlyActive")); } LoadResolutionLists(); LoadFPSData(); LoadDownscaleFilters(); #ifdef _WIN32 if (toggleAero) { bool disableAero = config_get_bool(main->Config(), "Video", "DisableAero"); toggleAero->setChecked(disableAero); aeroWasDisabled = disableAero; } #endif loading = false; } static inline bool IsSurround(const char *speakers) { static const char *surroundLayouts[] = {"2.1", "4.0", "4.1", "5.1", "7.1", nullptr}; if (!speakers || !*speakers) return false; const char **curLayout = surroundLayouts; for (; *curLayout; ++curLayout) { if (strcmp(*curLayout, speakers) == 0) { return true; } } return false; } void OBSBasicSettings::LoadSimpleOutputSettings() { const char *path = config_get_string(main->Config(), "SimpleOutput", "FilePath"); bool noSpace = config_get_bool(main->Config(), "SimpleOutput", "FileNameWithoutSpace"); const char *format = config_get_string(main->Config(), "SimpleOutput", "RecFormat"); int videoBitrate = config_get_uint(main->Config(), "SimpleOutput", "VBitrate"); const char *streamEnc = config_get_string( main->Config(), "SimpleOutput", "StreamEncoder"); int audioBitrate = config_get_uint(main->Config(), "SimpleOutput", "ABitrate"); bool advanced = config_get_bool(main->Config(), "SimpleOutput", "UseAdvanced"); const char *preset = config_get_string(main->Config(), "SimpleOutput", "Preset"); const char *qsvPreset = config_get_string(main->Config(), "SimpleOutput", "QSVPreset"); const char *nvPreset = config_get_string(main->Config(), "SimpleOutput", "NVENCPreset"); const char *amdPreset = config_get_string(main->Config(), "SimpleOutput", "AMDPreset"); const char *custom = config_get_string(main->Config(), "SimpleOutput", "x264Settings"); const char *recQual = config_get_string(main->Config(), "SimpleOutput", "RecQuality"); const char *recEnc = config_get_string(main->Config(), "SimpleOutput", "RecEncoder"); const char *muxCustom = config_get_string( main->Config(), "SimpleOutput", "MuxerCustom"); bool replayBuf = config_get_bool(main->Config(), "SimpleOutput", "RecRB"); int rbTime = config_get_int(main->Config(), "SimpleOutput", "RecRBTime"); int rbSize = config_get_int(main->Config(), "SimpleOutput", "RecRBSize"); curPreset = preset; curQSVPreset = qsvPreset; curNVENCPreset = nvPreset; curAMDPreset = amdPreset; audioBitrate = FindClosestAvailableAACBitrate(audioBitrate); ui->simpleOutputPath->setText(path); ui->simpleNoSpace->setChecked(noSpace); ui->simpleOutputVBitrate->setValue(videoBitrate); int idx = ui->simpleOutRecFormat->findText(format); ui->simpleOutRecFormat->setCurrentIndex(idx); const char *speakers = config_get_string(main->Config(), "Audio", "ChannelSetup"); // restrict list of bitrates when multichannel is OFF if (!IsSurround(speakers)) RestrictResetBitrates({ui->simpleOutputABitrate}, 320); SetComboByName(ui->simpleOutputABitrate, std::to_string(audioBitrate).c_str()); ui->simpleOutAdvanced->setChecked(advanced); ui->simpleOutCustom->setText(custom); idx = ui->simpleOutRecQuality->findData(QString(recQual)); if (idx == -1) idx = 0; ui->simpleOutRecQuality->setCurrentIndex(idx); idx = ui->simpleOutStrEncoder->findData(QString(streamEnc)); if (idx == -1) idx = 0; ui->simpleOutStrEncoder->setCurrentIndex(idx); idx = ui->simpleOutRecEncoder->findData(QString(recEnc)); if (idx == -1) idx = 0; ui->simpleOutRecEncoder->setCurrentIndex(idx); ui->simpleOutMuxCustom->setText(muxCustom); ui->simpleReplayBuf->setChecked(replayBuf); ui->simpleRBSecMax->setValue(rbTime); ui->simpleRBMegsMax->setValue(rbSize); SimpleStreamingEncoderChanged(); } void OBSBasicSettings::LoadAdvOutputStreamingSettings() { bool rescale = config_get_bool(main->Config(), "AdvOut", "Rescale"); const char *rescaleRes = config_get_string(main->Config(), "AdvOut", "RescaleRes"); int trackIndex = config_get_int(main->Config(), "AdvOut", "TrackIndex"); ui->advOutUseRescale->setChecked(rescale); ui->advOutRescale->setEnabled(rescale); ui->advOutRescale->setCurrentText(rescaleRes); QStringList specList = QTStr("FilenameFormatting.completer") .split(QRegularExpression("\n")); QCompleter *specCompleter = new QCompleter(specList); specCompleter->setCaseSensitivity(Qt::CaseSensitive); specCompleter->setFilterMode(Qt::MatchContains); ui->filenameFormatting->setCompleter(specCompleter); ui->filenameFormatting->setToolTip(QTStr("FilenameFormatting.TT")); switch (trackIndex) { case 1: ui->advOutTrack1->setChecked(true); break; case 2: ui->advOutTrack2->setChecked(true); break; case 3: ui->advOutTrack3->setChecked(true); break; case 4: ui->advOutTrack4->setChecked(true); break; case 5: ui->advOutTrack5->setChecked(true); break; case 6: ui->advOutTrack6->setChecked(true); break; } } OBSPropertiesView * OBSBasicSettings::CreateEncoderPropertyView(const char *encoder, const char *path, bool changed) { OBSDataAutoRelease settings = obs_encoder_defaults(encoder); OBSPropertiesView *view; if (path) { char encoderJsonPath[512]; int ret = GetProfilePath(encoderJsonPath, sizeof(encoderJsonPath), path); if (ret > 0) { obs_data_t *data = obs_data_create_from_json_file_safe( encoderJsonPath, "bak"); obs_data_apply(settings, data); obs_data_release(data); } } view = new OBSPropertiesView( settings.Get(), encoder, (PropertiesReloadCallback)obs_get_encoder_properties, 170); view->setFrameShape(QFrame::NoFrame); view->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); view->setProperty("changed", QVariant(changed)); QObject::connect(view, SIGNAL(Changed()), this, SLOT(OutputsChanged())); return view; } void OBSBasicSettings::LoadAdvOutputStreamingEncoderProperties() { const char *type = config_get_string(main->Config(), "AdvOut", "Encoder"); delete streamEncoderProps; streamEncoderProps = CreateEncoderPropertyView(type, "streamEncoder.json"); streamEncoderProps->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); ui->advOutEncoderLayout->addWidget(streamEncoderProps); connect(streamEncoderProps, SIGNAL(Changed()), this, SLOT(UpdateStreamDelayEstimate())); connect(streamEncoderProps, SIGNAL(Changed()), this, SLOT(AdvReplayBufferChanged())); curAdvStreamEncoder = type; if (!SetComboByValue(ui->advOutEncoder, type)) { uint32_t caps = obs_get_encoder_caps(type); if ((caps & ENCODER_HIDE_FLAGS) != 0) { const char *name = obs_encoder_get_display_name(type); ui->advOutEncoder->insertItem(0, QT_UTF8(name), QT_UTF8(type)); SetComboByValue(ui->advOutEncoder, type); } } UpdateStreamDelayEstimate(); } void OBSBasicSettings::LoadAdvOutputRecordingSettings() { const char *type = config_get_string(main->Config(), "AdvOut", "RecType"); const char *format = config_get_string(main->Config(), "AdvOut", "RecFormat"); const char *path = config_get_string(main->Config(), "AdvOut", "RecFilePath"); bool noSpace = config_get_bool(main->Config(), "AdvOut", "RecFileNameWithoutSpace"); bool rescale = config_get_bool(main->Config(), "AdvOut", "RecRescale"); const char *rescaleRes = config_get_string(main->Config(), "AdvOut", "RecRescaleRes"); const char *muxCustom = config_get_string(main->Config(), "AdvOut", "RecMuxerCustom"); int tracks = config_get_int(main->Config(), "AdvOut", "RecTracks"); int flvTrack = config_get_int(main->Config(), "AdvOut", "FLVTrack"); bool splitFile = config_get_bool(main->Config(), "AdvOut", "RecSplitFile"); const char *splitFileType = config_get_string(main->Config(), "AdvOut", "RecSplitFileType"); int splitFileTime = config_get_int(main->Config(), "AdvOut", "RecSplitFileTime"); int splitFileSize = config_get_int(main->Config(), "AdvOut", "RecSplitFileSize"); int typeIndex = (astrcmpi(type, "FFmpeg") == 0) ? 1 : 0; ui->advOutRecType->setCurrentIndex(typeIndex); ui->advOutRecPath->setText(path); ui->advOutNoSpace->setChecked(noSpace); ui->advOutRecUseRescale->setChecked(rescale); ui->advOutRecRescale->setCurrentText(rescaleRes); ui->advOutMuxCustom->setText(muxCustom); int idx = ui->advOutRecFormat->findText(format); ui->advOutRecFormat->setCurrentIndex(idx); ui->advOutRecTrack1->setChecked(tracks & (1 << 0)); ui->advOutRecTrack2->setChecked(tracks & (1 << 1)); ui->advOutRecTrack3->setChecked(tracks & (1 << 2)); ui->advOutRecTrack4->setChecked(tracks & (1 << 3)); ui->advOutRecTrack5->setChecked(tracks & (1 << 4)); ui->advOutRecTrack6->setChecked(tracks & (1 << 5)); if (astrcmpi(splitFileType, "Size") == 0) idx = 1; else if (astrcmpi(splitFileType, "Manual") == 0) idx = 2; else idx = 0; ui->advOutSplitFile->setChecked(splitFile); ui->advOutSplitFileType->setCurrentIndex(idx); ui->advOutSplitFileTime->setValue(splitFileTime); ui->advOutSplitFileSize->setValue(splitFileSize); switch (flvTrack) { case 1: ui->flvTrack1->setChecked(true); break; case 2: ui->flvTrack2->setChecked(true); break; case 3: ui->flvTrack3->setChecked(true); break; case 4: ui->flvTrack4->setChecked(true); break; case 5: ui->flvTrack5->setChecked(true); break; case 6: ui->flvTrack6->setChecked(true); break; default: ui->flvTrack1->setChecked(true); break; } } void OBSBasicSettings::LoadAdvOutputRecordingEncoderProperties() { const char *type = config_get_string(main->Config(), "AdvOut", "RecEncoder"); delete recordEncoderProps; recordEncoderProps = nullptr; if (astrcmpi(type, "none") != 0) { recordEncoderProps = CreateEncoderPropertyView(type, "recordEncoder.json"); recordEncoderProps->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); ui->advOutRecEncoderProps->layout()->addWidget( recordEncoderProps); connect(recordEncoderProps, SIGNAL(Changed()), this, SLOT(AdvReplayBufferChanged())); } curAdvRecordEncoder = type; if (!SetComboByValue(ui->advOutRecEncoder, type)) { uint32_t caps = obs_get_encoder_caps(type); if ((caps & ENCODER_HIDE_FLAGS) != 0) { const char *name = obs_encoder_get_display_name(type); ui->advOutRecEncoder->insertItem(1, QT_UTF8(name), QT_UTF8(type)); SetComboByValue(ui->advOutRecEncoder, type); } } } static void SelectFormat(QComboBox *combo, const char *name, const char *mimeType) { FormatDesc formatDesc(name, mimeType); for (int i = 0; i < combo->count(); i++) { QVariant v = combo->itemData(i); if (!v.isNull()) { if (formatDesc == v.value()) { combo->setCurrentIndex(i); return; } } } combo->setCurrentIndex(0); } static void SelectEncoder(QComboBox *combo, const char *name, int id) { int idx = FindEncoder(combo, name, id); if (idx >= 0) combo->setCurrentIndex(idx); } void OBSBasicSettings::LoadAdvOutputFFmpegSettings() { bool saveFile = config_get_bool(main->Config(), "AdvOut", "FFOutputToFile"); const char *path = config_get_string(main->Config(), "AdvOut", "FFFilePath"); bool noSpace = config_get_bool(main->Config(), "AdvOut", "FFFileNameWithoutSpace"); const char *url = config_get_string(main->Config(), "AdvOut", "FFURL"); const char *format = config_get_string(main->Config(), "AdvOut", "FFFormat"); const char *mimeType = config_get_string(main->Config(), "AdvOut", "FFFormatMimeType"); const char *muxCustom = config_get_string(main->Config(), "AdvOut", "FFMCustom"); int videoBitrate = config_get_int(main->Config(), "AdvOut", "FFVBitrate"); int gopSize = config_get_int(main->Config(), "AdvOut", "FFVGOPSize"); bool rescale = config_get_bool(main->Config(), "AdvOut", "FFRescale"); bool codecCompat = config_get_bool(main->Config(), "AdvOut", "FFIgnoreCompat"); const char *rescaleRes = config_get_string(main->Config(), "AdvOut", "FFRescaleRes"); const char *vEncoder = config_get_string(main->Config(), "AdvOut", "FFVEncoder"); int vEncoderId = config_get_int(main->Config(), "AdvOut", "FFVEncoderId"); const char *vEncCustom = config_get_string(main->Config(), "AdvOut", "FFVCustom"); int audioBitrate = config_get_int(main->Config(), "AdvOut", "FFABitrate"); int audioMixes = config_get_int(main->Config(), "AdvOut", "FFAudioMixes"); const char *aEncoder = config_get_string(main->Config(), "AdvOut", "FFAEncoder"); int aEncoderId = config_get_int(main->Config(), "AdvOut", "FFAEncoderId"); const char *aEncCustom = config_get_string(main->Config(), "AdvOut", "FFACustom"); ui->advOutFFType->setCurrentIndex(saveFile ? 0 : 1); ui->advOutFFRecPath->setText(QT_UTF8(path)); ui->advOutFFNoSpace->setChecked(noSpace); ui->advOutFFURL->setText(QT_UTF8(url)); SelectFormat(ui->advOutFFFormat, format, mimeType); ui->advOutFFMCfg->setText(muxCustom); ui->advOutFFVBitrate->setValue(videoBitrate); ui->advOutFFVGOPSize->setValue(gopSize); ui->advOutFFUseRescale->setChecked(rescale); ui->advOutFFIgnoreCompat->setChecked(codecCompat); ui->advOutFFRescale->setEnabled(rescale); ui->advOutFFRescale->setCurrentText(rescaleRes); SelectEncoder(ui->advOutFFVEncoder, vEncoder, vEncoderId); ui->advOutFFVCfg->setText(vEncCustom); ui->advOutFFABitrate->setValue(audioBitrate); SelectEncoder(ui->advOutFFAEncoder, aEncoder, aEncoderId); ui->advOutFFACfg->setText(aEncCustom); ui->advOutFFTrack1->setChecked(audioMixes & (1 << 0)); ui->advOutFFTrack2->setChecked(audioMixes & (1 << 1)); ui->advOutFFTrack3->setChecked(audioMixes & (1 << 2)); ui->advOutFFTrack4->setChecked(audioMixes & (1 << 3)); ui->advOutFFTrack5->setChecked(audioMixes & (1 << 4)); ui->advOutFFTrack6->setChecked(audioMixes & (1 << 5)); } void OBSBasicSettings::LoadAdvOutputAudioSettings() { int track1Bitrate = config_get_uint(main->Config(), "AdvOut", "Track1Bitrate"); int track2Bitrate = config_get_uint(main->Config(), "AdvOut", "Track2Bitrate"); int track3Bitrate = config_get_uint(main->Config(), "AdvOut", "Track3Bitrate"); int track4Bitrate = config_get_uint(main->Config(), "AdvOut", "Track4Bitrate"); int track5Bitrate = config_get_uint(main->Config(), "AdvOut", "Track5Bitrate"); int track6Bitrate = config_get_uint(main->Config(), "AdvOut", "Track6Bitrate"); const char *name1 = config_get_string(main->Config(), "AdvOut", "Track1Name"); const char *name2 = config_get_string(main->Config(), "AdvOut", "Track2Name"); const char *name3 = config_get_string(main->Config(), "AdvOut", "Track3Name"); const char *name4 = config_get_string(main->Config(), "AdvOut", "Track4Name"); const char *name5 = config_get_string(main->Config(), "AdvOut", "Track5Name"); const char *name6 = config_get_string(main->Config(), "AdvOut", "Track6Name"); track1Bitrate = FindClosestAvailableAACBitrate(track1Bitrate); track2Bitrate = FindClosestAvailableAACBitrate(track2Bitrate); track3Bitrate = FindClosestAvailableAACBitrate(track3Bitrate); track4Bitrate = FindClosestAvailableAACBitrate(track4Bitrate); track5Bitrate = FindClosestAvailableAACBitrate(track5Bitrate); track6Bitrate = FindClosestAvailableAACBitrate(track6Bitrate); // restrict list of bitrates when multichannel is OFF const char *speakers = config_get_string(main->Config(), "Audio", "ChannelSetup"); // restrict list of bitrates when multichannel is OFF if (!IsSurround(speakers)) { RestrictResetBitrates( {ui->advOutTrack1Bitrate, ui->advOutTrack2Bitrate, ui->advOutTrack3Bitrate, ui->advOutTrack4Bitrate, ui->advOutTrack5Bitrate, ui->advOutTrack6Bitrate}, 320); } SetComboByName(ui->advOutTrack1Bitrate, std::to_string(track1Bitrate).c_str()); SetComboByName(ui->advOutTrack2Bitrate, std::to_string(track2Bitrate).c_str()); SetComboByName(ui->advOutTrack3Bitrate, std::to_string(track3Bitrate).c_str()); SetComboByName(ui->advOutTrack4Bitrate, std::to_string(track4Bitrate).c_str()); SetComboByName(ui->advOutTrack5Bitrate, std::to_string(track5Bitrate).c_str()); SetComboByName(ui->advOutTrack6Bitrate, std::to_string(track6Bitrate).c_str()); ui->advOutTrack1Name->setText(name1); ui->advOutTrack2Name->setText(name2); ui->advOutTrack3Name->setText(name3); ui->advOutTrack4Name->setText(name4); ui->advOutTrack5Name->setText(name5); ui->advOutTrack6Name->setText(name6); } void OBSBasicSettings::LoadOutputSettings() { loading = true; ResetEncoders(); const char *mode = config_get_string(main->Config(), "Output", "Mode"); int modeIdx = astrcmpi(mode, "Advanced") == 0 ? 1 : 0; ui->outputMode->setCurrentIndex(modeIdx); LoadSimpleOutputSettings(); LoadAdvOutputStreamingSettings(); LoadAdvOutputStreamingEncoderProperties(); LoadAdvOutputRecordingSettings(); LoadAdvOutputRecordingEncoderProperties(); LoadAdvOutputFFmpegSettings(); LoadAdvOutputAudioSettings(); if (obs_video_active()) { ui->outputMode->setEnabled(false); ui->outputModeLabel->setEnabled(false); ui->simpleOutStrEncoderLabel->setEnabled(false); ui->simpleOutStrEncoder->setEnabled(false); ui->simpleRecordingGroupBox->setEnabled(false); ui->replayBufferGroupBox->setEnabled(false); ui->advOutTopContainer->setEnabled(false); ui->advOutRecTopContainer->setEnabled(false); ui->advOutRecTypeContainer->setEnabled(false); ui->advOutputAudioTracksTab->setEnabled(false); ui->advNetworkGroupBox->setEnabled(false); } loading = false; } void OBSBasicSettings::SetAdvOutputFFmpegEnablement(ff_codec_type encoderType, bool enabled, bool enableEncoder) { bool rescale = config_get_bool(main->Config(), "AdvOut", "FFRescale"); switch (encoderType) { case FF_CODEC_VIDEO: ui->advOutFFVBitrate->setEnabled(enabled); ui->advOutFFVGOPSize->setEnabled(enabled); ui->advOutFFUseRescale->setEnabled(enabled); ui->advOutFFRescale->setEnabled(enabled && rescale); ui->advOutFFVEncoder->setEnabled(enabled || enableEncoder); ui->advOutFFVCfg->setEnabled(enabled); break; case FF_CODEC_AUDIO: ui->advOutFFABitrate->setEnabled(enabled); ui->advOutFFAEncoder->setEnabled(enabled || enableEncoder); ui->advOutFFACfg->setEnabled(enabled); ui->advOutFFTrack1->setEnabled(enabled); ui->advOutFFTrack2->setEnabled(enabled); ui->advOutFFTrack3->setEnabled(enabled); ui->advOutFFTrack4->setEnabled(enabled); ui->advOutFFTrack5->setEnabled(enabled); ui->advOutFFTrack6->setEnabled(enabled); default: break; } } static inline void LoadListValue(QComboBox *widget, const char *text, const char *val) { widget->addItem(QT_UTF8(text), QT_UTF8(val)); } void OBSBasicSettings::LoadListValues(QComboBox *widget, obs_property_t *prop, int index) { size_t count = obs_property_list_item_count(prop); OBSSourceAutoRelease source = obs_get_output_source(index); const char *deviceId = nullptr; OBSDataAutoRelease settings = nullptr; if (source) { settings = obs_source_get_settings(source); if (settings) deviceId = obs_data_get_string(settings, "device_id"); } widget->addItem(QTStr("Basic.Settings.Audio.Disabled"), "disabled"); for (size_t i = 0; i < count; i++) { const char *name = obs_property_list_item_name(prop, i); const char *val = obs_property_list_item_string(prop, i); LoadListValue(widget, name, val); } if (deviceId) { QVariant var(QT_UTF8(deviceId)); int idx = widget->findData(var); if (idx != -1) { widget->setCurrentIndex(idx); } else { widget->insertItem(0, QTStr("Basic.Settings.Audio." "UnknownAudioDevice"), var); widget->setCurrentIndex(0); HighlightGroupBoxLabel(ui->audioDevicesGroupBox, widget, "errorLabel"); } } } void OBSBasicSettings::LoadAudioDevices() { const char *input_id = App()->InputAudioSource(); const char *output_id = App()->OutputAudioSource(); obs_properties_t *input_props = obs_get_source_properties(input_id); obs_properties_t *output_props = obs_get_source_properties(output_id); if (input_props) { obs_property_t *inputs = obs_properties_get(input_props, "device_id"); LoadListValues(ui->auxAudioDevice1, inputs, 3); LoadListValues(ui->auxAudioDevice2, inputs, 4); LoadListValues(ui->auxAudioDevice3, inputs, 5); LoadListValues(ui->auxAudioDevice4, inputs, 6); obs_properties_destroy(input_props); } if (output_props) { obs_property_t *outputs = obs_properties_get(output_props, "device_id"); LoadListValues(ui->desktopAudioDevice1, outputs, 1); LoadListValues(ui->desktopAudioDevice2, outputs, 2); obs_properties_destroy(output_props); } if (obs_video_active()) { ui->sampleRate->setEnabled(false); ui->channelSetup->setEnabled(false); } } #define NBSP "\xC2\xA0" void OBSBasicSettings::LoadAudioSources() { if (ui->audioSourceLayout->rowCount() > 0) { QLayoutItem *forDeletion = ui->audioSourceLayout->takeAt(0); forDeletion->widget()->deleteLater(); delete forDeletion; } auto layout = new QFormLayout(); layout->setVerticalSpacing(15); layout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow); audioSourceSignals.clear(); audioSources.clear(); auto widget = new QWidget(); widget->setLayout(layout); ui->audioSourceLayout->addRow(widget); const char *enablePtm = Str("Basic.Settings.Audio.EnablePushToMute"); const char *ptmDelay = Str("Basic.Settings.Audio.PushToMuteDelay"); const char *enablePtt = Str("Basic.Settings.Audio.EnablePushToTalk"); const char *pttDelay = Str("Basic.Settings.Audio.PushToTalkDelay"); auto AddSource = [&](obs_source_t *source) { if (!(obs_source_get_output_flags(source) & OBS_SOURCE_AUDIO)) return true; auto form = new QFormLayout(); form->setVerticalSpacing(0); form->setHorizontalSpacing(5); form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow); auto ptmCB = new SilentUpdateCheckBox(); ptmCB->setText(enablePtm); ptmCB->setChecked(obs_source_push_to_mute_enabled(source)); form->addRow(ptmCB); auto ptmSB = new SilentUpdateSpinBox(); ptmSB->setSuffix(NBSP "ms"); ptmSB->setRange(0, INT_MAX); ptmSB->setValue(obs_source_get_push_to_mute_delay(source)); form->addRow(ptmDelay, ptmSB); auto pttCB = new SilentUpdateCheckBox(); pttCB->setText(enablePtt); pttCB->setChecked(obs_source_push_to_talk_enabled(source)); form->addRow(pttCB); auto pttSB = new SilentUpdateSpinBox(); pttSB->setSuffix(NBSP "ms"); pttSB->setRange(0, INT_MAX); pttSB->setValue(obs_source_get_push_to_talk_delay(source)); form->addRow(pttDelay, pttSB); HookWidget(ptmCB, CHECK_CHANGED, AUDIO_CHANGED); HookWidget(ptmSB, SCROLL_CHANGED, AUDIO_CHANGED); HookWidget(pttCB, CHECK_CHANGED, AUDIO_CHANGED); HookWidget(pttSB, SCROLL_CHANGED, AUDIO_CHANGED); audioSourceSignals.reserve(audioSourceSignals.size() + 4); auto handler = obs_source_get_signal_handler(source); audioSourceSignals.emplace_back( handler, "push_to_mute_changed", [](void *data, calldata_t *param) { QMetaObject::invokeMethod( static_cast(data), "setCheckedSilently", Q_ARG(bool, calldata_bool(param, "enabled"))); }, ptmCB); audioSourceSignals.emplace_back( handler, "push_to_mute_delay", [](void *data, calldata_t *param) { QMetaObject::invokeMethod( static_cast(data), "setValueSilently", Q_ARG(int, calldata_int(param, "delay"))); }, ptmSB); audioSourceSignals.emplace_back( handler, "push_to_talk_changed", [](void *data, calldata_t *param) { QMetaObject::invokeMethod( static_cast(data), "setCheckedSilently", Q_ARG(bool, calldata_bool(param, "enabled"))); }, pttCB); audioSourceSignals.emplace_back( handler, "push_to_talk_delay", [](void *data, calldata_t *param) { QMetaObject::invokeMethod( static_cast(data), "setValueSilently", Q_ARG(int, calldata_int(param, "delay"))); }, pttSB); audioSources.emplace_back(OBSGetWeakRef(source), ptmCB, ptmSB, pttCB, pttSB); auto label = new OBSSourceLabel(source); TruncateLabel(label, label->text()); label->setMinimumSize(QSize(170, 0)); label->setAlignment(Qt::AlignRight | Qt::AlignTrailing | Qt::AlignVCenter); connect(label, &OBSSourceLabel::Removed, [=]() { QMetaObject::invokeMethod(this, "ReloadAudioSources"); }); connect(label, &OBSSourceLabel::Destroyed, [=]() { QMetaObject::invokeMethod(this, "ReloadAudioSources"); }); layout->addRow(label, form); return true; }; using AddSource_t = decltype(AddSource); obs_enum_sources( [](void *data, obs_source_t *source) { auto &AddSource = *static_cast(data); if (!obs_source_removed(source)) AddSource(source); return true; }, static_cast(&AddSource)); if (layout->rowCount() == 0) ui->audioHotkeysGroupBox->hide(); else ui->audioHotkeysGroupBox->show(); } void OBSBasicSettings::LoadAudioSettings() { uint32_t sampleRate = config_get_uint(main->Config(), "Audio", "SampleRate"); const char *speakers = config_get_string(main->Config(), "Audio", "ChannelSetup"); double meterDecayRate = config_get_double(main->Config(), "Audio", "MeterDecayRate"); uint32_t peakMeterTypeIdx = config_get_uint(main->Config(), "Audio", "PeakMeterType"); bool enableLLAudioBuffering = config_get_bool( GetGlobalConfig(), "Audio", "LowLatencyAudioBuffering"); loading = true; const char *str; if (sampleRate == 48000) str = "48 kHz"; else str = "44.1 kHz"; int sampleRateIdx = ui->sampleRate->findText(str); if (sampleRateIdx != -1) ui->sampleRate->setCurrentIndex(sampleRateIdx); if (strcmp(speakers, "Mono") == 0) ui->channelSetup->setCurrentIndex(0); else if (strcmp(speakers, "2.1") == 0) ui->channelSetup->setCurrentIndex(2); else if (strcmp(speakers, "4.0") == 0) ui->channelSetup->setCurrentIndex(3); else if (strcmp(speakers, "4.1") == 0) ui->channelSetup->setCurrentIndex(4); else if (strcmp(speakers, "5.1") == 0) ui->channelSetup->setCurrentIndex(5); else if (strcmp(speakers, "7.1") == 0) ui->channelSetup->setCurrentIndex(6); else ui->channelSetup->setCurrentIndex(1); if (meterDecayRate == VOLUME_METER_DECAY_MEDIUM) ui->meterDecayRate->setCurrentIndex(1); else if (meterDecayRate == VOLUME_METER_DECAY_SLOW) ui->meterDecayRate->setCurrentIndex(2); else ui->meterDecayRate->setCurrentIndex(0); ui->peakMeterType->setCurrentIndex(peakMeterTypeIdx); ui->lowLatencyBuffering->setChecked(enableLLAudioBuffering); LoadAudioDevices(); LoadAudioSources(); loading = false; } void OBSBasicSettings::UpdateColorFormatSpaceWarning() { const QString format = ui->colorFormat->currentData().toString(); switch (ui->colorSpace->currentIndex()) { case 3: /* Rec.2100 (PQ) */ case 4: /* Rec.2100 (HLG) */ if (format == "P010") { ui->advancedMsg2->clear(); } else if (format == "I010") { ui->advancedMsg2->setText( QTStr("Basic.Settings.Advanced.FormatWarning")); } else { ui->advancedMsg2->setText(QTStr( "Basic.Settings.Advanced.FormatWarning2100")); } break; default: if (format == "NV12") { ui->advancedMsg2->clear(); } else if ((format == "I010") || (format == "P010")) { ui->advancedMsg2->setText(QTStr( "Basic.Settings.Advanced.FormatWarning10BitSdr")); } else { ui->advancedMsg2->setText( QTStr("Basic.Settings.Advanced.FormatWarning")); } } } void OBSBasicSettings::LoadAdvancedSettings() { const char *videoColorFormat = config_get_string(main->Config(), "Video", "ColorFormat"); const char *videoColorSpace = config_get_string(main->Config(), "Video", "ColorSpace"); const char *videoColorRange = config_get_string(main->Config(), "Video", "ColorRange"); uint32_t sdrWhiteLevel = (uint32_t)config_get_uint( main->Config(), "Video", "SdrWhiteLevel"); uint32_t hdrNominalPeakLevel = (uint32_t)config_get_uint( main->Config(), "Video", "HdrNominalPeakLevel"); QString monDevName; QString monDevId; if (obs_audio_monitoring_available()) { monDevName = config_get_string(main->Config(), "Audio", "MonitoringDeviceName"); monDevId = config_get_string(main->Config(), "Audio", "MonitoringDeviceId"); } bool enableDelay = config_get_bool(main->Config(), "Output", "DelayEnable"); int delaySec = config_get_int(main->Config(), "Output", "DelaySec"); bool preserveDelay = config_get_bool(main->Config(), "Output", "DelayPreserve"); bool reconnect = config_get_bool(main->Config(), "Output", "Reconnect"); int retryDelay = config_get_int(main->Config(), "Output", "RetryDelay"); int maxRetries = config_get_int(main->Config(), "Output", "MaxRetries"); const char *filename = config_get_string(main->Config(), "Output", "FilenameFormatting"); bool overwriteIfExists = config_get_bool(main->Config(), "Output", "OverwriteIfExists"); const char *bindIP = config_get_string(main->Config(), "Output", "BindIP"); const char *rbPrefix = config_get_string(main->Config(), "SimpleOutput", "RecRBPrefix"); const char *rbSuffix = config_get_string(main->Config(), "SimpleOutput", "RecRBSuffix"); bool replayBuf = config_get_bool(main->Config(), "AdvOut", "RecRB"); int rbTime = config_get_int(main->Config(), "AdvOut", "RecRBTime"); int rbSize = config_get_int(main->Config(), "AdvOut", "RecRBSize"); bool autoRemux = config_get_bool(main->Config(), "Video", "AutoRemux"); const char *hotkeyFocusType = config_get_string( App()->GlobalConfig(), "General", "HotkeyFocusType"); bool dynBitrate = config_get_bool(main->Config(), "Output", "DynamicBitrate"); bool confirmOnExit = config_get_bool(GetGlobalConfig(), "General", "ConfirmOnExit"); ui->confirmOnExit->setChecked(confirmOnExit); loading = true; LoadRendererList(); if (obs_audio_monitoring_available() && !SetComboByValue(ui->monitoringDevice, monDevId.toUtf8())) SetInvalidValue(ui->monitoringDevice, monDevName.toUtf8(), monDevId.toUtf8()); ui->filenameFormatting->setText(filename); ui->overwriteIfExists->setChecked(overwriteIfExists); ui->simpleRBPrefix->setText(rbPrefix); ui->simpleRBSuffix->setText(rbSuffix); ui->advReplayBuf->setChecked(replayBuf); ui->advRBSecMax->setValue(rbTime); ui->advRBMegsMax->setValue(rbSize); ui->reconnectEnable->setChecked(reconnect); ui->reconnectRetryDelay->setValue(retryDelay); ui->reconnectMaxRetries->setValue(maxRetries); ui->streamDelaySec->setValue(delaySec); ui->streamDelayPreserve->setChecked(preserveDelay); ui->streamDelayEnable->setChecked(enableDelay); ui->autoRemux->setChecked(autoRemux); ui->dynBitrate->setChecked(dynBitrate); SetComboByValue(ui->colorFormat, videoColorFormat); SetComboByValue(ui->colorSpace, videoColorSpace); SetComboByValue(ui->colorRange, videoColorRange); ui->sdrWhiteLevel->setValue(sdrWhiteLevel); ui->hdrNominalPeakLevel->setValue(hdrNominalPeakLevel); if (!SetComboByValue(ui->bindToIP, bindIP)) SetInvalidValue(ui->bindToIP, bindIP, bindIP); if (obs_video_active()) { ui->advancedVideoContainer->setEnabled(false); } #ifdef __APPLE__ bool disableOSXVSync = config_get_bool(App()->GlobalConfig(), "Video", "DisableOSXVSync"); bool resetOSXVSync = config_get_bool(App()->GlobalConfig(), "Video", "ResetOSXVSyncOnExit"); ui->disableOSXVSync->setChecked(disableOSXVSync); ui->resetOSXVSync->setChecked(resetOSXVSync); ui->resetOSXVSync->setEnabled(disableOSXVSync); #elif _WIN32 bool disableAudioDucking = config_get_bool( App()->GlobalConfig(), "Audio", "DisableAudioDucking"); ui->disableAudioDucking->setChecked(disableAudioDucking); const char *processPriority = config_get_string( App()->GlobalConfig(), "General", "ProcessPriority"); bool enableNewSocketLoop = config_get_bool(main->Config(), "Output", "NewSocketLoopEnable"); bool enableLowLatencyMode = config_get_bool(main->Config(), "Output", "LowLatencyEnable"); int idx = ui->processPriority->findData(processPriority); if (idx == -1) idx = ui->processPriority->findData("Normal"); ui->processPriority->setCurrentIndex(idx); ui->enableNewSocketLoop->setChecked(enableNewSocketLoop); ui->enableLowLatencyMode->setChecked(enableLowLatencyMode); ui->enableLowLatencyMode->setToolTip( QTStr("Basic.Settings.Advanced.Network.TCPPacing.Tooltip")); #endif #if defined(_WIN32) || defined(__APPLE__) bool browserHWAccel = config_get_bool(App()->GlobalConfig(), "General", "BrowserHWAccel"); ui->browserHWAccel->setChecked(browserHWAccel); prevBrowserAccel = ui->browserHWAccel->isChecked(); #endif SetComboByValue(ui->hotkeyFocusType, hotkeyFocusType); loading = false; } template static inline void LayoutHotkey(OBSBasicSettings *settings, obs_hotkey_id id, obs_hotkey_t *key, Func &&fun, const map> &keys) { auto *label = new OBSHotkeyLabel; QString text = QT_UTF8(obs_hotkey_get_description(key)); label->setProperty("fullName", text); TruncateLabel(label, text); OBSHotkeyWidget *hw = nullptr; auto combos = keys.find(id); if (combos == std::end(keys)) hw = new OBSHotkeyWidget(settings, id, obs_hotkey_get_name(key), settings); else hw = new OBSHotkeyWidget(settings, id, obs_hotkey_get_name(key), settings, combos->second); hw->label = label; label->widget = hw; fun(key, label, hw); } template static QLabel *makeLabel(T &t, Func &&getName) { QLabel *label = new QLabel(getName(t)); label->setStyleSheet("font-weight: bold;"); return label; } template static QLabel *makeLabel(const OBSSource &source, Func &&) { OBSSourceLabel *label = new OBSSourceLabel(source); label->setStyleSheet("font-weight: bold;"); QString name = QT_UTF8(obs_source_get_name(source)); TruncateLabel(label, name); return label; } template static inline void AddHotkeys( QFormLayout &layout, Func &&getName, std::vector, QPointer>> &hotkeys) { if (hotkeys.empty()) return; layout.setItem(layout.rowCount(), QFormLayout::SpanningRole, new QSpacerItem(0, 10)); using tuple_type = std::tuple, QPointer>; stable_sort(begin(hotkeys), end(hotkeys), [&](const tuple_type &a, const tuple_type &b) { const auto &o_a = get<0>(a); const auto &o_b = get<0>(b); return o_a != o_b && string(getName(o_a)) < getName(o_b); }); string prevName; for (const auto &hotkey : hotkeys) { const auto &o = get<0>(hotkey); const char *name = getName(o); if (prevName != name) { prevName = name; layout.setItem(layout.rowCount(), QFormLayout::SpanningRole, new QSpacerItem(0, 10)); layout.addRow(makeLabel(o, getName)); } auto hlabel = get<1>(hotkey); auto widget = get<2>(hotkey); layout.addRow(hlabel, widget); } } void OBSBasicSettings::LoadHotkeySettings(obs_hotkey_id ignoreKey) { hotkeys.clear(); if (ui->hotkeyFormLayout->rowCount() > 0) { QLayoutItem *forDeletion = ui->hotkeyFormLayout->takeAt(0); forDeletion->widget()->deleteLater(); delete forDeletion; } ui->hotkeyFilterSearch->blockSignals(true); ui->hotkeyFilterInput->blockSignals(true); ui->hotkeyFilterSearch->setText(""); ui->hotkeyFilterInput->ResetKey(); ui->hotkeyFilterSearch->blockSignals(false); ui->hotkeyFilterInput->blockSignals(false); using keys_t = map>; keys_t keys; obs_enum_hotkey_bindings( [](void *data, size_t, obs_hotkey_binding_t *binding) { auto &keys = *static_cast(data); keys[obs_hotkey_binding_get_hotkey_id(binding)] .emplace_back( obs_hotkey_binding_get_key_combination( binding)); return true; }, &keys); QFormLayout *hotkeysLayout = new QFormLayout(); hotkeysLayout->setVerticalSpacing(0); hotkeysLayout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow); hotkeysLayout->setLabelAlignment(Qt::AlignRight | Qt::AlignTrailing | Qt::AlignVCenter); auto hotkeyChildWidget = new QWidget(); hotkeyChildWidget->setLayout(hotkeysLayout); ui->hotkeyFormLayout->addRow(hotkeyChildWidget); using namespace std; using encoders_elem_t = tuple, QPointer>; using outputs_elem_t = tuple, QPointer>; using services_elem_t = tuple, QPointer>; using sources_elem_t = tuple, QPointer>; vector encoders; vector outputs; vector services; vector scenes; vector sources; vector pairIds; map> pairLabels; using std::move; auto HandleEncoder = [&](void *registerer, OBSHotkeyLabel *label, OBSHotkeyWidget *hw) { auto weak_encoder = static_cast(registerer); auto encoder = OBSGetStrongRef(weak_encoder); if (!encoder) return true; encoders.emplace_back(move(encoder), label, hw); return false; }; auto HandleOutput = [&](void *registerer, OBSHotkeyLabel *label, OBSHotkeyWidget *hw) { auto weak_output = static_cast(registerer); auto output = OBSGetStrongRef(weak_output); if (!output) return true; outputs.emplace_back(move(output), label, hw); return false; }; auto HandleService = [&](void *registerer, OBSHotkeyLabel *label, OBSHotkeyWidget *hw) { auto weak_service = static_cast(registerer); auto service = OBSGetStrongRef(weak_service); if (!service) return true; services.emplace_back(move(service), label, hw); return false; }; auto HandleSource = [&](void *registerer, OBSHotkeyLabel *label, OBSHotkeyWidget *hw) { auto weak_source = static_cast(registerer); auto source = OBSGetStrongRef(weak_source); if (!source) return true; if (obs_scene_from_source(source)) scenes.emplace_back(source, label, hw); else if (obs_source_get_name(source) != NULL) sources.emplace_back(source, label, hw); return false; }; auto RegisterHotkey = [&](obs_hotkey_t *key, OBSHotkeyLabel *label, OBSHotkeyWidget *hw) { auto registerer_type = obs_hotkey_get_registerer_type(key); void *registerer = obs_hotkey_get_registerer(key); obs_hotkey_id partner = obs_hotkey_get_pair_partner_id(key); if (partner != OBS_INVALID_HOTKEY_ID) { pairLabels.emplace(obs_hotkey_get_id(key), make_pair(partner, label)); pairIds.push_back(obs_hotkey_get_id(key)); } using std::move; switch (registerer_type) { case OBS_HOTKEY_REGISTERER_FRONTEND: hotkeysLayout->addRow(label, hw); break; case OBS_HOTKEY_REGISTERER_ENCODER: if (HandleEncoder(registerer, label, hw)) return; break; case OBS_HOTKEY_REGISTERER_OUTPUT: if (HandleOutput(registerer, label, hw)) return; break; case OBS_HOTKEY_REGISTERER_SERVICE: if (HandleService(registerer, label, hw)) return; break; case OBS_HOTKEY_REGISTERER_SOURCE: if (HandleSource(registerer, label, hw)) return; break; } hotkeys.emplace_back( registerer_type == OBS_HOTKEY_REGISTERER_FRONTEND, hw); connect(hw, &OBSHotkeyWidget::KeyChanged, this, [=]() { HotkeysChanged(); ScanDuplicateHotkeys(hotkeysLayout); }); connect(hw, &OBSHotkeyWidget::SearchKey, [=](obs_key_combination_t combo) { ui->hotkeyFilterSearch->setText(""); ui->hotkeyFilterInput->HandleNewKey(combo); ui->hotkeyFilterInput->KeyChanged(combo); }); }; auto data = make_tuple(RegisterHotkey, std::move(keys), ignoreKey, this); using data_t = decltype(data); obs_enum_hotkeys( [](void *data, obs_hotkey_id id, obs_hotkey_t *key) { data_t &d = *static_cast(data); if (id != get<2>(d)) LayoutHotkey(get<3>(d), id, key, get<0>(d), get<1>(d)); return true; }, &data); for (auto keyId : pairIds) { auto data1 = pairLabels.find(keyId); if (data1 == end(pairLabels)) continue; auto &label1 = data1->second.second; if (label1->pairPartner) continue; auto data2 = pairLabels.find(data1->second.first); if (data2 == end(pairLabels)) continue; auto &label2 = data2->second.second; if (label2->pairPartner) continue; QString tt = QTStr("Basic.Settings.Hotkeys.Pair"); auto name1 = label1->text(); auto name2 = label2->text(); auto Update = [&](OBSHotkeyLabel *label, const QString &name, OBSHotkeyLabel *other, const QString &otherName) { QString string = other->property("fullName").value(); if (string.isEmpty() || string.isNull()) string = otherName; label->setToolTip(tt.arg(string)); label->setText(name + " *"); label->pairPartner = other; }; Update(label1, name1, label2, name2); Update(label2, name2, label1, name1); } AddHotkeys(*hotkeysLayout, obs_output_get_name, outputs); AddHotkeys(*hotkeysLayout, obs_source_get_name, scenes); AddHotkeys(*hotkeysLayout, obs_source_get_name, sources); AddHotkeys(*hotkeysLayout, obs_encoder_get_name, encoders); AddHotkeys(*hotkeysLayout, obs_service_get_name, services); ScanDuplicateHotkeys(hotkeysLayout); } void OBSBasicSettings::LoadSettings(bool changedOnly) { if (!changedOnly || generalChanged) LoadGeneralSettings(); if (!changedOnly || stream1Changed) LoadStream1Settings(); if (!changedOnly || outputsChanged) LoadOutputSettings(); if (!changedOnly || audioChanged) LoadAudioSettings(); if (!changedOnly || videoChanged) LoadVideoSettings(); if (!changedOnly || hotkeysChanged) LoadHotkeySettings(); if (!changedOnly || a11yChanged) LoadA11ySettings(); if (!changedOnly || advancedChanged) LoadAdvancedSettings(); } void OBSBasicSettings::SaveGeneralSettings() { int languageIndex = ui->language->currentIndex(); QVariant langData = ui->language->itemData(languageIndex); string language = langData.toString().toStdString(); if (WidgetChanged(ui->language)) config_set_string(GetGlobalConfig(), "General", "Language", language.c_str()); int themeIndex = ui->theme->currentIndex(); QString themeData = ui->theme->itemData(themeIndex).toString(); if (WidgetChanged(ui->theme)) config_set_string(GetGlobalConfig(), "General", "CurrentTheme3", QT_TO_UTF8(themeData)); #if defined(_WIN32) || defined(__APPLE__) if (WidgetChanged(ui->enableAutoUpdates)) config_set_bool(GetGlobalConfig(), "General", "EnableAutoUpdates", ui->enableAutoUpdates->isChecked()); #endif #ifdef _WIN32 if (ui->hideOBSFromCapture && WidgetChanged(ui->hideOBSFromCapture)) { bool hide_window = ui->hideOBSFromCapture->isChecked(); config_set_bool(GetGlobalConfig(), "BasicWindow", "HideOBSWindowsFromCapture", hide_window); QWindowList windows = QGuiApplication::allWindows(); for (auto window : windows) { if (window->isVisible()) { main->SetDisplayAffinity(window); } } blog(LOG_INFO, "Hide OBS windows from screen capture: %s", hide_window ? "true" : "false"); } #endif if (WidgetChanged(ui->openStatsOnStartup)) config_set_bool(main->Config(), "General", "OpenStatsOnStartup", ui->openStatsOnStartup->isChecked()); if (WidgetChanged(ui->snappingEnabled)) config_set_bool(GetGlobalConfig(), "BasicWindow", "SnappingEnabled", ui->snappingEnabled->isChecked()); if (WidgetChanged(ui->screenSnapping)) config_set_bool(GetGlobalConfig(), "BasicWindow", "ScreenSnapping", ui->screenSnapping->isChecked()); if (WidgetChanged(ui->centerSnapping)) config_set_bool(GetGlobalConfig(), "BasicWindow", "CenterSnapping", ui->centerSnapping->isChecked()); if (WidgetChanged(ui->sourceSnapping)) config_set_bool(GetGlobalConfig(), "BasicWindow", "SourceSnapping", ui->sourceSnapping->isChecked()); if (WidgetChanged(ui->snapDistance)) config_set_double(GetGlobalConfig(), "BasicWindow", "SnapDistance", ui->snapDistance->value()); if (WidgetChanged(ui->overflowAlwaysVisible)) config_set_bool(GetGlobalConfig(), "BasicWindow", "OverflowAlwaysVisible", ui->overflowAlwaysVisible->isChecked()); if (WidgetChanged(ui->overflowHide)) config_set_bool(GetGlobalConfig(), "BasicWindow", "OverflowHidden", ui->overflowHide->isChecked()); if (WidgetChanged(ui->overflowSelectionHide)) config_set_bool(GetGlobalConfig(), "BasicWindow", "OverflowSelectionHidden", ui->overflowSelectionHide->isChecked()); if (WidgetChanged(ui->previewSafeAreas)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "ShowSafeAreas", ui->previewSafeAreas->isChecked()); main->UpdatePreviewSafeAreas(); } if (WidgetChanged(ui->previewSpacingHelpers)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "SpacingHelpersEnabled", ui->previewSpacingHelpers->isChecked()); main->UpdatePreviewSpacingHelpers(); } if (WidgetChanged(ui->doubleClickSwitch)) config_set_bool(GetGlobalConfig(), "BasicWindow", "TransitionOnDoubleClick", ui->doubleClickSwitch->isChecked()); if (WidgetChanged(ui->automaticSearch)) config_set_bool(GetGlobalConfig(), "General", "AutomaticCollectionSearch", ui->automaticSearch->isChecked()); config_set_bool(GetGlobalConfig(), "BasicWindow", "WarnBeforeStartingStream", ui->warnBeforeStreamStart->isChecked()); config_set_bool(GetGlobalConfig(), "BasicWindow", "WarnBeforeStoppingStream", ui->warnBeforeStreamStop->isChecked()); config_set_bool(GetGlobalConfig(), "BasicWindow", "WarnBeforeStoppingRecord", ui->warnBeforeRecordStop->isChecked()); if (WidgetChanged(ui->hideProjectorCursor)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "HideProjectorCursor", ui->hideProjectorCursor->isChecked()); main->UpdateProjectorHideCursor(); } if (WidgetChanged(ui->projectorAlwaysOnTop)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "ProjectorAlwaysOnTop", ui->projectorAlwaysOnTop->isChecked()); #if defined(_WIN32) || defined(__APPLE__) main->UpdateProjectorAlwaysOnTop( ui->projectorAlwaysOnTop->isChecked()); #else main->ResetProjectors(); #endif } if (WidgetChanged(ui->recordWhenStreaming)) config_set_bool(GetGlobalConfig(), "BasicWindow", "RecordWhenStreaming", ui->recordWhenStreaming->isChecked()); if (WidgetChanged(ui->keepRecordStreamStops)) config_set_bool(GetGlobalConfig(), "BasicWindow", "KeepRecordingWhenStreamStops", ui->keepRecordStreamStops->isChecked()); if (WidgetChanged(ui->replayWhileStreaming)) config_set_bool(GetGlobalConfig(), "BasicWindow", "ReplayBufferWhileStreaming", ui->replayWhileStreaming->isChecked()); if (WidgetChanged(ui->keepReplayStreamStops)) config_set_bool(GetGlobalConfig(), "BasicWindow", "KeepReplayBufferStreamStops", ui->keepReplayStreamStops->isChecked()); if (WidgetChanged(ui->systemTrayEnabled)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "SysTrayEnabled", ui->systemTrayEnabled->isChecked()); main->SystemTray(false); } if (WidgetChanged(ui->systemTrayWhenStarted)) config_set_bool(GetGlobalConfig(), "BasicWindow", "SysTrayWhenStarted", ui->systemTrayWhenStarted->isChecked()); if (WidgetChanged(ui->systemTrayAlways)) config_set_bool(GetGlobalConfig(), "BasicWindow", "SysTrayMinimizeToTray", ui->systemTrayAlways->isChecked()); if (WidgetChanged(ui->saveProjectors)) config_set_bool(GetGlobalConfig(), "BasicWindow", "SaveProjectors", ui->saveProjectors->isChecked()); if (WidgetChanged(ui->closeProjectors)) config_set_bool(GetGlobalConfig(), "BasicWindow", "CloseExistingProjectors", ui->closeProjectors->isChecked()); if (WidgetChanged(ui->studioPortraitLayout)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "StudioPortraitLayout", ui->studioPortraitLayout->isChecked()); main->ResetUI(); } if (WidgetChanged(ui->prevProgLabelToggle)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "StudioModeLabels", ui->prevProgLabelToggle->isChecked()); main->ResetUI(); } bool multiviewChanged = false; if (WidgetChanged(ui->multiviewMouseSwitch)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "MultiviewMouseSwitch", ui->multiviewMouseSwitch->isChecked()); multiviewChanged = true; } if (WidgetChanged(ui->multiviewDrawNames)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "MultiviewDrawNames", ui->multiviewDrawNames->isChecked()); multiviewChanged = true; } if (WidgetChanged(ui->multiviewDrawAreas)) { config_set_bool(GetGlobalConfig(), "BasicWindow", "MultiviewDrawAreas", ui->multiviewDrawAreas->isChecked()); multiviewChanged = true; } if (WidgetChanged(ui->multiviewLayout)) { config_set_int(GetGlobalConfig(), "BasicWindow", "MultiviewLayout", ui->multiviewLayout->currentData().toInt()); multiviewChanged = true; } if (multiviewChanged) OBSProjector::UpdateMultiviewProjectors(); } void OBSBasicSettings::SaveVideoSettings() { QString baseResolution = ui->baseResolution->currentText(); QString outputResolution = ui->outputResolution->currentText(); int fpsType = ui->fpsType->currentIndex(); uint32_t cx = 0, cy = 0; /* ------------------- */ if (WidgetChanged(ui->baseResolution) && ConvertResText(QT_TO_UTF8(baseResolution), cx, cy)) { config_set_uint(main->Config(), "Video", "BaseCX", cx); config_set_uint(main->Config(), "Video", "BaseCY", cy); } if (WidgetChanged(ui->outputResolution) && ConvertResText(QT_TO_UTF8(outputResolution), cx, cy)) { config_set_uint(main->Config(), "Video", "OutputCX", cx); config_set_uint(main->Config(), "Video", "OutputCY", cy); } if (WidgetChanged(ui->fpsType)) config_set_uint(main->Config(), "Video", "FPSType", fpsType); SaveCombo(ui->fpsCommon, "Video", "FPSCommon"); SaveSpinBox(ui->fpsInteger, "Video", "FPSInt"); SaveSpinBox(ui->fpsNumerator, "Video", "FPSNum"); SaveSpinBox(ui->fpsDenominator, "Video", "FPSDen"); SaveComboData(ui->downscaleFilter, "Video", "ScaleType"); #ifdef _WIN32 if (toggleAero) { SaveCheckBox(toggleAero, "Video", "DisableAero"); aeroWasDisabled = toggleAero->isChecked(); } #endif } void OBSBasicSettings::SaveAdvancedSettings() { QString lastMonitoringDevice = config_get_string( main->Config(), "Audio", "MonitoringDeviceId"); #ifdef _WIN32 if (WidgetChanged(ui->renderer)) config_set_string(App()->GlobalConfig(), "Video", "Renderer", QT_TO_UTF8(ui->renderer->currentText())); std::string priority = QT_TO_UTF8(ui->processPriority->currentData().toString()); config_set_string(App()->GlobalConfig(), "General", "ProcessPriority", priority.c_str()); if (main->Active()) SetProcessPriority(priority.c_str()); SaveCheckBox(ui->enableNewSocketLoop, "Output", "NewSocketLoopEnable"); SaveCheckBox(ui->enableLowLatencyMode, "Output", "LowLatencyEnable"); #endif #if defined(_WIN32) || defined(__APPLE__) bool browserHWAccel = ui->browserHWAccel->isChecked(); config_set_bool(App()->GlobalConfig(), "General", "BrowserHWAccel", browserHWAccel); #endif if (WidgetChanged(ui->hotkeyFocusType)) { QString str = GetComboData(ui->hotkeyFocusType); config_set_string(App()->GlobalConfig(), "General", "HotkeyFocusType", QT_TO_UTF8(str)); } #ifdef __APPLE__ if (WidgetChanged(ui->disableOSXVSync)) { bool disable = ui->disableOSXVSync->isChecked(); config_set_bool(App()->GlobalConfig(), "Video", "DisableOSXVSync", disable); EnableOSXVSync(!disable); } if (WidgetChanged(ui->resetOSXVSync)) config_set_bool(App()->GlobalConfig(), "Video", "ResetOSXVSyncOnExit", ui->resetOSXVSync->isChecked()); #endif SaveComboData(ui->colorFormat, "Video", "ColorFormat"); SaveComboData(ui->colorSpace, "Video", "ColorSpace"); SaveComboData(ui->colorRange, "Video", "ColorRange"); SaveSpinBox(ui->sdrWhiteLevel, "Video", "SdrWhiteLevel"); SaveSpinBox(ui->hdrNominalPeakLevel, "Video", "HdrNominalPeakLevel"); if (obs_audio_monitoring_available()) { SaveCombo(ui->monitoringDevice, "Audio", "MonitoringDeviceName"); SaveComboData(ui->monitoringDevice, "Audio", "MonitoringDeviceId"); } #ifdef _WIN32 if (WidgetChanged(ui->disableAudioDucking)) { bool disable = ui->disableAudioDucking->isChecked(); config_set_bool(App()->GlobalConfig(), "Audio", "DisableAudioDucking", disable); DisableAudioDucking(disable); } #endif if (WidgetChanged(ui->confirmOnExit)) config_set_bool(GetGlobalConfig(), "General", "ConfirmOnExit", ui->confirmOnExit->isChecked()); SaveEdit(ui->filenameFormatting, "Output", "FilenameFormatting"); SaveEdit(ui->simpleRBPrefix, "SimpleOutput", "RecRBPrefix"); SaveEdit(ui->simpleRBSuffix, "SimpleOutput", "RecRBSuffix"); SaveCheckBox(ui->overwriteIfExists, "Output", "OverwriteIfExists"); SaveCheckBox(ui->streamDelayEnable, "Output", "DelayEnable"); SaveSpinBox(ui->streamDelaySec, "Output", "DelaySec"); SaveCheckBox(ui->streamDelayPreserve, "Output", "DelayPreserve"); SaveCheckBox(ui->reconnectEnable, "Output", "Reconnect"); SaveSpinBox(ui->reconnectRetryDelay, "Output", "RetryDelay"); SaveSpinBox(ui->reconnectMaxRetries, "Output", "MaxRetries"); SaveComboData(ui->bindToIP, "Output", "BindIP"); SaveCheckBox(ui->autoRemux, "Video", "AutoRemux"); SaveCheckBox(ui->dynBitrate, "Output", "DynamicBitrate"); if (obs_audio_monitoring_available()) { QString newDevice = ui->monitoringDevice->currentData().toString(); if (lastMonitoringDevice != newDevice) { obs_set_audio_monitoring_device( QT_TO_UTF8(ui->monitoringDevice->currentText()), QT_TO_UTF8(newDevice)); blog(LOG_INFO, "Audio monitoring device:\n\tname: %s\n\tid: %s", QT_TO_UTF8(ui->monitoringDevice->currentText()), QT_TO_UTF8(newDevice)); } } } static inline const char *OutputModeFromIdx(int idx) { if (idx == 1) return "Advanced"; else return "Simple"; } static inline const char *RecTypeFromIdx(int idx) { if (idx == 1) return "FFmpeg"; else return "Standard"; } static inline const char *SplitFileTypeFromIdx(int idx) { if (idx == 1) return "Size"; else if (idx == 2) return "Manual"; else return "Time"; } static void WriteJsonData(OBSPropertiesView *view, const char *path) { char full_path[512]; if (!view || !WidgetChanged(view)) return; int ret = GetProfilePath(full_path, sizeof(full_path), path); if (ret > 0) { obs_data_t *settings = view->GetSettings(); if (settings) { obs_data_save_json_safe(settings, full_path, "tmp", "bak"); } } } static void SaveTrackIndex(config_t *config, const char *section, const char *name, QAbstractButton *check1, QAbstractButton *check2, QAbstractButton *check3, QAbstractButton *check4, QAbstractButton *check5, QAbstractButton *check6) { if (check1->isChecked()) config_set_int(config, section, name, 1); else if (check2->isChecked()) config_set_int(config, section, name, 2); else if (check3->isChecked()) config_set_int(config, section, name, 3); else if (check4->isChecked()) config_set_int(config, section, name, 4); else if (check5->isChecked()) config_set_int(config, section, name, 5); else if (check6->isChecked()) config_set_int(config, section, name, 6); } void OBSBasicSettings::SaveFormat(QComboBox *combo) { QVariant v = combo->currentData(); if (!v.isNull()) { FormatDesc desc = v.value(); config_set_string(main->Config(), "AdvOut", "FFFormat", desc.name); config_set_string(main->Config(), "AdvOut", "FFFormatMimeType", desc.mimeType); const char *ext = ff_format_desc_extensions(desc.desc); string extStr = ext ? ext : ""; char *comma = strchr(&extStr[0], ','); if (comma) *comma = 0; config_set_string(main->Config(), "AdvOut", "FFExtension", extStr.c_str()); } else { config_set_string(main->Config(), "AdvOut", "FFFormat", nullptr); config_set_string(main->Config(), "AdvOut", "FFFormatMimeType", nullptr); config_remove_value(main->Config(), "AdvOut", "FFExtension"); } } void OBSBasicSettings::SaveEncoder(QComboBox *combo, const char *section, const char *value) { QVariant v = combo->currentData(); CodecDesc cd; if (!v.isNull()) cd = v.value(); config_set_int(main->Config(), section, QT_TO_UTF8(QString("%1Id").arg(value)), cd.id); if (cd.id != 0) config_set_string(main->Config(), section, value, cd.name); else config_set_string(main->Config(), section, value, nullptr); } void OBSBasicSettings::SaveOutputSettings() { config_set_string(main->Config(), "Output", "Mode", OutputModeFromIdx(ui->outputMode->currentIndex())); QString encoder = ui->simpleOutStrEncoder->currentData().toString(); const char *presetType; if (encoder == SIMPLE_ENCODER_QSV) presetType = "QSVPreset"; else if (encoder == SIMPLE_ENCODER_NVENC) presetType = "NVENCPreset"; #ifdef ENABLE_HEVC else if (encoder == SIMPLE_ENCODER_AMD_HEVC) presetType = "AMDPreset"; else if (encoder == SIMPLE_ENCODER_NVENC_HEVC) presetType = "NVENCPreset"; #endif else if (encoder == SIMPLE_ENCODER_AMD) presetType = "AMDPreset"; else if (encoder == SIMPLE_ENCODER_APPLE_H264) /* The Apple encoders don't have presets like the other encoders do. This only exists to make sure that the x264 preset doesn't get overwritten with empty data. */ presetType = "ApplePreset"; else presetType = "Preset"; SaveSpinBox(ui->simpleOutputVBitrate, "SimpleOutput", "VBitrate"); SaveComboData(ui->simpleOutStrEncoder, "SimpleOutput", "StreamEncoder"); SaveCombo(ui->simpleOutputABitrate, "SimpleOutput", "ABitrate"); SaveEdit(ui->simpleOutputPath, "SimpleOutput", "FilePath"); SaveCheckBox(ui->simpleNoSpace, "SimpleOutput", "FileNameWithoutSpace"); SaveCombo(ui->simpleOutRecFormat, "SimpleOutput", "RecFormat"); SaveCheckBox(ui->simpleOutAdvanced, "SimpleOutput", "UseAdvanced"); SaveComboData(ui->simpleOutPreset, "SimpleOutput", presetType); SaveEdit(ui->simpleOutCustom, "SimpleOutput", "x264Settings"); SaveComboData(ui->simpleOutRecQuality, "SimpleOutput", "RecQuality"); SaveComboData(ui->simpleOutRecEncoder, "SimpleOutput", "RecEncoder"); SaveEdit(ui->simpleOutMuxCustom, "SimpleOutput", "MuxerCustom"); SaveCheckBox(ui->simpleReplayBuf, "SimpleOutput", "RecRB"); SaveSpinBox(ui->simpleRBSecMax, "SimpleOutput", "RecRBTime"); SaveSpinBox(ui->simpleRBMegsMax, "SimpleOutput", "RecRBSize"); curAdvStreamEncoder = GetComboData(ui->advOutEncoder); SaveComboData(ui->advOutEncoder, "AdvOut", "Encoder"); SaveCheckBox(ui->advOutUseRescale, "AdvOut", "Rescale"); SaveCombo(ui->advOutRescale, "AdvOut", "RescaleRes"); SaveTrackIndex(main->Config(), "AdvOut", "TrackIndex", ui->advOutTrack1, ui->advOutTrack2, ui->advOutTrack3, ui->advOutTrack4, ui->advOutTrack5, ui->advOutTrack6); config_set_string(main->Config(), "AdvOut", "RecType", RecTypeFromIdx(ui->advOutRecType->currentIndex())); curAdvRecordEncoder = GetComboData(ui->advOutRecEncoder); SaveEdit(ui->advOutRecPath, "AdvOut", "RecFilePath"); SaveCheckBox(ui->advOutNoSpace, "AdvOut", "RecFileNameWithoutSpace"); SaveCombo(ui->advOutRecFormat, "AdvOut", "RecFormat"); SaveComboData(ui->advOutRecEncoder, "AdvOut", "RecEncoder"); SaveCheckBox(ui->advOutRecUseRescale, "AdvOut", "RecRescale"); SaveCombo(ui->advOutRecRescale, "AdvOut", "RecRescaleRes"); SaveEdit(ui->advOutMuxCustom, "AdvOut", "RecMuxerCustom"); SaveCheckBox(ui->advOutSplitFile, "AdvOut", "RecSplitFile"); config_set_string( main->Config(), "AdvOut", "RecSplitFileType", SplitFileTypeFromIdx(ui->advOutSplitFileType->currentIndex())); SaveSpinBox(ui->advOutSplitFileTime, "AdvOut", "RecSplitFileTime"); SaveSpinBox(ui->advOutSplitFileSize, "AdvOut", "RecSplitFileSize"); config_set_int( main->Config(), "AdvOut", "RecTracks", (ui->advOutRecTrack1->isChecked() ? (1 << 0) : 0) | (ui->advOutRecTrack2->isChecked() ? (1 << 1) : 0) | (ui->advOutRecTrack3->isChecked() ? (1 << 2) : 0) | (ui->advOutRecTrack4->isChecked() ? (1 << 3) : 0) | (ui->advOutRecTrack5->isChecked() ? (1 << 4) : 0) | (ui->advOutRecTrack6->isChecked() ? (1 << 5) : 0)); config_set_int(main->Config(), "AdvOut", "FLVTrack", CurrentFLVTrack()); config_set_bool(main->Config(), "AdvOut", "FFOutputToFile", ui->advOutFFType->currentIndex() == 0 ? true : false); SaveEdit(ui->advOutFFRecPath, "AdvOut", "FFFilePath"); SaveCheckBox(ui->advOutFFNoSpace, "AdvOut", "FFFileNameWithoutSpace"); SaveEdit(ui->advOutFFURL, "AdvOut", "FFURL"); SaveFormat(ui->advOutFFFormat); SaveEdit(ui->advOutFFMCfg, "AdvOut", "FFMCustom"); SaveSpinBox(ui->advOutFFVBitrate, "AdvOut", "FFVBitrate"); SaveSpinBox(ui->advOutFFVGOPSize, "AdvOut", "FFVGOPSize"); SaveCheckBox(ui->advOutFFUseRescale, "AdvOut", "FFRescale"); SaveCheckBox(ui->advOutFFIgnoreCompat, "AdvOut", "FFIgnoreCompat"); SaveCombo(ui->advOutFFRescale, "AdvOut", "FFRescaleRes"); SaveEncoder(ui->advOutFFVEncoder, "AdvOut", "FFVEncoder"); SaveEdit(ui->advOutFFVCfg, "AdvOut", "FFVCustom"); SaveSpinBox(ui->advOutFFABitrate, "AdvOut", "FFABitrate"); SaveEncoder(ui->advOutFFAEncoder, "AdvOut", "FFAEncoder"); SaveEdit(ui->advOutFFACfg, "AdvOut", "FFACustom"); config_set_int( main->Config(), "AdvOut", "FFAudioMixes", (ui->advOutFFTrack1->isChecked() ? (1 << 0) : 0) | (ui->advOutFFTrack2->isChecked() ? (1 << 1) : 0) | (ui->advOutFFTrack3->isChecked() ? (1 << 2) : 0) | (ui->advOutFFTrack4->isChecked() ? (1 << 3) : 0) | (ui->advOutFFTrack5->isChecked() ? (1 << 4) : 0) | (ui->advOutFFTrack6->isChecked() ? (1 << 5) : 0)); SaveCombo(ui->advOutTrack1Bitrate, "AdvOut", "Track1Bitrate"); SaveCombo(ui->advOutTrack2Bitrate, "AdvOut", "Track2Bitrate"); SaveCombo(ui->advOutTrack3Bitrate, "AdvOut", "Track3Bitrate"); SaveCombo(ui->advOutTrack4Bitrate, "AdvOut", "Track4Bitrate"); SaveCombo(ui->advOutTrack5Bitrate, "AdvOut", "Track5Bitrate"); SaveCombo(ui->advOutTrack6Bitrate, "AdvOut", "Track6Bitrate"); SaveEdit(ui->advOutTrack1Name, "AdvOut", "Track1Name"); SaveEdit(ui->advOutTrack2Name, "AdvOut", "Track2Name"); SaveEdit(ui->advOutTrack3Name, "AdvOut", "Track3Name"); SaveEdit(ui->advOutTrack4Name, "AdvOut", "Track4Name"); SaveEdit(ui->advOutTrack5Name, "AdvOut", "Track5Name"); SaveEdit(ui->advOutTrack6Name, "AdvOut", "Track6Name"); if (vodTrackCheckbox) { SaveCheckBox(simpleVodTrack, "SimpleOutput", "VodTrackEnabled"); SaveCheckBox(vodTrackCheckbox, "AdvOut", "VodTrackEnabled"); SaveTrackIndex(main->Config(), "AdvOut", "VodTrackIndex", vodTrack[0], vodTrack[1], vodTrack[2], vodTrack[3], vodTrack[4], vodTrack[5]); } SaveCheckBox(ui->advReplayBuf, "AdvOut", "RecRB"); SaveSpinBox(ui->advRBSecMax, "AdvOut", "RecRBTime"); SaveSpinBox(ui->advRBMegsMax, "AdvOut", "RecRBSize"); WriteJsonData(streamEncoderProps, "streamEncoder.json"); WriteJsonData(recordEncoderProps, "recordEncoder.json"); main->ResetOutputs(); } void OBSBasicSettings::SaveAudioSettings() { QString sampleRateStr = ui->sampleRate->currentText(); int channelSetupIdx = ui->channelSetup->currentIndex(); const char *channelSetup; switch (channelSetupIdx) { case 0: channelSetup = "Mono"; break; case 1: channelSetup = "Stereo"; break; case 2: channelSetup = "2.1"; break; case 3: channelSetup = "4.0"; break; case 4: channelSetup = "4.1"; break; case 5: channelSetup = "5.1"; break; case 6: channelSetup = "7.1"; break; default: channelSetup = "Stereo"; break; } int sampleRate = 44100; if (sampleRateStr == "48 kHz") sampleRate = 48000; if (WidgetChanged(ui->sampleRate)) config_set_uint(main->Config(), "Audio", "SampleRate", sampleRate); if (WidgetChanged(ui->channelSetup)) config_set_string(main->Config(), "Audio", "ChannelSetup", channelSetup); if (WidgetChanged(ui->meterDecayRate)) { double meterDecayRate; switch (ui->meterDecayRate->currentIndex()) { case 0: meterDecayRate = VOLUME_METER_DECAY_FAST; break; case 1: meterDecayRate = VOLUME_METER_DECAY_MEDIUM; break; case 2: meterDecayRate = VOLUME_METER_DECAY_SLOW; break; default: meterDecayRate = VOLUME_METER_DECAY_FAST; break; } config_set_double(main->Config(), "Audio", "MeterDecayRate", meterDecayRate); main->UpdateVolumeControlsDecayRate(); } if (WidgetChanged(ui->peakMeterType)) { uint32_t peakMeterTypeIdx = ui->peakMeterType->currentIndex(); config_set_uint(main->Config(), "Audio", "PeakMeterType", peakMeterTypeIdx); main->UpdateVolumeControlsPeakMeterType(); } if (WidgetChanged(ui->lowLatencyBuffering)) { bool enableLLAudioBuffering = ui->lowLatencyBuffering->isChecked(); config_set_bool(GetGlobalConfig(), "Audio", "LowLatencyAudioBuffering", enableLLAudioBuffering); } for (auto &audioSource : audioSources) { auto source = OBSGetStrongRef(get<0>(audioSource)); if (!source) continue; auto &ptmCB = get<1>(audioSource); auto &ptmSB = get<2>(audioSource); auto &pttCB = get<3>(audioSource); auto &pttSB = get<4>(audioSource); obs_source_enable_push_to_mute(source, ptmCB->isChecked()); obs_source_set_push_to_mute_delay(source, ptmSB->value()); obs_source_enable_push_to_talk(source, pttCB->isChecked()); obs_source_set_push_to_talk_delay(source, pttSB->value()); } auto UpdateAudioDevice = [this](bool input, QComboBox *combo, const char *name, int index) { main->ResetAudioDevice(input ? App()->InputAudioSource() : App()->OutputAudioSource(), QT_TO_UTF8(GetComboData(combo)), Str(name), index); }; UpdateAudioDevice(false, ui->desktopAudioDevice1, "Basic.DesktopDevice1", 1); UpdateAudioDevice(false, ui->desktopAudioDevice2, "Basic.DesktopDevice2", 2); UpdateAudioDevice(true, ui->auxAudioDevice1, "Basic.AuxDevice1", 3); UpdateAudioDevice(true, ui->auxAudioDevice2, "Basic.AuxDevice2", 4); UpdateAudioDevice(true, ui->auxAudioDevice3, "Basic.AuxDevice3", 5); UpdateAudioDevice(true, ui->auxAudioDevice4, "Basic.AuxDevice4", 6); main->SaveProject(); } void OBSBasicSettings::SaveHotkeySettings() { const auto &config = main->Config(); using namespace std; std::vector combinations; for (auto &hotkey : hotkeys) { auto &hw = *hotkey.second; if (!hw.Changed()) continue; hw.Save(combinations); if (!hotkey.first) continue; OBSDataArrayAutoRelease array = obs_hotkey_save(hw.id); OBSDataAutoRelease data = obs_data_create(); obs_data_set_array(data, "bindings", array); const char *json = obs_data_get_json(data); config_set_string(config, "Hotkeys", hw.name.c_str(), json); } if (!main->outputHandler || !main->outputHandler->replayBuffer) return; const char *id = obs_obj_get_id(main->outputHandler->replayBuffer); if (strcmp(id, "replay_buffer") == 0) { OBSDataAutoRelease hotkeys = obs_hotkeys_save_output( main->outputHandler->replayBuffer); config_set_string(config, "Hotkeys", "ReplayBuffer", obs_data_get_json(hotkeys)); } } #define MINOR_SEPARATOR "------------------------------------------------" static void AddChangedVal(std::string &changed, const char *str) { if (changed.size()) changed += ", "; changed += str; } void OBSBasicSettings::SaveSettings() { if (generalChanged) SaveGeneralSettings(); if (stream1Changed) SaveStream1Settings(); if (outputsChanged) SaveOutputSettings(); if (audioChanged) SaveAudioSettings(); if (videoChanged) SaveVideoSettings(); if (hotkeysChanged) SaveHotkeySettings(); if (a11yChanged) SaveA11ySettings(); if (advancedChanged) SaveAdvancedSettings(); if (videoChanged || advancedChanged) main->ResetVideo(); config_save_safe(main->Config(), "tmp", nullptr); config_save_safe(GetGlobalConfig(), "tmp", nullptr); main->SaveProject(); if (Changed()) { std::string changed; if (generalChanged) AddChangedVal(changed, "general"); if (stream1Changed) AddChangedVal(changed, "stream 1"); if (outputsChanged) AddChangedVal(changed, "outputs"); if (audioChanged) AddChangedVal(changed, "audio"); if (videoChanged) AddChangedVal(changed, "video"); if (hotkeysChanged) AddChangedVal(changed, "hotkeys"); if (a11yChanged) AddChangedVal(changed, "a11y"); if (advancedChanged) AddChangedVal(changed, "advanced"); blog(LOG_INFO, "Settings changed (%s)", changed.c_str()); blog(LOG_INFO, MINOR_SEPARATOR); } bool langChanged = (ui->language->currentIndex() != prevLangIndex); bool audioRestart = (ui->channelSetup->currentIndex() != channelIndex || ui->sampleRate->currentIndex() != sampleRateIndex); bool browserHWAccelChanged = (ui->browserHWAccel && ui->browserHWAccel->isChecked() != prevBrowserAccel); if (langChanged || audioRestart || browserHWAccelChanged) restart = true; else restart = false; } bool OBSBasicSettings::QueryChanges() { QMessageBox::StandardButton button; button = OBSMessageBox::question( this, QTStr("Basic.Settings.ConfirmTitle"), QTStr("Basic.Settings.Confirm"), QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel); if (button == QMessageBox::Cancel) { return false; } else if (button == QMessageBox::Yes) { SaveSettings(); } else { if (savedTheme != App()->GetTheme()) App()->SetTheme(savedTheme); LoadSettings(true); #ifdef _WIN32 if (toggleAero) SetAeroEnabled(!aeroWasDisabled); #endif restart = false; } ClearChanged(); return true; } void OBSBasicSettings::closeEvent(QCloseEvent *event) { if (!AskIfCanCloseSettings()) event->ignore(); } void OBSBasicSettings::reject() { if (AskIfCanCloseSettings()) close(); } void OBSBasicSettings::on_theme_activated(int idx) { QString currT = ui->theme->itemData(idx).toString(); App()->SetTheme(currT.toUtf8().constData()); } void OBSBasicSettings::on_listWidget_itemSelectionChanged() { int row = ui->listWidget->currentRow(); if (loading || row == pageIndex) return; pageIndex = row; } void OBSBasicSettings::on_buttonBox_clicked(QAbstractButton *button) { QDialogButtonBox::ButtonRole val = ui->buttonBox->buttonRole(button); if (val == QDialogButtonBox::ApplyRole || val == QDialogButtonBox::AcceptRole) { SaveSettings(); ClearChanged(); } if (val == QDialogButtonBox::AcceptRole || val == QDialogButtonBox::RejectRole) { if (val == QDialogButtonBox::RejectRole) { if (savedTheme != App()->GetTheme()) App()->SetTheme(savedTheme); #ifdef _WIN32 if (toggleAero) SetAeroEnabled(!aeroWasDisabled); #endif } ClearChanged(); close(); } } void OBSBasicSettings::on_simpleOutputBrowse_clicked() { QString dir = SelectDirectory( this, QTStr("Basic.Settings.Output.SelectDirectory"), ui->simpleOutputPath->text()); if (dir.isEmpty()) return; ui->simpleOutputPath->setText(dir); } void OBSBasicSettings::on_advOutRecPathBrowse_clicked() { QString dir = SelectDirectory( this, QTStr("Basic.Settings.Output.SelectDirectory"), ui->advOutRecPath->text()); if (dir.isEmpty()) return; ui->advOutRecPath->setText(dir); } void OBSBasicSettings::on_advOutFFPathBrowse_clicked() { QString dir = SelectDirectory( this, QTStr("Basic.Settings.Output.SelectDirectory"), ui->advOutRecPath->text()); if (dir.isEmpty()) return; ui->advOutFFRecPath->setText(dir); } void OBSBasicSettings::on_advOutEncoder_currentIndexChanged(int idx) { QString encoder = GetComboData(ui->advOutEncoder); if (!loading) { bool loadSettings = encoder == curAdvStreamEncoder; delete streamEncoderProps; streamEncoderProps = CreateEncoderPropertyView( QT_TO_UTF8(encoder), loadSettings ? "streamEncoder.json" : nullptr, true); streamEncoderProps->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); ui->advOutEncoderLayout->addWidget(streamEncoderProps); } ui->advOutUseRescale->setVisible(true); ui->advOutRescale->setVisible(true); UNUSED_PARAMETER(idx); } void OBSBasicSettings::on_advOutRecEncoder_currentIndexChanged(int idx) { if (!loading) { delete recordEncoderProps; recordEncoderProps = nullptr; } if (idx <= 0) { ui->advOutRecUseRescale->setChecked(false); ui->advOutRecUseRescale->setVisible(false); ui->advOutRecRescaleContainer->setVisible(false); ui->advOutRecEncoderProps->setVisible(false); return; } QString encoder = GetComboData(ui->advOutRecEncoder); bool loadSettings = encoder == curAdvRecordEncoder; if (!loading) { recordEncoderProps = CreateEncoderPropertyView( QT_TO_UTF8(encoder), loadSettings ? "recordEncoder.json" : nullptr, true); recordEncoderProps->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); ui->advOutRecEncoderProps->layout()->addWidget( recordEncoderProps); connect(recordEncoderProps, SIGNAL(Changed()), this, SLOT(AdvReplayBufferChanged())); } ui->advOutRecUseRescale->setVisible(true); ui->advOutRecRescaleContainer->setVisible(true); ui->advOutRecEncoderProps->setVisible(true); } void OBSBasicSettings::on_advOutFFIgnoreCompat_stateChanged(int) { /* Little hack to reload codecs when checked */ on_advOutFFFormat_currentIndexChanged( ui->advOutFFFormat->currentIndex()); } #define DEFAULT_CONTAINER_STR \ QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatDescDef") void OBSBasicSettings::on_advOutFFFormat_currentIndexChanged(int idx) { const QVariant itemDataVariant = ui->advOutFFFormat->itemData(idx); if (!itemDataVariant.isNull()) { FormatDesc desc = itemDataVariant.value(); SetAdvOutputFFmpegEnablement( FF_CODEC_AUDIO, ff_format_desc_has_audio(desc.desc), false); SetAdvOutputFFmpegEnablement( FF_CODEC_VIDEO, ff_format_desc_has_video(desc.desc), false); ReloadCodecs(desc.desc); ui->advOutFFFormatDesc->setText( ff_format_desc_long_name(desc.desc)); CodecDesc defaultAudioCodecDesc = GetDefaultCodecDesc(desc.desc, FF_CODEC_AUDIO); CodecDesc defaultVideoCodecDesc = GetDefaultCodecDesc(desc.desc, FF_CODEC_VIDEO); SelectEncoder(ui->advOutFFAEncoder, defaultAudioCodecDesc.name, defaultAudioCodecDesc.id); SelectEncoder(ui->advOutFFVEncoder, defaultVideoCodecDesc.name, defaultVideoCodecDesc.id); } else { ReloadCodecs(nullptr); ui->advOutFFFormatDesc->setText(DEFAULT_CONTAINER_STR); } } void OBSBasicSettings::on_advOutFFAEncoder_currentIndexChanged(int idx) { const QVariant itemDataVariant = ui->advOutFFAEncoder->itemData(idx); if (!itemDataVariant.isNull()) { CodecDesc desc = itemDataVariant.value(); SetAdvOutputFFmpegEnablement( FF_CODEC_AUDIO, desc.id != 0 || desc.name != nullptr, true); } } void OBSBasicSettings::on_advOutFFVEncoder_currentIndexChanged(int idx) { const QVariant itemDataVariant = ui->advOutFFVEncoder->itemData(idx); if (!itemDataVariant.isNull()) { CodecDesc desc = itemDataVariant.value(); SetAdvOutputFFmpegEnablement( FF_CODEC_VIDEO, desc.id != 0 || desc.name != nullptr, true); } } void OBSBasicSettings::on_advOutFFType_currentIndexChanged(int idx) { ui->advOutFFNoSpace->setHidden(idx != 0); } void OBSBasicSettings::on_colorFormat_currentIndexChanged(int) { UpdateColorFormatSpaceWarning(); } void OBSBasicSettings::on_colorSpace_currentIndexChanged(int) { UpdateColorFormatSpaceWarning(); } #define INVALID_RES_STR "Basic.Settings.Video.InvalidResolution" static bool ValidResolutions(Ui::OBSBasicSettings *ui) { QString baseRes = ui->baseResolution->lineEdit()->text(); uint32_t cx, cy; if (!ConvertResText(QT_TO_UTF8(baseRes), cx, cy)) { ui->videoMsg->setText(QTStr(INVALID_RES_STR)); return false; } bool lockedOutRes = !ui->outputResolution->isEditable(); if (!lockedOutRes) { QString outRes = ui->outputResolution->lineEdit()->text(); if (!ConvertResText(QT_TO_UTF8(outRes), cx, cy)) { ui->videoMsg->setText(QTStr(INVALID_RES_STR)); return false; } } ui->videoMsg->setText(""); return true; } void OBSBasicSettings::RecalcOutputResPixels(const char *resText) { uint32_t newCX; uint32_t newCY; ConvertResText(resText, newCX, newCY); if (newCX && newCY) { outputCX = newCX; outputCY = newCY; std::tuple aspect = aspect_ratio(outputCX, outputCY); ui->scaledAspect->setText( QTStr("AspectRatio") .arg(QString::number(std::get<0>(aspect)), QString::number(std::get<1>(aspect)))); } } bool OBSBasicSettings::AskIfCanCloseSettings() { bool canCloseSettings = false; if (!Changed() || QueryChanges()) canCloseSettings = true; if (forceAuthReload) { main->auth->Save(); main->auth->Load(); forceAuthReload = false; } return canCloseSettings; } void OBSBasicSettings::on_filenameFormatting_textEdited(const QString &text) { QString safeStr = text; #ifdef __APPLE__ safeStr.replace(QRegularExpression("[:]"), ""); #elif defined(_WIN32) safeStr.replace(QRegularExpression("[<>:\"\\|\\?\\*]"), ""); #else // TODO: Add filtering for other platforms #endif if (text != safeStr) ui->filenameFormatting->setText(safeStr); } void OBSBasicSettings::on_outputResolution_editTextChanged(const QString &text) { if (!loading) { RecalcOutputResPixels(QT_TO_UTF8(text)); LoadDownscaleFilters(); } } void OBSBasicSettings::on_baseResolution_editTextChanged(const QString &text) { if (!loading && ValidResolutions(ui.get())) { QString baseResolution = text; uint32_t cx, cy; ConvertResText(QT_TO_UTF8(baseResolution), cx, cy); std::tuple aspect = aspect_ratio(cx, cy); ui->baseAspect->setText( QTStr("AspectRatio") .arg(QString::number(std::get<0>(aspect)), QString::number(std::get<1>(aspect)))); ResetDownscales(cx, cy); } } void OBSBasicSettings::GeneralChanged() { if (!loading) { generalChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::Stream1Changed() { if (!loading) { stream1Changed = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::OutputsChanged() { if (!loading) { outputsChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::AudioChanged() { if (!loading) { audioChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::AudioChangedRestart() { if (!loading) { int currentChannelIndex = ui->channelSetup->currentIndex(); int currentSampleRateIndex = ui->sampleRate->currentIndex(); bool currentLLAudioBufVal = ui->lowLatencyBuffering->isChecked(); if (currentChannelIndex != channelIndex || currentSampleRateIndex != sampleRateIndex || currentLLAudioBufVal != llBufferingEnabled) { audioChanged = true; ui->audioMsg->setText( QTStr("Basic.Settings.ProgramRestart")); sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } else { audioChanged = false; ui->audioMsg->setText(""); sender()->setProperty("changed", QVariant(false)); EnableApplyButton(false); } } } void OBSBasicSettings::ReloadAudioSources() { LoadAudioSources(); } #define MULTI_CHANNEL_WARNING "Basic.Settings.Audio.MultichannelWarning" void OBSBasicSettings::SpeakerLayoutChanged(int idx) { QString speakerLayoutQstr = ui->channelSetup->itemText(idx); std::string speakerLayout = QT_TO_UTF8(speakerLayoutQstr); bool surround = IsSurround(speakerLayout.c_str()); if (surround) { /* * Display all bitrates */ PopulateAACBitrates( {ui->simpleOutputABitrate, ui->advOutTrack1Bitrate, ui->advOutTrack2Bitrate, ui->advOutTrack3Bitrate, ui->advOutTrack4Bitrate, ui->advOutTrack5Bitrate, ui->advOutTrack6Bitrate}); } else { /* * Reset audio bitrate for simple and adv mode, update list of * bitrates and save setting. */ RestrictResetBitrates( {ui->simpleOutputABitrate, ui->advOutTrack1Bitrate, ui->advOutTrack2Bitrate, ui->advOutTrack3Bitrate, ui->advOutTrack4Bitrate, ui->advOutTrack5Bitrate, ui->advOutTrack6Bitrate}, 320); SaveCombo(ui->simpleOutputABitrate, "SimpleOutput", "ABitrate"); SaveCombo(ui->advOutTrack1Bitrate, "AdvOut", "Track1Bitrate"); SaveCombo(ui->advOutTrack2Bitrate, "AdvOut", "Track2Bitrate"); SaveCombo(ui->advOutTrack3Bitrate, "AdvOut", "Track3Bitrate"); SaveCombo(ui->advOutTrack4Bitrate, "AdvOut", "Track4Bitrate"); SaveCombo(ui->advOutTrack5Bitrate, "AdvOut", "Track5Bitrate"); SaveCombo(ui->advOutTrack6Bitrate, "AdvOut", "Track6Bitrate"); } UpdateAudioWarnings(); } void OBSBasicSettings::HideOBSWindowWarning(int state) { if (loading || state == Qt::Unchecked) return; if (config_get_bool(GetGlobalConfig(), "General", "WarnedAboutHideOBSFromCapture")) return; OBSMessageBox::information( this, QTStr("Basic.Settings.General.HideOBSWindowsFromCapture"), QTStr("Basic.Settings.General.HideOBSWindowsFromCapture.Message")); config_set_bool(GetGlobalConfig(), "General", "WarnedAboutHideOBSFromCapture", true); config_save_safe(GetGlobalConfig(), "tmp", nullptr); } /* * resets current bitrate if too large and restricts the number of bitrates * displayed when multichannel OFF */ void RestrictResetBitrates(initializer_list boxes, int maxbitrate) { for (auto box : boxes) { int idx = box->currentIndex(); int max_bitrate = FindClosestAvailableAACBitrate(maxbitrate); int count = box->count(); int max_idx = box->findText( QT_UTF8(std::to_string(max_bitrate).c_str())); for (int i = (count - 1); i > max_idx; i--) box->removeItem(i); if (idx > max_idx) { int default_bitrate = FindClosestAvailableAACBitrate(maxbitrate / 2); int default_idx = box->findText(QT_UTF8( std::to_string(default_bitrate).c_str())); box->setCurrentIndex(default_idx); box->setProperty("changed", QVariant(true)); } else { box->setCurrentIndex(idx); } } } void OBSBasicSettings::VideoChangedRestart() { if (!loading) { videoChanged = true; ui->videoMsg->setText(QTStr("Basic.Settings.ProgramRestart")); sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::AdvancedChangedRestart() { if (!loading) { advancedChanged = true; ui->advancedMsg->setText( QTStr("Basic.Settings.ProgramRestart")); sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::VideoChangedResolution() { if (!loading && ValidResolutions(ui.get())) { videoChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::VideoChanged() { if (!loading) { videoChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::HotkeysChanged() { using namespace std; if (loading) return; hotkeysChanged = any_of(begin(hotkeys), end(hotkeys), [](const pair> &hotkey) { const auto &hw = *hotkey.second; return hw.Changed(); }); if (hotkeysChanged) EnableApplyButton(true); } void OBSBasicSettings::SearchHotkeys(const QString &text, obs_key_combination_t filterCombo) { if (ui->hotkeyFormLayout->rowCount() == 0) return; std::vector combos; bool showHotkey; ui->hotkeyScrollArea->ensureVisible(0, 0); ui->hotkeyScrollArea->setUpdatesEnabled(false); QLayoutItem *hotkeysItem = ui->hotkeyFormLayout->itemAt(0); QWidget *hotkeys = hotkeysItem->widget(); if (!hotkeys) return; QFormLayout *hotkeysLayout = qobject_cast(hotkeys->layout()); for (int i = 0; i < hotkeysLayout->rowCount(); i++) { auto label = hotkeysLayout->itemAt(i, QFormLayout::LabelRole); if (!label) continue; OBSHotkeyLabel *item = qobject_cast(label->widget()); if (!item) continue; item->widget->GetCombinations(combos); QString fullname = item->property("fullName").value(); showHotkey = text.isEmpty() || fullname.toLower().contains(text.toLower()); if (showHotkey && !obs_key_combination_is_empty(filterCombo)) { showHotkey = false; for (auto combo : combos) { if (combo == filterCombo) { showHotkey = true; continue; } } } label->widget()->setVisible(showHotkey); auto field = hotkeysLayout->itemAt(i, QFormLayout::FieldRole); if (field) field->widget()->setVisible(showHotkey); } ui->hotkeyScrollArea->setUpdatesEnabled(true); } void OBSBasicSettings::on_hotkeyFilterReset_clicked() { ui->hotkeyFilterSearch->setText(""); ui->hotkeyFilterInput->ResetKey(); } void OBSBasicSettings::on_hotkeyFilterSearch_textChanged(const QString text) { SearchHotkeys(text, ui->hotkeyFilterInput->key); } void OBSBasicSettings::on_hotkeyFilterInput_KeyChanged( obs_key_combination_t combo) { SearchHotkeys(ui->hotkeyFilterSearch->text(), combo); } static bool MarkHotkeyConflicts(OBSHotkeyLabel *item1, OBSHotkeyLabel *item2) { if (item1->pairPartner == item2) return false; auto &edits1 = item1->widget->edits; auto &edits2 = item2->widget->edits; bool hasDupes = false; for (auto &edit1 : edits1) { for (auto &edit2 : edits2) { bool isDupe = !obs_key_combination_is_empty(edit1->key) && edit1->key == edit2->key; hasDupes |= isDupe; edit1->hasDuplicate |= isDupe; edit2->hasDuplicate |= isDupe; } } return hasDupes; }; bool OBSBasicSettings::ScanDuplicateHotkeys(QFormLayout *layout) { vector items; bool hasDupes = false; for (int i = 0; i < layout->rowCount(); i++) { auto label = layout->itemAt(i, QFormLayout::LabelRole); if (!label) continue; OBSHotkeyLabel *item = qobject_cast(label->widget()); if (!item) continue; items.push_back(item); for (auto &edit : item->widget->edits) edit->hasDuplicate = false; } for (size_t i = 0; i < items.size(); i++) { OBSHotkeyLabel *item1 = items[i]; for (size_t j = i + 1; j < items.size(); j++) hasDupes |= MarkHotkeyConflicts(item1, items[j]); } for (auto *item : items) { for (auto &edit : item->widget->edits) { edit->UpdateDuplicationState(); } } return hasDupes; } void OBSBasicSettings::ReloadHotkeys(obs_hotkey_id ignoreKey) { LoadHotkeySettings(ignoreKey); } void OBSBasicSettings::A11yChanged() { if (!loading) { a11yChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::AdvancedChanged() { if (!loading) { advancedChanged = true; sender()->setProperty("changed", QVariant(true)); EnableApplyButton(true); } } void OBSBasicSettings::AdvOutSplitFileChanged() { bool splitFile = ui->advOutSplitFile->isChecked(); int splitFileType = splitFile ? ui->advOutSplitFileType->currentIndex() : -1; ui->advOutSplitFileType->setEnabled(splitFile); ui->advOutSplitFileTimeLabel->setVisible(splitFileType == 0); ui->advOutSplitFileTime->setVisible(splitFileType == 0); ui->advOutSplitFileSizeLabel->setVisible(splitFileType == 1); ui->advOutSplitFileSize->setVisible(splitFileType == 1); } void OBSBasicSettings::AdvOutRecCheckWarnings() { auto Checked = [](QCheckBox *box) { return box->isChecked() ? 1 : 0; }; QString errorMsg; QString warningMsg; uint32_t tracks = Checked(ui->advOutRecTrack1) + Checked(ui->advOutRecTrack2) + Checked(ui->advOutRecTrack3) + Checked(ui->advOutRecTrack4) + Checked(ui->advOutRecTrack5) + Checked(ui->advOutRecTrack6); bool useStreamEncoder = ui->advOutRecEncoder->currentIndex() == 0; if (useStreamEncoder) { if (!warningMsg.isEmpty()) warningMsg += "\n\n"; warningMsg += QTStr("OutputWarnings.CannotPause"); } if (ui->advOutRecFormat->currentText().compare("flv") == 0) { ui->advRecTrackWidget->setCurrentWidget(ui->flvTracks); } else { ui->advRecTrackWidget->setCurrentWidget(ui->recTracks); if (tracks == 0) errorMsg = QTStr("OutputWarnings.NoTracksSelected"); } if (ui->advOutRecFormat->currentText().compare("mp4") == 0 || ui->advOutRecFormat->currentText().compare("mov") == 0) { if (!warningMsg.isEmpty()) warningMsg += "\n\n"; warningMsg += QTStr("OutputWarnings.MP4Recording"); ui->autoRemux->setText( QTStr("Basic.Settings.Advanced.AutoRemux") + " " + QTStr("Basic.Settings.Advanced.AutoRemux.MP4")); } else { ui->autoRemux->setText( QTStr("Basic.Settings.Advanced.AutoRemux")); } delete advOutRecWarning; if (!errorMsg.isEmpty() || !warningMsg.isEmpty()) { advOutRecWarning = new QLabel( errorMsg.isEmpty() ? warningMsg : errorMsg, this); advOutRecWarning->setObjectName( errorMsg.isEmpty() ? "warningLabel" : "errorLabel"); advOutRecWarning->setWordWrap(true); QFormLayout *formLayout = reinterpret_cast( ui->advOutRecTopContainer->layout()); formLayout->addRow(nullptr, advOutRecWarning); } } static inline QString MakeMemorySizeString(int bitrate, int seconds) { QString str = QTStr("Basic.Settings.Advanced.StreamDelay.MemoryUsage"); int megabytes = bitrate * seconds / 1000 / 8; return str.arg(QString::number(megabytes)); } void OBSBasicSettings::UpdateSimpleOutStreamDelayEstimate() { int seconds = ui->streamDelaySec->value(); int vBitrate = ui->simpleOutputVBitrate->value(); int aBitrate = ui->simpleOutputABitrate->currentText().toInt(); QString msg = MakeMemorySizeString(vBitrate + aBitrate, seconds); ui->streamDelayInfo->setText(msg); } void OBSBasicSettings::UpdateAdvOutStreamDelayEstimate() { if (!streamEncoderProps) return; OBSData settings = streamEncoderProps->GetSettings(); int trackIndex = config_get_int(main->Config(), "AdvOut", "TrackIndex"); QString aBitrateText; switch (trackIndex) { case 1: aBitrateText = ui->advOutTrack1Bitrate->currentText(); break; case 2: aBitrateText = ui->advOutTrack2Bitrate->currentText(); break; case 3: aBitrateText = ui->advOutTrack3Bitrate->currentText(); break; case 4: aBitrateText = ui->advOutTrack4Bitrate->currentText(); break; case 5: aBitrateText = ui->advOutTrack5Bitrate->currentText(); break; case 6: aBitrateText = ui->advOutTrack6Bitrate->currentText(); break; } int seconds = ui->streamDelaySec->value(); int vBitrate = (int)obs_data_get_int(settings, "bitrate"); int aBitrate = aBitrateText.toInt(); QString msg = MakeMemorySizeString(vBitrate + aBitrate, seconds); ui->streamDelayInfo->setText(msg); } void OBSBasicSettings::UpdateStreamDelayEstimate() { if (ui->outputMode->currentIndex() == 0) UpdateSimpleOutStreamDelayEstimate(); else UpdateAdvOutStreamDelayEstimate(); UpdateAutomaticReplayBufferCheckboxes(); } bool EncoderAvailable(const char *encoder) { const char *val; int i = 0; while (obs_enum_encoder_types(i++, &val)) if (strcmp(val, encoder) == 0) return true; return false; } void OBSBasicSettings::FillSimpleRecordingValues() { #define ADD_QUALITY(str) \ ui->simpleOutRecQuality->addItem( \ QTStr("Basic.Settings.Output.Simple.RecordingQuality." str), \ QString(str)); #define ENCODER_STR(str) QTStr("Basic.Settings.Output.Simple.Encoder." str) ADD_QUALITY("Stream"); ADD_QUALITY("Small"); ADD_QUALITY("HQ"); ADD_QUALITY("Lossless"); ui->simpleOutRecEncoder->addItem(ENCODER_STR("Software"), QString(SIMPLE_ENCODER_X264)); ui->simpleOutRecEncoder->addItem(ENCODER_STR("SoftwareLowCPU"), QString(SIMPLE_ENCODER_X264_LOWCPU)); if (EncoderAvailable("obs_qsv11")) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.QSV.H264"), QString(SIMPLE_ENCODER_QSV)); if (EncoderAvailable("ffmpeg_nvenc")) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.NVENC.H264"), QString(SIMPLE_ENCODER_NVENC)); #ifdef ENABLE_HEVC if (EncoderAvailable("h265_texture_amf")) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.AMD.HEVC"), QString(SIMPLE_ENCODER_AMD_HEVC)); if (EncoderAvailable("ffmpeg_hevc_nvenc")) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.NVENC.HEVC"), QString(SIMPLE_ENCODER_NVENC_HEVC)); #endif if (EncoderAvailable("h264_texture_amf")) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.AMD.H264"), QString(SIMPLE_ENCODER_AMD)); if (EncoderAvailable("com.apple.videotoolbox.videoencoder.ave.avc") #ifndef __aarch64__ && os_get_emulation_status() == true #endif ) ui->simpleOutRecEncoder->addItem( ENCODER_STR("Hardware.Apple.H264"), QString(SIMPLE_ENCODER_APPLE_H264)); #undef ADD_QUALITY #undef ENCODER_STR } void OBSBasicSettings::FillAudioMonitoringDevices() { QComboBox *cb = ui->monitoringDevice; auto enum_devices = [](void *param, const char *name, const char *id) { QComboBox *cb = (QComboBox *)param; cb->addItem(name, id); return true; }; cb->addItem(QTStr("Basic.Settings.Advanced.Audio.MonitoringDevice" ".Default"), "default"); obs_enum_audio_monitoring_devices(enum_devices, cb); } void OBSBasicSettings::SimpleRecordingQualityChanged() { QString qual = ui->simpleOutRecQuality->currentData().toString(); bool streamQuality = qual == "Stream"; bool losslessQuality = !streamQuality && qual == "Lossless"; bool showEncoder = !streamQuality && !losslessQuality; ui->simpleOutRecEncoder->setVisible(showEncoder); ui->simpleOutRecEncoderLabel->setVisible(showEncoder); ui->simpleOutRecFormat->setVisible(!losslessQuality); ui->simpleOutRecFormatLabel->setVisible(!losslessQuality); SimpleRecordingEncoderChanged(); SimpleReplayBufferChanged(); } void OBSBasicSettings::SimpleStreamingEncoderChanged() { QString encoder = ui->simpleOutStrEncoder->currentData().toString(); QString preset; const char *defaultPreset = nullptr; ui->simpleOutAdvanced->setVisible(true); ui->simpleOutPresetLabel->setVisible(true); ui->simpleOutPreset->setVisible(true); ui->simpleOutPreset->clear(); if (encoder == SIMPLE_ENCODER_QSV) { ui->simpleOutPreset->addItem("speed", "speed"); ui->simpleOutPreset->addItem("balanced", "balanced"); ui->simpleOutPreset->addItem("quality", "quality"); defaultPreset = "balanced"; preset = curQSVPreset; } else if (encoder == SIMPLE_ENCODER_NVENC || encoder == SIMPLE_ENCODER_NVENC_HEVC) { const char *name = encoder == SIMPLE_ENCODER_NVENC ? "ffmpeg_nvenc" : "ffmpeg_hevc_nvenc"; obs_properties_t *props = obs_get_encoder_properties(name); obs_property_t *p = obs_properties_get(props, "preset"); size_t num = obs_property_list_item_count(p); for (size_t i = 0; i < num; i++) { const char *name = obs_property_list_item_name(p, i); const char *val = obs_property_list_item_string(p, i); /* bluray is for ideal bluray disc recording settings, * not streaming */ if (strcmp(val, "bd") == 0) continue; /* lossless should of course not be used to stream */ if (astrcmp_n(val, "lossless", 8) == 0) continue; ui->simpleOutPreset->addItem(QT_UTF8(name), val); } obs_properties_destroy(props); defaultPreset = "default"; preset = curNVENCPreset; } else if (encoder == SIMPLE_ENCODER_AMD || encoder == SIMPLE_ENCODER_AMD_HEVC) { ui->simpleOutPreset->addItem("Speed", "speed"); ui->simpleOutPreset->addItem("Balanced", "balanced"); ui->simpleOutPreset->addItem("Quality", "quality"); defaultPreset = "balanced"; preset = curAMDPreset; } else if (encoder == SIMPLE_ENCODER_APPLE_H264) { ui->simpleOutAdvanced->setChecked(false); ui->simpleOutAdvanced->setVisible(false); ui->simpleOutPreset->setVisible(false); ui->simpleOutPresetLabel->setVisible(false); } else { #define PRESET_STR(val) \ QString(Str("Basic.Settings.Output.EncoderPreset." val)).arg(val) ui->simpleOutPreset->addItem(PRESET_STR("ultrafast"), "ultrafast"); ui->simpleOutPreset->addItem("superfast", "superfast"); ui->simpleOutPreset->addItem(PRESET_STR("veryfast"), "veryfast"); ui->simpleOutPreset->addItem("faster", "faster"); ui->simpleOutPreset->addItem(PRESET_STR("fast"), "fast"); #undef PRESET_STR /* Users might have previously selected a preset which is no * longer available in simple mode. Make sure we don't mess * with their setups without them knowing. */ if (ui->simpleOutPreset->findData(curPreset) == -1) { ui->simpleOutPreset->addItem(curPreset, curPreset); QStandardItemModel *model = qobject_cast( ui->simpleOutPreset->model()); QStandardItem *item = model->item(model->rowCount() - 1); item->setEnabled(false); } defaultPreset = "veryfast"; preset = curPreset; } int idx = ui->simpleOutPreset->findData(QVariant(preset)); if (idx == -1) idx = ui->simpleOutPreset->findData(QVariant(defaultPreset)); ui->simpleOutPreset->setCurrentIndex(idx); } #define ESTIMATE_STR "Basic.Settings.Output.ReplayBuffer.Estimate" #define ESTIMATE_UNKNOWN_STR \ "Basic.Settings.Output.ReplayBuffer.EstimateUnknown" void OBSBasicSettings::UpdateAutomaticReplayBufferCheckboxes() { bool state = false; switch (ui->outputMode->currentIndex()) { case 0: state = ui->simpleReplayBuf->isChecked(); ui->simpleReplayBuf->setEnabled( !obs_frontend_replay_buffer_active()); break; case 1: state = ui->advReplayBuf->isChecked(); ui->advReplayBuf->setEnabled( !obs_frontend_replay_buffer_active()); break; } ui->replayWhileStreaming->setEnabled(state); ui->keepReplayStreamStops->setEnabled( state && ui->replayWhileStreaming->isChecked()); } void OBSBasicSettings::SimpleReplayBufferChanged() { QString qual = ui->simpleOutRecQuality->currentData().toString(); bool replayBufferEnabled = ui->simpleReplayBuf->isChecked(); bool lossless = qual == "Lossless"; bool streamQuality = qual == "Stream"; ui->simpleRBMegsMax->setVisible(!streamQuality); ui->simpleRBMegsMaxLabel->setVisible(!streamQuality); int vbitrate = ui->simpleOutputVBitrate->value(); int abitrate = ui->simpleOutputABitrate->currentText().toInt(); int seconds = ui->simpleRBSecMax->value(); int64_t memMB = int64_t(seconds) * int64_t(vbitrate + abitrate) * 1000 / 8 / 1024 / 1024; if (memMB < 1) memMB = 1; if (streamQuality) ui->simpleRBEstimate->setText( QTStr(ESTIMATE_STR).arg(QString::number(int(memMB)))); else ui->simpleRBEstimate->setText(QTStr(ESTIMATE_UNKNOWN_STR)); ui->replayBufferGroupBox->setVisible(!lossless && replayBufferEnabled); ui->simpleReplayBuf->setVisible(!lossless); UpdateAutomaticReplayBufferCheckboxes(); } #define TEXT_USE_STREAM_ENC \ QTStr("Basic.Settings.Output.Adv.Recording.UseStreamEncoder") void OBSBasicSettings::AdvReplayBufferChanged() { obs_data_t *settings; QString encoder = ui->advOutRecEncoder->currentText(); bool useStream = QString::compare(encoder, TEXT_USE_STREAM_ENC) == 0; if (useStream && streamEncoderProps) { settings = streamEncoderProps->GetSettings(); } else if (!useStream && recordEncoderProps) { settings = recordEncoderProps->GetSettings(); } else { if (useStream) encoder = GetComboData(ui->advOutEncoder); settings = obs_encoder_defaults(encoder.toUtf8().constData()); if (!settings) return; char encoderJsonPath[512]; int ret = GetProfilePath(encoderJsonPath, sizeof(encoderJsonPath), "recordEncoder.json"); if (ret > 0) { OBSDataAutoRelease data = obs_data_create_from_json_file_safe( encoderJsonPath, "bak"); obs_data_apply(settings, data); } } int vbitrate = (int)obs_data_get_int(settings, "bitrate"); const char *rateControl = obs_data_get_string(settings, "rate_control"); if (!rateControl) rateControl = ""; bool lossless = strcmp(rateControl, "lossless") == 0 || ui->advOutRecType->currentIndex() == 1; bool replayBufferEnabled = ui->advReplayBuf->isChecked(); int abitrate = 0; if (ui->advOutRecTrack1->isChecked()) abitrate += ui->advOutTrack1Bitrate->currentText().toInt(); if (ui->advOutRecTrack2->isChecked()) abitrate += ui->advOutTrack2Bitrate->currentText().toInt(); if (ui->advOutRecTrack3->isChecked()) abitrate += ui->advOutTrack3Bitrate->currentText().toInt(); if (ui->advOutRecTrack4->isChecked()) abitrate += ui->advOutTrack4Bitrate->currentText().toInt(); if (ui->advOutRecTrack5->isChecked()) abitrate += ui->advOutTrack5Bitrate->currentText().toInt(); if (ui->advOutRecTrack6->isChecked()) abitrate += ui->advOutTrack6Bitrate->currentText().toInt(); int seconds = ui->advRBSecMax->value(); int64_t memMB = int64_t(seconds) * int64_t(vbitrate + abitrate) * 1000 / 8 / 1024 / 1024; if (memMB < 1) memMB = 1; bool varRateControl = (astrcmpi(rateControl, "CBR") == 0 || astrcmpi(rateControl, "VBR") == 0 || astrcmpi(rateControl, "ABR") == 0); if (vbitrate == 0) varRateControl = false; ui->advRBMegsMax->setVisible(!varRateControl); ui->advRBMegsMaxLabel->setVisible(!varRateControl); if (varRateControl) ui->advRBEstimate->setText( QTStr(ESTIMATE_STR).arg(QString::number(int(memMB)))); else ui->advRBEstimate->setText(QTStr(ESTIMATE_UNKNOWN_STR)); ui->advReplayBufferFrame->setEnabled(!lossless && replayBufferEnabled); ui->advReplayBuf->setEnabled(!lossless); UpdateAutomaticReplayBufferCheckboxes(); } #define SIMPLE_OUTPUT_WARNING(str) \ QTStr("Basic.Settings.Output.Simple.Warn." str) void OBSBasicSettings::SimpleRecordingEncoderChanged() { QString qual = ui->simpleOutRecQuality->currentData().toString(); QString warning; bool enforceBitrate = !ui->ignoreRecommended->isChecked(); OBSService service = GetStream1Service(); delete simpleOutRecWarning; if (enforceBitrate && service) { OBSDataAutoRelease videoSettings = obs_data_create(); OBSDataAutoRelease audioSettings = obs_data_create(); int oldVBitrate = ui->simpleOutputVBitrate->value(); int oldABitrate = ui->simpleOutputABitrate->currentText().toInt(); obs_data_set_int(videoSettings, "bitrate", oldVBitrate); obs_data_set_int(audioSettings, "bitrate", oldABitrate); obs_service_apply_encoder_settings(service, videoSettings, audioSettings); int newVBitrate = obs_data_get_int(videoSettings, "bitrate"); int newABitrate = obs_data_get_int(audioSettings, "bitrate"); if (newVBitrate < oldVBitrate) warning = SIMPLE_OUTPUT_WARNING("VideoBitrate") .arg(newVBitrate); if (newABitrate < oldABitrate) { if (!warning.isEmpty()) warning += "\n\n"; warning += SIMPLE_OUTPUT_WARNING("AudioBitrate") .arg(newABitrate); } } if (qual == "Lossless") { if (!warning.isEmpty()) warning += "\n\n"; warning += SIMPLE_OUTPUT_WARNING("Lossless"); warning += "\n\n"; warning += SIMPLE_OUTPUT_WARNING("Encoder"); } else if (qual != "Stream") { QString enc = ui->simpleOutRecEncoder->currentData().toString(); QString streamEnc = ui->simpleOutStrEncoder->currentData().toString(); bool x264RecEnc = (enc == SIMPLE_ENCODER_X264 || enc == SIMPLE_ENCODER_X264_LOWCPU); if (streamEnc == SIMPLE_ENCODER_X264 && x264RecEnc) { if (!warning.isEmpty()) warning += "\n\n"; warning += SIMPLE_OUTPUT_WARNING("Encoder"); } } else { if (!warning.isEmpty()) warning += "\n\n"; warning += SIMPLE_OUTPUT_WARNING("CannotPause"); } if (qual != "Lossless" && (ui->simpleOutRecFormat->currentText().compare("mp4") == 0 || ui->simpleOutRecFormat->currentText().compare("mov") == 0)) { if (!warning.isEmpty()) warning += "\n\n"; warning += QTStr("OutputWarnings.MP4Recording"); ui->autoRemux->setText( QTStr("Basic.Settings.Advanced.AutoRemux") + " " + QTStr("Basic.Settings.Advanced.AutoRemux.MP4")); } else { ui->autoRemux->setText( QTStr("Basic.Settings.Advanced.AutoRemux")); } if (warning.isEmpty()) return; simpleOutRecWarning = new QLabel(warning, this); simpleOutRecWarning->setObjectName("warningLabel"); simpleOutRecWarning->setWordWrap(true); ui->simpleOutInfoLayout->addWidget(simpleOutRecWarning); } void OBSBasicSettings::SurroundWarning(int idx) { if (idx == lastChannelSetupIdx || idx == -1) return; if (loading) { lastChannelSetupIdx = idx; return; } QString speakerLayoutQstr = ui->channelSetup->itemText(idx); bool surround = IsSurround(QT_TO_UTF8(speakerLayoutQstr)); QString lastQstr = ui->channelSetup->itemText(lastChannelSetupIdx); bool wasSurround = IsSurround(QT_TO_UTF8(lastQstr)); if (surround && !wasSurround) { QMessageBox::StandardButton button; QString warningString = QTStr("Basic.Settings.ProgramRestart") + QStringLiteral("\n\n") + QTStr(MULTI_CHANNEL_WARNING) + QStringLiteral("\n\n") + QTStr(MULTI_CHANNEL_WARNING ".Confirm"); button = OBSMessageBox::question( this, QTStr(MULTI_CHANNEL_WARNING ".Title"), warningString); if (button == QMessageBox::No) { QMetaObject::invokeMethod( ui->channelSetup, "setCurrentIndex", Qt::QueuedConnection, Q_ARG(int, lastChannelSetupIdx)); return; } } lastChannelSetupIdx = idx; } #define LL_BUFFERING_WARNING "Basic.Settings.Audio.LowLatencyBufferingWarning" void OBSBasicSettings::UpdateAudioWarnings() { QString speakerLayoutQstr = ui->channelSetup->currentText(); bool surround = IsSurround(QT_TO_UTF8(speakerLayoutQstr)); bool lowBufferingActive = ui->lowLatencyBuffering->isChecked(); QString text; if (surround) { text = QTStr(MULTI_CHANNEL_WARNING ".Enabled") + QStringLiteral("\n\n") + QTStr(MULTI_CHANNEL_WARNING); } if (lowBufferingActive) { if (!text.isEmpty()) text += QStringLiteral("\n\n"); text += QTStr(LL_BUFFERING_WARNING ".Enabled") + QStringLiteral("\n\n") + QTStr(LL_BUFFERING_WARNING); } ui->audioMsg_2->setText(text); } void OBSBasicSettings::LowLatencyBufferingChanged(bool checked) { if (checked) { QString warningStr = QTStr(LL_BUFFERING_WARNING) + QStringLiteral("\n\n") + QTStr(LL_BUFFERING_WARNING ".Confirm"); auto button = OBSMessageBox::question( this, QTStr(LL_BUFFERING_WARNING ".Title"), warningStr); if (button == QMessageBox::No) { QMetaObject::invokeMethod(ui->lowLatencyBuffering, "setChecked", Qt::QueuedConnection, Q_ARG(bool, false)); return; } } QMetaObject::invokeMethod(this, "UpdateAudioWarnings", Qt::QueuedConnection); QMetaObject::invokeMethod(this, "AudioChangedRestart"); } void OBSBasicSettings::SimpleRecordingQualityLosslessWarning(int idx) { if (idx == lastSimpleRecQualityIdx || idx == -1) return; QString qual = ui->simpleOutRecQuality->itemData(idx).toString(); if (loading) { lastSimpleRecQualityIdx = idx; return; } if (qual == "Lossless") { QMessageBox::StandardButton button; QString warningString = SIMPLE_OUTPUT_WARNING("Lossless") + QString("\n\n") + SIMPLE_OUTPUT_WARNING("Lossless.Msg"); button = OBSMessageBox::question( this, SIMPLE_OUTPUT_WARNING("Lossless.Title"), warningString); if (button == QMessageBox::No) { QMetaObject::invokeMethod( ui->simpleOutRecQuality, "setCurrentIndex", Qt::QueuedConnection, Q_ARG(int, lastSimpleRecQualityIdx)); return; } } lastSimpleRecQualityIdx = idx; } void OBSBasicSettings::on_disableOSXVSync_clicked() { #ifdef __APPLE__ if (!loading) { bool disable = ui->disableOSXVSync->isChecked(); ui->resetOSXVSync->setEnabled(disable); } #endif } QIcon OBSBasicSettings::GetGeneralIcon() const { return generalIcon; } QIcon OBSBasicSettings::GetStreamIcon() const { return streamIcon; } QIcon OBSBasicSettings::GetOutputIcon() const { return outputIcon; } QIcon OBSBasicSettings::GetAudioIcon() const { return audioIcon; } QIcon OBSBasicSettings::GetVideoIcon() const { return videoIcon; } QIcon OBSBasicSettings::GetHotkeysIcon() const { return hotkeysIcon; } QIcon OBSBasicSettings::GetAccessibilityIcon() const { return accessibilityIcon; } QIcon OBSBasicSettings::GetAdvancedIcon() const { return advancedIcon; } void OBSBasicSettings::SetGeneralIcon(const QIcon &icon) { ui->listWidget->item(0)->setIcon(icon); } void OBSBasicSettings::SetStreamIcon(const QIcon &icon) { ui->listWidget->item(1)->setIcon(icon); } void OBSBasicSettings::SetOutputIcon(const QIcon &icon) { ui->listWidget->item(2)->setIcon(icon); } void OBSBasicSettings::SetAudioIcon(const QIcon &icon) { ui->listWidget->item(3)->setIcon(icon); } void OBSBasicSettings::SetVideoIcon(const QIcon &icon) { ui->listWidget->item(4)->setIcon(icon); } void OBSBasicSettings::SetHotkeysIcon(const QIcon &icon) { ui->listWidget->item(5)->setIcon(icon); } void OBSBasicSettings::SetAccessibilityIcon(const QIcon &icon) { ui->listWidget->item(6)->setIcon(icon); } void OBSBasicSettings::SetAdvancedIcon(const QIcon &icon) { ui->listWidget->item(7)->setIcon(icon); } int OBSBasicSettings::CurrentFLVTrack() { if (ui->flvTrack1->isChecked()) return 1; else if (ui->flvTrack2->isChecked()) return 2; else if (ui->flvTrack3->isChecked()) return 3; else if (ui->flvTrack4->isChecked()) return 4; else if (ui->flvTrack5->isChecked()) return 5; else if (ui->flvTrack6->isChecked()) return 6; return 0; } /* Using setEditable(true) on a QComboBox when there's a custom style in use * does not work properly, so instead completely recreate the widget, which * seems to work fine. */ void OBSBasicSettings::RecreateOutputResolutionWidget() { QSizePolicy sizePolicy = ui->outputResolution->sizePolicy(); bool changed = WidgetChanged(ui->outputResolution); delete ui->outputResolution; ui->outputResolution = new QComboBox(ui->videoPage); ui->outputResolution->setObjectName( QString::fromUtf8("outputResolution")); ui->outputResolution->setSizePolicy(sizePolicy); ui->outputResolution->setEditable(true); ui->outputResolution->setProperty("changed", changed); ui->outputResLabel->setBuddy(ui->outputResolution); ui->outputResLayout->insertWidget(0, ui->outputResolution); QWidget::setTabOrder(ui->baseResolution, ui->outputResolution); QWidget::setTabOrder(ui->outputResolution, ui->downscaleFilter); HookWidget(ui->outputResolution, CBEDIT_CHANGED, VIDEO_RES); connect(ui->outputResolution, &QComboBox::editTextChanged, this, &OBSBasicSettings::on_outputResolution_editTextChanged); ui->outputResolution->lineEdit()->setValidator( ui->baseResolution->lineEdit()->validator()); } void OBSBasicSettings::UpdateAdvNetworkGroup() { bool enabled = IsServiceOutputHasNetworkFeatures(); ui->advNetworkDisabled->setVisible(!enabled); ui->bindToIPLabel->setVisible(enabled); ui->bindToIP->setVisible(enabled); ui->dynBitrate->setVisible(enabled); #ifdef _WIN32 ui->enableNewSocketLoop->setVisible(enabled); ui->enableLowLatencyMode->setVisible(enabled); #endif }