obs-studio/libobs/obs-source-transition.c

1041 lines
27 KiB
C

/******************************************************************************
Copyright (C) 2013-2014 by Hugh Bailey <obs.jim@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#include "obs-internal.h"
#define lock_transition(transition) \
pthread_mutex_lock(&transition->transition_mutex);
#define unlock_transition(transition) \
pthread_mutex_unlock(&transition->transition_mutex);
#define trylock_textures(transition) \
pthread_mutex_trylock(&transition->transition_tex_mutex)
#define lock_textures(transition) \
pthread_mutex_lock(&transition->transition_tex_mutex)
#define unlock_textures(transition) \
pthread_mutex_unlock(&transition->transition_tex_mutex)
static inline bool transition_valid(const obs_source_t *transition,
const char *func)
{
if (!obs_ptr_valid(transition, func))
return false;
else if (transition->info.type != OBS_SOURCE_TYPE_TRANSITION)
return false;
return true;
}
bool obs_transition_init(obs_source_t *transition)
{
pthread_mutex_init_value(&transition->transition_mutex);
pthread_mutex_init_value(&transition->transition_tex_mutex);
if (pthread_mutex_init(&transition->transition_mutex, NULL) != 0)
return false;
if (pthread_mutex_init(&transition->transition_tex_mutex, NULL) != 0)
return false;
transition->transition_alignment = OBS_ALIGN_LEFT | OBS_ALIGN_TOP;
transition->transition_texrender[0] =
gs_texrender_create(GS_RGBA, GS_ZS_NONE);
transition->transition_texrender[1] =
gs_texrender_create(GS_RGBA, GS_ZS_NONE);
transition->transition_source_active[0] = true;
return transition->transition_texrender[0] != NULL &&
transition->transition_texrender[1] != NULL;
}
void obs_transition_free(obs_source_t *transition)
{
pthread_mutex_destroy(&transition->transition_mutex);
pthread_mutex_destroy(&transition->transition_tex_mutex);
gs_enter_context(obs->video.graphics);
gs_texrender_destroy(transition->transition_texrender[0]);
gs_texrender_destroy(transition->transition_texrender[1]);
gs_leave_context();
}
void obs_transition_clear(obs_source_t *transition)
{
obs_source_t *s[2];
bool active[2];
if (!transition_valid(transition, "obs_transition_clear"))
return;
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->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]);
}
}
void add_alignment(struct vec2 *v, uint32_t align, int cx, int cy);
static inline uint32_t get_cx(obs_source_t *tr)
{
return tr->transition_cx ?
tr->transition_cx : tr->transition_actual_cx;
}
static inline uint32_t get_cy(obs_source_t *tr)
{
return tr->transition_cy ?
tr->transition_cy : tr->transition_actual_cy;
}
static void recalculate_transition_matrix(obs_source_t *tr, size_t idx)
{
obs_source_t *child;
struct matrix4 mat;
struct vec2 pos;
struct vec2 scale;
float tr_cx = (float)get_cx(tr);
float tr_cy = (float)get_cy(tr);
float source_cx;
float source_cy;
float tr_aspect = tr_cx / tr_cy;
float source_aspect;
enum obs_transition_scale_type scale_type = tr->transition_scale_type;
lock_transition(tr);
child = tr->transition_sources[idx];
if (!child) {
unlock_transition(tr);
return;
}
source_cx = (float)obs_source_get_width(child);
source_cy = (float)obs_source_get_height(child);
unlock_transition(tr);
if (source_cx == 0.0f || source_cy == 0.0f)
return;
source_aspect = source_cx / source_cy;
if (scale_type == OBS_TRANSITION_SCALE_MAX_ONLY) {
if (source_cx > tr_cx || source_cy > tr_cy) {
scale_type = OBS_TRANSITION_SCALE_ASPECT;
} else {
scale.x = 1.0f;
scale.y = 1.0f;
}
}
if (scale_type == OBS_TRANSITION_SCALE_ASPECT) {
bool use_width = tr_aspect < source_aspect;
scale.x = scale.y = use_width ?
tr_cx / source_cx :
tr_cy / source_cy;
} else if (scale_type == OBS_TRANSITION_SCALE_STRETCH) {
scale.x = tr_cx / source_cx;
scale.y = tr_cy / source_cy;
}
source_cx *= scale.x;
source_cy *= scale.y;
vec2_zero(&pos);
add_alignment(&pos, tr->transition_alignment,
(int)(tr_cx - source_cx),
(int)(tr_cy - source_cy));
matrix4_identity(&mat);
matrix4_scale3f(&mat, &mat, scale.x, scale.y, 1.0f);
matrix4_translate3f(&mat, &mat, pos.x, pos.y, 0.0f);
matrix4_copy(&tr->transition_matrices[idx], &mat);
}
static inline void recalculate_transition_matrices(obs_source_t *transition)
{
recalculate_transition_matrix(transition, 0);
recalculate_transition_matrix(transition, 1);
}
static void recalculate_transition_size(obs_source_t *transition)
{
uint32_t cx = 0, cy = 0;
obs_source_t *child;
lock_transition(transition);
for (size_t i = 0; i < 2; i++) {
child = transition->transition_sources[i];
if (child) {
uint32_t new_cx = obs_source_get_width(child);
uint32_t new_cy = obs_source_get_height(child);
if (new_cx > cx) cx = new_cx;
if (new_cy > cy) cy = new_cy;
}
}
unlock_transition(transition);
transition->transition_actual_cx = cx;
transition->transition_actual_cy = cy;
}
void obs_transition_tick(obs_source_t *transition)
{
recalculate_transition_size(transition);
recalculate_transition_matrices(transition);
if (trylock_textures(transition) == 0) {
gs_texrender_reset(transition->transition_texrender[0]);
gs_texrender_reset(transition->transition_texrender[1]);
unlock_textures(transition);
}
}
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);
}
obs_source_t *obs_transition_get_source(obs_source_t *transition,
enum obs_transition_target target)
{
size_t idx = (size_t)target;
obs_source_t *ret;
if (!transition_valid(transition, "obs_transition_get_source"))
return NULL;
lock_transition(transition);
ret = transition->transition_sources[idx];
obs_source_addref(ret);
unlock_transition(transition);
return ret;
}
obs_source_t *obs_transition_get_active_source(obs_source_t *transition)
{
obs_source_t *ret;
if (!transition_valid(transition, "obs_transition_get_source"))
return NULL;
lock_transition(transition);
if (transition->transitioning_audio || transition->transitioning_video)
ret = transition->transition_sources[1];
else
ret = transition->transition_sources[0];
obs_source_addref(ret);
unlock_transition(transition);
return ret;
}
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 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 inline bool transition_active(obs_source_t *transition)
{
return transition->transitioning_audio ||
transition->transitioning_video;
}
bool obs_transition_start(obs_source_t *transition,
enum obs_transition_mode mode, uint32_t duration_ms,
obs_source_t *dest)
{
bool active;
bool same_as_source;
bool same_as_dest;
if (!transition_valid(transition, "obs_transition_start"))
return false;
lock_transition(transition);
same_as_source = dest == transition->transition_sources[0];
same_as_dest = dest == transition->transition_sources[1];
active = transition_active(transition);
unlock_transition(transition);
if (same_as_source && !active)
return false;
if (transition->info.transition_start)
transition->info.transition_start(transition->context.data);
if (transition->transition_use_fixed_duration)
duration_ms = transition->transition_fixed_duration;
if (!active || (!same_as_dest && !same_as_source)) {
transition->transition_start_time = os_gettime_ns();
transition->transition_duration =
(uint64_t)duration_ms * 1000000ULL;
}
set_source(transition, OBS_TRANSITION_SOURCE_B, dest,
activate_transition);
if (dest == NULL && same_as_dest && !same_as_source) {
transition->transitioning_video = true;
transition->transitioning_audio = true;
}
obs_source_dosignal(transition, "source_transition_start",
"transition_start");
recalculate_transition_size(transition);
recalculate_transition_matrices(transition);
/* TODO: Add mode */
UNUSED_PARAMETER(mode);
return true;
}
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 float calc_time(obs_source_t *transition, uint64_t ts)
{
uint64_t end;
if (ts <= transition->transition_start_time)
return 0.0f;
end = transition->transition_duration;
ts -= transition->transition_start_time;
if (ts >= end || end == 0)
return 1.0f;
return (float)((long double)ts / (long double)end);
}
static inline float get_video_time(obs_source_t *transition)
{
uint64_t ts = obs->video.video_time;
return calc_time(transition, ts);
}
float obs_transition_get_time(obs_source_t *transition)
{
return get_video_time(transition);
}
static inline gs_texture_t *get_texture(obs_source_t *transition,
enum obs_transition_target target)
{
size_t idx = (size_t)target;
return gs_texrender_get_texture(transition->transition_texrender[idx]);
}
void obs_transition_set_scale_type(obs_source_t *transition,
enum obs_transition_scale_type type)
{
if (!transition_valid(transition, "obs_transition_set_scale_type"))
return;
transition->transition_scale_type = type;
}
enum obs_transition_scale_type obs_transition_get_scale_type(
const obs_source_t *transition)
{
return transition_valid(transition, "obs_transition_get_scale_type") ?
transition->transition_scale_type :
OBS_TRANSITION_SCALE_MAX_ONLY;
}
void obs_transition_set_alignment(obs_source_t *transition, uint32_t alignment)
{
if (!transition_valid(transition, "obs_transition_set_alignment"))
return;
transition->transition_alignment = alignment;
}
uint32_t obs_transition_get_alignment(const obs_source_t *transition)
{
return transition_valid(transition, "obs_transition_get_alignment") ?
transition->transition_alignment : 0;
}
void obs_transition_set_size(obs_source_t *transition,
uint32_t cx, uint32_t cy)
{
if (!transition_valid(transition, "obs_transition_set_size"))
return;
transition->transition_cx = cx;
transition->transition_cy = cy;
}
void obs_transition_get_size(const obs_source_t *transition,
uint32_t *cx, uint32_t *cy)
{
if (!transition_valid(transition, "obs_transition_set_size")) {
*cx = 0;
*cy = 0;
return;
}
*cx = transition->transition_cx;
*cy = transition->transition_cy;
}
void obs_transition_save(obs_source_t *tr, obs_data_t *data)
{
obs_source_t *child;
lock_transition(tr);
child = transition_active(tr) ?
tr->transition_sources[1] : tr->transition_sources[0];
obs_data_set_string(data, "transition_source_a",
child ? child->context.name : "");
obs_data_set_int(data, "transition_alignment",
tr->transition_alignment);
obs_data_set_int(data, "transition_mode",
(int64_t)tr->transition_mode);
obs_data_set_int(data, "transition_scale_type",
(int64_t)tr->transition_scale_type);
obs_data_set_int(data, "transition_cx", tr->transition_cx);
obs_data_set_int(data, "transition_cy", tr->transition_cy);
unlock_transition(tr);
}
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);
}
struct transition_state {
obs_source_t *s[2];
bool transitioning_video;
bool transitioning_audio;
};
static inline void copy_transition_state(obs_source_t *transition,
struct transition_state *state)
{
state->s[0] = transition->transition_sources[0];
state->s[1] = transition->transition_sources[1];
obs_source_addref(state->s[0]);
obs_source_addref(state->s[1]);
state->transitioning_video = transition->transitioning_video;
state->transitioning_audio = transition->transitioning_audio;
}
static inline void enum_child(obs_source_t *tr, obs_source_t *child,
obs_source_enum_proc_t enum_callback, void *param)
{
if (!child)
return;
if (child->context.data && child->info.enum_active_sources)
child->info.enum_active_sources(child->context.data,
enum_callback, param);
enum_callback(tr, child, param);
}
void obs_transition_enum_sources(obs_source_t *transition,
obs_source_enum_proc_t cb, void *param)
{
lock_transition(transition);
for (size_t i = 0; i < 2; i++) {
if (transition->transition_sources[i])
cb(transition, transition->transition_sources[i], param);
}
unlock_transition(transition);
}
static inline void render_child(obs_source_t *transition,
obs_source_t *child, size_t idx)
{
uint32_t cx = get_cx(transition);
uint32_t cy = get_cy(transition);
struct vec4 blank;
if (!child)
return;
if (gs_texrender_begin(transition->transition_texrender[idx], cx, cy)) {
vec4_zero(&blank);
gs_clear(GS_CLEAR_COLOR, &blank, 0.0f, 0);
gs_ortho(0.0f, (float)cx, 0.0f, (float)cy, -100.0f, 100.0f);
gs_matrix_push();
gs_matrix_mul(&transition->transition_matrices[idx]);
obs_source_video_render(child);
gs_matrix_pop();
gs_texrender_end(transition->transition_texrender[idx]);
}
}
static void obs_transition_stop(obs_source_t *transition)
{
obs_source_t *old_child = transition->transition_sources[0];
if (old_child && transition->transition_source_active[0])
obs_source_remove_active_child(transition, old_child);
obs_source_release(old_child);
transition->transition_source_active[0] = true;
transition->transition_source_active[1] = false;
transition->transition_sources[0] = transition->transition_sources[1];
transition->transition_sources[1] = NULL;
}
static inline void handle_stop(obs_source_t *transition)
{
if (transition->info.transition_stop)
transition->info.transition_stop(transition->context.data);
obs_source_dosignal(transition, "source_transition_stop",
"transition_stop");
}
void obs_transition_video_render(obs_source_t *transition,
obs_transition_video_render_callback_t callback)
{
struct transition_state state;
struct matrix4 matrices[2];
bool locked = false;
bool stopped = false;
bool video_stopped = false;
float t;
if (!transition_valid(transition, "obs_transition_video_render"))
return;
t = get_video_time(transition);
lock_transition(transition);
if (t >= 1.0f && transition->transitioning_video) {
transition->transitioning_video = false;
video_stopped = true;
if (!transition->transitioning_audio) {
obs_transition_stop(transition);
stopped = true;
}
}
copy_transition_state(transition, &state);
matrices[0] = transition->transition_matrices[0];
matrices[1] = transition->transition_matrices[1];
unlock_transition(transition);
if (state.transitioning_video)
locked = trylock_textures(transition) == 0;
if (state.transitioning_video && locked && callback) {
gs_texture_t *tex[2];
uint32_t cx;
uint32_t cy;
for (size_t i = 0; i < 2; i++) {
if (state.s[i]) {
render_child(transition, state.s[i], i);
tex[i] = get_texture(transition, i);
if (!tex[i])
tex[i] = obs->video.transparent_texture;
} else {
tex[i] = obs->video.transparent_texture;
}
}
cx = get_cx(transition);
cy = get_cy(transition);
if (cx && cy)
callback(transition->context.data, tex[0], tex[1], t,
cx, cy);
} else if (state.transitioning_audio) {
if (state.s[1]) {
gs_matrix_push();
gs_matrix_mul(&matrices[1]);
obs_source_video_render(state.s[1]);
gs_matrix_pop();
}
} else {
if (state.s[0]) {
gs_matrix_push();
gs_matrix_mul(&matrices[0]);
obs_source_video_render(state.s[0]);
gs_matrix_pop();
}
}
if (locked)
unlock_textures(transition);
obs_source_release(state.s[0]);
obs_source_release(state.s[1]);
if (video_stopped)
obs_source_dosignal(transition, "source_transition_video_stop",
"transition_video_stop");
if (stopped)
handle_stop(transition);
}
bool obs_transition_video_render_direct(obs_source_t *transition,
enum obs_transition_target target)
{
struct transition_state state;
struct matrix4 matrices[2];
bool stopped = false;
bool video_stopped = false;
bool render_b = target == OBS_TRANSITION_SOURCE_B;
bool transitioning;
float t;
if (!transition_valid(transition, "obs_transition_video_render"))
return false;
t = get_video_time(transition);
lock_transition(transition);
if (t >= 1.0f && transition->transitioning_video) {
transition->transitioning_video = false;
video_stopped = true;
if (!transition->transitioning_audio) {
obs_transition_stop(transition);
stopped = true;
}
}
copy_transition_state(transition, &state);
transitioning = state.transitioning_audio || state.transitioning_video;
matrices[0] = transition->transition_matrices[0];
matrices[1] = transition->transition_matrices[1];
unlock_transition(transition);
int idx = (transitioning && render_b) ? 1 : 0;
if (state.s[idx]) {
gs_matrix_push();
gs_matrix_mul(&matrices[idx]);
obs_source_video_render(state.s[idx]);
gs_matrix_pop();
}
obs_source_release(state.s[0]);
obs_source_release(state.s[1]);
if (video_stopped)
obs_source_dosignal(transition, "source_transition_video_stop",
"transition_video_stop");
if (stopped)
handle_stop(transition);
return transitioning;
}
static inline float get_sample_time(obs_source_t *transition,
size_t sample_rate, size_t sample, uint64_t ts)
{
uint64_t sample_ts_offset = (uint64_t)sample * 1000000000ULL /
(uint64_t)sample_rate;
uint64_t i_ts = ts + sample_ts_offset;
return calc_time(transition, i_ts);
}
static inline void mix_child(obs_source_t *transition, float *out, float *in,
size_t count, size_t sample_rate, uint64_t ts,
obs_transition_audio_mix_callback_t mix)
{
void *context_data = transition->context.data;
for (size_t i = 0; i < count; i++) {
float t = get_sample_time(transition, sample_rate, i, ts);
out[i] += in[i] * mix(context_data, t);
}
}
static void process_audio(obs_source_t *transition, obs_source_t *child,
struct obs_source_audio_mix *audio, uint64_t min_ts,
uint32_t mixers, size_t channels, size_t sample_rate,
obs_transition_audio_mix_callback_t mix)
{
bool valid = child && !child->audio_pending;
struct obs_source_audio_mix child_audio;
uint64_t ts;
size_t pos;
if (!valid)
return;
ts = child->audio_ts;
obs_source_get_audio_mix(child, &child_audio);
pos = (size_t)ns_to_audio_frames(sample_rate, ts - min_ts);
if (pos > AUDIO_OUTPUT_FRAMES)
return;
for (size_t mix_idx = 0; mix_idx < MAX_AUDIO_MIXES; mix_idx++) {
struct audio_output_data *output = &audio->output[mix_idx];
struct audio_output_data *input = &child_audio.output[mix_idx];
if ((mixers & (1 << mix_idx)) == 0)
continue;
for (size_t ch = 0; ch < channels; ch++) {
float *out = output->data[ch];
float *in = input->data[ch];
mix_child(transition, out + pos, in,
AUDIO_OUTPUT_FRAMES - pos,
sample_rate, ts, mix);
}
}
}
static inline uint64_t calc_min_ts(obs_source_t *sources[2])
{
uint64_t min_ts = 0;
for (size_t i = 0; i < 2; i++) {
if (sources[i] && !sources[i]->audio_pending) {
if (!min_ts || sources[i]->audio_ts < min_ts)
min_ts = sources[i]->audio_ts;
}
}
return min_ts;
}
#define TOTAL_AUDIO_SIZE \
(MAX_AUDIO_MIXES * MAX_AUDIO_CHANNELS * \
AUDIO_OUTPUT_FRAMES * sizeof(float))
static inline bool stop_audio(obs_source_t *transition)
{
transition->transitioning_audio = false;
if (!transition->transitioning_video) {
obs_transition_stop(transition);
return true;
}
return false;
}
bool obs_transition_audio_render(obs_source_t *transition,
uint64_t *ts_out, struct obs_source_audio_mix *audio,
uint32_t mixers, size_t channels, size_t sample_rate,
obs_transition_audio_mix_callback_t mix_a,
obs_transition_audio_mix_callback_t mix_b)
{
obs_source_t *sources[2];
struct transition_state state = {0};
bool stopped = false;
uint64_t min_ts;
float t;
if (!transition_valid(transition, "obs_transition_audio_render"))
return false;
lock_transition(transition);
sources[0] = transition->transition_sources[0];
sources[1] = transition->transition_sources[1];
min_ts = calc_min_ts(sources);
if (min_ts) {
t = calc_time(transition, min_ts);
if (t >= 1.0f && transition->transitioning_audio)
stopped = stop_audio(transition);
sources[0] = transition->transition_sources[0];
sources[1] = transition->transition_sources[1];
min_ts = calc_min_ts(sources);
if (min_ts)
copy_transition_state(transition, &state);
} else if (!transition->transitioning_video &&
transition->transitioning_audio) {
stopped = stop_audio(transition);
}
unlock_transition(transition);
if (min_ts) {
if (state.transitioning_audio) {
if (state.s[0])
process_audio(transition, state.s[0], audio,
min_ts, mixers, channels,
sample_rate, mix_a);
if (state.s[1])
process_audio(transition, state.s[1], audio,
min_ts, mixers, channels,
sample_rate, mix_b);
} else if (state.s[0]) {
memcpy(audio->output[0].data[0],
state.s[0]->audio_output_buf[0][0],
TOTAL_AUDIO_SIZE);
}
obs_source_release(state.s[0]);
obs_source_release(state.s[1]);
}
if (stopped)
handle_stop(transition);
*ts_out = min_ts;
return !!min_ts;
}
void obs_transition_enable_fixed(obs_source_t *transition,
bool enable, uint32_t duration)
{
if (!transition_valid(transition, "obs_transition_enable_fixed"))
return;
transition->transition_use_fixed_duration = enable;
transition->transition_fixed_duration = duration;
}
bool obs_transition_fixed(obs_source_t *transition)
{
return transition_valid(transition, "obs_transition_fixed") ?
transition->transition_use_fixed_duration : false;
}
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;
}
void obs_transition_swap_begin(obs_source_t *tr_dest, obs_source_t *tr_source)
{
obs_source_t *old_children[2];
if (tr_dest == tr_source)
return;
lock_textures(tr_source);
lock_textures(tr_dest);
lock_transition(tr_source);
lock_transition(tr_dest);
for (size_t i = 0; i < 2; i++)
old_children[i] = copy_source_state(tr_dest, tr_source, i);
unlock_transition(tr_dest);
unlock_transition(tr_source);
for (size_t i = 0; i < 2; i++)
obs_source_release(old_children[i]);
}
void obs_transition_swap_end(obs_source_t *tr_dest, obs_source_t *tr_source)
{
if (tr_dest == tr_source)
return;
obs_transition_clear(tr_source);
for (size_t i = 0; i < 2; i++) {
gs_texrender_t *dest = tr_dest->transition_texrender[i];
gs_texrender_t *source = tr_source->transition_texrender[i];
tr_dest->transition_texrender[i] = source;
tr_source->transition_texrender[i] = dest;
}
unlock_textures(tr_dest);
unlock_textures(tr_source);
}