etc/obs-StreamFX
0
0
Fork 0
mirror of https://github.com/Xaymar/obs-StreamFX synced 2024-12-29 11:01:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

nvidia/ar/feature: Add wrapper for AR features

Browse source
This commit is contained in:
Michael Fabian 'Xaymar' Dirks 2021-10-25 19:59:02 +02:00
parent 913ac4b309
commit c1ecfe70b3
3 changed files with 300 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -1061,6 +1061,8 @@ if(HAVE_NVIDIA_AR_SDK)
list(APPEND PROJECT_PRIVATE_SOURCE
"source/nvidia/ar/nvidia-ar.hpp"
"source/nvidia/ar/nvidia-ar.cpp"
"source/nvidia/ar/nvidia-ar-feature.hpp"
"source/nvidia/ar/nvidia-ar-feature.cpp"
)
list(APPEND PROJECT_LIBRARIES
NVIDIA::AR

93
source/nvidia/ar/nvidia-ar-feature.cpp Normal file
View file

@ -0,0 +1,93 @@
// Copyright (c) 2021 Michael Fabian Dirks <info@xaymar.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include "nvidia-ar-feature.hpp"
#include "obs/gs/gs-helper.hpp"
#include "util/util-logging.hpp"
#include "util/util-platform.hpp"
#ifdef _DEBUG
#define ST_PREFIX "<%s> "
#define D_LOG_ERROR(x, ...) P_LOG_ERROR(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
#define D_LOG_WARNING(x, ...) P_LOG_WARN(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
#define D_LOG_INFO(x, ...) P_LOG_INFO(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
#define D_LOG_DEBUG(x, ...) P_LOG_DEBUG(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
#else
#define ST_PREFIX "<nvidia::ar::feature> "
#define D_LOG_ERROR(...) P_LOG_ERROR(ST_PREFIX __VA_ARGS__)
#define D_LOG_WARNING(...) P_LOG_WARN(ST_PREFIX __VA_ARGS__)
#define D_LOG_INFO(...) P_LOG_INFO(ST_PREFIX __VA_ARGS__)
#define D_LOG_DEBUG(...) P_LOG_DEBUG(ST_PREFIX __VA_ARGS__)
#endif
streamfx::nvidia::ar::feature::~feature()
{
D_LOG_DEBUG("Finalizing... (Addr: 0x%" PRIuPTR ")", this);
}
streamfx::nvidia::ar::feature::feature(feature_t feature)
: _nvcuda(::streamfx::nvidia::cuda::obs::get()), _nvcv(::streamfx::nvidia::cv::cv::get()),
_nvar(::streamfx::nvidia::ar::ar::get()), _fx()
{
D_LOG_DEBUG("Initializating... (Addr: 0x%" PRIuPTR ")", this);
auto gctx = ::streamfx::obs::gs::context();
auto cctx = cuda::obs::get()->get_context()->enter();
// Create the Effect/Feature.
::streamfx::nvidia::ar::handle_t handle;
if (cv::result res = _nvar->NvAR_Create(feature, &handle); res != cv::result::SUCCESS) {
throw cv::exception("Failed to create feature.", res);
}
_fx =
std::shared_ptr<void>(handle, [this](::streamfx::nvidia::ar::handle_t handle) { _nvar->NvAR_Destroy(handle); });
// Set CUDA stream and model directory.
set(P_NVAR_CONFIG "CUDAStream", _nvcuda->get_stream());
_model_path = _nvar->get_model_path().generic_u8string();
set(P_NVAR_CONFIG "ModelDir", _model_path);
}
streamfx::nvidia::cv::result streamfx::nvidia::ar::feature::get(parameter_t param, std::string_view& value)
{
const char* cvalue = nullptr;
cv::result res = get(param, cvalue);
if (res == cv::result::SUCCESS) {
if (cvalue) {
value.swap(std::string_view(cvalue));
} else {
value.swap(std::string_view());
}
}
return res;
}
streamfx::nvidia::cv::result streamfx::nvidia::ar::feature::get(parameter_t param, std::string& value)
{
const char* cvalue = nullptr;
cv::result res = get(param, cvalue);
if (res == cv::result::SUCCESS) {
if (cvalue) {
value = cvalue;
} else {
value.clear();
}
}
return res;
}

205
source/nvidia/ar/nvidia-ar-feature.hpp Normal file
View file

@ -0,0 +1,205 @@
// Copyright (c) 2021 Michael Fabian Dirks <info@xaymar.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#pragma once
#include <string_view>
#include "nvidia/ar/nvidia-ar.hpp"
#include "nvidia/cuda/nvidia-cuda-obs.hpp"
#include "nvidia/cv/nvidia-cv-image.hpp"
#include "nvidia/cv/nvidia-cv-texture.hpp"
#include "nvidia/cv/nvidia-cv.hpp"
namespace streamfx::nvidia::ar {
class feature {
protected:
std::shared_ptr<::streamfx::nvidia::cuda::obs> _nvcuda;
std::shared_ptr<::streamfx::nvidia::cv::cv> _nvcv;
std::shared_ptr<::streamfx::nvidia::ar::ar> _nvar;
std::shared_ptr<void> _fx;
std::string _model_path;
public:
~feature();
feature(feature_t feature);
::streamfx::nvidia::ar::handle_t get()
{
return _fx.get();
}
public /* Int32 */:
inline cv::result set(parameter_t param, uint32_t const value)
{
return _nvar->NvAR_SetU32(_fx.get(), param, value);
}
inline cv::result get(parameter_t param, uint32_t* value)
{
return _nvar->NvAR_GetU32(_fx.get(), param, value);
}
inline cv::result set(parameter_t param, int32_t const value)
{
return _nvar->NvAR_SetS32(_fx.get(), param, value);
}
inline cv::result get(parameter_t param, int32_t* value)
{
return _nvar->NvAR_GetS32(_fx.get(), param, value);
}
public /* Int64 */:
inline cv::result set(parameter_t param, uint64_t const value)
{
return _nvar->NvAR_SetU64(_fx.get(), param, value);
}
inline cv::result get(parameter_t param, uint64_t* value)
{
return _nvar->NvAR_GetU64(_fx.get(), param, value);
}
public /* Float32 */:
inline cv::result set(parameter_t param, float const value)
{
return _nvar->NvAR_SetF32(_fx.get(), param, value);
}
inline cv::result get(parameter_t param, float* value)
{
return _nvar->NvAR_GetF32(_fx.get(), param, value);
}
inline cv::result set(parameter_t param, float* const value, int32_t size)
{
return _nvar->NvAR_SetF32Array(_fx.get(), param, value, static_cast<int32_t>(size));
}
inline cv::result get(parameter_t param, const float* value, int32_t size)
{
return _nvar->NvAR_GetF32Array(_fx.get(), param, &value, &size);
}
inline cv::result set(parameter_t param, std::vector<float> const& value)
{
return _nvar->NvAR_SetF32Array(_fx.get(), param, value.data(), static_cast<int32_t>(value.size()));
}
inline cv::result get(parameter_t param, std::vector<float>& value)
{
const float* data;
int32_t size;
cv::result result;
result = _nvar->NvAR_GetF32Array(_fx.get(), param, &data, &size);
value.resize(size);
memcpy(value.data(), data, size * sizeof(float));
return result;
}
public /* Float64 */:
inline cv::result set(parameter_t param, double const value)
{
return _nvar->NvAR_SetF64(_fx.get(), param, value);
}
inline cv::result get(parameter_t param, double* value)
{
return _nvar->NvAR_GetF64(_fx.get(), param, value);
}
public /* String */:
inline cv::result set(parameter_t param, const char* const value)
{
return _nvar->NvAR_SetString(_fx.get(), param, value);
};
inline cv::result get(parameter_t param, const char*& value)
{
return _nvar->NvAR_GetString(_fx.get(), param, &value);
};
inline cv::result set(parameter_t param, std::string_view const value)
{
return _nvar->NvAR_SetString(_fx.get(), param, value.data());
};
cv::result get(parameter_t param, std::string_view& value);
inline cv::result set(parameter_t param, std::string const& value)
{
return _nvar->NvAR_SetString(_fx.get(), param, value.c_str());
};
cv::result get(parameter_t param, std::string& value);
public /* CUDA Stream */:
inline cv::result set(parameter_t param, cuda::stream_t const value)
{
return _nvar->NvAR_SetCudaStream(_fx.get(), param, value);
};
inline cv::result get(parameter_t param, cuda::stream_t& value)
{
return _nvar->NvAR_GetCudaStream(_fx.get(), param, &value);
};
inline cv::result set(parameter_t param, std::shared_ptr<::streamfx::nvidia::cuda::stream> const value)
{
return _nvar->NvAR_SetCudaStream(_fx.get(), param, value->get());
}
//inline cv::result get(parameter_t param, std::shared_ptr<::streamfx::nvidia::cuda::stream> value);
public /* CV Image */:
inline cv::result set(parameter_t param, cv::image_t& value)
{
return _nvar->NvAR_SetObject(_fx.get(), param, &value, sizeof(cv::image_t));
};
inline cv::result get(parameter_t param, cv::image_t*& value)
{
return _nvar->NvAR_GetObject(_fx.get(), param, reinterpret_cast<object_t*>(&value), sizeof(cv::image_t));
};
inline cv::result set(parameter_t param, std::shared_ptr<cv::image> const value)
{
return _nvar->NvAR_SetObject(_fx.get(), param, value->get_image(), sizeof(cv::image_t));
};
//inline cv::result get(parameter_t param, std::shared_ptr<cv::image>& value);
public /* CV Texture */:
inline cv::result set(parameter_t param, std::shared_ptr<cv::texture> const value)
{
return _nvar->NvAR_SetObject(_fx.get(), param, value->get_image(), sizeof(cv::image_t));
};
//inline cv::result get(parameter_t param, std::shared_ptr<cv::image>& value);
public /* Objects */:
inline cv::result set_object(parameter_t param, void* const data, size_t size)
{
return _nvar->NvAR_SetObject(_fx.get(), param, data, static_cast<uint32_t>(size));
}
inline cv::result get_object(parameter_t param, void*& data, size_t size)
{
return _nvar->NvAR_GetObject(_fx.get(), param, &data, static_cast<uint32_t>(size));
}
public /* Control */:
inline cv::result load()
{
return _nvar->NvAR_Load(_fx.get());
}
inline cv::result run()
{
return _nvar->NvAR_Run(_fx.get());
}
};
} // namespace streamfx::nvidia::ar