api-interface.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531
  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>
  11. static T GetOBSRef(QListWidgetItem *item)
  12. {
  13. return item->data(static_cast<int>(QtDataRole::OBSRef)).value<T>();
  14. }
  15. void EnumProfiles(function<bool (const char *, const char *)> &&cb);
  16. void EnumSceneCollections(function<bool (const char *, const char *)> &&cb);
  17. extern volatile bool streaming_active;
  18. extern volatile bool recording_active;
  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) :
  25. callback(cb), private_data(p)
  26. {}
  27. };
  28. template <typename T> inline size_t GetCallbackIdx(
  29. 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(main, "TransitionToScene",
  84. WaitConnection(),
  85. Q_ARG(OBSSource, OBSSource(scene)));
  86. } else {
  87. QMetaObject::invokeMethod(main, "SetCurrentScene",
  88. 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 obs_frontend_set_current_transition(
  110. obs_source_t *transition) override
  111. {
  112. QMetaObject::invokeMethod(main, "SetTransition",
  113. Q_ARG(OBSSource, OBSSource(transition)));
  114. }
  115. int obs_frontend_get_transition_duration(void) override
  116. {
  117. return main->ui->transitionDuration->value();
  118. }
  119. void obs_frontend_set_transition_duration(int duration) override
  120. {
  121. QMetaObject::invokeMethod(main->ui->transitionDuration, "setValue",
  122. Q_ARG(int, duration));
  123. }
  124. void obs_frontend_get_scene_collections(
  125. std::vector<std::string> &strings) override
  126. {
  127. auto addCollection = [&](const char *name, const char *)
  128. {
  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(App()->GlobalConfig(),
  137. "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(
  158. const char *name) override
  159. {
  160. bool success = false;
  161. QMetaObject::invokeMethod(main,
  162. "AddSceneCollection",
  163. WaitConnection(),
  164. Q_RETURN_ARG(bool, success),
  165. Q_ARG(bool, true),
  166. Q_ARG(QString, QT_UTF8(name)));
  167. return success;
  168. }
  169. void obs_frontend_get_profiles(
  170. std::vector<std::string> &strings) override
  171. {
  172. auto addProfile = [&](const char *name, const char *)
  173. {
  174. strings.emplace_back(name);
  175. return true;
  176. };
  177. EnumProfiles(addProfile);
  178. }
  179. char *obs_frontend_get_current_profile(void) override
  180. {
  181. const char *name = config_get_string(App()->GlobalConfig(),
  182. "Basic", "Profile");
  183. return bstrdup(name);
  184. }
  185. void obs_frontend_set_current_profile(const char *profile) override
  186. {
  187. QList<QAction*> menuActions =
  188. main->ui->profileMenu->actions();
  189. QString qstrProfile = QT_UTF8(profile);
  190. for (int i = 0; i < menuActions.count(); i++) {
  191. QAction *action = menuActions[i];
  192. QVariant v = action->property("file_name");
  193. if (v.typeName() != nullptr) {
  194. if (action->text() == qstrProfile) {
  195. action->trigger();
  196. break;
  197. }
  198. }
  199. }
  200. }
  201. void obs_frontend_streaming_start(void) override
  202. {
  203. QMetaObject::invokeMethod(main, "StartStreaming");
  204. }
  205. void obs_frontend_streaming_stop(void) override
  206. {
  207. QMetaObject::invokeMethod(main, "StopStreaming");
  208. }
  209. bool obs_frontend_streaming_active(void) override
  210. {
  211. return os_atomic_load_bool(&streaming_active);
  212. }
  213. void obs_frontend_recording_start(void) override
  214. {
  215. QMetaObject::invokeMethod(main, "StartRecording");
  216. }
  217. void obs_frontend_recording_stop(void) override
  218. {
  219. QMetaObject::invokeMethod(main, "StopRecording");
  220. }
  221. bool obs_frontend_recording_active(void) override
  222. {
  223. return os_atomic_load_bool(&recording_active);
  224. }
  225. void obs_frontend_replay_buffer_start(void) override
  226. {
  227. QMetaObject::invokeMethod(main, "StartReplayBuffer");
  228. }
  229. void obs_frontend_replay_buffer_save(void) override
  230. {
  231. QMetaObject::invokeMethod(main, "ReplayBufferSave");
  232. }
  233. void obs_frontend_replay_buffer_stop(void) override
  234. {
  235. QMetaObject::invokeMethod(main, "StopReplayBuffer");
  236. }
  237. bool obs_frontend_replay_buffer_active(void) override
  238. {
  239. return os_atomic_load_bool(&replaybuf_active);
  240. }
  241. void *obs_frontend_add_tools_menu_qaction(const char *name) override
  242. {
  243. main->ui->menuTools->setEnabled(true);
  244. return (void*)main->ui->menuTools->addAction(QT_UTF8(name));
  245. }
  246. void obs_frontend_add_tools_menu_item(const char *name,
  247. obs_frontend_cb callback, void *private_data) override
  248. {
  249. main->ui->menuTools->setEnabled(true);
  250. auto func = [private_data, callback] ()
  251. {
  252. callback(private_data);
  253. };
  254. QAction *action = main->ui->menuTools->addAction(QT_UTF8(name));
  255. QObject::connect(action, &QAction::triggered, func);
  256. }
  257. void obs_frontend_add_event_callback(obs_frontend_event_cb callback,
  258. void *private_data) override
  259. {
  260. size_t idx = GetCallbackIdx(callbacks, callback, private_data);
  261. if (idx == (size_t)-1)
  262. callbacks.emplace_back(callback, private_data);
  263. }
  264. void obs_frontend_remove_event_callback(obs_frontend_event_cb callback,
  265. void *private_data) override
  266. {
  267. size_t idx = GetCallbackIdx(callbacks, callback, private_data);
  268. if (idx == (size_t)-1)
  269. return;
  270. callbacks.erase(callbacks.begin() + idx);
  271. }
  272. obs_output_t *obs_frontend_get_streaming_output(void) override
  273. {
  274. OBSOutput output = main->outputHandler->streamOutput;
  275. obs_output_addref(output);
  276. return output;
  277. }
  278. obs_output_t *obs_frontend_get_recording_output(void) override
  279. {
  280. OBSOutput out = main->outputHandler->fileOutput;
  281. obs_output_addref(out);
  282. return out;
  283. }
  284. obs_output_t *obs_frontend_get_replay_buffer_output(void) override
  285. {
  286. OBSOutput out = main->outputHandler->replayBuffer;
  287. obs_output_addref(out);
  288. return out;
  289. }
  290. config_t *obs_frontend_get_profile_config(void) override
  291. {
  292. return main->basicConfig;
  293. }
  294. config_t *obs_frontend_get_global_config(void) override
  295. {
  296. return App()->GlobalConfig();
  297. }
  298. void obs_frontend_save(void) override
  299. {
  300. main->SaveProject();
  301. }
  302. void obs_frontend_defer_save_begin(void) override
  303. {
  304. QMetaObject::invokeMethod(main, "DeferSaveBegin");
  305. }
  306. void obs_frontend_defer_save_end(void) override
  307. {
  308. QMetaObject::invokeMethod(main, "DeferSaveEnd");
  309. }
  310. void obs_frontend_add_save_callback(obs_frontend_save_cb callback,
  311. void *private_data) override
  312. {
  313. size_t idx = GetCallbackIdx(saveCallbacks, callback,
  314. private_data);
  315. if (idx == (size_t)-1)
  316. saveCallbacks.emplace_back(callback, private_data);
  317. }
  318. void obs_frontend_remove_save_callback(obs_frontend_save_cb callback,
  319. void *private_data) override
  320. {
  321. size_t idx = GetCallbackIdx(saveCallbacks, callback,
  322. private_data);
  323. if (idx == (size_t)-1)
  324. return;
  325. saveCallbacks.erase(saveCallbacks.begin() + idx);
  326. }
  327. void obs_frontend_add_preload_callback(obs_frontend_save_cb callback,
  328. void *private_data) override
  329. {
  330. size_t idx = GetCallbackIdx(preloadCallbacks, callback,
  331. private_data);
  332. if (idx == (size_t)-1)
  333. preloadCallbacks.emplace_back(callback, private_data);
  334. }
  335. void obs_frontend_remove_preload_callback(obs_frontend_save_cb callback,
  336. void *private_data) override
  337. {
  338. size_t idx = GetCallbackIdx(preloadCallbacks, callback,
  339. private_data);
  340. if (idx == (size_t)-1)
  341. return;
  342. preloadCallbacks.erase(preloadCallbacks.begin() + idx);
  343. }
  344. void obs_frontend_push_ui_translation(
  345. obs_frontend_translate_ui_cb translate) override
  346. {
  347. App()->PushUITranslation(translate);
  348. }
  349. void obs_frontend_pop_ui_translation(void) override
  350. {
  351. App()->PopUITranslation();
  352. }
  353. void obs_frontend_set_streaming_service(obs_service_t *service) override
  354. {
  355. main->SetService(service);
  356. }
  357. obs_service_t *obs_frontend_get_streaming_service(void) override
  358. {
  359. return main->GetService();
  360. }
  361. void obs_frontend_save_streaming_service(void) override
  362. {
  363. main->SaveService();
  364. }
  365. bool obs_frontend_preview_program_mode_active(void) override
  366. {
  367. return main->IsPreviewProgramMode();
  368. }
  369. void obs_frontend_set_preview_program_mode(bool enable) override
  370. {
  371. main->SetPreviewProgramMode(enable);
  372. }
  373. void obs_frontend_preview_program_trigger_transition(void) override
  374. {
  375. QMetaObject::invokeMethod(main, "TransitionClicked");
  376. }
  377. bool obs_frontend_preview_enabled(void) override
  378. {
  379. return main->previewEnabled;
  380. }
  381. void obs_frontend_set_preview_enabled(bool enable) override
  382. {
  383. if (main->previewEnabled != enable)
  384. main->EnablePreviewDisplay(enable);
  385. }
  386. obs_source_t *obs_frontend_get_current_preview_scene(void) override
  387. {
  388. OBSSource source = nullptr;
  389. if (main->IsPreviewProgramMode()) {
  390. source = main->GetCurrentSceneSource();
  391. obs_source_addref(source);
  392. }
  393. return source;
  394. }
  395. void obs_frontend_set_current_preview_scene(obs_source_t *scene) override
  396. {
  397. if (main->IsPreviewProgramMode()) {
  398. QMetaObject::invokeMethod(main, "SetCurrentScene",
  399. Q_ARG(OBSSource, OBSSource(scene)),
  400. Q_ARG(bool, false));
  401. }
  402. }
  403. void on_load(obs_data_t *settings) override
  404. {
  405. for (size_t i = saveCallbacks.size(); i > 0; i--) {
  406. auto cb = saveCallbacks[i - 1];
  407. cb.callback(settings, false, cb.private_data);
  408. }
  409. }
  410. void on_preload(obs_data_t *settings) override
  411. {
  412. for (size_t i = preloadCallbacks.size(); i > 0; i--) {
  413. auto cb = preloadCallbacks[i - 1];
  414. cb.callback(settings, false, cb.private_data);
  415. }
  416. }
  417. void on_save(obs_data_t *settings) override
  418. {
  419. for (size_t i = saveCallbacks.size(); i > 0; i--) {
  420. auto cb = saveCallbacks[i - 1];
  421. cb.callback(settings, true, cb.private_data);
  422. }
  423. }
  424. void on_event(enum obs_frontend_event event) override
  425. {
  426. if (main->disableSaving)
  427. return;
  428. for (size_t i = callbacks.size(); i > 0; i--) {
  429. auto cb = callbacks[i - 1];
  430. cb.callback(event, cb.private_data);
  431. }
  432. }
  433. };
  434. obs_frontend_callbacks *InitializeAPIInterface(OBSBasic *main)
  435. {
  436. obs_frontend_callbacks *api = new OBSStudioAPI(main);
  437. obs_frontend_set_callbacks_internal(api);
  438. return api;
  439. }