RomanNum3ral
/
obs-streamFX
mirror of https://github.com/RomanNum3ral/obs-StreamFX.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

project: Apply more C++ paradigms to the code 

- Use auto in places where code clarity is improved or identical.
- Replace trivial constructors and destructors with default.
- Use true random for random generation.
- Use std::string_view where it is valid to do so.
- Apply const where it is valid to do so.
- Use references where it is valid to do so.
- Manually optimize memory usage with std::move and std::copy.
- Opt for memory efficient containers where the size is known ahead of time.

Signed-off-by: lainon <GermanAizek@yandex.ru>
This commit is contained in:
lainon 2022-07-21 13:09:10 +02:00 committed by Michael Fabian 'Xaymar' Dirks
parent cbddee5b90
commit 6e1566386e
62 changed files with 200 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
source/encoders/encoder-ffmpeg.cpp
View File

@ -824,7 +824,7 @@ const AVCodecContext* ffmpeg_instance::get_avcodeccontext()
return _context; return _context;
} }
void ffmpeg_instance::parse_ffmpeg_commandline(std::string text) void ffmpeg_instance::parse_ffmpeg_commandline(std::string_view text)
{ {
// Steps to properly parse a command line: // Steps to properly parse a command line:
// 1. Split by space and package by quotes. // 1. Split by space and package by quotes.
@ -915,7 +915,7 @@ void ffmpeg_instance::parse_ffmpeg_commandline(std::string text)
// have also dealt with escaping for the most part. We want to parse // have also dealt with escaping for the most part. We want to parse
// an FFmpeg commandline option set here, so the first character in // an FFmpeg commandline option set here, so the first character in
// the string must be a '-'. // the string must be a '-'.
for (std::string& opt : opts) { for (const auto& opt : opts) {
// Skip empty options. // Skip empty options.
if (opt.size() == 0) if (opt.size() == 0)
continue; continue;
@ -1133,7 +1133,7 @@ obs_properties_t* ffmpeg_factory::get_properties2(instance_t* data)
if (_handler && _handler->has_threading_support(this)) { if (_handler && _handler->has_threading_support(this)) {
auto p = obs_properties_add_int_slider(grp, ST_KEY_FFMPEG_THREADS, D_TRANSLATE(ST_I18N_FFMPEG_THREADS), 0, auto p = obs_properties_add_int_slider(grp, ST_KEY_FFMPEG_THREADS, D_TRANSLATE(ST_I18N_FFMPEG_THREADS), 0,
static_cast<int64_t>(std::thread::hardware_concurrency() * 2), 1); static_cast<int64_t>(std::thread::hardware_concurrency()) * 2, 1);
} }
}; };
@ -1220,9 +1220,9 @@ std::shared_ptr<handler::handler> ffmpeg_manager::get_handler(std::string codec)
#endif #endif
} }
bool ffmpeg_manager::has_handler(std::string codec) bool ffmpeg_manager::has_handler(std::string_view codec)
{ {
return (_handlers.find(codec) != _handlers.end()); return (_handlers.find(codec.data()) != _handlers.end());
} }
std::shared_ptr<ffmpeg_manager> _ffmepg_encoder_factory_instance = nullptr; std::shared_ptr<ffmpeg_manager> _ffmepg_encoder_factory_instance = nullptr;

4
source/encoders/encoder-ffmpeg.hpp
View File

@ -123,7 +123,7 @@ namespace streamfx::encoder::ffmpeg {
const AVCodecContext* get_avcodeccontext(); const AVCodecContext* get_avcodeccontext();
void parse_ffmpeg_commandline(std::string text); void parse_ffmpeg_commandline(std::string_view text);
}; };
class ffmpeg_factory : public obs::encoder_factory<ffmpeg_factory, ffmpeg_instance> { class ffmpeg_factory : public obs::encoder_factory<ffmpeg_factory, ffmpeg_instance> {
@ -172,7 +172,7 @@ namespace streamfx::encoder::ffmpeg {
std::shared_ptr<handler::handler> get_handler(std::string codec); std::shared_ptr<handler::handler> get_handler(std::string codec);
bool has_handler(std::string codec); bool has_handler(std::string_view codec);
public: // Singleton public: // Singleton
static void initialize(); static void initialize();

2
source/encoders/handlers/dnxhd_handler.cpp
View File

@ -27,7 +27,7 @@ void dnxhd_handler::override_colorformat(AVPixelFormat& target_format, obs_data_
std::pair{"dnxhr_444", AV_PIX_FMT_YUV444P10LE}}; std::pair{"dnxhr_444", AV_PIX_FMT_YUV444P10LE}};
const char* selected_profile = obs_data_get_string(settings, S_CODEC_DNXHR_PROFILE); const char* selected_profile = obs_data_get_string(settings, S_CODEC_DNXHR_PROFILE);
for (auto kv : profile_to_format_map) { for (const auto& kv : profile_to_format_map) {
if (strcmp(kv.first, selected_profile) == 0) { if (strcmp(kv.first, selected_profile) == 0) {
target_format = kv.second; target_format = kv.second;
return; return;

4
source/encoders/handlers/nvenc_h264_handler.cpp
View File

@ -94,10 +94,10 @@ void nvenc_h264_handler::update(obs_data_t* settings, const AVCodec* codec, AVCo
nvenc::update(settings, codec, context); nvenc::update(settings, codec, context);
if (!context->internal) { if (!context->internal) {
if (auto v = obs_data_get_string(settings, ST_KEY_PROFILE); v && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_PROFILE); v && (v[0] != '\0')) {
av_opt_set(context->priv_data, "profile", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "profile", v, AV_OPT_SEARCH_CHILDREN);
} }
if (auto v = obs_data_get_string(settings, ST_KEY_LEVEL); v && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_LEVEL); v && (v[0] != '\0')) {
av_opt_set(context->priv_data, "level", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "level", v, AV_OPT_SEARCH_CHILDREN);
} }
} }

6
source/encoders/handlers/nvenc_hevc_handler.cpp
View File

@ -92,13 +92,13 @@ void nvenc_hevc_handler::update(obs_data_t* settings, const AVCodec* codec, AVCo
nvenc::update(settings, codec, context); nvenc::update(settings, codec, context);
if (!context->internal) { if (!context->internal) {
if (auto v = obs_data_get_string(settings, ST_KEY_PROFILE); v && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_PROFILE); v && (v[0] != '\0')) {
av_opt_set(context->priv_data, "profile", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "profile", v, AV_OPT_SEARCH_CHILDREN);
} }
if (auto v = obs_data_get_string(settings, ST_KEY_TIER); v && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_TIER); v && (v[0] != '\0')) {
av_opt_set(context->priv_data, "tier", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "tier", v, AV_OPT_SEARCH_CHILDREN);
} }
if (auto v = obs_data_get_string(settings, ST_KEY_LEVEL); v && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_LEVEL); v && (v[0] != '\0')) {
av_opt_set(context->priv_data, "level", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "level", v, AV_OPT_SEARCH_CHILDREN);
} }
} }

28
source/encoders/handlers/nvenc_shared.cpp
View File

@ -202,12 +202,12 @@ void nvenc::get_defaults(obs_data_t* settings, const AVCodec*, AVCodecContext*)
static bool modified_ratecontrol(obs_properties_t* props, obs_property_t*, obs_data_t* settings) noexcept static bool modified_ratecontrol(obs_properties_t* props, obs_property_t*, obs_data_t* settings) noexcept
{ {
// Decode the name into useful flags. // Decode the name into useful flags.
auto value = obs_data_get_string(settings, ST_KEY_RATECONTROL_MODE); const char* value = obs_data_get_string(settings, ST_KEY_RATECONTROL_MODE);
bool have_bitrate = false; bool have_bitrate = false;
bool have_bitrate_range = false; bool have_bitrate_range = false;
bool have_quality = false; bool have_quality = false;
bool have_qp_limits = false; bool have_qp_limits = false;
bool have_qp = false; bool have_qp = false;
if (value == std::string_view("cbr")) { if (value == std::string_view("cbr")) {
have_bitrate = true; have_bitrate = true;
} else if (value == std::string_view("vbr")) { } else if (value == std::string_view("vbr")) {
@ -513,14 +513,14 @@ void nvenc::get_runtime_properties(obs_properties_t* props, const AVCodec*, AVCo
void nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) void nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
{ {
if (auto v = obs_data_get_string(settings, ST_KEY_PRESET); if (const char* v = obs_data_get_string(settings, ST_KEY_PRESET);
!context->internal && (v != nullptr) && (strlen(v) > 0)) { !context->internal && (v != nullptr) && (v[0] != '\0')) {
av_opt_set(context->priv_data, "preset", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "preset", v, AV_OPT_SEARCH_CHILDREN);
} }
{ // Rate Control { // Rate Control
auto v = obs_data_get_string(settings, ST_KEY_RATECONTROL_MODE); const char* v = obs_data_get_string(settings, ST_KEY_RATECONTROL_MODE);
if (!context->internal && (v != nullptr) && (strlen(v) > 0)) { if (!context->internal && (v != nullptr) && (v[0] != '\0')) {
av_opt_set(context->priv_data, "rc", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "rc", v, AV_OPT_SEARCH_CHILDREN);
} }
@ -572,8 +572,8 @@ void nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* c
if (!context->internal) { if (!context->internal) {
if (streamfx::ffmpeg::tools::avoption_exists(context->priv_data, "multipass")) { if (streamfx::ffmpeg::tools::avoption_exists(context->priv_data, "multipass")) {
// Multi-Pass // Multi-Pass
if (auto v = obs_data_get_string(settings, ST_KEY_RATECONTROL_MULTIPASS); if (const char* v = obs_data_get_string(settings, ST_KEY_RATECONTROL_MULTIPASS);
(v != nullptr) && (strlen(v) > 0)) { (v != nullptr) && (v[0] != '\0')) {
av_opt_set(context->priv_data, "multipass", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "multipass", v, AV_OPT_SEARCH_CHILDREN);
av_opt_set_int(context->priv_data, "2pass", 0, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(context->priv_data, "2pass", 0, AV_OPT_SEARCH_CHILDREN);
} }
@ -717,8 +717,8 @@ void nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* c
av_opt_set_int(context->priv_data, "weighted_pred", wp, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(context->priv_data, "weighted_pred", wp, AV_OPT_SEARCH_CHILDREN);
} }
if (auto v = obs_data_get_string(settings, ST_KEY_OTHER_BFRAMEREFERENCEMODE); if (const char* v = obs_data_get_string(settings, ST_KEY_OTHER_BFRAMEREFERENCEMODE);
(v != nullptr) && (strlen(v) > 0)) { (v != nullptr) && (v[0] != '\0')) {
av_opt_set(context->priv_data, "b_ref_mode", v, AV_OPT_SEARCH_CHILDREN); av_opt_set(context->priv_data, "b_ref_mode", v, AV_OPT_SEARCH_CHILDREN);
} }

2
source/ffmpeg/avframe-queue.cpp
View File

@ -42,7 +42,7 @@ std::shared_ptr<AVFrame> avframe_queue::create_frame()
return frame; return frame;
} }
avframe_queue::avframe_queue() {} avframe_queue::avframe_queue() = default;
avframe_queue::~avframe_queue() avframe_queue::~avframe_queue()
{ {

2
source/ffmpeg/hwapi/base.hpp
View File

@ -63,7 +63,7 @@ namespace streamfx::ffmpeg::hwapi {
virtual std::list<hwapi::device> enumerate_adapters() = 0; virtual std::list<hwapi::device> enumerate_adapters() = 0;
virtual std::shared_ptr<hwapi::instance> create(hwapi::device target) = 0; virtual std::shared_ptr<hwapi::instance> create(const hwapi::device& target) = 0;
virtual std::shared_ptr<hwapi::instance> create_from_obs() = 0; virtual std::shared_ptr<hwapi::instance> create_from_obs() = 0;
}; };

8
source/ffmpeg/hwapi/d3d11.cpp
View File

@ -102,7 +102,7 @@ std::list<device> d3d11::enumerate_adapters()
return std::move(adapters); return std::move(adapters);
} }
std::shared_ptr<instance> d3d11::create(device target) std::shared_ptr<instance> d3d11::create(const device& target)
{ {
std::shared_ptr<d3d11_instance> inst; std::shared_ptr<d3d11_instance> inst;
ATL::CComPtr<ID3D11Device> device; ATL::CComPtr<ID3D11Device> device;
@ -156,10 +156,8 @@ struct D3D11AVFrame {
}; };
d3d11_instance::d3d11_instance(ATL::CComPtr<ID3D11Device> device, ATL::CComPtr<ID3D11DeviceContext> context) d3d11_instance::d3d11_instance(ATL::CComPtr<ID3D11Device> device, ATL::CComPtr<ID3D11DeviceContext> context)
{ : _device(device), _context(context)
_device = device; {}
_context = context;
}
d3d11_instance::~d3d11_instance() {} d3d11_instance::~d3d11_instance() {}

2
source/ffmpeg/hwapi/d3d11.hpp
View File

@ -57,7 +57,7 @@ namespace streamfx::ffmpeg::hwapi {
virtual std::list<hwapi::device> enumerate_adapters() override; virtual std::list<hwapi::device> enumerate_adapters() override;
virtual std::shared_ptr<hwapi::instance> create(hwapi::device target) override; virtual std::shared_ptr<hwapi::instance> create(const hwapi::device& target) override;
virtual std::shared_ptr<hwapi::instance> create_from_obs() override; virtual std::shared_ptr<hwapi::instance> create_from_obs() override;
}; };

2
source/ffmpeg/swscale.cpp
View File

@ -24,7 +24,7 @@
using namespace streamfx::ffmpeg; using namespace streamfx::ffmpeg;
swscale::swscale() {} swscale::swscale() = default;
swscale::~swscale() swscale::~swscale()
{ {

33
source/ffmpeg/tools.cpp
View File

@ -357,66 +357,65 @@ const char* tools::get_thread_type_name(int thread_type)
} }
} }
void tools::print_av_option_bool(AVCodecContext* ctx_codec, const char* option, std::string text, bool inverse) void tools::print_av_option_bool(AVCodecContext* ctx_codec, const char* option, std::string_view text, bool inverse)
{ {
print_av_option_bool(ctx_codec, ctx_codec, option, text, inverse); print_av_option_bool(ctx_codec, ctx_codec, option, text, inverse);
} }
void tools::print_av_option_bool(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, void tools::print_av_option_bool(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string_view text,
bool inverse) bool inverse)
{ {
int64_t v = 0; int64_t v = 0;
if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) { if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) {
DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text.c_str(), DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text,
streamfx::ffmpeg::tools::get_error_description(err)); streamfx::ffmpeg::tools::get_error_description(err));
} else { } else {
DLOG_INFO("[%s] %s: %s%s", ctx_codec->codec->name, text.c_str(), DLOG_INFO("[%s] %s: %s%s", ctx_codec->codec->name, text, (inverse ? v != 0 : v == 0) ? "Disabled" : "Enabled",
(inverse ? v != 0 : v == 0) ? "Disabled" : "Enabled",
av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0 ? " <Default>" : ""); av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0 ? " <Default>" : "");
} }
} }
void tools::print_av_option_int(AVCodecContext* ctx_codec, const char* option, std::string text, std::string suffix) void tools::print_av_option_int(AVCodecContext* ctx_codec, const char* option, std::string_view text,
std::string_view suffix)
{ {
print_av_option_int(ctx_codec, ctx_codec, option, text, suffix); print_av_option_int(ctx_codec, ctx_codec, option, text, suffix);
} }
void tools::print_av_option_int(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, void tools::print_av_option_int(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string_view text,
std::string suffix) std::string_view suffix)
{ {
int64_t v = 0; int64_t v = 0;
bool is_default = av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0; bool is_default = av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0;
if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) { if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) {
if (is_default) { if (is_default) {
DLOG_INFO("[%s] %s: <Default>", ctx_codec->codec->name, text.c_str()); DLOG_INFO("[%s] %s: <Default>", ctx_codec->codec->name, text);
} else { } else {
DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text.c_str(), DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text,
streamfx::ffmpeg::tools::get_error_description(err)); streamfx::ffmpeg::tools::get_error_description(err));
} }
} else { } else {
DLOG_INFO("[%s] %s: %" PRId64 " %s%s", ctx_codec->codec->name, text.c_str(), v, suffix.c_str(), DLOG_INFO("[%s] %s: %" PRId64 " %s%s", ctx_codec->codec->name, text, v, suffix, is_default ? " <Default>" : "");
is_default ? " <Default>" : "");
} }
} }
void tools::print_av_option_string(AVCodecContext* ctx_codec, const char* option, std::string text, void tools::print_av_option_string(AVCodecContext* ctx_codec, const char* option, std::string_view text,
std::function<std::string(int64_t)> decoder) std::function<std::string(int64_t)> decoder)
{ {
print_av_option_string(ctx_codec, ctx_codec, option, text, decoder); print_av_option_string(ctx_codec, ctx_codec, option, text, decoder);
} }
void tools::print_av_option_string(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, void tools::print_av_option_string(AVCodecContext* ctx_codec, void* ctx_option, const char* option,
std::function<std::string(int64_t)> decoder) std::string_view text, std::function<std::string(int64_t)> decoder)
{ {
int64_t v = 0; int64_t v = 0;
if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) { if (int err = av_opt_get_int(ctx_option, option, AV_OPT_SEARCH_CHILDREN, &v); err != 0) {
DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text.c_str(), DLOG_INFO("[%s] %s: <Error: %s>", ctx_codec->codec->name, text,
streamfx::ffmpeg::tools::get_error_description(err)); streamfx::ffmpeg::tools::get_error_description(err));
} else { } else {
std::string name = "<Unknown>"; std::string name = "<Unknown>";
if (decoder) if (decoder)
name = decoder(v); name = decoder(v);
DLOG_INFO("[%s] %s: %s%s", ctx_codec->codec->name, text.c_str(), name.c_str(), DLOG_INFO("[%s] %s: %s%s", ctx_codec->codec->name, text, name.c_str(),
av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0 ? " <Default>" : ""); av_opt_is_set_to_default_by_name(ctx_option, option, AV_OPT_SEARCH_CHILDREN) > 0 ? " <Default>" : "");
} }
} }

15
source/ffmpeg/tools.hpp
View File

@ -63,17 +63,18 @@ namespace streamfx::ffmpeg::tools {
const char* get_thread_type_name(int thread_type); const char* get_thread_type_name(int thread_type);
void print_av_option_bool(AVCodecContext* context, const char* option, std::string text, bool inverse = false); void print_av_option_bool(AVCodecContext* context, const char* option, std::string_view text, bool inverse = false);
void print_av_option_bool(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, void print_av_option_bool(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string_view text,
bool inverse = false); bool inverse = false);
void print_av_option_int(AVCodecContext* context, const char* option, std::string text, std::string suffix); void print_av_option_int(AVCodecContext* context, const char* option, std::string_view text,
void print_av_option_int(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, std::string_view suffix);
std::string suffix); void print_av_option_int(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string_view text,
std::string_view suffix);
void print_av_option_string(AVCodecContext* context, const char* option, std::string text, void print_av_option_string(AVCodecContext* context, const char* option, std::string_view text,
std::function<std::string(int64_t)> decoder); std::function<std::string(int64_t)> decoder);
void print_av_option_string(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string text, void print_av_option_string(AVCodecContext* ctx_codec, void* ctx_option, const char* option, std::string_view text,
std::function<std::string(int64_t)> decoder); std::function<std::string(int64_t)> decoder);
void print_av_option_string2(AVCodecContext* context, std::string_view option, std::string_view text, void print_av_option_string2(AVCodecContext* context, std::string_view option, std::string_view text,

16
source/filters/filter-autoframing.cpp
View File

@ -246,7 +246,7 @@ void autoframing_instance::update(obs_data_t* data)
// Tracking // Tracking
_track_mode = static_cast<tracking_mode>(obs_data_get_int(data, ST_KEY_TRACKING_MODE)); _track_mode = static_cast<tracking_mode>(obs_data_get_int(data, ST_KEY_TRACKING_MODE));
{ {
if (auto text = obs_data_get_string(data, ST_KEY_TRACKING_FREQUENCY); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_TRACKING_FREQUENCY); text != nullptr) {
float value = 0.; float value = 0.;
if (sscanf(text, "%f", &value) == 1) { if (sscanf(text, "%f", &value) == 1) {
if (const char* seconds = strchr(text, 's'); seconds == nullptr) { if (const char* seconds = strchr(text, 's'); seconds == nullptr) {
@ -284,7 +284,7 @@ void autoframing_instance::update(obs_data_t* data)
_frame_size_y = {_frame_stability_kalman, 1.0f, ST_KALMAN_EEC, _frame_size_y.get()}; _frame_size_y = {_frame_stability_kalman, 1.0f, ST_KALMAN_EEC, _frame_size_y.get()};
} }
{ // Padding { // Padding
if (auto text = obs_data_get_string(data, ST_KEY_FRAMING_PADDING ".X"); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_FRAMING_PADDING ".X"); text != nullptr) {
float value = 0.; float value = 0.;
if (sscanf(text, "%f", &value) == 1) { if (sscanf(text, "%f", &value) == 1) {
if (const char* percent = strchr(text, '%'); percent != nullptr) { if (const char* percent = strchr(text, '%'); percent != nullptr) {
@ -297,7 +297,7 @@ void autoframing_instance::update(obs_data_t* data)
} }
_frame_padding.x = value; _frame_padding.x = value;
} }
if (auto text = obs_data_get_string(data, ST_KEY_FRAMING_PADDING ".Y"); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_FRAMING_PADDING ".Y"); text != nullptr) {
float value = 0.; float value = 0.;
if (sscanf(text, "%f", &value) == 1) { if (sscanf(text, "%f", &value) == 1) {
if (const char* percent = strchr(text, '%'); percent != nullptr) { if (const char* percent = strchr(text, '%'); percent != nullptr) {
@ -312,7 +312,7 @@ void autoframing_instance::update(obs_data_t* data)
} }
} }
{ // Offset { // Offset
if (auto text = obs_data_get_string(data, ST_KEY_FRAMING_OFFSET ".X"); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_FRAMING_OFFSET ".X"); text != nullptr) {
float value = 0.; float value = 0.;
if (sscanf(text, "%f", &value) == 1) { if (sscanf(text, "%f", &value) == 1) {
if (const char* percent = strchr(text, '%'); percent != nullptr) { if (const char* percent = strchr(text, '%'); percent != nullptr) {
@ -325,7 +325,7 @@ void autoframing_instance::update(obs_data_t* data)
} }
_frame_offset.x = value; _frame_offset.x = value;
} }
if (auto text = obs_data_get_string(data, ST_KEY_FRAMING_OFFSET ".Y"); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_FRAMING_OFFSET ".Y"); text != nullptr) {
float value = 0.; float value = 0.;
if (sscanf(text, "%f", &value) == 1) { if (sscanf(text, "%f", &value) == 1) {
if (const char* percent = strchr(text, '%'); percent != nullptr) { if (const char* percent = strchr(text, '%'); percent != nullptr) {
@ -341,7 +341,7 @@ void autoframing_instance::update(obs_data_t* data)
} }
{ // Aspect Ratio { // Aspect Ratio
_frame_aspect_ratio = static_cast<float>(_size.first) / static_cast<float>(_size.second); _frame_aspect_ratio = static_cast<float>(_size.first) / static_cast<float>(_size.second);
if (auto text = obs_data_get_string(data, ST_KEY_FRAMING_ASPECTRATIO); text != nullptr) { if (const char* text = obs_data_get_string(data, ST_KEY_FRAMING_ASPECTRATIO); text != nullptr) {
if (const char* percent = strchr(text, ':'); percent != nullptr) { if (const char* percent = strchr(text, ':'); percent != nullptr) {
float left = 0.; float left = 0.;
float right = 0.; float right = 0.;
@ -479,7 +479,7 @@ void autoframing_instance::video_render(gs_effect_t* effect)
auto op = _input->render(width, height); auto op = _input->render(width, height);
// Set correct projection matrix. // Set correct projection matrix.
gs_ortho(0, width, 0, height, 0, 1); gs_ortho(0, static_cast<float>(width), 0, static_cast<float>(height), 0, 1);
// Clear the buffer // Clear the buffer
gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &blank, 0, 0); gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &blank, 0, 0);
@ -982,7 +982,7 @@ void streamfx::filter::autoframing::autoframing_instance::nvar_facedetection_pro
// Try and find a match in the current list of tracked elements. // Try and find a match in the current list of tracked elements.
std::shared_ptr<track_el> match; std::shared_ptr<track_el> match;
float match_dst = max_dst; float match_dst = max_dst;
for (auto el : _tracked_elements) { for (const auto& el : _tracked_elements) {
// Skip "fresh" elements. // Skip "fresh" elements.
if (el->age < 0.00001) { if (el->age < 0.00001) {
continue; continue;

2
source/filters/filter-displacement.cpp
View File

@ -95,7 +95,7 @@ void displacement_instance::update(obs_data_t* settings)
_scale[0] = _scale[1] = static_cast<float_t>(obs_data_get_double(settings, ST_KEY_SCALE)); _scale[0] = _scale[1] = static_cast<float_t>(obs_data_get_double(settings, ST_KEY_SCALE));
_scale_type = static_cast<float_t>(obs_data_get_double(settings, ST_KEY_SCALE_TYPE) / 100.0); _scale_type = static_cast<float_t>(obs_data_get_double(settings, ST_KEY_SCALE_TYPE) / 100.0);
std::string new_file = obs_data_get_string(settings, ST_KEY_FILE); const char* new_file = obs_data_get_string(settings, ST_KEY_FILE);
if (new_file != _texture_file) { if (new_file != _texture_file) {
try { try {
_texture = std::make_shared<streamfx::obs::gs::texture>(new_file); _texture = std::make_shared<streamfx::obs::gs::texture>(new_file);

2
source/filters/filter-dynamic-mask.cpp
View File

@ -112,7 +112,7 @@ void dynamic_mask_instance::migrate(obs_data_t* data, uint64_t version) {}
void dynamic_mask_instance::update(obs_data_t* settings) void dynamic_mask_instance::update(obs_data_t* settings)
{ {
// Update source. // Update source.
if (auto v = obs_data_get_string(settings, ST_KEY_INPUT); (v != nullptr) && (strlen(v) > 0)) { if (const char* v = obs_data_get_string(settings, ST_KEY_INPUT); (v != nullptr) && (v[0] != '\0')) {
if (!acquire(v)) if (!acquire(v))
DLOG_ERROR("Failed to acquire Input source '%s'.", v); DLOG_ERROR("Failed to acquire Input source '%s'.", v);
} else { } else {

8
source/filters/filter-transform.cpp
View File

@ -705,7 +705,7 @@ obs_properties_t* transform_factory::get_properties2(transform_instance* data)
{ST_KEY_POSITION_Y, "Y"}, {ST_KEY_POSITION_Y, "Y"},
{ST_KEY_POSITION_Z, "Z"}, {ST_KEY_POSITION_Z, "Z"},
}; };
for (auto opt : opts) { for (const auto& opt : opts) {
auto p = obs_properties_add_float(grp, opt.first.c_str(), D_TRANSLATE(opt.second.c_str()), auto p = obs_properties_add_float(grp, opt.first.c_str(), D_TRANSLATE(opt.second.c_str()),
std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(),
std::numeric_limits<float>::max(), 0.01); std::numeric_limits<float>::max(), 0.01);
@ -721,7 +721,7 @@ obs_properties_t* transform_factory::get_properties2(transform_instance* data)
{ST_KEY_ROTATION_Y, D_TRANSLATE(ST_I18N_ROTATION ".Y")}, {ST_KEY_ROTATION_Y, D_TRANSLATE(ST_I18N_ROTATION ".Y")},
{ST_KEY_ROTATION_Z, D_TRANSLATE(ST_I18N_ROTATION ".Z")}, {ST_KEY_ROTATION_Z, D_TRANSLATE(ST_I18N_ROTATION ".Z")},
}; };
for (auto opt : opts) { for (const auto& opt : opts) {
auto p = obs_properties_add_float_slider(grp, opt.first.c_str(), D_TRANSLATE(opt.second.c_str()), auto p = obs_properties_add_float_slider(grp, opt.first.c_str(), D_TRANSLATE(opt.second.c_str()),
-180.0, 180.0, 0.01); -180.0, 180.0, 0.01);
obs_property_float_set_suffix(p, "° Deg"); obs_property_float_set_suffix(p, "° Deg");
@ -736,7 +736,7 @@ obs_properties_t* transform_factory::get_properties2(transform_instance* data)
{ST_KEY_SCALE_X, "X"}, {ST_KEY_SCALE_X, "X"},
{ST_KEY_SCALE_Y, "Y"}, {ST_KEY_SCALE_Y, "Y"},
}; };
for (auto opt : opts) { for (const auto& opt : opts) {
auto p = obs_properties_add_float_slider(grp, opt.first.c_str(), opt.second.c_str(), -1000, 1000, 0.01); auto p = obs_properties_add_float_slider(grp, opt.first.c_str(), opt.second.c_str(), -1000, 1000, 0.01);
obs_property_float_set_suffix(p, "%"); obs_property_float_set_suffix(p, "%");
} }
@ -750,7 +750,7 @@ obs_properties_t* transform_factory::get_properties2(transform_instance* data)
{ST_KEY_SHEAR_X, "X"}, {ST_KEY_SHEAR_X, "X"},
{ST_KEY_SHEAR_Y, "Y"}, {ST_KEY_SHEAR_Y, "Y"},
}; };
for (auto opt : opts) { for (const auto& opt : opts) {
auto p = auto p =
obs_properties_add_float_slider(grp, opt.first.c_str(), opt.second.c_str(), -200.0, 200.0, 0.01); obs_properties_add_float_slider(grp, opt.first.c_str(), opt.second.c_str(), -200.0, 200.0, 0.01);
obs_property_float_set_suffix(p, "%"); obs_property_float_set_suffix(p, "%");

3
source/gfx/blur/gfx-blur-box-linear.cpp
View File

@ -66,7 +66,6 @@ bool streamfx::gfx::blur::box_linear_factory::is_type_supported(::streamfx::gfx:
{ {
switch (type) { switch (type) {
case ::streamfx::gfx::blur::type::Area: case ::streamfx::gfx::blur::type::Area:
return true;
case ::streamfx::gfx::blur::type::Directional: case ::streamfx::gfx::blur::type::Directional:
return true; return true;
default: default:
@ -199,7 +198,7 @@ streamfx::gfx::blur::box_linear::~box_linear() {}
void streamfx::gfx::blur::box_linear::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture) void streamfx::gfx::blur::box_linear::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture)
{ {
_input_texture = texture; _input_texture = std::move(texture);
} }
::streamfx::gfx::blur::type streamfx::gfx::blur::box_linear::get_type() ::streamfx::gfx::blur::type streamfx::gfx::blur::box_linear::get_type()

2
source/gfx/blur/gfx-blur-box.cpp
View File

@ -208,7 +208,7 @@ streamfx::gfx::blur::box::~box() {}
void streamfx::gfx::blur::box::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture) void streamfx::gfx::blur::box::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture)
{ {
_input_texture = texture; _input_texture = std::move(texture);
} }
::streamfx::gfx::blur::type streamfx::gfx::blur::box::get_type() ::streamfx::gfx::blur::type streamfx::gfx::blur::box::get_type()

2
source/gfx/blur/gfx-blur-dual-filtering.cpp
View File

@ -202,7 +202,7 @@ streamfx::gfx::blur::dual_filtering::~dual_filtering() {}
void streamfx::gfx::blur::dual_filtering::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture) void streamfx::gfx::blur::dual_filtering::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture)
{ {
_input_texture = texture; _input_texture = std::move(texture);
} }
::streamfx::gfx::blur::type streamfx::gfx::blur::dual_filtering::get_type() ::streamfx::gfx::blur::type streamfx::gfx::blur::dual_filtering::get_type()

3
source/gfx/blur/gfx-blur-gaussian-linear.cpp
View File

@ -115,7 +115,6 @@ bool streamfx::gfx::blur::gaussian_linear_factory::is_type_supported(::streamfx:
{ {
switch (v) { switch (v) {
case ::streamfx::gfx::blur::type::Area: case ::streamfx::gfx::blur::type::Area:
return true;
case ::streamfx::gfx::blur::type::Directional: case ::streamfx::gfx::blur::type::Directional:
return true; return true;
default: default:
@ -251,7 +250,7 @@ streamfx::gfx::blur::gaussian_linear::~gaussian_linear() {}
void streamfx::gfx::blur::gaussian_linear::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture) void streamfx::gfx::blur::gaussian_linear::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture)
{ {
_input_texture = texture; _input_texture = std::move(texture);
} }
::streamfx::gfx::blur::type streamfx::gfx::blur::gaussian_linear::get_type() ::streamfx::gfx::blur::type streamfx::gfx::blur::gaussian_linear::get_type()

6
source/gfx/blur/gfx-blur-gaussian.cpp
View File

@ -41,8 +41,8 @@ streamfx::gfx::blur::gaussian_data::gaussian_data()
{ {
using namespace streamfx::util; using namespace streamfx::util;
std::vector<double> kernel_dbl(ST_KERNEL_SIZE); std::array<double, ST_KERNEL_SIZE> kernel_dbl;
std::vector<float> kernel(ST_KERNEL_SIZE); std::vector<float> kernel(ST_KERNEL_SIZE);
{ {
auto gctx = streamfx::obs::gs::context(); auto gctx = streamfx::obs::gs::context();
@ -277,7 +277,7 @@ streamfx::gfx::blur::gaussian::~gaussian() {}
void streamfx::gfx::blur::gaussian::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture) void streamfx::gfx::blur::gaussian::set_input(std::shared_ptr<::streamfx::obs::gs::texture> texture)
{ {
_input_texture = texture; _input_texture = std::move(texture);
} }
::streamfx::gfx::blur::type streamfx::gfx::blur::gaussian::get_type() ::streamfx::gfx::blur::type streamfx::gfx::blur::gaussian::get_type()

2
source/gfx/gfx-debug.cpp
View File

@ -139,7 +139,7 @@ void streamfx::gfx::debug::draw_arrow(float x, float y, float x2, float y2, floa
float len = sqrt(dx * dx + dy * dy); float len = sqrt(dx * dx + dy * dy);
if (abs(w) <= 1) { if (abs(w) <= 1) {
w = len / 3.; w = len / 3.f;
} }
matrix4 rotator; matrix4 rotator;

2
source/gfx/lut/gfx-lut-consumer.cpp
View File

@ -29,7 +29,7 @@ streamfx::gfx::lut::consumer::consumer()
throw std::runtime_error("Unable to get LUT consumer effect."); throw std::runtime_error("Unable to get LUT consumer effect.");
} }
streamfx::gfx::lut::consumer::~consumer() {} streamfx::gfx::lut::consumer::~consumer() = default;
std::shared_ptr<streamfx::obs::gs::effect> std::shared_ptr<streamfx::obs::gs::effect>
streamfx::gfx::lut::consumer::prepare(streamfx::gfx::lut::color_depth depth, streamfx::gfx::lut::consumer::prepare(streamfx::gfx::lut::color_depth depth,

2
source/gfx/lut/gfx-lut-producer.cpp
View File

@ -47,7 +47,7 @@ streamfx::gfx::lut::producer::producer()
throw std::runtime_error("Unable to get LUT producer effect."); throw std::runtime_error("Unable to get LUT producer effect.");
} }
streamfx::gfx::lut::producer::~producer() {} streamfx::gfx::lut::producer::~producer() = default;
std::shared_ptr<streamfx::obs::gs::texture> streamfx::gfx::lut::producer::produce(streamfx::gfx::lut::color_depth depth) std::shared_ptr<streamfx::obs::gs::texture> streamfx::gfx::lut::producer::produce(streamfx::gfx::lut::color_depth depth)
{ {

9
source/gfx/shader/gfx-shader-param-basic.cpp
View File

@ -31,7 +31,8 @@ static const std::string_view _annotation_scale = "scale";
static const std::string_view _annotation_enum_entry = "enum_%zu"; static const std::string_view _annotation_enum_entry = "enum_%zu";
static const std::string_view _annotation_enum_entry_name = "enum_%zu_name"; static const std::string_view _annotation_enum_entry_name = "enum_%zu_name";
inline bool get_annotation_string(streamfx::obs::gs::effect_parameter param, std::string anno_name, std::string& out) inline bool get_annotation_string(streamfx::obs::gs::effect_parameter param, std::string_view anno_name,
std::string& out)
{ {
if (!param) if (!param)
return false; return false;
@ -46,7 +47,7 @@ inline bool get_annotation_string(streamfx::obs::gs::effect_parameter param, std
return false; return false;
} }
inline bool get_annotation_float(streamfx::obs::gs::effect_parameter param, std::string anno_name, float_t& out) inline bool get_annotation_float(streamfx::obs::gs::effect_parameter param, std::string_view anno_name, float_t& out)
{ {
if (!param) { if (!param) {
return false; return false;
@ -60,7 +61,7 @@ inline bool get_annotation_float(streamfx::obs::gs::effect_parameter param, std:
return false; return false;
} }
streamfx::gfx::shader::basic_field_type streamfx::gfx::shader::get_field_type_from_string(std::string v) streamfx::gfx::shader::basic_field_type streamfx::gfx::shader::get_field_type_from_string(std::string_view v)
{ {
std::map<std::string, basic_field_type> matches = { std::map<std::string, basic_field_type> matches = {
{"input", basic_field_type::Input}, {"input", basic_field_type::Input},
@ -69,7 +70,7 @@ streamfx::gfx::shader::basic_field_type streamfx::gfx::shader::get_field_type_fr
{"enumeration", basic_field_type::Enum}, {"enumeration", basic_field_type::Enum},
}; };
auto fnd = matches.find(v); auto fnd = matches.find(v.data());
if (fnd != matches.end()) if (fnd != matches.end())
return fnd->second; return fnd->second;

2
source/gfx/shader/gfx-shader-param-basic.hpp
View File

@ -29,7 +29,7 @@ namespace streamfx::gfx {
Enum, Enum,
}; };
basic_field_type get_field_type_from_string(std::string v); basic_field_type get_field_type_from_string(std::string_view v);
struct basic_data { struct basic_data {
union { union {

23
source/gfx/shader/gfx-shader-param-texture.cpp
View File

@ -52,7 +52,7 @@ static constexpr std::string_view _annotation_default = "default";
static constexpr std::string_view _annotation_enum_entry = "enum_%zu"; static constexpr std::string_view _annotation_enum_entry = "enum_%zu";
static constexpr std::string_view _annotation_enum_entry_name = "enum_%zu_name"; static constexpr std::string_view _annotation_enum_entry_name = "enum_%zu_name";
streamfx::gfx::shader::texture_field_type streamfx::gfx::shader::get_texture_field_type_from_string(std::string v) streamfx::gfx::shader::texture_field_type streamfx::gfx::shader::get_texture_field_type_from_string(std::string_view v)
{ {
std::map<std::string, texture_field_type> matches = { std::map<std::string, texture_field_type> matches = {
{"input", texture_field_type::Input}, {"input", texture_field_type::Input},
@ -60,7 +60,7 @@ streamfx::gfx::shader::texture_field_type streamfx::gfx::shader::get_texture_fie
{"enumeration", texture_field_type::Enum}, {"enumeration", texture_field_type::Enum},
}; };
auto fnd = matches.find(v); auto fnd = matches.find(v.data());
if (fnd != matches.end()) if (fnd != matches.end())
return fnd->second; return fnd->second;
@ -82,15 +82,15 @@ streamfx::gfx::shader::texture_parameter::texture_parameter(streamfx::gfx::shade
_keys.reserve(3); _keys.reserve(3);
{ // Type { // Type
snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_TYPE); snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_TYPE);
_keys.push_back(std::string(string_buffer)); _keys.emplace_back(string_buffer);
} }
{ // File { // File
snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_FILE); snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_FILE);
_keys.push_back(std::string(string_buffer)); _keys.emplace_back(string_buffer);
} }
{ // Source { // Source
snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_SOURCE); snprintf(string_buffer, sizeof(string_buffer), "%s%s", get_key().data(), ST_KEY_SOURCE);
_keys.push_back(std::string(string_buffer)); _keys.emplace_back(string_buffer);
} }
} }
@ -233,9 +233,8 @@ void streamfx::gfx::shader::texture_parameter::properties(obs_properties_t* prop
} }
} }
std::filesystem::path make_absolute_to(std::filesystem::path origin, std::filesystem::path destination) std::filesystem::path make_absolute_to(const std::filesystem::path& origin, const std::filesystem::path& destination)
{ {
auto destination_dir = std::filesystem::absolute(destination.remove_filename());
return std::filesystem::absolute(destination / origin); return std::filesystem::absolute(destination / origin);
} }
@ -263,7 +262,7 @@ void streamfx::gfx::shader::texture_parameter::update(obs_data_t* settings)
_dirty_ts = std::chrono::high_resolution_clock::now() - std::chrono::milliseconds(1); _dirty_ts = std::chrono::high_resolution_clock::now() - std::chrono::milliseconds(1);
} }
} else if (_type == texture_type::Source) { } else if (_type == texture_type::Source) {
auto source_name = obs_data_get_string(settings, _keys[2].c_str()); const char* source_name = obs_data_get_string(settings, _keys[2].c_str());
if (_source_name != source_name) { if (_source_name != source_name) {
_source_name = source_name; _source_name = source_name;
@ -321,14 +320,14 @@ void streamfx::gfx::shader::texture_parameter::assign()
// Propagate all of this into the storage. // Propagate all of this into the storage.
_source_rendertarget = rt; _source_rendertarget = rt;
_source_visible = visible; _source_visible = std::move(visible);
_source_active = active; _source_active = std::move(active);
_source_child = child; _source_child = child;
_source = source; _source = std::move(source);
} }
_dirty = false; _dirty = false;
} catch (const std::exception& ex) { } catch (const std::exception&) {
_dirty_ts = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5000); _dirty_ts = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5000);
} catch (...) { } catch (...) {
_dirty_ts = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5000); _dirty_ts = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5000);

2
source/gfx/shader/gfx-shader-param-texture.hpp
View File

@ -19,7 +19,7 @@ namespace streamfx::gfx {
Enum, Enum,
}; };
texture_field_type get_texture_field_type_from_string(std::string v); texture_field_type get_texture_field_type_from_string(std::string_view v);
enum class texture_type { enum class texture_type {
File, File,

6
source/gfx/shader/gfx-shader-param.cpp
View File

@ -84,7 +84,7 @@ std::size_t streamfx::gfx::shader::get_length_from_effect_type(streamfx::obs::gs
} }
} }
streamfx::gfx::shader::parameter_type streamfx::gfx::shader::get_type_from_string(std::string v) streamfx::gfx::shader::parameter_type streamfx::gfx::shader::get_type_from_string(std::string_view v)
{ {
if ((v == "bool") || (v == "boolean")) { if ((v == "bool") || (v == "boolean")) {
return parameter_type::Boolean; return parameter_type::Boolean;
@ -139,7 +139,7 @@ streamfx::gfx::shader::parameter::parameter(streamfx::gfx::shader::shader*
// Read Name // Read Name
if (auto anno = _param.get_annotation(ST_ANNO_NAME); anno) { if (auto anno = _param.get_annotation(ST_ANNO_NAME); anno) {
if (std::string v = anno.get_default_string(); v.length() > 0) { if (std::string v = anno.get_default_string(); v.length() > 0) {
_name = v; _name = std::move(v);
} else { } else {
throw std::out_of_range("'" ST_ANNO_NAME "' annotation has zero length."); throw std::out_of_range("'" ST_ANNO_NAME "' annotation has zero length.");
} }
@ -148,7 +148,7 @@ streamfx::gfx::shader::parameter::parameter(streamfx::gfx::shader::shader*
// Read Description // Read Description
if (auto anno = _param.get_annotation(ST_ANNO_DESCRIPTION); anno) { if (auto anno = _param.get_annotation(ST_ANNO_DESCRIPTION); anno) {
if (std::string v = anno.get_default_string(); v.length() > 0) { if (std::string v = anno.get_default_string(); v.length() > 0) {
_description = v; _description = std::move(v);
} else { } else {
throw std::out_of_range("'" ST_ANNO_DESCRIPTION "' annotation has zero length."); throw std::out_of_range("'" ST_ANNO_DESCRIPTION "' annotation has zero length.");
} }

2
source/gfx/shader/gfx-shader-param.hpp
View File

@ -45,7 +45,7 @@ namespace streamfx::gfx {
std::size_t get_length_from_effect_type(streamfx::obs::gs::effect_parameter::type type); std::size_t get_length_from_effect_type(streamfx::obs::gs::effect_parameter::type type);
parameter_type get_type_from_string(std::string v); parameter_type get_type_from_string(std::string_view v);
class parameter { class parameter {
// Parent Shader // Parent Shader

6
source/gfx/shader/gfx-shader.cpp
View File

@ -62,7 +62,7 @@ streamfx::gfx::shader::shader::shader(obs_source_t* self, shader_mode mode)
} }
} }
streamfx::gfx::shader::shader::~shader() {} streamfx::gfx::shader::shader::~shader() = default;
bool streamfx::gfx::shader::shader::is_shader_different(const std::filesystem::path& file) bool streamfx::gfx::shader::shader::is_shader_different(const std::filesystem::path& file)
try { try {
@ -88,7 +88,7 @@ try {
return false; return false;
} }
bool streamfx::gfx::shader::shader::is_technique_different(const std::string& tech) bool streamfx::gfx::shader::shader::is_technique_different(std::string_view tech)
{ {
// Is the technique different? // Is the technique different?
if (tech != _shader_tech) if (tech != _shader_tech)
@ -97,7 +97,7 @@ bool streamfx::gfx::shader::shader::is_technique_different(const std::string& te
return false; return false;
} }
bool streamfx::gfx::shader::shader::load_shader(const std::filesystem::path& file, const std::string& tech, bool streamfx::gfx::shader::shader::load_shader(const std::filesystem::path& file, std::string_view tech,
bool& shader_dirty, bool& param_dirty) bool& shader_dirty, bool& param_dirty)
try { try {
if (!std::filesystem::exists(file)) if (!std::filesystem::exists(file))

4
source/gfx/shader/gfx-shader.hpp
View File

@ -84,9 +84,9 @@ namespace streamfx::gfx {
bool is_shader_different(const std::filesystem::path& file); bool is_shader_different(const std::filesystem::path& file);
bool is_technique_different(const std::string& tech); bool is_technique_different(std::string_view tech);
bool load_shader(const std::filesystem::path& file, const std::string& tech, bool& shader_dirty, bool load_shader(const std::filesystem::path& file, std::string_view tech, bool& shader_dirty,
bool& param_dirty); bool& param_dirty);
static void defaults(obs_data_t* data); static void defaults(obs_data_t* data);

2
source/nvidia/ar/nvidia-ar-facedetection.cpp
View File

@ -92,7 +92,7 @@ void ar::facedetection::set_tracking_limit(size_t v)
// Update bounding boxes structure. // Update bounding boxes structure.
_bboxes.rects = _rects.data(); _bboxes.rects = _rects.data();
_bboxes.maximum = v; _bboxes.maximum = static_cast<uint8_t>(v);
_bboxes.current = 0; _bboxes.current = 0;
// Update feature. // Update feature.

2
source/nvidia/cuda/nvidia-cuda-context.hpp
View File

@ -60,7 +60,7 @@ namespace streamfx::nvidia::cuda {
{ {
_ctx->pop(); _ctx->pop();
} }
inline context_stack(std::shared_ptr<::streamfx::nvidia::cuda::context> ctx) : _ctx(ctx) inline context_stack(std::shared_ptr<::streamfx::nvidia::cuda::context> ctx) : _ctx(std::move(ctx))
{ {
_ctx->push(); _ctx->push();
} }

7
source/nvidia/cuda/nvidia-cuda-gs-texture.cpp
View File

@ -62,14 +62,11 @@ streamfx::nvidia::cuda::gstexture::gstexture(std::shared_ptr<streamfx::obs::gs::
ID3D11Resource* resource = nullptr; ID3D11Resource* resource = nullptr;
switch (_texture->get_type()) { switch (_texture->get_type()) {
case streamfx::obs::gs::texture::type::Cube: case streamfx::obs::gs::texture::type::Cube:
case streamfx::obs::gs::texture::type::Volume:
case streamfx::obs::gs::texture::type::Normal: { case streamfx::obs::gs::texture::type::Normal: {
resource = static_cast<ID3D11Resource*>(gs_texture_get_obj(_texture->get_object())); resource = static_cast<ID3D11Resource*>(gs_texture_get_obj(_texture->get_object()));
break; break;
} }
case streamfx::obs::gs::texture::type::Volume: {
resource = static_cast<ID3D11Resource*>(gs_texture_get_obj(_texture->get_object()));
break;
}
} }
if (!resource) { if (!resource) {
@ -101,7 +98,7 @@ streamfx::nvidia::cuda::array_t
throw std::runtime_error("nvidia::cuda::gstexture: Mapping failed."); throw std::runtime_error("nvidia::cuda::gstexture: Mapping failed.");
} }
_stream = stream; _stream = std::move(stream);
_is_mapped = true; _is_mapped = true;
switch (_cuda->cuGraphicsSubResourceGetMappedArray(&_pointer, _resource, 0, 0)) { switch (_cuda->cuGraphicsSubResourceGetMappedArray(&_pointer, _resource, 0, 0)) {

2
source/nvidia/cv/nvidia-cv.hpp
View File

@ -293,7 +293,7 @@ namespace streamfx::nvidia::cv {
public: public:
exception(const char* what, result code) : std::runtime_error(what), _code(code) {} exception(const char* what, result code) : std::runtime_error(what), _code(code) {}
exception(const std::string& what, result code) : std::runtime_error(what), _code(code) {} exception(std::string_view what, result code) : std::runtime_error(what.data()), _code(code) {}
~exception(){}; ~exception(){};
inline result code() inline result code()

2
source/nvidia/vfx/nvidia-vfx-superresolution.cpp
View File

@ -134,7 +134,7 @@ void streamfx::nvidia::vfx::superresolution::set_scale(float scale)
scale = std::clamp<float>(scale, 1., 4.); scale = std::clamp<float>(scale, 1., 4.);
// Match to nearest scale. // Match to nearest scale.
double factor = find_closest_scale_factor(scale); float factor = static_cast<float>(find_closest_scale_factor(scale));
// If anything was changed, flag the effect as dirty. // If anything was changed, flag the effect as dirty.
if (!::streamfx::util::math::is_close<float>(_scale, factor, 0.01f)) if (!::streamfx::util::math::is_close<float>(_scale, factor, 0.01f))

12
source/obs/gs/gs-effect-parameter.cpp
View File

@ -48,22 +48,22 @@ streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param)
streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_effect_t> parent) streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_effect_t> parent)
: effect_parameter(param) : effect_parameter(param)
{ {
_effect_parent = parent; _effect_parent = std::move(parent);
} }
streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_epass_t> parent) streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_epass_t> parent)
: effect_parameter(param) : effect_parameter(param)
{ {
_pass_parent = parent; _pass_parent = std::move(parent);
} }
streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_eparam_t> parent) streamfx::obs::gs::effect_parameter::effect_parameter(gs_eparam_t* param, std::shared_ptr<gs_eparam_t> parent)
: effect_parameter(param) : effect_parameter(param)
{ {
_param_parent = parent; _param_parent = std::move(parent);
} }
streamfx::obs::gs::effect_parameter::~effect_parameter() {} streamfx::obs::gs::effect_parameter::~effect_parameter() = default;
streamfx::obs::gs::effect_parameter::effect_parameter(const effect_parameter& rhs) streamfx::obs::gs::effect_parameter::effect_parameter(const effect_parameter& rhs)
{ {
@ -694,7 +694,7 @@ void streamfx::obs::gs::effect_parameter::get_string(std::string& v)
v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1); v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1);
bfree(ptr); bfree(ptr);
} else { } else {
v = ""; v.clear();
} }
} }
@ -708,6 +708,6 @@ void streamfx::obs::gs::effect_parameter::get_default_string(std::string& v)
v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1); v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1);
bfree(ptr); bfree(ptr);
} else { } else {
v = ""; v.clear();
} }
} }

18
source/obs/gs/gs-effect-pass.cpp
View File

@ -36,7 +36,7 @@ streamfx::obs::gs::effect_pass::effect_pass(gs_epass_t* pass, std::shared_ptr<gs
reset(pass, [](void*) {}); reset(pass, [](void*) {});
} }
streamfx::obs::gs::effect_pass::~effect_pass() {} streamfx::obs::gs::effect_pass::~effect_pass() = default;
std::string streamfx::obs::gs::effect_pass::name() std::string streamfx::obs::gs::effect_pass::name()
{ {
@ -58,22 +58,22 @@ streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_vertex_p
return streamfx::obs::gs::effect_parameter((get()->vertshader_params.array + idx)->eparam, *this); return streamfx::obs::gs::effect_parameter((get()->vertshader_params.array + idx)->eparam, *this);
} }
streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_vertex_parameter(std::string name) streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_vertex_parameter(std::string_view name)
{ {
for (std::size_t idx = 0; idx < count_vertex_parameters(); idx++) { for (std::size_t idx = 0; idx < count_vertex_parameters(); idx++) {
auto ptr = get()->vertshader_params.array + idx; auto ptr = get()->vertshader_params.array + idx;
if (strcmp(ptr->eparam->name, name.c_str()) == 0) if (strcmp(ptr->eparam->name, name.data()) == 0)
return streamfx::obs::gs::effect_parameter(ptr->eparam, *this); return streamfx::obs::gs::effect_parameter(ptr->eparam, *this);
} }
return nullptr; return nullptr;
} }
bool streamfx::obs::gs::effect_pass::has_vertex_parameter(std::string name) bool streamfx::obs::gs::effect_pass::has_vertex_parameter(std::string_view name)
{ {
return (get_vertex_parameter(name) != nullptr); return (get_vertex_parameter(name) != nullptr);
} }
bool streamfx::obs::gs::effect_pass::has_vertex_parameter(std::string name, bool streamfx::obs::gs::effect_pass::has_vertex_parameter(std::string_view name,
streamfx::obs::gs::effect_parameter::type type) streamfx::obs::gs::effect_parameter::type type)
{ {
if (auto el = get_vertex_parameter(name); el != nullptr) { if (auto el = get_vertex_parameter(name); el != nullptr) {
@ -95,22 +95,22 @@ streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_pixel_pa
return streamfx::obs::gs::effect_parameter((get()->pixelshader_params.array + idx)->eparam, *this); return streamfx::obs::gs::effect_parameter((get()->pixelshader_params.array + idx)->eparam, *this);
} }
streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_pixel_parameter(std::string name) streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect_pass::get_pixel_parameter(std::string_view name)
{ {
for (std::size_t idx = 0; idx < count_pixel_parameters(); idx++) { for (std::size_t idx = 0; idx < count_pixel_parameters(); idx++) {
auto ptr = get()->pixelshader_params.array + idx; auto ptr = get()->pixelshader_params.array + idx;
if (strcmp(ptr->eparam->name, name.c_str()) == 0) if (strcmp(ptr->eparam->name, name.data()) == 0)
return streamfx::obs::gs::effect_parameter(ptr->eparam, *this); return streamfx::obs::gs::effect_parameter(ptr->eparam, *this);
} }
return nullptr; return nullptr;
} }
bool streamfx::obs::gs::effect_pass::has_pixel_parameter(std::string name) bool streamfx::obs::gs::effect_pass::has_pixel_parameter(std::string_view name)
{ {
return (get_pixel_parameter(name) != nullptr); return (get_pixel_parameter(name) != nullptr);
} }
bool streamfx::obs::gs::effect_pass::has_pixel_parameter(std::string name, bool streamfx::obs::gs::effect_pass::has_pixel_parameter(std::string_view name,
streamfx::obs::gs::effect_parameter::type type) streamfx::obs::gs::effect_parameter::type type)
{ {
if (auto el = get_pixel_parameter(name); el != nullptr) { if (auto el = get_pixel_parameter(name); el != nullptr) {

12
source/obs/gs/gs-effect-pass.hpp
View File

@ -37,14 +37,14 @@ namespace streamfx::obs::gs {
std::size_t count_vertex_parameters(); std::size_t count_vertex_parameters();
streamfx::obs::gs::effect_parameter get_vertex_parameter(std::size_t idx); streamfx::obs::gs::effect_parameter get_vertex_parameter(std::size_t idx);
streamfx::obs::gs::effect_parameter get_vertex_parameter(std::string name); streamfx::obs::gs::effect_parameter get_vertex_parameter(std::string_view name);
bool has_vertex_parameter(std::string name); bool has_vertex_parameter(std::string_view name);
bool has_vertex_parameter(std::string name, streamfx::obs::gs::effect_parameter::type type); bool has_vertex_parameter(std::string_view name, streamfx::obs::gs::effect_parameter::type type);
std::size_t count_pixel_parameters(); std::size_t count_pixel_parameters();
streamfx::obs::gs::effect_parameter get_pixel_parameter(std::size_t idx); streamfx::obs::gs::effect_parameter get_pixel_parameter(std::size_t idx);
streamfx::obs::gs::effect_parameter get_pixel_parameter(std::string name); streamfx::obs::gs::effect_parameter get_pixel_parameter(std::string_view name);
bool has_pixel_parameter(std::string name); bool has_pixel_parameter(std::string_view name);
bool has_pixel_parameter(std::string name, streamfx::obs::gs::effect_parameter::type type); bool has_pixel_parameter(std::string_view name, streamfx::obs::gs::effect_parameter::type type);
}; };
} // namespace streamfx::obs::gs } // namespace streamfx::obs::gs

8
source/obs/gs/gs-effect-technique.cpp
View File

@ -38,7 +38,7 @@ streamfx::obs::gs::effect_technique::effect_technique(gs_technique_t* technique,
reset(technique, [](void*) {}); reset(technique, [](void*) {});
} }
streamfx::obs::gs::effect_technique::~effect_technique() {} streamfx::obs::gs::effect_technique::~effect_technique() = default;
std::string streamfx::obs::gs::effect_technique::name() std::string streamfx::obs::gs::effect_technique::name()
{ {
@ -61,18 +61,18 @@ streamfx::obs::gs::effect_pass streamfx::obs::gs::effect_technique::get_pass(std
return streamfx::obs::gs::effect_pass(get()->passes.array + idx, *this); return streamfx::obs::gs::effect_pass(get()->passes.array + idx, *this);
} }
streamfx::obs::gs::effect_pass streamfx::obs::gs::effect_technique::get_pass(std::string name) streamfx::obs::gs::effect_pass streamfx::obs::gs::effect_technique::get_pass(std::string_view name)
{ {
for (std::size_t idx = 0; idx < get()->passes.num; idx++) { for (std::size_t idx = 0; idx < get()->passes.num; idx++) {
auto ptr = get()->passes.array + idx; auto ptr = get()->passes.array + idx;
if (strcmp(ptr->name, name.c_str()) == 0) if (strcmp(ptr->name, name.data()) == 0)
return streamfx::obs::gs::effect_pass(ptr, *this); return streamfx::obs::gs::effect_pass(ptr, *this);
} }
return nullptr; return nullptr;
} }
bool streamfx::obs::gs::effect_technique::has_pass(std::string name) bool streamfx::obs::gs::effect_technique::has_pass(std::string_view name)
{ {
if (get_pass(name) != nullptr) if (get_pass(name) != nullptr)
return true; return true;

4
source/obs/gs/gs-effect-technique.hpp
View File

@ -33,7 +33,7 @@ namespace streamfx::obs::gs {
std::size_t count_passes(); std::size_t count_passes();
streamfx::obs::gs::effect_pass get_pass(std::size_t idx); streamfx::obs::gs::effect_pass get_pass(std::size_t idx);
streamfx::obs::gs::effect_pass get_pass(std::string name); streamfx::obs::gs::effect_pass get_pass(std::string_view name);
bool has_pass(std::string name); bool has_pass(std::string_view name);
}; };
} // namespace streamfx::obs::gs } // namespace streamfx::obs::gs

26
source/obs/gs/gs-effect.cpp
View File

@ -27,11 +27,11 @@
#define MAX_EFFECT_SIZE 32 * 1024 * 1024 // 32 MiB, big enough for everything. #define MAX_EFFECT_SIZE 32 * 1024 * 1024 // 32 MiB, big enough for everything.
static std::string load_file_as_code(std::filesystem::path shader_file, bool is_top_level = true) static std::string load_file_as_code(const std::filesystem::path& shader_file, bool is_top_level = true)
{ {
std::stringstream shader_stream; std::stringstream shader_stream;
std::filesystem::path shader_path = std::filesystem::absolute(shader_file); const std::filesystem::path& shader_path = std::filesystem::absolute(shader_file);
std::filesystem::path shader_root = std::filesystem::path(shader_path).remove_filename(); const std::filesystem::path& shader_root = std::filesystem::path(shader_path).remove_filename();
// Ensure it meets size limits. // Ensure it meets size limits.
uintmax_t size = std::filesystem::file_size(shader_path); uintmax_t size = std::filesystem::file_size(shader_path);
@ -96,12 +96,12 @@ static std::string load_file_as_code(std::filesystem::path shader_file, bool is_
return shader_stream.str(); return shader_stream.str();
} }
streamfx::obs::gs::effect::effect(const std::string& code, const std::string& name) streamfx::obs::gs::effect::effect(std::string_view code, std::string_view name)
{ {
auto gctx = streamfx::obs::gs::context(); auto gctx = streamfx::obs::gs::context();
char* error_buffer = nullptr; char* error_buffer = nullptr;
gs_effect_t* effect = gs_effect_create(code.c_str(), name.c_str(), &error_buffer); gs_effect_t* effect = gs_effect_create(code.data(), name.data(), &error_buffer);
if (!effect) { if (!effect) {
throw error_buffer ? std::runtime_error(error_buffer) throw error_buffer ? std::runtime_error(error_buffer)
@ -136,11 +136,11 @@ streamfx::obs::gs::effect_technique streamfx::obs::gs::effect::get_technique(std
return streamfx::obs::gs::effect_technique(get()->techniques.array + idx, *this); return streamfx::obs::gs::effect_technique(get()->techniques.array + idx, *this);
} }
streamfx::obs::gs::effect_technique streamfx::obs::gs::effect::get_technique(const std::string& name) streamfx::obs::gs::effect_technique streamfx::obs::gs::effect::get_technique(std::string_view name)
{ {
for (std::size_t idx = 0; idx < count_techniques(); idx++) { for (std::size_t idx = 0; idx < count_techniques(); idx++) {
auto ptr = get()->techniques.array + idx; auto ptr = get()->techniques.array + idx;
if (strcmp(ptr->name, name.c_str()) == 0) { if (strcmp(ptr->name, name.data()) == 0) {
return streamfx::obs::gs::effect_technique(ptr, *this); return streamfx::obs::gs::effect_technique(ptr, *this);
} }
} }
@ -148,7 +148,7 @@ streamfx::obs::gs::effect_technique streamfx::obs::gs::effect::get_technique(con
return nullptr; return nullptr;
} }
bool streamfx::obs::gs::effect::has_technique(const std::string& name) bool streamfx::obs::gs::effect::has_technique(std::string_view name)
{ {
if (get_technique(name)) if (get_technique(name))
return true; return true;
@ -169,11 +169,11 @@ streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect::get_parameter(std
return streamfx::obs::gs::effect_parameter(get()->params.array + idx, *this); return streamfx::obs::gs::effect_parameter(get()->params.array + idx, *this);
} }
streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect::get_parameter(const std::string& name) streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect::get_parameter(std::string_view name)
{ {
for (std::size_t idx = 0; idx < count_parameters(); idx++) { for (std::size_t idx = 0; idx < count_parameters(); idx++) {
auto ptr = get()->params.array + idx; auto ptr = get()->params.array + idx;
if (strcmp(ptr->name, name.c_str()) == 0) { if (strcmp(ptr->name, name.data()) == 0) {
return streamfx::obs::gs::effect_parameter(ptr, *this); return streamfx::obs::gs::effect_parameter(ptr, *this);
} }
} }
@ -181,14 +181,14 @@ streamfx::obs::gs::effect_parameter streamfx::obs::gs::effect::get_parameter(con
return nullptr; return nullptr;
} }
bool streamfx::obs::gs::effect::has_parameter(const std::string& name) bool streamfx::obs::gs::effect::has_parameter(std::string_view name)
{ {
if (get_parameter(name)) if (get_parameter(name))
return true; return true;
return false; return false;
} }
bool streamfx::obs::gs::effect::has_parameter(const std::string& name, effect_parameter::type type) bool streamfx::obs::gs::effect::has_parameter(std::string_view name, effect_parameter::type type)
{ {
auto eprm = get_parameter(name); auto eprm = get_parameter(name);
if (eprm) if (eprm)

18
source/obs/gs/gs-effect.hpp
View File

@ -27,21 +27,21 @@
namespace streamfx::obs::gs { namespace streamfx::obs::gs {
class effect : public std::shared_ptr<gs_effect_t> { class effect : public std::shared_ptr<gs_effect_t> {
public: public:
effect(){}; effect() = default;
effect(const std::string& code, const std::string& name); effect(std::string_view code, std::string_view name);
effect(std::filesystem::path file); effect(std::filesystem::path file);
~effect(); ~effect();
std::size_t count_techniques(); std::size_t count_techniques();
streamfx::obs::gs::effect_technique get_technique(std::size_t idx); streamfx::obs::gs::effect_technique get_technique(std::size_t idx);
streamfx::obs::gs::effect_technique get_technique(const std::string& name); streamfx::obs::gs::effect_technique get_technique(std::string_view name);
bool has_technique(const std::string& name); bool has_technique(std::string_view name);
std::size_t count_parameters(); std::size_t count_parameters();
streamfx::obs::gs::effect_parameter get_parameter(std::size_t idx); streamfx::obs::gs::effect_parameter get_parameter(std::size_t idx);
streamfx::obs::gs::effect_parameter get_parameter(const std::string& name); streamfx::obs::gs::effect_parameter get_parameter(std::string_view name);
bool has_parameter(const std::string& name); bool has_parameter(std::string_view name);
bool has_parameter(const std::string& name, effect_parameter::type type); bool has_parameter(std::string_view name, effect_parameter::type type);
public /* Legacy Support */: public /* Legacy Support */:
inline gs_effect_t* get_object() inline gs_effect_t* get_object()
@ -49,12 +49,12 @@ namespace streamfx::obs::gs {
return get(); return get();
} }
static streamfx::obs::gs::effect create(const std::string& code, const std::string& name) static streamfx::obs::gs::effect create(std::string_view code, std::string_view name)
{ {
return streamfx::obs::gs::effect(code, name); return streamfx::obs::gs::effect(code, name);
}; };
static streamfx::obs::gs::effect create(const std::string& file) static streamfx::obs::gs::effect create(std::string_view file)
{ {
return streamfx::obs::gs::effect(std::filesystem::path(file)); return streamfx::obs::gs::effect(std::filesystem::path(file));
}; };

4
source/obs/gs/gs-mipmapper.cpp
View File

@ -327,11 +327,11 @@ void streamfx::obs::gs::mipmapper::rebuild(std::shared_ptr<streamfx::obs::gs::te
// Copy from the render target to the target mip level. // Copy from the render target to the target mip level.
#ifdef _WIN32 #ifdef _WIN32
if (gs_get_device_type() == GS_DEVICE_DIRECT3D_11) { if (gs_get_device_type() == GS_DEVICE_DIRECT3D_11) {
d3d_copy_subregion(d3dinfo, _rt->get_texture(), mip, cwidth, cheight); d3d_copy_subregion(d3dinfo, _rt->get_texture(), static_cast<uint32_t>(mip), cwidth, cheight);
} }
#endif #endif
if (gs_get_device_type() == GS_DEVICE_OPENGL) { if (gs_get_device_type() == GS_DEVICE_OPENGL) {
opengl_copy_subregion(oglinfo, _rt->get_texture(), mip, cwidth, cheight); opengl_copy_subregion(oglinfo, _rt->get_texture(), static_cast<uint32_t>(mip), cwidth, cheight);
} }
} }

2
source/obs/gs/gs-rendertarget.cpp
View File

@ -97,7 +97,7 @@ streamfx::obs::gs::rendertarget_op::rendertarget_op(streamfx::obs::gs::rendertar
parent->_is_being_rendered = true; parent->_is_being_rendered = true;
} }
streamfx::obs::gs::rendertarget_op::rendertarget_op(streamfx::obs::gs::rendertarget_op&& r) streamfx::obs::gs::rendertarget_op::rendertarget_op(streamfx::obs::gs::rendertarget_op&& r) noexcept
{ {
this->parent = r.parent; this->parent = r.parent;
r.parent = nullptr; r.parent = nullptr;

2
source/obs/gs/gs-rendertarget.hpp
View File

@ -65,7 +65,7 @@ namespace streamfx::obs::gs {
rendertarget_op(streamfx::obs::gs::rendertarget* rt, uint32_t width, uint32_t height); rendertarget_op(streamfx::obs::gs::rendertarget* rt, uint32_t width, uint32_t height);
// Move Constructor // Move Constructor
rendertarget_op(streamfx::obs::gs::rendertarget_op&&); rendertarget_op(streamfx::obs::gs::rendertarget_op&&) noexcept;
// Copy Constructor // Copy Constructor
rendertarget_op(const streamfx::obs::gs::rendertarget_op&) = delete; rendertarget_op(const streamfx::obs::gs::rendertarget_op&) = delete;

2
source/obs/gs/gs-vertexbuffer.cpp
View File

@ -203,7 +203,7 @@ streamfx::obs::gs::vertex_buffer::vertex_buffer(vertex_buffer const&& other) noe
_obs_data = other._obs_data; _obs_data = other._obs_data;
} }
void streamfx::obs::gs::vertex_buffer::operator=(vertex_buffer const&& other) void streamfx::obs::gs::vertex_buffer::operator=(vertex_buffer const&& other) noexcept
{ // Move Assignment { // Move Assignment
finalize(); finalize();

2
source/obs/gs/gs-vertexbuffer.hpp
View File

@ -111,7 +111,7 @@ namespace streamfx::obs::gs {
* *
* \param other * \param other
*/ */
void operator=(vertex_buffer const&& other); void operator=(vertex_buffer const&& other) noexcept;
void resize(uint32_t new_size); void resize(uint32_t new_size);

2
source/obs/obs-encoder-factory.hpp
View File

@ -118,7 +118,7 @@ namespace streamfx::obs {
_info.get_extra_data = _get_extra_data; _info.get_extra_data = _get_extra_data;
_info.get_sei_data = _get_sei_data; _info.get_sei_data = _get_sei_data;
} }
virtual ~encoder_factory() {} virtual ~encoder_factory() = default;
void finish_setup() void finish_setup()
{ {

6
source/obs/obs-signal-handler.hpp
View File

@ -35,8 +35,8 @@ namespace streamfx::obs {
template<typename T> template<typename T>
class signal_handler : public signal_handler_base<T> { class signal_handler : public signal_handler_base<T> {
public: public:
signal_handler(std::string signal, T keepalive) {} signal_handler(std::string_view signal, T keepalive) {}
virtual ~signal_handler() {} virtual ~signal_handler() = default;
}; };
template<> template<>
@ -51,7 +51,7 @@ namespace streamfx::obs {
} }
public: public:
signal_handler(std::string signal, std::shared_ptr<obs_source_t> keepalive) : _keepalive(keepalive) signal_handler(std::string_view signal, std::shared_ptr<obs_source_t> keepalive) : _keepalive(keepalive)
{ {
_signal = signal; _signal = signal;
signal_handler_t* sh = obs_source_get_signal_handler(_keepalive.get()); signal_handler_t* sh = obs_source_get_signal_handler(_keepalive.get());

2
source/obs/obs-source-factory.hpp
View File

@ -45,7 +45,7 @@ namespace streamfx::obs {
_info.save = _save; _info.save = _save;
_info.filter_remove = _filter_remove; _info.filter_remove = _filter_remove;
} }
virtual ~source_factory() {} virtual ~source_factory() = default;
protected: protected:
void finish_setup() void finish_setup()

2
source/sources/source-mirror.cpp
View File

@ -195,7 +195,7 @@ try {
// Everything went well, store. // Everything went well, store.
_source_child = std::make_shared<::streamfx::obs::source_active_child>(_self, source); _source_child = std::make_shared<::streamfx::obs::source_active_child>(_self, source);
_source = source; _source = std::move(source);
_source_size.first = obs_source_get_width(_source); _source_size.first = obs_source_get_width(_source);
_source_size.second = obs_source_get_height(_source); _source_size.second = obs_source_get_height(_source);

3
source/ui/ui-about.cpp
View File

@ -70,7 +70,8 @@ streamfx::ui::about::about() : QDialog(reinterpret_cast<QWidget*>(obs_frontend_g
content->setSizePolicy(QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Maximum); content->setSizePolicy(QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Maximum);
// Create a uniform // Create a uniform
std::mt19937_64 generator; std::random_device rd;
std::mt19937_64 generator(rd());
std::uniform_int_distribution<uint64_t> rnd; std::uniform_int_distribution<uint64_t> rnd;
// Load entries from 'thanks.json' // Load entries from 'thanks.json'

18
source/util/util-curl.cpp
View File

@ -124,9 +124,9 @@ void streamfx::util::curl::clear_headers()
_headers.clear(); _headers.clear();
} }
void streamfx::util::curl::clear_header(std::string header) void streamfx::util::curl::clear_header(std::string_view header)
{ {
_headers.erase(header); _headers.erase(header.data());
} }
void streamfx::util::curl::set_header(std::string header, std::string value) void streamfx::util::curl::set_header(std::string header, std::string value)
@ -134,7 +134,7 @@ void streamfx::util::curl::set_header(std::string header, std::string value)
_headers.insert_or_assign(header, value); _headers.insert_or_assign(header, value);
} }
size_t perform_get_kv_size(std::string a, std::string b) size_t perform_get_kv_size(std::string_view a, std::string_view b)
{ {
return a.size() + 2 + b.size() + 1; return a.size() + 2 + b.size() + 1;
}; };
@ -148,7 +148,7 @@ CURLcode streamfx::util::curl::perform()
// Calculate full buffer size. // Calculate full buffer size.
{ {
size_t buffer_size = 0; size_t buffer_size = 0;
for (auto kv : _headers) { for (const auto& kv : _headers) {
buffer_size += perform_get_kv_size(kv.first, kv.second); buffer_size += perform_get_kv_size(kv.first, kv.second);
} }
buffer.resize(buffer_size * 2); buffer.resize(buffer_size * 2);
@ -156,7 +156,7 @@ CURLcode streamfx::util::curl::perform()
// Create HTTP Headers. // Create HTTP Headers.
{ {
size_t buffer_offset = 0; size_t buffer_offset = 0;
for (auto kv : _headers) { for (const auto& kv : _headers) {
size_t size = perform_get_kv_size(kv.first, kv.second); size_t size = perform_get_kv_size(kv.first, kv.second);
snprintf(&buffer.at(buffer_offset), size, "%s: %s", kv.first.c_str(), kv.second.c_str()); snprintf(&buffer.at(buffer_offset), size, "%s: %s", kv.first.c_str(), kv.second.c_str());
@ -186,7 +186,7 @@ void streamfx::util::curl::reset()
CURLcode streamfx::util::curl::set_read_callback(curl_io_callback_t cb) CURLcode streamfx::util::curl::set_read_callback(curl_io_callback_t cb)
{ {
_read_callback = cb; _read_callback = std::move(cb);
if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_READDATA, this); res != CURLE_OK) if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_READDATA, this); res != CURLE_OK)
return res; return res;
return curl_easy_setopt(_curl, CURLOPT_READFUNCTION, &read_helper); return curl_easy_setopt(_curl, CURLOPT_READFUNCTION, &read_helper);
@ -194,7 +194,7 @@ CURLcode streamfx::util::curl::set_read_callback(curl_io_callback_t cb)
CURLcode streamfx::util::curl::set_write_callback(curl_io_callback_t cb) CURLcode streamfx::util::curl::set_write_callback(curl_io_callback_t cb)
{ {
_write_callback = cb; _write_callback = std::move(cb);
if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_WRITEDATA, this); res != CURLE_OK) if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_WRITEDATA, this); res != CURLE_OK)
return res; return res;
return curl_easy_setopt(_curl, CURLOPT_WRITEFUNCTION, &write_helper); return curl_easy_setopt(_curl, CURLOPT_WRITEFUNCTION, &write_helper);
@ -202,7 +202,7 @@ CURLcode streamfx::util::curl::set_write_callback(curl_io_callback_t cb)
CURLcode streamfx::util::curl::set_xferinfo_callback(curl_xferinfo_callback_t cb) CURLcode streamfx::util::curl::set_xferinfo_callback(curl_xferinfo_callback_t cb)
{ {
_xferinfo_callback = cb; _xferinfo_callback = std::move(cb);
if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_XFERINFODATA, this); res != CURLE_OK) if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_XFERINFODATA, this); res != CURLE_OK)
return res; return res;
return curl_easy_setopt(_curl, CURLOPT_XFERINFOFUNCTION, &xferinfo_callback); return curl_easy_setopt(_curl, CURLOPT_XFERINFOFUNCTION, &xferinfo_callback);
@ -210,7 +210,7 @@ CURLcode streamfx::util::curl::set_xferinfo_callback(curl_xferinfo_callback_t cb
CURLcode streamfx::util::curl::set_debug_callback(curl_debug_callback_t cb) CURLcode streamfx::util::curl::set_debug_callback(curl_debug_callback_t cb)
{ {
_debug_callback = cb; _debug_callback = std::move(cb);
if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_DEBUGDATA, this); res != CURLE_OK) if (CURLcode res = curl_easy_setopt(_curl, CURLOPT_DEBUGDATA, this); res != CURLE_OK)
return res; return res;
return curl_easy_setopt(_curl, CURLOPT_DEBUGFUNCTION, &debug_helper); return curl_easy_setopt(_curl, CURLOPT_DEBUGFUNCTION, &debug_helper);

2
source/util/util-curl.hpp
View File

@ -110,7 +110,7 @@ namespace streamfx::util {
void clear_headers(); void clear_headers();
void clear_header(std::string header); void clear_header(std::string_view header);
void set_header(std::string header, std::string value); void set_header(std::string header, std::string value);

4
source/util/util-event.hpp
View File

@ -44,7 +44,7 @@ namespace streamfx::util {
event(const event<_args...>&) = delete; event(const event<_args...>&) = delete;
/* Move Constructor */ /* Move Constructor */
event(event<_args...>&& other) : event() event(event<_args...>&& other) noexcept : event()
{ {
std::lock_guard<std::recursive_mutex> lg(_lock); std::lock_guard<std::recursive_mutex> lg(_lock);
std::lock_guard<std::recursive_mutex> lgo(other._lock); std::lock_guard<std::recursive_mutex> lgo(other._lock);
@ -60,7 +60,7 @@ namespace streamfx::util {
event<_args...>& operator=(const event<_args...>&) = delete; event<_args...>& operator=(const event<_args...>&) = delete;
/* Move Operator */ /* Move Operator */
event<_args...>& operator=(event<_args...>&& other) event<_args...>& operator=(event<_args...>&& other) noexcept
{ {
std::lock_guard<std::recursive_mutex> lg(_lock); std::lock_guard<std::recursive_mutex> lg(_lock);
std::lock_guard<std::recursive_mutex> lgo(other._lock); std::lock_guard<std::recursive_mutex> lgo(other._lock);

8
source/util/util-library.cpp
View File

@ -45,10 +45,10 @@ streamfx::util::library::library(std::filesystem::path file) : _library(nullptr)
_library = reinterpret_cast<void*>(LoadLibraryExW(wfile.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS)); _library = reinterpret_cast<void*>(LoadLibraryExW(wfile.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS));
} }
if (!_library) { if (!_library) {
DWORD error = GetLastError(); std::string ex = "Failed to load library.";
DWORD error = GetLastError();
if (error != ERROR_PROC_NOT_FOUND) { if (error != ERROR_PROC_NOT_FOUND) {
PSTR message = NULL; PSTR message = NULL;
std::string ex = "Failed to load library.";
FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER,
NULL, error, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPSTR)&message, 0, NULL); NULL, error, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPSTR)&message, 0, NULL);
if (message) { if (message) {
@ -57,7 +57,7 @@ streamfx::util::library::library(std::filesystem::path file) : _library(nullptr)
throw std::runtime_error(ex); throw std::runtime_error(ex);
} }
} }
throw std::runtime_error("Failed to load library."); throw std::runtime_error(ex);
} }
#elif defined(ST_UNIX) #elif defined(ST_UNIX)
_library = dlopen(file.u8string().c_str(), RTLD_LAZY); _library = dlopen(file.u8string().c_str(), RTLD_LAZY);

2
source/util/util-threadpool.cpp
View File

@ -145,7 +145,7 @@ void streamfx::util::threadpool::work()
_worker_idx.fetch_sub(1); _worker_idx.fetch_sub(1);
} }
streamfx::util::threadpool::task::task() {} streamfx::util::threadpool::task::task() = default;
streamfx::util::threadpool::task::task(threadpool_callback_t fn, threadpool_data_t dt) streamfx::util::threadpool::task::task(threadpool_callback_t fn, threadpool_data_t dt)
: _mutex(), _is_complete(), _is_dead(false), _callback(fn), _data(dt) : _mutex(), _is_complete(), _is_dead(false), _callback(fn), _data(dt)

6
source/util/utility.cpp
View File

@ -103,12 +103,12 @@ void streamfx::util::vec4a::operator delete[](void* p)
streamfx::util::free_aligned(p); streamfx::util::free_aligned(p);
} }
std::pair<int64_t, int64_t> streamfx::util::size_from_string(std::string text, bool allowSquare) std::pair<int64_t, int64_t> streamfx::util::size_from_string(std::string_view text, bool allowSquare)
{ {
int64_t width, height; int64_t width, height;
const char* begin = text.c_str(); const auto* begin = text.data();
const char* end = text.c_str() + text.size() + 1; const auto* end = text.data() + text.size() + 1;
char* here = const_cast<char*>(end); char* here = const_cast<char*>(end);
long long res = strtoll(begin, &here, 0); long long res = strtoll(begin, &here, 0);

4
source/util/utility.hpp
View File

@ -103,7 +103,7 @@ namespace streamfx::util {
static void operator delete[](void* p); static void operator delete[](void* p);
}; };
std::pair<int64_t, int64_t> size_from_string(std::string text, bool allowSquare = true); std::pair<int64_t, int64_t> size_from_string(std::string_view text, bool allowSquare = true);
namespace math { namespace math {
template<typename T> template<typename T>
@ -243,7 +243,7 @@ namespace streamfx::util {
: _q_process_noise_covariance(pnc), _r_measurement_noise_covariance(mnc), _x_value_of_interest(value), : _q_process_noise_covariance(pnc), _r_measurement_noise_covariance(mnc), _x_value_of_interest(value),
_p_estimation_error_covariance(eec), _k_kalman_gain(0.0) _p_estimation_error_covariance(eec), _k_kalman_gain(0.0)
{} {}
~kalman1D() {} ~kalman1D() = default;
T filter(T measurement) T filter(T measurement)
{ {