mirror of
https://github.com/Xaymar/obs-StreamFX
synced 2024-10-24 05:42:39 +00:00
add8012549
The source allows you to apply effects to the same source without requiring a new instance of the source. Any changes done to the original source also apply to the mirror, so there is less total work that needs to be done. It can also rescale the source, allowing you to use the same source as a cheap instant backdrop with Blur for example. What you do in the end is completely unwritten and up to you to decide.
337 lines
10 KiB
C++
337 lines
10 KiB
C++
/*
|
|
* Modern effects for a modern Streamer
|
|
* Copyright (C) 2017 Michael Fabian Dirks
|
|
*
|
|
* 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "source-mirror.h"
|
|
#include "strings.h"
|
|
#include <memory>
|
|
#include <cstring>
|
|
#include <vector>
|
|
|
|
#define S_SOURCE_MIRROR "Source.Mirror"
|
|
#define P_SOURCE "Source.Mirror.Source"
|
|
#define P_SOURCE_SIZE "Source.Mirror.Source.Size"
|
|
#define P_SCALING "Source.Mirror.Scaling"
|
|
#define P_SCALING_METHOD "Source.Mirror.Scaling.Method"
|
|
#define P_SCALING_METHOD_POINT "Source.Mirror.Scaling.Method.Point"
|
|
#define P_SCALING_METHOD_BILINEAR "Source.Mirror.Scaling.Method.Bilinear"
|
|
#define P_SCALING_METHOD_BILINEARLOWRES "Source.Mirror.Scaling.Method.BilinearLowRes"
|
|
#define P_SCALING_METHOD_BICUBIC "Source.Mirror.Scaling.Method.Bicubic"
|
|
#define P_SCALING_METHOD_LANCZOS "Source.Mirror.Scaling.Method.Lanczos"
|
|
#define P_SCALING_SIZE "Source.Mirror.Scaling.Size"
|
|
|
|
enum class ScalingMethod : int64_t {
|
|
Point,
|
|
Bilinear,
|
|
BilinearLowRes,
|
|
Bicubic,
|
|
Lanczos,
|
|
};
|
|
|
|
Source::MirrorAddon* inst;
|
|
INITIALIZER(SourceMirrorInit) {
|
|
initializerFunctions.push_back([] {
|
|
inst = new Source::MirrorAddon();
|
|
});
|
|
finalizerFunctions.push_back([] {
|
|
delete inst;
|
|
});
|
|
}
|
|
|
|
Source::MirrorAddon::MirrorAddon() {
|
|
memset(&osi, 0, sizeof(obs_source_info));
|
|
osi.id = "obs-stream-effects-source-mirror";
|
|
osi.type = OBS_SOURCE_TYPE_INPUT;
|
|
osi.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW;
|
|
|
|
osi.get_name = get_name;
|
|
osi.get_defaults = get_defaults;
|
|
osi.get_properties = get_properties;
|
|
osi.get_width = get_width;
|
|
osi.get_height = get_height;
|
|
osi.create = create;
|
|
osi.destroy = destroy;
|
|
osi.update = update;
|
|
osi.activate = activate;
|
|
osi.deactivate = deactivate;
|
|
osi.video_tick = video_tick;
|
|
osi.video_render = video_render;
|
|
|
|
obs_register_source(&osi);
|
|
}
|
|
|
|
Source::MirrorAddon::~MirrorAddon() {}
|
|
|
|
const char * Source::MirrorAddon::get_name(void *) {
|
|
return P_TRANSLATE(S_SOURCE_MIRROR);
|
|
}
|
|
|
|
void Source::MirrorAddon::get_defaults(obs_data_t *data) {
|
|
obs_data_set_default_string(data, P_SOURCE, "");
|
|
obs_data_set_default_bool(data, P_SCALING, false);
|
|
obs_data_set_default_string(data, P_SCALING_SIZE, "100x100");
|
|
obs_data_set_default_int(data, P_SCALING_METHOD, (int64_t)ScalingMethod::Bilinear);
|
|
}
|
|
|
|
bool Source::MirrorAddon::modified_properties(obs_properties_t *pr, obs_property_t *p, obs_data_t *data) {
|
|
if (obs_properties_get(pr, P_SOURCE) == p) {
|
|
obs_source_t* target = obs_get_source_by_name(obs_data_get_string(data, P_SOURCE));
|
|
if (target) {
|
|
std::vector<char> buf(256);
|
|
sprintf_s(buf.data(), buf.size(), "%ldx%ld\0",
|
|
obs_source_get_width(target), obs_source_get_height(target));
|
|
obs_data_set_string(data, P_SOURCE_SIZE, buf.data());
|
|
} else {
|
|
obs_data_set_string(data, P_SOURCE_SIZE, "0x0");
|
|
}
|
|
}
|
|
|
|
if (obs_properties_get(pr, P_SCALING) == p) {
|
|
bool show = obs_data_get_bool(data, P_SCALING);
|
|
obs_property_set_visible(obs_properties_get(pr, P_SCALING_METHOD), show);
|
|
obs_property_set_visible(obs_properties_get(pr, P_SCALING_SIZE), show);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool UpdateSourceListCB(void *ptr, obs_source_t* src) {
|
|
obs_property_t* p = (obs_property_t*)ptr;
|
|
obs_property_list_add_string(p, obs_source_get_name(src), obs_source_get_name(src));
|
|
return true;
|
|
}
|
|
|
|
void UpdateSourceList(obs_property_t* p) {
|
|
obs_property_list_clear(p);
|
|
obs_enum_sources(UpdateSourceListCB, p);
|
|
}
|
|
|
|
obs_properties_t * Source::MirrorAddon::get_properties(void *ptr) {
|
|
obs_properties_t* pr = obs_properties_create();
|
|
obs_property_t* p = nullptr;
|
|
|
|
p = obs_properties_add_list(pr, P_SOURCE, P_TRANSLATE(P_SOURCE),
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
|
|
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SOURCE)));
|
|
obs_property_set_modified_callback(p, modified_properties);
|
|
UpdateSourceList(p);
|
|
|
|
p = obs_properties_add_text(pr, P_SOURCE_SIZE, P_TRANSLATE(P_SOURCE_SIZE), OBS_TEXT_DEFAULT);
|
|
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SOURCE_SIZE)));
|
|
obs_property_set_enabled(p, false);
|
|
|
|
p = obs_properties_add_bool(pr, P_SCALING, P_TRANSLATE(P_SCALING));
|
|
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SCALING)));
|
|
obs_property_set_modified_callback(p, modified_properties);
|
|
|
|
p = obs_properties_add_list(pr, P_SCALING_METHOD, P_TRANSLATE(P_SCALING_METHOD),
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SCALING_METHOD)));
|
|
obs_property_list_add_int(p, P_TRANSLATE(P_SCALING_METHOD_POINT), (int64_t)ScalingMethod::Point);
|
|
obs_property_list_add_int(p, P_TRANSLATE(P_SCALING_METHOD_BILINEAR), (int64_t)ScalingMethod::Bilinear);
|
|
obs_property_list_add_int(p, P_TRANSLATE(P_SCALING_METHOD_BILINEARLOWRES), (int64_t)ScalingMethod::BilinearLowRes);
|
|
obs_property_list_add_int(p, P_TRANSLATE(P_SCALING_METHOD_BICUBIC), (int64_t)ScalingMethod::Bicubic);
|
|
obs_property_list_add_int(p, P_TRANSLATE(P_SCALING_METHOD_LANCZOS), (int64_t)ScalingMethod::Lanczos);
|
|
|
|
p = obs_properties_add_text(pr, P_SCALING_SIZE, P_TRANSLATE(P_SCALING_SIZE),
|
|
OBS_TEXT_DEFAULT);
|
|
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SCALING_SIZE)));
|
|
|
|
return pr;
|
|
}
|
|
|
|
void * Source::MirrorAddon::create(obs_data_t *data, obs_source_t *source) {
|
|
return new Source::Mirror(data, source);
|
|
}
|
|
|
|
void Source::MirrorAddon::destroy(void *p) {
|
|
delete static_cast<Source::Mirror*>(p);
|
|
}
|
|
|
|
uint32_t Source::MirrorAddon::get_width(void *p) {
|
|
return static_cast<Source::Mirror*>(p)->get_width();
|
|
}
|
|
|
|
uint32_t Source::MirrorAddon::get_height(void *p) {
|
|
return static_cast<Source::Mirror*>(p)->get_height();
|
|
}
|
|
|
|
void Source::MirrorAddon::update(void *p, obs_data_t *data) {
|
|
static_cast<Source::Mirror*>(p)->update(data);
|
|
}
|
|
|
|
void Source::MirrorAddon::activate(void *p) {
|
|
static_cast<Source::Mirror*>(p)->activate();
|
|
}
|
|
|
|
void Source::MirrorAddon::deactivate(void *p) {
|
|
static_cast<Source::Mirror*>(p)->deactivate();
|
|
}
|
|
|
|
void Source::MirrorAddon::video_tick(void *p, float t) {
|
|
static_cast<Source::Mirror*>(p)->video_tick(t);
|
|
}
|
|
|
|
void Source::MirrorAddon::video_render(void *p, gs_effect_t *ef) {
|
|
static_cast<Source::Mirror*>(p)->video_render(ef);
|
|
}
|
|
|
|
Source::Mirror::Mirror(obs_data_t* data, obs_source_t* src) {
|
|
m_active = true;
|
|
m_source = src;
|
|
m_target = nullptr;
|
|
|
|
m_rescale = false;
|
|
m_width = m_height = 1;
|
|
m_renderTarget = std::make_unique<GS::RenderTarget>(GS_RGBA, GS_ZS_NONE);
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
|
|
|
|
update(data);
|
|
}
|
|
|
|
Source::Mirror::~Mirror() {
|
|
|
|
}
|
|
|
|
uint32_t Source::Mirror::get_width() {
|
|
if (m_rescale && m_width > 0)
|
|
return m_width;
|
|
if (m_target && m_target != m_source)
|
|
return obs_source_get_width(m_target);
|
|
return 1;
|
|
}
|
|
|
|
uint32_t Source::Mirror::get_height() {
|
|
if (m_rescale && m_height > 0)
|
|
return m_height;
|
|
if (m_target && m_target != m_source)
|
|
return obs_source_get_height(m_target);
|
|
return 1;
|
|
}
|
|
|
|
void Source::Mirror::update(obs_data_t* data) {
|
|
// Update selected source.
|
|
const char* source = obs_data_get_string(data, P_SOURCE);
|
|
m_target = obs_get_source_by_name(source);
|
|
m_targetName = source;
|
|
|
|
// Rescaling
|
|
m_rescale = obs_data_get_bool(data, P_SCALING);
|
|
if (m_rescale) { // Parse rescaling settings.
|
|
uint32_t width, height;
|
|
|
|
// Read value.
|
|
const char* size = obs_data_get_string(data, P_SCALING_SIZE);
|
|
const char* xpos = strchr(size, 'x');
|
|
if (xpos != nullptr) {
|
|
// Width
|
|
width = strtoul(size, nullptr, 10);
|
|
if (errno == ERANGE || width == 0) {
|
|
m_rescale = false;
|
|
m_width = 1;
|
|
} else {
|
|
m_width = width;
|
|
}
|
|
|
|
height = strtoul(xpos + 1, nullptr, 10);
|
|
if (errno == ERANGE || height == 0) {
|
|
m_rescale = false;
|
|
m_height = 1;
|
|
} else {
|
|
m_height = height;
|
|
}
|
|
} else {
|
|
m_rescale = false;
|
|
m_width = 1;
|
|
m_height = 1;
|
|
}
|
|
|
|
ScalingMethod scaler = (ScalingMethod)obs_data_get_int(data, P_SCALING_METHOD);
|
|
switch (scaler) {
|
|
case ScalingMethod::Bilinear:
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
|
|
break;
|
|
case ScalingMethod::BilinearLowRes:
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_BILINEAR_LOWRES);
|
|
break;
|
|
case ScalingMethod::Bicubic:
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_BICUBIC);
|
|
break;
|
|
case ScalingMethod::Lanczos:
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_LANCZOS);
|
|
break;
|
|
case ScalingMethod::Point:
|
|
default:
|
|
m_scalingEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Source::Mirror::activate() {
|
|
m_active = true;
|
|
}
|
|
|
|
void Source::Mirror::deactivate() {
|
|
m_active = false;
|
|
}
|
|
|
|
void Source::Mirror::video_tick(float) {
|
|
if (!m_target)
|
|
m_target = obs_get_source_by_name(m_targetName.c_str());
|
|
}
|
|
|
|
void Source::Mirror::video_render(gs_effect_t* effect) {
|
|
if (!m_active || (m_source == m_target) || (m_width == 0 || m_height == 0))
|
|
return;
|
|
|
|
if (m_rescale && m_width > 0 && m_height > 0 && m_scalingEffect) {
|
|
uint32_t sw, sh;
|
|
sw = obs_source_get_width(m_target);
|
|
sh = obs_source_get_height(m_target);
|
|
|
|
// Store original Source Texture
|
|
try {
|
|
vec4 black; vec4_zero(&black);
|
|
auto op = m_renderTarget->Render(m_width, m_height);
|
|
gs_ortho(0, sw, 0, sh, 0, 1);
|
|
gs_clear(GS_CLEAR_COLOR, &black, 0, 0);
|
|
|
|
gs_eparam_t *scale_param = gs_effect_get_param_by_name(m_scalingEffect, "base_dimension_i");
|
|
if (scale_param) {
|
|
struct vec2 base_res_i = {
|
|
1.0f / (float)sw,
|
|
1.0f / (float)sh
|
|
};
|
|
gs_effect_set_vec2(scale_param, &base_res_i);
|
|
}
|
|
while (gs_effect_loop(m_scalingEffect, "Draw")) {
|
|
obs_source_video_render(m_target);
|
|
}
|
|
} catch (...) {
|
|
return;
|
|
}
|
|
|
|
while (gs_effect_loop(obs_get_base_effect(OBS_EFFECT_DEFAULT), "Draw")) {
|
|
obs_source_draw(m_renderTarget->GetTextureObject(), 0, 0, m_width, m_height, false);
|
|
}
|
|
} else {
|
|
obs_source_video_render(m_target);
|
|
}
|
|
}
|