obs-source-transition.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937
  1. /******************************************************************************
  2. Copyright (C) 2013-2014 by Hugh Bailey <[email protected]>
  3. This program is free software: you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation, either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>.
  13. ******************************************************************************/
  14. #include "obs-internal.h"
  15. #define lock_transition(transition) \
  16. pthread_mutex_lock(&transition->transition_mutex);
  17. #define unlock_transition(transition) \
  18. pthread_mutex_unlock(&transition->transition_mutex);
  19. #define trylock_textures(transition) \
  20. pthread_mutex_trylock(&transition->transition_tex_mutex)
  21. #define lock_textures(transition) \
  22. pthread_mutex_lock(&transition->transition_tex_mutex)
  23. #define unlock_textures(transition) \
  24. pthread_mutex_unlock(&transition->transition_tex_mutex)
  25. static inline bool transition_valid(const obs_source_t *transition,
  26. const char *func)
  27. {
  28. if (!obs_ptr_valid(transition, func))
  29. return false;
  30. else if (transition->info.type != OBS_SOURCE_TYPE_TRANSITION)
  31. return false;
  32. return true;
  33. }
  34. bool obs_transition_init(obs_source_t *transition)
  35. {
  36. pthread_mutex_init_value(&transition->transition_mutex);
  37. pthread_mutex_init_value(&transition->transition_tex_mutex);
  38. if (pthread_mutex_init(&transition->transition_mutex, NULL) != 0)
  39. return false;
  40. if (pthread_mutex_init(&transition->transition_tex_mutex, NULL) != 0)
  41. return false;
  42. transition->transition_alignment = OBS_ALIGN_LEFT | OBS_ALIGN_TOP;
  43. transition->transition_texrender[0] =
  44. gs_texrender_create(GS_RGBA, GS_ZS_NONE);
  45. transition->transition_texrender[1] =
  46. gs_texrender_create(GS_RGBA, GS_ZS_NONE);
  47. transition->transition_source_active[0] = true;
  48. return transition->transition_texrender[0] != NULL &&
  49. transition->transition_texrender[1] != NULL;
  50. }
  51. void obs_transition_free(obs_source_t *transition)
  52. {
  53. pthread_mutex_destroy(&transition->transition_mutex);
  54. pthread_mutex_destroy(&transition->transition_tex_mutex);
  55. gs_enter_context(obs->video.graphics);
  56. gs_texrender_destroy(transition->transition_texrender[0]);
  57. gs_texrender_destroy(transition->transition_texrender[1]);
  58. gs_leave_context();
  59. }
  60. void obs_transition_clear(obs_source_t *transition)
  61. {
  62. obs_source_t *s[2];
  63. bool active[2];
  64. if (!transition_valid(transition, "obs_transition_clear"))
  65. return;
  66. lock_transition(transition);
  67. for (size_t i = 0; i < 2; i++) {
  68. s[i] = transition->transition_sources[i];
  69. active[i] = transition->transition_source_active[i];
  70. transition->transition_sources[i] = NULL;
  71. transition->transition_source_active[i] = false;
  72. }
  73. transition->transitioning_video = false;
  74. transition->transitioning_audio = false;
  75. unlock_transition(transition);
  76. for (size_t i = 0; i < 2; i++) {
  77. if (s[i] && active[i])
  78. obs_source_remove_active_child(transition, s[i]);
  79. obs_source_release(s[i]);
  80. }
  81. }
  82. void add_alignment(struct vec2 *v, uint32_t align, int cx, int cy);
  83. static void recalculate_transition_matrix(obs_source_t *tr, size_t idx)
  84. {
  85. obs_source_t *child;
  86. struct matrix4 mat;
  87. struct vec2 pos;
  88. struct vec2 scale;
  89. float tr_cx = (float)tr->transition_actual_cx;
  90. float tr_cy = (float)tr->transition_actual_cy;
  91. float source_cx;
  92. float source_cy;
  93. float tr_aspect = tr_cx / tr_cy;
  94. float source_aspect;
  95. enum obs_transition_scale_type scale_type = tr->transition_scale_type;
  96. lock_transition(tr);
  97. child = tr->transition_sources[idx];
  98. if (!child) {
  99. unlock_transition(tr);
  100. return;
  101. }
  102. source_cx = (float)obs_source_get_width(child);
  103. source_cy = (float)obs_source_get_height(child);
  104. unlock_transition(tr);
  105. if (source_cx == 0.0f || source_cy == 0.0f)
  106. return;
  107. source_aspect = source_cx / source_cy;
  108. if (scale_type == OBS_TRANSITION_SCALE_MAX_ONLY) {
  109. if (source_cx > tr_cx || source_cy > tr_cy) {
  110. scale_type = OBS_TRANSITION_SCALE_ASPECT;
  111. } else {
  112. scale.x = 1.0f;
  113. scale.y = 1.0f;
  114. }
  115. }
  116. if (scale_type == OBS_TRANSITION_SCALE_ASPECT) {
  117. bool use_width = tr_aspect < source_aspect;
  118. scale.x = scale.y = use_width ?
  119. tr_cx / source_cx :
  120. tr_cy / source_cy;
  121. } else if (scale_type == OBS_TRANSITION_SCALE_STRETCH) {
  122. scale.x = tr_cx / source_cx;
  123. scale.y = tr_cy / source_cy;
  124. }
  125. source_cx *= scale.x;
  126. source_cy *= scale.y;
  127. vec2_zero(&pos);
  128. add_alignment(&pos, tr->transition_alignment,
  129. (int)(tr_cx - source_cx),
  130. (int)(tr_cy - source_cy));
  131. matrix4_identity(&mat);
  132. matrix4_scale3f(&mat, &mat, scale.x, scale.y, 1.0f);
  133. matrix4_translate3f(&mat, &mat, pos.x, pos.y, 0.0f);
  134. matrix4_copy(&tr->transition_matrices[idx], &mat);
  135. }
  136. static inline void recalculate_transition_matrices(obs_source_t *transition)
  137. {
  138. recalculate_transition_matrix(transition, 0);
  139. recalculate_transition_matrix(transition, 1);
  140. }
  141. static void recalculate_transition_size(obs_source_t *transition)
  142. {
  143. uint32_t cx = 0, cy = 0;
  144. obs_source_t *child;
  145. lock_transition(transition);
  146. for (size_t i = 0; i < 2; i++) {
  147. child = transition->transition_sources[i];
  148. if (child) {
  149. uint32_t new_cx = obs_source_get_width(child);
  150. uint32_t new_cy = obs_source_get_height(child);
  151. if (new_cx > cx) cx = new_cx;
  152. if (new_cy > cy) cy = new_cy;
  153. }
  154. }
  155. unlock_transition(transition);
  156. transition->transition_actual_cx = cx;
  157. transition->transition_actual_cy = cy;
  158. }
  159. void obs_transition_tick(obs_source_t *transition)
  160. {
  161. recalculate_transition_size(transition);
  162. recalculate_transition_matrices(transition);
  163. if (trylock_textures(transition) == 0) {
  164. gs_texrender_reset(transition->transition_texrender[0]);
  165. gs_texrender_reset(transition->transition_texrender[1]);
  166. unlock_textures(transition);
  167. }
  168. }
  169. static void set_source(obs_source_t *transition,
  170. enum obs_transition_target target, obs_source_t *new_child,
  171. bool (*callback)(obs_source_t *t, size_t idx, obs_source_t *c))
  172. {
  173. size_t idx = (size_t)target;
  174. obs_source_t *old_child;
  175. bool add_success = true;
  176. bool already_active;
  177. if (new_child)
  178. obs_source_addref(new_child);
  179. lock_transition(transition);
  180. old_child = transition->transition_sources[idx];
  181. if (new_child == old_child) {
  182. unlock_transition(transition);
  183. obs_source_release(new_child);
  184. return;
  185. }
  186. already_active = transition->transition_source_active[idx];
  187. if (already_active) {
  188. if (new_child)
  189. add_success = obs_source_add_active_child(transition,
  190. new_child);
  191. if (old_child && add_success)
  192. obs_source_remove_active_child(transition, old_child);
  193. }
  194. if (callback && add_success)
  195. add_success = callback(transition, idx, new_child);
  196. transition->transition_sources[idx] = add_success ? new_child : NULL;
  197. unlock_transition(transition);
  198. if (add_success) {
  199. if (transition->transition_cx == 0 ||
  200. transition->transition_cy == 0) {
  201. recalculate_transition_size(transition);
  202. recalculate_transition_matrices(transition);
  203. }
  204. } else {
  205. obs_source_release(new_child);
  206. }
  207. obs_source_release(old_child);
  208. }
  209. obs_source_t *obs_transition_get_source(obs_source_t *transition,
  210. enum obs_transition_target target)
  211. {
  212. size_t idx = (size_t)target;
  213. obs_source_t *ret;
  214. if (!transition_valid(transition, "obs_transition_get_source"))
  215. return NULL;
  216. lock_transition(transition);
  217. ret = transition->transition_sources[idx];
  218. obs_source_addref(ret);
  219. unlock_transition(transition);
  220. return ret;
  221. }
  222. obs_source_t *obs_transition_get_active_source(obs_source_t *transition)
  223. {
  224. obs_source_t *ret;
  225. if (!transition_valid(transition, "obs_transition_get_source"))
  226. return NULL;
  227. lock_transition(transition);
  228. if (transition->transitioning_audio || transition->transitioning_video)
  229. ret = transition->transition_sources[1];
  230. else
  231. ret = transition->transition_sources[0];
  232. obs_source_addref(ret);
  233. unlock_transition(transition);
  234. return ret;
  235. }
  236. static inline bool activate_child(obs_source_t *transition, size_t idx)
  237. {
  238. bool success = true;
  239. lock_transition(transition);
  240. if (transition->transition_sources[idx] &&
  241. !transition->transition_source_active[idx]) {
  242. success = obs_source_add_active_child(transition,
  243. transition->transition_sources[idx]);
  244. if (success)
  245. transition->transition_source_active[idx] = true;
  246. }
  247. unlock_transition(transition);
  248. return success;
  249. }
  250. static bool activate_transition(obs_source_t *transition, size_t idx,
  251. obs_source_t *child)
  252. {
  253. if (!transition->transition_source_active[idx]) {
  254. if (!obs_source_add_active_child(transition, child))
  255. return false;
  256. transition->transition_source_active[idx] = true;
  257. }
  258. transition->transitioning_video = true;
  259. transition->transitioning_audio = true;
  260. return true;
  261. }
  262. static inline bool transition_active(obs_source_t *transition)
  263. {
  264. return transition->transitioning_audio ||
  265. transition->transitioning_video;
  266. }
  267. bool obs_transition_start(obs_source_t *transition,
  268. enum obs_transition_mode mode, uint32_t duration_ms,
  269. obs_source_t *dest)
  270. {
  271. bool active;
  272. bool same_as_source;
  273. bool same_as_dest;
  274. if (!transition_valid(transition, "obs_transition_start"))
  275. return false;
  276. lock_transition(transition);
  277. same_as_source = dest == transition->transition_sources[0];
  278. same_as_dest = dest == transition->transition_sources[1];
  279. active = transition_active(transition);
  280. unlock_transition(transition);
  281. if (same_as_source && !active)
  282. return false;
  283. if (transition->transition_use_fixed_duration)
  284. duration_ms = transition->transition_fixed_duration;
  285. if (!active || (!same_as_dest && !same_as_source)) {
  286. transition->transition_start_time = os_gettime_ns();
  287. transition->transition_duration =
  288. (uint64_t)duration_ms * 1000000ULL;
  289. }
  290. set_source(transition, OBS_TRANSITION_SOURCE_B, dest,
  291. activate_transition);
  292. obs_source_dosignal(transition, "source_transition_start",
  293. "transition_start");
  294. /* TODO: Add mode */
  295. UNUSED_PARAMETER(mode);
  296. return true;
  297. }
  298. void obs_transition_set(obs_source_t *transition, obs_source_t *source)
  299. {
  300. obs_source_t *s[2];
  301. bool active[2];
  302. if (!transition_valid(transition, "obs_transition_clear"))
  303. return;
  304. obs_source_addref(source);
  305. lock_transition(transition);
  306. for (size_t i = 0; i < 2; i++) {
  307. s[i] = transition->transition_sources[i];
  308. active[i] = transition->transition_source_active[i];
  309. transition->transition_sources[i] = NULL;
  310. transition->transition_source_active[i] = false;
  311. }
  312. transition->transition_source_active[0] = true;
  313. transition->transition_sources[0] = source;
  314. transition->transitioning_video = false;
  315. transition->transitioning_audio = false;
  316. unlock_transition(transition);
  317. for (size_t i = 0; i < 2; i++) {
  318. if (s[i] && active[i])
  319. obs_source_remove_active_child(transition, s[i]);
  320. obs_source_release(s[i]);
  321. }
  322. if (source)
  323. obs_source_add_active_child(transition, source);
  324. }
  325. static float calc_time(obs_source_t *transition, uint64_t ts)
  326. {
  327. uint64_t end;
  328. if (ts <= transition->transition_start_time)
  329. return 0.0f;
  330. end = transition->transition_duration;
  331. ts -= transition->transition_start_time;
  332. if (ts >= end || end == 0)
  333. return 1.0f;
  334. return (float)((long double)ts / (long double)end);
  335. }
  336. static inline float get_video_time(obs_source_t *transition)
  337. {
  338. uint64_t ts = obs->video.video_time;
  339. return calc_time(transition, ts);
  340. }
  341. static inline gs_texture_t *get_texture(obs_source_t *transition,
  342. enum obs_transition_target target)
  343. {
  344. size_t idx = (size_t)target;
  345. return gs_texrender_get_texture(transition->transition_texrender[idx]);
  346. }
  347. void obs_transition_set_scale_type(obs_source_t *transition,
  348. enum obs_transition_scale_type type)
  349. {
  350. if (!transition_valid(transition, "obs_transition_set_scale_type"))
  351. return;
  352. transition->transition_scale_type = type;
  353. }
  354. enum obs_transition_scale_type obs_transition_get_scale_type(
  355. const obs_source_t *transition)
  356. {
  357. return transition_valid(transition, "obs_transition_get_scale_type") ?
  358. transition->transition_scale_type :
  359. OBS_TRANSITION_SCALE_MAX_ONLY;
  360. }
  361. void obs_transition_set_alignment(obs_source_t *transition, uint32_t alignment)
  362. {
  363. if (!transition_valid(transition, "obs_transition_set_alignment"))
  364. return;
  365. transition->transition_alignment = alignment;
  366. }
  367. uint32_t obs_transition_get_alignment(const obs_source_t *transition)
  368. {
  369. return transition_valid(transition, "obs_transition_get_alignment") ?
  370. transition->transition_alignment : 0;
  371. }
  372. void obs_transition_set_size(obs_source_t *transition,
  373. uint32_t cx, uint32_t cy)
  374. {
  375. if (!transition_valid(transition, "obs_transition_set_size"))
  376. return;
  377. transition->transition_cx = cx;
  378. transition->transition_cy = cy;
  379. }
  380. void obs_transition_get_size(const obs_source_t *transition,
  381. uint32_t *cx, uint32_t *cy)
  382. {
  383. if (!transition_valid(transition, "obs_transition_set_size")) {
  384. *cx = 0;
  385. *cy = 0;
  386. return;
  387. }
  388. *cx = transition->transition_cx;
  389. *cy = transition->transition_cy;
  390. }
  391. void obs_transition_save(obs_source_t *tr, obs_data_t *data)
  392. {
  393. obs_source_t *child;
  394. lock_transition(tr);
  395. child = transition_active(tr) ?
  396. tr->transition_sources[1] : tr->transition_sources[0];
  397. obs_data_set_string(data, "transition_source_a",
  398. child ? child->context.name : "");
  399. obs_data_set_int(data, "transition_alignment",
  400. tr->transition_alignment);
  401. obs_data_set_int(data, "transition_mode",
  402. (int64_t)tr->transition_mode);
  403. obs_data_set_int(data, "transition_scale_type",
  404. (int64_t)tr->transition_scale_type);
  405. obs_data_set_int(data, "transition_cx", tr->transition_cx);
  406. obs_data_set_int(data, "transition_cy", tr->transition_cy);
  407. unlock_transition(tr);
  408. }
  409. void obs_transition_load(obs_source_t *tr, obs_data_t *data)
  410. {
  411. const char *name = obs_data_get_string(data, "transition_source_a");
  412. int64_t alignment = obs_data_get_int(data, "transition_alignment");
  413. int64_t mode = obs_data_get_int(data, "transition_mode");
  414. int64_t scale_type = obs_data_get_int(data, "transition_scale_type");
  415. int64_t cx = obs_data_get_int(data, "transition_cx");
  416. int64_t cy = obs_data_get_int(data, "transition_cy");
  417. obs_source_t *source = NULL;
  418. if (name) {
  419. source = obs_get_source_by_name(name);
  420. if (source) {
  421. if (!obs_source_add_active_child(tr, source)) {
  422. blog(LOG_WARNING, "Cannot set transition '%s' "
  423. "to source '%s' due to "
  424. "infinite recursion",
  425. tr->context.name, name);
  426. obs_source_release(source);
  427. source = NULL;
  428. }
  429. } else {
  430. blog(LOG_WARNING, "Failed to find source '%s' for "
  431. "transition '%s'",
  432. name, tr->context.name);
  433. }
  434. }
  435. lock_transition(tr);
  436. tr->transition_sources[0] = source;
  437. tr->transition_source_active[0] = true;
  438. tr->transition_alignment = (uint32_t)alignment;
  439. tr->transition_mode = (enum obs_transition_mode)mode;
  440. tr->transition_scale_type = (enum obs_transition_scale_type)scale_type;
  441. tr->transition_cx = (uint32_t)cx;
  442. tr->transition_cy = (uint32_t)cy;
  443. unlock_transition(tr);
  444. recalculate_transition_size(tr);
  445. recalculate_transition_matrices(tr);
  446. }
  447. struct transition_state {
  448. obs_source_t *s[2];
  449. bool transitioning_video;
  450. bool transitioning_audio;
  451. };
  452. static inline void copy_transition_state(obs_source_t *transition,
  453. struct transition_state *state)
  454. {
  455. state->s[0] = transition->transition_sources[0];
  456. state->s[1] = transition->transition_sources[1];
  457. obs_source_addref(state->s[0]);
  458. obs_source_addref(state->s[1]);
  459. state->transitioning_video = transition->transitioning_video;
  460. state->transitioning_audio = transition->transitioning_audio;
  461. }
  462. static inline void enum_child(obs_source_t *tr, obs_source_t *child,
  463. obs_source_enum_proc_t enum_callback, void *param)
  464. {
  465. if (!child)
  466. return;
  467. if (child->context.data && child->info.enum_active_sources)
  468. child->info.enum_active_sources(child->context.data,
  469. enum_callback, param);
  470. enum_callback(tr, child, param);
  471. }
  472. void obs_transition_enum_sources(obs_source_t *transition,
  473. obs_source_enum_proc_t cb, void *param)
  474. {
  475. lock_transition(transition);
  476. for (size_t i = 0; i < 2; i++) {
  477. if (transition->transition_sources[i])
  478. cb(transition, transition->transition_sources[i], param);
  479. }
  480. unlock_transition(transition);
  481. }
  482. static inline void render_child(obs_source_t *transition,
  483. obs_source_t *child, size_t idx)
  484. {
  485. uint32_t cx = transition->transition_actual_cx;
  486. uint32_t cy = transition->transition_actual_cy;
  487. struct vec4 blank;
  488. if (!child)
  489. return;
  490. if (gs_texrender_begin(transition->transition_texrender[idx], cx, cy)) {
  491. vec4_zero(&blank);
  492. gs_clear(GS_CLEAR_COLOR, &blank, 0.0f, 0);
  493. gs_matrix_push();
  494. gs_matrix_mul(&transition->transition_matrices[idx]);
  495. obs_source_video_render(child);
  496. gs_matrix_pop();
  497. gs_texrender_end(transition->transition_texrender[idx]);
  498. }
  499. }
  500. static void obs_transition_stop(obs_source_t *transition)
  501. {
  502. obs_source_t *old_child = transition->transition_sources[0];
  503. if (old_child && transition->transition_source_active[0])
  504. obs_source_remove_active_child(transition, old_child);
  505. obs_source_release(old_child);
  506. transition->transition_source_active[0] = true;
  507. transition->transition_source_active[1] = false;
  508. transition->transition_sources[0] = transition->transition_sources[1];
  509. transition->transition_sources[1] = NULL;
  510. }
  511. void obs_transition_video_render(obs_source_t *transition,
  512. obs_transition_video_render_callback_t callback)
  513. {
  514. struct transition_state state;
  515. bool locked = false;
  516. bool stopped = false;
  517. bool video_stopped = false;
  518. float t;
  519. if (!transition_valid(transition, "obs_transition_video_render"))
  520. return;
  521. t = get_video_time(transition);
  522. lock_transition(transition);
  523. if (t >= 1.0f && transition->transitioning_video) {
  524. transition->transitioning_video = false;
  525. video_stopped = true;
  526. if (!transition->transitioning_audio) {
  527. obs_transition_stop(transition);
  528. stopped = true;
  529. }
  530. }
  531. copy_transition_state(transition, &state);
  532. unlock_transition(transition);
  533. if (state.transitioning_video)
  534. locked = trylock_textures(transition) == 0;
  535. if (state.transitioning_video && locked && callback) {
  536. gs_texture_t *tex[2];
  537. for (size_t i = 0; i < 2; i++) {
  538. if (state.s[i]) {
  539. render_child(transition, state.s[i], i);
  540. tex[i] = get_texture(transition, i);
  541. if (!tex[i])
  542. tex[i] = obs->video.transparent_texture;
  543. } else {
  544. tex[i] = obs->video.transparent_texture;
  545. }
  546. }
  547. callback(transition->context.data, tex[0], tex[1], t,
  548. transition->transition_actual_cx,
  549. transition->transition_actual_cy);
  550. } else if (state.transitioning_audio) {
  551. if (state.s[1])
  552. obs_source_video_render(state.s[1]);
  553. } else {
  554. if (state.s[0])
  555. obs_source_video_render(state.s[0]);
  556. }
  557. if (locked)
  558. unlock_textures(transition);
  559. obs_source_release(state.s[0]);
  560. obs_source_release(state.s[1]);
  561. if (video_stopped)
  562. obs_source_dosignal(transition, "source_transition_video_stop",
  563. "transition_video_stop");
  564. if (stopped)
  565. obs_source_dosignal(transition, "source_transition_stop",
  566. "transition_stop");
  567. }
  568. static inline float get_sample_time(obs_source_t *transition,
  569. size_t sample_rate, size_t sample, uint64_t ts)
  570. {
  571. uint64_t sample_ts_offset = (uint64_t)sample * 1000000000ULL /
  572. (uint64_t)sample_rate;
  573. uint64_t i_ts = ts + sample_ts_offset;
  574. return calc_time(transition, i_ts);
  575. }
  576. static inline void mix_child(obs_source_t *transition, float *out, float *in,
  577. size_t count, size_t sample_rate, uint64_t ts,
  578. obs_transition_audio_mix_callback_t mix)
  579. {
  580. void *context_data = transition->context.data;
  581. for (size_t i = 0; i < count; i++) {
  582. float t = get_sample_time(transition, sample_rate, i, ts);
  583. out[i] += in[i] * mix(context_data, t);
  584. }
  585. }
  586. static void process_audio(obs_source_t *transition, obs_source_t *child,
  587. struct obs_source_audio_mix *audio, uint64_t min_ts,
  588. uint32_t mixers, size_t channels, size_t sample_rate,
  589. obs_transition_audio_mix_callback_t mix)
  590. {
  591. bool valid = child && !child->audio_pending;
  592. struct obs_source_audio_mix child_audio;
  593. uint64_t ts;
  594. size_t pos;
  595. if (!valid)
  596. return;
  597. ts = child->audio_ts;
  598. obs_source_get_audio_mix(child, &child_audio);
  599. pos = (size_t)ns_to_audio_frames(sample_rate, ts - min_ts);
  600. if (pos > AUDIO_OUTPUT_FRAMES)
  601. return;
  602. for (size_t mix_idx = 0; mix_idx < MAX_AUDIO_MIXES; mix_idx++) {
  603. struct audio_output_data *output = &audio->output[mix_idx];
  604. struct audio_output_data *input = &child_audio.output[mix_idx];
  605. if ((mixers & (1 << mix_idx)) == 0)
  606. continue;
  607. for (size_t ch = 0; ch < channels; ch++) {
  608. float *out = output->data[ch];
  609. float *in = input->data[ch];
  610. mix_child(transition, out + pos, in,
  611. AUDIO_OUTPUT_FRAMES - pos,
  612. sample_rate, ts, mix);
  613. }
  614. }
  615. }
  616. static inline uint64_t calc_min_ts(obs_source_t *sources[2])
  617. {
  618. uint64_t min_ts = 0;
  619. for (size_t i = 0; i < 2; i++) {
  620. if (sources[i] && !sources[i]->audio_pending) {
  621. if (!min_ts || sources[i]->audio_ts < min_ts)
  622. min_ts = sources[i]->audio_ts;
  623. }
  624. }
  625. return min_ts;
  626. }
  627. #define TOTAL_AUDIO_SIZE \
  628. (MAX_AUDIO_MIXES * MAX_AUDIO_CHANNELS * \
  629. AUDIO_OUTPUT_FRAMES * sizeof(float))
  630. static inline bool stop_audio(obs_source_t *transition)
  631. {
  632. transition->transitioning_audio = false;
  633. if (!transition->transitioning_video) {
  634. obs_transition_stop(transition);
  635. return true;
  636. }
  637. return false;
  638. }
  639. bool obs_transition_audio_render(obs_source_t *transition,
  640. uint64_t *ts_out, struct obs_source_audio_mix *audio,
  641. uint32_t mixers, size_t channels, size_t sample_rate,
  642. obs_transition_audio_mix_callback_t mix_a,
  643. obs_transition_audio_mix_callback_t mix_b)
  644. {
  645. obs_source_t *sources[2];
  646. struct transition_state state = {0};
  647. bool stopped = false;
  648. uint64_t min_ts;
  649. float t;
  650. if (!transition_valid(transition, "obs_transition_audio_render"))
  651. return false;
  652. lock_transition(transition);
  653. sources[0] = transition->transition_sources[0];
  654. sources[1] = transition->transition_sources[1];
  655. min_ts = calc_min_ts(sources);
  656. if (min_ts) {
  657. t = calc_time(transition, min_ts);
  658. if (t >= 1.0f && transition->transitioning_audio)
  659. stopped = stop_audio(transition);
  660. sources[0] = transition->transition_sources[0];
  661. sources[1] = transition->transition_sources[1];
  662. min_ts = calc_min_ts(sources);
  663. if (min_ts)
  664. copy_transition_state(transition, &state);
  665. } else if (transition->transitioning_audio) {
  666. stopped = stop_audio(transition);
  667. }
  668. unlock_transition(transition);
  669. if (min_ts) {
  670. if (state.transitioning_audio) {
  671. if (state.s[0])
  672. process_audio(transition, state.s[0], audio,
  673. min_ts, mixers, channels,
  674. sample_rate, mix_a);
  675. if (state.s[1])
  676. process_audio(transition, state.s[1], audio,
  677. min_ts, mixers, channels,
  678. sample_rate, mix_b);
  679. } else if (state.s[0]) {
  680. memcpy(audio->output[0].data[0],
  681. state.s[0]->audio_output_buf[0][0],
  682. TOTAL_AUDIO_SIZE);
  683. }
  684. obs_source_release(state.s[0]);
  685. obs_source_release(state.s[1]);
  686. }
  687. if (stopped)
  688. obs_source_dosignal(transition, "source_transition_stop",
  689. "transition_stop");
  690. *ts_out = min_ts;
  691. return !!min_ts;
  692. }
  693. void obs_transition_enable_fixed(obs_source_t *transition,
  694. bool enable, uint32_t duration)
  695. {
  696. if (!transition_valid(transition, "obs_transition_enable_fixed"))
  697. return;
  698. transition->transition_use_fixed_duration = enable;
  699. transition->transition_fixed_duration = duration;
  700. }
  701. bool obs_transition_fixed(obs_source_t *transition)
  702. {
  703. return transition_valid(transition, "obs_transition_fixed") ?
  704. transition->transition_use_fixed_duration : false;
  705. }
  706. static inline obs_source_t *copy_source_state(obs_source_t *tr_dest,
  707. obs_source_t *tr_source, size_t idx)
  708. {
  709. obs_source_t *old_child = tr_dest->transition_sources[idx];
  710. obs_source_t *new_child = tr_source->transition_sources[idx];
  711. bool active = tr_source->transition_source_active[idx];
  712. if (old_child && tr_dest->transition_source_active[idx])
  713. obs_source_remove_active_child(tr_dest, old_child);
  714. tr_dest->transition_sources[idx] = new_child;
  715. tr_dest->transition_source_active[idx] = active;
  716. if (active && new_child)
  717. obs_source_add_active_child(tr_dest, new_child);
  718. obs_source_addref(new_child);
  719. return old_child;
  720. }
  721. void obs_transition_swap_begin(obs_source_t *tr_dest, obs_source_t *tr_source)
  722. {
  723. obs_source_t *old_children[2];
  724. if (tr_dest == tr_source)
  725. return;
  726. lock_textures(tr_source);
  727. lock_textures(tr_dest);
  728. lock_transition(tr_source);
  729. lock_transition(tr_dest);
  730. for (size_t i = 0; i < 2; i++)
  731. old_children[i] = copy_source_state(tr_dest, tr_source, i);
  732. unlock_transition(tr_dest);
  733. unlock_transition(tr_source);
  734. for (size_t i = 0; i < 2; i++)
  735. obs_source_release(old_children[i]);
  736. }
  737. void obs_transition_swap_end(obs_source_t *tr_dest, obs_source_t *tr_source)
  738. {
  739. if (tr_dest == tr_source)
  740. return;
  741. obs_transition_clear(tr_source);
  742. for (size_t i = 0; i < 2; i++) {
  743. gs_texrender_t *dest = tr_dest->transition_texrender[i];
  744. gs_texrender_t *source = tr_source->transition_texrender[i];
  745. tr_dest->transition_texrender[i] = source;
  746. tr_source->transition_texrender[i] = dest;
  747. }
  748. unlock_textures(tr_dest);
  749. unlock_textures(tr_source);
  750. }