window-basic-settings.cpp 90 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120
  1. /******************************************************************************
  2. Copyright (C) 2013-2014 by Hugh Bailey <[email protected]>
  3. Philippe Groarke <[email protected]>
  4. This program is free software: you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation, either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program. If not, see <http://www.gnu.org/licenses/>.
  14. ******************************************************************************/
  15. #include <obs.hpp>
  16. #include <util/util.hpp>
  17. #include <util/lexer.h>
  18. #include <graphics/math-defs.h>
  19. #include <initializer_list>
  20. #include <sstream>
  21. #include <QCompleter>
  22. #include <QLineEdit>
  23. #include <QMessageBox>
  24. #include <QCloseEvent>
  25. #include <QFileDialog>
  26. #include <QDirIterator>
  27. #include <QVariant>
  28. #include <QTreeView>
  29. #include <QStandardItemModel>
  30. #include <QSpacerItem>
  31. #include "audio-encoders.hpp"
  32. #include "hotkey-edit.hpp"
  33. #include "source-label.hpp"
  34. #include "obs-app.hpp"
  35. #include "platform.hpp"
  36. #include "properties-view.hpp"
  37. #include "qt-wrappers.hpp"
  38. #include "window-basic-main.hpp"
  39. #include "window-basic-settings.hpp"
  40. #include <util/platform.h>
  41. using namespace std;
  42. // Used for QVariant in codec comboboxes
  43. namespace {
  44. static bool StringEquals(QString left, QString right)
  45. {
  46. return left == right;
  47. }
  48. struct FormatDesc {
  49. const char *name = nullptr;
  50. const char *mimeType = nullptr;
  51. const ff_format_desc *desc = nullptr;
  52. inline FormatDesc() = default;
  53. inline FormatDesc(const char *name, const char *mimeType,
  54. const ff_format_desc *desc = nullptr)
  55. : name(name), mimeType(mimeType), desc(desc) {}
  56. bool operator==(const FormatDesc &f) const
  57. {
  58. if (!StringEquals(name, f.name))
  59. return false;
  60. return StringEquals(mimeType, f.mimeType);
  61. }
  62. };
  63. struct CodecDesc {
  64. const char *name = nullptr;
  65. int id = 0;
  66. inline CodecDesc() = default;
  67. inline CodecDesc(const char *name, int id) : name(name), id(id) {}
  68. bool operator==(const CodecDesc &codecDesc) const
  69. {
  70. if (id != codecDesc.id)
  71. return false;
  72. return StringEquals(name, codecDesc.name);
  73. }
  74. };
  75. }
  76. Q_DECLARE_METATYPE(FormatDesc)
  77. Q_DECLARE_METATYPE(CodecDesc)
  78. /* parses "[width]x[height]", string, i.e. 1024x768 */
  79. static bool ConvertResText(const char *res, uint32_t &cx, uint32_t &cy)
  80. {
  81. BaseLexer lex;
  82. base_token token;
  83. lexer_start(lex, res);
  84. /* parse width */
  85. if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
  86. return false;
  87. if (token.type != BASETOKEN_DIGIT)
  88. return false;
  89. cx = std::stoul(token.text.array);
  90. /* parse 'x' */
  91. if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
  92. return false;
  93. if (strref_cmpi(&token.text, "x") != 0)
  94. return false;
  95. /* parse height */
  96. if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
  97. return false;
  98. if (token.type != BASETOKEN_DIGIT)
  99. return false;
  100. cy = std::stoul(token.text.array);
  101. /* shouldn't be any more tokens after this */
  102. if (lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
  103. return false;
  104. return true;
  105. }
  106. static inline bool WidgetChanged(QWidget *widget)
  107. {
  108. return widget->property("changed").toBool();
  109. }
  110. static inline void SetComboByName(QComboBox *combo, const char *name)
  111. {
  112. int idx = combo->findText(QT_UTF8(name));
  113. if (idx != -1)
  114. combo->setCurrentIndex(idx);
  115. }
  116. static inline void SetComboByValue(QComboBox *combo, const char *name)
  117. {
  118. int idx = combo->findData(QT_UTF8(name));
  119. if (idx != -1)
  120. combo->setCurrentIndex(idx);
  121. }
  122. static inline QString GetComboData(QComboBox *combo)
  123. {
  124. int idx = combo->currentIndex();
  125. if (idx == -1)
  126. return QString();
  127. return combo->itemData(idx).toString();
  128. }
  129. static int FindEncoder(QComboBox *combo, const char *name, int id)
  130. {
  131. CodecDesc codecDesc(name, id);
  132. for(int i = 0; i < combo->count(); i++) {
  133. QVariant v = combo->itemData(i);
  134. if (!v.isNull()) {
  135. if (codecDesc == v.value<CodecDesc>()) {
  136. return i;
  137. break;
  138. }
  139. }
  140. }
  141. return -1;
  142. }
  143. static CodecDesc GetDefaultCodecDesc(const ff_format_desc *formatDesc,
  144. ff_codec_type codecType)
  145. {
  146. int id = 0;
  147. switch (codecType) {
  148. case FF_CODEC_AUDIO:
  149. id = ff_format_desc_audio(formatDesc);
  150. break;
  151. case FF_CODEC_VIDEO:
  152. id = ff_format_desc_video(formatDesc);
  153. break;
  154. default:
  155. return CodecDesc();
  156. }
  157. return CodecDesc(ff_format_desc_get_default_name(formatDesc, codecType),
  158. id);
  159. }
  160. #ifdef _WIN32
  161. void OBSBasicSettings::ToggleDisableAero(bool checked)
  162. {
  163. SetAeroEnabled(!checked);
  164. }
  165. #endif
  166. static void PopulateAACBitrates(initializer_list<QComboBox*> boxes)
  167. {
  168. auto &bitrateMap = GetAACEncoderBitrateMap();
  169. if (bitrateMap.empty())
  170. return;
  171. vector<pair<QString, QString>> pairs;
  172. for (auto &entry : bitrateMap)
  173. pairs.emplace_back(QString::number(entry.first),
  174. obs_encoder_get_display_name(entry.second));
  175. for (auto box : boxes) {
  176. QString currentText = box->currentText();
  177. box->clear();
  178. for (auto &pair : pairs) {
  179. box->addItem(pair.first);
  180. box->setItemData(box->count() - 1, pair.second,
  181. Qt::ToolTipRole);
  182. }
  183. box->setCurrentText(currentText);
  184. }
  185. }
  186. void OBSBasicSettings::HookWidget(QWidget *widget, const char *signal,
  187. const char *slot)
  188. {
  189. QObject::connect(widget, signal, this, slot);
  190. widget->setProperty("changed", QVariant(false));
  191. }
  192. #define COMBO_CHANGED SIGNAL(currentIndexChanged(int))
  193. #define EDIT_CHANGED SIGNAL(textChanged(const QString &))
  194. #define CBEDIT_CHANGED SIGNAL(editTextChanged(const QString &))
  195. #define CHECK_CHANGED SIGNAL(clicked(bool))
  196. #define SCROLL_CHANGED SIGNAL(valueChanged(int))
  197. #define GENERAL_CHANGED SLOT(GeneralChanged())
  198. #define STREAM1_CHANGED SLOT(Stream1Changed())
  199. #define OUTPUTS_CHANGED SLOT(OutputsChanged())
  200. #define AUDIO_RESTART SLOT(AudioChangedRestart())
  201. #define AUDIO_CHANGED SLOT(AudioChanged())
  202. #define VIDEO_RESTART SLOT(VideoChangedRestart())
  203. #define VIDEO_RES SLOT(VideoChangedResolution())
  204. #define VIDEO_CHANGED SLOT(VideoChanged())
  205. #define ADV_CHANGED SLOT(AdvancedChanged())
  206. #define ADV_RESTART SLOT(AdvancedChangedRestart())
  207. OBSBasicSettings::OBSBasicSettings(QWidget *parent)
  208. : QDialog (parent),
  209. main (qobject_cast<OBSBasic*>(parent)),
  210. ui (new Ui::OBSBasicSettings)
  211. {
  212. string path;
  213. ui->setupUi(this);
  214. PopulateAACBitrates({ui->simpleOutputABitrate,
  215. ui->advOutTrack1Bitrate, ui->advOutTrack2Bitrate,
  216. ui->advOutTrack3Bitrate, ui->advOutTrack3Bitrate});
  217. ui->listWidget->setAttribute(Qt::WA_MacShowFocusRect, false);
  218. auto policy = ui->audioSourceScrollArea->sizePolicy();
  219. policy.setVerticalStretch(true);
  220. ui->audioSourceScrollArea->setSizePolicy(policy);
  221. HookWidget(ui->language, COMBO_CHANGED, GENERAL_CHANGED);
  222. HookWidget(ui->theme, COMBO_CHANGED, GENERAL_CHANGED);
  223. HookWidget(ui->warnBeforeStreamStart,CHECK_CHANGED, GENERAL_CHANGED);
  224. HookWidget(ui->warnBeforeStreamStop, CHECK_CHANGED, GENERAL_CHANGED);
  225. HookWidget(ui->snappingEnabled, CHECK_CHANGED, GENERAL_CHANGED);
  226. HookWidget(ui->screenSnapping, CHECK_CHANGED, GENERAL_CHANGED);
  227. HookWidget(ui->centerSnapping, CHECK_CHANGED, GENERAL_CHANGED);
  228. HookWidget(ui->sourceSnapping, CHECK_CHANGED, GENERAL_CHANGED);
  229. HookWidget(ui->snapDistance, SCROLL_CHANGED, GENERAL_CHANGED);
  230. HookWidget(ui->outputMode, COMBO_CHANGED, OUTPUTS_CHANGED);
  231. HookWidget(ui->streamType, COMBO_CHANGED, STREAM1_CHANGED);
  232. HookWidget(ui->simpleOutputPath, EDIT_CHANGED, OUTPUTS_CHANGED);
  233. HookWidget(ui->simpleNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED);
  234. HookWidget(ui->simpleOutRecFormat, COMBO_CHANGED, OUTPUTS_CHANGED);
  235. HookWidget(ui->simpleOutputVBitrate, SCROLL_CHANGED, OUTPUTS_CHANGED);
  236. HookWidget(ui->simpleOutputABitrate, COMBO_CHANGED, OUTPUTS_CHANGED);
  237. HookWidget(ui->simpleOutAdvanced, CHECK_CHANGED, OUTPUTS_CHANGED);
  238. HookWidget(ui->simpleOutPreset, COMBO_CHANGED, OUTPUTS_CHANGED);
  239. HookWidget(ui->simpleOutCustom, EDIT_CHANGED, OUTPUTS_CHANGED);
  240. HookWidget(ui->simpleOutRecQuality, COMBO_CHANGED, OUTPUTS_CHANGED);
  241. HookWidget(ui->simpleOutRecEncoder, COMBO_CHANGED, OUTPUTS_CHANGED);
  242. HookWidget(ui->simpleOutMuxCustom, EDIT_CHANGED, OUTPUTS_CHANGED);
  243. HookWidget(ui->advOutEncoder, COMBO_CHANGED, OUTPUTS_CHANGED);
  244. HookWidget(ui->advOutUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED);
  245. HookWidget(ui->advOutRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED);
  246. HookWidget(ui->advOutTrack1, CHECK_CHANGED, OUTPUTS_CHANGED);
  247. HookWidget(ui->advOutTrack2, CHECK_CHANGED, OUTPUTS_CHANGED);
  248. HookWidget(ui->advOutTrack3, CHECK_CHANGED, OUTPUTS_CHANGED);
  249. HookWidget(ui->advOutTrack4, CHECK_CHANGED, OUTPUTS_CHANGED);
  250. HookWidget(ui->advOutApplyService, CHECK_CHANGED, OUTPUTS_CHANGED);
  251. HookWidget(ui->advOutRecType, COMBO_CHANGED, OUTPUTS_CHANGED);
  252. HookWidget(ui->advOutRecPath, EDIT_CHANGED, OUTPUTS_CHANGED);
  253. HookWidget(ui->advOutNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED);
  254. HookWidget(ui->advOutRecFormat, COMBO_CHANGED, OUTPUTS_CHANGED);
  255. HookWidget(ui->advOutRecEncoder, COMBO_CHANGED, OUTPUTS_CHANGED);
  256. HookWidget(ui->advOutRecUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED);
  257. HookWidget(ui->advOutRecRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED);
  258. HookWidget(ui->advOutMuxCustom, EDIT_CHANGED, OUTPUTS_CHANGED);
  259. HookWidget(ui->advOutRecTrack1, CHECK_CHANGED, OUTPUTS_CHANGED);
  260. HookWidget(ui->advOutRecTrack2, CHECK_CHANGED, OUTPUTS_CHANGED);
  261. HookWidget(ui->advOutRecTrack3, CHECK_CHANGED, OUTPUTS_CHANGED);
  262. HookWidget(ui->advOutRecTrack4, CHECK_CHANGED, OUTPUTS_CHANGED);
  263. HookWidget(ui->advOutFFType, COMBO_CHANGED, OUTPUTS_CHANGED);
  264. HookWidget(ui->advOutFFRecPath, EDIT_CHANGED, OUTPUTS_CHANGED);
  265. HookWidget(ui->advOutFFNoSpace, CHECK_CHANGED, OUTPUTS_CHANGED);
  266. HookWidget(ui->advOutFFURL, EDIT_CHANGED, OUTPUTS_CHANGED);
  267. HookWidget(ui->advOutFFFormat, COMBO_CHANGED, OUTPUTS_CHANGED);
  268. HookWidget(ui->advOutFFMCfg, EDIT_CHANGED, OUTPUTS_CHANGED);
  269. HookWidget(ui->advOutFFVBitrate, SCROLL_CHANGED, OUTPUTS_CHANGED);
  270. HookWidget(ui->advOutFFUseRescale, CHECK_CHANGED, OUTPUTS_CHANGED);
  271. HookWidget(ui->advOutFFRescale, CBEDIT_CHANGED, OUTPUTS_CHANGED);
  272. HookWidget(ui->advOutFFVEncoder, COMBO_CHANGED, OUTPUTS_CHANGED);
  273. HookWidget(ui->advOutFFVCfg, EDIT_CHANGED, OUTPUTS_CHANGED);
  274. HookWidget(ui->advOutFFABitrate, SCROLL_CHANGED, OUTPUTS_CHANGED);
  275. HookWidget(ui->advOutFFTrack1, CHECK_CHANGED, OUTPUTS_CHANGED);
  276. HookWidget(ui->advOutFFTrack2, CHECK_CHANGED, OUTPUTS_CHANGED);
  277. HookWidget(ui->advOutFFTrack3, CHECK_CHANGED, OUTPUTS_CHANGED);
  278. HookWidget(ui->advOutFFTrack4, CHECK_CHANGED, OUTPUTS_CHANGED);
  279. HookWidget(ui->advOutFFAEncoder, COMBO_CHANGED, OUTPUTS_CHANGED);
  280. HookWidget(ui->advOutFFACfg, EDIT_CHANGED, OUTPUTS_CHANGED);
  281. HookWidget(ui->advOutTrack1Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED);
  282. HookWidget(ui->advOutTrack1Name, EDIT_CHANGED, OUTPUTS_CHANGED);
  283. HookWidget(ui->advOutTrack2Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED);
  284. HookWidget(ui->advOutTrack2Name, EDIT_CHANGED, OUTPUTS_CHANGED);
  285. HookWidget(ui->advOutTrack3Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED);
  286. HookWidget(ui->advOutTrack3Name, EDIT_CHANGED, OUTPUTS_CHANGED);
  287. HookWidget(ui->advOutTrack4Bitrate, COMBO_CHANGED, OUTPUTS_CHANGED);
  288. HookWidget(ui->advOutTrack4Name, EDIT_CHANGED, OUTPUTS_CHANGED);
  289. HookWidget(ui->channelSetup, COMBO_CHANGED, AUDIO_RESTART);
  290. HookWidget(ui->sampleRate, COMBO_CHANGED, AUDIO_RESTART);
  291. HookWidget(ui->desktopAudioDevice1, COMBO_CHANGED, AUDIO_CHANGED);
  292. HookWidget(ui->desktopAudioDevice2, COMBO_CHANGED, AUDIO_CHANGED);
  293. HookWidget(ui->auxAudioDevice1, COMBO_CHANGED, AUDIO_CHANGED);
  294. HookWidget(ui->auxAudioDevice2, COMBO_CHANGED, AUDIO_CHANGED);
  295. HookWidget(ui->auxAudioDevice3, COMBO_CHANGED, AUDIO_CHANGED);
  296. HookWidget(ui->baseResolution, CBEDIT_CHANGED, VIDEO_RES);
  297. HookWidget(ui->outputResolution, CBEDIT_CHANGED, VIDEO_RES);
  298. HookWidget(ui->downscaleFilter, COMBO_CHANGED, VIDEO_CHANGED);
  299. HookWidget(ui->fpsType, COMBO_CHANGED, VIDEO_CHANGED);
  300. HookWidget(ui->fpsCommon, COMBO_CHANGED, VIDEO_CHANGED);
  301. HookWidget(ui->fpsInteger, SCROLL_CHANGED, VIDEO_CHANGED);
  302. HookWidget(ui->fpsInteger, SCROLL_CHANGED, VIDEO_CHANGED);
  303. HookWidget(ui->fpsNumerator, SCROLL_CHANGED, VIDEO_CHANGED);
  304. HookWidget(ui->fpsDenominator, SCROLL_CHANGED, VIDEO_CHANGED);
  305. HookWidget(ui->renderer, COMBO_CHANGED, ADV_RESTART);
  306. HookWidget(ui->adapter, COMBO_CHANGED, ADV_RESTART);
  307. HookWidget(ui->colorFormat, COMBO_CHANGED, ADV_CHANGED);
  308. HookWidget(ui->colorSpace, COMBO_CHANGED, ADV_CHANGED);
  309. HookWidget(ui->colorRange, COMBO_CHANGED, ADV_CHANGED);
  310. HookWidget(ui->disableOSXVSync, CHECK_CHANGED, ADV_CHANGED);
  311. HookWidget(ui->resetOSXVSync, CHECK_CHANGED, ADV_CHANGED);
  312. HookWidget(ui->filenameFormatting, EDIT_CHANGED, ADV_CHANGED);
  313. HookWidget(ui->overwriteIfExists, CHECK_CHANGED, ADV_CHANGED);
  314. HookWidget(ui->streamDelayEnable, CHECK_CHANGED, ADV_CHANGED);
  315. HookWidget(ui->streamDelaySec, SCROLL_CHANGED, ADV_CHANGED);
  316. HookWidget(ui->streamDelayPreserve, CHECK_CHANGED, ADV_CHANGED);
  317. HookWidget(ui->reconnectEnable, CHECK_CHANGED, ADV_CHANGED);
  318. HookWidget(ui->reconnectRetryDelay, SCROLL_CHANGED, ADV_CHANGED);
  319. HookWidget(ui->reconnectMaxRetries, SCROLL_CHANGED, ADV_CHANGED);
  320. #ifdef _WIN32
  321. uint32_t winVer = GetWindowsVersion();
  322. if (winVer > 0 && winVer < 0x602) {
  323. toggleAero = new QCheckBox(
  324. QTStr("Basic.Settings.Video.DisableAero"),
  325. this);
  326. QFormLayout *videoLayout =
  327. reinterpret_cast<QFormLayout*>(ui->videoPage->layout());
  328. videoLayout->addRow(nullptr, toggleAero);
  329. HookWidget(toggleAero, CHECK_CHANGED, VIDEO_CHANGED);
  330. connect(toggleAero, &QAbstractButton::toggled,
  331. this, &OBSBasicSettings::ToggleDisableAero);
  332. }
  333. #else
  334. delete ui->rendererLabel;
  335. delete ui->renderer;
  336. delete ui->adapterLabel;
  337. delete ui->adapter;
  338. ui->rendererLabel = nullptr;
  339. ui->renderer = nullptr;
  340. ui->adapterLabel = nullptr;
  341. ui->adapter = nullptr;
  342. #endif
  343. #ifndef __APPLE__
  344. delete ui->disableOSXVSync;
  345. delete ui->resetOSXVSync;
  346. ui->disableOSXVSync = nullptr;
  347. ui->resetOSXVSync = nullptr;
  348. #endif
  349. connect(ui->streamDelaySec, SIGNAL(valueChanged(int)),
  350. this, SLOT(UpdateStreamDelayEstimate()));
  351. connect(ui->outputMode, SIGNAL(currentIndexChanged(int)),
  352. this, SLOT(UpdateStreamDelayEstimate()));
  353. connect(ui->simpleOutputVBitrate, SIGNAL(valueChanged(int)),
  354. this, SLOT(UpdateStreamDelayEstimate()));
  355. connect(ui->simpleOutputABitrate, SIGNAL(currentIndexChanged(int)),
  356. this, SLOT(UpdateStreamDelayEstimate()));
  357. connect(ui->advOutTrack1Bitrate, SIGNAL(currentIndexChanged(int)),
  358. this, SLOT(UpdateStreamDelayEstimate()));
  359. connect(ui->advOutTrack2Bitrate, SIGNAL(currentIndexChanged(int)),
  360. this, SLOT(UpdateStreamDelayEstimate()));
  361. connect(ui->advOutTrack3Bitrate, SIGNAL(currentIndexChanged(int)),
  362. this, SLOT(UpdateStreamDelayEstimate()));
  363. connect(ui->advOutTrack4Bitrate, SIGNAL(currentIndexChanged(int)),
  364. this, SLOT(UpdateStreamDelayEstimate()));
  365. //Apply button disabled until change.
  366. EnableApplyButton(false);
  367. // Initialize libff library
  368. ff_init();
  369. installEventFilter(CreateShortcutFilter());
  370. LoadServiceTypes();
  371. LoadEncoderTypes();
  372. LoadColorRanges();
  373. LoadFormats();
  374. auto ReloadAudioSources = [](void *data, calldata_t *param)
  375. {
  376. auto settings = static_cast<OBSBasicSettings*>(data);
  377. auto source = static_cast<obs_source_t*>(calldata_ptr(param,
  378. "source"));
  379. if (!source)
  380. return;
  381. if (!(obs_source_get_output_flags(source) & OBS_SOURCE_AUDIO))
  382. return;
  383. QMetaObject::invokeMethod(settings, "ReloadAudioSources",
  384. Qt::QueuedConnection);
  385. };
  386. sourceCreated.Connect(obs_get_signal_handler(), "source_create",
  387. ReloadAudioSources, this);
  388. channelChanged.Connect(obs_get_signal_handler(), "channel_change",
  389. ReloadAudioSources, this);
  390. auto ReloadHotkeys = [](void *data, calldata_t*)
  391. {
  392. auto settings = static_cast<OBSBasicSettings*>(data);
  393. QMetaObject::invokeMethod(settings, "ReloadHotkeys");
  394. };
  395. hotkeyRegistered.Connect(obs_get_signal_handler(), "hotkey_register",
  396. ReloadHotkeys, this);
  397. auto ReloadHotkeysIgnore = [](void *data, calldata_t *param)
  398. {
  399. auto settings = static_cast<OBSBasicSettings*>(data);
  400. auto key = static_cast<obs_hotkey_t*>(
  401. calldata_ptr(param,"key"));
  402. QMetaObject::invokeMethod(settings, "ReloadHotkeys",
  403. Q_ARG(obs_hotkey_id, obs_hotkey_get_id(key)));
  404. };
  405. hotkeyUnregistered.Connect(obs_get_signal_handler(),
  406. "hotkey_unregister", ReloadHotkeysIgnore, this);
  407. FillSimpleRecordingValues();
  408. connect(ui->simpleOutRecQuality, SIGNAL(currentIndexChanged(int)),
  409. this, SLOT(SimpleRecordingQualityChanged()));
  410. connect(ui->simpleOutRecQuality, SIGNAL(currentIndexChanged(int)),
  411. this, SLOT(SimpleRecordingQualityLosslessWarning(int)));
  412. connect(ui->simpleOutRecEncoder, SIGNAL(currentIndexChanged(int)),
  413. this, SLOT(SimpleRecordingEncoderChanged()));
  414. LoadSettings(false);
  415. // Add warning checks to advanced output recording section controls
  416. connect(ui->advOutRecTrack1, SIGNAL(clicked()),
  417. this, SLOT(AdvOutRecCheckWarnings()));
  418. connect(ui->advOutRecTrack2, SIGNAL(clicked()),
  419. this, SLOT(AdvOutRecCheckWarnings()));
  420. connect(ui->advOutRecTrack3, SIGNAL(clicked()),
  421. this, SLOT(AdvOutRecCheckWarnings()));
  422. connect(ui->advOutRecTrack4, SIGNAL(clicked()),
  423. this, SLOT(AdvOutRecCheckWarnings()));
  424. AdvOutRecCheckWarnings();
  425. SimpleRecordingQualityChanged();
  426. }
  427. void OBSBasicSettings::SaveCombo(QComboBox *widget, const char *section,
  428. const char *value)
  429. {
  430. if (WidgetChanged(widget))
  431. config_set_string(main->Config(), section, value,
  432. QT_TO_UTF8(widget->currentText()));
  433. }
  434. void OBSBasicSettings::SaveComboData(QComboBox *widget, const char *section,
  435. const char *value)
  436. {
  437. if (WidgetChanged(widget)) {
  438. QString str = GetComboData(widget);
  439. config_set_string(main->Config(), section, value,
  440. QT_TO_UTF8(str));
  441. }
  442. }
  443. void OBSBasicSettings::SaveCheckBox(QAbstractButton *widget,
  444. const char *section, const char *value, bool invert)
  445. {
  446. if (WidgetChanged(widget)) {
  447. bool checked = widget->isChecked();
  448. if (invert) checked = !checked;
  449. config_set_bool(main->Config(), section, value, checked);
  450. }
  451. }
  452. void OBSBasicSettings::SaveEdit(QLineEdit *widget, const char *section,
  453. const char *value)
  454. {
  455. if (WidgetChanged(widget))
  456. config_set_string(main->Config(), section, value,
  457. QT_TO_UTF8(widget->text()));
  458. }
  459. void OBSBasicSettings::SaveSpinBox(QSpinBox *widget, const char *section,
  460. const char *value)
  461. {
  462. if (WidgetChanged(widget))
  463. config_set_int(main->Config(), section, value, widget->value());
  464. }
  465. void OBSBasicSettings::LoadServiceTypes()
  466. {
  467. const char *type;
  468. size_t idx = 0;
  469. while (obs_enum_service_types(idx++, &type)) {
  470. const char *name = obs_service_get_display_name(type);
  471. QString qName = QT_UTF8(name);
  472. QString qType = QT_UTF8(type);
  473. ui->streamType->addItem(qName, qType);
  474. }
  475. type = obs_service_get_type(main->GetService());
  476. SetComboByValue(ui->streamType, type);
  477. }
  478. #define TEXT_USE_STREAM_ENC \
  479. QTStr("Basic.Settings.Output.Adv.Recording.UseStreamEncoder")
  480. void OBSBasicSettings::LoadEncoderTypes()
  481. {
  482. const char *type;
  483. size_t idx = 0;
  484. ui->advOutRecEncoder->addItem(TEXT_USE_STREAM_ENC, "none");
  485. while (obs_enum_encoder_types(idx++, &type)) {
  486. const char *name = obs_encoder_get_display_name(type);
  487. const char *codec = obs_get_encoder_codec(type);
  488. if (strcmp(codec, "h264") != 0)
  489. continue;
  490. QString qName = QT_UTF8(name);
  491. QString qType = QT_UTF8(type);
  492. ui->advOutEncoder->addItem(qName, qType);
  493. ui->advOutRecEncoder->addItem(qName, qType);
  494. }
  495. }
  496. #define CS_PARTIAL_STR QTStr("Basic.Settings.Advanced.Video.ColorRange.Partial")
  497. #define CS_FULL_STR QTStr("Basic.Settings.Advanced.Video.ColorRange.Full")
  498. void OBSBasicSettings::LoadColorRanges()
  499. {
  500. ui->colorRange->addItem(CS_PARTIAL_STR, "Partial");
  501. ui->colorRange->addItem(CS_FULL_STR, "Full");
  502. }
  503. #define AV_FORMAT_DEFAULT_STR \
  504. QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatDefault")
  505. #define AUDIO_STR \
  506. QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatAudio")
  507. #define VIDEO_STR \
  508. QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatVideo")
  509. void OBSBasicSettings::LoadFormats()
  510. {
  511. ui->advOutFFFormat->blockSignals(true);
  512. formats.reset(ff_format_supported());
  513. const ff_format_desc *format = formats.get();
  514. while(format != nullptr) {
  515. bool audio = ff_format_desc_has_audio(format);
  516. bool video = ff_format_desc_has_video(format);
  517. FormatDesc formatDesc(ff_format_desc_name(format),
  518. ff_format_desc_mime_type(format),
  519. format);
  520. if (audio || video) {
  521. QString itemText(ff_format_desc_name(format));
  522. if (audio ^ video)
  523. itemText += QString(" (%1)").arg(
  524. audio ? AUDIO_STR : VIDEO_STR);
  525. ui->advOutFFFormat->addItem(itemText,
  526. qVariantFromValue(formatDesc));
  527. }
  528. format = ff_format_desc_next(format);
  529. }
  530. ui->advOutFFFormat->model()->sort(0);
  531. ui->advOutFFFormat->insertItem(0, AV_FORMAT_DEFAULT_STR);
  532. ui->advOutFFFormat->blockSignals(false);
  533. }
  534. static void AddCodec(QComboBox *combo, const ff_codec_desc *codec_desc)
  535. {
  536. QString itemText(ff_codec_desc_name(codec_desc));
  537. if (ff_codec_desc_is_alias(codec_desc))
  538. itemText += QString(" (%1)").arg(
  539. ff_codec_desc_base_name(codec_desc));
  540. CodecDesc cd(ff_codec_desc_name(codec_desc),
  541. ff_codec_desc_id(codec_desc));
  542. combo->addItem(itemText, qVariantFromValue(cd));
  543. }
  544. #define AV_ENCODER_DEFAULT_STR \
  545. QTStr("Basic.Settings.Output.Adv.FFmpeg.AVEncoderDefault")
  546. static void AddDefaultCodec(QComboBox *combo, const ff_format_desc *formatDesc,
  547. ff_codec_type codecType)
  548. {
  549. CodecDesc cd = GetDefaultCodecDesc(formatDesc, codecType);
  550. int existingIdx = FindEncoder(combo, cd.name, cd.id);
  551. if (existingIdx >= 0)
  552. combo->removeItem(existingIdx);
  553. combo->addItem(QString("%1 (%2)").arg(cd.name, AV_ENCODER_DEFAULT_STR),
  554. qVariantFromValue(cd));
  555. }
  556. #define AV_ENCODER_DISABLE_STR \
  557. QTStr("Basic.Settings.Output.Adv.FFmpeg.AVEncoderDisable")
  558. void OBSBasicSettings::ReloadCodecs(const ff_format_desc *formatDesc)
  559. {
  560. ui->advOutFFAEncoder->blockSignals(true);
  561. ui->advOutFFVEncoder->blockSignals(true);
  562. ui->advOutFFAEncoder->clear();
  563. ui->advOutFFVEncoder->clear();
  564. if (formatDesc == nullptr)
  565. return;
  566. OBSFFCodecDesc codecDescs(ff_codec_supported(formatDesc));
  567. const ff_codec_desc *codec = codecDescs.get();
  568. while(codec != nullptr) {
  569. switch (ff_codec_desc_type(codec)) {
  570. case FF_CODEC_AUDIO:
  571. AddCodec(ui->advOutFFAEncoder, codec);
  572. break;
  573. case FF_CODEC_VIDEO:
  574. AddCodec(ui->advOutFFVEncoder, codec);
  575. break;
  576. default:
  577. break;
  578. }
  579. codec = ff_codec_desc_next(codec);
  580. }
  581. if (ff_format_desc_has_audio(formatDesc))
  582. AddDefaultCodec(ui->advOutFFAEncoder, formatDesc,
  583. FF_CODEC_AUDIO);
  584. if (ff_format_desc_has_video(formatDesc))
  585. AddDefaultCodec(ui->advOutFFVEncoder, formatDesc,
  586. FF_CODEC_VIDEO);
  587. ui->advOutFFAEncoder->model()->sort(0);
  588. ui->advOutFFVEncoder->model()->sort(0);
  589. QVariant disable = qVariantFromValue(CodecDesc());
  590. ui->advOutFFAEncoder->insertItem(0, AV_ENCODER_DISABLE_STR, disable);
  591. ui->advOutFFVEncoder->insertItem(0, AV_ENCODER_DISABLE_STR, disable);
  592. ui->advOutFFAEncoder->blockSignals(false);
  593. ui->advOutFFVEncoder->blockSignals(false);
  594. }
  595. void OBSBasicSettings::LoadLanguageList()
  596. {
  597. const char *currentLang = App()->GetLocale();
  598. ui->language->clear();
  599. for (const auto &locale : GetLocaleNames()) {
  600. int idx = ui->language->count();
  601. ui->language->addItem(QT_UTF8(locale.second.c_str()),
  602. QT_UTF8(locale.first.c_str()));
  603. if (locale.first == currentLang)
  604. ui->language->setCurrentIndex(idx);
  605. }
  606. ui->language->model()->sort(0);
  607. }
  608. void OBSBasicSettings::LoadThemeList()
  609. {
  610. /* Save theme if user presses Cancel */
  611. savedTheme = string(App()->GetTheme());
  612. ui->theme->clear();
  613. QSet<QString> uniqueSet;
  614. string themeDir;
  615. char userThemeDir[512];
  616. int ret = GetConfigPath(userThemeDir, sizeof(userThemeDir),
  617. "obs-studio/themes/");
  618. GetDataFilePath("themes/", themeDir);
  619. /* Check user dir first. */
  620. if (ret > 0) {
  621. QDirIterator it(QString(userThemeDir), QStringList() << "*.qss",
  622. QDir::Files);
  623. while (it.hasNext()) {
  624. it.next();
  625. QString name = it.fileName().section(".",0,0);
  626. ui->theme->addItem(name);
  627. uniqueSet.insert(name);
  628. }
  629. }
  630. /* Check shipped themes. */
  631. QDirIterator uIt(QString(themeDir.c_str()), QStringList() << "*.qss",
  632. QDir::Files);
  633. while (uIt.hasNext()) {
  634. uIt.next();
  635. QString name = uIt.fileName().section(".",0,0);
  636. if (!uniqueSet.contains(name))
  637. ui->theme->addItem(name);
  638. }
  639. int idx = ui->theme->findText(App()->GetTheme());
  640. if (idx != -1)
  641. ui->theme->setCurrentIndex(idx);
  642. }
  643. void OBSBasicSettings::LoadGeneralSettings()
  644. {
  645. loading = true;
  646. LoadLanguageList();
  647. LoadThemeList();
  648. bool snappingEnabled = config_get_bool(GetGlobalConfig(),
  649. "BasicWindow", "SnappingEnabled");
  650. ui->snappingEnabled->setChecked(snappingEnabled);
  651. bool screenSnapping = config_get_bool(GetGlobalConfig(),
  652. "BasicWindow", "ScreenSnapping");
  653. ui->screenSnapping->setChecked(screenSnapping);
  654. bool centerSnapping = config_get_bool(GetGlobalConfig(),
  655. "BasicWindow", "CenterSnapping");
  656. ui->centerSnapping->setChecked(centerSnapping);
  657. bool sourceSnapping = config_get_bool(GetGlobalConfig(),
  658. "BasicWindow", "SourceSnapping");
  659. ui->sourceSnapping->setChecked(sourceSnapping);
  660. double snapDistance = config_get_double(GetGlobalConfig(),
  661. "BasicWindow", "SnapDistance");
  662. ui->snapDistance->setValue(snapDistance);
  663. bool warnBeforeStreamStart = config_get_bool(GetGlobalConfig(),
  664. "BasicWindow", "WarnBeforeStartingStream");
  665. ui->warnBeforeStreamStart->setChecked(warnBeforeStreamStart);
  666. bool warnBeforeStreamStop = config_get_bool(GetGlobalConfig(),
  667. "BasicWindow", "WarnBeforeStoppingStream");
  668. ui->warnBeforeStreamStop->setChecked(warnBeforeStreamStop);
  669. loading = false;
  670. }
  671. void OBSBasicSettings::LoadStream1Settings()
  672. {
  673. QLayout *layout = ui->streamContainer->layout();
  674. obs_service_t *service = main->GetService();
  675. const char *type = obs_service_get_type(service);
  676. loading = true;
  677. obs_data_t *settings = obs_service_get_settings(service);
  678. delete streamProperties;
  679. streamProperties = new OBSPropertiesView(settings, type,
  680. (PropertiesReloadCallback)obs_get_service_properties,
  681. 170);
  682. streamProperties->setProperty("changed", QVariant(false));
  683. layout->addWidget(streamProperties);
  684. QObject::connect(streamProperties, SIGNAL(Changed()),
  685. this, STREAM1_CHANGED);
  686. obs_data_release(settings);
  687. loading = false;
  688. if (main->StreamingActive()) {
  689. ui->streamType->setEnabled(false);
  690. ui->streamContainer->setEnabled(false);
  691. }
  692. }
  693. void OBSBasicSettings::LoadRendererList()
  694. {
  695. #ifdef _WIN32
  696. const char *renderer = config_get_string(GetGlobalConfig(), "Video",
  697. "Renderer");
  698. ui->renderer->addItem(QT_UTF8("Direct3D 11"));
  699. ui->renderer->addItem(QT_UTF8("OpenGL"));
  700. int idx = ui->renderer->findText(QT_UTF8(renderer));
  701. if (idx == -1)
  702. idx = 0;
  703. if (strcmp(renderer, "OpenGL") == 0) {
  704. delete ui->adapter;
  705. delete ui->adapterLabel;
  706. ui->adapter = nullptr;
  707. ui->adapterLabel = nullptr;
  708. }
  709. ui->renderer->setCurrentIndex(idx);
  710. #endif
  711. }
  712. Q_DECLARE_METATYPE(MonitorInfo);
  713. static string ResString(uint32_t cx, uint32_t cy)
  714. {
  715. stringstream res;
  716. res << cx << "x" << cy;
  717. return res.str();
  718. }
  719. /* some nice default output resolution vals */
  720. static const double vals[] =
  721. {
  722. 1.0,
  723. 1.25,
  724. (1.0/0.75),
  725. 1.5,
  726. (1.0/0.6),
  727. 1.75,
  728. 2.0,
  729. 2.25,
  730. 2.5,
  731. 2.75,
  732. 3.0
  733. };
  734. static const size_t numVals = sizeof(vals)/sizeof(double);
  735. void OBSBasicSettings::ResetDownscales(uint32_t cx, uint32_t cy)
  736. {
  737. QString advRescale;
  738. QString advRecRescale;
  739. QString advFFRescale;
  740. QString oldOutputRes;
  741. string bestScale;
  742. int bestPixelDiff = 0x7FFFFFFF;
  743. uint32_t out_cx = outputCX;
  744. uint32_t out_cy = outputCY;
  745. advRescale = ui->advOutRescale->lineEdit()->text();
  746. advRecRescale = ui->advOutRecRescale->lineEdit()->text();
  747. advFFRescale = ui->advOutFFRescale->lineEdit()->text();
  748. ui->outputResolution->blockSignals(true);
  749. ui->outputResolution->clear();
  750. ui->advOutRescale->clear();
  751. ui->advOutRecRescale->clear();
  752. ui->advOutFFRescale->clear();
  753. if (!out_cx || !out_cy) {
  754. out_cx = cx;
  755. out_cy = cy;
  756. oldOutputRes = ui->baseResolution->lineEdit()->text();
  757. } else {
  758. oldOutputRes = QString::number(out_cx) + "x" +
  759. QString::number(out_cy);
  760. }
  761. for (size_t idx = 0; idx < numVals; idx++) {
  762. uint32_t downscaleCX = uint32_t(double(cx) / vals[idx]);
  763. uint32_t downscaleCY = uint32_t(double(cy) / vals[idx]);
  764. uint32_t outDownscaleCX = uint32_t(double(out_cx) / vals[idx]);
  765. uint32_t outDownscaleCY = uint32_t(double(out_cy) / vals[idx]);
  766. downscaleCX &= 0xFFFFFFFC;
  767. downscaleCY &= 0xFFFFFFFE;
  768. outDownscaleCX &= 0xFFFFFFFE;
  769. outDownscaleCY &= 0xFFFFFFFE;
  770. string res = ResString(downscaleCX, downscaleCY);
  771. string outRes = ResString(outDownscaleCX, outDownscaleCY);
  772. ui->outputResolution->addItem(res.c_str());
  773. ui->advOutRescale->addItem(outRes.c_str());
  774. ui->advOutRecRescale->addItem(outRes.c_str());
  775. ui->advOutFFRescale->addItem(outRes.c_str());
  776. /* always try to find the closest output resolution to the
  777. * previously set output resolution */
  778. int newPixelCount = int(downscaleCX * downscaleCY);
  779. int oldPixelCount = int(out_cx * out_cy);
  780. int diff = abs(newPixelCount - oldPixelCount);
  781. if (diff < bestPixelDiff) {
  782. bestScale = res;
  783. bestPixelDiff = diff;
  784. }
  785. }
  786. string res = ResString(cx, cy);
  787. float baseAspect = float(cx) / float(cy);
  788. float outputAspect = float(out_cx) / float(out_cy);
  789. bool closeAspect = close_float(baseAspect, outputAspect, 0.01f);
  790. if (closeAspect)
  791. ui->outputResolution->lineEdit()->setText(oldOutputRes);
  792. else
  793. ui->outputResolution->lineEdit()->setText(bestScale.c_str());
  794. ui->outputResolution->blockSignals(false);
  795. if (!closeAspect) {
  796. ui->outputResolution->setProperty("changed", QVariant(true));
  797. videoChanged = true;
  798. }
  799. if (advRescale.isEmpty())
  800. advRescale = res.c_str();
  801. if (advRecRescale.isEmpty())
  802. advRecRescale = res.c_str();
  803. if (advFFRescale.isEmpty())
  804. advFFRescale = res.c_str();
  805. ui->advOutRescale->lineEdit()->setText(advRescale);
  806. ui->advOutRecRescale->lineEdit()->setText(advRecRescale);
  807. ui->advOutFFRescale->lineEdit()->setText(advFFRescale);
  808. }
  809. void OBSBasicSettings::LoadDownscaleFilters()
  810. {
  811. ui->downscaleFilter->addItem(
  812. QTStr("Basic.Settings.Video.DownscaleFilter.Bilinear"),
  813. QT_UTF8("bilinear"));
  814. ui->downscaleFilter->addItem(
  815. QTStr("Basic.Settings.Video.DownscaleFilter.Bicubic"),
  816. QT_UTF8("bicubic"));
  817. ui->downscaleFilter->addItem(
  818. QTStr("Basic.Settings.Video.DownscaleFilter.Lanczos"),
  819. QT_UTF8("lanczos"));
  820. const char *scaleType = config_get_string(main->Config(),
  821. "Video", "ScaleType");
  822. if (astrcmpi(scaleType, "bilinear") == 0)
  823. ui->downscaleFilter->setCurrentIndex(0);
  824. else if (astrcmpi(scaleType, "lanczos") == 0)
  825. ui->downscaleFilter->setCurrentIndex(2);
  826. else
  827. ui->downscaleFilter->setCurrentIndex(1);
  828. }
  829. void OBSBasicSettings::LoadResolutionLists()
  830. {
  831. uint32_t cx = config_get_uint(main->Config(), "Video", "BaseCX");
  832. uint32_t cy = config_get_uint(main->Config(), "Video", "BaseCY");
  833. uint32_t out_cx = config_get_uint(main->Config(), "Video", "OutputCX");
  834. uint32_t out_cy = config_get_uint(main->Config(), "Video", "OutputCY");
  835. vector<MonitorInfo> monitors;
  836. ui->baseResolution->clear();
  837. GetMonitors(monitors);
  838. for (MonitorInfo &monitor : monitors) {
  839. string res = ResString(monitor.cx, monitor.cy);
  840. ui->baseResolution->addItem(res.c_str());
  841. }
  842. string outputResString = ResString(out_cx, out_cy);
  843. ui->baseResolution->lineEdit()->setText(ResString(cx, cy).c_str());
  844. RecalcOutputResPixels(outputResString.c_str());
  845. ResetDownscales(cx, cy);
  846. ui->outputResolution->lineEdit()->setText(outputResString.c_str());
  847. }
  848. static inline void LoadFPSCommon(OBSBasic *main, Ui::OBSBasicSettings *ui)
  849. {
  850. const char *val = config_get_string(main->Config(), "Video",
  851. "FPSCommon");
  852. int idx = ui->fpsCommon->findText(val);
  853. if (idx == -1) idx = 3;
  854. ui->fpsCommon->setCurrentIndex(idx);
  855. }
  856. static inline void LoadFPSInteger(OBSBasic *main, Ui::OBSBasicSettings *ui)
  857. {
  858. uint32_t val = config_get_uint(main->Config(), "Video", "FPSInt");
  859. ui->fpsInteger->setValue(val);
  860. }
  861. static inline void LoadFPSFraction(OBSBasic *main, Ui::OBSBasicSettings *ui)
  862. {
  863. uint32_t num = config_get_uint(main->Config(), "Video", "FPSNum");
  864. uint32_t den = config_get_uint(main->Config(), "Video", "FPSDen");
  865. ui->fpsNumerator->setValue(num);
  866. ui->fpsDenominator->setValue(den);
  867. }
  868. void OBSBasicSettings::LoadFPSData()
  869. {
  870. LoadFPSCommon(main, ui.get());
  871. LoadFPSInteger(main, ui.get());
  872. LoadFPSFraction(main, ui.get());
  873. uint32_t fpsType = config_get_uint(main->Config(), "Video",
  874. "FPSType");
  875. if (fpsType > 2) fpsType = 0;
  876. ui->fpsType->setCurrentIndex(fpsType);
  877. ui->fpsTypes->setCurrentIndex(fpsType);
  878. }
  879. void OBSBasicSettings::LoadVideoSettings()
  880. {
  881. loading = true;
  882. if (video_output_active(obs_get_video())) {
  883. ui->videoPage->setEnabled(false);
  884. ui->videoMsg->setText(
  885. QTStr("Basic.Settings.Video.CurrentlyActive"));
  886. }
  887. LoadResolutionLists();
  888. LoadFPSData();
  889. LoadDownscaleFilters();
  890. #ifdef _WIN32
  891. if (toggleAero) {
  892. bool disableAero = config_get_bool(main->Config(), "Video",
  893. "DisableAero");
  894. toggleAero->setChecked(disableAero);
  895. aeroWasDisabled = disableAero;
  896. }
  897. #endif
  898. loading = false;
  899. }
  900. void OBSBasicSettings::LoadSimpleOutputSettings()
  901. {
  902. const char *path = config_get_string(main->Config(), "SimpleOutput",
  903. "FilePath");
  904. bool noSpace = config_get_bool(main->Config(), "SimpleOutput",
  905. "FileNameWithoutSpace");
  906. const char *format = config_get_string(main->Config(), "SimpleOutput",
  907. "RecFormat");
  908. int videoBitrate = config_get_uint(main->Config(), "SimpleOutput",
  909. "VBitrate");
  910. int audioBitrate = config_get_uint(main->Config(), "SimpleOutput",
  911. "ABitrate");
  912. bool advanced = config_get_bool(main->Config(), "SimpleOutput",
  913. "UseAdvanced");
  914. const char *preset = config_get_string(main->Config(), "SimpleOutput",
  915. "Preset");
  916. const char *custom = config_get_string(main->Config(), "SimpleOutput",
  917. "x264Settings");
  918. const char *recQual = config_get_string(main->Config(), "SimpleOutput",
  919. "RecQuality");
  920. const char *recEnc = config_get_string(main->Config(), "SimpleOutput",
  921. "RecEncoder");
  922. const char *muxCustom = config_get_string(main->Config(),
  923. "SimpleOutput", "MuxerCustom");
  924. audioBitrate = FindClosestAvailableAACBitrate(audioBitrate);
  925. ui->simpleOutputPath->setText(path);
  926. ui->simpleNoSpace->setChecked(noSpace);
  927. ui->simpleOutputVBitrate->setValue(videoBitrate);
  928. int idx = ui->simpleOutRecFormat->findText(format);
  929. ui->simpleOutRecFormat->setCurrentIndex(idx);
  930. SetComboByName(ui->simpleOutputABitrate,
  931. std::to_string(audioBitrate).c_str());
  932. ui->simpleOutAdvanced->setChecked(advanced);
  933. ui->simpleOutPreset->setCurrentText(preset);
  934. ui->simpleOutCustom->setText(custom);
  935. idx = ui->simpleOutRecQuality->findData(QString(recQual));
  936. if (idx == -1) idx = 0;
  937. ui->simpleOutRecQuality->setCurrentIndex(idx);
  938. idx = ui->simpleOutRecEncoder->findData(QString(recEnc));
  939. if (idx == -1) idx = 0;
  940. ui->simpleOutRecEncoder->setCurrentIndex(idx);
  941. ui->simpleOutMuxCustom->setText(muxCustom);
  942. }
  943. void OBSBasicSettings::LoadAdvOutputStreamingSettings()
  944. {
  945. bool rescale = config_get_bool(main->Config(), "AdvOut",
  946. "Rescale");
  947. const char *rescaleRes = config_get_string(main->Config(), "AdvOut",
  948. "RescaleRes");
  949. int trackIndex = config_get_int(main->Config(), "AdvOut",
  950. "TrackIndex");
  951. bool applyServiceSettings = config_get_bool(main->Config(), "AdvOut",
  952. "ApplyServiceSettings");
  953. ui->advOutApplyService->setChecked(applyServiceSettings);
  954. ui->advOutUseRescale->setChecked(rescale);
  955. ui->advOutRescale->setEnabled(rescale);
  956. ui->advOutRescale->setCurrentText(rescaleRes);
  957. QStringList specList = QTStr("FilenameFormatting.completer").split(
  958. QRegularExpression("\n"));
  959. QCompleter *specCompleter = new QCompleter(specList);
  960. specCompleter->setCaseSensitivity(Qt::CaseSensitive);
  961. specCompleter->setFilterMode(Qt::MatchContains);
  962. ui->filenameFormatting->setCompleter(specCompleter);
  963. ui->filenameFormatting->setToolTip(QTStr("FilenameFormatting.TT"));
  964. switch (trackIndex) {
  965. case 1: ui->advOutTrack1->setChecked(true); break;
  966. case 2: ui->advOutTrack2->setChecked(true); break;
  967. case 3: ui->advOutTrack3->setChecked(true); break;
  968. case 4: ui->advOutTrack4->setChecked(true); break;
  969. }
  970. }
  971. OBSPropertiesView *OBSBasicSettings::CreateEncoderPropertyView(
  972. const char *encoder, const char *path, bool changed)
  973. {
  974. obs_data_t *settings = obs_encoder_defaults(encoder);
  975. OBSPropertiesView *view;
  976. char encoderJsonPath[512];
  977. int ret = GetProfilePath(encoderJsonPath, sizeof(encoderJsonPath),
  978. path);
  979. if (ret > 0) {
  980. obs_data_t *data = obs_data_create_from_json_file_safe(
  981. encoderJsonPath, "bak");
  982. obs_data_apply(settings, data);
  983. obs_data_release(data);
  984. }
  985. view = new OBSPropertiesView(settings, encoder,
  986. (PropertiesReloadCallback)obs_get_encoder_properties,
  987. 170);
  988. view->setFrameShape(QFrame::StyledPanel);
  989. view->setProperty("changed", QVariant(changed));
  990. QObject::connect(view, SIGNAL(Changed()), this, SLOT(OutputsChanged()));
  991. obs_data_release(settings);
  992. return view;
  993. }
  994. void OBSBasicSettings::LoadAdvOutputStreamingEncoderProperties()
  995. {
  996. const char *encoder = config_get_string(main->Config(), "AdvOut",
  997. "Encoder");
  998. delete streamEncoderProps;
  999. streamEncoderProps = CreateEncoderPropertyView(encoder,
  1000. "streamEncoder.json");
  1001. ui->advOutputStreamTab->layout()->addWidget(streamEncoderProps);
  1002. connect(streamEncoderProps, SIGNAL(Changed()),
  1003. this, SLOT(UpdateStreamDelayEstimate()));
  1004. SetComboByValue(ui->advOutEncoder, encoder);
  1005. UpdateStreamDelayEstimate();
  1006. }
  1007. void OBSBasicSettings::LoadAdvOutputRecordingSettings()
  1008. {
  1009. const char *type = config_get_string(main->Config(), "AdvOut",
  1010. "RecType");
  1011. const char *format = config_get_string(main->Config(), "AdvOut",
  1012. "RecFormat");
  1013. const char *path = config_get_string(main->Config(), "AdvOut",
  1014. "RecFilePath");
  1015. bool noSpace = config_get_bool(main->Config(), "AdvOut",
  1016. "RecFileNameWithoutSpace");
  1017. bool rescale = config_get_bool(main->Config(), "AdvOut",
  1018. "RecRescale");
  1019. const char *rescaleRes = config_get_string(main->Config(), "AdvOut",
  1020. "RecRescaleRes");
  1021. const char *muxCustom = config_get_string(main->Config(), "AdvOut",
  1022. "RecMuxerCustom");
  1023. int tracks = config_get_int(main->Config(), "AdvOut", "RecTracks");
  1024. int typeIndex = (astrcmpi(type, "FFmpeg") == 0) ? 1 : 0;
  1025. ui->advOutRecType->setCurrentIndex(typeIndex);
  1026. ui->advOutRecPath->setText(path);
  1027. ui->advOutNoSpace->setChecked(noSpace);
  1028. ui->advOutRecUseRescale->setChecked(rescale);
  1029. ui->advOutRecRescale->setCurrentText(rescaleRes);
  1030. ui->advOutMuxCustom->setText(muxCustom);
  1031. int idx = ui->advOutRecFormat->findText(format);
  1032. ui->advOutRecFormat->setCurrentIndex(idx);
  1033. ui->advOutRecTrack1->setChecked(tracks & (1<<0));
  1034. ui->advOutRecTrack2->setChecked(tracks & (1<<1));
  1035. ui->advOutRecTrack3->setChecked(tracks & (1<<2));
  1036. ui->advOutRecTrack4->setChecked(tracks & (1<<3));
  1037. }
  1038. void OBSBasicSettings::LoadAdvOutputRecordingEncoderProperties()
  1039. {
  1040. const char *encoder = config_get_string(main->Config(), "AdvOut",
  1041. "RecEncoder");
  1042. delete recordEncoderProps;
  1043. recordEncoderProps = nullptr;
  1044. if (astrcmpi(encoder, "none") != 0) {
  1045. recordEncoderProps = CreateEncoderPropertyView(encoder,
  1046. "recordEncoder.json");
  1047. ui->advOutRecStandard->layout()->addWidget(recordEncoderProps);
  1048. }
  1049. SetComboByValue(ui->advOutRecEncoder, encoder);
  1050. }
  1051. static void SelectFormat(QComboBox *combo, const char *name,
  1052. const char *mimeType)
  1053. {
  1054. FormatDesc formatDesc(name, mimeType);
  1055. for(int i = 0; i < combo->count(); i++) {
  1056. QVariant v = combo->itemData(i);
  1057. if (!v.isNull()) {
  1058. if (formatDesc == v.value<FormatDesc>()) {
  1059. combo->setCurrentIndex(i);
  1060. return;
  1061. }
  1062. }
  1063. }
  1064. combo->setCurrentIndex(0);
  1065. }
  1066. static void SelectEncoder(QComboBox *combo, const char *name, int id)
  1067. {
  1068. int idx = FindEncoder(combo, name, id);
  1069. if (idx >= 0)
  1070. combo->setCurrentIndex(idx);
  1071. }
  1072. void OBSBasicSettings::LoadAdvOutputFFmpegSettings()
  1073. {
  1074. bool saveFile = config_get_bool(main->Config(), "AdvOut",
  1075. "FFOutputToFile");
  1076. const char *path = config_get_string(main->Config(), "AdvOut",
  1077. "FFFilePath");
  1078. bool noSpace = config_get_bool(main->Config(), "AdvOut",
  1079. "FFFileNameWithoutSpace");
  1080. const char *url = config_get_string(main->Config(), "AdvOut", "FFURL");
  1081. const char *format = config_get_string(main->Config(), "AdvOut",
  1082. "FFFormat");
  1083. const char *mimeType = config_get_string(main->Config(), "AdvOut",
  1084. "FFFormatMimeType");
  1085. const char *muxCustom = config_get_string(main->Config(), "AdvOut",
  1086. "FFMCustom");
  1087. int videoBitrate = config_get_int(main->Config(), "AdvOut",
  1088. "FFVBitrate");
  1089. bool rescale = config_get_bool(main->Config(), "AdvOut",
  1090. "FFRescale");
  1091. const char *rescaleRes = config_get_string(main->Config(), "AdvOut",
  1092. "FFRescaleRes");
  1093. const char *vEncoder = config_get_string(main->Config(), "AdvOut",
  1094. "FFVEncoder");
  1095. int vEncoderId = config_get_int(main->Config(), "AdvOut",
  1096. "FFVEncoderId");
  1097. const char *vEncCustom = config_get_string(main->Config(), "AdvOut",
  1098. "FFVCustom");
  1099. int audioBitrate = config_get_int(main->Config(), "AdvOut",
  1100. "FFABitrate");
  1101. int audioTrack = config_get_int(main->Config(), "AdvOut",
  1102. "FFAudioTrack");
  1103. const char *aEncoder = config_get_string(main->Config(), "AdvOut",
  1104. "FFAEncoder");
  1105. int aEncoderId = config_get_int(main->Config(), "AdvOut",
  1106. "FFAEncoderId");
  1107. const char *aEncCustom = config_get_string(main->Config(), "AdvOut",
  1108. "FFACustom");
  1109. ui->advOutFFType->setCurrentIndex(saveFile ? 0 : 1);
  1110. ui->advOutFFRecPath->setText(QT_UTF8(path));
  1111. ui->advOutFFNoSpace->setChecked(noSpace);
  1112. ui->advOutFFURL->setText(QT_UTF8(url));
  1113. SelectFormat(ui->advOutFFFormat, format, mimeType);
  1114. ui->advOutFFMCfg->setText(muxCustom);
  1115. ui->advOutFFVBitrate->setValue(videoBitrate);
  1116. ui->advOutFFUseRescale->setChecked(rescale);
  1117. ui->advOutFFRescale->setEnabled(rescale);
  1118. ui->advOutFFRescale->setCurrentText(rescaleRes);
  1119. SelectEncoder(ui->advOutFFVEncoder, vEncoder, vEncoderId);
  1120. ui->advOutFFVCfg->setText(vEncCustom);
  1121. ui->advOutFFABitrate->setValue(audioBitrate);
  1122. SelectEncoder(ui->advOutFFAEncoder, aEncoder, aEncoderId);
  1123. ui->advOutFFACfg->setText(aEncCustom);
  1124. switch (audioTrack) {
  1125. case 1: ui->advOutFFTrack1->setChecked(true); break;
  1126. case 2: ui->advOutFFTrack2->setChecked(true); break;
  1127. case 3: ui->advOutFFTrack3->setChecked(true); break;
  1128. case 4: ui->advOutFFTrack4->setChecked(true); break;
  1129. }
  1130. }
  1131. void OBSBasicSettings::LoadAdvOutputAudioSettings()
  1132. {
  1133. int track1Bitrate = config_get_uint(main->Config(), "AdvOut",
  1134. "Track1Bitrate");
  1135. int track2Bitrate = config_get_uint(main->Config(), "AdvOut",
  1136. "Track2Bitrate");
  1137. int track3Bitrate = config_get_uint(main->Config(), "AdvOut",
  1138. "Track3Bitrate");
  1139. int track4Bitrate = config_get_uint(main->Config(), "AdvOut",
  1140. "Track4Bitrate");
  1141. const char *name1 = config_get_string(main->Config(), "AdvOut",
  1142. "Track1Name");
  1143. const char *name2 = config_get_string(main->Config(), "AdvOut",
  1144. "Track2Name");
  1145. const char *name3 = config_get_string(main->Config(), "AdvOut",
  1146. "Track3Name");
  1147. const char *name4 = config_get_string(main->Config(), "AdvOut",
  1148. "Track4Name");
  1149. track1Bitrate = FindClosestAvailableAACBitrate(track1Bitrate);
  1150. track2Bitrate = FindClosestAvailableAACBitrate(track2Bitrate);
  1151. track3Bitrate = FindClosestAvailableAACBitrate(track3Bitrate);
  1152. track4Bitrate = FindClosestAvailableAACBitrate(track4Bitrate);
  1153. SetComboByName(ui->advOutTrack1Bitrate,
  1154. std::to_string(track1Bitrate).c_str());
  1155. SetComboByName(ui->advOutTrack2Bitrate,
  1156. std::to_string(track2Bitrate).c_str());
  1157. SetComboByName(ui->advOutTrack3Bitrate,
  1158. std::to_string(track3Bitrate).c_str());
  1159. SetComboByName(ui->advOutTrack4Bitrate,
  1160. std::to_string(track4Bitrate).c_str());
  1161. ui->advOutTrack1Name->setText(name1);
  1162. ui->advOutTrack2Name->setText(name2);
  1163. ui->advOutTrack3Name->setText(name3);
  1164. ui->advOutTrack4Name->setText(name4);
  1165. }
  1166. void OBSBasicSettings::LoadOutputSettings()
  1167. {
  1168. loading = true;
  1169. const char *mode = config_get_string(main->Config(), "Output", "Mode");
  1170. int modeIdx = astrcmpi(mode, "Advanced") == 0 ? 1 : 0;
  1171. ui->outputMode->setCurrentIndex(modeIdx);
  1172. LoadSimpleOutputSettings();
  1173. LoadAdvOutputStreamingSettings();
  1174. LoadAdvOutputStreamingEncoderProperties();
  1175. LoadAdvOutputRecordingSettings();
  1176. LoadAdvOutputRecordingEncoderProperties();
  1177. LoadAdvOutputFFmpegSettings();
  1178. LoadAdvOutputAudioSettings();
  1179. if (video_output_active(obs_get_video())) {
  1180. ui->outputMode->setEnabled(false);
  1181. ui->outputModeLabel->setEnabled(false);
  1182. ui->advOutTopContainer->setEnabled(false);
  1183. ui->advOutRecTopContainer->setEnabled(false);
  1184. ui->advOutRecTypeContainer->setEnabled(false);
  1185. ui->advOutputAudioTracksTab->setEnabled(false);
  1186. }
  1187. loading = false;
  1188. }
  1189. void OBSBasicSettings::SetAdvOutputFFmpegEnablement(
  1190. ff_codec_type encoderType, bool enabled,
  1191. bool enableEncoder)
  1192. {
  1193. bool rescale = config_get_bool(main->Config(), "AdvOut",
  1194. "FFRescale");
  1195. switch (encoderType) {
  1196. case FF_CODEC_VIDEO:
  1197. ui->advOutFFVBitrate->setEnabled(enabled);
  1198. ui->advOutFFUseRescale->setEnabled(enabled);
  1199. ui->advOutFFRescale->setEnabled(enabled && rescale);
  1200. ui->advOutFFVEncoder->setEnabled(enabled || enableEncoder);
  1201. ui->advOutFFVCfg->setEnabled(enabled);
  1202. break;
  1203. case FF_CODEC_AUDIO:
  1204. ui->advOutFFABitrate->setEnabled(enabled);
  1205. ui->advOutFFAEncoder->setEnabled(enabled || enableEncoder);
  1206. ui->advOutFFACfg->setEnabled(enabled);
  1207. ui->advOutFFTrack1->setEnabled(enabled);
  1208. ui->advOutFFTrack2->setEnabled(enabled);
  1209. ui->advOutFFTrack3->setEnabled(enabled);
  1210. ui->advOutFFTrack4->setEnabled(enabled);
  1211. default:
  1212. break;
  1213. }
  1214. }
  1215. static inline void LoadListValue(QComboBox *widget, const char *text,
  1216. const char *val)
  1217. {
  1218. widget->addItem(QT_UTF8(text), QT_UTF8(val));
  1219. }
  1220. void OBSBasicSettings::LoadListValues(QComboBox *widget, obs_property_t *prop,
  1221. int index)
  1222. {
  1223. size_t count = obs_property_list_item_count(prop);
  1224. obs_source_t *source = obs_get_output_source(index);
  1225. const char *deviceId = nullptr;
  1226. obs_data_t *settings = nullptr;
  1227. if (source) {
  1228. settings = obs_source_get_settings(source);
  1229. if (settings)
  1230. deviceId = obs_data_get_string(settings, "device_id");
  1231. }
  1232. widget->addItem(QTStr("Disabled"), "disabled");
  1233. for (size_t i = 0; i < count; i++) {
  1234. const char *name = obs_property_list_item_name(prop, i);
  1235. const char *val = obs_property_list_item_string(prop, i);
  1236. LoadListValue(widget, name, val);
  1237. }
  1238. if (deviceId) {
  1239. QVariant var(QT_UTF8(deviceId));
  1240. int idx = widget->findData(var);
  1241. if (idx != -1) {
  1242. widget->setCurrentIndex(idx);
  1243. } else {
  1244. widget->insertItem(0,
  1245. QTStr("Basic.Settings.Audio."
  1246. "UnknownAudioDevice"),
  1247. var);
  1248. widget->setCurrentIndex(0);
  1249. }
  1250. }
  1251. if (settings)
  1252. obs_data_release(settings);
  1253. if (source)
  1254. obs_source_release(source);
  1255. }
  1256. void OBSBasicSettings::LoadAudioDevices()
  1257. {
  1258. const char *input_id = App()->InputAudioSource();
  1259. const char *output_id = App()->OutputAudioSource();
  1260. obs_properties_t *input_props = obs_get_source_properties(input_id);
  1261. obs_properties_t *output_props = obs_get_source_properties(output_id);
  1262. if (input_props) {
  1263. obs_property_t *inputs = obs_properties_get(input_props,
  1264. "device_id");
  1265. LoadListValues(ui->auxAudioDevice1, inputs, 3);
  1266. LoadListValues(ui->auxAudioDevice2, inputs, 4);
  1267. LoadListValues(ui->auxAudioDevice3, inputs, 5);
  1268. obs_properties_destroy(input_props);
  1269. }
  1270. if (output_props) {
  1271. obs_property_t *outputs = obs_properties_get(output_props,
  1272. "device_id");
  1273. LoadListValues(ui->desktopAudioDevice1, outputs, 1);
  1274. LoadListValues(ui->desktopAudioDevice2, outputs, 2);
  1275. obs_properties_destroy(output_props);
  1276. }
  1277. }
  1278. #define NBSP "\xC2\xA0"
  1279. void OBSBasicSettings::LoadAudioSources()
  1280. {
  1281. auto layout = new QFormLayout();
  1282. layout->setVerticalSpacing(15);
  1283. layout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
  1284. ui->audioSourceScrollArea->takeWidget()->deleteLater();
  1285. audioSourceSignals.clear();
  1286. audioSources.clear();
  1287. auto widget = new QWidget();
  1288. widget->setLayout(layout);
  1289. ui->audioSourceScrollArea->setWidget(widget);
  1290. const char *enablePtm = Str("Basic.Settings.Audio.EnablePushToMute");
  1291. const char *ptmDelay = Str("Basic.Settings.Audio.PushToMuteDelay");
  1292. const char *enablePtt = Str("Basic.Settings.Audio.EnablePushToTalk");
  1293. const char *pttDelay = Str("Basic.Settings.Audio.PushToTalkDelay");
  1294. auto AddSource = [&](obs_source_t *source)
  1295. {
  1296. if (!(obs_source_get_output_flags(source) & OBS_SOURCE_AUDIO))
  1297. return true;
  1298. auto form = new QFormLayout();
  1299. form->setVerticalSpacing(0);
  1300. form->setHorizontalSpacing(5);
  1301. form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
  1302. auto ptmCB = new SilentUpdateCheckBox();
  1303. ptmCB->setText(enablePtm);
  1304. ptmCB->setChecked(obs_source_push_to_mute_enabled(source));
  1305. form->addRow(ptmCB);
  1306. auto ptmSB = new SilentUpdateSpinBox();
  1307. ptmSB->setSuffix(NBSP "ms");
  1308. ptmSB->setRange(0, INT_MAX);
  1309. ptmSB->setValue(obs_source_get_push_to_mute_delay(source));
  1310. form->addRow(ptmDelay, ptmSB);
  1311. auto pttCB = new SilentUpdateCheckBox();
  1312. pttCB->setText(enablePtt);
  1313. pttCB->setChecked(obs_source_push_to_talk_enabled(source));
  1314. form->addRow(pttCB);
  1315. auto pttSB = new SilentUpdateSpinBox();
  1316. pttSB->setSuffix(NBSP "ms");
  1317. pttSB->setRange(0, INT_MAX);
  1318. pttSB->setValue(obs_source_get_push_to_talk_delay(source));
  1319. form->addRow(pttDelay, pttSB);
  1320. HookWidget(ptmCB, CHECK_CHANGED, AUDIO_CHANGED);
  1321. HookWidget(ptmSB, SCROLL_CHANGED, AUDIO_CHANGED);
  1322. HookWidget(pttCB, CHECK_CHANGED, AUDIO_CHANGED);
  1323. HookWidget(pttSB, SCROLL_CHANGED, AUDIO_CHANGED);
  1324. audioSourceSignals.reserve(audioSourceSignals.size() + 4);
  1325. auto handler = obs_source_get_signal_handler(source);
  1326. audioSourceSignals.emplace_back(handler, "push_to_mute_changed",
  1327. [](void *data, calldata_t *param)
  1328. {
  1329. QMetaObject::invokeMethod(static_cast<QObject*>(data),
  1330. "setCheckedSilently",
  1331. Q_ARG(bool, calldata_bool(param, "enabled")));
  1332. }, ptmCB);
  1333. audioSourceSignals.emplace_back(handler, "push_to_mute_delay",
  1334. [](void *data, calldata_t *param)
  1335. {
  1336. QMetaObject::invokeMethod(static_cast<QObject*>(data),
  1337. "setValueSilently",
  1338. Q_ARG(int, calldata_int(param, "delay")));
  1339. }, ptmSB);
  1340. audioSourceSignals.emplace_back(handler, "push_to_talk_changed",
  1341. [](void *data, calldata_t *param)
  1342. {
  1343. QMetaObject::invokeMethod(static_cast<QObject*>(data),
  1344. "setCheckedSilently",
  1345. Q_ARG(bool, calldata_bool(param, "enabled")));
  1346. }, pttCB);
  1347. audioSourceSignals.emplace_back(handler, "push_to_talk_delay",
  1348. [](void *data, calldata_t *param)
  1349. {
  1350. QMetaObject::invokeMethod(static_cast<QObject*>(data),
  1351. "setValueSilently",
  1352. Q_ARG(int, calldata_int(param, "delay")));
  1353. }, pttSB);
  1354. audioSources.emplace_back(OBSGetWeakRef(source),
  1355. ptmCB, pttSB, pttCB, pttSB);
  1356. auto label = new OBSSourceLabel(source);
  1357. connect(label, &OBSSourceLabel::Removed,
  1358. [=]()
  1359. {
  1360. LoadAudioSources();
  1361. });
  1362. connect(label, &OBSSourceLabel::Destroyed,
  1363. [=]()
  1364. {
  1365. LoadAudioSources();
  1366. });
  1367. layout->addRow(label, form);
  1368. return true;
  1369. };
  1370. using AddSource_t = decltype(AddSource);
  1371. obs_enum_sources([](void *data, obs_source_t *source)
  1372. {
  1373. auto &AddSource = *static_cast<AddSource_t*>(data);
  1374. AddSource(source);
  1375. return true;
  1376. }, static_cast<void*>(&AddSource));
  1377. if (layout->rowCount() == 0)
  1378. ui->audioSourceScrollArea->hide();
  1379. else
  1380. ui->audioSourceScrollArea->show();
  1381. }
  1382. void OBSBasicSettings::LoadAudioSettings()
  1383. {
  1384. uint32_t sampleRate = config_get_uint(main->Config(), "Audio",
  1385. "SampleRate");
  1386. const char *speakers = config_get_string(main->Config(), "Audio",
  1387. "ChannelSetup");
  1388. loading = true;
  1389. const char *str;
  1390. if (sampleRate == 48000)
  1391. str = "48khz";
  1392. else
  1393. str = "44.1khz";
  1394. int sampleRateIdx = ui->sampleRate->findText(str);
  1395. if (sampleRateIdx != -1)
  1396. ui->sampleRate->setCurrentIndex(sampleRateIdx);
  1397. if (strcmp(speakers, "Mono") == 0)
  1398. ui->channelSetup->setCurrentIndex(0);
  1399. else
  1400. ui->channelSetup->setCurrentIndex(1);
  1401. LoadAudioDevices();
  1402. LoadAudioSources();
  1403. loading = false;
  1404. }
  1405. void OBSBasicSettings::LoadAdvancedSettings()
  1406. {
  1407. const char *videoColorFormat = config_get_string(main->Config(),
  1408. "Video", "ColorFormat");
  1409. const char *videoColorSpace = config_get_string(main->Config(),
  1410. "Video", "ColorSpace");
  1411. const char *videoColorRange = config_get_string(main->Config(),
  1412. "Video", "ColorRange");
  1413. bool enableDelay = config_get_bool(main->Config(), "Output",
  1414. "DelayEnable");
  1415. int delaySec = config_get_int(main->Config(), "Output",
  1416. "DelaySec");
  1417. bool preserveDelay = config_get_bool(main->Config(), "Output",
  1418. "DelayPreserve");
  1419. bool reconnect = config_get_bool(main->Config(), "Output",
  1420. "Reconnect");
  1421. int retryDelay = config_get_int(main->Config(), "Output",
  1422. "RetryDelay");
  1423. int maxRetries = config_get_int(main->Config(), "Output",
  1424. "MaxRetries");
  1425. const char *filename = config_get_string(main->Config(), "Output",
  1426. "FilenameFormatting");
  1427. bool overwriteIfExists = config_get_bool(main->Config(), "Output",
  1428. "OverwriteIfExists");
  1429. loading = true;
  1430. LoadRendererList();
  1431. ui->filenameFormatting->setText(filename);
  1432. ui->overwriteIfExists->setChecked(overwriteIfExists);
  1433. ui->reconnectEnable->setChecked(reconnect);
  1434. ui->reconnectRetryDelay->setValue(retryDelay);
  1435. ui->reconnectMaxRetries->setValue(maxRetries);
  1436. ui->streamDelaySec->setValue(delaySec);
  1437. ui->streamDelayPreserve->setChecked(preserveDelay);
  1438. ui->streamDelayEnable->setChecked(enableDelay);
  1439. SetComboByName(ui->colorFormat, videoColorFormat);
  1440. SetComboByName(ui->colorSpace, videoColorSpace);
  1441. SetComboByValue(ui->colorRange, videoColorRange);
  1442. if (video_output_active(obs_get_video())) {
  1443. ui->advancedVideoContainer->setEnabled(false);
  1444. }
  1445. #ifdef __APPLE__
  1446. bool disableOSXVSync = config_get_bool(App()->GlobalConfig(),
  1447. "Video", "DisableOSXVSync");
  1448. bool resetOSXVSync = config_get_bool(App()->GlobalConfig(),
  1449. "Video", "ResetOSXVSyncOnExit");
  1450. ui->disableOSXVSync->setChecked(disableOSXVSync);
  1451. ui->resetOSXVSync->setChecked(resetOSXVSync);
  1452. ui->resetOSXVSync->setEnabled(disableOSXVSync);
  1453. #endif
  1454. loading = false;
  1455. }
  1456. template <typename Func>
  1457. static inline void LayoutHotkey(obs_hotkey_id id, obs_hotkey_t *key, Func &&fun,
  1458. const map<obs_hotkey_id, vector<obs_key_combination_t>> &keys)
  1459. {
  1460. auto *label = new OBSHotkeyLabel;
  1461. label->setText(obs_hotkey_get_description(key));
  1462. OBSHotkeyWidget *hw = nullptr;
  1463. auto combos = keys.find(id);
  1464. if (combos == std::end(keys))
  1465. hw = new OBSHotkeyWidget(id, obs_hotkey_get_name(key));
  1466. else
  1467. hw = new OBSHotkeyWidget(id, obs_hotkey_get_name(key),
  1468. combos->second);
  1469. hw->label = label;
  1470. label->widget = hw;
  1471. fun(key, label, hw);
  1472. }
  1473. template <typename Func, typename T>
  1474. static QLabel *makeLabel(T &t, Func &&getName)
  1475. {
  1476. return new QLabel(getName(t));
  1477. }
  1478. template <typename Func>
  1479. static QLabel *makeLabel(const OBSSource &source, Func &&)
  1480. {
  1481. return new OBSSourceLabel(source);
  1482. }
  1483. template <typename Func, typename T>
  1484. static inline void AddHotkeys(QFormLayout &layout,
  1485. Func &&getName, std::vector<
  1486. std::tuple<T, QPointer<QLabel>, QPointer<QWidget>>
  1487. > &hotkeys)
  1488. {
  1489. if (hotkeys.empty())
  1490. return;
  1491. auto line = new QFrame();
  1492. line->setFrameShape(QFrame::HLine);
  1493. line->setFrameShadow(QFrame::Sunken);
  1494. layout.setItem(layout.rowCount(), QFormLayout::SpanningRole,
  1495. new QSpacerItem(0, 10));
  1496. layout.addRow(line);
  1497. using tuple_type =
  1498. std::tuple<T, QPointer<QLabel>, QPointer<QWidget>>;
  1499. stable_sort(begin(hotkeys), end(hotkeys),
  1500. [&](const tuple_type &a, const tuple_type &b)
  1501. {
  1502. const auto &o_a = get<0>(a);
  1503. const auto &o_b = get<0>(b);
  1504. return o_a != o_b &&
  1505. string(getName(o_a)) <
  1506. getName(o_b);
  1507. });
  1508. string prevName;
  1509. for (const auto &hotkey : hotkeys) {
  1510. const auto &o = get<0>(hotkey);
  1511. const char *name = getName(o);
  1512. if (prevName != name) {
  1513. prevName = name;
  1514. layout.setItem(layout.rowCount(),
  1515. QFormLayout::SpanningRole,
  1516. new QSpacerItem(0, 10));
  1517. layout.addRow(makeLabel(o, getName));
  1518. }
  1519. auto hlabel = get<1>(hotkey);
  1520. auto widget = get<2>(hotkey);
  1521. layout.addRow(hlabel, widget);
  1522. }
  1523. }
  1524. void OBSBasicSettings::LoadHotkeySettings(obs_hotkey_id ignoreKey)
  1525. {
  1526. hotkeys.clear();
  1527. ui->hotkeyPage->takeWidget()->deleteLater();
  1528. using keys_t = map<obs_hotkey_id, vector<obs_key_combination_t>>;
  1529. keys_t keys;
  1530. obs_enum_hotkey_bindings([](void *data,
  1531. size_t, obs_hotkey_binding_t *binding)
  1532. {
  1533. auto &keys = *static_cast<keys_t*>(data);
  1534. keys[obs_hotkey_binding_get_hotkey_id(binding)].emplace_back(
  1535. obs_hotkey_binding_get_key_combination(binding));
  1536. return true;
  1537. }, &keys);
  1538. auto layout = new QFormLayout();
  1539. layout->setVerticalSpacing(0);
  1540. layout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
  1541. layout->setLabelAlignment(
  1542. Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
  1543. auto widget = new QWidget();
  1544. widget->setLayout(layout);
  1545. ui->hotkeyPage->setWidget(widget);
  1546. using namespace std;
  1547. using encoders_elem_t =
  1548. tuple<OBSEncoder, QPointer<QLabel>, QPointer<QWidget>>;
  1549. using outputs_elem_t =
  1550. tuple<OBSOutput, QPointer<QLabel>, QPointer<QWidget>>;
  1551. using services_elem_t =
  1552. tuple<OBSService, QPointer<QLabel>, QPointer<QWidget>>;
  1553. using sources_elem_t =
  1554. tuple<OBSSource, QPointer<QLabel>, QPointer<QWidget>>;
  1555. vector<encoders_elem_t> encoders;
  1556. vector<outputs_elem_t> outputs;
  1557. vector<services_elem_t> services;
  1558. vector<sources_elem_t> scenes;
  1559. vector<sources_elem_t> sources;
  1560. vector<obs_hotkey_id> pairIds;
  1561. map<obs_hotkey_id, pair<obs_hotkey_id, OBSHotkeyLabel*>> pairLabels;
  1562. using std::move;
  1563. auto HandleEncoder = [&](void *registerer, OBSHotkeyLabel *label,
  1564. OBSHotkeyWidget *hw)
  1565. {
  1566. auto weak_encoder =
  1567. static_cast<obs_weak_encoder_t*>(registerer);
  1568. auto encoder = OBSGetStrongRef(weak_encoder);
  1569. if (!encoder)
  1570. return true;
  1571. encoders.emplace_back(move(encoder), label, hw);
  1572. return false;
  1573. };
  1574. auto HandleOutput = [&](void *registerer, OBSHotkeyLabel *label,
  1575. OBSHotkeyWidget *hw)
  1576. {
  1577. auto weak_output = static_cast<obs_weak_output_t*>(registerer);
  1578. auto output = OBSGetStrongRef(weak_output);
  1579. if (!output)
  1580. return true;
  1581. outputs.emplace_back(move(output), label, hw);
  1582. return false;
  1583. };
  1584. auto HandleService = [&](void *registerer, OBSHotkeyLabel *label,
  1585. OBSHotkeyWidget *hw)
  1586. {
  1587. auto weak_service =
  1588. static_cast<obs_weak_service_t*>(registerer);
  1589. auto service = OBSGetStrongRef(weak_service);
  1590. if (!service)
  1591. return true;
  1592. services.emplace_back(move(service), label, hw);
  1593. return false;
  1594. };
  1595. auto HandleSource = [&](void *registerer, OBSHotkeyLabel *label,
  1596. OBSHotkeyWidget *hw)
  1597. {
  1598. auto weak_source = static_cast<obs_weak_source_t*>(registerer);
  1599. auto source = OBSGetStrongRef(weak_source);
  1600. if (!source)
  1601. return true;
  1602. if (obs_scene_from_source(source))
  1603. scenes.emplace_back(source, label, hw);
  1604. else
  1605. sources.emplace_back(source, label, hw);
  1606. return false;
  1607. };
  1608. auto RegisterHotkey = [&](obs_hotkey_t *key, OBSHotkeyLabel *label,
  1609. OBSHotkeyWidget *hw)
  1610. {
  1611. auto registerer_type = obs_hotkey_get_registerer_type(key);
  1612. void *registerer = obs_hotkey_get_registerer(key);
  1613. obs_hotkey_id partner = obs_hotkey_get_pair_partner_id(key);
  1614. if (partner != OBS_INVALID_HOTKEY_ID) {
  1615. pairLabels.emplace(obs_hotkey_get_id(key),
  1616. make_pair(partner, label));
  1617. pairIds.push_back(obs_hotkey_get_id(key));
  1618. }
  1619. using std::move;
  1620. switch (registerer_type) {
  1621. case OBS_HOTKEY_REGISTERER_FRONTEND:
  1622. layout->addRow(label, hw);
  1623. break;
  1624. case OBS_HOTKEY_REGISTERER_ENCODER:
  1625. if (HandleEncoder(registerer, label, hw))
  1626. return;
  1627. break;
  1628. case OBS_HOTKEY_REGISTERER_OUTPUT:
  1629. if (HandleOutput(registerer, label, hw))
  1630. return;
  1631. break;
  1632. case OBS_HOTKEY_REGISTERER_SERVICE:
  1633. if (HandleService(registerer, label, hw))
  1634. return;
  1635. break;
  1636. case OBS_HOTKEY_REGISTERER_SOURCE:
  1637. if (HandleSource(registerer, label, hw))
  1638. return;
  1639. break;
  1640. }
  1641. hotkeys.emplace_back(registerer_type ==
  1642. OBS_HOTKEY_REGISTERER_FRONTEND, hw);
  1643. connect(hw, &OBSHotkeyWidget::KeyChanged,
  1644. this, &OBSBasicSettings::HotkeysChanged);
  1645. };
  1646. auto data = make_tuple(RegisterHotkey, std::move(keys), ignoreKey);
  1647. using data_t = decltype(data);
  1648. obs_enum_hotkeys([](void *data, obs_hotkey_id id, obs_hotkey_t *key)
  1649. {
  1650. data_t &d = *static_cast<data_t*>(data);
  1651. if (id != get<2>(d))
  1652. LayoutHotkey(id, key, get<0>(d), get<1>(d));
  1653. return true;
  1654. }, &data);
  1655. for (auto keyId : pairIds) {
  1656. auto data1 = pairLabels.find(keyId);
  1657. if (data1 == end(pairLabels))
  1658. continue;
  1659. auto &label1 = data1->second.second;
  1660. if (label1->pairPartner)
  1661. continue;
  1662. auto data2 = pairLabels.find(data1->second.first);
  1663. if (data2 == end(pairLabels))
  1664. continue;
  1665. auto &label2 = data2->second.second;
  1666. if (label2->pairPartner)
  1667. continue;
  1668. QString tt = QTStr("Basic.Settings.Hotkeys.Pair");
  1669. auto name1 = label1->text();
  1670. auto name2 = label2->text();
  1671. auto Update = [&](OBSHotkeyLabel *label, const QString &name,
  1672. OBSHotkeyLabel *other, const QString &otherName)
  1673. {
  1674. label->setToolTip(tt.arg(otherName));
  1675. label->setText(name + " *");
  1676. label->pairPartner = other;
  1677. };
  1678. Update(label1, name1, label2, name2);
  1679. Update(label2, name2, label1, name1);
  1680. }
  1681. AddHotkeys(*layout, obs_output_get_name, outputs);
  1682. AddHotkeys(*layout, obs_source_get_name, scenes);
  1683. AddHotkeys(*layout, obs_source_get_name, sources);
  1684. AddHotkeys(*layout, obs_encoder_get_name, encoders);
  1685. AddHotkeys(*layout, obs_service_get_name, services);
  1686. }
  1687. void OBSBasicSettings::LoadSettings(bool changedOnly)
  1688. {
  1689. if (!changedOnly || generalChanged)
  1690. LoadGeneralSettings();
  1691. if (!changedOnly || stream1Changed)
  1692. LoadStream1Settings();
  1693. if (!changedOnly || outputsChanged)
  1694. LoadOutputSettings();
  1695. if (!changedOnly || audioChanged)
  1696. LoadAudioSettings();
  1697. if (!changedOnly || videoChanged)
  1698. LoadVideoSettings();
  1699. if (!changedOnly || hotkeysChanged)
  1700. LoadHotkeySettings();
  1701. if (!changedOnly || advancedChanged)
  1702. LoadAdvancedSettings();
  1703. }
  1704. void OBSBasicSettings::SaveGeneralSettings()
  1705. {
  1706. int languageIndex = ui->language->currentIndex();
  1707. QVariant langData = ui->language->itemData(languageIndex);
  1708. string language = langData.toString().toStdString();
  1709. if (WidgetChanged(ui->language))
  1710. config_set_string(GetGlobalConfig(), "General", "Language",
  1711. language.c_str());
  1712. int themeIndex = ui->theme->currentIndex();
  1713. QString themeData = ui->theme->itemText(themeIndex);
  1714. string theme = themeData.toStdString();
  1715. if (WidgetChanged(ui->theme)) {
  1716. config_set_string(GetGlobalConfig(), "General", "Theme",
  1717. theme.c_str());
  1718. App()->SetTheme(theme);
  1719. }
  1720. if (WidgetChanged(ui->snappingEnabled))
  1721. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1722. "SnappingEnabled",
  1723. ui->snappingEnabled->isChecked());
  1724. if (WidgetChanged(ui->screenSnapping))
  1725. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1726. "ScreenSnapping",
  1727. ui->screenSnapping->isChecked());
  1728. if (WidgetChanged(ui->centerSnapping))
  1729. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1730. "CenterSnapping",
  1731. ui->centerSnapping->isChecked());
  1732. if (WidgetChanged(ui->sourceSnapping))
  1733. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1734. "SourceSnapping",
  1735. ui->sourceSnapping->isChecked());
  1736. if (WidgetChanged(ui->snapDistance))
  1737. config_set_double(GetGlobalConfig(), "BasicWindow",
  1738. "SnapDistance",
  1739. ui->snapDistance->value());
  1740. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1741. "WarnBeforeStartingStream",
  1742. ui->warnBeforeStreamStart->isChecked());
  1743. config_set_bool(GetGlobalConfig(), "BasicWindow",
  1744. "WarnBeforeStoppingStream",
  1745. ui->warnBeforeStreamStop->isChecked());
  1746. }
  1747. void OBSBasicSettings::SaveStream1Settings()
  1748. {
  1749. QString streamType = GetComboData(ui->streamType);
  1750. obs_service_t *oldService = main->GetService();
  1751. obs_data_t *hotkeyData = obs_hotkeys_save_service(oldService);
  1752. obs_service_t *newService = obs_service_create(QT_TO_UTF8(streamType),
  1753. "default_service", streamProperties->GetSettings(),
  1754. hotkeyData);
  1755. obs_data_release(hotkeyData);
  1756. if (!newService)
  1757. return;
  1758. main->SetService(newService);
  1759. main->SaveService();
  1760. obs_service_release(newService);
  1761. }
  1762. void OBSBasicSettings::SaveVideoSettings()
  1763. {
  1764. QString baseResolution = ui->baseResolution->currentText();
  1765. QString outputResolution = ui->outputResolution->currentText();
  1766. int fpsType = ui->fpsType->currentIndex();
  1767. uint32_t cx = 0, cy = 0;
  1768. /* ------------------- */
  1769. if (WidgetChanged(ui->baseResolution) &&
  1770. ConvertResText(QT_TO_UTF8(baseResolution), cx, cy)) {
  1771. config_set_uint(main->Config(), "Video", "BaseCX", cx);
  1772. config_set_uint(main->Config(), "Video", "BaseCY", cy);
  1773. }
  1774. if (WidgetChanged(ui->outputResolution) &&
  1775. ConvertResText(QT_TO_UTF8(outputResolution), cx, cy)) {
  1776. config_set_uint(main->Config(), "Video", "OutputCX", cx);
  1777. config_set_uint(main->Config(), "Video", "OutputCY", cy);
  1778. }
  1779. if (WidgetChanged(ui->fpsType))
  1780. config_set_uint(main->Config(), "Video", "FPSType", fpsType);
  1781. SaveCombo(ui->fpsCommon, "Video", "FPSCommon");
  1782. SaveSpinBox(ui->fpsInteger, "Video", "FPSInt");
  1783. SaveSpinBox(ui->fpsNumerator, "Video", "FPSNum");
  1784. SaveSpinBox(ui->fpsDenominator, "Video", "FPSDen");
  1785. SaveComboData(ui->downscaleFilter, "Video", "ScaleType");
  1786. #ifdef _WIN32
  1787. if (toggleAero) {
  1788. SaveCheckBox(toggleAero, "Video", "DisableAero");
  1789. aeroWasDisabled = toggleAero->isChecked();
  1790. }
  1791. #endif
  1792. }
  1793. void OBSBasicSettings::SaveAdvancedSettings()
  1794. {
  1795. #ifdef _WIN32
  1796. if (WidgetChanged(ui->renderer))
  1797. config_set_string(App()->GlobalConfig(), "Video", "Renderer",
  1798. QT_TO_UTF8(ui->renderer->currentText()));
  1799. #endif
  1800. #ifdef __APPLE__
  1801. if (WidgetChanged(ui->disableOSXVSync)) {
  1802. bool disable = ui->disableOSXVSync->isChecked();
  1803. config_set_bool(App()->GlobalConfig(),
  1804. "Video", "DisableOSXVSync", disable);
  1805. EnableOSXVSync(!disable);
  1806. }
  1807. if (WidgetChanged(ui->resetOSXVSync))
  1808. config_set_bool(App()->GlobalConfig(),
  1809. "Video", "ResetOSXVSyncOnExit",
  1810. ui->resetOSXVSync->isChecked());
  1811. #endif
  1812. SaveCombo(ui->colorFormat, "Video", "ColorFormat");
  1813. SaveCombo(ui->colorSpace, "Video", "ColorSpace");
  1814. SaveComboData(ui->colorRange, "Video", "ColorRange");
  1815. SaveEdit(ui->filenameFormatting, "Output", "FilenameFormatting");
  1816. SaveCheckBox(ui->overwriteIfExists, "Output", "OverwriteIfExists");
  1817. SaveCheckBox(ui->streamDelayEnable, "Output", "DelayEnable");
  1818. SaveSpinBox(ui->streamDelaySec, "Output", "DelaySec");
  1819. SaveCheckBox(ui->streamDelayPreserve, "Output", "DelayPreserve");
  1820. SaveCheckBox(ui->reconnectEnable, "Output", "Reconnect");
  1821. SaveSpinBox(ui->reconnectRetryDelay, "Output", "RetryDelay");
  1822. SaveSpinBox(ui->reconnectMaxRetries, "Output", "MaxRetries");
  1823. }
  1824. static inline const char *OutputModeFromIdx(int idx)
  1825. {
  1826. if (idx == 1)
  1827. return "Advanced";
  1828. else
  1829. return "Simple";
  1830. }
  1831. static inline const char *RecTypeFromIdx(int idx)
  1832. {
  1833. if (idx == 1)
  1834. return "FFmpeg";
  1835. else
  1836. return "Standard";
  1837. }
  1838. static void WriteJsonData(OBSPropertiesView *view, const char *path)
  1839. {
  1840. char full_path[512];
  1841. if (!view || !WidgetChanged(view))
  1842. return;
  1843. int ret = GetProfilePath(full_path, sizeof(full_path), path);
  1844. if (ret > 0) {
  1845. obs_data_t *settings = view->GetSettings();
  1846. if (settings) {
  1847. obs_data_save_json_safe(settings, full_path,
  1848. "tmp", "bak");
  1849. }
  1850. }
  1851. }
  1852. static void SaveTrackIndex(config_t *config, const char *section,
  1853. const char *name,
  1854. QAbstractButton *check1,
  1855. QAbstractButton *check2,
  1856. QAbstractButton *check3,
  1857. QAbstractButton *check4)
  1858. {
  1859. if (check1->isChecked()) config_set_int(config, section, name, 1);
  1860. else if (check2->isChecked()) config_set_int(config, section, name, 2);
  1861. else if (check3->isChecked()) config_set_int(config, section, name, 3);
  1862. else if (check4->isChecked()) config_set_int(config, section, name, 4);
  1863. }
  1864. void OBSBasicSettings::SaveFormat(QComboBox *combo)
  1865. {
  1866. QVariant v = combo->currentData();
  1867. if (!v.isNull()) {
  1868. FormatDesc desc = v.value<FormatDesc>();
  1869. config_set_string(main->Config(), "AdvOut", "FFFormat",
  1870. desc.name);
  1871. config_set_string(main->Config(), "AdvOut", "FFFormatMimeType",
  1872. desc.mimeType);
  1873. const char *ext = ff_format_desc_extensions(desc.desc);
  1874. string extStr = ext ? ext : "";
  1875. char *comma = strchr(&extStr[0], ',');
  1876. if (comma)
  1877. comma = 0;
  1878. config_set_string(main->Config(), "AdvOut", "FFExtension",
  1879. extStr.c_str());
  1880. } else {
  1881. config_set_string(main->Config(), "AdvOut", "FFFormat",
  1882. nullptr);
  1883. config_set_string(main->Config(), "AdvOut", "FFFormatMimeType",
  1884. nullptr);
  1885. config_remove_value(main->Config(), "AdvOut", "FFExtension");
  1886. }
  1887. }
  1888. void OBSBasicSettings::SaveEncoder(QComboBox *combo, const char *section,
  1889. const char *value)
  1890. {
  1891. QVariant v = combo->currentData();
  1892. CodecDesc cd;
  1893. if (!v.isNull())
  1894. cd = v.value<CodecDesc>();
  1895. config_set_int(main->Config(), section,
  1896. QT_TO_UTF8(QString("%1Id").arg(value)), cd.id);
  1897. if (cd.id != 0)
  1898. config_set_string(main->Config(), section, value, cd.name);
  1899. else
  1900. config_set_string(main->Config(), section, value, nullptr);
  1901. }
  1902. void OBSBasicSettings::SaveOutputSettings()
  1903. {
  1904. config_set_string(main->Config(), "Output", "Mode",
  1905. OutputModeFromIdx(ui->outputMode->currentIndex()));
  1906. SaveSpinBox(ui->simpleOutputVBitrate, "SimpleOutput", "VBitrate");
  1907. SaveCombo(ui->simpleOutputABitrate, "SimpleOutput", "ABitrate");
  1908. SaveEdit(ui->simpleOutputPath, "SimpleOutput", "FilePath");
  1909. SaveCheckBox(ui->simpleNoSpace, "SimpleOutput", "FileNameWithoutSpace");
  1910. SaveCombo(ui->simpleOutRecFormat, "SimpleOutput", "RecFormat");
  1911. SaveCheckBox(ui->simpleOutAdvanced, "SimpleOutput", "UseAdvanced");
  1912. SaveCombo(ui->simpleOutPreset, "SimpleOutput", "Preset");
  1913. SaveEdit(ui->simpleOutCustom, "SimpleOutput", "x264Settings");
  1914. SaveComboData(ui->simpleOutRecQuality, "SimpleOutput", "RecQuality");
  1915. SaveComboData(ui->simpleOutRecEncoder, "SimpleOutput", "RecEncoder");
  1916. SaveEdit(ui->simpleOutMuxCustom, "SimpleOutput", "MuxerCustom");
  1917. SaveCheckBox(ui->advOutApplyService, "AdvOut", "ApplyServiceSettings");
  1918. SaveComboData(ui->advOutEncoder, "AdvOut", "Encoder");
  1919. SaveCheckBox(ui->advOutUseRescale, "AdvOut", "Rescale");
  1920. SaveCombo(ui->advOutRescale, "AdvOut", "RescaleRes");
  1921. SaveTrackIndex(main->Config(), "AdvOut", "TrackIndex",
  1922. ui->advOutTrack1, ui->advOutTrack2,
  1923. ui->advOutTrack3, ui->advOutTrack4);
  1924. config_set_string(main->Config(), "AdvOut", "RecType",
  1925. RecTypeFromIdx(ui->advOutRecType->currentIndex()));
  1926. SaveEdit(ui->advOutRecPath, "AdvOut", "RecFilePath");
  1927. SaveCheckBox(ui->advOutNoSpace, "AdvOut", "RecFileNameWithoutSpace");
  1928. SaveCombo(ui->advOutRecFormat, "AdvOut", "RecFormat");
  1929. SaveComboData(ui->advOutRecEncoder, "AdvOut", "RecEncoder");
  1930. SaveCheckBox(ui->advOutRecUseRescale, "AdvOut", "RecRescale");
  1931. SaveCombo(ui->advOutRecRescale, "AdvOut", "RecRescaleRes");
  1932. SaveEdit(ui->advOutMuxCustom, "AdvOut", "RecMuxerCustom");
  1933. config_set_int(main->Config(), "AdvOut", "RecTracks",
  1934. (ui->advOutRecTrack1->isChecked() ? (1<<0) : 0) |
  1935. (ui->advOutRecTrack2->isChecked() ? (1<<1) : 0) |
  1936. (ui->advOutRecTrack3->isChecked() ? (1<<2) : 0) |
  1937. (ui->advOutRecTrack4->isChecked() ? (1<<3) : 0));
  1938. config_set_bool(main->Config(), "AdvOut", "FFOutputToFile",
  1939. ui->advOutFFType->currentIndex() == 0 ? true : false);
  1940. SaveEdit(ui->advOutFFRecPath, "AdvOut", "FFFilePath");
  1941. SaveCheckBox(ui->advOutFFNoSpace, "AdvOut", "FFFileNameWithoutSpace");
  1942. SaveEdit(ui->advOutFFURL, "AdvOut", "FFURL");
  1943. SaveFormat(ui->advOutFFFormat);
  1944. SaveEdit(ui->advOutFFMCfg, "AdvOut", "FFMCustom");
  1945. SaveSpinBox(ui->advOutFFVBitrate, "AdvOut", "FFVBitrate");
  1946. SaveCheckBox(ui->advOutFFUseRescale, "AdvOut", "FFRescale");
  1947. SaveCombo(ui->advOutFFRescale, "AdvOut", "FFRescaleRes");
  1948. SaveEncoder(ui->advOutFFVEncoder, "AdvOut", "FFVEncoder");
  1949. SaveEdit(ui->advOutFFVCfg, "AdvOut", "FFVCustom");
  1950. SaveSpinBox(ui->advOutFFABitrate, "AdvOut", "FFABitrate");
  1951. SaveEncoder(ui->advOutFFAEncoder, "AdvOut", "FFAEncoder");
  1952. SaveEdit(ui->advOutFFACfg, "AdvOut", "FFACustom");
  1953. SaveTrackIndex(main->Config(), "AdvOut", "FFAudioTrack",
  1954. ui->advOutFFTrack1, ui->advOutFFTrack2,
  1955. ui->advOutFFTrack3, ui->advOutFFTrack4);
  1956. SaveCombo(ui->advOutTrack1Bitrate, "AdvOut", "Track1Bitrate");
  1957. SaveCombo(ui->advOutTrack2Bitrate, "AdvOut", "Track2Bitrate");
  1958. SaveCombo(ui->advOutTrack3Bitrate, "AdvOut", "Track3Bitrate");
  1959. SaveCombo(ui->advOutTrack4Bitrate, "AdvOut", "Track4Bitrate");
  1960. SaveEdit(ui->advOutTrack1Name, "AdvOut", "Track1Name");
  1961. SaveEdit(ui->advOutTrack2Name, "AdvOut", "Track2Name");
  1962. SaveEdit(ui->advOutTrack3Name, "AdvOut", "Track3Name");
  1963. SaveEdit(ui->advOutTrack4Name, "AdvOut", "Track4Name");
  1964. WriteJsonData(streamEncoderProps, "streamEncoder.json");
  1965. WriteJsonData(recordEncoderProps, "recordEncoder.json");
  1966. main->ResetOutputs();
  1967. }
  1968. void OBSBasicSettings::SaveAudioSettings()
  1969. {
  1970. QString sampleRateStr = ui->sampleRate->currentText();
  1971. int channelSetupIdx = ui->channelSetup->currentIndex();
  1972. const char *channelSetup = (channelSetupIdx == 0) ? "Mono" : "Stereo";
  1973. int sampleRate = 44100;
  1974. if (sampleRateStr == "48khz")
  1975. sampleRate = 48000;
  1976. if (WidgetChanged(ui->sampleRate))
  1977. config_set_uint(main->Config(), "Audio", "SampleRate",
  1978. sampleRate);
  1979. if (WidgetChanged(ui->channelSetup))
  1980. config_set_string(main->Config(), "Audio", "ChannelSetup",
  1981. channelSetup);
  1982. for (auto &audioSource : audioSources) {
  1983. auto source = OBSGetStrongRef(get<0>(audioSource));
  1984. if (!source)
  1985. continue;
  1986. auto &ptmCB = get<1>(audioSource);
  1987. auto &ptmSB = get<2>(audioSource);
  1988. auto &pttCB = get<3>(audioSource);
  1989. auto &pttSB = get<4>(audioSource);
  1990. obs_source_enable_push_to_mute(source, ptmCB->isChecked());
  1991. obs_source_set_push_to_mute_delay(source, ptmSB->value());
  1992. obs_source_enable_push_to_talk(source, pttCB->isChecked());
  1993. obs_source_set_push_to_talk_delay(source, pttSB->value());
  1994. }
  1995. auto UpdateAudioDevice = [this](bool input, QComboBox *combo,
  1996. const char *name, int index)
  1997. {
  1998. main->ResetAudioDevice(
  1999. input ? App()->InputAudioSource()
  2000. : App()->OutputAudioSource(),
  2001. QT_TO_UTF8(GetComboData(combo)),
  2002. Str(name), index);
  2003. };
  2004. UpdateAudioDevice(false, ui->desktopAudioDevice1,
  2005. "Basic.DesktopDevice1", 1);
  2006. UpdateAudioDevice(false, ui->desktopAudioDevice2,
  2007. "Basic.DesktopDevice2", 2);
  2008. UpdateAudioDevice(true, ui->auxAudioDevice1,
  2009. "Basic.AuxDevice1", 3);
  2010. UpdateAudioDevice(true, ui->auxAudioDevice2,
  2011. "Basic.AuxDevice2", 4);
  2012. UpdateAudioDevice(true, ui->auxAudioDevice3,
  2013. "Basic.AuxDevice3", 5);
  2014. main->SaveProject();
  2015. }
  2016. void OBSBasicSettings::SaveHotkeySettings()
  2017. {
  2018. const auto &config = main->Config();
  2019. using namespace std;
  2020. std::vector<obs_key_combination> combinations;
  2021. for (auto &hotkey : hotkeys) {
  2022. auto &hw = *hotkey.second;
  2023. if (!hw.Changed())
  2024. continue;
  2025. hw.Save(combinations);
  2026. if (!hotkey.first)
  2027. continue;
  2028. obs_data_array_t *array = obs_hotkey_save(hw.id);
  2029. obs_data_t *data = obs_data_create();
  2030. obs_data_set_array(data, "bindings", array);
  2031. const char *json = obs_data_get_json(data);
  2032. config_set_string(config, "Hotkeys", hw.name.c_str(), json);
  2033. obs_data_release(data);
  2034. obs_data_array_release(array);
  2035. }
  2036. }
  2037. #define MINOR_SEPARATOR \
  2038. "------------------------------------------------"
  2039. static void AddChangedVal(std::string &changed, const char *str)
  2040. {
  2041. if (changed.size())
  2042. changed += ", ";
  2043. changed += str;
  2044. }
  2045. void OBSBasicSettings::SaveSettings()
  2046. {
  2047. if (generalChanged)
  2048. SaveGeneralSettings();
  2049. if (stream1Changed)
  2050. SaveStream1Settings();
  2051. if (outputsChanged)
  2052. SaveOutputSettings();
  2053. if (audioChanged)
  2054. SaveAudioSettings();
  2055. if (videoChanged)
  2056. SaveVideoSettings();
  2057. if (hotkeysChanged)
  2058. SaveHotkeySettings();
  2059. if (advancedChanged)
  2060. SaveAdvancedSettings();
  2061. if (videoChanged || advancedChanged)
  2062. main->ResetVideo();
  2063. config_save_safe(main->Config(), "tmp", nullptr);
  2064. config_save_safe(GetGlobalConfig(), "tmp", nullptr);
  2065. main->SaveProject();
  2066. if (Changed()) {
  2067. std::string changed;
  2068. if (generalChanged)
  2069. AddChangedVal(changed, "general");
  2070. if (stream1Changed)
  2071. AddChangedVal(changed, "stream 1");
  2072. if (outputsChanged)
  2073. AddChangedVal(changed, "outputs");
  2074. if (audioChanged)
  2075. AddChangedVal(changed, "audio");
  2076. if (videoChanged)
  2077. AddChangedVal(changed, "video");
  2078. if (hotkeysChanged)
  2079. AddChangedVal(changed, "hotkeys");
  2080. if (advancedChanged)
  2081. AddChangedVal(changed, "advanced");
  2082. blog(LOG_INFO, "Settings changed (%s)", changed.c_str());
  2083. blog(LOG_INFO, MINOR_SEPARATOR);
  2084. }
  2085. }
  2086. bool OBSBasicSettings::QueryChanges()
  2087. {
  2088. QMessageBox::StandardButton button;
  2089. button = QMessageBox::question(this,
  2090. QTStr("Basic.Settings.ConfirmTitle"),
  2091. QTStr("Basic.Settings.Confirm"),
  2092. QMessageBox::Yes | QMessageBox::No |
  2093. QMessageBox::Cancel);
  2094. if (button == QMessageBox::Cancel) {
  2095. return false;
  2096. } else if (button == QMessageBox::Yes) {
  2097. SaveSettings();
  2098. } else {
  2099. LoadSettings(true);
  2100. #ifdef _WIN32
  2101. if (toggleAero)
  2102. SetAeroEnabled(!aeroWasDisabled);
  2103. #endif
  2104. }
  2105. ClearChanged();
  2106. return true;
  2107. }
  2108. void OBSBasicSettings::closeEvent(QCloseEvent *event)
  2109. {
  2110. if (Changed() && !QueryChanges())
  2111. event->ignore();
  2112. }
  2113. void OBSBasicSettings::on_theme_activated(int idx)
  2114. {
  2115. string currT = ui->theme->itemText(idx).toStdString();
  2116. App()->SetTheme(currT);
  2117. }
  2118. void OBSBasicSettings::on_listWidget_itemSelectionChanged()
  2119. {
  2120. int row = ui->listWidget->currentRow();
  2121. if (loading || row == pageIndex)
  2122. return;
  2123. pageIndex = row;
  2124. }
  2125. void OBSBasicSettings::on_buttonBox_clicked(QAbstractButton *button)
  2126. {
  2127. QDialogButtonBox::ButtonRole val = ui->buttonBox->buttonRole(button);
  2128. if (val == QDialogButtonBox::ApplyRole ||
  2129. val == QDialogButtonBox::AcceptRole) {
  2130. SaveSettings();
  2131. ClearChanged();
  2132. }
  2133. if (val == QDialogButtonBox::AcceptRole ||
  2134. val == QDialogButtonBox::RejectRole) {
  2135. if (val == QDialogButtonBox::RejectRole) {
  2136. App()->SetTheme(savedTheme);
  2137. #ifdef _WIN32
  2138. if (toggleAero)
  2139. SetAeroEnabled(!aeroWasDisabled);
  2140. #endif
  2141. }
  2142. ClearChanged();
  2143. close();
  2144. }
  2145. }
  2146. void OBSBasicSettings::on_streamType_currentIndexChanged(int idx)
  2147. {
  2148. if (loading)
  2149. return;
  2150. QLayout *layout = ui->streamContainer->layout();
  2151. QString streamType = ui->streamType->itemData(idx).toString();
  2152. obs_data_t *settings = obs_service_defaults(QT_TO_UTF8(streamType));
  2153. delete streamProperties;
  2154. streamProperties = new OBSPropertiesView(settings,
  2155. QT_TO_UTF8(streamType),
  2156. (PropertiesReloadCallback)obs_get_service_properties,
  2157. 170);
  2158. streamProperties->setProperty("changed", QVariant(true));
  2159. layout->addWidget(streamProperties);
  2160. QObject::connect(streamProperties, SIGNAL(Changed()),
  2161. this, STREAM1_CHANGED);
  2162. obs_data_release(settings);
  2163. }
  2164. void OBSBasicSettings::on_simpleOutputBrowse_clicked()
  2165. {
  2166. QString dir = QFileDialog::getExistingDirectory(this,
  2167. QTStr("Basic.Settings.Output.SelectDirectory"),
  2168. ui->simpleOutputPath->text(),
  2169. QFileDialog::ShowDirsOnly |
  2170. QFileDialog::DontResolveSymlinks);
  2171. if (dir.isEmpty())
  2172. return;
  2173. ui->simpleOutputPath->setText(dir);
  2174. }
  2175. void OBSBasicSettings::on_advOutRecPathBrowse_clicked()
  2176. {
  2177. QString dir = QFileDialog::getExistingDirectory(this,
  2178. QTStr("Basic.Settings.Output.SelectDirectory"),
  2179. ui->advOutRecPath->text(),
  2180. QFileDialog::ShowDirsOnly |
  2181. QFileDialog::DontResolveSymlinks);
  2182. if (dir.isEmpty())
  2183. return;
  2184. ui->advOutRecPath->setText(dir);
  2185. }
  2186. void OBSBasicSettings::on_advOutFFPathBrowse_clicked()
  2187. {
  2188. QString dir = QFileDialog::getExistingDirectory(this,
  2189. QTStr("Basic.Settings.Output.SelectDirectory"),
  2190. ui->advOutRecPath->text(),
  2191. QFileDialog::ShowDirsOnly |
  2192. QFileDialog::DontResolveSymlinks);
  2193. if (dir.isEmpty())
  2194. return;
  2195. ui->advOutFFRecPath->setText(dir);
  2196. }
  2197. void OBSBasicSettings::on_advOutEncoder_currentIndexChanged(int idx)
  2198. {
  2199. QString encoder = GetComboData(ui->advOutEncoder);
  2200. delete streamEncoderProps;
  2201. streamEncoderProps = CreateEncoderPropertyView(QT_TO_UTF8(encoder),
  2202. "streamEncoder.json", true);
  2203. ui->advOutputStreamTab->layout()->addWidget(streamEncoderProps);
  2204. UNUSED_PARAMETER(idx);
  2205. }
  2206. void OBSBasicSettings::on_advOutRecEncoder_currentIndexChanged(int idx)
  2207. {
  2208. ui->advOutRecUseRescale->setEnabled(idx > 0);
  2209. ui->advOutRecRescaleContainer->setEnabled(idx > 0);
  2210. delete recordEncoderProps;
  2211. recordEncoderProps = nullptr;
  2212. if (idx > 0) {
  2213. QString encoder = GetComboData(ui->advOutRecEncoder);
  2214. recordEncoderProps = CreateEncoderPropertyView(
  2215. QT_TO_UTF8(encoder),
  2216. "recordEncoder.json", true);
  2217. ui->advOutRecStandard->layout()->addWidget(recordEncoderProps);
  2218. }
  2219. }
  2220. #define DEFAULT_CONTAINER_STR \
  2221. QTStr("Basic.Settings.Output.Adv.FFmpeg.FormatDescDef")
  2222. void OBSBasicSettings::on_advOutFFFormat_currentIndexChanged(int idx)
  2223. {
  2224. const QVariant itemDataVariant = ui->advOutFFFormat->itemData(idx);
  2225. if (!itemDataVariant.isNull()) {
  2226. FormatDesc desc = itemDataVariant.value<FormatDesc>();
  2227. SetAdvOutputFFmpegEnablement(FF_CODEC_AUDIO,
  2228. ff_format_desc_has_audio(desc.desc),
  2229. false);
  2230. SetAdvOutputFFmpegEnablement(FF_CODEC_VIDEO,
  2231. ff_format_desc_has_video(desc.desc),
  2232. false);
  2233. ReloadCodecs(desc.desc);
  2234. ui->advOutFFFormatDesc->setText(ff_format_desc_long_name(
  2235. desc.desc));
  2236. CodecDesc defaultAudioCodecDesc =
  2237. GetDefaultCodecDesc(desc.desc, FF_CODEC_AUDIO);
  2238. CodecDesc defaultVideoCodecDesc =
  2239. GetDefaultCodecDesc(desc.desc, FF_CODEC_VIDEO);
  2240. SelectEncoder(ui->advOutFFAEncoder, defaultAudioCodecDesc.name,
  2241. defaultAudioCodecDesc.id);
  2242. SelectEncoder(ui->advOutFFVEncoder, defaultVideoCodecDesc.name,
  2243. defaultVideoCodecDesc.id);
  2244. } else {
  2245. ReloadCodecs(nullptr);
  2246. ui->advOutFFFormatDesc->setText(DEFAULT_CONTAINER_STR);
  2247. }
  2248. }
  2249. void OBSBasicSettings::on_advOutFFAEncoder_currentIndexChanged(int idx)
  2250. {
  2251. const QVariant itemDataVariant = ui->advOutFFAEncoder->itemData(idx);
  2252. if (!itemDataVariant.isNull()) {
  2253. CodecDesc desc = itemDataVariant.value<CodecDesc>();
  2254. SetAdvOutputFFmpegEnablement(FF_CODEC_AUDIO,
  2255. desc.id != 0 || desc.name != nullptr, true);
  2256. }
  2257. }
  2258. void OBSBasicSettings::on_advOutFFVEncoder_currentIndexChanged(int idx)
  2259. {
  2260. const QVariant itemDataVariant = ui->advOutFFVEncoder->itemData(idx);
  2261. if (!itemDataVariant.isNull()) {
  2262. CodecDesc desc = itemDataVariant.value<CodecDesc>();
  2263. SetAdvOutputFFmpegEnablement(FF_CODEC_VIDEO,
  2264. desc.id != 0 || desc.name != nullptr, true);
  2265. }
  2266. }
  2267. void OBSBasicSettings::on_advOutFFType_currentIndexChanged(int idx)
  2268. {
  2269. ui->advOutFFNoSpace->setHidden(idx != 0);
  2270. }
  2271. void OBSBasicSettings::on_colorFormat_currentIndexChanged(const QString &text)
  2272. {
  2273. bool usingNV12 = text == "NV12";
  2274. if (usingNV12)
  2275. ui->advancedMsg2->setText(QString());
  2276. else
  2277. ui->advancedMsg2->setText(
  2278. QTStr("Basic.Settings.Advanced.FormatWarning"));
  2279. }
  2280. #define INVALID_RES_STR "Basic.Settings.Video.InvalidResolution"
  2281. static bool ValidResolutions(Ui::OBSBasicSettings *ui)
  2282. {
  2283. QString baseRes = ui->baseResolution->lineEdit()->text();
  2284. QString outputRes = ui->outputResolution->lineEdit()->text();
  2285. uint32_t cx, cy;
  2286. if (!ConvertResText(QT_TO_UTF8(baseRes), cx, cy) ||
  2287. !ConvertResText(QT_TO_UTF8(outputRes), cx, cy)) {
  2288. ui->videoMsg->setText(QTStr(INVALID_RES_STR));
  2289. return false;
  2290. }
  2291. ui->videoMsg->setText("");
  2292. return true;
  2293. }
  2294. void OBSBasicSettings::RecalcOutputResPixels(const char *resText)
  2295. {
  2296. uint32_t newCX;
  2297. uint32_t newCY;
  2298. ConvertResText(resText, newCX, newCY);
  2299. if (newCX && newCY) {
  2300. outputCX = newCX;
  2301. outputCY = newCY;
  2302. }
  2303. }
  2304. void OBSBasicSettings::on_filenameFormatting_textEdited(const QString &text)
  2305. {
  2306. #ifdef __APPLE__
  2307. size_t invalidLocation =
  2308. text.toStdString().find_first_of(":/\\");
  2309. #elif _WIN32
  2310. size_t invalidLocation =
  2311. text.toStdString().find_first_of("<>:\"/\\|?*");
  2312. #else
  2313. size_t invalidLocation = text.toStdString().find_first_of("/");
  2314. #endif
  2315. if (invalidLocation != string::npos)
  2316. ui->filenameFormatting->backspace();
  2317. }
  2318. void OBSBasicSettings::on_outputResolution_editTextChanged(const QString &text)
  2319. {
  2320. if (!loading)
  2321. RecalcOutputResPixels(QT_TO_UTF8(text));
  2322. }
  2323. void OBSBasicSettings::on_baseResolution_editTextChanged(const QString &text)
  2324. {
  2325. if (!loading && ValidResolutions(ui.get())) {
  2326. QString baseResolution = text;
  2327. uint32_t cx, cy;
  2328. ConvertResText(QT_TO_UTF8(baseResolution), cx, cy);
  2329. ResetDownscales(cx, cy);
  2330. }
  2331. }
  2332. void OBSBasicSettings::GeneralChanged()
  2333. {
  2334. if (!loading) {
  2335. generalChanged = true;
  2336. sender()->setProperty("changed", QVariant(true));
  2337. EnableApplyButton(true);
  2338. }
  2339. }
  2340. void OBSBasicSettings::Stream1Changed()
  2341. {
  2342. if (!loading) {
  2343. stream1Changed = true;
  2344. sender()->setProperty("changed", QVariant(true));
  2345. EnableApplyButton(true);
  2346. }
  2347. }
  2348. void OBSBasicSettings::OutputsChanged()
  2349. {
  2350. if (!loading) {
  2351. outputsChanged = true;
  2352. sender()->setProperty("changed", QVariant(true));
  2353. EnableApplyButton(true);
  2354. }
  2355. }
  2356. void OBSBasicSettings::AudioChanged()
  2357. {
  2358. if (!loading) {
  2359. audioChanged = true;
  2360. sender()->setProperty("changed", QVariant(true));
  2361. EnableApplyButton(true);
  2362. }
  2363. }
  2364. void OBSBasicSettings::AudioChangedRestart()
  2365. {
  2366. if (!loading) {
  2367. audioChanged = true;
  2368. ui->audioMsg->setText(QTStr("Basic.Settings.ProgramRestart"));
  2369. sender()->setProperty("changed", QVariant(true));
  2370. EnableApplyButton(true);
  2371. }
  2372. }
  2373. void OBSBasicSettings::ReloadAudioSources()
  2374. {
  2375. LoadAudioSources();
  2376. }
  2377. void OBSBasicSettings::VideoChangedRestart()
  2378. {
  2379. if (!loading) {
  2380. videoChanged = true;
  2381. ui->videoMsg->setText(QTStr("Basic.Settings.ProgramRestart"));
  2382. sender()->setProperty("changed", QVariant(true));
  2383. EnableApplyButton(true);
  2384. }
  2385. }
  2386. void OBSBasicSettings::AdvancedChangedRestart()
  2387. {
  2388. if (!loading) {
  2389. advancedChanged = true;
  2390. ui->advancedMsg->setText(
  2391. QTStr("Basic.Settings.ProgramRestart"));
  2392. sender()->setProperty("changed", QVariant(true));
  2393. EnableApplyButton(true);
  2394. }
  2395. }
  2396. void OBSBasicSettings::VideoChangedResolution()
  2397. {
  2398. if (!loading && ValidResolutions(ui.get())) {
  2399. videoChanged = true;
  2400. sender()->setProperty("changed", QVariant(true));
  2401. EnableApplyButton(true);
  2402. }
  2403. }
  2404. void OBSBasicSettings::VideoChanged()
  2405. {
  2406. if (!loading) {
  2407. videoChanged = true;
  2408. sender()->setProperty("changed", QVariant(true));
  2409. EnableApplyButton(true);
  2410. }
  2411. }
  2412. void OBSBasicSettings::HotkeysChanged()
  2413. {
  2414. using namespace std;
  2415. if (loading)
  2416. return;
  2417. hotkeysChanged = any_of(begin(hotkeys), end(hotkeys),
  2418. [](const pair<bool, QPointer<OBSHotkeyWidget>> &hotkey)
  2419. {
  2420. const auto &hw = *hotkey.second;
  2421. return hw.Changed();
  2422. });
  2423. if (hotkeysChanged)
  2424. EnableApplyButton(true);
  2425. }
  2426. void OBSBasicSettings::ReloadHotkeys(obs_hotkey_id ignoreKey)
  2427. {
  2428. LoadHotkeySettings(ignoreKey);
  2429. }
  2430. void OBSBasicSettings::AdvancedChanged()
  2431. {
  2432. if (!loading) {
  2433. advancedChanged = true;
  2434. sender()->setProperty("changed", QVariant(true));
  2435. EnableApplyButton(true);
  2436. }
  2437. }
  2438. void OBSBasicSettings::AdvOutRecCheckWarnings()
  2439. {
  2440. auto Checked = [](QCheckBox *box)
  2441. {
  2442. return box->isChecked() ? 1 : 0;
  2443. };
  2444. QString msg;
  2445. uint32_t tracks =
  2446. Checked(ui->advOutRecTrack1) +
  2447. Checked(ui->advOutRecTrack2) +
  2448. Checked(ui->advOutRecTrack3) +
  2449. Checked(ui->advOutRecTrack4);
  2450. const char *objectName = nullptr;
  2451. if (tracks == 0) {
  2452. msg = QTStr("OutputWarnings.NoTracksSelected");
  2453. objectName = "errorLabel";
  2454. } else if (tracks > 1) {
  2455. msg = QTStr("OutputWarnings.MultiTrackRecording");
  2456. objectName = "warningLabel";
  2457. }
  2458. delete advOutRecWarning;
  2459. if (!msg.isEmpty()) {
  2460. advOutRecWarning = new QLabel(msg, this);
  2461. advOutRecWarning->setObjectName(objectName);
  2462. QFormLayout *formLayout = reinterpret_cast<QFormLayout*>(
  2463. ui->advOutRecTopContainer->layout());
  2464. formLayout->addRow(nullptr, advOutRecWarning);
  2465. }
  2466. }
  2467. static inline QString MakeMemorySizeString(int bitrate, int seconds)
  2468. {
  2469. QString str = QTStr("Basic.Settings.Advanced.StreamDelay.MemoryUsage");
  2470. int megabytes = bitrate * seconds / 1000 / 8;
  2471. return str.arg(QString::number(megabytes));
  2472. }
  2473. void OBSBasicSettings::UpdateSimpleOutStreamDelayEstimate()
  2474. {
  2475. int seconds = ui->streamDelaySec->value();
  2476. int vBitrate = ui->simpleOutputVBitrate->value();
  2477. int aBitrate = ui->simpleOutputABitrate->currentText().toInt();
  2478. QString msg = MakeMemorySizeString(vBitrate + aBitrate, seconds);
  2479. ui->streamDelayInfo->setText(msg);
  2480. }
  2481. void OBSBasicSettings::UpdateAdvOutStreamDelayEstimate()
  2482. {
  2483. if (!streamEncoderProps)
  2484. return;
  2485. OBSData settings = streamEncoderProps->GetSettings();
  2486. int trackIndex = config_get_int(main->Config(), "AdvOut", "TrackIndex");
  2487. QString aBitrateText;
  2488. switch (trackIndex) {
  2489. case 1: aBitrateText = ui->advOutTrack1Bitrate->currentText(); break;
  2490. case 2: aBitrateText = ui->advOutTrack2Bitrate->currentText(); break;
  2491. case 3: aBitrateText = ui->advOutTrack3Bitrate->currentText(); break;
  2492. case 4: aBitrateText = ui->advOutTrack4Bitrate->currentText(); break;
  2493. }
  2494. int seconds = ui->streamDelaySec->value();
  2495. int vBitrate = (int)obs_data_get_int(settings, "bitrate");
  2496. int aBitrate = aBitrateText.toInt();
  2497. QString msg = MakeMemorySizeString(vBitrate + aBitrate, seconds);
  2498. ui->streamDelayInfo->setText(msg);
  2499. }
  2500. void OBSBasicSettings::UpdateStreamDelayEstimate()
  2501. {
  2502. if (ui->outputMode->currentIndex() == 0)
  2503. UpdateSimpleOutStreamDelayEstimate();
  2504. else
  2505. UpdateAdvOutStreamDelayEstimate();
  2506. }
  2507. void OBSBasicSettings::FillSimpleRecordingValues()
  2508. {
  2509. #define ADD_QUALITY(str) \
  2510. ui->simpleOutRecQuality->addItem( \
  2511. QTStr("Basic.Settings.Output.Simple.RecordingQuality." \
  2512. str), \
  2513. QString(str));
  2514. #define ENCODER_STR(str) QTStr("Basic.Settings.Output.Simple.Encoder." str)
  2515. ADD_QUALITY("Stream");
  2516. ADD_QUALITY("Small");
  2517. ADD_QUALITY("HQ");
  2518. ADD_QUALITY("Lossless");
  2519. ui->simpleOutRecEncoder->addItem(
  2520. ENCODER_STR("Software"),
  2521. QString(SIMPLE_ENCODER_X264));
  2522. ui->simpleOutRecEncoder->addItem(
  2523. ENCODER_STR("SoftwareLowCPU"),
  2524. QString(SIMPLE_ENCODER_X264_LOWCPU));
  2525. #undef ADD_QUALITY
  2526. #undef ENCODER_STR
  2527. }
  2528. void OBSBasicSettings::SimpleRecordingQualityChanged()
  2529. {
  2530. QString qual = ui->simpleOutRecQuality->currentData().toString();
  2531. bool streamQuality = qual == "Stream";
  2532. bool losslessQuality = !streamQuality && qual == "Lossless";
  2533. bool showEncoder = !streamQuality && !losslessQuality;
  2534. ui->simpleOutRecEncoder->setVisible(showEncoder);
  2535. ui->simpleOutRecEncoderLabel->setVisible(showEncoder);
  2536. ui->simpleOutRecFormat->setVisible(!losslessQuality);
  2537. ui->simpleOutRecFormatLabel->setVisible(!losslessQuality);
  2538. SimpleRecordingEncoderChanged();
  2539. }
  2540. #define SIMPLE_OUTPUT_WARNING(str) \
  2541. QTStr("Basic.Settings.Output.Simple.Warn." str)
  2542. void OBSBasicSettings::SimpleRecordingEncoderChanged()
  2543. {
  2544. QString qual = ui->simpleOutRecQuality->currentData().toString();
  2545. QString warning;
  2546. delete simpleOutRecWarning;
  2547. if (qual == "Stream") {
  2548. return;
  2549. } else if (qual == "Lossless") {
  2550. warning = SIMPLE_OUTPUT_WARNING("Lossless");
  2551. warning += "\n\n";
  2552. warning += SIMPLE_OUTPUT_WARNING("Encoder");
  2553. } else {
  2554. QString enc = ui->simpleOutRecEncoder->currentData().toString();
  2555. if (enc != SIMPLE_ENCODER_X264 &&
  2556. enc != SIMPLE_ENCODER_X264_LOWCPU)
  2557. return;
  2558. warning = SIMPLE_OUTPUT_WARNING("Encoder");
  2559. }
  2560. simpleOutRecWarning = new QLabel(warning, this);
  2561. simpleOutRecWarning->setObjectName("warningLabel");
  2562. simpleOutRecWarning->setWordWrap(true);
  2563. ui->simpleOutInfoLayout->addWidget(simpleOutRecWarning);
  2564. }
  2565. void OBSBasicSettings::SimpleRecordingQualityLosslessWarning(int idx)
  2566. {
  2567. if (idx == lastSimpleRecQualityIdx || idx == -1)
  2568. return;
  2569. QString qual = ui->simpleOutRecQuality->itemData(idx).toString();
  2570. if (loading) {
  2571. lastSimpleRecQualityIdx = idx;
  2572. return;
  2573. }
  2574. if (qual == "Lossless") {
  2575. QMessageBox::StandardButton button;
  2576. QString warningString =
  2577. SIMPLE_OUTPUT_WARNING("Lossless") +
  2578. QString("\n\n") +
  2579. SIMPLE_OUTPUT_WARNING("Lossless.Msg");
  2580. button = QMessageBox::question(this,
  2581. SIMPLE_OUTPUT_WARNING("Lossless.Title"),
  2582. warningString,
  2583. QMessageBox::Yes | QMessageBox::No);
  2584. if (button == QMessageBox::No) {
  2585. QMetaObject::invokeMethod(ui->simpleOutRecQuality,
  2586. "setCurrentIndex", Qt::QueuedConnection,
  2587. Q_ARG(int, lastSimpleRecQualityIdx));
  2588. return;
  2589. }
  2590. }
  2591. lastSimpleRecQualityIdx = idx;
  2592. }
  2593. void OBSBasicSettings::on_disableOSXVSync_clicked()
  2594. {
  2595. #ifdef __APPLE__
  2596. if (!loading) {
  2597. bool disable = ui->disableOSXVSync->isChecked();
  2598. ui->resetOSXVSync->setEnabled(disable);
  2599. }
  2600. #endif
  2601. }