obs-source-transition.c 27 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036
  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 inline uint32_t get_cx(obs_source_t *tr)
  84. {
  85. return tr->transition_cx ?
  86. tr->transition_cx : tr->transition_actual_cx;
  87. }
  88. static inline uint32_t get_cy(obs_source_t *tr)
  89. {
  90. return tr->transition_cy ?
  91. tr->transition_cy : tr->transition_actual_cy;
  92. }
  93. static void recalculate_transition_matrix(obs_source_t *tr, size_t idx)
  94. {
  95. obs_source_t *child;
  96. struct matrix4 mat;
  97. struct vec2 pos;
  98. struct vec2 scale;
  99. float tr_cx = (float)get_cx(tr);
  100. float tr_cy = (float)get_cy(tr);
  101. float source_cx;
  102. float source_cy;
  103. float tr_aspect = tr_cx / tr_cy;
  104. float source_aspect;
  105. enum obs_transition_scale_type scale_type = tr->transition_scale_type;
  106. lock_transition(tr);
  107. child = tr->transition_sources[idx];
  108. if (!child) {
  109. unlock_transition(tr);
  110. return;
  111. }
  112. source_cx = (float)obs_source_get_width(child);
  113. source_cy = (float)obs_source_get_height(child);
  114. unlock_transition(tr);
  115. if (source_cx == 0.0f || source_cy == 0.0f)
  116. return;
  117. source_aspect = source_cx / source_cy;
  118. if (scale_type == OBS_TRANSITION_SCALE_MAX_ONLY) {
  119. if (source_cx > tr_cx || source_cy > tr_cy) {
  120. scale_type = OBS_TRANSITION_SCALE_ASPECT;
  121. } else {
  122. scale.x = 1.0f;
  123. scale.y = 1.0f;
  124. }
  125. }
  126. if (scale_type == OBS_TRANSITION_SCALE_ASPECT) {
  127. bool use_width = tr_aspect < source_aspect;
  128. scale.x = scale.y = use_width ?
  129. tr_cx / source_cx :
  130. tr_cy / source_cy;
  131. } else if (scale_type == OBS_TRANSITION_SCALE_STRETCH) {
  132. scale.x = tr_cx / source_cx;
  133. scale.y = tr_cy / source_cy;
  134. }
  135. source_cx *= scale.x;
  136. source_cy *= scale.y;
  137. vec2_zero(&pos);
  138. add_alignment(&pos, tr->transition_alignment,
  139. (int)(tr_cx - source_cx),
  140. (int)(tr_cy - source_cy));
  141. matrix4_identity(&mat);
  142. matrix4_scale3f(&mat, &mat, scale.x, scale.y, 1.0f);
  143. matrix4_translate3f(&mat, &mat, pos.x, pos.y, 0.0f);
  144. matrix4_copy(&tr->transition_matrices[idx], &mat);
  145. }
  146. static inline void recalculate_transition_matrices(obs_source_t *transition)
  147. {
  148. recalculate_transition_matrix(transition, 0);
  149. recalculate_transition_matrix(transition, 1);
  150. }
  151. static void recalculate_transition_size(obs_source_t *transition)
  152. {
  153. uint32_t cx = 0, cy = 0;
  154. obs_source_t *child;
  155. lock_transition(transition);
  156. for (size_t i = 0; i < 2; i++) {
  157. child = transition->transition_sources[i];
  158. if (child) {
  159. uint32_t new_cx = obs_source_get_width(child);
  160. uint32_t new_cy = obs_source_get_height(child);
  161. if (new_cx > cx) cx = new_cx;
  162. if (new_cy > cy) cy = new_cy;
  163. }
  164. }
  165. unlock_transition(transition);
  166. transition->transition_actual_cx = cx;
  167. transition->transition_actual_cy = cy;
  168. }
  169. void obs_transition_tick(obs_source_t *transition)
  170. {
  171. recalculate_transition_size(transition);
  172. recalculate_transition_matrices(transition);
  173. if (trylock_textures(transition) == 0) {
  174. gs_texrender_reset(transition->transition_texrender[0]);
  175. gs_texrender_reset(transition->transition_texrender[1]);
  176. unlock_textures(transition);
  177. }
  178. }
  179. static void set_source(obs_source_t *transition,
  180. enum obs_transition_target target, obs_source_t *new_child,
  181. bool (*callback)(obs_source_t *t, size_t idx, obs_source_t *c))
  182. {
  183. size_t idx = (size_t)target;
  184. obs_source_t *old_child;
  185. bool add_success = true;
  186. bool already_active;
  187. if (new_child)
  188. obs_source_addref(new_child);
  189. lock_transition(transition);
  190. old_child = transition->transition_sources[idx];
  191. if (new_child == old_child) {
  192. unlock_transition(transition);
  193. obs_source_release(new_child);
  194. return;
  195. }
  196. already_active = transition->transition_source_active[idx];
  197. if (already_active) {
  198. if (new_child)
  199. add_success = obs_source_add_active_child(transition,
  200. new_child);
  201. if (old_child && add_success)
  202. obs_source_remove_active_child(transition, old_child);
  203. }
  204. if (callback && add_success)
  205. add_success = callback(transition, idx, new_child);
  206. transition->transition_sources[idx] = add_success ? new_child : NULL;
  207. unlock_transition(transition);
  208. if (add_success) {
  209. if (transition->transition_cx == 0 ||
  210. transition->transition_cy == 0) {
  211. recalculate_transition_size(transition);
  212. recalculate_transition_matrices(transition);
  213. }
  214. } else {
  215. obs_source_release(new_child);
  216. }
  217. obs_source_release(old_child);
  218. }
  219. obs_source_t *obs_transition_get_source(obs_source_t *transition,
  220. enum obs_transition_target target)
  221. {
  222. size_t idx = (size_t)target;
  223. obs_source_t *ret;
  224. if (!transition_valid(transition, "obs_transition_get_source"))
  225. return NULL;
  226. lock_transition(transition);
  227. ret = transition->transition_sources[idx];
  228. obs_source_addref(ret);
  229. unlock_transition(transition);
  230. return ret;
  231. }
  232. obs_source_t *obs_transition_get_active_source(obs_source_t *transition)
  233. {
  234. obs_source_t *ret;
  235. if (!transition_valid(transition, "obs_transition_get_source"))
  236. return NULL;
  237. lock_transition(transition);
  238. if (transition->transitioning_audio || transition->transitioning_video)
  239. ret = transition->transition_sources[1];
  240. else
  241. ret = transition->transition_sources[0];
  242. obs_source_addref(ret);
  243. unlock_transition(transition);
  244. return ret;
  245. }
  246. static inline bool activate_child(obs_source_t *transition, size_t idx)
  247. {
  248. bool success = true;
  249. lock_transition(transition);
  250. if (transition->transition_sources[idx] &&
  251. !transition->transition_source_active[idx]) {
  252. success = obs_source_add_active_child(transition,
  253. transition->transition_sources[idx]);
  254. if (success)
  255. transition->transition_source_active[idx] = true;
  256. }
  257. unlock_transition(transition);
  258. return success;
  259. }
  260. static bool activate_transition(obs_source_t *transition, size_t idx,
  261. obs_source_t *child)
  262. {
  263. if (!transition->transition_source_active[idx]) {
  264. if (!obs_source_add_active_child(transition, child))
  265. return false;
  266. transition->transition_source_active[idx] = true;
  267. }
  268. transition->transitioning_video = true;
  269. transition->transitioning_audio = true;
  270. return true;
  271. }
  272. static inline bool transition_active(obs_source_t *transition)
  273. {
  274. return transition->transitioning_audio ||
  275. transition->transitioning_video;
  276. }
  277. bool obs_transition_start(obs_source_t *transition,
  278. enum obs_transition_mode mode, uint32_t duration_ms,
  279. obs_source_t *dest)
  280. {
  281. bool active;
  282. bool same_as_source;
  283. bool same_as_dest;
  284. if (!transition_valid(transition, "obs_transition_start"))
  285. return false;
  286. lock_transition(transition);
  287. same_as_source = dest == transition->transition_sources[0];
  288. same_as_dest = dest == transition->transition_sources[1];
  289. active = transition_active(transition);
  290. unlock_transition(transition);
  291. if (same_as_source && !active)
  292. return false;
  293. if (transition->info.transition_start)
  294. transition->info.transition_start(transition->context.data);
  295. if (transition->transition_use_fixed_duration)
  296. duration_ms = transition->transition_fixed_duration;
  297. if (!active || (!same_as_dest && !same_as_source)) {
  298. transition->transition_start_time = os_gettime_ns();
  299. transition->transition_duration =
  300. (uint64_t)duration_ms * 1000000ULL;
  301. }
  302. set_source(transition, OBS_TRANSITION_SOURCE_B, dest,
  303. activate_transition);
  304. if (dest == NULL && same_as_dest && !same_as_source) {
  305. transition->transitioning_video = true;
  306. transition->transitioning_audio = true;
  307. }
  308. obs_source_dosignal(transition, "source_transition_start",
  309. "transition_start");
  310. recalculate_transition_size(transition);
  311. recalculate_transition_matrices(transition);
  312. /* TODO: Add mode */
  313. UNUSED_PARAMETER(mode);
  314. return true;
  315. }
  316. void obs_transition_set(obs_source_t *transition, obs_source_t *source)
  317. {
  318. obs_source_t *s[2];
  319. bool active[2];
  320. if (!transition_valid(transition, "obs_transition_clear"))
  321. return;
  322. obs_source_addref(source);
  323. lock_transition(transition);
  324. for (size_t i = 0; i < 2; i++) {
  325. s[i] = transition->transition_sources[i];
  326. active[i] = transition->transition_source_active[i];
  327. transition->transition_sources[i] = NULL;
  328. transition->transition_source_active[i] = false;
  329. }
  330. transition->transition_source_active[0] = true;
  331. transition->transition_sources[0] = source;
  332. transition->transitioning_video = false;
  333. transition->transitioning_audio = false;
  334. unlock_transition(transition);
  335. for (size_t i = 0; i < 2; i++) {
  336. if (s[i] && active[i])
  337. obs_source_remove_active_child(transition, s[i]);
  338. obs_source_release(s[i]);
  339. }
  340. if (source)
  341. obs_source_add_active_child(transition, source);
  342. }
  343. static float calc_time(obs_source_t *transition, uint64_t ts)
  344. {
  345. uint64_t end;
  346. if (ts <= transition->transition_start_time)
  347. return 0.0f;
  348. end = transition->transition_duration;
  349. ts -= transition->transition_start_time;
  350. if (ts >= end || end == 0)
  351. return 1.0f;
  352. return (float)((long double)ts / (long double)end);
  353. }
  354. static inline float get_video_time(obs_source_t *transition)
  355. {
  356. uint64_t ts = obs->video.video_time;
  357. return calc_time(transition, ts);
  358. }
  359. float obs_transition_get_time(obs_source_t *transition)
  360. {
  361. return get_video_time(transition);
  362. }
  363. static inline gs_texture_t *get_texture(obs_source_t *transition,
  364. enum obs_transition_target target)
  365. {
  366. size_t idx = (size_t)target;
  367. return gs_texrender_get_texture(transition->transition_texrender[idx]);
  368. }
  369. void obs_transition_set_scale_type(obs_source_t *transition,
  370. enum obs_transition_scale_type type)
  371. {
  372. if (!transition_valid(transition, "obs_transition_set_scale_type"))
  373. return;
  374. transition->transition_scale_type = type;
  375. }
  376. enum obs_transition_scale_type obs_transition_get_scale_type(
  377. const obs_source_t *transition)
  378. {
  379. return transition_valid(transition, "obs_transition_get_scale_type") ?
  380. transition->transition_scale_type :
  381. OBS_TRANSITION_SCALE_MAX_ONLY;
  382. }
  383. void obs_transition_set_alignment(obs_source_t *transition, uint32_t alignment)
  384. {
  385. if (!transition_valid(transition, "obs_transition_set_alignment"))
  386. return;
  387. transition->transition_alignment = alignment;
  388. }
  389. uint32_t obs_transition_get_alignment(const obs_source_t *transition)
  390. {
  391. return transition_valid(transition, "obs_transition_get_alignment") ?
  392. transition->transition_alignment : 0;
  393. }
  394. void obs_transition_set_size(obs_source_t *transition,
  395. uint32_t cx, uint32_t cy)
  396. {
  397. if (!transition_valid(transition, "obs_transition_set_size"))
  398. return;
  399. transition->transition_cx = cx;
  400. transition->transition_cy = cy;
  401. }
  402. void obs_transition_get_size(const obs_source_t *transition,
  403. uint32_t *cx, uint32_t *cy)
  404. {
  405. if (!transition_valid(transition, "obs_transition_set_size")) {
  406. *cx = 0;
  407. *cy = 0;
  408. return;
  409. }
  410. *cx = transition->transition_cx;
  411. *cy = transition->transition_cy;
  412. }
  413. void obs_transition_save(obs_source_t *tr, obs_data_t *data)
  414. {
  415. obs_source_t *child;
  416. lock_transition(tr);
  417. child = transition_active(tr) ?
  418. tr->transition_sources[1] : tr->transition_sources[0];
  419. obs_data_set_string(data, "transition_source_a",
  420. child ? child->context.name : "");
  421. obs_data_set_int(data, "transition_alignment",
  422. tr->transition_alignment);
  423. obs_data_set_int(data, "transition_mode",
  424. (int64_t)tr->transition_mode);
  425. obs_data_set_int(data, "transition_scale_type",
  426. (int64_t)tr->transition_scale_type);
  427. obs_data_set_int(data, "transition_cx", tr->transition_cx);
  428. obs_data_set_int(data, "transition_cy", tr->transition_cy);
  429. unlock_transition(tr);
  430. }
  431. void obs_transition_load(obs_source_t *tr, obs_data_t *data)
  432. {
  433. const char *name = obs_data_get_string(data, "transition_source_a");
  434. int64_t alignment = obs_data_get_int(data, "transition_alignment");
  435. int64_t mode = obs_data_get_int(data, "transition_mode");
  436. int64_t scale_type = obs_data_get_int(data, "transition_scale_type");
  437. int64_t cx = obs_data_get_int(data, "transition_cx");
  438. int64_t cy = obs_data_get_int(data, "transition_cy");
  439. obs_source_t *source = NULL;
  440. if (name) {
  441. source = obs_get_source_by_name(name);
  442. if (source) {
  443. if (!obs_source_add_active_child(tr, source)) {
  444. blog(LOG_WARNING, "Cannot set transition '%s' "
  445. "to source '%s' due to "
  446. "infinite recursion",
  447. tr->context.name, name);
  448. obs_source_release(source);
  449. source = NULL;
  450. }
  451. } else {
  452. blog(LOG_WARNING, "Failed to find source '%s' for "
  453. "transition '%s'",
  454. name, tr->context.name);
  455. }
  456. }
  457. lock_transition(tr);
  458. tr->transition_sources[0] = source;
  459. tr->transition_source_active[0] = true;
  460. tr->transition_alignment = (uint32_t)alignment;
  461. tr->transition_mode = (enum obs_transition_mode)mode;
  462. tr->transition_scale_type = (enum obs_transition_scale_type)scale_type;
  463. tr->transition_cx = (uint32_t)cx;
  464. tr->transition_cy = (uint32_t)cy;
  465. unlock_transition(tr);
  466. recalculate_transition_size(tr);
  467. recalculate_transition_matrices(tr);
  468. }
  469. struct transition_state {
  470. obs_source_t *s[2];
  471. bool transitioning_video;
  472. bool transitioning_audio;
  473. };
  474. static inline void copy_transition_state(obs_source_t *transition,
  475. struct transition_state *state)
  476. {
  477. state->s[0] = transition->transition_sources[0];
  478. state->s[1] = transition->transition_sources[1];
  479. obs_source_addref(state->s[0]);
  480. obs_source_addref(state->s[1]);
  481. state->transitioning_video = transition->transitioning_video;
  482. state->transitioning_audio = transition->transitioning_audio;
  483. }
  484. static inline void enum_child(obs_source_t *tr, obs_source_t *child,
  485. obs_source_enum_proc_t enum_callback, void *param)
  486. {
  487. if (!child)
  488. return;
  489. if (child->context.data && child->info.enum_active_sources)
  490. child->info.enum_active_sources(child->context.data,
  491. enum_callback, param);
  492. enum_callback(tr, child, param);
  493. }
  494. void obs_transition_enum_sources(obs_source_t *transition,
  495. obs_source_enum_proc_t cb, void *param)
  496. {
  497. lock_transition(transition);
  498. for (size_t i = 0; i < 2; i++) {
  499. if (transition->transition_sources[i])
  500. cb(transition, transition->transition_sources[i], param);
  501. }
  502. unlock_transition(transition);
  503. }
  504. static inline void render_child(obs_source_t *transition,
  505. obs_source_t *child, size_t idx)
  506. {
  507. uint32_t cx = get_cx(transition);
  508. uint32_t cy = get_cy(transition);
  509. struct vec4 blank;
  510. if (!child)
  511. return;
  512. if (gs_texrender_begin(transition->transition_texrender[idx], cx, cy)) {
  513. vec4_zero(&blank);
  514. gs_clear(GS_CLEAR_COLOR, &blank, 0.0f, 0);
  515. gs_ortho(0.0f, (float)cx, 0.0f, (float)cy, -100.0f, 100.0f);
  516. gs_matrix_push();
  517. gs_matrix_mul(&transition->transition_matrices[idx]);
  518. obs_source_video_render(child);
  519. gs_matrix_pop();
  520. gs_texrender_end(transition->transition_texrender[idx]);
  521. }
  522. }
  523. static void obs_transition_stop(obs_source_t *transition)
  524. {
  525. obs_source_t *old_child = transition->transition_sources[0];
  526. if (old_child && transition->transition_source_active[0])
  527. obs_source_remove_active_child(transition, old_child);
  528. obs_source_release(old_child);
  529. transition->transition_source_active[0] = true;
  530. transition->transition_source_active[1] = false;
  531. transition->transition_sources[0] = transition->transition_sources[1];
  532. transition->transition_sources[1] = NULL;
  533. }
  534. static inline void handle_stop(obs_source_t *transition)
  535. {
  536. if (transition->info.transition_stop)
  537. transition->info.transition_stop(transition->context.data);
  538. obs_source_dosignal(transition, "source_transition_stop",
  539. "transition_stop");
  540. }
  541. void obs_transition_video_render(obs_source_t *transition,
  542. obs_transition_video_render_callback_t callback)
  543. {
  544. struct transition_state state;
  545. struct matrix4 matrices[2];
  546. bool locked = false;
  547. bool stopped = false;
  548. bool video_stopped = false;
  549. float t;
  550. if (!transition_valid(transition, "obs_transition_video_render"))
  551. return;
  552. t = get_video_time(transition);
  553. lock_transition(transition);
  554. if (t >= 1.0f && transition->transitioning_video) {
  555. transition->transitioning_video = false;
  556. video_stopped = true;
  557. if (!transition->transitioning_audio) {
  558. obs_transition_stop(transition);
  559. stopped = true;
  560. }
  561. }
  562. copy_transition_state(transition, &state);
  563. matrices[0] = transition->transition_matrices[0];
  564. matrices[1] = transition->transition_matrices[1];
  565. unlock_transition(transition);
  566. if (state.transitioning_video)
  567. locked = trylock_textures(transition) == 0;
  568. if (state.transitioning_video && locked && callback) {
  569. gs_texture_t *tex[2];
  570. uint32_t cx;
  571. uint32_t cy;
  572. for (size_t i = 0; i < 2; i++) {
  573. if (state.s[i]) {
  574. render_child(transition, state.s[i], i);
  575. tex[i] = get_texture(transition, i);
  576. if (!tex[i])
  577. tex[i] = obs->video.transparent_texture;
  578. } else {
  579. tex[i] = obs->video.transparent_texture;
  580. }
  581. }
  582. cx = get_cx(transition);
  583. cy = get_cy(transition);
  584. if (cx && cy)
  585. callback(transition->context.data, tex[0], tex[1], t,
  586. cx, cy);
  587. } else if (state.transitioning_audio) {
  588. if (state.s[1]) {
  589. gs_matrix_push();
  590. gs_matrix_mul(&matrices[1]);
  591. obs_source_video_render(state.s[1]);
  592. gs_matrix_pop();
  593. }
  594. } else {
  595. if (state.s[0]) {
  596. gs_matrix_push();
  597. gs_matrix_mul(&matrices[0]);
  598. obs_source_video_render(state.s[0]);
  599. gs_matrix_pop();
  600. }
  601. }
  602. if (locked)
  603. unlock_textures(transition);
  604. obs_source_release(state.s[0]);
  605. obs_source_release(state.s[1]);
  606. if (video_stopped)
  607. obs_source_dosignal(transition, "source_transition_video_stop",
  608. "transition_video_stop");
  609. if (stopped)
  610. handle_stop(transition);
  611. }
  612. bool obs_transition_video_render_direct(obs_source_t *transition,
  613. enum obs_transition_target target)
  614. {
  615. struct transition_state state;
  616. struct matrix4 matrices[2];
  617. bool stopped = false;
  618. bool video_stopped = false;
  619. bool render_b = target == OBS_TRANSITION_SOURCE_B;
  620. bool transitioning;
  621. float t;
  622. if (!transition_valid(transition, "obs_transition_video_render"))
  623. return false;
  624. t = get_video_time(transition);
  625. lock_transition(transition);
  626. if (t >= 1.0f && transition->transitioning_video) {
  627. transition->transitioning_video = false;
  628. video_stopped = true;
  629. if (!transition->transitioning_audio) {
  630. obs_transition_stop(transition);
  631. stopped = true;
  632. }
  633. }
  634. copy_transition_state(transition, &state);
  635. transitioning = state.transitioning_audio || state.transitioning_video;
  636. matrices[0] = transition->transition_matrices[0];
  637. matrices[1] = transition->transition_matrices[1];
  638. unlock_transition(transition);
  639. int idx = (transitioning && render_b) ? 1 : 0;
  640. if (state.s[idx]) {
  641. gs_matrix_push();
  642. gs_matrix_mul(&matrices[idx]);
  643. obs_source_video_render(state.s[idx]);
  644. gs_matrix_pop();
  645. }
  646. obs_source_release(state.s[0]);
  647. obs_source_release(state.s[1]);
  648. if (video_stopped)
  649. obs_source_dosignal(transition, "source_transition_video_stop",
  650. "transition_video_stop");
  651. if (stopped)
  652. handle_stop(transition);
  653. return transitioning;
  654. }
  655. static inline float get_sample_time(obs_source_t *transition,
  656. size_t sample_rate, size_t sample, uint64_t ts)
  657. {
  658. uint64_t sample_ts_offset = (uint64_t)sample * 1000000000ULL /
  659. (uint64_t)sample_rate;
  660. uint64_t i_ts = ts + sample_ts_offset;
  661. return calc_time(transition, i_ts);
  662. }
  663. static inline void mix_child(obs_source_t *transition, float *out, float *in,
  664. size_t count, size_t sample_rate, uint64_t ts,
  665. obs_transition_audio_mix_callback_t mix)
  666. {
  667. void *context_data = transition->context.data;
  668. for (size_t i = 0; i < count; i++) {
  669. float t = get_sample_time(transition, sample_rate, i, ts);
  670. out[i] += in[i] * mix(context_data, t);
  671. }
  672. }
  673. static void process_audio(obs_source_t *transition, obs_source_t *child,
  674. struct obs_source_audio_mix *audio, uint64_t min_ts,
  675. uint32_t mixers, size_t channels, size_t sample_rate,
  676. obs_transition_audio_mix_callback_t mix)
  677. {
  678. bool valid = child && !child->audio_pending;
  679. struct obs_source_audio_mix child_audio;
  680. uint64_t ts;
  681. size_t pos;
  682. if (!valid)
  683. return;
  684. ts = child->audio_ts;
  685. obs_source_get_audio_mix(child, &child_audio);
  686. pos = (size_t)ns_to_audio_frames(sample_rate, ts - min_ts);
  687. if (pos > AUDIO_OUTPUT_FRAMES)
  688. return;
  689. for (size_t mix_idx = 0; mix_idx < MAX_AUDIO_MIXES; mix_idx++) {
  690. struct audio_output_data *output = &audio->output[mix_idx];
  691. struct audio_output_data *input = &child_audio.output[mix_idx];
  692. if ((mixers & (1 << mix_idx)) == 0)
  693. continue;
  694. for (size_t ch = 0; ch < channels; ch++) {
  695. float *out = output->data[ch];
  696. float *in = input->data[ch];
  697. mix_child(transition, out + pos, in,
  698. AUDIO_OUTPUT_FRAMES - pos,
  699. sample_rate, ts, mix);
  700. }
  701. }
  702. }
  703. static inline uint64_t calc_min_ts(obs_source_t *sources[2])
  704. {
  705. uint64_t min_ts = 0;
  706. for (size_t i = 0; i < 2; i++) {
  707. if (sources[i] && !sources[i]->audio_pending) {
  708. if (!min_ts || sources[i]->audio_ts < min_ts)
  709. min_ts = sources[i]->audio_ts;
  710. }
  711. }
  712. return min_ts;
  713. }
  714. static inline bool stop_audio(obs_source_t *transition)
  715. {
  716. transition->transitioning_audio = false;
  717. if (!transition->transitioning_video) {
  718. obs_transition_stop(transition);
  719. return true;
  720. }
  721. return false;
  722. }
  723. bool obs_transition_audio_render(obs_source_t *transition,
  724. uint64_t *ts_out, struct obs_source_audio_mix *audio,
  725. uint32_t mixers, size_t channels, size_t sample_rate,
  726. obs_transition_audio_mix_callback_t mix_a,
  727. obs_transition_audio_mix_callback_t mix_b)
  728. {
  729. obs_source_t *sources[2];
  730. struct transition_state state = {0};
  731. bool stopped = false;
  732. uint64_t min_ts;
  733. float t;
  734. if (!transition_valid(transition, "obs_transition_audio_render"))
  735. return false;
  736. lock_transition(transition);
  737. sources[0] = transition->transition_sources[0];
  738. sources[1] = transition->transition_sources[1];
  739. min_ts = calc_min_ts(sources);
  740. if (min_ts) {
  741. t = calc_time(transition, min_ts);
  742. if (t >= 1.0f && transition->transitioning_audio)
  743. stopped = stop_audio(transition);
  744. sources[0] = transition->transition_sources[0];
  745. sources[1] = transition->transition_sources[1];
  746. min_ts = calc_min_ts(sources);
  747. if (min_ts)
  748. copy_transition_state(transition, &state);
  749. } else if (!transition->transitioning_video &&
  750. transition->transitioning_audio) {
  751. stopped = stop_audio(transition);
  752. }
  753. unlock_transition(transition);
  754. if (min_ts) {
  755. if (state.transitioning_audio) {
  756. if (state.s[0])
  757. process_audio(transition, state.s[0], audio,
  758. min_ts, mixers, channels,
  759. sample_rate, mix_a);
  760. if (state.s[1])
  761. process_audio(transition, state.s[1], audio,
  762. min_ts, mixers, channels,
  763. sample_rate, mix_b);
  764. } else if (state.s[0]) {
  765. memcpy(audio->output[0].data[0],
  766. state.s[0]->audio_output_buf[0][0],
  767. TOTAL_AUDIO_SIZE);
  768. }
  769. obs_source_release(state.s[0]);
  770. obs_source_release(state.s[1]);
  771. }
  772. if (stopped)
  773. handle_stop(transition);
  774. *ts_out = min_ts;
  775. return !!min_ts;
  776. }
  777. void obs_transition_enable_fixed(obs_source_t *transition,
  778. bool enable, uint32_t duration)
  779. {
  780. if (!transition_valid(transition, "obs_transition_enable_fixed"))
  781. return;
  782. transition->transition_use_fixed_duration = enable;
  783. transition->transition_fixed_duration = duration;
  784. }
  785. bool obs_transition_fixed(obs_source_t *transition)
  786. {
  787. return transition_valid(transition, "obs_transition_fixed") ?
  788. transition->transition_use_fixed_duration : false;
  789. }
  790. static inline obs_source_t *copy_source_state(obs_source_t *tr_dest,
  791. obs_source_t *tr_source, size_t idx)
  792. {
  793. obs_source_t *old_child = tr_dest->transition_sources[idx];
  794. obs_source_t *new_child = tr_source->transition_sources[idx];
  795. bool active = tr_source->transition_source_active[idx];
  796. if (old_child && tr_dest->transition_source_active[idx])
  797. obs_source_remove_active_child(tr_dest, old_child);
  798. tr_dest->transition_sources[idx] = new_child;
  799. tr_dest->transition_source_active[idx] = active;
  800. if (active && new_child)
  801. obs_source_add_active_child(tr_dest, new_child);
  802. obs_source_addref(new_child);
  803. return old_child;
  804. }
  805. void obs_transition_swap_begin(obs_source_t *tr_dest, obs_source_t *tr_source)
  806. {
  807. obs_source_t *old_children[2];
  808. if (tr_dest == tr_source)
  809. return;
  810. lock_textures(tr_source);
  811. lock_textures(tr_dest);
  812. lock_transition(tr_source);
  813. lock_transition(tr_dest);
  814. for (size_t i = 0; i < 2; i++)
  815. old_children[i] = copy_source_state(tr_dest, tr_source, i);
  816. unlock_transition(tr_dest);
  817. unlock_transition(tr_source);
  818. for (size_t i = 0; i < 2; i++)
  819. obs_source_release(old_children[i]);
  820. }
  821. void obs_transition_swap_end(obs_source_t *tr_dest, obs_source_t *tr_source)
  822. {
  823. if (tr_dest == tr_source)
  824. return;
  825. obs_transition_clear(tr_source);
  826. for (size_t i = 0; i < 2; i++) {
  827. gs_texrender_t *dest = tr_dest->transition_texrender[i];
  828. gs_texrender_t *source = tr_source->transition_texrender[i];
  829. tr_dest->transition_texrender[i] = source;
  830. tr_source->transition_texrender[i] = dest;
  831. }
  832. unlock_textures(tr_dest);
  833. unlock_textures(tr_source);
  834. }