jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/libobs/obs.hpp

394 lines
11 KiB
C++
Raw Normal View History

add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
/******************************************************************************
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
With the permission of my fellow contributors, I'm switching obs-studio back to GPL v2+ to prevent issues between this project and the original OBS project, and for personal reasons to avoid legal ambiguity (not political reasons, I admittedly would prefer GPL v3+)
2013-12-02 21:24:38 -08:00
the Free Software Foundation, either version 2 of the License, or
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
move libobs C++ bindings to libobs
2013-12-22 16:42:02 -08:00
/* Useful C++ classes and bindings for base obs data */
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
#pragma once
move libobs C++ bindings to libobs
2013-12-22 16:42:02 -08:00
#include "obs.h"
add a 'wrapper' file for wx
2013-11-22 19:57:24 -08:00
added initial config file stuff, set up a 'dummy' window to cause the graphics system to persist through window changes
2013-11-23 22:38:52 -08:00
/* RAII wrappers */
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
template<typename T, void release(T)> class OBSRefAutoRelease;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
template<typename T, void addref(T), void release(T)> class OBSRef;
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
template<typename T, T getref(T), void release(T)> class OBSSafeRef;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
using OBSObject =
OBSSafeRef<obs_object_t *, obs_object_get_ref, obs_object_release>;
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
using OBSSource =
OBSSafeRef<obs_source_t *, obs_source_get_ref, obs_source_release>;
using OBSScene =
OBSSafeRef<obs_scene_t *, obs_scene_get_ref, obs_scene_release>;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
using OBSSceneItem =
OBSRef<obs_sceneitem_t *, obs_sceneitem_addref, obs_sceneitem_release>;
using OBSData = OBSRef<obs_data_t *, obs_data_addref, obs_data_release>;
using OBSDataArray = OBSRef<obs_data_array_t *, obs_data_array_addref,
obs_data_array_release>;
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
using OBSOutput =
OBSSafeRef<obs_output_t *, obs_output_get_ref, obs_output_release>;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
using OBSEncoder =
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
OBSSafeRef<obs_encoder_t *, obs_encoder_get_ref, obs_encoder_release>;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
using OBSService =
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
OBSSafeRef<obs_service_t *, obs_service_get_ref, obs_service_release>;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
using OBSWeakObject = OBSRef<obs_weak_object_t *, obs_weak_object_addref,
obs_weak_object_release>;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
using OBSWeakSource = OBSRef<obs_weak_source_t *, obs_weak_source_addref,
obs_weak_source_release>;
using OBSWeakOutput = OBSRef<obs_weak_output_t *, obs_weak_output_addref,
obs_weak_output_release>;
using OBSWeakEncoder = OBSRef<obs_weak_encoder_t *, obs_weak_encoder_addref,
obs_weak_encoder_release>;
using OBSWeakService = OBSRef<obs_weak_service_t *, obs_weak_service_addref,
obs_weak_service_release>;
libobs: Add preprocessor directive for AutoRelease types Since these helpers come from obs-websocket, obs-websocket needs a way to disable its own helpers if OBS is new enough to include them already.
2021-12-17 15:50:00 -08:00
#define OBS_AUTORELEASE
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
using OBSObjectAutoRelease =
OBSRefAutoRelease<obs_object_t *, obs_object_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSSourceAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_source_t *, obs_source_release>;
using OBSSceneAutoRelease = OBSRefAutoRelease<obs_scene_t *, obs_scene_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSSceneItemAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_sceneitem_t *, obs_sceneitem_release>;
using OBSDataAutoRelease = OBSRefAutoRelease<obs_data_t *, obs_data_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSDataArrayAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_data_array_t *, obs_data_array_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSOutputAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_output_t *, obs_output_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSEncoderAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_encoder_t *, obs_encoder_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSServiceAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_service_t *, obs_service_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
using OBSWeakObjectAutoRelease =
OBSRefAutoRelease<obs_weak_object_t *, obs_weak_object_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSWeakSourceAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_weak_source_t *, obs_weak_source_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSWeakOutputAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_weak_output_t *, obs_weak_output_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSWeakEncoderAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_weak_encoder_t *, obs_weak_encoder_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
using OBSWeakServiceAutoRelease =
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
OBSRefAutoRelease<obs_weak_service_t *, obs_weak_service_release>;
libobs: Add AutoRelease OBSRef wrappers for OBS types These AutoRelease versions of the C++ OBSRef types do not add a ref on construction, which is useful when accepting the result of a function that turns a raw C pointer type that has had a reference added. Not having these types has resulted in multiple awkward anti-patterns. Such as immediately releasing after construction to account for the extra addref, or avoiding using the C++ type entirely and manually releasing it later. Example: ``` OBSSource source = obs_get_source_by_name(name.c_str()); obs_source_release(source); ``` The whole point of these types is to avoid the need for manual releases, and rely on the RAII mechanisms inside of C++. Additionally, the immediate release isn't commented anywhere, resulting in confusion for other developers looking at the code as to why things are being immediately released. The AutoRelease types and names are taken from obs-websocket.
2021-11-26 00:48:28 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
template<typename T, void release(T)> class OBSRefAutoRelease {
protected:
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
T val;
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
public:
inline OBSRefAutoRelease() : val(nullptr) {}
inline OBSRefAutoRelease(T val_) : val(val_) {}
OBSRefAutoRelease(const OBSRefAutoRelease &ref) = delete;
inline OBSRefAutoRelease(OBSRefAutoRelease &&ref) : val(ref.val)
Compact/clean up OBSRef class just a bit more Replace a NULL with nullptr and reduce code duplication with the = operators
2014-02-02 14:34:02 -08:00
{
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
ref.val = nullptr;
Compact/clean up OBSRef class just a bit more Replace a NULL with nullptr and reduce code duplication with the = operators
2014-02-02 14:34:02 -08:00
}
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
inline ~OBSRefAutoRelease() { release(val); }
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
inline operator T() const { return val; }
inline T Get() const { return val; }
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
inline bool operator==(T p) const { return val == p; }
inline bool operator!=(T p) const { return val != p; }
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
inline OBSRefAutoRelease &operator=(OBSRefAutoRelease &&ref)
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
{
if (this != &ref) {
Fix OBSRef move assignment not releasing the previous reference
2014-10-29 08:17:07 -07:00
release(val);
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
val = ref.val;
Compact/clean up OBSRef class just a bit more Replace a NULL with nullptr and reduce code duplication with the = operators
2014-02-02 14:34:02 -08:00
ref.val = nullptr;
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
}
return *this;
}
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
inline OBSRefAutoRelease &operator=(T new_val)
{
release(val);
val = new_val;
return *this;
}
};
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
template<typename T, void addref(T), void release(T)>
class OBSRef : public OBSRefAutoRelease<T, release> {
inline OBSRef &Replace(T valIn)
{
addref(valIn);
libobs: Fix template errors on non-MS compilers Because apparently Microsoft's compilers are bad at following language specs.
2021-12-30 22:01:30 -08:00
release(this->val);
this->val = valIn;
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
return *this;
}
struct TakeOwnership {
};
libobs: Fix template errors on non-MS compilers Because apparently Microsoft's compilers are bad at following language specs.
2021-12-30 22:01:30 -08:00
inline OBSRef(T val_, TakeOwnership)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(val_)
{
}
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
public:
libobs: Fix template errors on non-MS compilers Because apparently Microsoft's compilers are bad at following language specs.
2021-12-30 22:01:30 -08:00
inline OBSRef()
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(nullptr)
{
}
inline OBSRef(const OBSRef &ref)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(ref.val)
{
addref(this->val);
}
inline OBSRef(T val_)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(val_)
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
{
libobs: Fix template errors on non-MS compilers Because apparently Microsoft's compilers are bad at following language specs.
2021-12-30 22:01:30 -08:00
addref(this->val);
libobs, UI: Fix cpp auto-release assignment from OBSRefs The *AutoRelease helpers should not take references from OBSRef objects. Instead, make an OBSRefAutoRelease base class, and OBSRef a subclass of that to allow moves, and then perform moves from those objects. This fixes an issue where *AutoRelease OBSRef objects would cause an unintended double release of objects after having been assigned values from non-*AutoRelease OBSRef objects.
2021-12-30 21:10:50 -08:00
}
inline OBSRef &operator=(const OBSRef &ref) { return Replace(ref.val); }
inline OBSRef &operator=(T valIn) { return Replace(valIn); }
libobs: Add weak reference type for obs_source
2015-05-03 11:45:41 -07:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
friend OBSWeakObject OBSGetWeakRef(obs_object_t *object);
libobs: Add weak reference type for obs_source
2015-05-03 11:45:41 -07:00
friend OBSWeakSource OBSGetWeakRef(obs_source_t *source);
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07:00
friend OBSWeakOutput OBSGetWeakRef(obs_output_t *output);
(API Change) libobs: Make obs_encoder refcounted
2015-05-03 17:01:38 -07:00
friend OBSWeakEncoder OBSGetWeakRef(obs_encoder_t *encoder);
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
friend OBSWeakService OBSGetWeakRef(obs_service_t *service);
};
template<typename T, T getref(T), void release(T)>
class OBSSafeRef : public OBSRefAutoRelease<T, release> {
inline OBSSafeRef &Replace(T valIn)
{
T newVal = getref(valIn);
release(this->val);
this->val = newVal;
return *this;
}
struct TakeOwnership {
};
inline OBSSafeRef(T val_, TakeOwnership)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(val_)
{
}
(API Change) libobs: Make obs_service refcounted
2015-05-03 17:07:43 -07:00
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
public:
inline OBSSafeRef()
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(nullptr)
{
}
inline OBSSafeRef(const OBSSafeRef &ref)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(ref.val)
{
this->val = getref(ref.val);
}
inline OBSSafeRef(T val_)
: OBSRefAutoRelease<T, release>::OBSRefAutoRelease(val_)
{
this->val = getref(this->val);
}
inline OBSSafeRef &operator=(const OBSSafeRef &ref)
{
return Replace(ref.val);
}
inline OBSSafeRef &operator=(T valIn) { return Replace(valIn); }
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
friend OBSObject OBSGetStrongRef(obs_weak_object_t *weak);
libobs: Use get_ref calls for obs.hpp helper classes
2022-01-24 11:59:17 -08:00
friend OBSSource OBSGetStrongRef(obs_weak_source_t *weak);
friend OBSOutput OBSGetStrongRef(obs_weak_output_t *weak);
friend OBSEncoder OBSGetStrongRef(obs_weak_encoder_t *weak);
(API Change) libobs: Make obs_service refcounted
2015-05-03 17:07:43 -07:00
friend OBSService OBSGetStrongRef(obs_weak_service_t *weak);
add RAII wrapper class for sources
2013-11-22 15:20:02 -08:00
};
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
libobs: Add obs_object abstraction and functions With this, you can now cast normal obs objects (services, outputs, sources, encoders) to an obs_object_t, and then use obs_object_* functions to get references, release references, and similar for weak object references as well. This allows the ability for the frontend to use an object of any of those types interchangeably in certain situations without having to handle each specific type individually. This is useful because the properties view in particular doesn't care what type of object it uses, it just needs to be able to hold weak references to abstract OBS objects.
2022-02-02 21:56:30 -08:00
inline OBSObject OBSGetStrongRef(obs_weak_object_t *weak)
{
return {obs_weak_object_get_object(weak), OBSObject::TakeOwnership()};
}
inline OBSWeakObject OBSGetWeakRef(obs_object_t *object)
{
return {obs_object_get_weak_object(object),
OBSWeakObject::TakeOwnership()};
}
libobs: Add weak reference type for obs_source
2015-05-03 11:45:41 -07:00
inline OBSSource OBSGetStrongRef(obs_weak_source_t *weak)
{
return {obs_weak_source_get_source(weak), OBSSource::TakeOwnership()};
}
inline OBSWeakSource OBSGetWeakRef(obs_source_t *source)
{
return {obs_source_get_weak_source(source),
OBSWeakSource::TakeOwnership()};
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07:00
inline OBSOutput OBSGetStrongRef(obs_weak_output_t *weak)
{
return {obs_weak_output_get_output(weak), OBSOutput::TakeOwnership()};
}
inline OBSWeakOutput OBSGetWeakRef(obs_output_t *output)
{
return {obs_output_get_weak_output(output),
OBSWeakOutput::TakeOwnership()};
}
(API Change) libobs: Make obs_encoder refcounted
2015-05-03 17:01:38 -07:00
inline OBSEncoder OBSGetStrongRef(obs_weak_encoder_t *weak)
{
return {obs_weak_encoder_get_encoder(weak),
OBSEncoder::TakeOwnership()};
}
inline OBSWeakEncoder OBSGetWeakRef(obs_encoder_t *encoder)
{
return {obs_encoder_get_weak_encoder(encoder),
OBSWeakEncoder::TakeOwnership()};
}
(API Change) libobs: Make obs_service refcounted
2015-05-03 17:07:43 -07:00
inline OBSService OBSGetStrongRef(obs_weak_service_t *weak)
{
return {obs_weak_service_get_service(weak),
OBSService::TakeOwnership()};
}
inline OBSWeakService OBSGetWeakRef(obs_service_t *service)
{
return {obs_service_get_weak_service(service),
OBSWeakService::TakeOwnership()};
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
/* objects that are not meant to be instanced */
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
template<typename T, void destroy(T)> class OBSPtr {
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
T obj;
public:
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
inline OBSPtr() : obj(nullptr) {}
inline OBSPtr(T obj_) : obj(obj_) {}
inline OBSPtr(const OBSPtr &) = delete;
inline OBSPtr(OBSPtr &&other) : obj(other.obj) { other.obj = nullptr; }
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
inline ~OBSPtr() { destroy(obj); }
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
inline OBSPtr &operator=(T obj_)
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
{
if (obj_ != obj)
destroy(obj);
obj = obj_;
return *this;
}
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
inline OBSPtr &operator=(const OBSPtr &) = delete;
inline OBSPtr &operator=(OBSPtr &&other)
Add missing copy/move operations for OBSObj
2014-10-29 06:37:53 -07:00
{
if (obj)
destroy(obj);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obj = other.obj;
Add missing copy/move operations for OBSObj
2014-10-29 06:37:53 -07:00
other.obj = nullptr;
return *this;
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
inline operator T() const { return obj; }
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
inline bool operator==(T p) const { return obj == p; }
inline bool operator!=(T p) const { return obj != p; }
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
};
libobs: Rename OBSObj to OBSPtr Makes it a bit more explicit that it's just a pointer RAII, and because an OBSObject will be added
2022-02-02 21:54:39 -08:00
using OBSDisplay = OBSPtr<obs_display_t *, obs_display_destroy>;
using OBSView = OBSPtr<obs_view_t *, obs_view_destroy>;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
/* signal handler connection */
class OBSSignal {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
signal_handler_t *handler;
const char *signal;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
signal_callback_t callback;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
void *param;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
public:
inline OBSSignal()
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
: handler(nullptr),
signal(nullptr),
callback(nullptr),
param(nullptr)
{
}
inline OBSSignal(signal_handler_t *handler_, const char *signal_,
signal_callback_t callback_, void *param_)
: handler(handler_),
signal(signal_),
callback(callback_),
param(param_)
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
{
libobs/callback: Add signal reference counting Adds a simple signal reference counting function (signal_handler_connect_ref) that makes it so that signals keep the handler around until the all the signal itself is disconnected. This prevents potential crashes where a signal might try to disconnect after a handler has already been destroyed (typically in C++ with OBSSignalHandler helper objects, where destruction isn't guaranteed to be predictable). This also modifies OBSSignalHandler to use the reference-counting connections.
2018-03-09 19:31:30 -08:00
signal_handler_connect_ref(handler, signal, callback, param);
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
}
inline void Disconnect()
{
signal_handler_disconnect(handler, signal, callback, param);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
handler = nullptr;
signal = nullptr;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
callback = nullptr;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
param = nullptr;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
inline ~OBSSignal() { Disconnect(); }
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
inline void Connect(signal_handler_t *handler_, const char *signal_,
signal_callback_t callback_, void *param_)
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
{
Disconnect();
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
handler = handler_;
signal = signal_;
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
callback = callback_;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
param = param_;
libobs/callback: Add signal reference counting Adds a simple signal reference counting function (signal_handler_connect_ref) that makes it so that signals keep the handler around until the all the signal itself is disconnected. This prevents potential crashes where a signal might try to disconnect after a handler has already been destroyed (typically in C++ with OBSSignalHandler helper objects, where destruction isn't guaranteed to be predictable). This also modifies OBSSignalHandler to use the reference-counting connections.
2018-03-09 19:31:30 -08:00
signal_handler_connect_ref(handler, signal, callback, param);
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
}
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
OBSSignal(const OBSSignal &) = delete;
libobs: Handle noexcept warnings VC++ wants noexcept for move assignment operators, and move contructors.
2020-03-19 11:20:44 -07:00
OBSSignal(OBSSignal &&other) noexcept
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
: handler(other.handler),
signal(other.signal),
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
callback(other.callback),
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
param(other.param)
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
other.handler = nullptr;
other.signal = nullptr;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
other.callback = nullptr;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
other.param = nullptr;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
}
OBSSignal &operator=(const OBSSignal &) = delete;
libobs: Handle noexcept warnings VC++ wants noexcept for move assignment operators, and move contructors.
2020-03-19 11:20:44 -07:00
OBSSignal &operator=(OBSSignal &&other) noexcept
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
{
Disconnect();
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
handler = other.handler;
signal = other.signal;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
callback = other.callback;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
param = other.param;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
other.handler = nullptr;
other.signal = nullptr;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
other.callback = nullptr;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
other.param = nullptr;
Add missing copy/move operations for OBSSignal
2014-10-28 15:49:20 -07:00
return *this;
}
Add source properties window (very preliminary) - Add a properties window for sources so that you can now actually edit the settings for sources. Also, display the source by itself in the window (Note: not working on mac, and possibly not working on linux). When changing the settings for a source, it will call obs_source_update on that source when you have modified any values automatically. - Add a properties 'widget', eventually I want to turn this in to a regular nice properties view like you'd see in the designer, but right now it just uses a form layout in a QScrollArea with regular controls to display the properties. It's clunky but works for the time being. - Make it so that swap chains and the main graphics subsystem will automatically use at least one backbuffer if none was specified - Fix bug where displays weren't added to the main display array - Make it so that you can get the properties of a source via the actual pointer of a source/encoder/output in addition to being able to look up properties via identifier. - When registering source types, check for required functions (wasn't doing it before). getheight/getwidth should not be optional if it's a video source as well. - Add an RAII OBSObj wrapper to obs.hpp for non-reference-counted libobs pointers - Add an RAII OBSSignal wrapper to obs.hpp for libobs signals to automatically disconnect them on destruction - Move the "scale and center" calculation in window-basic-main.cpp to its own function and in its own source file - Add an 'update' callback to WASAPI audio sources
2014-03-23 01:07:54 -07:00
};