etc/obs-StreamFX
0
0
Fork 0
mirror of https://github.com/Xaymar/obs-StreamFX synced 2024-11-15 00:05:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

project: Remove non-standard std:: prefix from types

Browse source
This commit is contained in:
Michael Fabian 'Xaymar' Dirks 2020-08-10 03:29:05 +02:00 committed by Michael Fabian Dirks
parent dd9bbbcfe2
commit a53518cdb9
69 changed files with 349 additions and 357 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
source/encoders/codecs/hevc.cpp
View file

@ -23,7 +23,7 @@
using namespace streamfx::encoder::codec;
enum class nal_unit_type : std::uint8_t { // 6 bits
enum class nal_unit_type : uint8_t { // 6 bits
TRAIL_N = 0,
TRAIL_R = 1,
TSA_N = 2,
@ -93,17 +93,17 @@ enum class nal_unit_type : std::uint8_t { // 6 bits
struct hevc_nal_unit_header {
bool zero_bit : 1;
nal_unit_type nut : 6;
std::uint8_t layer_id : 6;
std::uint8_t temporal_id_plus1 : 3;
uint8_t layer_id : 6;
uint8_t temporal_id_plus1 : 3;
};
struct hevc_nal {
hevc_nal_unit_header* header;
std::size_t size = 0;
std::uint8_t* data = nullptr;
uint8_t* data = nullptr;
};
bool is_nal(std::uint8_t* data, std::uint8_t* end)
bool is_nal(uint8_t* data, uint8_t* end)
{
std::size_t s = static_cast<size_t>(end - data);
if (s < 4)
@ -121,7 +121,7 @@ bool is_nal(std::uint8_t* data, std::uint8_t* end)
return true;
}
bool seek_to_nal(std::uint8_t*& data, std::uint8_t* end)
bool seek_to_nal(uint8_t*& data, uint8_t* end)
{
if (data > end)
return false;
@ -135,16 +135,16 @@ bool seek_to_nal(std::uint8_t*& data, std::uint8_t* end)
return false;
}
std::size_t get_nal_size(std::uint8_t* data, std::uint8_t* end)
std::size_t get_nal_size(uint8_t* data, uint8_t* end)
{
std::uint8_t* ptr = data + 4;
uint8_t* ptr = data + 4;
if (!seek_to_nal(ptr, end)) {
return static_cast<size_t>(end - data);
}
return static_cast<size_t>(ptr - data);
}
bool is_discard_marker(std::uint8_t* data, std::uint8_t* end)
bool is_discard_marker(uint8_t* data, uint8_t* end)
{
std::size_t s = static_cast<size_t>(end - data);
if (s < 4)
@ -179,7 +179,7 @@ bool is_discard_marker(std::uint8_t* data, std::uint8_t* end)
}
}
bool should_discard_nal(std::uint8_t* data, std::uint8_t* end)
bool should_discard_nal(uint8_t* data, uint8_t* end)
{
if (data > end)
return true;
@ -192,17 +192,17 @@ bool should_discard_nal(std::uint8_t* data, std::uint8_t* end)
return false;
}
void progress_parse(std::uint8_t*& ptr, std::uint8_t* end, size_t& sz)
void progress_parse(uint8_t*& ptr, uint8_t* end, size_t& sz)
{
ptr += sz;
sz = get_nal_size(ptr, end);
}
void hevc::extract_header_sei(std::uint8_t* data, std::size_t sz_data, std::vector<std::uint8_t>& header,
std::vector<std::uint8_t>& sei)
void hevc::extract_header_sei(uint8_t* data, std::size_t sz_data, std::vector<uint8_t>& header,
std::vector<uint8_t>& sei)
{
std::uint8_t* ptr = data;
std::uint8_t* end = data + sz_data;
uint8_t* ptr = data;
uint8_t* end = data + sz_data;
// Reserve enough memory to store the entire packet data if necessary.
header.reserve(sz_data);

4
source/encoders/codecs/hevc.hpp
View file

@ -59,6 +59,6 @@ namespace streamfx::encoder::codec::hevc {
UNKNOWN = -1,
};
void extract_header_sei(std::uint8_t* data, std::size_t sz_data, std::vector<std::uint8_t>& header,
std::vector<std::uint8_t>& sei);
void extract_header_sei(uint8_t* data, std::size_t sz_data, std::vector<uint8_t>& header,
std::vector<uint8_t>& sei);
} // namespace streamfx::encoder::codec::hevc

2
source/encoders/codecs/prores.hpp
View file

@ -33,7 +33,7 @@
#define P_PRORES_PROFILE_AP4X "Codec.ProRes.Profile.AP4X"
namespace streamfx::encoder::codec::prores {
enum class profile : std::int32_t {
enum class profile : int32_t {
APCO = 0,
Y422_PROXY = APCO,
APCS = 1,

33
source/encoders/encoder-ffmpeg.cpp
View file

@ -180,7 +180,7 @@ void ffmpeg_instance::get_properties(obs_properties_t* props)
obs_property_set_enabled(obs_properties_get(props, KEY_FFMPEG_GPU), false);
}
void ffmpeg_instance::migrate(obs_data_t* settings, std::uint64_t version)
void ffmpeg_instance::migrate(obs_data_t* settings, uint64_t version)
{
if (_handler)
_handler->migrate(settings, version, _codec, _context);
@ -314,15 +314,15 @@ static inline void copy_data(encoder_frame* frame, AVFrame* vframe)
std::size_t plane_height = static_cast<size_t>(vframe->height) >> (idx ? v_chroma_shift : 0);
if (static_cast<std::uint32_t>(vframe->linesize[idx]) == frame->linesize[idx]) {
if (static_cast<uint32_t>(vframe->linesize[idx]) == frame->linesize[idx]) {
std::memcpy(vframe->data[idx], frame->data[idx], frame->linesize[idx] * plane_height);
} else {
std::size_t ls_in = static_cast<size_t>(frame->linesize[idx]);
std::size_t ls_out = static_cast<size_t>(vframe->linesize[idx]);
std::size_t bytes = ls_in < ls_out ? ls_in : ls_out;
std::uint8_t* to = vframe->data[idx];
std::uint8_t* from = frame->data[idx];
uint8_t* to = vframe->data[idx];
uint8_t* from = frame->data[idx];
for (std::size_t y = 0; y < plane_height; y++) {
std::memcpy(to, from, bytes);
@ -357,9 +357,8 @@ bool ffmpeg_instance::encode_video(struct encoder_frame* frame, struct encoder_p
&& (_scaler.get_source_format() == _scaler.get_target_format())) {
copy_data(frame, vframe.get());
} else {
int res =
_scaler.convert(reinterpret_cast<std::uint8_t**>(frame->data), reinterpret_cast<int*>(frame->linesize),
0, _context->height, vframe->data, vframe->linesize);
int res = _scaler.convert(reinterpret_cast<uint8_t**>(frame->data), reinterpret_cast<int*>(frame->linesize),
0, _context->height, vframe->data, vframe->linesize);
if (res <= 0) {
DLOG_ERROR("Failed to convert frame: %s (%" PRId32 ").", ::ffmpeg::tools::get_error_description(res),
res);
@ -447,13 +446,11 @@ void ffmpeg_instance::initialize_sw(obs_data_t* settings)
_context->framerate.num = _context->time_base.den = static_cast<int>(voi->fps_num);
_context->framerate.den = _context->time_base.num = static_cast<int>(voi->fps_den);
_scaler.set_source_size(static_cast<std::uint32_t>(_context->width),
static_cast<std::uint32_t>(_context->height));
_scaler.set_source_size(static_cast<uint32_t>(_context->width), static_cast<uint32_t>(_context->height));
_scaler.set_source_color(_context->color_range == AVCOL_RANGE_JPEG, _context->colorspace);
_scaler.set_source_format(_pixfmt_source);
_scaler.set_target_size(static_cast<std::uint32_t>(_context->width),
static_cast<std::uint32_t>(_context->height));
_scaler.set_target_size(static_cast<uint32_t>(_context->width), static_cast<uint32_t>(_context->height));
_scaler.set_target_color(_context->color_range == AVCOL_RANGE_JPEG, _context->colorspace);
_scaler.set_target_format(_pixfmt_target);
@ -603,10 +600,10 @@ int ffmpeg_instance::receive_packet(bool* received_packet, struct encoder_packet
if (!_have_first_frame) {
if (_codec->id == AV_CODEC_ID_H264) {
std::uint8_t* tmp_packet;
std::uint8_t* tmp_header;
std::uint8_t* tmp_sei;
std::size_t sz_packet, sz_header, sz_sei;
uint8_t* tmp_packet;
uint8_t* tmp_header;
uint8_t* tmp_sei;
std::size_t sz_packet, sz_header, sz_sei;
obs_extract_avc_headers(_packet.data, static_cast<size_t>(_packet.size), &tmp_packet, &sz_packet,
&tmp_header, &sz_header, &tmp_sei, &sz_sei);
@ -1025,13 +1022,13 @@ obs_properties_t* ffmpeg_factory::get_properties2(instance_t* data)
}
{ // Key-Frame Interval Seconds
auto p = obs_properties_add_float(grp, KEY_KEYFRAMES_INTERVAL_SECONDS, D_TRANSLATE(ST_KEYFRAMES_INTERVAL),
0.00, std::numeric_limits<std::int16_t>::max(), 0.01);
0.00, std::numeric_limits<int16_t>::max(), 0.01);
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_KEYFRAMES_INTERVAL)));
obs_property_float_set_suffix(p, " seconds");
}
{ // Key-Frame Interval Frames
auto p = obs_properties_add_int(grp, KEY_KEYFRAMES_INTERVAL_FRAMES, D_TRANSLATE(ST_KEYFRAMES_INTERVAL), 0,
std::numeric_limits<std::int32_t>::max(), 1);
std::numeric_limits<int32_t>::max(), 1);
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_KEYFRAMES_INTERVAL)));
obs_property_int_set_suffix(p, " frames");
}
@ -1053,7 +1050,7 @@ obs_properties_t* ffmpeg_factory::get_properties2(instance_t* data)
if (_handler && _handler->is_hardware_encoder(this)) {
auto p = obs_properties_add_int(grp, KEY_FFMPEG_GPU, D_TRANSLATE(ST_FFMPEG_GPU), -1,
std::numeric_limits<std::uint8_t>::max(), 1);
std::numeric_limits<uint8_t>::max(), 1);
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_FFMPEG_GPU)));
}

8
source/encoders/encoder-ffmpeg.hpp
View file

@ -67,9 +67,9 @@ namespace streamfx::encoder::ffmpeg {
std::size_t _sent_frames;
// Extra Data
bool _have_first_frame;
std::vector<std::uint8_t> _extra_data;
std::vector<std::uint8_t> _sei_data;
bool _have_first_frame;
std::vector<uint8_t> _extra_data;
std::vector<uint8_t> _sei_data;
// Frame Stack and Queue
std::stack<std::shared_ptr<AVFrame>> _free_frames;
@ -83,7 +83,7 @@ namespace streamfx::encoder::ffmpeg {
public:
void get_properties(obs_properties_t* props);
void migrate(obs_data_t* settings, std::uint64_t version) override;
void migrate(obs_data_t* settings, uint64_t version) override;
bool update(obs_data_t* settings) override;

2
source/encoders/handlers/handler.hpp
View file

@ -60,7 +60,7 @@ namespace streamfx::encoder::ffmpeg {
virtual void get_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context,
bool hw_encode){};
virtual void migrate(obs_data_t* settings, std::uint64_t version, const AVCodec* codec,
virtual void migrate(obs_data_t* settings, uint64_t version, const AVCodec* codec,
AVCodecContext* context){};
virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context){};

2
source/encoders/handlers/nvenc_h264_handler.cpp
View file

@ -178,7 +178,7 @@ void nvenc_h264_handler::get_runtime_properties(obs_properties_t* props, const A
nvenc::get_runtime_properties(props, codec, context);
}
void streamfx::encoder::ffmpeg::handler::nvenc_h264_handler::migrate(obs_data_t* settings, std::uint64_t version,
void streamfx::encoder::ffmpeg::handler::nvenc_h264_handler::migrate(obs_data_t* settings, uint64_t version,
const AVCodec* codec, AVCodecContext* context)
{
nvenc::migrate(settings, version, codec, context);

3
source/encoders/handlers/nvenc_h264_handler.hpp
View file

@ -53,8 +53,7 @@ namespace streamfx::encoder::ffmpeg::handler {
virtual void get_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context,
bool hw_encode);
virtual void migrate(obs_data_t* settings, std::uint64_t version, const AVCodec* codec,
AVCodecContext* context);
virtual void migrate(obs_data_t* settings, uint64_t version, const AVCodec* codec, AVCodecContext* context);
virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);

2
source/encoders/handlers/nvenc_hevc_handler.cpp
View file

@ -196,7 +196,7 @@ void nvenc_hevc_handler::get_runtime_properties(obs_properties_t* props, const A
nvenc::get_runtime_properties(props, codec, context);
}
void streamfx::encoder::ffmpeg::handler::nvenc_hevc_handler::migrate(obs_data_t* settings, std::uint64_t version,
void streamfx::encoder::ffmpeg::handler::nvenc_hevc_handler::migrate(obs_data_t* settings, uint64_t version,
const AVCodec* codec, AVCodecContext* context)
{
nvenc::migrate(settings, version, codec, context);

3
source/encoders/handlers/nvenc_hevc_handler.hpp
View file

@ -53,8 +53,7 @@ namespace streamfx::encoder::ffmpeg::handler {
virtual void get_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context,
bool hw_encode);
virtual void migrate(obs_data_t* settings, std::uint64_t version, const AVCodec* codec,
AVCodecContext* context);
virtual void migrate(obs_data_t* settings, uint64_t version, const AVCodec* codec, AVCodecContext* context);
virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);

8
source/encoders/handlers/nvenc_shared.cpp
View file

@ -345,21 +345,21 @@ void nvenc::get_properties_post(obs_properties_t* props, const AVCodec* codec)
{
auto p = obs_properties_add_int(grp, KEY_RATECONTROL_LIMITS_BITRATE_TARGET,
D_TRANSLATE(ST_RATECONTROL_LIMITS_BITRATE_TARGET), -1,
std::numeric_limits<std::int32_t>::max(), 1);
std::numeric_limits<int32_t>::max(), 1);
obs_property_int_set_suffix(p, " kbit/s");
}
{
auto p = obs_properties_add_int(grp, KEY_RATECONTROL_LIMITS_BITRATE_MAXIMUM,
D_TRANSLATE(ST_RATECONTROL_LIMITS_BITRATE_MAXIMUM), -1,
std::numeric_limits<std::int32_t>::max(), 1);
std::numeric_limits<int32_t>::max(), 1);
obs_property_int_set_suffix(p, " kbit/s");
}
{
auto p = obs_properties_add_int(grp, KEY_RATECONTROL_LIMITS_BUFFERSIZE,
D_TRANSLATE(ST_RATECONTROL_LIMITS_BUFFERSIZE), 0,
std::numeric_limits<std::int32_t>::max(), 1);
std::numeric_limits<int32_t>::max(), 1);
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_RATECONTROL_LIMITS_BUFFERSIZE)));
obs_property_int_set_suffix(p, " kbit");
}
@ -444,7 +444,7 @@ void nvenc::get_properties_post(obs_properties_t* props, const AVCodec* codec)
// H.264 does not support using all B-Frames as reference.
continue;
}
obs_property_list_add_int(p, D_TRANSLATE(kv.second.c_str()), static_cast<std::int64_t>(kv.first));
obs_property_list_add_int(p, D_TRANSLATE(kv.second.c_str()), static_cast<int64_t>(kv.first));
}
}

2
source/encoders/handlers/prores_aw_handler.cpp
View file

@ -42,7 +42,7 @@ void prores_aw_handler::override_colorformat(AVPixelFormat& target_format, obs_d
std::pair{profile::AP4H, AV_PIX_FMT_YUV444P10}, std::pair{profile::AP4X, AV_PIX_FMT_YUV444P10},
};
const std::int64_t profile_id = obs_data_get_int(settings, P_PRORES_PROFILE);
const int64_t profile_id = obs_data_get_int(settings, P_PRORES_PROFILE);
for (auto kv : profile_to_format_map) {
if (kv.first == static_cast<profile>(profile_id)) {
target_format = kv.second;

12
source/ffmpeg/avframe-queue.cpp
View file

@ -49,24 +49,24 @@ avframe_queue::~avframe_queue()
clear();
}
void avframe_queue::set_resolution(std::int32_t const width, std::int32_t const height)
void avframe_queue::set_resolution(int32_t const width, int32_t const height)
{
this->_resolution.first = width;
this->_resolution.second = height;
}
void avframe_queue::get_resolution(std::int32_t& width, std::int32_t& height)
void avframe_queue::get_resolution(int32_t& width, int32_t& height)
{
width = this->_resolution.first;
height = this->_resolution.second;
}
std::int32_t avframe_queue::get_width()
int32_t avframe_queue::get_width()
{
return this->_resolution.first;
}
std::int32_t avframe_queue::get_height()
int32_t avframe_queue::get_height()
{
return this->_resolution.second;
}
@ -113,8 +113,8 @@ std::shared_ptr<AVFrame> avframe_queue::pop()
ret = create_frame();
} else {
_frames.pop_front();
if ((static_cast<std::int32_t>(ret->width) != this->_resolution.first)
|| (static_cast<std::int32_t>(ret->height) != this->_resolution.second)
if ((static_cast<int32_t>(ret->width) != this->_resolution.first)
|| (static_cast<int32_t>(ret->height) != this->_resolution.second)
|| (ret->format != this->_format)) {
ret = nullptr;
}

12
source/ffmpeg/avframe-queue.hpp
View file

@ -40,8 +40,8 @@ namespace ffmpeg {
std::deque<std::shared_ptr<AVFrame>> _frames;
std::mutex _lock;
std::pair<std::int32_t, std::int32_t> _resolution;
AVPixelFormat _format = AV_PIX_FMT_NONE;
std::pair<int32_t, int32_t> _resolution;
AVPixelFormat _format = AV_PIX_FMT_NONE;
std::shared_ptr<AVFrame> create_frame();
@ -49,10 +49,10 @@ namespace ffmpeg {
avframe_queue();
~avframe_queue();
void set_resolution(std::int32_t width, std::int32_t height);
void get_resolution(std::int32_t& width, std::int32_t& height);
std::int32_t get_width();
std::int32_t get_height();
void set_resolution(int32_t width, int32_t height);
void get_resolution(int32_t& width, int32_t& height);
int32_t get_width();
int32_t get_height();
void set_pixel_format(AVPixelFormat format);
AVPixelFormat get_pixel_format();

6
source/ffmpeg/hwapi/base.hpp
View file

@ -50,10 +50,10 @@ namespace ffmpeg::hwapi {
virtual std::shared_ptr<AVFrame> allocate_frame(AVBufferRef* frames) = 0;
virtual void copy_from_obs(AVBufferRef* frames, std::uint32_t handle, uint64_t lock_key,
uint64_t* next_lock_key, std::shared_ptr<AVFrame> frame) = 0;
virtual void copy_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key, uint64_t* next_lock_key,
std::shared_ptr<AVFrame> frame) = 0;
virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, std::uint32_t handle, uint64_t lock_key,
virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
uint64_t* next_lock_key) = 0;
};

4
source/ffmpeg/hwapi/d3d11.cpp
View file

@ -208,7 +208,7 @@ std::shared_ptr<AVFrame> d3d11_instance::allocate_frame(AVBufferRef* frames)
return frame;
}
void d3d11_instance::copy_from_obs(AVBufferRef*, std::uint32_t handle, uint64_t lock_key, uint64_t* next_lock_key,
void d3d11_instance::copy_from_obs(AVBufferRef*, uint32_t handle, uint64_t lock_key, uint64_t* next_lock_key,
std::shared_ptr<AVFrame> frame)
{
auto gctx = gs::context();
@ -251,7 +251,7 @@ void d3d11_instance::copy_from_obs(AVBufferRef*, std::uint32_t handle, uint64_t
mutex->ReleaseSync(*next_lock_key);
}
std::shared_ptr<AVFrame> d3d11_instance::avframe_from_obs(AVBufferRef* frames, std::uint32_t handle, uint64_t lock_key,
std::shared_ptr<AVFrame> d3d11_instance::avframe_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
uint64_t* next_lock_key)
{
auto gctx = gs::context();

6
source/ffmpeg/hwapi/d3d11.hpp
View file

@ -74,10 +74,10 @@ namespace ffmpeg::hwapi {
virtual std::shared_ptr<AVFrame> allocate_frame(AVBufferRef* frames) override;
virtual void copy_from_obs(AVBufferRef* frames, std::uint32_t handle, uint64_t lock_key,
uint64_t* next_lock_key, std::shared_ptr<AVFrame> frame) override;
virtual void copy_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key, uint64_t* next_lock_key,
std::shared_ptr<AVFrame> frame) override;
virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, std::uint32_t handle, uint64_t lock_key,
virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
uint64_t* next_lock_key) override;
};
} // namespace ffmpeg::hwapi

16
source/ffmpeg/swscale.cpp
View file

@ -31,7 +31,7 @@ swscale::~swscale()
finalize();
}
void swscale::set_source_size(std::uint32_t width, std::uint32_t height)
void swscale::set_source_size(uint32_t width, uint32_t height)
{
source_size.first = width;
source_size.second = height;
@ -48,12 +48,12 @@ std::pair<uint32_t, uint32_t> swscale::get_source_size()
return this->source_size;
}
std::uint32_t swscale::get_source_width()
uint32_t swscale::get_source_width()
{
return this->source_size.first;
}
std::uint32_t swscale::get_source_height()
uint32_t swscale::get_source_height()
{
return this->source_size.second;
}
@ -94,7 +94,7 @@ bool swscale::is_source_full_range()
return this->source_full_range;
}
void swscale::set_target_size(std::uint32_t width, std::uint32_t height)
void swscale::set_target_size(uint32_t width, uint32_t height)
{
target_size.first = width;
target_size.second = height;
@ -111,12 +111,12 @@ std::pair<uint32_t, uint32_t> swscale::get_target_size()
return this->target_size;
}
std::uint32_t swscale::get_target_width()
uint32_t swscale::get_target_width()
{
return this->target_size.first;
}
std::uint32_t swscale::get_target_height()
uint32_t swscale::get_target_height()
{
return this->target_size.second;
}
@ -196,8 +196,8 @@ bool swscale::finalize()
return false;
}
int32_t swscale::convert(const std::uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, std::uint8_t* const target_data[], const int target_stride[])
int32_t swscale::convert(const uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, uint8_t* const target_data[], const int target_stride[])
{
if (!this->context) {
return 0;

16
source/ffmpeg/swscale.hpp
View file

@ -53,11 +53,11 @@ namespace ffmpeg {
swscale();
~swscale();
void set_source_size(std::uint32_t width, std::uint32_t height);
void set_source_size(uint32_t width, uint32_t height);
void get_source_size(uint32_t& width, uint32_t& height);
std::pair<uint32_t, uint32_t> get_source_size();
std::uint32_t get_source_width();
std::uint32_t get_source_height();
uint32_t get_source_width();
uint32_t get_source_height();
void set_source_format(AVPixelFormat format);
AVPixelFormat get_source_format();
void set_source_color(bool full_range, AVColorSpace space);
@ -66,11 +66,11 @@ namespace ffmpeg {
void set_source_full_range(bool full_range);
bool is_source_full_range();
void set_target_size(std::uint32_t width, std::uint32_t height);
void set_target_size(uint32_t width, uint32_t height);
void get_target_size(uint32_t& width, uint32_t& height);
std::pair<uint32_t, uint32_t> get_target_size();
std::uint32_t get_target_width();
std::uint32_t get_target_height();
uint32_t get_target_width();
uint32_t get_target_height();
void set_target_format(AVPixelFormat format);
AVPixelFormat get_target_format();
void set_target_color(bool full_range, AVColorSpace space);
@ -82,7 +82,7 @@ namespace ffmpeg {
bool initialize(int flags);
bool finalize();
int32_t convert(const std::uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, std::uint8_t* const target_data[], const int target_stride[]);
int32_t convert(const uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, uint8_t* const target_data[], const int target_stride[]);
};
} // namespace ffmpeg

22
source/filters/filter-blur.cpp
View file

@ -199,7 +199,7 @@ void blur_instance::load(obs_data_t* settings)
update(settings);
}
void blur_instance::migrate(obs_data_t* settings, std::uint64_t version)
void blur_instance::migrate(obs_data_t* settings, uint64_t version)
{
// Now we use a fall-through switch to gradually upgrade each known version change.
switch (version) {
@ -292,12 +292,12 @@ void blur_instance::update(obs_data_t* settings)
break;
}
if ((_mask.type == mask_type::Image) || (_mask.type == mask_type::Source)) {
std::uint32_t color = static_cast<uint32_t>(obs_data_get_int(settings, ST_MASK_COLOR));
_mask.color.r = ((color >> 0) & 0xFF) / 255.0f;
_mask.color.g = ((color >> 8) & 0xFF) / 255.0f;
_mask.color.b = ((color >> 16) & 0xFF) / 255.0f;
_mask.color.a = static_cast<float_t>(obs_data_get_double(settings, ST_MASK_ALPHA));
_mask.multiplier = float_t(obs_data_get_double(settings, ST_MASK_MULTIPLIER));
uint32_t color = static_cast<uint32_t>(obs_data_get_int(settings, ST_MASK_COLOR));
_mask.color.r = ((color >> 0) & 0xFF) / 255.0f;
_mask.color.g = ((color >> 8) & 0xFF) / 255.0f;
_mask.color.b = ((color >> 16) & 0xFF) / 255.0f;
_mask.color.a = static_cast<float_t>(obs_data_get_double(settings, ST_MASK_ALPHA));
_mask.multiplier = float_t(obs_data_get_double(settings, ST_MASK_MULTIPLIER));
}
}
}
@ -357,8 +357,8 @@ void blur_instance::video_render(gs_effect_t* effect)
obs_source_t* parent = obs_filter_get_parent(this->_self);
obs_source_t* target = obs_filter_get_target(this->_self);
gs_effect_t* defaultEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
std::uint32_t baseW = obs_source_get_base_width(target);
std::uint32_t baseH = obs_source_get_base_height(target);
uint32_t baseW = obs_source_get_base_width(target);
uint32_t baseH = obs_source_get_base_height(target);
// Verify that we can actually run first.
if (!target || !parent || !this->_self || !this->_blur || (baseW == 0) || (baseH == 0)) {
@ -474,8 +474,8 @@ void blur_instance::video_render(gs_effect_t* effect)
}
if (_mask.source.source_texture) {
std::uint32_t source_width = obs_source_get_width(this->_mask.source.source_texture->get_object());
std::uint32_t source_height = obs_source_get_height(this->_mask.source.source_texture->get_object());
uint32_t source_width = obs_source_get_width(this->_mask.source.source_texture->get_object());
uint32_t source_height = obs_source_get_height(this->_mask.source.source_texture->get_object());
if (source_width == 0) {
source_width = baseW;

2
source/filters/filter-blur.hpp
View file

@ -100,7 +100,7 @@ namespace streamfx::filter::blur {
public:
virtual void load(obs_data_t* settings) override;
virtual void migrate(obs_data_t* settings, std::uint64_t version) override;
virtual void migrate(obs_data_t* settings, uint64_t version) override;
virtual void update(obs_data_t* settings) override;
virtual void video_tick(float_t time) override;

6
source/filters/filter-color-grade.cpp
View file

@ -127,7 +127,7 @@ void color_grade_instance::load(obs_data_t* data)
update(data);
}
void color_grade_instance::migrate(obs_data_t* data, std::uint64_t version) {}
void color_grade_instance::migrate(obs_data_t* data, uint64_t version) {}
void color_grade_instance::update(obs_data_t* data)
{
@ -176,8 +176,8 @@ void color_grade_instance::video_render(gs_effect_t* effect)
// Grab initial values.
obs_source_t* parent = obs_filter_get_parent(_self);
obs_source_t* target = obs_filter_get_target(_self);
std::uint32_t width = obs_source_get_base_width(target);
std::uint32_t height = obs_source_get_base_height(target);
uint32_t width = obs_source_get_base_width(target);
uint32_t height = obs_source_get_base_height(target);
gs_effect_t* effect_default = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
// Skip filter if anything is wrong.

2
source/filters/filter-color-grade.hpp
View file

@ -72,7 +72,7 @@ namespace streamfx::filter::color_grade {
virtual ~color_grade_instance();
virtual void load(obs_data_t* data) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* data) override;
virtual void video_tick(float_t time) override;

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

@ -55,7 +55,7 @@ void displacement_instance::load(obs_data_t* settings)
update(settings);
}
void displacement_instance::migrate(obs_data_t* data, std::uint64_t version)
void displacement_instance::migrate(obs_data_t* data, uint64_t version)
{
switch (version & STREAMFX_MASK_COMPAT) {
case 0:

6
source/filters/filter-displacement.hpp
View file

@ -33,15 +33,15 @@ namespace streamfx::filter::displacement {
float_t _scale_type;
// Cache
std::uint32_t _width;
std::uint32_t _height;
uint32_t _width;
uint32_t _height;
public:
displacement_instance(obs_data_t*, obs_source_t*);
virtual ~displacement_instance();
virtual void load(obs_data_t* settings) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* settings) override;
virtual void video_tick(float_t) override;

6
source/filters/filter-dynamic-mask.cpp
View file

@ -79,7 +79,7 @@ void dynamic_mask_instance::load(obs_data_t* settings)
update(settings);
}
void dynamic_mask_instance::migrate(obs_data_t* data, std::uint64_t version) {}
void dynamic_mask_instance::migrate(obs_data_t* data, uint64_t version) {}
void dynamic_mask_instance::update(obs_data_t* settings)
{
@ -191,8 +191,8 @@ void dynamic_mask_instance::video_render(gs_effect_t* in_effect)
{
obs_source_t* parent = obs_filter_get_parent(_self);
obs_source_t* target = obs_filter_get_target(_self);
std::uint32_t width = obs_source_get_base_width(target);
std::uint32_t height = obs_source_get_base_height(target);
uint32_t width = obs_source_get_base_width(target);
uint32_t height = obs_source_get_base_height(target);
if (!_self || !parent || !target || !width || !height || !_input || !_input_capture || !_effect) {
obs_source_skip_video_filter(_self);

4
source/filters/filter-dynamic-mask.hpp
View file

@ -28,7 +28,7 @@
#include "obs/obs-source.hpp"
namespace streamfx::filter::dynamic_mask {
enum class channel : std::int8_t { Invalid = -1, Red, Green, Blue, Alpha };
enum class channel : int8_t { Invalid = -1, Red, Green, Blue, Alpha };
class dynamic_mask_instance : public obs::source_instance {
std::map<std::tuple<channel, channel, std::string>, std::string> _translation_map;
@ -66,7 +66,7 @@ namespace streamfx::filter::dynamic_mask {
virtual ~dynamic_mask_instance();
virtual void load(obs_data_t* settings) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* settings) override;
virtual void save(obs_data_t* settings) override;

6
source/filters/filter-nv-face-tracking.cpp
View file

@ -172,7 +172,7 @@ void face_tracking_instance::async_initialize(std::shared_ptr<void> ptr)
// Create Bounding Boxes Data
_ar_bboxes_data.assign(1, {0., 0., 0., 0.});
_ar_bboxes.boxes = _ar_bboxes_data.data();
_ar_bboxes.max_boxes = std::clamp<std::uint8_t>(static_cast<std::uint8_t>(_ar_bboxes_data.size()), 0, 255);
_ar_bboxes.max_boxes = std::clamp<uint8_t>(static_cast<uint8_t>(_ar_bboxes_data.size()), 0, 255);
_ar_bboxes.num_boxes = 0;
_ar_bboxes_confidence.resize(_ar_bboxes_data.size());
if (NvCV_Status res = _ar_library->set_object(_ar_feature.get(), NvAR_Parameter_Output(BoundingBoxes),
@ -474,7 +474,7 @@ void face_tracking_instance::load(obs_data_t* data)
update(data);
}
void face_tracking_instance::migrate(obs_data_t* data, std::uint64_t version) {}
void face_tracking_instance::migrate(obs_data_t* data, uint64_t version) {}
void face_tracking_instance::update(obs_data_t* data)
{
@ -592,7 +592,7 @@ bool face_tracking_instance::button_profile(obs_properties_t* props, obs_propert
for (auto& kv : profilers) {
DLOG_INFO(" %-20s: %8lldµs %10lld %8lldµs %8lldµs %8lldµs", kv.first.c_str(),
std::chrono::duration_cast<std::chrono::microseconds>(kv.second->total_duration()).count(),
kv.second->count(), static_cast<std::int64_t>(kv.second->average_duration() / 1000.0),
kv.second->count(), static_cast<int64_t>(kv.second->average_duration() / 1000.0),
std::chrono::duration_cast<std::chrono::microseconds>(kv.second->percentile(0.999)).count(),
std::chrono::duration_cast<std::chrono::microseconds>(kv.second->percentile(0.95)).count());
}

8
source/filters/filter-nv-face-tracking.hpp
View file

@ -37,9 +37,9 @@
namespace streamfx::filter::nvidia {
class face_tracking_instance : public obs::source_instance {
// Filter Cache
std::pair<std::uint32_t, std::uint32_t> _size;
bool _rt_is_fresh;
std::shared_ptr<gs::rendertarget> _rt;
std::pair<uint32_t, uint32_t> _size;
bool _rt_is_fresh;
std::shared_ptr<gs::rendertarget> _rt;
std::mutex _delete_protection;
@ -114,7 +114,7 @@ namespace streamfx::filter::nvidia {
virtual void load(obs_data_t* data) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* data) override;

46
source/filters/filter-sdf-effects.cpp
View file

@ -122,7 +122,7 @@ void sdf_effects_instance::load(obs_data_t* settings)
update(settings);
}
void sdf_effects_instance::migrate(obs_data_t* data, std::uint64_t version) {}
void sdf_effects_instance::migrate(obs_data_t* data, uint64_t version) {}
void sdf_effects_instance::update(obs_data_t* data)
{
@ -132,12 +132,12 @@ void sdf_effects_instance::update(obs_data_t* data)
&& (obs_data_get_double(data, ST_SHADOW_OUTER_ALPHA) >= std::numeric_limits<double_t>::epsilon());
{
struct cs {
std::uint8_t r, g, b, a;
uint8_t r, g, b, a;
};
union {
std::uint32_t color;
std::uint8_t channel[4];
cs c;
uint32_t color;
uint8_t channel[4];
cs c;
};
color = uint32_t(obs_data_get_int(data, ST_SHADOW_OUTER_COLOR));
_outer_shadow_color.x = float_t(c.r / 255.0);
@ -157,12 +157,12 @@ void sdf_effects_instance::update(obs_data_t* data)
&& (obs_data_get_double(data, ST_SHADOW_INNER_ALPHA) >= std::numeric_limits<double_t>::epsilon());
{
struct cs {
std::uint8_t r, g, b, a;
uint8_t r, g, b, a;
};
union {
std::uint32_t color;
std::uint8_t channel[4];
cs c;
uint32_t color;
uint8_t channel[4];
cs c;
};
color = uint32_t(obs_data_get_int(data, ST_SHADOW_INNER_COLOR));
_inner_shadow_color.x = float_t(c.r / 255.0);
@ -181,12 +181,12 @@ void sdf_effects_instance::update(obs_data_t* data)
&& (obs_data_get_double(data, ST_GLOW_OUTER_ALPHA) >= std::numeric_limits<double_t>::epsilon());
{
struct cs {
std::uint8_t r, g, b, a;
uint8_t r, g, b, a;
};
union {
std::uint32_t color;
std::uint8_t channel[4];
cs c;
uint32_t color;
uint8_t channel[4];
cs c;
};
color = uint32_t(obs_data_get_int(data, ST_GLOW_OUTER_COLOR));
_outer_glow_color.x = float_t(c.r / 255.0);
@ -207,12 +207,12 @@ void sdf_effects_instance::update(obs_data_t* data)
&& (obs_data_get_double(data, ST_GLOW_INNER_ALPHA) >= std::numeric_limits<double_t>::epsilon());
{
struct cs {
std::uint8_t r, g, b, a;
uint8_t r, g, b, a;
};
union {
std::uint32_t color;
std::uint8_t channel[4];
cs c;
uint32_t color;
uint8_t channel[4];
cs c;
};
color = uint32_t(obs_data_get_int(data, ST_GLOW_INNER_COLOR));
_inner_glow_color.x = float_t(c.r / 255.0);
@ -233,12 +233,12 @@ void sdf_effects_instance::update(obs_data_t* data)
&& (obs_data_get_double(data, ST_OUTLINE_ALPHA) >= std::numeric_limits<double_t>::epsilon());
{
struct cs {
std::uint8_t r, g, b, a;
uint8_t r, g, b, a;
};
union {
std::uint32_t color;
std::uint8_t channel[4];
cs c;
uint32_t color;
uint8_t channel[4];
cs c;
};
color = uint32_t(obs_data_get_int(data, ST_OUTLINE_COLOR));
_outline_color.x = float_t(c.r / 255.0);
@ -271,8 +271,8 @@ void sdf_effects_instance::video_render(gs_effect_t* effect)
{
obs_source_t* parent = obs_filter_get_parent(_self);
obs_source_t* target = obs_filter_get_target(_self);
std::uint32_t baseW = obs_source_get_base_width(target);
std::uint32_t baseH = obs_source_get_base_height(target);
uint32_t baseW = obs_source_get_base_width(target);
uint32_t baseH = obs_source_get_base_height(target);
gs_effect_t* final_effect = effect ? effect : obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
gs_effect_t* default_effect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);

2
source/filters/filter-sdf-effects.hpp
View file

@ -86,7 +86,7 @@ namespace streamfx::filter::sdf_effects {
virtual ~sdf_effects_instance();
virtual void load(obs_data_t* settings) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* settings) override;
virtual void video_tick(float_t) override;

6
source/filters/filter-shader.cpp
View file

@ -34,12 +34,12 @@ shader_instance::shader_instance(obs_data_t* data, obs_source_t* self) : obs::so
shader_instance::~shader_instance() {}
std::uint32_t shader_instance::get_width()
uint32_t shader_instance::get_width()
{
return _fx->width();
}
std::uint32_t shader_instance::get_height()
uint32_t shader_instance::get_height()
{
return _fx->height();
}
@ -54,7 +54,7 @@ void shader_instance::load(obs_data_t* data)
update(data);
}
void shader_instance::migrate(obs_data_t* data, std::uint64_t version) {}
void shader_instance::migrate(obs_data_t* data, uint64_t version) {}
void shader_instance::update(obs_data_t* data)
{

6
source/filters/filter-shader.hpp
View file

@ -32,13 +32,13 @@ namespace streamfx::filter::shader {
shader_instance(obs_data_t* data, obs_source_t* self);
virtual ~shader_instance();
virtual std::uint32_t get_width() override;
virtual std::uint32_t get_height() override;
virtual uint32_t get_width() override;
virtual uint32_t get_height() override;
void properties(obs_properties_t* props);
virtual void load(obs_data_t* data) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t* data) override;
virtual void video_tick(float_t sec_since_last) override;

16
source/filters/filter-transform.cpp
View file

@ -85,7 +85,7 @@ transform_instance::transform_instance(obs_data_t* data, obs_source_t* context)
{
_cache_rt = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
_source_rt = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
_vertex_buffer = std::make_shared<gs::vertex_buffer>(uint32_t(4u), std::uint8_t(1u));
_vertex_buffer = std::make_shared<gs::vertex_buffer>(uint32_t(4u), uint8_t(1u));
_position = std::make_unique<util::vec3a>();
_rotation = std::make_unique<util::vec3a>();
@ -116,7 +116,7 @@ void transform_instance::load(obs_data_t* settings)
update(settings);
}
void transform_instance::migrate(obs_data_t* data, std::uint64_t version)
void transform_instance::migrate(obs_data_t* data, uint64_t version)
{
switch (version & STREAMFX_MASK_COMPAT) {
case 0:
@ -154,8 +154,8 @@ void transform_instance::update(obs_data_t* settings)
void transform_instance::video_tick(float_t)
{
std::uint32_t width = 0;
std::uint32_t height = 0;
uint32_t width = 0;
uint32_t height = 0;
// Grab parent and target.
obs_source_t* target = obs_filter_get_target(_self);
@ -274,8 +274,8 @@ void transform_instance::video_render(gs_effect_t* effect)
{
obs_source_t* parent = obs_filter_get_parent(_self);
obs_source_t* target = obs_filter_get_target(_self);
std::uint32_t base_width = obs_source_get_base_width(target);
std::uint32_t base_height = obs_source_get_base_height(target);
uint32_t base_width = obs_source_get_base_width(target);
uint32_t base_height = obs_source_get_base_height(target);
gs_effect_t* default_effect = obs_get_base_effect(OBS_EFFECT_DEFAULT);
if (!effect)
effect = default_effect;
@ -290,8 +290,8 @@ void transform_instance::video_render(gs_effect_t* effect)
obs_source_get_name(obs_filter_get_parent(_self))};
#endif
std::uint32_t cache_width = base_width;
std::uint32_t cache_height = base_height;
uint32_t cache_width = base_width;
uint32_t cache_height = base_height;
if (_mipmap_enabled) {
double_t aspect = double_t(base_width) / double_t(base_height);

4
source/filters/filter-transform.hpp
View file

@ -48,7 +48,7 @@ namespace streamfx::filter::transform {
// Mesh
bool _update_mesh;
std::shared_ptr<gs::vertex_buffer> _vertex_buffer;
std::uint32_t _rotation_order;
uint32_t _rotation_order;
std::unique_ptr<util::vec3a> _position;
std::unique_ptr<util::vec3a> _rotation;
std::unique_ptr<util::vec3a> _scale;
@ -63,7 +63,7 @@ namespace streamfx::filter::transform {
virtual ~transform_instance() override;
virtual void load(obs_data_t* settings) override;
virtual void migrate(obs_data_t* data, std::uint64_t version) override;
virtual void migrate(obs_data_t* data, uint64_t version) override;
virtual void update(obs_data_t*) override;
virtual void video_tick(float_t) override;

12
source/gfx/blur/gfx-blur-dual-filtering.cpp
View file

@ -271,8 +271,8 @@ std::shared_ptr<::gs::texture> gfx::blur::dual_filtering::render()
}
// Reduce Size
std::uint32_t owidth = width >> n;
std::uint32_t oheight = height >> n;
uint32_t owidth = width >> n;
uint32_t oheight = height >> n;
if ((owidth <= 0) || (oheight <= 0)) {
actual_iterations = n - 1;
break;
@ -303,10 +303,10 @@ std::shared_ptr<::gs::texture> gfx::blur::dual_filtering::render()
std::shared_ptr<gs::texture> tex_in = _rts[n]->get_texture();
// Get Size
std::uint32_t iwidth = width >> n;
std::uint32_t iheight = height >> n;
std::uint32_t owidth = width >> (n - 1);
std::uint32_t oheight = height >> (n - 1);
uint32_t iwidth = width >> n;
uint32_t iheight = height >> n;
uint32_t owidth = width >> (n - 1);
uint32_t oheight = height >> (n - 1);
// Apply
effect.get_parameter("pImage").set_texture(tex_in);

8
source/gfx/shader/gfx-shader-param-basic.hpp
View file

@ -33,9 +33,9 @@ namespace gfx {
struct basic_data {
union {
int32_t i32;
std::uint32_t ui32;
float_t f32;
int32_t i32;
uint32_t ui32;
float_t f32;
};
};
@ -95,7 +95,7 @@ namespace gfx {
struct bool_parameter : public basic_parameter {
// std::vector<bool> doesn't allow .data()
std::vector<std::int32_t> _data;
std::vector<int32_t> _data;
public:
bool_parameter(gs::effect_parameter param, std::string prefix);

12
source/gfx/shader/gfx-shader.cpp
View file

@ -375,7 +375,7 @@ void gfx::shader::shader::update(obs_data_t* data)
}
}
std::uint32_t gfx::shader::shader::width()
uint32_t gfx::shader::shader::width()
{
switch (_mode) {
case shader_mode::Transition:
@ -399,7 +399,7 @@ std::uint32_t gfx::shader::shader::width()
}
}
std::uint32_t gfx::shader::shader::height()
uint32_t gfx::shader::shader::height()
{
switch (_mode) {
case shader_mode::Transition:
@ -423,12 +423,12 @@ std::uint32_t gfx::shader::shader::height()
}
}
std::uint32_t gfx::shader::shader::base_width()
uint32_t gfx::shader::shader::base_width()
{
return _base_width;
}
std::uint32_t gfx::shader::shader::base_height()
uint32_t gfx::shader::shader::base_height()
{
return _base_height;
}
@ -537,7 +537,7 @@ void gfx::shader::shader::render()
}
}
void gfx::shader::shader::set_size(std::uint32_t w, std::uint32_t h)
void gfx::shader::shader::set_size(uint32_t w, uint32_t h)
{
_base_width = w;
_base_height = h;
@ -595,7 +595,7 @@ void gfx::shader::shader::set_transition_time(float_t t)
}
}
void gfx::shader::shader::set_transition_size(std::uint32_t w, std::uint32_t h)
void gfx::shader::shader::set_transition_size(uint32_t w, uint32_t h)
{
if (!_shader)
return;

20
source/gfx/shader/gfx-shader.hpp
View file

@ -44,10 +44,10 @@ namespace gfx {
obs_source_t* _self;
// Inputs
shader_mode _mode;
std::uint32_t _base_width;
std::uint32_t _base_height;
bool _active;
shader_mode _mode;
uint32_t _base_width;
uint32_t _base_height;
bool _active;
// Shader
gs::effect _shader;
@ -100,13 +100,13 @@ namespace gfx {
void update(obs_data_t* data);
std::uint32_t width();
uint32_t width();
std::uint32_t height();
uint32_t height();
std::uint32_t base_width();
uint32_t base_width();
std::uint32_t base_height();
uint32_t base_height();
bool tick(float_t time);
@ -115,7 +115,7 @@ namespace gfx {
void render();
public:
void set_size(std::uint32_t w, std::uint32_t h);
void set_size(uint32_t w, uint32_t h);
void set_input_a(std::shared_ptr<gs::texture> tex);
@ -123,7 +123,7 @@ namespace gfx {
void set_transition_time(float_t t);
void set_transition_size(std::uint32_t w, std::uint32_t h);
void set_transition_size(uint32_t w, uint32_t h);
void set_active(bool active);
};

14
source/nvidia/ar/nvidia-ar-feature.hpp
View file

@ -38,37 +38,37 @@ namespace nvidia::ar {
inline NvCV_Status get(std::string name, T& value);
template<>
inline NvCV_Status set(std::string name, std::int32_t value)
inline NvCV_Status set(std::string name, int32_t value)
{
return _ar->set_int32(_feature.get(), name.c_str(), value);
}
template<>
inline NvCV_Status get(std::string name, std::int32_t& value)
inline NvCV_Status get(std::string name, int32_t& value)
{
return _ar->get_int32(_feature.get(), name.c_str(), &value);
}
template<>
inline NvCV_Status set(std::string name, std::uint32_t value)
inline NvCV_Status set(std::string name, uint32_t value)
{
return _ar->set_uint32(_feature.get(), name.c_str(), value);
}
template<>
inline NvCV_Status get(std::string name, std::uint32_t& value)
inline NvCV_Status get(std::string name, uint32_t& value)
{
return _ar->get_uint32(_feature.get(), name.c_str(), &value);
}
template<>
inline NvCV_Status set(std::string name, std::uint64_t value)
inline NvCV_Status set(std::string name, uint64_t value)
{
return _ar->set_uint64(_feature.get(), name.c_str(), value);
}
template<>
inline NvCV_Status get(std::string name, std::uint64_t& value)
inline NvCV_Status get(std::string name, uint64_t& value)
{
return _ar->get_uint64(_feature.get(), name.c_str(), &value);
}
@ -89,7 +89,7 @@ namespace nvidia::ar {
inline NvCV_Status set(std::string name, std::vector<std::float_t> value)
{
return _ar->set_float32_array(_feature.get(), name.c_str(), value.data(),
static_cast<std::int32_t>(value.size()));
static_cast<int32_t>(value.size()));
}
template<>

2
source/nvidia/cuda/nvidia-cuda-stream.cpp
View file

@ -21,7 +21,7 @@
#include <stdexcept>
nvidia::cuda::stream::stream(std::shared_ptr<::nvidia::cuda::cuda> cuda, ::nvidia::cuda::stream_flags flags,
std::int32_t priority)
int32_t priority)
: _cuda(cuda)
{
nvidia::cuda::result res;

2
source/nvidia/cuda/nvidia-cuda-stream.hpp
View file

@ -28,7 +28,7 @@ namespace nvidia::cuda {
public:
stream(std::shared_ptr<::nvidia::cuda::cuda> cuda,
::nvidia::cuda::stream_flags flags = ::nvidia::cuda::stream_flags::DEFAULT, std::int32_t priority = 0);
::nvidia::cuda::stream_flags flags = ::nvidia::cuda::stream_flags::DEFAULT, int32_t priority = 0);
~stream();
::nvidia::cuda::stream_t get();

50
source/nvidia/cuda/nvidia-cuda.hpp
View file

@ -58,14 +58,14 @@ namespace nvidia::cuda {
// Still missing some.
};
enum class memory_type : std::uint32_t {
enum class memory_type : uint32_t {
HOST = 1,
DEVICE = 2,
ARRAY = 3,
UNIFIED = 4,
};
enum class array_format : std::uint32_t {
enum class array_format : uint32_t {
UNSIGNED_INT8 = 0b00000001,
UNSIGNED_INT16 = 0b00000010,
UNSIGNED_INT32 = 0b00000011,
@ -76,7 +76,7 @@ namespace nvidia::cuda {
FLOAT = 0b00100000,
};
enum class context_flags : std::uint32_t {
enum class context_flags : uint32_t {
SCHEDULER_AUTO = 0x0,
SCHEDULER_SPIN = 0x1,
SCHEDULER_YIELD = 0x2,
@ -85,17 +85,17 @@ namespace nvidia::cuda {
LOCAL_MEMORY_RESIZE_TO_MAXIMUM = 0x10,
};
enum class stream_flags : std::uint32_t {
enum class stream_flags : uint32_t {
DEFAULT = 0x0,
NON_BLOCKING = 0x1,
};
typedef void* array_t;
typedef void* context_t;
typedef std::uint64_t device_ptr_t;
typedef void* graphics_resource_t;
typedef void* stream_t;
typedef std::int32_t device_t;
typedef void* array_t;
typedef void* context_t;
typedef uint64_t device_ptr_t;
typedef void* graphics_resource_t;
typedef void* stream_t;
typedef int32_t device_t;
struct memcpy2d_t {
std::size_t src_x_in_bytes;
@ -121,10 +121,10 @@ namespace nvidia::cuda {
};
struct array_descriptor_t {
std::size_t width;
std::size_t height;
std::uint32_t num_channels;
array_format format;
std::size_t width;
std::size_t height;
uint32_t num_channels;
array_format format;
};
class cuda {
@ -137,10 +137,10 @@ namespace nvidia::cuda {
public:
// Initialization
CUDA_DEFINE_FUNCTION(cuInit, std::int32_t flags);
CUDA_DEFINE_FUNCTION(cuInit, int32_t flags);
// Version Management
CUDA_DEFINE_FUNCTION(cuDriverGetVersion, std::int32_t* driverVersion);
CUDA_DEFINE_FUNCTION(cuDriverGetVersion, int32_t* driverVersion);
// Device Management
// cuDeviceGet
@ -169,7 +169,7 @@ namespace nvidia::cuda {
// cuCtxGetFlags
// cuCtxGetLimit
// cuCtxGetSharedMemConfig
CUDA_DEFINE_FUNCTION(cuCtxGetStreamPriorityRange, std::int32_t* lowestPriority, std::int32_t* highestPriority);
CUDA_DEFINE_FUNCTION(cuCtxGetStreamPriorityRange, int32_t* lowestPriority, int32_t* highestPriority);
CUDA_DEFINE_FUNCTION(cuCtxPopCurrent, context_t* ctx);
CUDA_DEFINE_FUNCTION(cuCtxPushCurrent, context_t ctx);
// cuCtxSetCacheConfig
@ -214,13 +214,13 @@ namespace nvidia::cuda {
// cuMemAllocHost_v2
// cuMemAllocManaged
CUDA_DEFINE_FUNCTION(cuMemAllocPitch, device_ptr_t* ptr, std::size_t* pitch, std::size_t width_in_bytes,
std::size_t height, std::uint32_t element_size_bytes);
std::size_t height, uint32_t element_size_bytes);
CUDA_DEFINE_FUNCTION(cuMemFree, device_ptr_t ptr);
// cuMemFreeHost
// cuMemGetAddressRange_v2
// cuMemGetInfo_v2
// cuMemHostAlloc
CUDA_DEFINE_FUNCTION(cuMemHostGetDevicePointer, device_ptr_t* devptr, void* ptr, std::uint32_t flags);
CUDA_DEFINE_FUNCTION(cuMemHostGetDevicePointer, device_ptr_t* devptr, void* ptr, uint32_t flags);
// cuMemHostGetFlags
// cuMemHostRegister_v2
// cuMemHostUnregister
@ -292,7 +292,7 @@ namespace nvidia::cuda {
// cuStreamAttachMemAsync
// cuStreamBeginCapture_v2
CUDA_DEFINE_FUNCTION(cuStreamCreate, stream_t* stream, stream_flags flags);
CUDA_DEFINE_FUNCTION(cuStreamCreateWithPriority, stream_t* stream, stream_flags flags, std::int32_t priority);
CUDA_DEFINE_FUNCTION(cuStreamCreateWithPriority, stream_t* stream, stream_flags flags, int32_t priority);
CUDA_DEFINE_FUNCTION(cuStreamDestroy, stream_t stream);
// cuStreamEndCapture
// cuStreamGetCaptureInfo
@ -356,15 +356,13 @@ namespace nvidia::cuda {
// Todo
// Graphics Interoperability
CUDA_DEFINE_FUNCTION(cuGraphicsMapResources, std::uint32_t count, graphics_resource_t* resources,
stream_t stream);
CUDA_DEFINE_FUNCTION(cuGraphicsMapResources, uint32_t count, graphics_resource_t* resources, stream_t stream);
// cuGraphicsResourcesGetMappedMipmappedArray
// cuGraphicsResourcesGetMappedPointer_v2
// cuGraphicsResourcesSetMapFlags_v2
CUDA_DEFINE_FUNCTION(cuGraphicsSubResourceGetMappedArray, array_t* array, graphics_resource_t resource,
std::uint32_t index, std::uint32_t level);
CUDA_DEFINE_FUNCTION(cuGraphicsUnmapResources, std::uint32_t count, graphics_resource_t* resources,
stream_t stream);
uint32_t index, uint32_t level);
CUDA_DEFINE_FUNCTION(cuGraphicsUnmapResources, uint32_t count, graphics_resource_t* resources, stream_t stream);
CUDA_DEFINE_FUNCTION(cuGraphicsUnregisterResource, graphics_resource_t resource);
// Profile Control
@ -394,7 +392,7 @@ namespace nvidia::cuda {
CUDA_DEFINE_FUNCTION(cuD3D11GetDevice, device_t* device, IDXGIAdapter* adapter);
// cuD3D11GetDevices
CUDA_DEFINE_FUNCTION(cuGraphicsD3D11RegisterResource, graphics_resource_t* resource,
ID3D11Resource* d3dresource, std::uint32_t flags);
ID3D11Resource* d3dresource, uint32_t flags);
#endif
public:
static std::shared_ptr<cuda> get();

44
source/obs/gs/gs-effect-parameter.cpp
View file

@ -293,7 +293,7 @@ void gs::effect_parameter::get_float2(float_t& x, float_t& y)
{
if (get_type() != type::Float2)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -307,7 +307,7 @@ void gs::effect_parameter::get_default_float2(float_t& x, float_t& y)
{
if (get_type() != type::Float2)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -346,7 +346,7 @@ void gs::effect_parameter::get_float3(float_t& x, float_t& y, float_t& z)
{
if (get_type() != type::Float3)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -361,7 +361,7 @@ void gs::effect_parameter::get_default_float3(float_t& x, float_t& y, float_t& z
{
if (get_type() != type::Float3)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -401,7 +401,7 @@ void gs::effect_parameter::get_float4(float_t& x, float_t& y, float_t& z, float_
{
if (get_type() != type::Float4)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -417,7 +417,7 @@ void gs::effect_parameter::get_default_float4(float_t& x, float_t& y, float_t& z
{
if (get_type() != type::Float4)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<float_t*>(ptr);
y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t));
@ -440,7 +440,7 @@ void gs::effect_parameter::get_int(int32_t& x)
{
if ((get_type() != type::Integer) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
bfree(ptr);
@ -453,7 +453,7 @@ void gs::effect_parameter::get_default_int(int32_t& x)
{
if ((get_type() != type::Integer) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
bfree(ptr);
@ -474,7 +474,7 @@ void gs::effect_parameter::get_int2(int32_t& x, int32_t& y)
{
if ((get_type() != type::Integer2) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -488,7 +488,7 @@ void gs::effect_parameter::get_default_int2(int32_t& x, int32_t& y)
{
if ((get_type() != type::Integer2) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -510,7 +510,7 @@ void gs::effect_parameter::get_int3(int32_t& x, int32_t& y, int32_t& z)
{
if ((get_type() != type::Integer3) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -525,7 +525,7 @@ void gs::effect_parameter::get_default_int3(int32_t& x, int32_t& y, int32_t& z)
{
if ((get_type() != type::Integer3) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -548,7 +548,7 @@ void gs::effect_parameter::get_int4(int32_t& x, int32_t& y, int32_t& z, int32_t&
{
if ((get_type() != type::Integer4) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -564,7 +564,7 @@ void gs::effect_parameter::get_default_int4(int32_t& x, int32_t& y, int32_t& z,
{
if ((get_type() != type::Integer4) && (get_type() != type::Unknown))
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
x = *reinterpret_cast<int32_t*>(ptr);
y = *reinterpret_cast<int32_t*>(ptr + sizeof(int32_t));
@ -587,7 +587,7 @@ void gs::effect_parameter::get_matrix(matrix4& v)
{
if (get_type() != type::Matrix)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
v.x.x = *reinterpret_cast<float_t*>(ptr + sizeof(float_t) * 0);
v.x.y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t) * 1);
@ -618,7 +618,7 @@ void gs::effect_parameter::get_default_matrix(matrix4& v)
{
if (get_type() != type::Matrix)
throw std::bad_cast();
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
v.x.x = *reinterpret_cast<float_t*>(ptr + sizeof(float_t) * 0);
v.x.y = *reinterpret_cast<float_t*>(ptr + sizeof(float_t) * 1);
@ -684,10 +684,10 @@ void gs::effect_parameter::get_string(std::string& v)
{
if (get_type() != type::String)
throw std::bad_cast();
std::size_t ptr_len = gs_effect_get_val_size(get());
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_val(get()));
std::size_t ptr_len = gs_effect_get_val_size(get());
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_val(get()));
if (ptr) {
v = std::string(reinterpret_cast<std::int8_t*>(ptr), reinterpret_cast<std::int8_t*>(ptr) + ptr_len - 1);
v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1);
bfree(ptr);
} else {
v = "";
@ -698,10 +698,10 @@ void gs::effect_parameter::get_default_string(std::string& v)
{
if (get_type() != type::String)
throw std::bad_cast();
std::size_t ptr_len = gs_effect_get_default_val_size(get());
std::uint8_t* ptr = static_cast<std::uint8_t*>(gs_effect_get_default_val(get()));
std::size_t ptr_len = gs_effect_get_default_val_size(get());
uint8_t* ptr = static_cast<uint8_t*>(gs_effect_get_default_val(get()));
if (ptr) {
v = std::string(reinterpret_cast<std::int8_t*>(ptr), reinterpret_cast<std::int8_t*>(ptr) + ptr_len - 1);
v = std::string(reinterpret_cast<int8_t*>(ptr), reinterpret_cast<int8_t*>(ptr) + ptr_len - 1);
bfree(ptr);
} else {
v = "";

2
source/obs/gs/gs-indexbuffer.cpp
View file

@ -22,7 +22,7 @@
#include "gs-limits.hpp"
#include "obs/gs/gs-helper.hpp"
gs::index_buffer::index_buffer(std::uint32_t maximumVertices)
gs::index_buffer::index_buffer(uint32_t maximumVertices)
{
this->reserve(maximumVertices);
auto gctx = gs::context();

2
source/obs/gs/gs-indexbuffer.hpp
View file

@ -24,7 +24,7 @@
namespace gs {
class index_buffer : public std::vector<uint32_t> {
public:
index_buffer(std::uint32_t maximumVertices);
index_buffer(uint32_t maximumVertices);
index_buffer();
index_buffer(index_buffer& other);
index_buffer(std::vector<uint32_t>& other);

4
source/obs/gs/gs-limits.hpp
View file

@ -21,6 +21,6 @@
#include "common.hpp"
namespace gs {
static const std::uint32_t MAXIMUM_VERTICES = 0xFFFFFFu;
static const std::uint32_t MAXIMUM_UVW_LAYERS = 8u;
static const uint32_t MAXIMUM_VERTICES = 0xFFFFFFu;
static const uint32_t MAXIMUM_UVW_LAYERS = 8u;
} // namespace gs

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

@ -45,7 +45,7 @@ gs::mipmapper::~mipmapper()
gs::mipmapper::mipmapper()
{
_vb = std::make_unique<gs::vertex_buffer>(uint32_t(3u), std::uint8_t(1u));
_vb = std::make_unique<gs::vertex_buffer>(uint32_t(3u), uint8_t(1u));
{
auto vtx = _vb->at(0);
@ -211,7 +211,7 @@ void gs::mipmapper::rebuild(std::shared_ptr<gs::texture> source, std::shared_ptr
if (gs_get_device_type() == GS_DEVICE_DIRECT3D_11) {
ID3D11Texture2D* rtt =
reinterpret_cast<ID3D11Texture2D*>(gs_texture_get_obj(_rt->get_texture()->get_object()));
std::uint32_t level = uint32_t(D3D11CalcSubresource(UINT(mip), 0, UINT(max_mip_level)));
uint32_t level = uint32_t(D3D11CalcSubresource(UINT(mip), 0, UINT(max_mip_level)));
D3D11_BOX box = {0, 0, 0, cwidth, cheight, 1};
d3d_context->CopySubresourceRegion(d3d_target, level, 0, 0, 0, rtt, 0, &box);

4
source/obs/gs/gs-rendertarget.cpp
View file

@ -38,7 +38,7 @@ gs::rendertarget::rendertarget(gs_color_format colorFormat, gs_zstencil_format z
}
}
gs::rendertarget_op gs::rendertarget::render(std::uint32_t width, std::uint32_t height)
gs::rendertarget_op gs::rendertarget::render(uint32_t width, uint32_t height)
{
return {this, width, height};
}
@ -80,7 +80,7 @@ gs_zstencil_format gs::rendertarget::get_zstencil_format()
return _zstencil_format;
}
gs::rendertarget_op::rendertarget_op(gs::rendertarget* rt, std::uint32_t width, std::uint32_t height) : parent(rt)
gs::rendertarget_op::rendertarget_op(gs::rendertarget* rt, uint32_t width, uint32_t height) : parent(rt)
{
if (parent == nullptr)
throw std::invalid_argument("rt");

4
source/obs/gs/gs-rendertarget.hpp
View file

@ -53,7 +53,7 @@ namespace gs {
gs_zstencil_format get_zstencil_format();
gs::rendertarget_op render(std::uint32_t width, std::uint32_t height);
gs::rendertarget_op render(uint32_t width, uint32_t height);
};
class rendertarget_op {
@ -62,7 +62,7 @@ namespace gs {
public:
~rendertarget_op();
rendertarget_op(gs::rendertarget* rt, std::uint32_t width, std::uint32_t height);
rendertarget_op(gs::rendertarget* rt, uint32_t width, uint32_t height);
// Move Constructor
rendertarget_op(gs::rendertarget_op&&);

16
source/obs/gs/gs-sampler.cpp
View file

@ -77,36 +77,36 @@ gs_address_mode gs::sampler::get_address_mode_w()
return _sampler_info.address_w;
}
void gs::sampler::set_max_anisotropy(std::int32_t v)
void gs::sampler::set_max_anisotropy(int32_t v)
{
_dirty = true;
_sampler_info.max_anisotropy = v;
}
std::int32_t gs::sampler::get_max_anisotropy()
int32_t gs::sampler::get_max_anisotropy()
{
return _sampler_info.max_anisotropy;
}
void gs::sampler::set_border_color(std::uint32_t v)
void gs::sampler::set_border_color(uint32_t v)
{
_dirty = true;
_sampler_info.border_color = v;
}
void gs::sampler::set_border_color(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a)
void gs::sampler::set_border_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
{
_dirty = true;
_sampler_info.border_color = (static_cast<std::uint32_t>(a) << 24) | (static_cast<std::uint32_t>(r) << 16)
| (static_cast<std::uint32_t>(g) << 8) | static_cast<std::uint32_t>(b);
_sampler_info.border_color = (static_cast<uint32_t>(a) << 24) | (static_cast<uint32_t>(r) << 16)
| (static_cast<uint32_t>(g) << 8) | static_cast<uint32_t>(b);
}
std::uint32_t gs::sampler::get_border_color()
uint32_t gs::sampler::get_border_color()
{
return _sampler_info.border_color;
}
std::uint8_t gs::sampler::get_border_color(bool r, bool g, bool b, bool a)
uint8_t gs::sampler::get_border_color(bool r, bool g, bool b, bool a)
{
if (a)
return (_sampler_info.border_color >> 24) & 0xFF;

10
source/obs/gs/gs-sampler.hpp
View file

@ -38,13 +38,13 @@ namespace gs {
void set_address_mode_w(gs_address_mode v);
gs_address_mode get_address_mode_w();
void set_max_anisotropy(std::int32_t v);
void set_max_anisotropy(int32_t v);
int get_max_anisotropy();
void set_border_color(std::uint32_t v);
void set_border_color(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a);
std::uint32_t get_border_color();
std::uint8_t get_border_color(bool r, bool g, bool b, bool a);
void set_border_color(uint32_t v);
void set_border_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
uint32_t get_border_color();
uint8_t get_border_color(bool r, bool g, bool b, bool a);
gs_sampler_state* refresh();

24
source/obs/gs/gs-texture.cpp
View file

@ -23,9 +23,9 @@
#include <sys/stat.h>
#include "obs/gs/gs-helper.hpp"
static std::uint32_t decode_flags(gs::texture::flags texture_flags)
static uint32_t decode_flags(gs::texture::flags texture_flags)
{
std::uint32_t flags = 0;
uint32_t flags = 0;
if (exact(texture_flags, gs::texture::flags::Dynamic))
flags |= GS_DYNAMIC;
if (exact(texture_flags, gs::texture::flags::BuildMipMaps))
@ -33,8 +33,8 @@ static std::uint32_t decode_flags(gs::texture::flags texture_flags)
return flags;
}
gs::texture::texture(std::uint32_t width, std::uint32_t height, gs_color_format format, std::uint32_t mip_levels,
const std::uint8_t** mip_data, gs::texture::flags texture_flags)
gs::texture::texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels,
const uint8_t** mip_data, gs::texture::flags texture_flags)
{
if (width == 0)
throw std::logic_error("width must be at least 1");
@ -60,8 +60,8 @@ gs::texture::texture(std::uint32_t width, std::uint32_t height, gs_color_format
_type = type::Normal;
}
gs::texture::texture(std::uint32_t width, std::uint32_t height, std::uint32_t depth, gs_color_format format,
std::uint32_t mip_levels, const std::uint8_t** mip_data, gs::texture::flags texture_flags)
gs::texture::texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels,
const uint8_t** mip_data, gs::texture::flags texture_flags)
{
if (width == 0)
throw std::logic_error("width must be at least 1");
@ -92,8 +92,8 @@ gs::texture::texture(std::uint32_t width, std::uint32_t height, std::uint32_t de
_type = type::Volume;
}
gs::texture::texture(std::uint32_t size, gs_color_format format, std::uint32_t mip_levels,
const std::uint8_t** mip_data, gs::texture::flags texture_flags)
gs::texture::texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t** mip_data,
gs::texture::flags texture_flags)
{
if (size == 0)
throw std::logic_error("size must be at least 1");
@ -149,7 +149,7 @@ gs::texture::~texture()
_texture = nullptr;
}
void gs::texture::load(std::int32_t unit)
void gs::texture::load(int32_t unit)
{
auto gctx = gs::context();
gs_load_texture(_texture, unit);
@ -160,7 +160,7 @@ gs_texture_t* gs::texture::get_object()
return _texture;
}
std::uint32_t gs::texture::get_width()
uint32_t gs::texture::get_width()
{
switch (_type) {
case type::Normal:
@ -173,7 +173,7 @@ std::uint32_t gs::texture::get_width()
return 0;
}
std::uint32_t gs::texture::get_height()
uint32_t gs::texture::get_height()
{
switch (_type) {
case type::Normal:
@ -186,7 +186,7 @@ std::uint32_t gs::texture::get_height()
return 0;
}
std::uint32_t gs::texture::get_depth()
uint32_t gs::texture::get_depth()
{
switch (_type) {
case type::Normal:

22
source/obs/gs/gs-texture.hpp
View file

@ -23,9 +23,9 @@
namespace gs {
class texture {
public:
enum class type : std::uint8_t { Normal, Volume, Cube };
enum class type : uint8_t { Normal, Volume, Cube };
enum class flags : std::uint8_t {
enum class flags : uint8_t {
None,
Dynamic,
BuildMipMaps,
@ -49,8 +49,8 @@ namespace gs {
* \param mip_data Texture data including mipmaps
* \param texture_flags Texture Flags
*/
texture(std::uint32_t width, std::uint32_t height, gs_color_format format, std::uint32_t mip_levels,
const std::uint8_t** mip_data, gs::texture::flags texture_flags);
texture(uint32_t width, uint32_t height, gs_color_format format, uint32_t mip_levels, const uint8_t** mip_data,
gs::texture::flags texture_flags);
/*!
* \brief Create a 3D Texture
@ -63,8 +63,8 @@ namespace gs {
* \param mip_data Texture data including mipmaps
* \param texture_flags Texture Flags
*/
texture(std::uint32_t width, std::uint32_t height, std::uint32_t depth, gs_color_format format,
std::uint32_t mip_levels, const std::uint8_t** mip_data, gs::texture::flags texture_flags);
texture(uint32_t width, uint32_t height, uint32_t depth, gs_color_format format, uint32_t mip_levels,
const uint8_t** mip_data, gs::texture::flags texture_flags);
/*!
* \brief Create a Cube Texture
@ -75,7 +75,7 @@ namespace gs {
* \param mip_data Texture data including mipmaps
* \param texture_flags Texture Flags
*/
texture(std::uint32_t size, gs_color_format format, std::uint32_t mip_levels, const std::uint8_t** mip_data,
texture(uint32_t size, gs_color_format format, uint32_t mip_levels, const uint8_t** mip_data,
gs::texture::flags texture_flags);
/*!
@ -95,15 +95,15 @@ namespace gs {
*/
texture(gs_texture_t* tex, bool takeOwnership = false) : _texture(tex), _is_owner(takeOwnership) {}
void load(std::int32_t unit);
void load(int32_t unit);
gs_texture_t* get_object();
std::uint32_t get_width();
uint32_t get_width();
std::uint32_t get_height();
uint32_t get_height();
std::uint32_t get_depth();
uint32_t get_depth();
gs::texture::type get_type();

6
source/obs/obs-encoder-factory.hpp
View file

@ -173,9 +173,9 @@ namespace obs {
try {
auto priv = reinterpret_cast<instance_t*>(data);
if (priv) {
std::uint64_t version = static_cast<std::uint64_t>(obs_data_get_int(settings, S_VERSION));
uint64_t version = static_cast<uint64_t>(obs_data_get_int(settings, S_VERSION));
priv->migrate(settings, version);
obs_data_set_int(settings, S_VERSION, static_cast<std::int64_t>(STREAMFX_VERSION));
obs_data_set_int(settings, S_VERSION, static_cast<int64_t>(STREAMFX_VERSION));
obs_data_set_string(settings, S_COMMIT, STREAMFX_COMMIT);
return priv->update(settings);
}
@ -303,7 +303,7 @@ namespace obs {
encoder_instance(obs_data_t* settings, obs_encoder_t* self, bool is_hw) : _self(self) {}
virtual ~encoder_instance(){};
virtual void migrate(obs_data_t* settings, std::uint64_t version) {}
virtual void migrate(obs_data_t* settings, uint64_t version) {}
virtual bool update(obs_data_t* settings)
{

31
source/obs/obs-source-factory.hpp
View file

@ -241,7 +241,7 @@ namespace obs {
DLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
}
static std::uint32_t _get_width(void* data) noexcept
static uint32_t _get_width(void* data) noexcept
try {
if (data)
return reinterpret_cast<_instance*>(data)->get_width();
@ -254,7 +254,7 @@ namespace obs {
return 0;
}
static std::uint32_t _get_height(void* data) noexcept
static uint32_t _get_height(void* data) noexcept
try {
if (data)
return reinterpret_cast<_instance*>(data)->get_height();
@ -367,9 +367,9 @@ namespace obs {
try {
auto priv = reinterpret_cast<_instance*>(data);
if (priv) {
std::uint64_t version = static_cast<std::uint64_t>(obs_data_get_int(settings, S_VERSION));
uint64_t version = static_cast<uint64_t>(obs_data_get_int(settings, S_VERSION));
priv->migrate(settings, version);
obs_data_set_int(settings, S_VERSION, static_cast<std::int64_t>(STREAMFX_VERSION));
obs_data_set_int(settings, S_VERSION, static_cast<int64_t>(STREAMFX_VERSION));
obs_data_set_string(settings, S_COMMIT, STREAMFX_COMMIT);
priv->load(settings);
}
@ -393,7 +393,7 @@ namespace obs {
try {
if (data) {
reinterpret_cast<_instance*>(data)->save(settings);
obs_data_set_int(settings, S_VERSION, static_cast<std::int64_t>(STREAMFX_VERSION));
obs_data_set_int(settings, S_VERSION, static_cast<int64_t>(STREAMFX_VERSION));
obs_data_set_string(settings, S_COMMIT, STREAMFX_COMMIT);
}
} catch (const std::exception& ex) {
@ -403,7 +403,7 @@ namespace obs {
}
static void _mouse_click(void* data, const struct obs_mouse_event* event, int32_t type, bool mouse_up,
std::uint32_t click_count) noexcept
uint32_t click_count) noexcept
try {
if (data)
reinterpret_cast<_instance*>(data)->mouse_click(event, type, mouse_up, click_count);
@ -464,7 +464,7 @@ namespace obs {
}
static bool _audio_render(void* data, uint64_t* ts_out, struct obs_source_audio_mix* audio_output,
std::uint32_t mixers, std::size_t channels, std::size_t sample_rate) noexcept
uint32_t mixers, std::size_t channels, std::size_t sample_rate) noexcept
try {
if (data)
return reinterpret_cast<_instance*>(data)->audio_render(ts_out, audio_output, mixers, channels,
@ -549,12 +549,12 @@ namespace obs {
source_instance(obs_data_t* settings, obs_source_t* source) : _self(source) {}
virtual ~source_instance(){};
virtual std::uint32_t get_width()
virtual uint32_t get_width()
{
return 0;
}
virtual std::uint32_t get_height()
virtual uint32_t get_height()
{
return 0;
}
@ -585,19 +585,18 @@ namespace obs {
virtual void load(obs_data_t* settings) {}
virtual void migrate(obs_data_t* settings, std::uint64_t version) {}
virtual void migrate(obs_data_t* settings, uint64_t version) {}
virtual void update(obs_data_t* settings) {}
virtual void save(obs_data_t* settings) {}
virtual void mouse_click(const struct obs_mouse_event* event, std::int32_t type, bool mouse_up,
std::uint32_t click_count)
virtual void mouse_click(const struct obs_mouse_event* event, int32_t type, bool mouse_up, uint32_t click_count)
{}
virtual void mouse_move(const struct obs_mouse_event* event, bool mouse_leave) {}
virtual void mouse_wheel(const struct obs_mouse_event* event, std::int32_t x_delta, std::int32_t y_delta) {}
virtual void mouse_wheel(const struct obs_mouse_event* event, int32_t x_delta, int32_t y_delta) {}
virtual void focus(bool focus) {}
@ -605,8 +604,8 @@ namespace obs {
virtual void filter_remove(obs_source_t* source) {}
virtual bool audio_render(std::uint64_t* ts_out, struct obs_source_audio_mix* audio_output,
std::uint32_t mixers, std::size_t channels, std::size_t sample_rate)
virtual bool audio_render(uint64_t* ts_out, struct obs_source_audio_mix* audio_output, uint32_t mixers,
std::size_t channels, std::size_t sample_rate)
{
return false;
}
@ -617,7 +616,7 @@ namespace obs {
virtual void transition_stop() {}
virtual bool audio_mix(std::uint64_t* ts_out, struct audio_output_data* audio_output, std::size_t channels,
virtual bool audio_mix(uint64_t* ts_out, struct audio_output_data* audio_output, std::size_t channels,
std::size_t sample_rate)
{
return false;

4
source/obs/obs-source-tracker.cpp
View file

@ -190,13 +190,13 @@ bool obs::source_tracker::filter_sources(std::string, obs_source_t* source)
bool obs::source_tracker::filter_audio_sources(std::string, obs_source_t* source)
{
std::uint32_t flags = obs_source_get_output_flags(source);
uint32_t flags = obs_source_get_output_flags(source);
return !(flags & OBS_SOURCE_AUDIO) || (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT);
}
bool obs::source_tracker::filter_video_sources(std::string, obs_source_t* source)
{
std::uint32_t flags = obs_source_get_output_flags(source);
uint32_t flags = obs_source_get_output_flags(source);
return !(flags & OBS_SOURCE_VIDEO) || (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT);
}

4
source/obs/obs-source.cpp
View file

@ -798,7 +798,7 @@ void* obs::deprecated_source::type_data()
return obs_source_get_type_data(_self);
}
std::uint32_t obs::deprecated_source::width()
uint32_t obs::deprecated_source::width()
{
if (!_self) {
return 0;
@ -806,7 +806,7 @@ std::uint32_t obs::deprecated_source::width()
return obs_source_get_width(_self);
}
std::uint32_t obs::deprecated_source::height()
uint32_t obs::deprecated_source::height()
{
if (!_self) {
return 0;

4
source/obs/obs-source.hpp
View file

@ -76,8 +76,8 @@ namespace obs {
void* type_data();
std::uint32_t width();
std::uint32_t height();
uint32_t width();
uint32_t height();
bool destroyed();

2
source/obs/obs-tools.cpp
View file

@ -105,7 +105,7 @@ struct _hack_obs_property {
struct _hack_obs_properties {
void* param;
void (*destroy)(void* param);
std::uint32_t flags;
uint32_t flags;
struct _hack_obs_property* first_property;
struct _hack_obs_property** last;

6
source/sources/source-mirror.cpp
View file

@ -81,12 +81,12 @@ mirror_instance::~mirror_instance()
release();
}
std::uint32_t mirror_instance::get_width()
uint32_t mirror_instance::get_width()
{
return _source_size.first;
}
std::uint32_t mirror_instance::get_height()
uint32_t mirror_instance::get_height()
{
return _source_size.second;
}
@ -96,7 +96,7 @@ void mirror_instance::load(obs_data_t* data)
update(data);
}
void mirror_instance::migrate(obs_data_t* data, std::uint64_t version)
void mirror_instance::migrate(obs_data_t* data, uint64_t version)
{
switch (version) {
case 0:

10
source/sources/source-mirror.hpp
View file

@ -36,8 +36,8 @@ namespace streamfx::source::mirror {
struct mirror_audio_data {
mirror_audio_data(const audio_data*, speaker_layout);
obs_source_audio osa;
std::vector<std::vector<std::uint8_t>> data;
obs_source_audio osa;
std::vector<std::vector<uint8_t>> data;
};
class mirror_instance : public obs::source_instance {
@ -58,11 +58,11 @@ namespace streamfx::source::mirror {
mirror_instance(obs_data_t* settings, obs_source_t* self);
virtual ~mirror_instance();
virtual std::uint32_t get_width() override;
virtual std::uint32_t get_height() override;
virtual uint32_t get_width() override;
virtual uint32_t get_height() override;
virtual void load(obs_data_t*) override;
virtual void migrate(obs_data_t*, std::uint64_t) override;
virtual void migrate(obs_data_t*, uint64_t) override;
virtual void update(obs_data_t*) override;
virtual void save(obs_data_t*) override;

4
source/sources/source-shader.cpp
View file

@ -35,12 +35,12 @@ shader_instance::shader_instance(obs_data_t* data, obs_source_t* self) : obs::so
shader_instance::~shader_instance() {}
std::uint32_t shader_instance::get_width()
uint32_t shader_instance::get_width()
{
return _fx->width();
}
std::uint32_t shader_instance::get_height()
uint32_t shader_instance::get_height()
{
return _fx->height();
}

4
source/sources/source-shader.hpp
View file

@ -32,8 +32,8 @@ namespace streamfx::source::shader {
shader_instance(obs_data_t* data, obs_source_t* self);
virtual ~shader_instance();
virtual std::uint32_t get_width() override;
virtual std::uint32_t get_height() override;
virtual uint32_t get_width() override;
virtual uint32_t get_height() override;
void properties(obs_properties_t* props);

16
source/transitions/transition-shader.cpp
View file

@ -35,12 +35,12 @@ shader_instance::shader_instance(obs_data_t* data, obs_source_t* self) : obs::so
shader_instance::~shader_instance() {}
std::uint32_t shader_instance::get_width()
uint32_t shader_instance::get_width()
{
return _fx->width();
}
std::uint32_t shader_instance::get_height()
uint32_t shader_instance::get_height()
{
return _fx->height();
}
@ -84,13 +84,13 @@ void shader_instance::video_render(gs_effect_t* effect)
gs::debug_marker gdmp{gs::debug_color_source, "Shader Transition '%s'", obs_source_get_name(_self)};
#endif
obs_transition_video_render(
_self, [](void* data, gs_texture_t* a, gs_texture_t* b, float t, std::uint32_t cx, std::uint32_t cy) {
reinterpret_cast<shader_instance*>(data)->transition_render(a, b, t, cx, cy);
});
obs_transition_video_render(_self,
[](void* data, gs_texture_t* a, gs_texture_t* b, float t, uint32_t cx, uint32_t cy) {
reinterpret_cast<shader_instance*>(data)->transition_render(a, b, t, cx, cy);
});
}
void shader_instance::transition_render(gs_texture_t* a, gs_texture_t* b, float_t t, std::uint32_t cx, std::uint32_t cy)
void shader_instance::transition_render(gs_texture_t* a, gs_texture_t* b, float_t t, uint32_t cx, uint32_t cy)
{
_fx->set_input_a(std::make_shared<::gs::texture>(a, false));
_fx->set_input_b(std::make_shared<::gs::texture>(b, false));
@ -100,7 +100,7 @@ void shader_instance::transition_render(gs_texture_t* a, gs_texture_t* b, float_
_fx->render();
}
bool shader_instance::audio_render(uint64_t* ts_out, obs_source_audio_mix* audio_output, std::uint32_t mixers,
bool shader_instance::audio_render(uint64_t* ts_out, obs_source_audio_mix* audio_output, uint32_t mixers,
std::size_t channels, std::size_t sample_rate)
{
return obs_transition_audio_render(

8
source/transitions/transition-shader.hpp
View file

@ -32,8 +32,8 @@ namespace streamfx::transition::shader {
shader_instance(obs_data_t* data, obs_source_t* self);
virtual ~shader_instance();
virtual std::uint32_t get_width() override;
virtual std::uint32_t get_height() override;
virtual uint32_t get_width() override;
virtual uint32_t get_height() override;
void properties(obs_properties_t* props);
@ -43,9 +43,9 @@ namespace streamfx::transition::shader {
virtual void video_tick(float_t sec_since_last) override;
virtual void video_render(gs_effect_t* effect) override;
void transition_render(gs_texture_t* a, gs_texture_t* b, float_t t, std::uint32_t cx, std::uint32_t cy);
void transition_render(gs_texture_t* a, gs_texture_t* b, float_t t, uint32_t cx, uint32_t cy);
virtual bool audio_render(uint64_t* ts_out, struct obs_source_audio_mix* audio_output, std::uint32_t mixers,
virtual bool audio_render(uint64_t* ts_out, struct obs_source_audio_mix* audio_output, uint32_t mixers,
std::size_t channels, std::size_t sample_rate) override;
virtual void transition_start() override;

4
source/ui/ui-about.hpp
View file

@ -35,7 +35,7 @@ namespace streamfx::ui {
Q_OBJECT
public:
enum class role_type : std::int32_t {
enum class role_type : int32_t {
NONE,
SPACER,
THANKYOU,
@ -49,7 +49,7 @@ namespace streamfx::ui {
CREATOR,
};
enum class link_type : std::int32_t {
enum class link_type : int32_t {
NONE,
GENERIC,

2
source/util/util-profiler.hpp
View file

@ -53,7 +53,7 @@ namespace util {
void track(std::chrono::nanoseconds duration);
std::uint64_t count();
uint64_t count();
std::chrono::nanoseconds total_duration();

30
source/util/utility.hpp
View file

@ -98,17 +98,17 @@ namespace util {
obs_property_t* obs_properties_add_tristate(obs_properties_t* props, const char* name, const char* desc);
inline bool is_tristate_enabled(std::int64_t tristate)
inline bool is_tristate_enabled(int64_t tristate)
{
return tristate == 1;
}
inline bool is_tristate_disabled(std::int64_t tristate)
inline bool is_tristate_disabled(int64_t tristate)
{
return tristate == 0;
}
inline bool is_tristate_default(std::int64_t tristate)
inline bool is_tristate_default(int64_t tristate)
{
return tristate == -1;
}
@ -178,27 +178,27 @@ namespace util {
{ \
return is_power_of_two_loop(v); \
}
P_IS_POWER_OF_TWO_AS_LOOP(std::int8_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::uint8_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::int16_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::uint16_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::int32_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::uint32_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::int64_t)
P_IS_POWER_OF_TWO_AS_LOOP(std::uint64_t)
P_IS_POWER_OF_TWO_AS_LOOP(int8_t)
P_IS_POWER_OF_TWO_AS_LOOP(uint8_t)
P_IS_POWER_OF_TWO_AS_LOOP(int16_t)
P_IS_POWER_OF_TWO_AS_LOOP(uint16_t)
P_IS_POWER_OF_TWO_AS_LOOP(int32_t)
P_IS_POWER_OF_TWO_AS_LOOP(uint32_t)
P_IS_POWER_OF_TWO_AS_LOOP(int64_t)
P_IS_POWER_OF_TWO_AS_LOOP(uint64_t)
#undef P_IS_POWER_OF_TWO_AS_LOOP
#pragma pop_macro("P_IS_POWER_OF_TWO_AS_LOOP")
template<typename T>
inline std::uint64_t get_power_of_two_exponent_floor(T v)
inline uint64_t get_power_of_two_exponent_floor(T v)
{
return std::uint64_t(floor(log10(T(v)) / log10(2.0)));
return uint64_t(floor(log10(T(v)) / log10(2.0)));
}
template<typename T>
inline std::uint64_t get_power_of_two_exponent_ceil(T v)
inline uint64_t get_power_of_two_exponent_ceil(T v)
{
return std::uint64_t(ceil(log10(T(v)) / log10(2.0)));
return uint64_t(ceil(log10(T(v)) / log10(2.0)));
}
template<typename T, typename C>