391 lines
10 KiB
C
391 lines
10 KiB
C
#include <obs-module.h>
|
|
#include <util/dstr.h>
|
|
|
|
#define TIMING_TIME 0
|
|
#define TIMING_FRAME 1
|
|
|
|
enum fade_style { FADE_STYLE_FADE_OUT_FADE_IN, FADE_STYLE_CROSS_FADE };
|
|
|
|
struct stinger_info {
|
|
obs_source_t *source;
|
|
|
|
obs_source_t *media_source;
|
|
|
|
uint64_t duration_ns;
|
|
uint64_t duration_frames;
|
|
uint64_t transition_point_ns;
|
|
uint64_t transition_point_frame;
|
|
float transition_point;
|
|
float transition_a_mul;
|
|
float transition_b_mul;
|
|
bool transitioning;
|
|
bool transition_point_is_frame;
|
|
int monitoring_type;
|
|
enum fade_style fade_style;
|
|
|
|
float (*mix_a)(void *data, float t);
|
|
float (*mix_b)(void *data, float t);
|
|
};
|
|
|
|
static const char *stinger_get_name(void *type_data)
|
|
{
|
|
UNUSED_PARAMETER(type_data);
|
|
return obs_module_text("StingerTransition");
|
|
}
|
|
|
|
static float mix_a_fade_in_out(void *data, float t);
|
|
static float mix_b_fade_in_out(void *data, float t);
|
|
static float mix_a_cross_fade(void *data, float t);
|
|
static float mix_b_cross_fade(void *data, float t);
|
|
|
|
static void stinger_update(void *data, obs_data_t *settings)
|
|
{
|
|
struct stinger_info *s = data;
|
|
const char *path = obs_data_get_string(settings, "path");
|
|
bool hw_decode = obs_data_get_bool(settings, "hw_decode");
|
|
|
|
obs_data_t *media_settings = obs_data_create();
|
|
obs_data_set_string(media_settings, "local_file", path);
|
|
obs_data_set_bool(media_settings, "hw_decode", hw_decode);
|
|
|
|
obs_source_release(s->media_source);
|
|
struct dstr name;
|
|
dstr_init_copy(&name, obs_source_get_name(s->source));
|
|
dstr_cat(&name, " (Stinger)");
|
|
s->media_source = obs_source_create_private("ffmpeg_source", name.array,
|
|
media_settings);
|
|
dstr_free(&name);
|
|
obs_data_release(media_settings);
|
|
|
|
int64_t point = obs_data_get_int(settings, "transition_point");
|
|
|
|
s->transition_point_is_frame = obs_data_get_int(settings, "tp_type") ==
|
|
TIMING_FRAME;
|
|
|
|
if (s->transition_point_is_frame)
|
|
s->transition_point_frame = (uint64_t)point;
|
|
else
|
|
s->transition_point_ns = (uint64_t)(point * 1000000LL);
|
|
|
|
s->monitoring_type =
|
|
(int)obs_data_get_int(settings, "audio_monitoring");
|
|
obs_source_set_monitoring_type(s->media_source, s->monitoring_type);
|
|
|
|
s->fade_style =
|
|
(enum fade_style)obs_data_get_int(settings, "audio_fade_style");
|
|
|
|
switch (s->fade_style) {
|
|
default:
|
|
case FADE_STYLE_FADE_OUT_FADE_IN:
|
|
s->mix_a = mix_a_fade_in_out;
|
|
s->mix_b = mix_b_fade_in_out;
|
|
break;
|
|
case FADE_STYLE_CROSS_FADE:
|
|
s->mix_a = mix_a_cross_fade;
|
|
s->mix_b = mix_b_cross_fade;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void *stinger_create(obs_data_t *settings, obs_source_t *source)
|
|
{
|
|
struct stinger_info *s = bzalloc(sizeof(*s));
|
|
|
|
s->source = source;
|
|
s->mix_a = mix_a_fade_in_out;
|
|
s->mix_b = mix_b_fade_in_out;
|
|
|
|
obs_transition_enable_fixed(s->source, true, 0);
|
|
obs_source_update(source, settings);
|
|
return s;
|
|
}
|
|
|
|
static void stinger_destroy(void *data)
|
|
{
|
|
struct stinger_info *s = data;
|
|
obs_source_release(s->media_source);
|
|
bfree(s);
|
|
}
|
|
|
|
static void stinger_defaults(obs_data_t *settings)
|
|
{
|
|
obs_data_set_default_bool(settings, "hw_decode", true);
|
|
}
|
|
|
|
static void stinger_video_render(void *data, gs_effect_t *effect)
|
|
{
|
|
struct stinger_info *s = data;
|
|
|
|
float t = obs_transition_get_time(s->source);
|
|
bool use_a = t < s->transition_point;
|
|
|
|
enum obs_transition_target target = use_a ? OBS_TRANSITION_SOURCE_A
|
|
: OBS_TRANSITION_SOURCE_B;
|
|
|
|
if (!obs_transition_video_render_direct(s->source, target))
|
|
return;
|
|
|
|
/* --------------------- */
|
|
|
|
float source_cx = (float)obs_source_get_width(s->source);
|
|
float source_cy = (float)obs_source_get_height(s->source);
|
|
uint32_t media_cx = obs_source_get_width(s->media_source);
|
|
uint32_t media_cy = obs_source_get_height(s->media_source);
|
|
|
|
if (!media_cx || !media_cy)
|
|
return;
|
|
|
|
float scale_x = source_cx / (float)media_cx;
|
|
float scale_y = source_cy / (float)media_cy;
|
|
|
|
gs_matrix_push();
|
|
gs_matrix_scale3f(scale_x, scale_y, 1.0f);
|
|
obs_source_video_render(s->media_source);
|
|
gs_matrix_pop();
|
|
|
|
UNUSED_PARAMETER(effect);
|
|
}
|
|
|
|
static inline float calc_fade(float t, float mul)
|
|
{
|
|
t *= mul;
|
|
return t > 1.0f ? 1.0f : t;
|
|
}
|
|
|
|
static float mix_a_fade_in_out(void *data, float t)
|
|
{
|
|
struct stinger_info *s = data;
|
|
return 1.0f - calc_fade(t, s->transition_a_mul);
|
|
}
|
|
|
|
static float mix_b_fade_in_out(void *data, float t)
|
|
{
|
|
struct stinger_info *s = data;
|
|
return 1.0f - calc_fade(1.0f - t, s->transition_b_mul);
|
|
}
|
|
|
|
static float mix_a_cross_fade(void *data, float t)
|
|
{
|
|
UNUSED_PARAMETER(data);
|
|
return 1.0f - t;
|
|
}
|
|
|
|
static float mix_b_cross_fade(void *data, float t)
|
|
{
|
|
UNUSED_PARAMETER(data);
|
|
return t;
|
|
}
|
|
|
|
static bool stinger_audio_render(void *data, uint64_t *ts_out,
|
|
struct obs_source_audio_mix *audio,
|
|
uint32_t mixers, size_t channels,
|
|
size_t sample_rate)
|
|
{
|
|
struct stinger_info *s = data;
|
|
uint64_t ts = 0;
|
|
|
|
if (!obs_source_audio_pending(s->media_source)) {
|
|
ts = obs_source_get_audio_timestamp(s->media_source);
|
|
if (!ts)
|
|
return false;
|
|
}
|
|
|
|
bool success = obs_transition_audio_render(s->source, ts_out, audio,
|
|
mixers, channels,
|
|
sample_rate, s->mix_a,
|
|
s->mix_b);
|
|
if (!ts)
|
|
return success;
|
|
|
|
if (!*ts_out || ts < *ts_out)
|
|
*ts_out = ts;
|
|
|
|
struct obs_source_audio_mix child_audio;
|
|
obs_source_get_audio_mix(s->media_source, &child_audio);
|
|
|
|
for (size_t mix = 0; mix < MAX_AUDIO_MIXES; mix++) {
|
|
if ((mixers & (1 << mix)) == 0)
|
|
continue;
|
|
|
|
for (size_t ch = 0; ch < channels; ch++) {
|
|
register float *out = audio->output[mix].data[ch];
|
|
register float *in = child_audio.output[mix].data[ch];
|
|
register float *end = in + AUDIO_OUTPUT_FRAMES;
|
|
|
|
while (in < end)
|
|
*(out++) += *(in++);
|
|
}
|
|
}
|
|
|
|
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") + 250000000ULL;
|
|
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 void stinger_transition_stop(void *data)
|
|
{
|
|
struct stinger_info *s = data;
|
|
|
|
if (s->media_source)
|
|
obs_source_remove_active_child(s->source, s->media_source);
|
|
|
|
s->transitioning = false;
|
|
}
|
|
|
|
static void stinger_enum_active_sources(void *data,
|
|
obs_source_enum_proc_t enum_callback,
|
|
void *param)
|
|
{
|
|
struct stinger_info *s = data;
|
|
if (s->media_source && s->transitioning)
|
|
enum_callback(s->source, s->media_source, param);
|
|
}
|
|
|
|
static void stinger_enum_all_sources(void *data,
|
|
obs_source_enum_proc_t enum_callback,
|
|
void *param)
|
|
{
|
|
struct stinger_info *s = data;
|
|
if (s->media_source)
|
|
enum_callback(s->source, s->media_source, param);
|
|
}
|
|
|
|
#define FILE_FILTER \
|
|
"Video Files (*.mp4 *.ts *.mov *.wmv *.flv *.mkv *.avi *.gif *.webm);;"
|
|
|
|
static bool transition_point_type_modified(obs_properties_t *ppts,
|
|
obs_property_t *p, obs_data_t *s)
|
|
{
|
|
int64_t type = obs_data_get_int(s, "tp_type");
|
|
p = obs_properties_get(ppts, "transition_point");
|
|
|
|
if (type == TIMING_TIME) {
|
|
obs_property_set_description(
|
|
p, obs_module_text("TransitionPoint"));
|
|
obs_property_int_set_suffix(p, " ms");
|
|
} else {
|
|
obs_property_set_description(
|
|
p, obs_module_text("TransitionPointFrame"));
|
|
obs_property_int_set_suffix(p, "");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static obs_properties_t *stinger_properties(void *data)
|
|
{
|
|
obs_properties_t *ppts = obs_properties_create();
|
|
|
|
obs_properties_set_flags(ppts, OBS_PROPERTIES_DEFER_UPDATE);
|
|
|
|
obs_properties_add_path(ppts, "path", obs_module_text("VideoFile"),
|
|
OBS_PATH_FILE, FILE_FILTER, NULL);
|
|
obs_property_t *p = obs_properties_add_list(
|
|
ppts, "tp_type", obs_module_text("TransitionPointType"),
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
#ifndef __APPLE__
|
|
obs_properties_add_bool(ppts, "hw_decode",
|
|
obs_module_text("HardwareDecode"));
|
|
#endif
|
|
obs_property_list_add_int(p, obs_module_text("TransitionPointTypeTime"),
|
|
TIMING_TIME);
|
|
obs_property_list_add_int(
|
|
p, obs_module_text("TransitionPointTypeFrame"), TIMING_FRAME);
|
|
|
|
obs_property_set_modified_callback(p, transition_point_type_modified);
|
|
|
|
obs_properties_add_int(ppts, "transition_point",
|
|
obs_module_text("TransitionPoint"), 0, 120000,
|
|
1);
|
|
|
|
obs_property_t *monitor_list = obs_properties_add_list(
|
|
ppts, "audio_monitoring", obs_module_text("AudioMonitoring"),
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
obs_property_list_add_int(monitor_list,
|
|
obs_module_text("AudioMonitoring.None"),
|
|
OBS_MONITORING_TYPE_NONE);
|
|
obs_property_list_add_int(
|
|
monitor_list, obs_module_text("AudioMonitoring.MonitorOnly"),
|
|
OBS_MONITORING_TYPE_MONITOR_ONLY);
|
|
obs_property_list_add_int(monitor_list,
|
|
obs_module_text("AudioMonitoring.Both"),
|
|
OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT);
|
|
|
|
obs_property_t *audio_fade_style = obs_properties_add_list(
|
|
ppts, "audio_fade_style", obs_module_text("AudioFadeStyle"),
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
obs_property_list_add_int(
|
|
audio_fade_style,
|
|
obs_module_text("AudioFadeStyle.FadeOutFadeIn"),
|
|
FADE_STYLE_FADE_OUT_FADE_IN);
|
|
obs_property_list_add_int(audio_fade_style,
|
|
obs_module_text("AudioFadeStyle.CrossFade"),
|
|
FADE_STYLE_CROSS_FADE);
|
|
|
|
UNUSED_PARAMETER(data);
|
|
return ppts;
|
|
}
|
|
|
|
struct obs_source_info stinger_transition = {
|
|
.id = "obs_stinger_transition",
|
|
.type = OBS_SOURCE_TYPE_TRANSITION,
|
|
.get_name = stinger_get_name,
|
|
.create = stinger_create,
|
|
.destroy = stinger_destroy,
|
|
.update = stinger_update,
|
|
.get_defaults = stinger_defaults,
|
|
.video_render = stinger_video_render,
|
|
.audio_render = stinger_audio_render,
|
|
.get_properties = stinger_properties,
|
|
.enum_active_sources = stinger_enum_active_sources,
|
|
.enum_all_sources = stinger_enum_all_sources,
|
|
.transition_start = stinger_transition_start,
|
|
.transition_stop = stinger_transition_stop,
|
|
};
|