From 843a76d1c62d24e13100fcf6db2f256d44027d7e Mon Sep 17 00:00:00 2001 From: Michael Fabian 'Xaymar' Dirks Date: Tue, 28 Sep 2021 00:16:21 +0200 Subject: [PATCH] filter/upscaling: 'Video Super-Resolution' -> 'Upscaling' The previous name was too strict on what could be put into the effect, and would result in additional clutter in the Filter menu when we eventually decide to support other Upscaling methods than Super-Resolution networks. --- CMakeLists.txt | 34 ++-- data/locale/en-US.ini | 18 +- ...perresolution.cpp => filter-upscaling.cpp} | 167 +++++++++--------- ...perresolution.hpp => filter-upscaling.hpp} | 59 +++---- source/plugin.cpp | 12 +- 5 files changed, 141 insertions(+), 149 deletions(-) rename source/filters/{filter-video-superresolution.cpp => filter-upscaling.cpp} (71%) rename source/filters/{filter-video-superresolution.hpp => filter-upscaling.hpp} (63%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 92692665..41550c14 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -305,8 +305,8 @@ set(${PREFIX}ENABLE_FILTER_NVIDIA_FACE_TRACKING ON CACHE BOOL "Enable NVIDIA Fac set(${PREFIX}ENABLE_FILTER_SDF_EFFECTS ON CACHE BOOL "Enable SDF Effects Filter") set(${PREFIX}ENABLE_FILTER_SHADER ON CACHE BOOL "Enable Shader Filter") set(${PREFIX}ENABLE_FILTER_TRANSFORM ON CACHE BOOL "Enable Transform Filter") -set(${PREFIX}ENABLE_FILTER_VIDEO_SUPERRESOLUTION ON CACHE BOOL "Enable Video Super-Resolution filter") -set(${PREFIX}ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA ON CACHE BOOL "Enable NVIDIA Video Super-Resolution for Video Super-Resolution Filter") +set(${PREFIX}ENABLE_FILTER_UPSCALING ON CACHE BOOL "Enable Upscaling Filter") +set(${PREFIX}ENABLE_FILTER_UPSCALING_NVIDIA ON CACHE BOOL "Enable NVIDIA provider(s) for Upscaling Filter") ## Sources set(${PREFIX}ENABLE_SOURCE_MIRROR ON CACHE BOOL "Enable Mirror Source") @@ -696,20 +696,20 @@ function(feature_filter_transform RESOLVE) is_feature_enabled(FILTER_TRANSFORM T_CHECK) endfunction() -function(feature_filter_video_superresolution RESOLVE) - is_feature_enabled(FILTER_VIDEO_SUPERRESOLUTION T_CHECK) +function(feature_filter_upscaling RESOLVE) + is_feature_enabled(FILTER_UPSCALING T_CHECK) if(RESOLVE AND T_CHECK) # Verify that the requirements for the providers are available if(NOT HAVE_NVIDIA_VFX_SDK) - message(WARNING "${LOGPREFIX}: 'NVIDIA Video Effects SDK' is missing. Disabling Video Super-Resolution provider...") - set_feature_disabled(FILTER_VIDEO_SUPERRESOLUTION_NVIDIA ON) + message(WARNING "${LOGPREFIX}: 'NVIDIA Video Effects SDK' is missing. Disabling NVIDIA provider(s)...") + set_feature_disabled(FILTER_UPSCALING_NVIDIA ON) endif() # Verify that we have at least one provider for Video Super-Resolution. - is_feature_enabled(FILTER_VIDEO_SUPERRESOLUTION_NVIDIA T_CHECK_NVIDIA) + is_feature_enabled(FILTER_UPSCALING_NVIDIA T_CHECK_NVIDIA) if (NOT T_CHECK_NVIDIA) - message(WARNING "${LOGPREFIX}: Video Super-Resolution has no available providers. Disabling...") - set_feature_disabled(FILTER_VIDEO_SUPERRESOLUTION ON) + message(WARNING "${LOGPREFIX}: Upscaling has no available providers. Disabling...") + set_feature_disabled(FILTER_UPSCALING ON) endif() elseif(T_CHECK) set(REQUIRE_NVIDIA_VFX_SDK ON PARENT_SCOPE) @@ -771,7 +771,7 @@ feature_filter_nvidia_face_tracking(OFF) feature_filter_sdf_effects(OFF) feature_filter_shader(OFF) feature_filter_transform(OFF) -feature_filter_video_superresolution(OFF) +feature_filter_upscaling(OFF) feature_source_mirror(OFF) feature_source_shader(OFF) feature_transition_shader(OFF) @@ -926,7 +926,7 @@ feature_filter_nvidia_face_tracking(ON) feature_filter_sdf_effects(ON) feature_filter_shader(ON) feature_filter_transform(ON) -feature_filter_video_superresolution(ON) +feature_filter_upscaling(ON) feature_source_mirror(ON) feature_source_shader(ON) feature_transition_shader(ON) @@ -1391,19 +1391,19 @@ if(T_CHECK) endif() # Filter/Video Super-Resolution -is_feature_enabled(FILTER_VIDEO_SUPERRESOLUTION T_CHECK) +is_feature_enabled(FILTER_UPSCALING T_CHECK) if(T_CHECK) list(APPEND PROJECT_PRIVATE_SOURCE - "source/filters/filter-video-superresolution.hpp" - "source/filters/filter-video-superresolution.cpp" + "source/filters/filter-upscaling.hpp" + "source/filters/filter-upscaling.cpp" ) list(APPEND PROJECT_DEFINITIONS - ENABLE_FILTER_VIDEO_SUPERRESOLUTION + ENABLE_FILTER_UPSCALING ) - is_feature_enabled(FILTER_VIDEO_SUPERRESOLUTION_NVIDIA T_CHECK) + is_feature_enabled(FILTER_UPSCALING_NVIDIA T_CHECK) if (T_CHECK) list(APPEND PROJECT_DEFINITIONS - ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA + ENABLE_FILTER_UPSCALING_NVIDIA ) endif() endif() diff --git a/data/locale/en-US.ini b/data/locale/en-US.ini index be9d3ef3..42d10b00 100644 --- a/data/locale/en-US.ini +++ b/data/locale/en-US.ini @@ -335,15 +335,15 @@ Filter.Transform.Rotation.Order.ZXY="Roll, Pitch, Yaw" Filter.Transform.Rotation.Order.ZYX="Roll, Yaw, Pitch" Filter.Transform.Mipmapping="Enable Mipmapping" -# Filter - Video Super-Resolution -Filter.VideoSuperResolution="Video Super-Resolution" -Filter.VideoSuperResolution.Provider="Provider" -Filter.VideoSuperResolution.Provider.NVIDIAVideoSuperResolution="NVIDIA Video Super-Resolution, powered by NVIDIA Broadcast" -Filter.VideoSuperResolution.NVIDIA.SuperRes="NVIDIA Video Super-Resolution" -Filter.VideoSuperResolution.NVIDIA.SuperRes.Scale="Scale" -Filter.VideoSuperResolution.NVIDIA.SuperRes.Strength="Strength" -Filter.VideoSuperResolution.NVIDIA.SuperRes.Strength.Weak="Weak" -Filter.VideoSuperResolution.NVIDIA.SuperRes.Strength.Strong="Strong" +# Filter - Upscaling +Filter.Upscaling="Upscaling" +Filter.Upscaling.Provider="Provider" +Filter.Upscaling.Provider.NVIDIAVideoSuperResolution="NVIDIA Video Super-Resolution, powered by NVIDIA Broadcast" +Filter.Upscaling.NVIDIA.SuperRes="NVIDIA Video Super-Resolution" +Filter.Upscaling.NVIDIA.SuperRes.Scale="Scale" +Filter.Upscaling.NVIDIA.SuperRes.Strength="Strength" +Filter.Upscaling.NVIDIA.SuperRes.Strength.Weak="Weak" +Filter.Upscaling.NVIDIA.SuperRes.Strength.Strong="Strong" # Source - Mirror Source.Mirror="Source Mirror" diff --git a/source/filters/filter-video-superresolution.cpp b/source/filters/filter-upscaling.cpp similarity index 71% rename from source/filters/filter-video-superresolution.cpp rename to source/filters/filter-upscaling.cpp index 2ef17502..21302436 100644 --- a/source/filters/filter-video-superresolution.cpp +++ b/source/filters/filter-upscaling.cpp @@ -18,7 +18,7 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. -#include "filter-video-superresolution.hpp" +#include "filter-upscaling.hpp" #include #include "obs/gs/gs-helper.hpp" #include "plugin.hpp" @@ -38,12 +38,12 @@ #define D_LOG_DEBUG(...) P_LOG_DEBUG(ST_PREFIX __VA_ARGS__) #endif -#define ST_I18N "Filter.VideoSuperResolution" +#define ST_I18N "Filter.Upscaling" #define ST_KEY_PROVIDER "Provider" #define ST_I18N_PROVIDER ST_I18N "." ST_KEY_PROVIDER -#define ST_I18N_PROVIDER_NVIDIA_SUPERRES ST_I18N_PROVIDER ".NVIDIAVideoSuperResolution" +#define ST_I18N_PROVIDER_NVIDIA_SUPERRES ST_I18N_PROVIDER ".NVIDIA.VideoSuperResolution" -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA #define ST_KEY_NVIDIA_SUPERRES "NVIDIA.SuperRes" #define ST_I18N_NVIDIA_SUPERRES ST_I18N "." ST_KEY_NVIDIA_SUPERRES #define ST_KEY_NVIDIA_SUPERRES_STRENGTH "NVIDIA.SuperRes.Strength" @@ -54,35 +54,35 @@ #define ST_I18N_NVIDIA_SUPERRES_SCALE ST_I18N "." ST_KEY_NVIDIA_SUPERRES_SCALE #endif -using streamfx::filter::video_superresolution::video_superresolution_factory; -using streamfx::filter::video_superresolution::video_superresolution_instance; -using streamfx::filter::video_superresolution::video_superresolution_provider; +using streamfx::filter::upscaling::upscaling_factory; +using streamfx::filter::upscaling::upscaling_instance; +using streamfx::filter::upscaling::upscaling_provider; static constexpr std::string_view HELP_URL = - "https://github.com/Xaymar/obs-StreamFX/wiki/Filter-Video-Super-Resolution"; + "https://github.com/Xaymar/obs-StreamFX/wiki/Filter-Upscaling"; /** Priority of providers for automatic selection if more than one is available. * */ -static video_superresolution_provider provider_priority[] = { - video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION, +static upscaling_provider provider_priority[] = { + upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION, }; -const char* streamfx::filter::video_superresolution::cstring(video_superresolution_provider provider) +const char* streamfx::filter::upscaling::cstring(upscaling_provider provider) { switch (provider) { - case video_superresolution_provider::INVALID: + case upscaling_provider::INVALID: return "N/A"; - case video_superresolution_provider::AUTOMATIC: + case upscaling_provider::AUTOMATIC: return D_TRANSLATE(S_STATE_AUTOMATIC); - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: return D_TRANSLATE(ST_I18N_PROVIDER_NVIDIA_SUPERRES); default: throw std::runtime_error("Missing Conversion Entry"); } } -std::string streamfx::filter::video_superresolution::string(video_superresolution_provider provider) +std::string streamfx::filter::upscaling::string(upscaling_provider provider) { return cstring(provider); } @@ -90,11 +90,11 @@ std::string streamfx::filter::video_superresolution::string(video_superresolutio //------------------------------------------------------------------------------ // Instance //------------------------------------------------------------------------------ -video_superresolution_instance::video_superresolution_instance(obs_data_t* data, obs_source_t* self) +upscaling_instance::upscaling_instance(obs_data_t* data, obs_source_t* self) : obs::source_instance(data, self), - _in_size(1, 1), _out_size(1, 1), _provider_ready(false), _provider(video_superresolution_provider::INVALID), - _provider_lock(), _provider_task(), _input(), _output(), _dirty(false) + _in_size(1, 1), _out_size(1, 1), _provider_ready(false), _provider(upscaling_provider::INVALID), _provider_lock(), + _provider_task(), _input(), _output(), _dirty(false) { { ::streamfx::obs::gs::context gctx; @@ -110,13 +110,13 @@ video_superresolution_instance::video_superresolution_instance(obs_data_t* data, } } -video_superresolution_instance::~video_superresolution_instance() +upscaling_instance::~upscaling_instance() { // TODO: Make this asynchronous. std::unique_lock ul(_provider_lock); switch (_provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_unload(); break; #endif @@ -125,20 +125,19 @@ video_superresolution_instance::~video_superresolution_instance() } } -void video_superresolution_instance::load(obs_data_t* data) +void upscaling_instance::load(obs_data_t* data) { update(data); } -void video_superresolution_instance::migrate(obs_data_t* data, uint64_t version) {} +void upscaling_instance::migrate(obs_data_t* data, uint64_t version) {} -void video_superresolution_instance::update(obs_data_t* data) +void upscaling_instance::update(obs_data_t* data) { // Check if the user changed which Denoising provider we use. - video_superresolution_provider provider = - static_cast(obs_data_get_int(data, ST_KEY_PROVIDER)); - if (provider == video_superresolution_provider::AUTOMATIC) { - provider = video_superresolution_factory::get()->find_ideal_provider(); + upscaling_provider provider = static_cast(obs_data_get_int(data, ST_KEY_PROVIDER)); + if (provider == upscaling_provider::AUTOMATIC) { + provider = upscaling_factory::get()->find_ideal_provider(); } // Check if the provider was changed, and if so switch. @@ -151,8 +150,8 @@ void video_superresolution_instance::update(obs_data_t* data) std::unique_lock ul(_provider_lock); switch (_provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_update(data); break; #endif @@ -162,11 +161,11 @@ void video_superresolution_instance::update(obs_data_t* data) } } -void streamfx::filter::video_superresolution::video_superresolution_instance::properties(obs_properties_t* properties) +void streamfx::filter::upscaling::upscaling_instance::properties(obs_properties_t* properties) { switch (_provider_ui) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_properties(properties); break; #endif @@ -175,17 +174,17 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::pr } } -uint32_t streamfx::filter::video_superresolution::video_superresolution_instance::get_width() +uint32_t streamfx::filter::upscaling::upscaling_instance::get_width() { return std::max(_out_size.first, 1); } -uint32_t streamfx::filter::video_superresolution::video_superresolution_instance::get_height() +uint32_t streamfx::filter::upscaling::upscaling_instance::get_height() { return std::max(_out_size.second, 1); } -void video_superresolution_instance::video_tick(float_t time) +void upscaling_instance::video_tick(float_t time) { auto target = obs_filter_get_target(_self); auto width = obs_source_get_base_width(target); @@ -198,8 +197,8 @@ void video_superresolution_instance::video_tick(float_t time) std::unique_lock ul(_provider_lock); switch (_provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_size(); break; #endif @@ -211,7 +210,7 @@ void video_superresolution_instance::video_tick(float_t time) _dirty = true; } -void video_superresolution_instance::video_render(gs_effect_t* effect) +void upscaling_instance::video_render(gs_effect_t* effect) { auto parent = obs_filter_get_parent(_self); auto target = obs_filter_get_target(_self); @@ -285,8 +284,8 @@ void video_superresolution_instance::video_render(gs_effect_t* effect) ::streamfx::obs::gs::debug_marker profiler1{::streamfx::obs::gs::debug_color_convert, "Process"}; #endif switch (_provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_process(); break; #endif @@ -320,11 +319,10 @@ void video_superresolution_instance::video_render(gs_effect_t* effect) } struct switch_provider_data_t { - video_superresolution_provider provider; + upscaling_provider provider; }; -void streamfx::filter::video_superresolution::video_superresolution_instance::switch_provider( - video_superresolution_provider provider) +void streamfx::filter::upscaling::upscaling_instance::switch_provider(upscaling_provider provider) { std::unique_lock ul(_provider_lock); @@ -353,11 +351,10 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::sw // 3. Then spawn a new task to switch provider. _provider_task = streamfx::threadpool()->push( - std::bind(&video_superresolution_instance::task_switch_provider, this, std::placeholders::_1), spd); + std::bind(&upscaling_instance::task_switch_provider, this, std::placeholders::_1), spd); } -void streamfx::filter::video_superresolution::video_superresolution_instance::task_switch_provider( - util::threadpool_data_t data) +void streamfx::filter::upscaling::upscaling_instance::task_switch_provider(util::threadpool_data_t data) { std::shared_ptr spd = std::static_pointer_cast(data); @@ -370,8 +367,8 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::ta try { // 3. Unload the previous provider. switch (spd->provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_unload(); break; #endif @@ -381,8 +378,8 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::ta // 4. Load the new provider. switch (_provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: nvvfxsr_load(); { auto data = obs_source_get_settings(_self); @@ -407,18 +404,18 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::ta } } -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_load() +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_load() { _nvidia_fx = std::make_shared<::streamfx::nvidia::vfx::superresolution>(); } -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_unload() +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_unload() { _nvidia_fx.reset(); } -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_size() +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_size() { if (!_nvidia_fx) { return; @@ -428,7 +425,7 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::nv _nvidia_fx->size(in_size, _in_size, _out_size); } -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_process() +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_process() { if (!_nvidia_fx) { _output = _input->get_texture(); @@ -438,8 +435,7 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::nv _output = _nvidia_fx->process(_input->get_texture()); } -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_properties( - obs_properties_t* props) +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_properties(obs_properties_t* props) { obs_properties_t* grp = obs_properties_create(); obs_properties_add_group(props, ST_KEY_NVIDIA_SUPERRES, D_TRANSLATE(ST_I18N_NVIDIA_SUPERRES), OBS_GROUP_NORMAL, @@ -460,7 +456,7 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::nv } } -void streamfx::filter::video_superresolution::video_superresolution_instance::nvvfxsr_update(obs_data_t* data) +void streamfx::filter::upscaling::upscaling_instance::nvvfxsr_update(obs_data_t* data) { if (!_nvidia_fx) return; @@ -475,14 +471,14 @@ void streamfx::filter::video_superresolution::video_superresolution_instance::nv //------------------------------------------------------------------------------ // Factory //------------------------------------------------------------------------------ -video_superresolution_factory::~video_superresolution_factory() {} +upscaling_factory::~upscaling_factory() {} -video_superresolution_factory::video_superresolution_factory() +upscaling_factory::upscaling_factory() { bool any_available = false; // 1. Try and load any configured providers. -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA try { // Load CVImage and Video Effects SDK. _nvcuda = ::streamfx::nvidia::cuda::obs::get(); @@ -520,16 +516,16 @@ video_superresolution_factory::video_superresolution_factory() finish_setup(); } -const char* video_superresolution_factory::get_name() +const char* upscaling_factory::get_name() { return D_TRANSLATE(ST_I18N); } -void video_superresolution_factory::get_defaults2(obs_data_t* data) +void upscaling_factory::get_defaults2(obs_data_t* data) { - obs_data_set_default_int(data, ST_KEY_PROVIDER, static_cast(video_superresolution_provider::AUTOMATIC)); + obs_data_set_default_int(data, ST_KEY_PROVIDER, static_cast(upscaling_provider::AUTOMATIC)); -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA obs_data_set_default_double(data, ST_KEY_NVIDIA_SUPERRES_SCALE, 150.); obs_data_set_default_double(data, ST_KEY_NVIDIA_SUPERRES_STRENGTH, 0.); #endif @@ -546,14 +542,14 @@ try { return false; } -obs_properties_t* video_superresolution_factory::get_properties2(video_superresolution_instance* data) +obs_properties_t* upscaling_factory::get_properties2(upscaling_instance* data) { obs_properties_t* pr = obs_properties_create(); #ifdef ENABLE_FRONTEND { - obs_properties_add_button2(pr, S_MANUAL_OPEN, D_TRANSLATE(S_MANUAL_OPEN), - video_superresolution_factory::on_manual_open, nullptr); + obs_properties_add_button2(pr, S_MANUAL_OPEN, D_TRANSLATE(S_MANUAL_OPEN), upscaling_factory::on_manual_open, + nullptr); } #endif @@ -570,10 +566,9 @@ obs_properties_t* video_superresolution_factory::get_properties2(video_superreso OBS_COMBO_FORMAT_INT); obs_property_set_modified_callback(p, modified_provider); obs_property_list_add_int(p, D_TRANSLATE(S_STATE_AUTOMATIC), - static_cast(video_superresolution_provider::AUTOMATIC)); - obs_property_list_add_int( - p, D_TRANSLATE(ST_I18N_PROVIDER_NVIDIA_SUPERRES), - static_cast(video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION)); + static_cast(upscaling_provider::AUTOMATIC)); + obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_PROVIDER_NVIDIA_SUPERRES), + static_cast(upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION)); } } @@ -581,7 +576,7 @@ obs_properties_t* video_superresolution_factory::get_properties2(video_superreso } #ifdef ENABLE_FRONTEND -bool video_superresolution_factory::on_manual_open(obs_properties_t* props, obs_property_t* property, void* data) +bool upscaling_factory::on_manual_open(obs_properties_t* props, obs_property_t* property, void* data) try { streamfx::open_url(HELP_URL); return false; @@ -594,12 +589,11 @@ try { } #endif -bool streamfx::filter::video_superresolution::video_superresolution_factory::is_provider_available( - video_superresolution_provider provider) +bool streamfx::filter::upscaling::upscaling_factory::is_provider_available(upscaling_provider provider) { switch (provider) { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA - case video_superresolution_provider::NVIDIA_VIDEO_SUPERRESOLUTION: +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA + case upscaling_provider::NVIDIA_VIDEO_SUPERRESOLUTION: return _nvidia_available; #endif default: @@ -607,36 +601,35 @@ bool streamfx::filter::video_superresolution::video_superresolution_factory::is_ } } -video_superresolution_provider - streamfx::filter::video_superresolution::video_superresolution_factory::find_ideal_provider() +upscaling_provider streamfx::filter::upscaling::upscaling_factory::find_ideal_provider() { for (auto v : provider_priority) { - if (video_superresolution_factory::get()->is_provider_available(v)) { + if (upscaling_factory::get()->is_provider_available(v)) { return v; break; } } - return video_superresolution_provider::AUTOMATIC; + return upscaling_provider::AUTOMATIC; } -std::shared_ptr _video_superresolution_factory_instance = nullptr; +std::shared_ptr _video_superresolution_factory_instance = nullptr; -void video_superresolution_factory::initialize() +void upscaling_factory::initialize() try { if (!_video_superresolution_factory_instance) - _video_superresolution_factory_instance = std::make_shared(); + _video_superresolution_factory_instance = std::make_shared(); } catch (const std::exception& ex) { D_LOG_ERROR("Failed to initialize due to error: %s", ex.what()); } catch (...) { D_LOG_ERROR("Failed to initialize due to unknown error.", ""); } -void video_superresolution_factory::finalize() +void upscaling_factory::finalize() { _video_superresolution_factory_instance.reset(); } -std::shared_ptr video_superresolution_factory::get() +std::shared_ptr upscaling_factory::get() { return _video_superresolution_factory_instance; } diff --git a/source/filters/filter-video-superresolution.hpp b/source/filters/filter-upscaling.hpp similarity index 63% rename from source/filters/filter-video-superresolution.hpp rename to source/filters/filter-upscaling.hpp index 53cc7367..e3827925 100644 --- a/source/filters/filter-video-superresolution.hpp +++ b/source/filters/filter-upscaling.hpp @@ -28,42 +28,42 @@ #include "plugin.hpp" #include "util/util-threadpool.hpp" -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA #include "nvidia/vfx/nvidia-vfx-superresolution.hpp" #endif -namespace streamfx::filter::video_superresolution { - enum class video_superresolution_provider { +namespace streamfx::filter::upscaling { + enum class upscaling_provider { INVALID = -1, AUTOMATIC = 0, NVIDIA_VIDEO_SUPERRESOLUTION = 1, }; - const char* cstring(video_superresolution_provider provider); + const char* cstring(upscaling_provider provider); - std::string string(video_superresolution_provider provider); + std::string string(upscaling_provider provider); - class video_superresolution_instance : public ::streamfx::obs::source_instance { + class upscaling_instance : public ::streamfx::obs::source_instance { std::pair _in_size; std::pair _out_size; - std::atomic _provider_ready; - std::atomic _provider; - video_superresolution_provider _provider_ui; - std::mutex _provider_lock; - std::shared_ptr _provider_task; + std::atomic _provider; + upscaling_provider _provider_ui; + std::atomic _provider_ready; + std::mutex _provider_lock; + std::shared_ptr _provider_task; std::shared_ptr<::streamfx::obs::gs::rendertarget> _input; std::shared_ptr<::streamfx::obs::gs::texture> _output; bool _dirty; -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA std::shared_ptr<::streamfx::nvidia::vfx::superresolution> _nvidia_fx; #endif public: - video_superresolution_instance(obs_data_t* data, obs_source_t* self); - ~video_superresolution_instance() override; + upscaling_instance(obs_data_t* data, obs_source_t* self); + ~upscaling_instance() override; void load(obs_data_t* data) override; void migrate(obs_data_t* data, uint64_t version) override; @@ -77,10 +77,10 @@ namespace streamfx::filter::video_superresolution { void video_render(gs_effect_t* effect) override; private: - void switch_provider(video_superresolution_provider provider); + void switch_provider(upscaling_provider provider); void task_switch_provider(util::threadpool_data_t data); -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA void nvvfxsr_load(); void nvvfxsr_unload(); void nvvfxsr_size(); @@ -90,11 +90,10 @@ namespace streamfx::filter::video_superresolution { #endif }; - class video_superresolution_factory - : public ::streamfx::obs::source_factory< - ::streamfx::filter::video_superresolution::video_superresolution_factory, - ::streamfx::filter::video_superresolution::video_superresolution_instance> { -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION_NVIDIA + class upscaling_factory + : public ::streamfx::obs::source_factory<::streamfx::filter::upscaling::upscaling_factory, + ::streamfx::filter::upscaling::upscaling_instance> { +#ifdef ENABLE_FILTER_UPSCALING_NVIDIA bool _nvidia_available; std::shared_ptr<::streamfx::nvidia::cuda::obs> _nvcuda; std::shared_ptr<::streamfx::nvidia::cv::cv> _nvcvi; @@ -102,25 +101,25 @@ namespace streamfx::filter::video_superresolution { #endif public: - virtual ~video_superresolution_factory(); - video_superresolution_factory(); + virtual ~upscaling_factory(); + upscaling_factory(); virtual const char* get_name() override; virtual void get_defaults2(obs_data_t* data) override; - virtual obs_properties_t* get_properties2(video_superresolution_instance* data) override; + virtual obs_properties_t* get_properties2(upscaling_instance* data) override; #ifdef ENABLE_FRONTEND static bool on_manual_open(obs_properties_t* props, obs_property_t* property, void* data); #endif - bool is_provider_available(video_superresolution_provider); - video_superresolution_provider find_ideal_provider(); + bool is_provider_available(upscaling_provider); + upscaling_provider find_ideal_provider(); public: // Singleton - static void initialize(); - static void finalize(); - static std::shared_ptr<::streamfx::filter::video_superresolution::video_superresolution_factory> get(); + static void initialize(); + static void finalize(); + static std::shared_ptr<::streamfx::filter::upscaling::upscaling_factory> get(); }; -} // namespace streamfx::filter::video_superresolution +} // namespace streamfx::filter::upscaling diff --git a/source/plugin.cpp b/source/plugin.cpp index bc75c71d..48c21357 100644 --- a/source/plugin.cpp +++ b/source/plugin.cpp @@ -59,8 +59,8 @@ #ifdef ENABLE_FILTER_TRANSFORM #include "filters/filter-transform.hpp" #endif -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION -#include "filters/filter-video-superresolution.hpp" +#ifdef ENABLE_FILTER_UPSCALING +#include "filters/filter-upscaling.hpp" #endif #ifdef ENABLE_SOURCE_MIRROR @@ -167,8 +167,8 @@ try { #ifdef ENABLE_FILTER_TRANSFORM streamfx::filter::transform::transform_factory::initialize(); #endif -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION - streamfx::filter::video_superresolution::video_superresolution_factory::initialize(); +#ifdef ENABLE_FILTER_UPSCALING + streamfx::filter::upscaling::upscaling_factory::initialize(); #endif } @@ -256,8 +256,8 @@ try { #ifdef ENABLE_FILTER_TRANSFORM streamfx::filter::transform::transform_factory::finalize(); #endif -#ifdef ENABLE_FILTER_VIDEO_SUPERRESOLUTION - streamfx::filter::video_superresolution::video_superresolution_factory::finalize(); +#ifdef ENABLE_FILTER_UPSCALING + streamfx::filter::upscaling::upscaling_factory::finalize(); #endif }