void obs_transition_set(obs_source_t *transition, obs_source_t *source)
{
obs_source_t *s[2];
bool active[2];
if (!transition_valid(transition, "obs_transition_clear"))
return;
obs_source_addref(source);
lock_transition(transition);
for (size_t i = 0; i < 2; i++) {
s[i] = transition->transition_sources[i];
active[i] = transition->transition_source_active[i];
transition->transition_sources[i] = NULL;
transition->transition_source_active[i] = false;
}
transition->transition_source_active[0] = true;
transition->transition_sources[0] = source;
transition->transitioning_video = false;
transition->transitioning_audio = false;
unlock_transition(transition);
for (size_t i = 0; i < 2; i++) {
if (s[i] && active[i])
obs_source_remove_active_child(transition, s[i]);
obs_source_release(s[i]);
}
if (source)
obs_source_add_active_child(transition, source);
}
static void set_source(obs_source_t *transition,
enum obs_transition_target target, obs_source_t *new_child,
bool (*callback)(obs_source_t *t, size_t idx, obs_source_t *c))
{
size_t idx = (size_t)target;
obs_source_t *old_child;
bool add_success = true;
bool already_active;
if (new_child)
obs_source_addref(new_child);
lock_transition(transition);
old_child = transition->transition_sources[idx];
if (new_child == old_child) {
unlock_transition(transition);
obs_source_release(new_child);
return;
}
already_active = transition->transition_source_active[idx];
if (already_active) {
if (new_child)
add_success = obs_source_add_active_child(transition,
new_child);
if (old_child && add_success)
obs_source_remove_active_child(transition, old_child);
}
if (callback && add_success)
add_success = callback(transition, idx, new_child);
transition->transition_sources[idx] = add_success ? new_child : NULL;
unlock_transition(transition);
if (add_success) {
if (transition->transition_cx == 0 ||
transition->transition_cy == 0) {
recalculate_transition_size(transition);
recalculate_transition_matrices(transition);
}
} else {
obs_source_release(new_child);
}
obs_source_release(old_child);
}
static bool activate_transition(obs_source_t *transition, size_t idx,
obs_source_t *child)
{
if (!transition->transition_source_active[idx]) {
if (!obs_source_add_active_child(transition, child))
return false;
transition->transition_source_active[idx] = true;
}
transition->transitioning_video = true;
transition->transitioning_audio = true;
return true;
}
static void stinger_transition_start(void *data)
{
struct stinger_info *s = data;
if (s->media_source) {
calldata_t cd = {0};
proc_handler_t *ph =
obs_source_get_proc_handler(s->media_source);
if (s->transitioning) {
proc_handler_call(ph, "restart", &cd);
return;
}
proc_handler_call(ph, "get_duration", &cd);
proc_handler_call(ph, "get_nb_frames", &cd);
s->duration_ns = (uint64_t)calldata_int(&cd, "duration");
s->duration_frames = (uint64_t)calldata_int(&cd, "num_frames");
if (s->transition_point_is_frame)
s->transition_point = (float)(
(long double)s->transition_point_frame /
(long double)s->duration_frames);
else
s->transition_point = (float)(
(long double)s->transition_point_ns /
(long double)s->duration_ns);
if (s->transition_point > 0.999f)
s->transition_point = 0.999f;
else if (s->transition_point < 0.001f)
s->transition_point = 0.001f;
s->transition_a_mul = (1.0f / s->transition_point);
s->transition_b_mul = (1.0f / (1.0f - s->transition_point));
obs_transition_enable_fixed(s->source, true,
(uint32_t)(s->duration_ns / 1000000));
calldata_free(&cd);
obs_source_add_active_child(s->source, s->media_source);
}
s->transitioning = true;
}
static inline obs_source_t *copy_source_state(obs_source_t *tr_dest,
obs_source_t *tr_source, size_t idx)
{
obs_source_t *old_child = tr_dest->transition_sources[idx];
obs_source_t *new_child = tr_source->transition_sources[idx];
bool active = tr_source->transition_source_active[idx];
if (old_child && tr_dest->transition_source_active[idx])
obs_source_remove_active_child(tr_dest, old_child);
tr_dest->transition_sources[idx] = new_child;
tr_dest->transition_source_active[idx] = active;
if (active && new_child)
obs_source_add_active_child(tr_dest, new_child);
obs_source_addref(new_child);
return old_child;
}
static inline bool activate_child(obs_source_t *transition, size_t idx)
{
bool success = true;
lock_transition(transition);
if (transition->transition_sources[idx] &&
!transition->transition_source_active[idx]) {
success = obs_source_add_active_child(transition,
transition->transition_sources[idx]);
if (success)
transition->transition_source_active[idx] = true;
}
unlock_transition(transition);
return success;
}
static void set_visibility(struct obs_scene_item *item, bool vis)
{
pthread_mutex_lock(&item->actions_mutex);
da_resize(item->audio_actions, 0);
if (os_atomic_load_long(&item->active_refs) > 0) {
if (!vis)
obs_source_remove_active_child(item->parent->source,
item->source);
} else if (vis) {
obs_source_add_active_child(item->parent->source, item->source);
}
os_atomic_set_long(&item->active_refs, vis ? 1 : 0);
item->visible = vis;
item->user_visible = vis;
pthread_mutex_unlock(&item->actions_mutex);
}
void obs_transition_load(obs_source_t *tr, obs_data_t *data)
{
const char *name = obs_data_get_string(data, "transition_source_a");
int64_t alignment = obs_data_get_int(data, "transition_alignment");
int64_t mode = obs_data_get_int(data, "transition_mode");
int64_t scale_type = obs_data_get_int(data, "transition_scale_type");
int64_t cx = obs_data_get_int(data, "transition_cx");
int64_t cy = obs_data_get_int(data, "transition_cy");
obs_source_t *source = NULL;
if (name) {
source = obs_get_source_by_name(name);
if (source) {
if (!obs_source_add_active_child(tr, source)) {
blog(LOG_WARNING, "Cannot set transition '%s' "
"to source '%s' due to "
"infinite recursion",
tr->context.name, name);
obs_source_release(source);
source = NULL;
}
} else {
blog(LOG_WARNING, "Failed to find source '%s' for "
"transition '%s'",
name, tr->context.name);
}
}
lock_transition(tr);
tr->transition_sources[0] = source;
tr->transition_source_active[0] = true;
tr->transition_alignment = (uint32_t)alignment;
tr->transition_mode = (enum obs_transition_mode)mode;
tr->transition_scale_type = (enum obs_transition_scale_type)scale_type;
tr->transition_cx = (uint32_t)cx;
tr->transition_cy = (uint32_t)cy;
unlock_transition(tr);
recalculate_transition_size(tr);
recalculate_transition_matrices(tr);
}
