api-interface.cpp 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567
  1. #include <obs-frontend-internal.hpp>
  2. #include "obs-app.hpp"
  3. #include "qt-wrappers.hpp"
  4. #include "window-basic-main.hpp"
  5. #include "window-basic-main-outputs.hpp"
  6. #include <functional>
  7. using namespace std;
  8. Q_DECLARE_METATYPE(OBSScene);
  9. Q_DECLARE_METATYPE(OBSSource);
  10. template<typename T> static T GetOBSRef(QListWidgetItem *item)
  11. {
  12. return item->data(static_cast<int>(QtDataRole::OBSRef)).value<T>();
  13. }
  14. void EnumProfiles(function<bool(const char *, const char *)> &&cb);
  15. void EnumSceneCollections(function<bool(const char *, const char *)> &&cb);
  16. extern volatile bool streaming_active;
  17. extern volatile bool recording_active;
  18. extern volatile bool recording_paused;
  19. extern volatile bool replaybuf_active;
  20. /* ------------------------------------------------------------------------- */
  21. template<typename T> struct OBSStudioCallback {
  22. T callback;
  23. void *private_data;
  24. inline OBSStudioCallback(T cb, void *p) : callback(cb), private_data(p)
  25. {
  26. }
  27. };
  28. template<typename T>
  29. inline size_t GetCallbackIdx(vector<OBSStudioCallback<T>> &callbacks,
  30. T callback, void *private_data)
  31. {
  32. for (size_t i = 0; i < callbacks.size(); i++) {
  33. OBSStudioCallback<T> curCB = callbacks[i];
  34. if (curCB.callback == callback &&
  35. curCB.private_data == private_data)
  36. return i;
  37. }
  38. return (size_t)-1;
  39. }
  40. struct OBSStudioAPI : obs_frontend_callbacks {
  41. OBSBasic *main;
  42. vector<OBSStudioCallback<obs_frontend_event_cb>> callbacks;
  43. vector<OBSStudioCallback<obs_frontend_save_cb>> saveCallbacks;
  44. vector<OBSStudioCallback<obs_frontend_save_cb>> preloadCallbacks;
  45. inline OBSStudioAPI(OBSBasic *main_) : main(main_) {}
  46. void *obs_frontend_get_main_window(void) override
  47. {
  48. return (void *)main;
  49. }
  50. void *obs_frontend_get_main_window_handle(void) override
  51. {
  52. return (void *)main->winId();
  53. }
  54. void *obs_frontend_get_system_tray(void) override
  55. {
  56. return (void *)main->trayIcon.data();
  57. }
  58. void obs_frontend_get_scenes(
  59. struct obs_frontend_source_list *sources) override
  60. {
  61. for (int i = 0; i < main->ui->scenes->count(); i++) {
  62. QListWidgetItem *item = main->ui->scenes->item(i);
  63. OBSScene scene = GetOBSRef<OBSScene>(item);
  64. obs_source_t *source = obs_scene_get_source(scene);
  65. obs_source_addref(source);
  66. da_push_back(sources->sources, &source);
  67. }
  68. }
  69. obs_source_t *obs_frontend_get_current_scene(void) override
  70. {
  71. OBSSource source;
  72. if (main->IsPreviewProgramMode()) {
  73. source = obs_weak_source_get_source(main->programScene);
  74. } else {
  75. source = main->GetCurrentSceneSource();
  76. obs_source_addref(source);
  77. }
  78. return source;
  79. }
  80. void obs_frontend_set_current_scene(obs_source_t *scene) override
  81. {
  82. if (main->IsPreviewProgramMode()) {
  83. QMetaObject::invokeMethod(
  84. main, "TransitionToScene", WaitConnection(),
  85. Q_ARG(OBSSource, OBSSource(scene)));
  86. } else {
  87. QMetaObject::invokeMethod(
  88. main, "SetCurrentScene", WaitConnection(),
  89. Q_ARG(OBSSource, OBSSource(scene)),
  90. Q_ARG(bool, false));
  91. }
  92. }
  93. void obs_frontend_get_transitions(
  94. struct obs_frontend_source_list *sources) override
  95. {
  96. for (int i = 0; i < main->ui->transitions->count(); i++) {
  97. OBSSource tr = main->ui->transitions->itemData(i)
  98. .value<OBSSource>();
  99. obs_source_addref(tr);
  100. da_push_back(sources->sources, &tr);
  101. }
  102. }
  103. obs_source_t *obs_frontend_get_current_transition(void) override
  104. {
  105. OBSSource tr = main->GetCurrentTransition();
  106. obs_source_addref(tr);
  107. return tr;
  108. }
  109. void
  110. obs_frontend_set_current_transition(obs_source_t *transition) override
  111. {
  112. QMetaObject::invokeMethod(main, "SetTransition",
  113. Q_ARG(OBSSource,
  114. OBSSource(transition)));
  115. }
  116. int obs_frontend_get_transition_duration(void) override
  117. {
  118. return main->ui->transitionDuration->value();
  119. }
  120. void obs_frontend_set_transition_duration(int duration) override
  121. {
  122. QMetaObject::invokeMethod(main->ui->transitionDuration,
  123. "setValue", Q_ARG(int, duration));
  124. }
  125. void obs_frontend_get_scene_collections(
  126. std::vector<std::string> &strings) override
  127. {
  128. auto addCollection = [&](const char *name, const char *) {
  129. strings.emplace_back(name);
  130. return true;
  131. };
  132. EnumSceneCollections(addCollection);
  133. }
  134. char *obs_frontend_get_current_scene_collection(void) override
  135. {
  136. const char *cur_name = config_get_string(
  137. App()->GlobalConfig(), "Basic", "SceneCollection");
  138. return bstrdup(cur_name);
  139. }
  140. void obs_frontend_set_current_scene_collection(
  141. const char *collection) override
  142. {
  143. QList<QAction *> menuActions =
  144. main->ui->sceneCollectionMenu->actions();
  145. QString qstrCollection = QT_UTF8(collection);
  146. for (int i = 0; i < menuActions.count(); i++) {
  147. QAction *action = menuActions[i];
  148. QVariant v = action->property("file_name");
  149. if (v.typeName() != nullptr) {
  150. if (action->text() == qstrCollection) {
  151. action->trigger();
  152. break;
  153. }
  154. }
  155. }
  156. }
  157. bool obs_frontend_add_scene_collection(const char *name) override
  158. {
  159. bool success = false;
  160. QMetaObject::invokeMethod(main, "AddSceneCollection",
  161. WaitConnection(),
  162. Q_RETURN_ARG(bool, success),
  163. Q_ARG(bool, true),
  164. Q_ARG(QString, QT_UTF8(name)));
  165. return success;
  166. }
  167. void
  168. obs_frontend_get_profiles(std::vector<std::string> &strings) override
  169. {
  170. auto addProfile = [&](const char *name, const char *) {
  171. strings.emplace_back(name);
  172. return true;
  173. };
  174. EnumProfiles(addProfile);
  175. }
  176. char *obs_frontend_get_current_profile(void) override
  177. {
  178. const char *name = config_get_string(App()->GlobalConfig(),
  179. "Basic", "Profile");
  180. return bstrdup(name);
  181. }
  182. void obs_frontend_set_current_profile(const char *profile) override
  183. {
  184. QList<QAction *> menuActions = main->ui->profileMenu->actions();
  185. QString qstrProfile = QT_UTF8(profile);
  186. for (int i = 0; i < menuActions.count(); i++) {
  187. QAction *action = menuActions[i];
  188. QVariant v = action->property("file_name");
  189. if (v.typeName() != nullptr) {
  190. if (action->text() == qstrProfile) {
  191. action->trigger();
  192. break;
  193. }
  194. }
  195. }
  196. }
  197. void obs_frontend_streaming_start(void) override
  198. {
  199. QMetaObject::invokeMethod(main, "StartStreaming");
  200. }
  201. void obs_frontend_streaming_stop(void) override
  202. {
  203. QMetaObject::invokeMethod(main, "StopStreaming");
  204. }
  205. bool obs_frontend_streaming_active(void) override
  206. {
  207. return os_atomic_load_bool(&streaming_active);
  208. }
  209. void obs_frontend_recording_start(void) override
  210. {
  211. QMetaObject::invokeMethod(main, "StartRecording");
  212. }
  213. void obs_frontend_recording_stop(void) override
  214. {
  215. QMetaObject::invokeMethod(main, "StopRecording");
  216. }
  217. bool obs_frontend_recording_active(void) override
  218. {
  219. return os_atomic_load_bool(&recording_active);
  220. }
  221. void obs_frontend_recording_pause(bool pause) override
  222. {
  223. QMetaObject::invokeMethod(main, pause ? "PauseRecording"
  224. : "UnpauseRecording");
  225. }
  226. bool obs_frontend_recording_paused(void) override
  227. {
  228. return os_atomic_load_bool(&recording_paused);
  229. }
  230. void obs_frontend_replay_buffer_start(void) override
  231. {
  232. QMetaObject::invokeMethod(main, "StartReplayBuffer");
  233. }
  234. void obs_frontend_replay_buffer_save(void) override
  235. {
  236. QMetaObject::invokeMethod(main, "ReplayBufferSave");
  237. }
  238. void obs_frontend_replay_buffer_stop(void) override
  239. {
  240. QMetaObject::invokeMethod(main, "StopReplayBuffer");
  241. }
  242. bool obs_frontend_replay_buffer_active(void) override
  243. {
  244. return os_atomic_load_bool(&replaybuf_active);
  245. }
  246. void *obs_frontend_add_tools_menu_qaction(const char *name) override
  247. {
  248. main->ui->menuTools->setEnabled(true);
  249. return (void *)main->ui->menuTools->addAction(QT_UTF8(name));
  250. }
  251. void obs_frontend_add_tools_menu_item(const char *name,
  252. obs_frontend_cb callback,
  253. void *private_data) override
  254. {
  255. main->ui->menuTools->setEnabled(true);
  256. auto func = [private_data, callback]() {
  257. callback(private_data);
  258. };
  259. QAction *action = main->ui->menuTools->addAction(QT_UTF8(name));
  260. QObject::connect(action, &QAction::triggered, func);
  261. }
  262. void *obs_frontend_add_dock(void *dock) override
  263. {
  264. return (void *)main->AddDockWidget((QDockWidget *)dock);
  265. }
  266. void obs_frontend_add_event_callback(obs_frontend_event_cb callback,
  267. void *private_data) override
  268. {
  269. size_t idx = GetCallbackIdx(callbacks, callback, private_data);
  270. if (idx == (size_t)-1)
  271. callbacks.emplace_back(callback, private_data);
  272. }
  273. void obs_frontend_remove_event_callback(obs_frontend_event_cb callback,
  274. void *private_data) override
  275. {
  276. size_t idx = GetCallbackIdx(callbacks, callback, private_data);
  277. if (idx == (size_t)-1)
  278. return;
  279. callbacks.erase(callbacks.begin() + idx);
  280. }
  281. obs_output_t *obs_frontend_get_streaming_output(void) override
  282. {
  283. OBSOutput output = main->outputHandler->streamOutput;
  284. obs_output_addref(output);
  285. return output;
  286. }
  287. obs_output_t *obs_frontend_get_recording_output(void) override
  288. {
  289. OBSOutput out = main->outputHandler->fileOutput;
  290. obs_output_addref(out);
  291. return out;
  292. }
  293. obs_output_t *obs_frontend_get_replay_buffer_output(void) override
  294. {
  295. OBSOutput out = main->outputHandler->replayBuffer;
  296. obs_output_addref(out);
  297. return out;
  298. }
  299. config_t *obs_frontend_get_profile_config(void) override
  300. {
  301. return main->basicConfig;
  302. }
  303. config_t *obs_frontend_get_global_config(void) override
  304. {
  305. return App()->GlobalConfig();
  306. }
  307. void obs_frontend_open_projector(const char *type, int monitor,
  308. const char *geometry,
  309. const char *name) override
  310. {
  311. SavedProjectorInfo proj = {
  312. ProjectorType::Preview,
  313. monitor,
  314. geometry ? geometry : "",
  315. name ? name : "",
  316. };
  317. if (type) {
  318. if (astrcmpi(type, "Source") == 0)
  319. proj.type = ProjectorType::Source;
  320. else if (astrcmpi(type, "Scene") == 0)
  321. proj.type = ProjectorType::Scene;
  322. else if (astrcmpi(type, "StudioProgram") == 0)
  323. proj.type = ProjectorType::StudioProgram;
  324. else if (astrcmpi(type, "Multiview") == 0)
  325. proj.type = ProjectorType::Multiview;
  326. }
  327. QMetaObject::invokeMethod(main, "OpenSavedProjector",
  328. WaitConnection(),
  329. Q_ARG(SavedProjectorInfo *, &proj));
  330. }
  331. void obs_frontend_save(void) override { main->SaveProject(); }
  332. void obs_frontend_defer_save_begin(void) override
  333. {
  334. QMetaObject::invokeMethod(main, "DeferSaveBegin");
  335. }
  336. void obs_frontend_defer_save_end(void) override
  337. {
  338. QMetaObject::invokeMethod(main, "DeferSaveEnd");
  339. }
  340. void obs_frontend_add_save_callback(obs_frontend_save_cb callback,
  341. void *private_data) override
  342. {
  343. size_t idx =
  344. GetCallbackIdx(saveCallbacks, callback, private_data);
  345. if (idx == (size_t)-1)
  346. saveCallbacks.emplace_back(callback, private_data);
  347. }
  348. void obs_frontend_remove_save_callback(obs_frontend_save_cb callback,
  349. void *private_data) override
  350. {
  351. size_t idx =
  352. GetCallbackIdx(saveCallbacks, callback, private_data);
  353. if (idx == (size_t)-1)
  354. return;
  355. saveCallbacks.erase(saveCallbacks.begin() + idx);
  356. }
  357. void obs_frontend_add_preload_callback(obs_frontend_save_cb callback,
  358. void *private_data) override
  359. {
  360. size_t idx = GetCallbackIdx(preloadCallbacks, callback,
  361. private_data);
  362. if (idx == (size_t)-1)
  363. preloadCallbacks.emplace_back(callback, private_data);
  364. }
  365. void obs_frontend_remove_preload_callback(obs_frontend_save_cb callback,
  366. void *private_data) override
  367. {
  368. size_t idx = GetCallbackIdx(preloadCallbacks, callback,
  369. private_data);
  370. if (idx == (size_t)-1)
  371. return;
  372. preloadCallbacks.erase(preloadCallbacks.begin() + idx);
  373. }
  374. void obs_frontend_push_ui_translation(
  375. obs_frontend_translate_ui_cb translate) override
  376. {
  377. App()->PushUITranslation(translate);
  378. }
  379. void obs_frontend_pop_ui_translation(void) override
  380. {
  381. App()->PopUITranslation();
  382. }
  383. void obs_frontend_set_streaming_service(obs_service_t *service) override
  384. {
  385. main->SetService(service);
  386. }
  387. obs_service_t *obs_frontend_get_streaming_service(void) override
  388. {
  389. return main->GetService();
  390. }
  391. void obs_frontend_save_streaming_service(void) override
  392. {
  393. main->SaveService();
  394. }
  395. bool obs_frontend_preview_program_mode_active(void) override
  396. {
  397. return main->IsPreviewProgramMode();
  398. }
  399. void obs_frontend_set_preview_program_mode(bool enable) override
  400. {
  401. main->SetPreviewProgramMode(enable);
  402. }
  403. void obs_frontend_preview_program_trigger_transition(void) override
  404. {
  405. QMetaObject::invokeMethod(main, "TransitionClicked");
  406. }
  407. bool obs_frontend_preview_enabled(void) override
  408. {
  409. return main->previewEnabled;
  410. }
  411. void obs_frontend_set_preview_enabled(bool enable) override
  412. {
  413. if (main->previewEnabled != enable)
  414. main->EnablePreviewDisplay(enable);
  415. }
  416. obs_source_t *obs_frontend_get_current_preview_scene(void) override
  417. {
  418. OBSSource source = nullptr;
  419. if (main->IsPreviewProgramMode()) {
  420. source = main->GetCurrentSceneSource();
  421. obs_source_addref(source);
  422. }
  423. return source;
  424. }
  425. void
  426. obs_frontend_set_current_preview_scene(obs_source_t *scene) override
  427. {
  428. if (main->IsPreviewProgramMode()) {
  429. QMetaObject::invokeMethod(main, "SetCurrentScene",
  430. Q_ARG(OBSSource,
  431. OBSSource(scene)),
  432. Q_ARG(bool, false));
  433. }
  434. }
  435. void on_load(obs_data_t *settings) override
  436. {
  437. for (size_t i = saveCallbacks.size(); i > 0; i--) {
  438. auto cb = saveCallbacks[i - 1];
  439. cb.callback(settings, false, cb.private_data);
  440. }
  441. }
  442. void on_preload(obs_data_t *settings) override
  443. {
  444. for (size_t i = preloadCallbacks.size(); i > 0; i--) {
  445. auto cb = preloadCallbacks[i - 1];
  446. cb.callback(settings, false, cb.private_data);
  447. }
  448. }
  449. void on_save(obs_data_t *settings) override
  450. {
  451. for (size_t i = saveCallbacks.size(); i > 0; i--) {
  452. auto cb = saveCallbacks[i - 1];
  453. cb.callback(settings, true, cb.private_data);
  454. }
  455. }
  456. void on_event(enum obs_frontend_event event) override
  457. {
  458. if (main->disableSaving)
  459. return;
  460. for (size_t i = callbacks.size(); i > 0; i--) {
  461. auto cb = callbacks[i - 1];
  462. cb.callback(event, cb.private_data);
  463. }
  464. }
  465. };
  466. obs_frontend_callbacks *InitializeAPIInterface(OBSBasic *main)
  467. {
  468. obs_frontend_callbacks *api = new OBSStudioAPI(main);
  469. obs_frontend_set_callbacks_internal(api);
  470. return api;
  471. }