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

3104 lines
79 KiB
C
Raw Normal View History

first commit
2013-09-30 19:37:13 -07:00
/******************************************************************************
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
Copyright (C) 2013-2014 by Hugh Bailey <obs.jim@gmail.com>
first commit
2013-09-30 19:37:13 -07:00
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
first commit
2013-09-30 19:37:13 -07: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/>.
******************************************************************************/
Output total frames and percentage skipped
2014-07-27 09:25:55 -07:00
#include <inttypes.h>
(API Change) Add colorspace info to obs_video_info This was an important change because we were originally using an hard-coded 709/partial range color matrix for the output, which was causing problems for people wanting to use different formats or color spaces. This will now automatically generate the color matrix depending on the format, color space, and range, or use an identity matrix if the video format is RGB instead of YUV.
2014-12-11 19:51:30 -08:00
#include "graphics/matrix4.h"
make sure to include function declarations from calldata.h
2013-12-30 09:09:20 -08:00
#include "callback/calldata.h"
first commit
2013-09-30 19:37:13 -07:00
#include "obs.h"
Rename obs-data.h to obs-internal.h Renaming obs-data.h to avoid confusion about its usage
2014-01-26 17:48:14 -08:00
#include "obs-internal.h"
first commit
2013-09-30 19:37:13 -07:00
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core *obs = NULL;
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
static THREAD_LOCAL bool is_ui_thread = false;
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
extern void add_default_module_paths(void);
adjust file locations to be more portable
2013-11-01 14:33:00 -07:00
extern char *find_libobs_data_file(const char *file);
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
static inline void make_video_info(struct video_output_info *vi,
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
struct obs_video_info *ovi)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08: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
vi->name = "video";
vi->format = ovi->output_format;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
vi->fps_num = ovi->fps_num;
vi->fps_den = ovi->fps_den;
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
vi->width = ovi->output_width;
vi->height = ovi->output_height;
vi->range = ovi->range;
(API Change) Add colorspace info to obs_video_info This was an important change because we were originally using an hard-coded 709/partial range color matrix for the output, which was causing problems for people wanting to use different formats or color spaces. This will now automatically generate the color matrix depending on the format, color space, and range, or use an identity matrix if the video format is RGB instead of YUV.
2014-12-11 19:51:30 -08:00
vi->colorspace = ovi->colorspace;
libobs: Redesign/optimize frame encoding handling Previously, the design for the interaction between the encoder thread and the graphics thread was that the encoder thread would signal to the graphics thread when to start drawing each frame. The original idea behind this was to prevent mutually cascading stalls of encoding or graphics rendering (i.e., if rendering took too long, then encoding would have to catch up, then rendering would have to catch up again, and so on, cascading upon each other). The ultimate goal was to prevent encoding from impacting graphics and vise versa. However, eventually it was realized that there were some fundamental flaws with this design. 1. Stray frame duplication. You could not guarantee that a frame would render on time, so sometimes frames would unintentionally be lost if there was any sort of minor hiccup or if the thread took too long to be scheduled I'm guessing. 2. Frame timing in the rendering thread was less accurate. The only place where frame timing was accurate was in the encoder thread, and the graphics thread was at the whim of thread scheduling. On higher end computers it was typically fine, but it was just generally not guaranteed that a frame would be rendered when it was supposed to be rendered. So the solution (originally proposed by r1ch and paibox) is to instead keep the encoding and graphics threads separate as usual, but instead of the encoder thread controlling the graphics thread, the graphics thread now controls the encoder thread. The encoder thread keeps a limited cache of frames, then the graphics thread copies frames in to the cache and increments a semaphore to schedule the encoder thread to encode that data. In the cache, each frame has an encode counter. If the frame cache is full (e.g., the encoder taking too long to return frames), it will not cache a new frame, but instead will just increment the counter on the last frame in the cache to schedule that frame to encode again, ensuring that frames are on time and reducing CPU usage by lowering video complexity. If the graphics thread takes too long to render a frame, then it will add that frame with the count value set to the total amount of frames that were missed (actual legitimately duplicated frames). Because the cache gives many frames of breathing room for the encoder to encode frames, this design helps improve results especially when using encoding presets that have higher complexity and CPU usage, minimizing the risk of needlessly skipped or duplicated frames. I also managed to sneak in what should be a bit of an optimization to reduce copying of frame data, though how much of an optimization it ultimately ends up being is debatable. So to sum it up, this commit increases accuracy of frame timing, completely removes stray frame duplication, gives better results for higher complexity encoding presets, and potentially optimizes the frame pipeline a tiny bit.
2014-12-31 01:53:13 -08:00
vi->cache_size = 6;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static inline void calc_gpu_conversion_sizes(struct obs_core_video_mix *video)
Add planar YUV 4:4:4 format support Adds the ability to natively output with planar YUV 4:4:4.
2015-04-16 22:52:44 -07:00
{
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
const struct video_output_info *info =
video_output_get_info(video->video);
Add planar YUV 4:4:4 format support Adds the ability to natively output with planar YUV 4:4:4.
2015-04-16 22:52:44 -07:00
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->conversion_needed = false;
video->conversion_techs[0] = NULL;
video->conversion_techs[1] = NULL;
video->conversion_techs[2] = NULL;
video->conversion_width_i = 0.f;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
video->conversion_height_i = 0.f;
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
switch ((uint32_t)info->format) {
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
case VIDEO_FORMAT_I420:
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->conversion_needed = true;
video->conversion_techs[0] = "Planar_Y";
video->conversion_techs[1] = "Planar_U_Left";
video->conversion_techs[2] = "Planar_V_Left";
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video->conversion_width_i = 1.f / (float)info->width;
Add NV12 conversion shader
2014-04-04 11:49:23 -07:00
break;
case VIDEO_FORMAT_NV12:
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->conversion_needed = true;
video->conversion_techs[0] = "NV12_Y";
video->conversion_techs[1] = "NV12_UV";
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video->conversion_width_i = 1.f / (float)info->width;
Add NV12 conversion shader
2014-04-04 11:49:23 -07:00
break;
Add planar YUV 4:4:4 format support Adds the ability to natively output with planar YUV 4:4:4.
2015-04-16 22:52:44 -07:00
case VIDEO_FORMAT_I444:
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->conversion_needed = true;
video->conversion_techs[0] = "Planar_Y";
video->conversion_techs[1] = "Planar_U";
video->conversion_techs[2] = "Planar_V";
Add planar YUV 4:4:4 format support Adds the ability to natively output with planar YUV 4:4:4.
2015-04-16 22:52:44 -07:00
break;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
case VIDEO_FORMAT_I010:
video->conversion_needed = true;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video->conversion_width_i = 1.f / (float)info->width;
video->conversion_height_i = 1.f / (float)info->height;
if (info->colorspace == VIDEO_CS_2100_PQ) {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
video->conversion_techs[0] = "I010_PQ_Y";
video->conversion_techs[1] = "I010_PQ_U";
video->conversion_techs[2] = "I010_PQ_V";
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
} else if (info->colorspace == VIDEO_CS_2100_HLG) {
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
video->conversion_techs[0] = "I010_HLG_Y";
video->conversion_techs[1] = "I010_HLG_U";
video->conversion_techs[2] = "I010_HLG_V";
} else {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
video->conversion_techs[0] = "I010_SRGB_Y";
video->conversion_techs[1] = "I010_SRGB_U";
video->conversion_techs[2] = "I010_SRGB_V";
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
}
break;
case VIDEO_FORMAT_P010:
video->conversion_needed = true;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video->conversion_width_i = 1.f / (float)info->width;
video->conversion_height_i = 1.f / (float)info->height;
if (info->colorspace == VIDEO_CS_2100_PQ) {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
video->conversion_techs[0] = "P010_PQ_Y";
video->conversion_techs[1] = "P010_PQ_UV";
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
} else if (info->colorspace == VIDEO_CS_2100_HLG) {
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
video->conversion_techs[0] = "P010_HLG_Y";
video->conversion_techs[1] = "P010_HLG_UV";
} else {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
video->conversion_techs[0] = "P010_SRGB_Y";
video->conversion_techs[1] = "P010_SRGB_UV";
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
}
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
}
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static bool obs_init_gpu_conversion(struct obs_core_video_mix *video)
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
const struct video_output_info *info =
video_output_get_info(video->video);
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
calc_gpu_conversion_sizes(video);
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->using_nv12_tex =
info->format == VIDEO_FORMAT_NV12 ? gs_nv12_available() : false;
video->using_p010_tex =
info->format == VIDEO_FORMAT_P010 ? gs_p010_available() : false;
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->conversion_needed) {
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
blog(LOG_INFO, "GPU conversion not available for format: %u",
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
(unsigned int)info->format);
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
video->gpu_conversion = false;
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
video->using_nv12_tex = false;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
video->using_p010_tex = false;
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
blog(LOG_INFO, "NV12 texture support not available");
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
return true;
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
if (video->using_nv12_tex)
blog(LOG_INFO, "NV12 texture support enabled");
else
blog(LOG_INFO, "NV12 texture support not available");
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (video->using_p010_tex)
blog(LOG_INFO, "P010 texture support enabled");
else
blog(LOG_INFO, "P010 texture support not available");
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->convert_textures[0] = NULL;
video->convert_textures[1] = NULL;
video->convert_textures[2] = NULL;
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
#ifdef _WIN32
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->convert_textures_encode[0] = NULL;
video->convert_textures_encode[1] = NULL;
video->convert_textures_encode[2] = NULL;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
if (video->using_nv12_tex) {
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
if (!gs_texture_create_nv12(&video->convert_textures_encode[0],
&video->convert_textures_encode[1],
info->width, info->height,
GS_RENDER_TARGET |
GS_SHARED_KM_TEX)) {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
return false;
}
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
} else if (video->using_p010_tex) {
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
if (!gs_texture_create_p010(&video->convert_textures_encode[0],
&video->convert_textures_encode[1],
info->width, info->height,
GS_RENDER_TARGET |
GS_SHARED_KM_TEX)) {
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
return false;
}
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
#endif
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
bool success = true;
switch (info->format) {
case VIDEO_FORMAT_I420:
video->convert_textures[0] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R8, 1,
NULL, GS_RENDER_TARGET);
video->convert_textures[1] =
gs_texture_create(info->width / 2, info->height / 2,
GS_R8, 1, NULL, GS_RENDER_TARGET);
video->convert_textures[2] =
gs_texture_create(info->width / 2, info->height / 2,
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
GS_R8, 1, NULL, GS_RENDER_TARGET);
if (!video->convert_textures[0] ||
!video->convert_textures[1] || !video->convert_textures[2])
success = false;
break;
case VIDEO_FORMAT_NV12:
video->convert_textures[0] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R8, 1,
NULL, GS_RENDER_TARGET);
video->convert_textures[1] =
gs_texture_create(info->width / 2, info->height / 2,
GS_R8G8, 1, NULL, GS_RENDER_TARGET);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->convert_textures[0] || !video->convert_textures[1])
success = false;
break;
case VIDEO_FORMAT_I444:
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->convert_textures[0] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R8, 1,
NULL, GS_RENDER_TARGET);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->convert_textures[1] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R8, 1,
NULL, GS_RENDER_TARGET);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->convert_textures[2] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R8, 1,
NULL, GS_RENDER_TARGET);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->convert_textures[0] ||
!video->convert_textures[1] || !video->convert_textures[2])
success = false;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
break;
case VIDEO_FORMAT_I010:
video->convert_textures[0] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R16, 1,
NULL, GS_RENDER_TARGET);
video->convert_textures[1] =
gs_texture_create(info->width / 2, info->height / 2,
GS_R16, 1, NULL, GS_RENDER_TARGET);
video->convert_textures[2] =
gs_texture_create(info->width / 2, info->height / 2,
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
GS_R16, 1, NULL, GS_RENDER_TARGET);
if (!video->convert_textures[0] ||
!video->convert_textures[1] || !video->convert_textures[2])
success = false;
break;
case VIDEO_FORMAT_P010:
video->convert_textures[0] =
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_create(info->width, info->height, GS_R16, 1,
NULL, GS_RENDER_TARGET);
video->convert_textures[1] =
gs_texture_create(info->width / 2, info->height / 2,
GS_RG16, 1, NULL, GS_RENDER_TARGET);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->convert_textures[0] || !video->convert_textures[1])
success = false;
break;
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
}
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!success) {
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->convert_textures[c]) {
gs_texture_destroy(video->convert_textures[c]);
video->convert_textures[c] = NULL;
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
#ifdef _WIN32
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (video->convert_textures_encode[c]) {
gs_texture_destroy(
video->convert_textures_encode[c]);
video->convert_textures_encode[c] = NULL;
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
#endif
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
}
}
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
return success;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
}
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
static bool obs_init_gpu_copy_surfaces(struct obs_core_video_mix *video,
size_t i)
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
{
const struct video_output_info *info =
video_output_get_info(video->video);
switch (info->format) {
case VIDEO_FORMAT_I420:
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R8);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->copy_surfaces[i][0])
return false;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->copy_surfaces[i][1] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_R8);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->copy_surfaces[i][1])
return false;
video->copy_surfaces[i][2] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_R8);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->copy_surfaces[i][2])
return false;
break;
case VIDEO_FORMAT_NV12:
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R8);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->copy_surfaces[i][0])
return false;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->copy_surfaces[i][1] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_R8G8);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->copy_surfaces[i][1])
return false;
break;
case VIDEO_FORMAT_I444:
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R8);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->copy_surfaces[i][0])
return false;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
video->copy_surfaces[i][1] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R8);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->copy_surfaces[i][1])
return false;
video->copy_surfaces[i][2] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R8);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
if (!video->copy_surfaces[i][2])
return false;
break;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
case VIDEO_FORMAT_I010:
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R16);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces[i][0])
return false;
video->copy_surfaces[i][1] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_R16);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces[i][1])
return false;
video->copy_surfaces[i][2] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_R16);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces[i][2])
return false;
break;
case VIDEO_FORMAT_P010:
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_R16);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces[i][0])
return false;
video->copy_surfaces[i][1] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width / 2, info->height / 2, GS_RG16);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces[i][1])
return false;
break;
UI, libobs: Fix compiler warnings
2019-10-09 22:24:55 -07:00
default:
break;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
}
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
return true;
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static bool obs_init_textures(struct obs_core_video_mix *video)
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
{
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
const struct video_output_info *info =
video_output_get_info(video->video);
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
bool success = true;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
for (size_t i = 0; i < NUM_TEXTURES; i++) {
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
#ifdef _WIN32
if (video->using_nv12_tex) {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->copy_surfaces_encode[i] =
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
gs_stagesurface_create_nv12(info->width,
info->height);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->copy_surfaces_encode[i]) {
success = false;
break;
}
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
} else if (video->using_p010_tex) {
video->copy_surfaces_encode[i] =
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
gs_stagesurface_create_p010(info->width,
info->height);
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
if (!video->copy_surfaces_encode[i]) {
success = false;
break;
}
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
}
#endif
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (video->gpu_conversion) {
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (!obs_init_gpu_copy_surfaces(video, i)) {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
success = false;
break;
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
} else {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
video->copy_surfaces[i][0] = gs_stagesurface_create(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->width, info->height, GS_RGBA);
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
if (!video->copy_surfaces[i][0]) {
success = false;
break;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
}
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
}
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
enum gs_color_format format = GS_RGBA;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
switch (info->format) {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case VIDEO_FORMAT_I010:
case VIDEO_FORMAT_P010:
libobs: Add support for YUV422P10LE, YUV444P12LE, YUVA444P12LE
2022-04-19 10:37:07 -07:00
case VIDEO_FORMAT_I210:
case VIDEO_FORMAT_I412:
case VIDEO_FORMAT_YA2L:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
format = GS_RGBA16F;
}
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
enum gs_color_space space = GS_CS_SRGB;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
switch (info->colorspace) {
libobs: Rename Rec. 2020 to Rec. 2100 Rec. 2020 is really an SDR spec, but I think HDR10 made it okay to slap PQ on it, call it an HDR spec. Rec. 2100 came along after and formally allowed the use of PQ/HLG, so we should use 2100 instead.
2022-04-09 20:54:28 -07:00
case VIDEO_CS_2100_PQ:
case VIDEO_CS_2100_HLG:
libobs: Add Rec. 2020 video_colorspace enum values One for PQ, and one for HLG. Including transfer function as part of the color space simplifies logic by avoid invalid combinations.
2022-03-16 01:01:47 -07:00
space = GS_CS_709_EXTENDED;
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
break;
default:
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
switch (info->format) {
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case VIDEO_FORMAT_I010:
case VIDEO_FORMAT_P010:
space = GS_CS_SRGB_16F;
}
libobs: Add Rec. 2020 video_colorspace enum values One for PQ, and one for HLG. Including transfer function as part of the color space simplifies logic by avoid invalid combinations.
2022-03-16 01:01:47 -07:00
}
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->render_texture =
gs_texture_create(obs->video.base_width, obs->video.base_height,
format, 1, NULL, GS_RENDER_TARGET);
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
if (!video->render_texture)
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
success = false;
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->output_texture = gs_texture_create(
info->width, info->height, format, 1, NULL, GS_RENDER_TARGET);
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
if (!video->output_texture)
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
success = false;
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
if (success) {
video->render_space = space;
} else {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
for (size_t i = 0; i < NUM_TEXTURES; i++) {
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->copy_surfaces[i][c]) {
gs_stagesurface_destroy(
video->copy_surfaces[i][c]);
video->copy_surfaces[i][c] = NULL;
}
}
#ifdef _WIN32
if (video->copy_surfaces_encode[i]) {
gs_stagesurface_destroy(
video->copy_surfaces_encode[i]);
video->copy_surfaces_encode[i] = NULL;
}
#endif
}
if (video->render_texture) {
gs_texture_destroy(video->render_texture);
video->render_texture = NULL;
}
if (video->output_texture) {
gs_texture_destroy(video->output_texture);
video->output_texture = NULL;
}
}
return success;
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
}
libobs: Add obs_load_effect function Just creates an effect to the target variable only if its current value is null. This will be used for deinterlacing effects to prevent having to compile the shaders unless they're actually being used.
2016-03-15 20:22:03 -07:00
gs_effect_t *obs_load_effect(gs_effect_t **effect, const char *file)
{
if (!*effect) {
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
char *filename = obs_find_data_file(file);
libobs: Add obs_load_effect function Just creates an effect to the target variable only if its current value is null. This will be used for deinterlacing effects to prevent having to compile the shaders unless they're actually being used.
2016-03-15 20:22:03 -07:00
*effect = gs_effect_create_from_file(filename, NULL);
bfree(filename);
}
return *effect;
}
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
static int obs_init_graphics(struct obs_video_info *ovi)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_video *video = &obs->video;
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
uint8_t transparent_tex_data[2 * 2 * 4] = {0};
libobs: Always have a transparent blank texture available Allows transitions to be able to return a blank texture to transitions if a transition is transitioning from/to a NULL source.
2016-01-03 15:52:56 -08:00
const uint8_t *transparent_tex = transparent_tex_data;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
struct gs_sampler_info point_sampler = {0};
fill in the texture_setimage function, fill in a few other functions, and change certain names to be a little more consistent
2013-10-25 10:25:28 -07:00
bool success = true;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
int errorcode;
first commit
2013-09-30 19:37:13 -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
errorcode =
gs_create(&video->graphics, ovi->graphics_module, ovi->adapter);
first commit
2013-09-30 19:37:13 -07:00
if (errorcode != GS_SUCCESS) {
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
switch (errorcode) {
case GS_ERROR_MODULE_NOT_FOUND:
return OBS_VIDEO_MODULE_NOT_FOUND;
case GS_ERROR_NOT_SUPPORTED:
return OBS_VIDEO_NOT_SUPPORTED;
default:
return OBS_VIDEO_FAIL;
}
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_enter_context(video->graphics);
first commit
2013-09-30 19:37:13 -07:00
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
char *filename = obs_find_data_file("default.effect");
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
video->default_effect = gs_effect_create_from_file(filename, NULL);
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
bfree(filename);
Initialize default_rect_effect only with OpenGL Instead of limiting this to an apple-specific define, just limit it to OpenGL -- because this particular effect file cannot be used with Direct3D.
2014-10-14 06:47:25 -07:00
if (gs_get_device_type() == GS_DEVICE_OPENGL) {
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("default_rect.effect");
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
video->default_rect_effect =
gs_effect_create_from_file(filename, NULL);
Initialize default_rect_effect only with OpenGL Instead of limiting this to an apple-specific define, just limit it to OpenGL -- because this particular effect file cannot be used with Direct3D.
2014-10-14 06:47:25 -07:00
bfree(filename);
}
Add obs_get_default_rect_effect This provides a default effect for users of GL_TEXTURE_RECTANGLE/textures that return true for gs_texture_is_rect
2014-10-03 06:56:38 -07:00
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("opaque.effect");
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
video->opaque_effect = gs_effect_create_from_file(filename, NULL);
libobs: Add obs_get_opaque_effect function This returns a common effect useful for rendering an image with the alpha channel overridden to 1.0.
2015-03-14 00:24:32 -07:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("solid.effect");
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
video->solid_effect = gs_effect_create_from_file(filename, NULL);
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
bfree(filename);
UI: Add scene item canvas overflow to preview
2019-01-14 17:58:20 -08:00
filename = obs_find_data_file("repeat.effect");
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
video->repeat_effect = gs_effect_create_from_file(filename, NULL);
UI: Add scene item canvas overflow to preview
2019-01-14 17:58:20 -08:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("format_conversion.effect");
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
video->conversion_effect = gs_effect_create_from_file(filename, NULL);
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("bicubic_scale.effect");
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
video->bicubic_effect = gs_effect_create_from_file(filename, NULL);
(API Change) libobs: Add bicubic/lanczos scaling This adds bicubic and lanczos scaling capability to libobs to improve scaling quality and sharpness when the output resolution has to be scaled relative to the base resolution. Bilinear is also available, although bilinear has rather poor quality and causes scaling to appear blurry. If the output resolution is close to the base resolution, then bilinear is used instead as an optimization, as there's no need to use these shaders if scaling is not in use. The Bicubic and Lanczos effects are also exposed via exported function to allow the ability to use those shaders in plugin modules if desired. The API change adds a variable 'scale_type' to the obs_video_info structure that allows the user interface to choose what type of scaling filter should be used.
2014-12-14 23:45:44 -08:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("lanczos_scale.effect");
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
video->lanczos_effect = gs_effect_create_from_file(filename, NULL);
(API Change) libobs: Add bicubic/lanczos scaling This adds bicubic and lanczos scaling capability to libobs to improve scaling quality and sharpness when the output resolution has to be scaled relative to the base resolution. Bilinear is also available, although bilinear has rather poor quality and causes scaling to appear blurry. If the output resolution is close to the base resolution, then bilinear is used instead as an optimization, as there's no need to use these shaders if scaling is not in use. The Bicubic and Lanczos effects are also exposed via exported function to allow the ability to use those shaders in plugin modules if desired. The API change adds a variable 'scale_type' to the obs_video_info structure that allows the user interface to choose what type of scaling filter should be used.
2014-12-14 23:45:44 -08:00
bfree(filename);
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
filename = obs_find_data_file("area.effect");
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
video->area_effect = gs_effect_create_from_file(filename, NULL);
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("bilinear_lowres_scale.effect");
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
video->bilinear_lowres_effect =
gs_effect_create_from_file(filename, NULL);
libobs: Add low resolution bilinear scale effect This effect preserves detail of images that are scaled below half size by using sampling 9 pixels.
2015-04-06 07:09:47 -07:00
bfree(filename);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
filename = obs_find_data_file("premultiplied_alpha.effect");
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
video->premultiplied_alpha_effect =
gs_effect_create_from_file(filename, NULL);
libobs: Add premultiplied alpha base effect
2016-03-26 21:41:49 -07:00
bfree(filename);
libobs: Fix invalid max_anisotropy value max_anisotropy is initialized to zero, but the minimum value is 1.
2019-03-19 01:26:28 -07:00
point_sampler.max_anisotropy = 1;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
video->point_sampler = gs_samplerstate_create(&point_sampler);
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
obs->video.transparent_texture =
gs_texture_create(2, 2, GS_RGBA, 1, &transparent_tex, 0);
libobs: Always have a transparent blank texture available Allows transitions to be able to return a blank texture to transitions if a transition is transitioning from/to a NULL source.
2016-01-03 15:52:56 -08:00
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
if (!video->default_effect)
success = false;
Initialize default_rect_effect only with OpenGL Instead of limiting this to an apple-specific define, just limit it to OpenGL -- because this particular effect file cannot be used with Direct3D.
2014-10-14 06:47:25 -07:00
if (gs_get_device_type() == GS_DEVICE_OPENGL) {
if (!video->default_rect_effect)
success = false;
}
libobs: Add obs_get_opaque_effect function This returns a common effect useful for rendering an image with the alpha channel overridden to 1.0.
2015-03-14 00:24:32 -07:00
if (!video->opaque_effect)
success = false;
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
if (!video->solid_effect)
success = false;
if (!video->conversion_effect)
success = false;
libobs: Add premultiplied alpha base effect
2016-03-26 21:41:49 -07:00
if (!video->premultiplied_alpha_effect)
success = false;
libobs: Always have a transparent blank texture available Allows transitions to be able to return a blank texture to transitions if a transition is transitioning from/to a NULL source.
2016-01-03 15:52:56 -08:00
if (!video->transparent_texture)
success = false;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (!video->point_sampler)
success = false;
first commit
2013-09-30 19:37:13 -07:00
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_leave_context();
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return success ? OBS_VIDEO_SUCCESS : OBS_VIDEO_FAIL;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static inline void set_video_matrix(struct obs_core_video_mix *video,
struct video_output_info *info)
(API Change) Add colorspace info to obs_video_info This was an important change because we were originally using an hard-coded 709/partial range color matrix for the output, which was causing problems for people wanting to use different formats or color spaces. This will now automatically generate the color matrix depending on the format, color space, and range, or use an identity matrix if the video format is RGB instead of YUV.
2014-12-11 19:51:30 -08:00
{
struct matrix4 mat;
struct vec4 r_row;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (format_is_yuv(info->format)) {
libobs,plugins: Replace video matrix function video_format_get_parameters_for_format provides a more accurate matrix than video_format_get_parameters.
2022-04-02 23:57:30 -07:00
video_format_get_parameters_for_format(
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
info->colorspace, info->range, info->format,
libobs,plugins: Replace video matrix function video_format_get_parameters_for_format provides a more accurate matrix than video_format_get_parameters.
2022-04-02 23:57:30 -07:00
(float *)&mat, NULL, NULL);
(API Change) Add colorspace info to obs_video_info This was an important change because we were originally using an hard-coded 709/partial range color matrix for the output, which was causing problems for people wanting to use different formats or color spaces. This will now automatically generate the color matrix depending on the format, color space, and range, or use an identity matrix if the video format is RGB instead of YUV.
2014-12-11 19:51:30 -08:00
matrix4_inv(&mat, &mat);
/* swap R and G */
r_row = mat.x;
mat.x = mat.y;
mat.y = r_row;
} else {
matrix4_identity(&mat);
}
memcpy(video->color_matrix, &mat, sizeof(float) * 16);
}
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
static int obs_init_video_mix(struct obs_video_info *ovi,
struct obs_core_video_mix *video)
first commit
2013-09-30 19:37:13 -07:00
{
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
struct video_output_info vi;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
pthread_mutex_init_value(&video->gpu_encoder_mutex);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
make_video_info(&vi, ovi);
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
video->gpu_conversion = ovi->gpu_conversion;
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
video->scale_type = ovi->scale_type;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video->gpu_was_active = false;
video->raw_was_active = false;
video->was_active = false;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
set_video_matrix(video, &vi);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
int errorcode = video_output_open(&video->video, &vi);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (errorcode != VIDEO_OUTPUT_SUCCESS) {
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
if (errorcode == VIDEO_OUTPUT_INVALIDPARAM) {
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
blog(LOG_ERROR, "Invalid video parameters specified");
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_INVALID_PARAM;
} else {
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
blog(LOG_ERROR, "Could not open video output");
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
}
return OBS_VIDEO_FAIL;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (pthread_mutex_init(&video->gpu_encoder_mutex, NULL) < 0)
return OBS_VIDEO_FAIL;
gs_enter_context(obs->video.graphics);
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (video->gpu_conversion && !obs_init_gpu_conversion(video))
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_FAIL;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (!obs_init_textures(video))
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_FAIL;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_leave_context();
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
return OBS_VIDEO_SUCCESS;
}
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
struct obs_core_video_mix *obs_create_video_mix(struct obs_video_info *ovi)
{
struct obs_core_video_mix *video =
bzalloc(sizeof(struct obs_core_video_mix));
if (obs_init_video_mix(ovi, video) != OBS_VIDEO_SUCCESS) {
bfree(video);
video = NULL;
}
return video;
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static int obs_init_video(struct obs_video_info *ovi)
{
struct obs_core_video *video = &obs->video;
video->base_width = ovi->base_width;
video->base_height = ovi->base_height;
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->video_frame_interval_ns =
util_mul_div64(1000000000ULL, ovi->fps_den, ovi->fps_num);
video->video_half_frame_interval_ns =
util_mul_div64(500000000ULL, ovi->fps_den, ovi->fps_num);
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
if (pthread_mutex_init(&video->task_mutex, NULL) < 0)
return OBS_VIDEO_FAIL;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (pthread_mutex_init(&video->mixes_mutex, NULL) < 0)
return OBS_VIDEO_FAIL;
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
libobs: Initialize main_view video mix before video thread Fixes a race condition where the video thread would exit because it sees no active mixes, causing OBS to freeze on startup. Fixes #7095
2022-08-18 14:17:48 -07:00
video->ovi = *ovi;
if (!obs_view_add(&obs->data.main_view))
return OBS_VIDEO_FAIL;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
int errorcode;
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 09:38:00 -07:00
#ifdef __APPLE__
errorcode = pthread_create(&video->video_thread, NULL,
obs_graphics_thread_autorelease, obs);
#else
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
errorcode = pthread_create(&video->video_thread, NULL,
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
obs_graphics_thread, obs);
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 09:38:00 -07:00
#endif
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (errorcode != 0)
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_FAIL;
first commit
2013-09-30 19:37:13 -07:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
video->thread_initialized = true;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_SUCCESS;
first commit
2013-09-30 19:37:13 -07:00
}
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
static void stop_video(void)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
pthread_mutex_lock(&obs->video.mixes_mutex);
for (size_t i = 0, num = obs->video.mixes.num; i < num; i++)
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
video_output_stop(obs->video.mixes.array[i]->video);
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
pthread_mutex_unlock(&obs->video.mixes_mutex);
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_video *video = &obs->video;
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
void *thread_retval;
first commit
2013-09-30 19:37:13 -07:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
if (video->thread_initialized) {
pthread_join(video->video_thread, &thread_retval);
video->thread_initialized = false;
}
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static void obs_free_render_textures(struct obs_core_video_mix *video)
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
{
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
if (!obs->video.graphics)
return;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_enter_context(obs->video.graphics);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->mapped_surfaces[c]) {
gs_stagesurface_unmap(video->mapped_surfaces[c]);
video->mapped_surfaces[c] = NULL;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
}
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
}
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
for (size_t i = 0; i < NUM_TEXTURES; i++) {
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->copy_surfaces[i][c]) {
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
gs_stagesurface_destroy(
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->copy_surfaces[i][c]);
video->copy_surfaces[i][c] = NULL;
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
}
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
video->active_copy_surfaces[i][c] = NULL;
}
#ifdef _WIN32
if (video->copy_surfaces_encode[i]) {
gs_stagesurface_destroy(video->copy_surfaces_encode[i]);
video->copy_surfaces_encode[i] = NULL;
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
}
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
#endif
}
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_destroy(video->render_texture);
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
for (size_t c = 0; c < NUM_CHANNELS; c++) {
if (video->convert_textures[c]) {
gs_texture_destroy(video->convert_textures[c]);
video->convert_textures[c] = NULL;
}
libobs: NV12 textures only for active GPU encoders Intel GPUs in particular are slow to copy NV12/P010 textures. We can use ordinary UNORM textures for CPU encoders.
2022-03-02 22:19:51 -08:00
#ifdef _WIN32
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
if (video->convert_textures_encode[c]) {
gs_texture_destroy(video->convert_textures_encode[c]);
video->convert_textures_encode[c] = NULL;
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
}
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
#endif
}
libobs: Separate textures for YUV output, fix chroma The shaders to pack YUV information into the same texture were rather complicated and suffering precision issues. Breaking them up into separate textures makes the shaders much simpler and avoids having to compute large integer offsets. Unfortunately, the code to handle multiple textures is not as pleasant, but at least the NV12 rendering path is no longer separate. In addition, write chroma samples to "standard" offsets. For I444, there's no difference, but I420/NV12 formats now have chroma shifted to the left as 4:2:0 is shown in the H.264 specification. Intel GPA, SetStablePowerState, Intel HD Graphics 530 Expect speed incrase: I420: 844 us -> 493 us (254 us + 190 us + 274 us) I444: 837 us -> 747 us (258 us + 276 us + 272 us) NV12: 450 us -> 368 us (319 us + 168 us) Expect no change: NV12 (HW): 580 (481 us + 166 us) us -> 588 us (468 us + 247 us) RGB: 359 us -> 387 us Fixes https://obsproject.com/mantis/view.php?id=624 Fixes https://obsproject.com/mantis/view.php?id=1512
2019-07-26 23:21:41 -07:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_texture_destroy(video->output_texture);
video->render_texture = NULL;
video->output_texture = NULL;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
libobs: Format changes for multiple video mixes
2022-06-15 10:07:50 -07:00
gs_leave_context();
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
}
void obs_free_video_mix(struct obs_core_video_mix *video)
{
if (video->video) {
video_output_close(video->video);
video->video = NULL;
obs_free_render_textures(video);
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
libobs: Redesign/optimize frame encoding handling Previously, the design for the interaction between the encoder thread and the graphics thread was that the encoder thread would signal to the graphics thread when to start drawing each frame. The original idea behind this was to prevent mutually cascading stalls of encoding or graphics rendering (i.e., if rendering took too long, then encoding would have to catch up, then rendering would have to catch up again, and so on, cascading upon each other). The ultimate goal was to prevent encoding from impacting graphics and vise versa. However, eventually it was realized that there were some fundamental flaws with this design. 1. Stray frame duplication. You could not guarantee that a frame would render on time, so sometimes frames would unintentionally be lost if there was any sort of minor hiccup or if the thread took too long to be scheduled I'm guessing. 2. Frame timing in the rendering thread was less accurate. The only place where frame timing was accurate was in the encoder thread, and the graphics thread was at the whim of thread scheduling. On higher end computers it was typically fine, but it was just generally not guaranteed that a frame would be rendered when it was supposed to be rendered. So the solution (originally proposed by r1ch and paibox) is to instead keep the encoding and graphics threads separate as usual, but instead of the encoder thread controlling the graphics thread, the graphics thread now controls the encoder thread. The encoder thread keeps a limited cache of frames, then the graphics thread copies frames in to the cache and increments a semaphore to schedule the encoder thread to encode that data. In the cache, each frame has an encode counter. If the frame cache is full (e.g., the encoder taking too long to return frames), it will not cache a new frame, but instead will just increment the counter on the last frame in the cache to schedule that frame to encode again, ensuring that frames are on time and reducing CPU usage by lowering video complexity. If the graphics thread takes too long to render a frame, then it will add that frame with the count value set to the total amount of frames that were missed (actual legitimately duplicated frames). Because the cache gives many frames of breathing room for the encoder to encode frames, this design helps improve results especially when using encoding presets that have higher complexity and CPU usage, minimizing the risk of needlessly skipped or duplicated frames. I also managed to sneak in what should be a bit of an optimization to reduce copying of frame data, though how much of an optimization it ultimately ends up being is debatable. So to sum it up, this commit increases accuracy of frame timing, completely removes stray frame duplication, gives better results for higher complexity encoding presets, and potentially optimizes the frame pipeline a tiny bit.
2014-12-31 01:53:13 -08:00
circlebuf_free(&video->vframe_info_buffer);
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
circlebuf_free(&video->vframe_info_buffer_gpu);
Add timestamp circlebuf for video input/output At the start of each render loop, it would get the timestamp, and then it would then assign that timestamp to whatever frame was downloaded. However, the frame that was downloaded was usually occurred a number of frames ago, so it would assign the wrong timestamp value to that frame. This fixes that issue by storing the timestamps in a circular buffer.
2014-10-21 20:08:39 -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
video->texture_rendered = false;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
memset(video->textures_copied, 0,
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
sizeof(video->textures_copied));
video->texture_converted = false;
libobs: Fix bug with frame output handling The boolean variables which stored whether frames have been rendered/downloaded/converted/etc were not being reset when video restarted, causing frames to not be sent in the correct order whenever video was reset. This could lead to minor desync of video/audio.
2014-12-31 01:45:39 -08:00
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
pthread_mutex_destroy(&video->gpu_encoder_mutex);
pthread_mutex_init_value(&video->gpu_encoder_mutex);
da_free(video->gpu_encoders);
video->gpu_encoder_active = 0;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
video->cur_texture = 0;
}
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
bfree(video);
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
static void obs_free_video(void)
{
pthread_mutex_lock(&obs->video.mixes_mutex);
size_t num = obs->video.mixes.num;
if (num)
libobs: Fix format specifier warning
2022-08-14 14:45:34 -07:00
blog(LOG_WARNING, "%zu views remain at shutdown", num);
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
for (size_t i = 0; i < num; i++) {
obs_free_video_mix(obs->video.mixes.array[i]);
obs->video.mixes.array[i] = NULL;
}
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
pthread_mutex_unlock(&obs->video.mixes_mutex);
pthread_mutex_destroy(&obs->video.mixes_mutex);
pthread_mutex_init_value(&obs->video.mixes_mutex);
da_free(obs->video.mixes);
pthread_mutex_destroy(&obs->video.task_mutex);
pthread_mutex_init_value(&obs->video.task_mutex);
circlebuf_free(&obs->video.tasks);
}
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
static void obs_free_graphics(void)
{
struct obs_core_video *video = &obs->video;
if (video->graphics) {
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_enter_context(video->graphics);
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
libobs: Always have a transparent blank texture available Allows transitions to be able to return a blank texture to transitions if a transition is transitioning from/to a NULL source.
2016-01-03 15:52:56 -08:00
gs_texture_destroy(video->transparent_texture);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_samplerstate_destroy(video->point_sampler);
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_effect_destroy(video->default_effect);
Add obs_get_default_rect_effect This provides a default effect for users of GL_TEXTURE_RECTANGLE/textures that return true for gs_texture_is_rect
2014-10-03 06:56:38 -07:00
gs_effect_destroy(video->default_rect_effect);
libobs: Add obs_get_opaque_effect function This returns a common effect useful for rendering an image with the alpha channel overridden to 1.0.
2015-03-14 00:24:32 -07:00
gs_effect_destroy(video->opaque_effect);
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_effect_destroy(video->solid_effect);
gs_effect_destroy(video->conversion_effect);
(API Change) libobs: Add bicubic/lanczos scaling This adds bicubic and lanczos scaling capability to libobs to improve scaling quality and sharpness when the output resolution has to be scaled relative to the base resolution. Bilinear is also available, although bilinear has rather poor quality and causes scaling to appear blurry. If the output resolution is close to the base resolution, then bilinear is used instead as an optimization, as there's no need to use these shaders if scaling is not in use. The Bicubic and Lanczos effects are also exposed via exported function to allow the ability to use those shaders in plugin modules if desired. The API change adds a variable 'scale_type' to the obs_video_info structure that allows the user interface to choose what type of scaling filter should be used.
2014-12-14 23:45:44 -08:00
gs_effect_destroy(video->bicubic_effect);
libobs: Make sure to destroy effect This actually isn't necessary because the graphics subsystem technically automatically frees effects, but that could change, so call this just to be safe.
2019-02-10 18:12:37 -08:00
gs_effect_destroy(video->repeat_effect);
(API Change) libobs: Add bicubic/lanczos scaling This adds bicubic and lanczos scaling capability to libobs to improve scaling quality and sharpness when the output resolution has to be scaled relative to the base resolution. Bilinear is also available, although bilinear has rather poor quality and causes scaling to appear blurry. If the output resolution is close to the base resolution, then bilinear is used instead as an optimization, as there's no need to use these shaders if scaling is not in use. The Bicubic and Lanczos effects are also exposed via exported function to allow the ability to use those shaders in plugin modules if desired. The API change adds a variable 'scale_type' to the obs_video_info structure that allows the user interface to choose what type of scaling filter should be used.
2014-12-14 23:45:44 -08:00
gs_effect_destroy(video->lanczos_effect);
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
gs_effect_destroy(video->area_effect);
libobs: Add low resolution bilinear scale effect This effect preserves detail of images that are scaled below half size by using sampling 9 pixels.
2015-04-06 07:09:47 -07:00
gs_effect_destroy(video->bilinear_lowres_effect);
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
video->default_effect = NULL;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_leave_context();
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
gs_destroy(video->graphics);
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
video->graphics = NULL;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
static void set_audio_thread(void *unused);
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
static bool obs_init_audio(struct audio_output_info *ai)
first commit
2013-09-30 19:37:13 -07:00
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_audio *audio = &obs->audio;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
int errorcode;
first commit
2013-09-30 19:37:13 -07:00
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
pthread_mutex_init_value(&audio->monitoring_mutex);
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&audio->monitoring_mutex) != 0)
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
return false;
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
if (pthread_mutex_init(&audio->task_mutex, NULL) != 0)
return false;
struct obs_task_info audio_init = {.task = set_audio_thread};
circlebuf_push_back(&audio->tasks, &audio_init, sizeof(audio_init));
first commit
2013-09-30 19:37:13 -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
audio->user_volume = 1.0f;
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
audio->monitoring_device_name = bstrdup("Default");
audio->monitoring_device_id = bstrdup("default");
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
errorcode = audio_output_open(&audio->audio, ai);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (errorcode == AUDIO_OUTPUT_SUCCESS)
return true;
fixed broken comparison
2013-11-20 14:11:31 -08:00
else if (errorcode == AUDIO_OUTPUT_INVALIDPARAM)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
blog(LOG_ERROR, "Invalid audio parameters specified");
else
blog(LOG_ERROR, "Could not open audio output");
return false;
}
libobs: Add stop_audio function, change shutdown order This fixes a crash that could occur during freeing of sources, as the audio subsystem was destroyed before sources were released. If a source had monitoring enabled, it would try to lock a mutex that has been destroyed, resulting in a crash. Freeing audio after obs_free_data was also not a solution, as the main view is freed in obs_free_data, and the audio subsystem is still running and trying to lock the main view channel mutex which has been freed. This seems to be the best middle ground, making sure the audio subsystem is stopped so it no longer tries to access the main view channel, then freed after obs_free_data. Fixes https://github.com/obsproject/obs-studio/issues/4409
2021-05-06 16:52:52 -07:00
static void stop_audio(void)
{
struct obs_core_audio *audio = &obs->audio;
if (audio->audio) {
audio_output_close(audio->audio);
audio->audio = NULL;
}
}
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
static void obs_free_audio(void)
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_audio *audio = &obs->audio;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (audio->audio)
audio_output_close(audio->audio);
libobs: Implement new audio subsystem The new audio subsystem fixes two issues: - First Primary issue it fixes is the ability for parent sources to intercept the audio of child sources, and do custom processing on them. The main reason for this was the ability to do custom cross-fading in transitions, but it's also useful for things such as side-chain effects, applying audio effects to entire scenes, applying scene-specific audio filters on sub-sources, and other such possibilities. - The secondary issue that needed fixing was audio buffering. Previously, audio buffering was always a fixed buffer size, so it would always have exactly a certain number of milliseconds of audio buffering (and thus output delay). Instead, it now dynamically increases audio buffering only as necessary, minimizing output delay, and removing the need for users to have to worry about an audio buffering setting. The new design makes it so that audio from the leaves of the scene graph flow to the root nodes, and can be intercepted by parent sources. Each audio source handles its own buffering, and each audio tick a specific number of audio frames are popped from the front of the circular buffer on each audio source. Composite sources (such as scenes) can access the audio for child sources and do custom processing or mixing on that audio. Composite sources use the audio_render callback of sources to do synchronous or deferred audio processing per audio tick. Things like scenes now mix audio from their sub-sources.
2015-12-20 03:06:35 -08:00
circlebuf_free(&audio->buffered_timestamps);
da_free(audio->render_order);
da_free(audio->root_nodes);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
da_free(audio->monitors);
bfree(audio->monitoring_device_name);
bfree(audio->monitoring_device_id);
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
circlebuf_free(&audio->tasks);
pthread_mutex_destroy(&audio->task_mutex);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
pthread_mutex_destroy(&audio->monitoring_mutex);
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
memset(audio, 0, sizeof(struct obs_core_audio));
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
static bool obs_init_data(void)
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_data *data = &obs->data;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
Add NULL checks and assertions to fix clang static analysis problems Also remove an unused variable from obs-encoder.c (via clang static analysis)
2014-04-14 13:55:14 -07:00
assert(data != NULL);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
pthread_mutex_init_value(&obs->data.displays_mutex);
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
pthread_mutex_init_value(&obs->data.draw_callbacks_mutex);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->sources_mutex) != 0)
Use recursive mutex for user sources and displays - Using a recursive mutex fixes issues where objects need to enter the main libobs sources mutex while already within the mutex in the same thread. Otherwise it would keep getting locked on itself on destruction.
2014-01-08 17:07:04 -08:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->audio_sources_mutex) != 0)
libobs: Store linked list of audio sources Useful for going traversing the list of audio sources (particularly for the new audio subsystem)
2015-12-17 04:00:14 -08:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->displays_mutex) != 0)
Use recursive mutex for user sources and displays - Using a recursive mutex fixes issues where objects need to enter the main libobs sources mutex while already within the mutex in the same thread. Otherwise it would keep getting locked on itself on destruction.
2014-01-08 17:07:04 -08:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->outputs_mutex) != 0)
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->encoders_mutex) != 0)
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&data->services_mutex) != 0)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
goto fail;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&obs->data.draw_callbacks_mutex) != 0)
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
goto fail;
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
if (!obs_view_init(&data->main_view))
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
goto fail;
first commit
2013-09-30 19:37:13 -07:00
libobs: Add functions to get/set global private data Allows the ability to set custom global OBS context private data for allowing the frontend to communicate variables with plugins in an indirect way.
2018-08-10 06:01:22 -07:00
data->private_data = obs_data_create();
Fix render issues with main preview widget - I seem to have fixed ths issues with the main preview widget. It seems you just need to set the right window attributes to stop it from breaking. Though when opengl is enabled, there appears to be a weird background glitch in the Qt stuff -- I'm not entirely sure what's going on. Bug in Qt? Also fixed the layout issues, and the widget now properly resizes and centers in to its parent widget. - Prevent the render loop from accessing data if the data isn't valid. Because obs->data is freed before the graphics stuff, it can cause the graphics to keep trying to query the obs->data.displays_mutex after it had already been destroyed.
2014-01-23 16:00:42 -08:00
data->valid = true;
Use recursive mutex for user sources and displays - Using a recursive mutex fixes issues where objects need to enter the main libobs sources mutex while already within the mutex in the same thread. Otherwise it would keep getting locked on itself on destruction.
2014-01-08 17:07:04 -08:00
fail:
Fix render issues with main preview widget - I seem to have fixed ths issues with the main preview widget. It seems you just need to set the right window attributes to stop it from breaking. Though when opengl is enabled, there appears to be a weird background glitch in the Qt stuff -- I'm not entirely sure what's going on. Bug in Qt? Also fixed the layout issues, and the widget now properly resizes and centers in to its parent widget. - Prevent the render loop from accessing data if the data isn't valid. Because obs->data is freed before the graphics stuff, it can cause the graphics to keep trying to query the obs->data.displays_mutex after it had already been destroyed.
2014-01-23 16:00:42 -08:00
return data->valid;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Free main view separately from std. views The main view does not need to worry about hiding/deactivation of sources when it's being freed here, when the obs context is shutting down in this section of obs, all the sources are being freed, thus there's no need to worry about deactivating/hiding sources.
2015-03-02 00:30:40 -08:00
void obs_main_view_free(struct obs_view *view)
{
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
if (!view)
return;
libobs: Free main view separately from std. views The main view does not need to worry about hiding/deactivation of sources when it's being freed here, when the obs context is shutting down in this section of obs, all the sources are being freed, thus there's no need to worry about deactivating/hiding sources.
2015-03-02 00:30:40 -08:00
for (size_t i = 0; i < MAX_CHANNELS; i++)
obs_source_release(view->channels[i]);
memset(view->channels, 0, sizeof(view->channels));
pthread_mutex_destroy(&view->channels_mutex);
}
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
#define FREE_OBS_LINKED_LIST(type) \
do { \
int unfreed = 0; \
while (data->first_##type) { \
obs_##type##_destroy(data->first_##type); \
unfreed++; \
} \
if (unfreed) \
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
blog(LOG_INFO, "\t%d " #type "(s) were remaining", \
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
unfreed); \
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
} while (false)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
static void obs_free_data(void)
first commit
2013-09-30 19:37:13 -07:00
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_data *data = &obs->data;
first commit
2013-09-30 19:37:13 -07:00
Fix render issues with main preview widget - I seem to have fixed ths issues with the main preview widget. It seems you just need to set the right window attributes to stop it from breaking. Though when opengl is enabled, there appears to be a weird background glitch in the Qt stuff -- I'm not entirely sure what's going on. Bug in Qt? Also fixed the layout issues, and the widget now properly resizes and centers in to its parent widget. - Prevent the render loop from accessing data if the data isn't valid. Because obs->data is freed before the graphics stuff, it can cause the graphics to keep trying to query the obs->data.displays_mutex after it had already been destroyed.
2014-01-23 16:00:42 -08:00
data->valid = false;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
obs_view_remove(&data->main_view);
libobs: Free main view separately from std. views The main view does not need to worry about hiding/deactivation of sources when it's being freed here, when the obs context is shutting down in this section of obs, all the sources are being freed, thus there's no need to worry about deactivating/hiding sources.
2015-03-02 00:30:40 -08:00
obs_main_view_free(&data->main_view);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
blog(LOG_INFO, "Freeing OBS context data");
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
FREE_OBS_LINKED_LIST(source);
FREE_OBS_LINKED_LIST(output);
FREE_OBS_LINKED_LIST(encoder);
FREE_OBS_LINKED_LIST(display);
FREE_OBS_LINKED_LIST(service);
libobs: Don't destroy mutex before destroying sources is done
2022-01-20 13:57:12 -08:00
os_task_queue_wait(obs->destruction_task_thread);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
pthread_mutex_destroy(&data->sources_mutex);
libobs: Store linked list of audio sources Useful for going traversing the list of audio sources (particularly for the new audio subsystem)
2015-12-17 04:00:14 -08:00
pthread_mutex_destroy(&data->audio_sources_mutex);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
pthread_mutex_destroy(&data->displays_mutex);
pthread_mutex_destroy(&data->outputs_mutex);
pthread_mutex_destroy(&data->encoders_mutex);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
pthread_mutex_destroy(&data->services_mutex);
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
pthread_mutex_destroy(&data->draw_callbacks_mutex);
da_free(data->draw_callbacks);
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-06 23:13:56 -08:00
da_free(data->tick_callbacks);
libobs: Add functions to get/set global private data Allows the ability to set custom global OBS context private data for allowing the frontend to communicate variables with plugins in an indirect way.
2018-08-10 06:01:22 -07:00
obs_data_release(data->private_data);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
static const char *obs_signals[] = {
"void source_create(ptr source)",
"void source_destroy(ptr source)",
"void source_remove(ptr source)",
libobs: Add load/save signals for sources These signals are meant to replace the add/remove signals.
2015-10-28 12:38:47 -07:00
"void source_save(ptr source)",
"void source_load(ptr source)",
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
"void source_activate(ptr source)",
"void source_deactivate(ptr source)",
"void source_show(ptr source)",
"void source_hide(ptr source)",
libobs: Add funcs to determine whether audio active Adds functions to allow sources to inform the UI whether the audio is currently active or not. Allows the ability to turn on/off the items in the mixer.
2019-09-19 23:37:29 -07:00
"void source_audio_activate(ptr source)",
"void source_audio_deactivate(ptr source)",
Add signal for renaming sources
2014-06-30 00:05:35 -07:00
"void source_rename(ptr source, string new_name, string prev_name)",
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
"void source_volume(ptr source, in out float volume)",
libobs: Add level/magnitude/peak volume levels This replaces the older code which simply queried the max volume level value for any given audio. I'm still not 100% sure on if this is how I want to approach the problem, particularly, whether this should be done in obs_source or in audio_line, but it can always be moved later if needed. This uses the calculations by the awesome Bill Hamilton that OBS1 used for its volume levels. It calculates the current max (level), magnitude, and current peak. This data then can be used to create awesome volume meter controls later on. NOTE: Will probably need optimization, does one float at a time right now. Also, change some of the naming conventions. I actually need to change a lot of the naming conventions in general so that all words are separated by underscores. Kind of a bad practice there on my part.
2014-06-03 04:43:00 -07:00
"void source_volume_level(ptr source, float level, float magnitude, "
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
"float peak)",
libobs: Implement transition sources Transition sources are implemented by registering a source type as OBS_SOURCE_TYPE_TRANSITION. They're automatically marked as video composite sources, and video_render/audio_render callbacks must be set when registering the source. get_width and get_height callbacks are unused for these types of sources, as transitions automatically handle width/height behind the scenes with the transition settings. In the video_render callback, the helper function obs_transition_video_render is used to assist in automatically processing and rendering the audio. A render callback is passed to the function, which in turn passes to/from textures that are automatically rendered in the back-end. Similarly, in the audio_render callback, the helper function obs_transition_audio_render is used to assist in automatically processing and rendering the audio. Two mix callbacks are used to handle how the source/destination sources are mixed together. To ensure the best possible quality, audio processing is per-sample. Transitions can be set to automatically resize, or they can be set to have a fixed size. Sources within transitions can be made to scale to the transition size (with or without aspect ratio), or to not scale unless they're bigger than the transition. They can have a specific alignment within the transition, or they just default to top-left. These features are implemented for the purpose of extending transitions to also act as "switch" sources later, where you can switch to/from two different sources using the transition animation. Planned (but not yet implemented and lower priority) features: - "Switch" transitions which allow the ability to switch back and forth between two sources with a transitioning animation without discarding the references - Easing options to allow the option to transition with a bezier or custom curve - Manual transitioning to allow the front-end/user to manually control the transition offset
2016-01-03 16:41:14 -08:00
"void source_transition_start(ptr source)",
"void source_transition_video_stop(ptr source)",
"void source_transition_stop(ptr source)",
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
"void channel_change(int channel, in out ptr source, ptr prev_source)",
"void master_volume(in out float volume)",
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
"void hotkey_layout_change()",
"void hotkey_register(ptr hotkey)",
"void hotkey_unregister(ptr hotkey)",
"void hotkey_bindings_changed(ptr hotkey)",
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
NULL,
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
};
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
static inline bool obs_init_handlers(void)
{
obs->signals = signal_handler_create();
if (!obs->signals)
return false;
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
obs->procs = proc_handler_create();
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
if (!obs->procs)
return false;
return signal_handler_add_array(obs->signals, obs_signals);
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
}
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
static pthread_once_t obs_pthread_once_init_token = PTHREAD_ONCE_INIT;
static inline bool obs_init_hotkeys(void)
{
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
bool success = false;
assert(hotkeys != NULL);
da_init(hotkeys->hotkeys);
hotkeys->signals = obs->signals;
hotkeys->name_map_init_token = obs_pthread_once_init_token;
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
hotkeys->mute = bstrdup("Mute");
hotkeys->unmute = bstrdup("Unmute");
hotkeys->push_to_mute = bstrdup("Push-to-mute");
hotkeys->push_to_talk = bstrdup("Push-to-talk");
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
hotkeys->sceneitem_show = bstrdup("Show '%1'");
hotkeys->sceneitem_hide = bstrdup("Hide '%1'");
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
if (!obs_hotkeys_platform_init(hotkeys))
return false;
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&hotkeys->mutex) != 0)
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
goto fail;
if (os_event_init(&hotkeys->stop_event, OS_EVENT_TYPE_MANUAL) != 0)
goto fail;
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
if (pthread_create(&hotkeys->hotkey_thread, NULL, obs_hotkey_thread,
NULL))
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
goto fail;
libobs: Fix issue 4408 (hotkey logic) If obs_core_hotkeys.strict_modifiers is true (new default), hotkey is triggered only if current key modifiers exactly match the hotkey definition. If false, legacy behavior is selected.
2021-08-06 14:16:01 -07:00
hotkeys->strict_modifiers = true;
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
hotkeys->hotkey_thread_initialized = true;
success = true;
fail:
return success;
}
static inline void stop_hotkeys(void)
{
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
void *thread_ret;
if (hotkeys->hotkey_thread_initialized) {
os_event_signal(hotkeys->stop_event);
pthread_join(hotkeys->hotkey_thread, &thread_ret);
hotkeys->hotkey_thread_initialized = false;
}
os_event_destroy(hotkeys->stop_event);
obs_hotkeys_free();
}
static inline void obs_free_hotkeys(void)
{
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
bfree(hotkeys->mute);
bfree(hotkeys->unmute);
bfree(hotkeys->push_to_mute);
bfree(hotkeys->push_to_talk);
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
bfree(hotkeys->sceneitem_show);
bfree(hotkeys->sceneitem_hide);
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
obs_hotkey_name_map_free();
obs_hotkeys_platform_free(hotkeys);
pthread_mutex_destroy(&hotkeys->mutex);
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
extern const struct obs_source_info scene_info;
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
extern const struct obs_source_info group_info;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Add audio lines Adds the "audio_line" internal source type as a bare source type for the sole purpose of outputting audio, and the obs_source_info::audio_mix callback which allows mixing of those audio lines, which is then treated as normal audio for the source. Audio line objects should be added as sub-sources when multiple audio lines from a single source are needed, then mixed together with the audio_mix callback. The difference between the new obs_source_info::audio_mix callback and obs_source_info::audio_render is that obs_source_info::audio_mix (along with the audio_line source) are only one track, and it outputs audio to the source automatically via obs_source_output_audio() when the call completes. This allows the mixed audio to be treated like a normal source's audio, in that you can filter it, change its volume, or monitor it. This change was necessary because the CEF (used with the browser source) outputs multiple audio streams at once to a single browser source, so it's the program's responsibility to mix those streams together itself.
2019-08-21 14:35:40 -07:00
static const char *submix_name(void *unused)
{
UNUSED_PARAMETER(unused);
return "Audio line (internal use only)";
}
const struct obs_source_info audio_line_info = {
.id = "audio_line",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_AUDIO | OBS_SOURCE_CAP_DISABLED |
OBS_SOURCE_SUBMIX,
.get_name = submix_name,
};
Log system information on startup
2014-07-12 00:21:06 -07:00
extern void log_system_info(void);
(API Change) libobs: Add global module config path API Changed: --------------------------- From: - bool obs_startup(const char *locale, profiler_name_store_t *store); To: - bool obs_startup(const char *locale, const char *module_config_path, profiler_name_store_t *store); Summary: --------------------------- This allows plugin modules to store plugin-specific configuration data (rather than only allowing objects to store configuration data). This will be useful for things like caching data, for example looking up and storing ingests from remote (rather than storing locally), or caching font data (so it doesn't have to build a font cache each time), among other things. Also adds a module-specific directory for the UI
2015-08-09 05:09:07 -07:00
static bool obs_init(const char *locale, const char *module_config_path,
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
profiler_name_store_t *store)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
{
Use bzalloc instead of bmalloc then memset Reduces needless code repetition and still allows for proper memory alignment. Cleans up the code a bit.
2014-02-09 11:34:07 -08:00
obs = bzalloc(sizeof(struct obs_core));
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
pthread_mutex_init_value(&obs->audio.monitoring_mutex);
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
pthread_mutex_init_value(&obs->audio.task_mutex);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
pthread_mutex_init_value(&obs->video.task_mutex);
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
pthread_mutex_init_value(&obs->video.mixes_mutex);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
(API Change) libobs: Add profile_name_store_t parameter to obs_startup Due to all the threads in libobs it wouldn't be safe to make that parameter reconfigurable after libobs is initialized without adding even more synchronization. On the other hand, adding a function to set the name store before calling obs_startup would solve the problem of passing a name store into libobs, but it can lead to more complicated semantics for obs_get_profiler_name_store (e.g., should it always return the current name store even if libobs isn't initialized until someone calls set_name_store(NULL)? should obs_shutdown call set_name_store(NULL)? Passing it as obs_startup parameter avoids these (and hopefully other) potential misunderstandings
2015-08-02 03:06:00 -07:00
obs->name_store_owned = !store;
obs->name_store = store ? store : profiler_name_store_create();
if (!obs->name_store) {
blog(LOG_ERROR, "Couldn't create profiler name store");
return false;
}
Log system information on startup
2014-07-12 00:21:06 -07:00
log_system_info();
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
if (!obs_init_data())
return false;
if (!obs_init_handlers())
return false;
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
if (!obs_init_hotkeys())
return false;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Fix destruction order for destruction task queue Destruction of the task queue should probably happen after the audio and video threads have been destroyed and all audio/video processing has stopped.
2021-12-21 11:46:42 -08:00
obs->destruction_task_thread = os_task_queue_create();
if (!obs->destruction_task_thread)
return false;
(API Change) libobs: Add global module config path API Changed: --------------------------- From: - bool obs_startup(const char *locale, profiler_name_store_t *store); To: - bool obs_startup(const char *locale, const char *module_config_path, profiler_name_store_t *store); Summary: --------------------------- This allows plugin modules to store plugin-specific configuration data (rather than only allowing objects to store configuration data). This will be useful for things like caching data, for example looking up and storing ingests from remote (rather than storing locally), or caching font data (so it doesn't have to build a font cache each time), among other things. Also adds a module-specific directory for the UI
2015-08-09 05:09:07 -07:00
if (module_config_path)
obs->module_config_path = bstrdup(module_config_path);
Add API for setting/getting current locale This API is used to set the current locale for libobs, which it will set for all modules when a module is loaded or specifically when the locale is manually changed.
2014-06-25 00:21:16 -07:00
obs->locale = bstrdup(locale);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_register_source(&scene_info);
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
obs_register_source(&group_info);
libobs: Add audio lines Adds the "audio_line" internal source type as a bare source type for the sole purpose of outputting audio, and the obs_source_info::audio_mix callback which allows mixing of those audio lines, which is then treated as normal audio for the source. Audio line objects should be added as sub-sources when multiple audio lines from a single source are needed, then mixed together with the audio_mix callback. The difference between the new obs_source_info::audio_mix callback and obs_source_info::audio_render is that obs_source_info::audio_mix (along with the audio_line source) are only one track, and it outputs audio to the source automatically via obs_source_output_audio() when the call completes. This allows the mixed audio to be treated like a normal source's audio, in that you can filter it, change its volume, or monitor it. This change was necessary because the CEF (used with the browser source) outputs multiple audio streams at once to a single browser source, so it's the program's responsibility to mix those streams together itself.
2019-08-21 14:35:40 -07:00
obs_register_source(&audio_line_info);
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
add_default_module_paths();
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
return true;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Add win32 crash handler A slightly refactored version of R1CH's crash handler, allows crash handling for windows which provides stack traces of all threads and a list of all loaded modules. Also shows the processor, windows version, and current libobs version.
2015-01-02 05:57:06 -08:00
#ifdef _WIN32
libobs: Robust COM initialization Qt seems to force STA, so it's misleading to ask for MTA and ignore the failure result, so just ask for STA. Also, don't uninitialize COM if initialization failed.
2019-11-24 09:46:41 -08:00
extern bool initialize_com(void);
libobs: Call CoInitializeEx in libobs Due to the fact that certain modules may need COM on startup, initialize COM by default in libobs.
2015-09-22 11:27:38 -07:00
extern void uninitialize_com(void);
libobs: Robust COM initialization Qt seems to force STA, so it's misleading to ask for MTA and ignore the failure result, so just ask for STA. Also, don't uninitialize COM if initialization failed.
2019-11-24 09:46:41 -08:00
static bool com_initialized = false;
libobs: Add win32 crash handler A slightly refactored version of R1CH's crash handler, allows crash handling for windows which provides stack traces of all threads and a list of all loaded modules. Also shows the processor, windows version, and current libobs version.
2015-01-02 05:57:06 -08:00
#endif
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
/* Separate from actual context initialization
* since this can be set before startup and persist
* after shutdown. */
static DARRAY(struct dstr) core_module_paths = {0};
char *obs_find_data_file(const char *file)
{
struct dstr path = {0};
libobs: Remove unnecessary const qualifier This function returns a char *, so it should not be const (the value is set from a function which also returns a char *, so there is no real reason for this to be const).
2018-06-30 12:38:49 -07:00
char *result = find_libobs_data_file(file);
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
if (result)
return result;
libobs: Change int to size_t The loop increments i towards an unsigned type, so i should also be an unsigned type.
2018-06-30 12:23:08 -07:00
for (size_t i = 0; i < core_module_paths.num; ++i) {
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
if (check_path(file, core_module_paths.array[i].array, &path))
return path.array;
}
dstr_free(&path);
return NULL;
}
void obs_add_data_path(const char *path)
{
struct dstr *new_path = da_push_back_new(core_module_paths);
dstr_init_copy(new_path, path);
}
bool obs_remove_data_path(const char *path)
{
libobs: Change int to size_t The loop increments i towards an unsigned type, so i should also be an unsigned type.
2018-06-30 12:23:08 -07:00
for (size_t i = 0; i < core_module_paths.num; ++i) {
libobs: Allow custom core data paths Closes obsproject/obs-studio#1300
2018-05-18 11:49:53 -07:00
int result = dstr_cmp(&core_module_paths.array[i], path);
if (result == 0) {
dstr_free(&core_module_paths.array[i]);
da_erase(core_module_paths, i);
return true;
}
}
return false;
}
libobs: Add profiler calls
2015-07-10 23:04:46 -07:00
static const char *obs_startup_name = "obs_startup";
(API Change) libobs: Add global module config path API Changed: --------------------------- From: - bool obs_startup(const char *locale, profiler_name_store_t *store); To: - bool obs_startup(const char *locale, const char *module_config_path, profiler_name_store_t *store); Summary: --------------------------- This allows plugin modules to store plugin-specific configuration data (rather than only allowing objects to store configuration data). This will be useful for things like caching data, for example looking up and storing ingests from remote (rather than storing locally), or caching font data (so it doesn't have to build a font cache each time), among other things. Also adds a module-specific directory for the UI
2015-08-09 05:09:07 -07:00
bool obs_startup(const char *locale, const char *module_config_path,
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
profiler_name_store_t *store)
first commit
2013-09-30 19:37:13 -07:00
{
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
bool success;
first commit
2013-09-30 19:37:13 -07:00
libobs: Add profiler calls
2015-07-10 23:04:46 -07:00
profile_start(obs_startup_name);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (obs) {
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
blog(LOG_WARNING, "Tried to call obs_startup more than once");
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
return false;
}
libobs: Add win32 crash handler A slightly refactored version of R1CH's crash handler, allows crash handling for windows which provides stack traces of all threads and a list of all loaded modules. Also shows the processor, windows version, and current libobs version.
2015-01-02 05:57:06 -08:00
#ifdef _WIN32
libobs: Robust COM initialization Qt seems to force STA, so it's misleading to ask for MTA and ignore the failure result, so just ask for STA. Also, don't uninitialize COM if initialization failed.
2019-11-24 09:46:41 -08:00
com_initialized = initialize_com();
libobs: Add win32 crash handler A slightly refactored version of R1CH's crash handler, allows crash handling for windows which provides stack traces of all threads and a list of all loaded modules. Also shows the processor, windows version, and current libobs version.
2015-01-02 05:57:06 -08:00
#endif
(API Change) libobs: Add global module config path API Changed: --------------------------- From: - bool obs_startup(const char *locale, profiler_name_store_t *store); To: - bool obs_startup(const char *locale, const char *module_config_path, profiler_name_store_t *store); Summary: --------------------------- This allows plugin modules to store plugin-specific configuration data (rather than only allowing objects to store configuration data). This will be useful for things like caching data, for example looking up and storing ingests from remote (rather than storing locally), or caching font data (so it doesn't have to build a font cache each time), among other things. Also adds a module-specific directory for the UI
2015-08-09 05:09:07 -07:00
success = obs_init(locale, module_config_path, store);
libobs: Add profiler calls
2015-07-10 23:04:46 -07:00
profile_end(obs_startup_name);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (!success)
obs_shutdown();
return success;
first commit
2013-09-30 19:37:13 -07:00
}
libobs/UI: Allow Access To argc/argv This paves the way for plugins to have access to the argc/argv used when spawning OBS. Notably, this will allow a patch to obs-browser that passes through command line arguments on macOS to CEF.
2018-07-03 14:31:27 -07:00
static struct obs_cmdline_args cmdline_args = {0, NULL};
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 obs_set_cmdline_args(int argc, const char *const *argv)
libobs/UI: Allow Access To argc/argv This paves the way for plugins to have access to the argc/argv used when spawning OBS. Notably, this will allow a patch to obs-browser that passes through command line arguments on macOS to CEF.
2018-07-03 14:31:27 -07:00
{
char *data;
size_t len;
int i;
/* Once argc is set (non-zero) we shouldn't call again */
if (cmdline_args.argc)
return;
cmdline_args.argc = argc;
/* Safely copy over argv */
len = 0;
for (i = 0; i < argc; i++)
len += strlen(argv[i]) + 1;
cmdline_args.argv = bmalloc(sizeof(char *) * (argc + 1) + len);
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
data = (char *)cmdline_args.argv + sizeof(char *) * (argc + 1);
libobs/UI: Allow Access To argc/argv This paves the way for plugins to have access to the argc/argv used when spawning OBS. Notably, this will allow a patch to obs-browser that passes through command line arguments on macOS to CEF.
2018-07-03 14:31:27 -07:00
for (i = 0; i < argc; i++) {
cmdline_args.argv[i] = data;
len = strlen(argv[i]) + 1;
memcpy(data, argv[i], len);
data += len;
}
cmdline_args.argv[argc] = NULL;
}
struct obs_cmdline_args obs_get_cmdline_args(void)
{
return cmdline_args;
}
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
void obs_shutdown(void)
first commit
2013-09-30 19:37:13 -07:00
{
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
struct obs_module *module;
first commit
2013-09-30 19:37:13 -07:00
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
obs_wait_for_destroy_queue();
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
for (size_t i = 0; i < obs->source_types.num; i++) {
struct obs_source_info *item = &obs->source_types.array[i];
if (item->type_data && item->free_type_data)
item->free_type_data(item->type_data);
if (item->id)
bfree((void *)item->id);
}
da_free(obs->source_types);
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
#define FREE_REGISTERED_TYPES(structure, list) \
do { \
for (size_t i = 0; i < list.num; i++) { \
struct structure *item = &list.array[i]; \
if (item->type_data && item->free_type_data) \
libobs: Add private data to definition structures This is useful for allowing the ability to have private data associated with the object type definition structures. This private data can be useful for things like plugin wrappers for other languages, or providing dynamically generated object types.
2015-09-15 22:39:11 -07:00
item->free_type_data(item->type_data); \
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
} \
da_free(list); \
libobs: Add private data to definition structures This is useful for allowing the ability to have private data associated with the object type definition structures. This private data can be useful for things like plugin wrappers for other languages, or providing dynamically generated object types.
2015-09-15 22:39:11 -07:00
} while (false)
FREE_REGISTERED_TYPES(obs_output_info, obs->output_types);
FREE_REGISTERED_TYPES(obs_encoder_info, obs->encoder_types);
FREE_REGISTERED_TYPES(obs_service_info, obs->service_types);
FREE_REGISTERED_TYPES(obs_modal_ui, obs->modal_ui_callbacks);
FREE_REGISTERED_TYPES(obs_modeless_ui, obs->modeless_ui_callbacks);
#undef FREE_REGISTERED_TYPES
first commit
2013-09-30 19:37:13 -07:00
libobs: Remove multiple calls to free_type_data
2017-03-29 19:41:47 -07:00
da_free(obs->input_types);
da_free(obs->filter_types);
da_free(obs->transition_types);
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
stop_video();
libobs: Add stop_audio function, change shutdown order This fixes a crash that could occur during freeing of sources, as the audio subsystem was destroyed before sources were released. If a source had monitoring enabled, it would try to lock a mutex that has been destroyed, resulting in a crash. Freeing audio after obs_free_data was also not a solution, as the main view is freed in obs_free_data, and the audio subsystem is still running and trying to lock the main view channel mutex which has been freed. This seems to be the best middle ground, making sure the audio subsystem is stopped so it no longer tries to access the main view channel, then freed after obs_free_data. Fixes https://github.com/obsproject/obs-studio/issues/4409
2021-05-06 16:52:52 -07:00
stop_audio();
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
stop_hotkeys();
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
libobs: Unload modules while OBS core is active Modules are now unloaded while OBS core is still active, allowing modules that call into libobs in their unload function to continue to work. This changes the behavior of such calls - previously they were a no-op since the OBS core would be gone, but they are now executed with the OBS core still being active.
2020-06-01 06:54:46 -07:00
module = obs->first_module;
while (module) {
struct obs_module *next = module->next;
free_module(module);
module = next;
}
obs->first_module = NULL;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
obs_free_data();
libobs: Add stop_audio function, change shutdown order This fixes a crash that could occur during freeing of sources, as the audio subsystem was destroyed before sources were released. If a source had monitoring enabled, it would try to lock a mutex that has been destroyed, resulting in a crash. Freeing audio after obs_free_data was also not a solution, as the main view is freed in obs_free_data, and the audio subsystem is still running and trying to lock the main view channel mutex which has been freed. This seems to be the best middle ground, making sure the audio subsystem is stopped so it no longer tries to access the main view channel, then freed after obs_free_data. Fixes https://github.com/obsproject/obs-studio/issues/4409
2021-05-06 16:52:52 -07:00
obs_free_audio();
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
obs_free_video();
libobs: Fix destruction order for destruction task queue Destruction of the task queue should probably happen after the audio and video threads have been destroyed and all audio/video processing has stopped.
2021-12-21 11:46:42 -08:00
os_task_queue_destroy(obs->destruction_task_thread);
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
obs_free_hotkeys();
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
obs_free_graphics();
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
proc_handler_destroy(obs->procs);
signal_handler_destroy(obs->signals);
libobs: Set core signal handlers to NULL after destroying Fixes https://obsproject.com/mantis/view.php?id=595
2016-08-21 18:00:07 -07:00
obs->procs = NULL;
obs->signals = NULL;
first commit
2013-09-30 19:37:13 -07:00
libobs: Unload modules while OBS core is active Modules are now unloaded while OBS core is still active, allowing modules that call into libobs in their unload function to continue to work. This changes the behavior of such calls - previously they were a no-op since the OBS core would be gone, but they are now executed with the OBS core still being active.
2020-06-01 06:54:46 -07:00
for (size_t i = 0; i < obs->module_paths.num; i++)
free_module_path(obs->module_paths.array + i);
da_free(obs->module_paths);
first commit
2013-09-30 19:37:13 -07:00
libobs: Unload modules while OBS core is active Modules are now unloaded while OBS core is still active, allowing modules that call into libobs in their unload function to continue to work. This changes the behavior of such calls - previously they were a no-op since the OBS core would be gone, but they are now executed with the OBS core still being active.
2020-06-01 06:54:46 -07:00
if (obs->name_store_owned)
profiler_name_store_free(obs->name_store);
(API Change) libobs: Add profile_name_store_t parameter to obs_startup Due to all the threads in libobs it wouldn't be safe to make that parameter reconfigurable after libobs is initialized without adding even more synchronization. On the other hand, adding a function to set the name store before calling obs_startup would solve the problem of passing a name store into libobs, but it can lead to more complicated semantics for obs_get_profiler_name_store (e.g., should it always return the current name store even if libobs isn't initialized until someone calls set_name_store(NULL)? should obs_shutdown call set_name_store(NULL)? Passing it as obs_startup parameter avoids these (and hopefully other) potential misunderstandings
2015-08-02 03:06:00 -07:00
libobs: Unload modules while OBS core is active Modules are now unloaded while OBS core is still active, allowing modules that call into libobs in their unload function to continue to work. This changes the behavior of such calls - previously they were a no-op since the OBS core would be gone, but they are now executed with the OBS core still being active.
2020-06-01 06:54:46 -07:00
bfree(obs->module_config_path);
bfree(obs->locale);
bfree(obs);
obs = NULL;
libobs/UI: Allow Access To argc/argv This paves the way for plugins to have access to the argc/argv used when spawning OBS. Notably, this will allow a patch to obs-browser that passes through command line arguments on macOS to CEF.
2018-07-03 14:31:27 -07:00
bfree(cmdline_args.argv);
libobs: Call CoInitializeEx in libobs Due to the fact that certain modules may need COM on startup, initialize COM by default in libobs.
2015-09-22 11:27:38 -07:00
#ifdef _WIN32
libobs: Robust COM initialization Qt seems to force STA, so it's misleading to ask for MTA and ignore the failure result, so just ask for STA. Also, don't uninitialize COM if initialization failed.
2019-11-24 09:46:41 -08:00
if (com_initialized)
uninitialize_com();
libobs: Call CoInitializeEx in libobs Due to the fact that certain modules may need COM on startup, initialize COM by default in libobs.
2015-09-22 11:27:38 -07:00
#endif
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
}
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
bool obs_initialized(void)
{
return obs != NULL;
}
Add function to get current core version The version macro that modules use to compile versus the actual core version that may be in use may be different, so this is a way to compare them to check for compatibility issues later on.
2014-07-27 09:43:32 -07:00
uint32_t obs_get_version(void)
{
return LIBOBS_API_VER;
}
libobs: Add API function to get version string Some plugins are using the OBS_VERSION macro obs-config.h to specify the current version, which will bake the string in to the plugin, making it so that if the plugin is not replaced for a patch, it could potentially have the incorrect version. This makes it so that a plugin/frontend can get the current version string that's baked in to libobs itself.
2017-07-31 13:52:08 -07:00
const char *obs_get_version_string(void)
{
return OBS_VERSION;
}
Add API for setting/getting current locale This API is used to set the current locale for libobs, which it will set for all modules when a module is loaded or specifically when the locale is manually changed.
2014-06-25 00:21:16 -07:00
void obs_set_locale(const char *locale)
{
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
struct obs_module *module;
Add API for setting/getting current locale This API is used to set the current locale for libobs, which it will set for all modules when a module is loaded or specifically when the locale is manually changed.
2014-06-25 00:21:16 -07:00
if (obs->locale)
bfree(obs->locale);
obs->locale = bstrdup(locale);
Add module callbacks for loading locale data The module callback obs_module_set_locale will be called after loading the module, and any time the locale is manually changed via core API. When this function is called, the module is expected to load new text lookup values for all the text it uses based upon the current locale.
2014-06-25 00:22:54 -07:00
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
module = obs->first_module;
while (module) {
Add module callbacks for loading locale data The module callback obs_module_set_locale will be called after loading the module, and any time the locale is manually changed via core API. When this function is called, the module is expected to load new text lookup values for all the text it uses based upon the current locale.
2014-06-25 00:22:54 -07:00
if (module->set_locale)
module->set_locale(locale);
(API Change) Refactor module handling Changed API: - char *obs_find_plugin_file(const char *sub_path); Changed to: char *obs_module_file(const char *file); Cahnge it so you no longer need to specify a sub-path such as: obs_find_plugin_file("module_name/file.ext") Instead, now automatically handle the module data path so all you need to do is: obs_module_file("file.ext") - int obs_load_module(const char *name); Changed to: int obs_open_module(obs_module_t *module, const char *path, const char *data_path); bool obs_init_module(obs_module_t module); Change the module loading API so that if the front-end chooses, it can load modules directly from a specified path, and associate a data directory with it on the spot. The module will not be initialized immediately; obs_init_module must be called on the module pointer in order to fully initialize the module. This is done so a module can be disabled by the front-end if the it so chooses. New API: - void obs_add_module_path(const char *bin, const char *data); These functions allow you to specify new module search paths to add, and allow you to search through them, or optionally just load all modules from them. If the string %module% is included, it will replace it with the module's name when that string is used as a lookup. Data paths are now directly added to the module's internal storage structure, and when obs_find_module_file is used, it will look up the pointer to the obs_module structure and get its data directory that way. Example: obs_add_module_path("/opt/obs/my-modules/%module%/bin", "/opt/obs/my-modules/%module%/data"); This would cause it to additionally look for the binary of a hypthetical module named "foo" at /opt/obs/my-modules/foo/bin/foo.so (or libfoo.so), and then look for the data in /opt/obs/my-modules/foo/data. This gives the front-end more flexibility for handling third-party plugin modules, or handling all plugin modules in a custom way. - void obs_find_modules(obs_find_module_callback_t callback, void *param); This searches the existing paths for modules and calls the callback function when any are found. Useful for plugin management and custom handling of the paths by the front-end if desired. - void obs_load_all_modules(void); Search through the paths and both loads and initializes all modules automatically without custom handling. - void obs_enum_modules(obs_enum_module_callback_t callback, void *param); Enumerates currently opened modules.
2014-07-27 12:00:11 -07:00
module = module->next;
Add module callbacks for loading locale data The module callback obs_module_set_locale will be called after loading the module, and any time the locale is manually changed via core API. When this function is called, the module is expected to load new text lookup values for all the text it uses based upon the current locale.
2014-06-25 00:22:54 -07:00
}
Add API for setting/getting current locale This API is used to set the current locale for libobs, which it will set for all modules when a module is loaded or specifically when the locale is manually changed.
2014-06-25 00:21:16 -07:00
}
const char *obs_get_locale(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->locale;
Add API for setting/getting current locale This API is used to set the current locale for libobs, which it will set for all modules when a module is loaded or specifically when the locale is manually changed.
2014-06-25 00:21:16 -07:00
}
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
#define OBS_SIZE_MIN 2
#define OBS_SIZE_MAX (32 * 1024)
static inline bool size_valid(uint32_t width, uint32_t height)
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
{
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return (width >= OBS_SIZE_MIN && height >= OBS_SIZE_MIN &&
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
width <= OBS_SIZE_MAX && height <= OBS_SIZE_MAX);
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
}
int obs_reset_video(struct obs_video_info *ovi)
{
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
if (!obs)
return OBS_VIDEO_FAIL;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
/* don't allow changing of video settings if active. */
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (obs_video_active())
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_CURRENTLY_ACTIVE;
if (!size_valid(ovi->output_width, ovi->output_height) ||
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
!size_valid(ovi->base_width, ovi->base_height))
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return OBS_VIDEO_INVALID_PARAM;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
stop_video();
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
obs_free_video();
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
Fix potentially dereferenced null pointer
2014-07-13 05:01:53 -07:00
/* align to multiple-of-two and SSE alignment sizes */
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
ovi->output_width &= 0xFFFFFFFC;
Fix potentially dereferenced null pointer
2014-07-13 05:01:53 -07:00
ovi->output_height &= 0xFFFFFFFE;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (!obs->video.graphics) {
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
int errorcode = obs_init_graphics(ovi);
Free graphics subsystem if graphics fails to load The graphics subsystem was not being freed here, for example if a required effect failed to compile it would still successfully have the graphics subsystem sans required effect. The graphics subsystem should be completely shut down if required libobs effects fail to compile.
2014-10-14 01:44:59 -07:00
if (errorcode != OBS_VIDEO_SUCCESS) {
obs_free_graphics();
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
return errorcode;
Free graphics subsystem if graphics fails to load The graphics subsystem was not being freed here, for example if a required effect failed to compile it would still successfully have the graphics subsystem sans required effect. The graphics subsystem should be completely shut down if required libobs effects fail to compile.
2014-10-14 01:44:59 -07:00
}
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
}
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
libobs: Add downscale filter to log
2016-09-22 21:18:06 -07:00
const char *scale_type_name = "";
switch (ovi->scale_type) {
case OBS_SCALE_DISABLE:
scale_type_name = "Disabled";
break;
case OBS_SCALE_POINT:
scale_type_name = "Point";
break;
case OBS_SCALE_BICUBIC:
scale_type_name = "Bicubic";
break;
case OBS_SCALE_BILINEAR:
scale_type_name = "Bilinear";
break;
case OBS_SCALE_LANCZOS:
scale_type_name = "Lanczos";
break;
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
case OBS_SCALE_AREA:
scale_type_name = "Area";
break;
libobs: Add downscale filter to log
2016-09-22 21:18:06 -07:00
}
libobs: Log YUV space/range on video reset Closes jp9000/obs-studio#1196
2018-02-11 21:20:18 -08:00
bool yuv = format_is_yuv(ovi->output_format);
const char *yuv_format = get_video_colorspace_name(ovi->colorspace);
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
const char *yuv_range =
get_video_range_name(ovi->output_format, ovi->range);
libobs: Log YUV space/range on video reset Closes jp9000/obs-studio#1196
2018-02-11 21:20:18 -08:00
libobs: Add log separators to video/audio resets
2015-07-05 23:51:16 -07:00
blog(LOG_INFO, "---------------------------------");
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
blog(LOG_INFO,
"video settings reset:\n"
"\tbase resolution: %dx%d\n"
"\toutput resolution: %dx%d\n"
"\tdownscale filter: %s\n"
"\tfps: %d/%d\n"
"\tformat: %s\n"
"\tYUV mode: %s%s%s",
ovi->base_width, ovi->base_height, ovi->output_width,
ovi->output_height, scale_type_name, ovi->fps_num, ovi->fps_den,
get_video_format_name(ovi->output_format),
yuv ? yuv_format : "None", yuv ? "/" : "", yuv ? yuv_range : "");
Log audio/video settings
2014-07-13 05:02:44 -07:00
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
return obs_init_video(ovi);
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
}
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
#ifndef SEC_TO_MSEC
#define SEC_TO_MSEC 1000
#endif
bool obs_reset_audio2(const struct obs_audio_info2 *oai)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
struct obs_core_audio *audio = &obs->audio;
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
struct audio_output_info ai;
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
/* don't allow changing of audio settings if active. */
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
if (!obs || (audio->audio && audio_output_active(audio->audio)))
Fix video reset and apply new video settings This allows the changing of bideo settings without having to completely reset all graphics data. Will recreate internal output/conversion buffers and such and reset the main preview.
2014-02-22 19:14:19 -08:00
return false;
Add preliminary audio processing - Mixing still isn't implemented, but the audio system should be able to start up, and mix at least once audio line for the time being. Will have to write some test audio sources to verify things are working properly, and build the rest of the output functionality.
2014-01-09 18:08:20 -08:00
obs_free_audio();
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
if (!oai)
made it so that graphics device and associated objects are not lost every time video settings are changed
2013-11-26 21:20:11 -08:00
return true;
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
if (oai->max_buffering_ms) {
uint32_t max_frames = oai->max_buffering_ms *
oai->samples_per_sec / SEC_TO_MSEC;
max_frames += (AUDIO_OUTPUT_FRAMES - 1);
audio->max_buffering_ticks = max_frames / AUDIO_OUTPUT_FRAMES;
} else {
audio->max_buffering_ticks = 45;
}
audio->fixed_buffer = oai->fixed_buffering;
int max_buffering_ms = audio->max_buffering_ticks *
AUDIO_OUTPUT_FRAMES * SEC_TO_MSEC /
(int)oai->samples_per_sec;
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
ai.name = "Audio";
ai.samples_per_sec = oai->samples_per_sec;
ai.format = AUDIO_FORMAT_FLOAT_PLANAR;
ai.speakers = oai->speakers;
libobs: Implement new audio subsystem The new audio subsystem fixes two issues: - First Primary issue it fixes is the ability for parent sources to intercept the audio of child sources, and do custom processing on them. The main reason for this was the ability to do custom cross-fading in transitions, but it's also useful for things such as side-chain effects, applying audio effects to entire scenes, applying scene-specific audio filters on sub-sources, and other such possibilities. - The secondary issue that needed fixing was audio buffering. Previously, audio buffering was always a fixed buffer size, so it would always have exactly a certain number of milliseconds of audio buffering (and thus output delay). Instead, it now dynamically increases audio buffering only as necessary, minimizing output delay, and removing the need for users to have to worry about an audio buffering setting. The new design makes it so that audio from the leaves of the scene graph flow to the root nodes, and can be intercepted by parent sources. Each audio source handles its own buffering, and each audio tick a specific number of audio frames are popped from the front of the circular buffer on each audio source. Composite sources (such as scenes) can access the audio for child sources and do custom processing or mixing on that audio. Composite sources use the audio_render callback of sources to do synchronous or deferred audio processing per audio tick. Things like scenes now mix audio from their sub-sources.
2015-12-20 03:06:35 -08:00
ai.input_callback = audio_callback;
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
libobs: Add log separators to video/audio resets
2015-07-05 23:51:16 -07:00
blog(LOG_INFO, "---------------------------------");
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
blog(LOG_INFO,
"audio settings reset:\n"
"\tsamples per sec: %d\n"
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
"\tspeakers: %d\n"
"\tmax buffering: %d milliseconds\n"
"\tbuffering type: %s",
(int)ai.samples_per_sec, (int)ai.speakers, max_buffering_ms,
oai->fixed_buffering ? "fixed" : "dynamically increasing");
Log audio/video settings
2014-07-13 05:02:44 -07:00
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
return obs_init_audio(&ai);
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Add ability to configure audio buffering latency Allows a frontend the ability to set the maximum audio buffering latency, and specify whether that audio buffering is either fixed (to the maximum audio buffering latency), or dynamically increasing from 0. This will be useful if the user wishes to output audio to devices or through a virtual audio device at a guaranteed minimal latency.
2022-04-24 08:43:12 -07:00
bool obs_reset_audio(const struct obs_audio_info *oai)
{
struct obs_audio_info2 oai2 = {
.samples_per_sec = oai->samples_per_sec,
.speakers = oai->speakers,
};
return obs_reset_audio2(&oai2);
}
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
bool obs_get_video_info(struct obs_video_info *ovi)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (!obs->video.graphics)
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
return false;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
*ovi = obs->video.ovi;
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
return true;
}
libobs, UI: Add SDR white nits option
2022-02-20 20:31:30 -08:00
float obs_get_video_sdr_white_level(void)
{
struct obs_core_video *video = &obs->video;
return video->graphics ? video->sdr_white_level : 300.f;
}
libobs,UI: Support HLG nominal peak level HLG output uses MovieLabs-recommended procedure. - If peak luminance is greater than 1000, use maxRGB EETF to 1000. - Otherwise, don't tonemap. - Then use normal HLG conversion procedure with gamma 1.2 (1000 nits).
2022-04-10 12:31:08 -07:00
float obs_get_video_hdr_nominal_peak_level(void)
{
struct obs_core_video *video = &obs->video;
return video->graphics ? video->hdr_nominal_peak_level : 1000.f;
}
void obs_set_video_levels(float sdr_white_level, float hdr_nominal_peak_level)
libobs, UI: Add SDR white nits option
2022-02-20 20:31:30 -08:00
{
struct obs_core_video *video = &obs->video;
assert(video->graphics);
libobs,UI: Support HLG nominal peak level HLG output uses MovieLabs-recommended procedure. - If peak luminance is greater than 1000, use maxRGB EETF to 1000. - Otherwise, don't tonemap. - Then use normal HLG conversion procedure with gamma 1.2 (1000 nits).
2022-04-10 12:31:08 -07:00
video->sdr_white_level = sdr_white_level;
video->hdr_nominal_peak_level = hdr_nominal_peak_level;
libobs, UI: Add SDR white nits option
2022-02-20 20:31:30 -08:00
}
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
bool obs_get_audio_info(struct obs_audio_info *oai)
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
{
Improve naming scheme of libobs core structures
2014-02-05 20:03:06 -08:00
struct obs_core_audio *audio = &obs->audio;
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
const struct audio_output_info *info;
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
if (!oai || !audio->audio)
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
return false;
(API Change) media-io: Improve naming consistency Renamed: To: ----------------------------------------------------------- audio_output_blocksize audio_output_get_block_size audio_output_planes audio_output_get_planes audio_output_channels audio_output_get_channels audio_output_samplerate audio_output_get_sample_rate audio_output_getinfo audio_output_get_info audio_output_createline audio_output_create_line video_output_getinfo video_output_get_info video_gettime video_output_get_time video_getframetime video_output_get_frame_time video_output_width video_output_get_width video_output_height video_output_get_height video_output_framerate video_output_get_frame_rate video_output_num_skipped_frames video_output_get_skipped_frames video_output_total_frames video_output_get_total_frames
2014-08-05 15:07:54 -07:00
info = audio_output_get_info(audio->audio);
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
(API Change) Always use planar float audio output Core API functions changed: ----------------------------- EXPORT bool obs_reset_audio(struct audio_output_info *aoi); EXPORT bool obs_get_audio_info(struct audio_output_info *aoi); To: ----------------------------- EXPORT bool obs_reset_audio(const struct obs_audio_info *oai); EXPORT bool obs_get_audio_info(struct obs_audio_info *oai); Core structure added: ----------------------------- struct obs_audio_info { uint32_t samples_per_sec; enum speaker_layout speakers; uint64_t buffer_ms; }; Non-interleaved (planar) floating point output is standard with audio filtering, so to prevent audio filters from having to worry about different audio format implementations and for the sake consistency between user interfaces, make it so that audio is always set to non-interleaved floating point output.
2015-03-07 04:47:12 -08:00
oai->samples_per_sec = info->samples_per_sec;
oai->speakers = info->speakers;
added functions to get current audio/video output information
2013-12-06 05:38:19 -08:00
return true;
}
libobs: Add function to enumerate all source types
2015-12-29 16:08:36 -08:00
bool obs_enum_source_types(size_t idx, const char **id)
{
if (idx >= obs->source_types.num)
return false;
*id = obs->source_types.array[idx].id;
return true;
}
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
bool obs_enum_input_types(size_t idx, const char **id)
first commit
2013-09-30 19:37:13 -07:00
{
if (idx >= obs->input_types.num)
return false;
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
*id = obs->input_types.array[idx].id;
first commit
2013-09-30 19:37:13 -07:00
return true;
}
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
bool obs_enum_input_types2(size_t idx, const char **id,
const char **unversioned_id)
{
if (idx >= obs->input_types.num)
return false;
if (id)
*id = obs->input_types.array[idx].id;
if (unversioned_id)
*unversioned_id = obs->input_types.array[idx].unversioned_id;
return true;
}
const char *obs_get_latest_input_type_id(const char *unversioned_id)
{
struct obs_source_info *latest = NULL;
int version = -1;
if (!unversioned_id)
libobs: Don't return false, return NULL
2020-03-09 16:42:50 -07:00
return NULL;
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
libobs: Fix crash when querying versioned id The wrong array was used, thus it couldn't find "group" or "scene".
2020-03-09 16:37:46 -07:00
for (size_t i = 0; i < obs->source_types.num; i++) {
struct obs_source_info *info = &obs->source_types.array[i];
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
if (strcmp(info->unversioned_id, unversioned_id) == 0 &&
(int)info->version > version) {
latest = info;
version = info->version;
}
}
assert(!!latest);
if (!latest)
return NULL;
return latest->id;
}
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
bool obs_enum_filter_types(size_t idx, const char **id)
first commit
2013-09-30 19:37:13 -07:00
{
if (idx >= obs->filter_types.num)
return false;
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
*id = obs->filter_types.array[idx].id;
first commit
2013-09-30 19:37:13 -07:00
return true;
}
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
bool obs_enum_transition_types(size_t idx, const char **id)
first commit
2013-09-30 19:37:13 -07:00
{
if (idx >= obs->transition_types.num)
return false;
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
*id = obs->transition_types.array[idx].id;
first commit
2013-09-30 19:37:13 -07:00
return true;
}
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
bool obs_enum_output_types(size_t idx, const char **id)
first commit
2013-09-30 19:37:13 -07:00
{
if (idx >= obs->output_types.num)
return false;
add names to sources, use 'id' for the internal source identifier names rather than 'name'
2013-12-20 16:23:19 -08:00
*id = obs->output_types.array[idx].id;
first commit
2013-09-30 19:37:13 -07:00
return true;
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
bool obs_enum_encoder_types(size_t idx, const char **id)
{
if (idx >= obs->encoder_types.num)
return false;
*id = obs->encoder_types.array[idx].id;
return true;
}
bool obs_enum_service_types(size_t idx, const char **id)
{
if (idx >= obs->service_types.num)
return false;
*id = obs->service_types.array[idx].id;
return true;
}
(API Change) Remove obs_graphics() API Removed: - graphics_t obs_graphics(); Replaced With: - void obs_enter_graphics(); - void obs_leave_graphics(); Description: obs_graphics() was somewhat of a pointless function. The only time that it was ever necessary was to pass it as a parameter to gs_entercontext() followed by a subsequent gs_leavecontext() call after that. So, I felt that it made a bit more sense just to implement obs_enter_graphics() and obs_leave_graphics() functions to do the exact same thing without having to repeat that code. There's really no need to ever "hold" the graphics pointer, though I suppose that could change in the future so having a similar function come back isn't out of the question. Still, this at least reduces the amount of unnecessary repeated code for the time being.
2014-08-04 05:48:58 -07:00
void obs_enter_graphics(void)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
if (obs->video.graphics)
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_enter_context(obs->video.graphics);
(API Change) Remove obs_graphics() API Removed: - graphics_t obs_graphics(); Replaced With: - void obs_enter_graphics(); - void obs_leave_graphics(); Description: obs_graphics() was somewhat of a pointless function. The only time that it was ever necessary was to pass it as a parameter to gs_entercontext() followed by a subsequent gs_leavecontext() call after that. So, I felt that it made a bit more sense just to implement obs_enter_graphics() and obs_leave_graphics() functions to do the exact same thing without having to repeat that code. There's really no need to ever "hold" the graphics pointer, though I suppose that could change in the future so having a similar function come back isn't out of the question. Still, this at least reduces the amount of unnecessary repeated code for the time being.
2014-08-04 05:48:58 -07:00
}
void obs_leave_graphics(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
if (obs->video.graphics)
(API Change) Improve graphics API consistency Summary: - Prefix all graphics subsystem names with gs_ or GS_ - Unsquish funciton names (for example _setfloat to _set_float) - Changed create functions to be more consistent with the rest of the API elsewhere. For exmaple, instead of gs_create_texture/gs_texture_destroy, it's now gs_texture_create/gs_texture_destroy - Renamed gs_stencil_op enum to gs_stencil_op_type From: To: ----------------------------------------------------------- tvertarray gs_tvertarray vb_data gs_vb_data vbdata_create gs_vbdata_create vbdata_destroy gs_vbdata_destroy shader_param gs_shader_param gs_effect gs_effect effect_technique gs_effect_technique effect_pass gs_effect_pass effect_param gs_effect_param texture_t gs_texture_t stagesurf_t gs_stagesurf_t zstencil_t gs_zstencil_t vertbuffer_t gs_vertbuffer_t indexbuffer_t gs_indexbuffer_t samplerstate_t gs_samplerstate_t swapchain_t gs_swapchain_t texrender_t gs_texrender_t shader_t gs_shader_t sparam_t gs_sparam_t effect_t gs_effect_t technique_t gs_technique_t eparam_t gs_eparam_t device_t gs_device_t graphics_t graphics_t shader_param_type gs_shader_param_type SHADER_PARAM_UNKNOWN GS_SHADER_PARAM_UNKNOWN SHADER_PARAM_BOOL GS_SHADER_PARAM_BOOL SHADER_PARAM_FLOAT GS_SHADER_PARAM_FLOAT SHADER_PARAM_INT GS_SHADER_PARAM_INT SHADER_PARAM_STRING GS_SHADER_PARAM_STRING SHADER_PARAM_VEC2 GS_SHADER_PARAM_VEC2 SHADER_PARAM_VEC3 GS_SHADER_PARAM_VEC3 SHADER_PARAM_VEC4 GS_SHADER_PARAM_VEC4 SHADER_PARAM_MATRIX4X4 GS_SHADER_PARAM_MATRIX4X4 SHADER_PARAM_TEXTURE GS_SHADER_PARAM_TEXTURE shader_param_info gs_shader_param_info shader_type gs_shader_type SHADER_VERTEX GS_SHADER_VERTEX SHADER_PIXEL GS_SHADER_PIXEL shader_destroy gs_shader_destroy shader_numparams gs_shader_get_num_params shader_getparambyidx gs_shader_get_param_by_idx shader_getparambyname gs_shader_get_param_by_name shader_getviewprojmatrix gs_shader_get_viewproj_matrix shader_getworldmatrix gs_shader_get_world_matrix shader_getparaminfo gs_shader_get_param_info shader_setbool gs_shader_set_bool shader_setfloat gs_shader_set_float shader_setint gs_shader_set_int shader_setmatrix3 gs_shader_setmatrix3 shader_setmatrix4 gs_shader_set_matrix4 shader_setvec2 gs_shader_set_vec2 shader_setvec3 gs_shader_set_vec3 shader_setvec4 gs_shader_set_vec4 shader_settexture gs_shader_set_texture shader_setval gs_shader_set_val shader_setdefault gs_shader_set_default effect_property_type gs_effect_property_type EFFECT_NONE GS_EFFECT_NONE EFFECT_BOOL GS_EFFECT_BOOL EFFECT_FLOAT GS_EFFECT_FLOAT EFFECT_COLOR GS_EFFECT_COLOR EFFECT_TEXTURE GS_EFFECT_TEXTURE effect_param_info gs_effect_param_info effect_destroy gs_effect_destroy effect_gettechnique gs_effect_get_technique technique_begin gs_technique_begin technique_end gs_technique_end technique_beginpass gs_technique_begin_pass technique_beginpassbyname gs_technique_begin_pass_by_name technique_endpass gs_technique_end_pass effect_numparams gs_effect_get_num_params effect_getparambyidx gs_effect_get_param_by_idx effect_getparambyname gs_effect_get_param_by_name effect_updateparams gs_effect_update_params effect_getviewprojmatrix gs_effect_get_viewproj_matrix effect_getworldmatrix gs_effect_get_world_matrix effect_getparaminfo gs_effect_get_param_info effect_setbool gs_effect_set_bool effect_setfloat gs_effect_set_float effect_setint gs_effect_set_int effect_setmatrix4 gs_effect_set_matrix4 effect_setvec2 gs_effect_set_vec2 effect_setvec3 gs_effect_set_vec3 effect_setvec4 gs_effect_set_vec4 effect_settexture gs_effect_set_texture effect_setval gs_effect_set_val effect_setdefault gs_effect_set_default texrender_create gs_texrender_create texrender_destroy gs_texrender_destroy texrender_begin gs_texrender_begin texrender_end gs_texrender_end texrender_reset gs_texrender_reset texrender_gettexture gs_texrender_get_texture GS_BUILDMIPMAPS GS_BUILD_MIPMAPS GS_RENDERTARGET GS_RENDER_TARGET gs_device_name gs_get_device_name gs_device_type gs_get_device_type gs_entercontext gs_enter_context gs_leavecontext gs_leave_context gs_getcontext gs_get_context gs_renderstart gs_render_start gs_renderstop gs_render_stop gs_rendersave gs_render_save gs_getinput gs_get_input gs_geteffect gs_get_effect gs_create_effect_from_file gs_effect_create_from_file gs_create_effect gs_effect_create gs_create_vertexshader_from_file gs_vertexshader_create_from_file gs_create_pixelshader_from_file gs_pixelshader_create_from_file gs_create_texture_from_file gs_texture_create_from_file gs_resetviewport gs_reset_viewport gs_set2dmode gs_set_2d_mode gs_set3dmode gs_set_3d_mode gs_create_swapchain gs_swapchain_create gs_getsize gs_get_size gs_getwidth gs_get_width gs_getheight gs_get_height gs_create_texture gs_texture_create gs_create_cubetexture gs_cubetexture_create gs_create_volumetexture gs_voltexture_create gs_create_zstencil gs_zstencil_create gs_create_stagesurface gs_stagesurface_create gs_create_samplerstate gs_samplerstate_create gs_create_vertexshader gs_vertexshader_create gs_create_pixelshader gs_pixelshader_create gs_create_vertexbuffer gs_vertexbuffer_create gs_create_indexbuffer gs_indexbuffer_create gs_gettexturetype gs_get_texture_type gs_load_defaultsamplerstate gs_load_default_samplerstate gs_getvertexshader gs_get_vertex_shader gs_getpixelshader gs_get_pixel_shader gs_getrendertarget gs_get_render_target gs_getzstenciltarget gs_get_zstencil_target gs_setrendertarget gs_set_render_target gs_setcuberendertarget gs_set_cube_render_target gs_beginscene gs_begin_scene gs_draw gs_draw gs_endscene gs_end_scene gs_setcullmode gs_set_cull_mode gs_getcullmode gs_get_cull_mode gs_enable_depthtest gs_enable_depth_test gs_enable_stenciltest gs_enable_stencil_test gs_enable_stencilwrite gs_enable_stencil_write gs_blendfunction gs_blend_function gs_depthfunction gs_depth_function gs_stencilfunction gs_stencil_function gs_stencilop gs_stencil_op gs_setviewport gs_set_viewport gs_getviewport gs_get_viewport gs_setscissorrect gs_set_scissor_rect gs_create_texture_from_iosurface gs_texture_create_from_iosurface gs_create_gdi_texture gs_texture_create_gdi gs_is_compressed_format gs_is_compressed_format gs_num_total_levels gs_get_total_levels texture_setimage gs_texture_set_image cubetexture_setimage gs_cubetexture_set_image swapchain_destroy gs_swapchain_destroy texture_destroy gs_texture_destroy texture_getwidth gs_texture_get_width texture_getheight gs_texture_get_height texture_getcolorformat gs_texture_get_color_format texture_map gs_texture_map texture_unmap gs_texture_unmap texture_isrect gs_texture_is_rect texture_getobj gs_texture_get_obj cubetexture_destroy gs_cubetexture_destroy cubetexture_getsize gs_cubetexture_get_size cubetexture_getcolorformat gs_cubetexture_get_color_format volumetexture_destroy gs_voltexture_destroy volumetexture_getwidth gs_voltexture_get_width volumetexture_getheight gs_voltexture_get_height volumetexture_getdepth gs_voltexture_getdepth volumetexture_getcolorformat gs_voltexture_get_color_format stagesurface_destroy gs_stagesurface_destroy stagesurface_getwidth gs_stagesurface_get_width stagesurface_getheight gs_stagesurface_get_height stagesurface_getcolorformat gs_stagesurface_get_color_format stagesurface_map gs_stagesurface_map stagesurface_unmap gs_stagesurface_unmap zstencil_destroy gs_zstencil_destroy samplerstate_destroy gs_samplerstate_destroy vertexbuffer_destroy gs_vertexbuffer_destroy vertexbuffer_flush gs_vertexbuffer_flush vertexbuffer_getdata gs_vertexbuffer_get_data indexbuffer_destroy gs_indexbuffer_destroy indexbuffer_flush gs_indexbuffer_flush indexbuffer_getdata gs_indexbuffer_get_data indexbuffer_numindices gs_indexbuffer_get_num_indices indexbuffer_gettype gs_indexbuffer_get_type texture_rebind_iosurface gs_texture_rebind_iosurface texture_get_dc gs_texture_get_dc texture_release_dc gs_texture_release_dc
2014-08-07 23:42:07 -07:00
gs_leave_context();
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
audio_t *obs_get_audio(void)
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->audio.audio;
Simplify media i/o interfaces Completely revamped the entire media i/o data and handlers. The original idea was to have a system that would have connecting media inputs and outputs, but at a certain point I realized that this was an unnecessary complexity for what we wanted to do. (Also, it reminded me of directshow filters, and I HATE directshow with a passion, and wouldn't wish it upon my greatest enemy) Now, audio/video outputs are connected to directly, with better callback handlers, and will eventually have the ability to automatically handle conversions such as 4:4:4 to 4:2:0 when connecting to an input that uses them. Doing this will allow the video/audio i/o handlers to also prevent duplicate conversion, as well as make it easier/simple to use. My true goal for this is to make output and encoder plugins as simple to create as possible. I want to be able to be able to create an output plugin with almost no real hassle of having to worry about image conversions, media inputs/outputs, etc. A plugin developer shouldn't have to handle that sort of stuff when he/she doesn't really need to. Plugins will be able to simply create a callback via obs_video() and/or obs_audio(), and they will automatically receive the audio/video data in the formats requested via a simple callback, without needing to do almost anything else at all.
2014-01-14 00:58:47 -08:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
video_t *obs_get_video(void)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
return obs->video.main_mix->video;
first commit
2013-09-30 19:37:13 -07:00
}
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
/* TODO: optimize this later so it's not just O(N) string lookups */
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
static inline struct obs_modal_ui *
get_modal_ui_callback(const char *id, const char *task, const char *target)
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
{
Revamp API and start using doxygen The API used to be designed in such a way to where it would expect exports for each individual source/output/encoder/etc. You would export functions for each and it would automatically load those functions based on a specific naming scheme from the module. The idea behind this was that I wanted to limit the usage of structures in the API so only functions could be used. It was an interesting idea in theory, but this idea turned out to be flawed in a number of ways: 1.) Requiring exports to create sources/outputs/encoders/etc meant that you could not create them by any other means, which meant that things like faruton's .net plugin would become difficult. 2.) Export function declarations could not be checked, therefore if you created a function with the wrong parameters and parameter types, the compiler wouldn't know how to check for that. 3.) Required overly complex load functions in libobs just to handle it. It makes much more sense to just have a load function that you call manually. Complexity is the bane of all good programs. 4.) It required that you have functions of specific names, which looked and felt somewhat unsightly. So, to fix these issues, I replaced it with a more commonly used API scheme, seen commonly in places like kernels and typical C libraries with abstraction. You simply create a structure that contains the callback definitions, and you pass it to a function to register that definition (such as obs_register_source), which you call in the obs_module_load of the module. It will also automatically check the structure size and ensure that it only loads the required values if the structure happened to add new values in an API change. The "main" source file for each module must include obs-module.h, and must use OBS_DECLARE_MODULE() within that source file. Also, started writing some doxygen documentation in to the main library headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
for (size_t i = 0; i < obs->modal_ui_callbacks.num; i++) {
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
struct obs_modal_ui *callback =
obs->modal_ui_callbacks.array + i;
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08: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
if (strcmp(callback->id, id) == 0 &&
strcmp(callback->task, task) == 0 &&
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
strcmp(callback->target, target) == 0)
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
return callback;
}
return NULL;
}
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
static inline struct obs_modeless_ui *
get_modeless_ui_callback(const char *id, const char *task, const char *target)
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
{
Revamp API and start using doxygen The API used to be designed in such a way to where it would expect exports for each individual source/output/encoder/etc. You would export functions for each and it would automatically load those functions based on a specific naming scheme from the module. The idea behind this was that I wanted to limit the usage of structures in the API so only functions could be used. It was an interesting idea in theory, but this idea turned out to be flawed in a number of ways: 1.) Requiring exports to create sources/outputs/encoders/etc meant that you could not create them by any other means, which meant that things like faruton's .net plugin would become difficult. 2.) Export function declarations could not be checked, therefore if you created a function with the wrong parameters and parameter types, the compiler wouldn't know how to check for that. 3.) Required overly complex load functions in libobs just to handle it. It makes much more sense to just have a load function that you call manually. Complexity is the bane of all good programs. 4.) It required that you have functions of specific names, which looked and felt somewhat unsightly. So, to fix these issues, I replaced it with a more commonly used API scheme, seen commonly in places like kernels and typical C libraries with abstraction. You simply create a structure that contains the callback definitions, and you pass it to a function to register that definition (such as obs_register_source), which you call in the obs_module_load of the module. It will also automatically check the structure size and ensure that it only loads the required values if the structure happened to add new values in an API change. The "main" source file for each module must include obs-module.h, and must use OBS_DECLARE_MODULE() within that source file. Also, started writing some doxygen documentation in to the main library headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
for (size_t i = 0; i < obs->modeless_ui_callbacks.num; i++) {
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
struct obs_modeless_ui *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
callback = obs->modeless_ui_callbacks.array + i;
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08: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
if (strcmp(callback->id, id) == 0 &&
strcmp(callback->task, task) == 0 &&
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
strcmp(callback->target, target) == 0)
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
return callback;
}
return NULL;
}
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
int obs_exec_ui(const char *name, const char *task, const char *target,
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
void *data, void *ui_data)
{
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
struct obs_modal_ui *callback;
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
int errorcode = OBS_UI_NOTFOUND;
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
if (!obs)
return errorcode;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
callback = get_modal_ui_callback(name, task, target);
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
if (callback) {
Revamp API and start using doxygen The API used to be designed in such a way to where it would expect exports for each individual source/output/encoder/etc. You would export functions for each and it would automatically load those functions based on a specific naming scheme from the module. The idea behind this was that I wanted to limit the usage of structures in the API so only functions could be used. It was an interesting idea in theory, but this idea turned out to be flawed in a number of ways: 1.) Requiring exports to create sources/outputs/encoders/etc meant that you could not create them by any other means, which meant that things like faruton's .net plugin would become difficult. 2.) Export function declarations could not be checked, therefore if you created a function with the wrong parameters and parameter types, the compiler wouldn't know how to check for that. 3.) Required overly complex load functions in libobs just to handle it. It makes much more sense to just have a load function that you call manually. Complexity is the bane of all good programs. 4.) It required that you have functions of specific names, which looked and felt somewhat unsightly. So, to fix these issues, I replaced it with a more commonly used API scheme, seen commonly in places like kernels and typical C libraries with abstraction. You simply create a structure that contains the callback definitions, and you pass it to a function to register that definition (such as obs_register_source), which you call in the obs_module_load of the module. It will also automatically check the structure size and ensure that it only loads the required values if the structure happened to add new values in an API change. The "main" source file for each module must include obs-module.h, and must use OBS_DECLARE_MODULE() within that source file. Also, started writing some doxygen documentation in to the main library headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
bool success = callback->exec(data, ui_data);
Add module UI export capability Add the ability to be able to call and use toolkit-specific or program-specific user interface in modules. User interface code can be either bundled with the module, or 'split' out in to separate libraries (recommended). There are three reasons why splitting is recommended: 1.) It allows plugins to be able to create custom user interface for each toolkit if desired. 2.) Often, UI will be programmed in one language (the language of the toolkit), and core logic may be programmed in another. This allows plugins to keep the languages separated if necessary. 3.) It prevents direct linkage of UI toolkits libraries with core module logic. Splitting is not required, though is recommended if you want your plugin to be more flexible with other user interface toolkits or programs. Will implement a generic properties lookup next, which will be used for automatic UI handling so that plugin UI isn't necessarily required.
2014-01-31 23:49:50 -08:00
errorcode = success ? OBS_UI_SUCCESS : OBS_UI_CANCEL;
}
return errorcode;
}
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
void *obs_create_ui(const char *name, const char *task, const char *target,
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 *data, void *ui_data)
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
{
Simplify/improve UI exporting a bit more Reduce and simplify the UI export interface. Having to export functions with designated names was a bit silly for this case, it makes more sense for inputs/outputs/etc because they have more functions associated with them, but in this case the callback can be retrieved simply through the enumeration exports. Makes it a bit easier and a little less awkward for this situation. Also, changed the exports and names to be a bit more consistent, labelling them both as either "modal" or "modeless", and changed the UI function calls to obs_exec_ui and obs_create_ui to imply modal/modeless functionality a bit more.
2014-02-01 16:43:32 -08:00
struct obs_modeless_ui *callback;
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
callback = get_modeless_ui_callback(name, task, target);
Revamp API and start using doxygen The API used to be designed in such a way to where it would expect exports for each individual source/output/encoder/etc. You would export functions for each and it would automatically load those functions based on a specific naming scheme from the module. The idea behind this was that I wanted to limit the usage of structures in the API so only functions could be used. It was an interesting idea in theory, but this idea turned out to be flawed in a number of ways: 1.) Requiring exports to create sources/outputs/encoders/etc meant that you could not create them by any other means, which meant that things like faruton's .net plugin would become difficult. 2.) Export function declarations could not be checked, therefore if you created a function with the wrong parameters and parameter types, the compiler wouldn't know how to check for that. 3.) Required overly complex load functions in libobs just to handle it. It makes much more sense to just have a load function that you call manually. Complexity is the bane of all good programs. 4.) It required that you have functions of specific names, which looked and felt somewhat unsightly. So, to fix these issues, I replaced it with a more commonly used API scheme, seen commonly in places like kernels and typical C libraries with abstraction. You simply create a structure that contains the callback definitions, and you pass it to a function to register that definition (such as obs_register_source), which you call in the obs_module_load of the module. It will also automatically check the structure size and ensure that it only loads the required values if the structure happened to add new values in an API change. The "main" source file for each module must include obs-module.h, and must use OBS_DECLARE_MODULE() within that source file. Also, started writing some doxygen documentation in to the main library headers. Will add more detailed documentation as I go.
2014-02-12 07:04:50 -08:00
return callback ? callback->create(data, ui_data) : NULL;
Add support for modeless UI creation I realized that I had intended modeless UI to be usable by plugins, but it had been pointed out to me that modeless really needs to return a pointer/handle to the user interface object that was created.
2014-02-01 11:48:35 -08:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_source_t *obs_get_output_source(uint32_t channel)
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
{
(API Change) Unsquish libobs (base) names Previous names: New names: ----------------------------------------------------------- obs_view_setsource obs_view_set_source obs_view_getsource obs_view_get_source obs_source_getdisplayname obs_source_get_display_name obs_source_getwidth obs_source_get_width obs_source_getheight obs_source_get_height obs_filter_getparent obs_filter_get_parent obs_filter_gettarget obs_filter_get_target obs_source_filter_setorder obs_source_filter_set_order obs_source_getsettings obs_source_get_settings obs_source_getname obs_source_get_name obs_source_setname obs_source_set_name obs_source_setvolume obs_source_set_volume obs_source_getvolume obs_source_get_volume obs_scene_getsource obs_scene_get_source obs_scene_fromsource obs_scene_from_source obs_scene_findsource obs_scene_find_source obs_output_getdisplayname obs_output_get_display_name obs_output_getname obs_output_get_name obs_encoder_getname obs_encoder_get_name obs_service_getdisplayname obs_service_get_display_name obs_service_getname obs_service_get_name
2014-08-04 08:41:15 -07:00
return obs_view_get_source(&obs->data.main_view, channel);
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_set_output_source(uint32_t channel, obs_source_t *source)
first commit
2013-09-30 19:37:13 -07:00
{
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
assert(channel < MAX_CHANNELS);
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
if (channel >= MAX_CHANNELS)
return;
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
struct obs_source *prev_source;
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
struct obs_view *view = &obs->data.main_view;
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
struct calldata params = {0};
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
pthread_mutex_lock(&view->channels_mutex);
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
source = obs_source_get_ref(source);
Activate user-selected audio devices - Fix a bug where the initial audio data insertion would cause all audio data to unintentionally clear (mixed up < and > operators, damn human error) - Fixed a potential interdependant lock scenario with channel mutex locks and graphics mutex locks. The main video thread could lock the graphics mutex and then while in the graphics mutex could lock the channels mutex. Meanwhile in another thread, the channel mutex could get locked, and then the graphics mutex would get locked, causing a deadlock. The best way to deal with this is to not let mutexes lock within other mutexes, but sometimes it's difficult to avoid such as in the main video thread. - Audio devices should now be functional, and the devices in the audio settings can now be changed as desired.
2014-03-07 16:03:34 -08:00
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
prev_source = view->channels[channel];
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_set_int(&params, "channel", channel);
calldata_set_ptr(&params, "prev_source", prev_source);
calldata_set_ptr(&params, "source", source);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
signal_handler_signal(obs->signals, "channel_change", &params);
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_get_ptr(&params, "source", &source);
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
calldata_free(&params);
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
view->channels[channel] = source;
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
Activate user-selected audio devices - Fix a bug where the initial audio data insertion would cause all audio data to unintentionally clear (mixed up < and > operators, damn human error) - Fixed a potential interdependant lock scenario with channel mutex locks and graphics mutex locks. The main video thread could lock the graphics mutex and then while in the graphics mutex could lock the channels mutex. Meanwhile in another thread, the channel mutex could get locked, and then the graphics mutex would get locked, causing a deadlock. The best way to deal with this is to not let mutexes lock within other mutexes, but sometimes it's difficult to avoid such as in the main video thread. - Audio devices should now be functional, and the devices in the audio settings can now be changed as desired.
2014-03-07 16:03:34 -08:00
pthread_mutex_unlock(&view->channels_mutex);
if (source)
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
obs_source_activate(source, MAIN_VIEW);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
if (prev_source) {
Separate source activation for main/aux views Split off activate to activate and show callbacks, and split off deactivate to deactivate and hide callbacks. Sources didn't previously have a means to know whether it was actually being displayed in the main view or just happened to be visible somewhere. Now, for things like transition sources, they have a means of knowing when they have actually been "activated" so they can initiate their sequence. A source is now only considered "active" when it's being displayed by the main view. When a source is shown in the main view, the activate callback/signal is triggered. When it's no longer being displayed by the main view, deactivate callback/signal is triggered. When a source is just generally visible to see by any view, the show callback/signal is triggered. If it's no longer visible by any views, then the hide callback/signal is triggered. Presentation volume will now only be active when a source is active in the main view rather than also in auxilary views. Also fix a potential bug where parents wouldn't properly increment or decrement all the activation references of a child source when a child was added or removed.
2014-02-23 16:46:00 -08:00
obs_source_deactivate(prev_source, MAIN_VIEW);
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
obs_source_release(prev_source);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
}
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08: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
void obs_enum_sources(bool (*enum_proc)(void *, obs_source_t *), void *param)
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
{
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
obs_source_t *source;
pthread_mutex_lock(&obs->data.sources_mutex);
source = obs->data.first_source;
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
while (source) {
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
obs_source_t *s = obs_source_get_ref(source);
if (s) {
if (strcmp(s->info.id, group_info.id) == 0 &&
!enum_proc(param, s)) {
obs_source_release(s);
break;
} else if (s->info.type == OBS_SOURCE_TYPE_INPUT &&
!s->context.private &&
!enum_proc(param, s)) {
obs_source_release(s);
break;
}
obs_source_release(s);
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
}
libobs: Check for removals in obs_enum_sources Checks for removals while enumerating, which allows one to be able to remove a source in the enumeration.
2015-06-27 18:14:33 -07:00
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
source = (obs_source_t *)source->context.next;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
}
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
libobs: Add obs_enum_scenes for enumerating scenes Closes obsproject/obs-studio#1507
2018-09-30 14:55:40 -07:00
pthread_mutex_unlock(&obs->data.sources_mutex);
}
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 obs_enum_scenes(bool (*enum_proc)(void *, obs_source_t *), void *param)
libobs: Add obs_enum_scenes for enumerating scenes Closes obsproject/obs-studio#1507
2018-09-30 14:55:40 -07:00
{
obs_source_t *source;
pthread_mutex_lock(&obs->data.sources_mutex);
source = obs->data.first_source;
while (source) {
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
obs_source_t *s = obs_source_get_ref(source);
if (s) {
if (source->info.type == OBS_SOURCE_TYPE_SCENE &&
!source->context.private && !enum_proc(param, s)) {
obs_source_release(s);
break;
}
obs_source_release(s);
libobs: Add obs_enum_scenes for enumerating scenes Closes obsproject/obs-studio#1507
2018-09-30 14:55:40 -07:00
}
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
source = (obs_source_t *)source->context.next;
libobs: Add obs_enum_scenes for enumerating scenes Closes obsproject/obs-studio#1507
2018-09-30 14:55:40 -07:00
}
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
pthread_mutex_unlock(&obs->data.sources_mutex);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
static inline void obs_enum(void *pstart, pthread_mutex_t *mutex, void *proc,
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 preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
{
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
struct obs_context_data **start = pstart, *context;
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
bool (*enum_proc)(void *, void *) = proc;
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
assert(start);
assert(mutex);
assert(enum_proc);
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
pthread_mutex_lock(mutex);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
context = *start;
while (context) {
if (!enum_proc(param, context))
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
break;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
context = context->next;
}
pthread_mutex_unlock(mutex);
Add preliminary output/encoder interface - First, I redid the output interface for libobs. I feel like it's going in a pretty good direction in terms of design. Right now, the design is so that outputs and encoders are separate. One or more outputs can connect to a specific encoder to receive its data, or the output can connect directly to raw data from libobs output itself, if the output doesn't want to use a designated encoder. Data is received via callbacks set when you connect to the encoder or raw output. Multiple outputs can receive the data from a single encoder context if need be (such as for streaming to multiple channels at once, and/or recording with the same data). When an encoder is first connected to, it will connect to raw output, and start encoding. Additional connections will receive that same data being encoded as well after that. When the last encoder has disconnected, it will stop encoding. If for some reason the encoder needs to stop, it will use the callback with NULL to signal that encoding has stopped. Some of these things may be subject to change in the future, though it feels pretty good with this design so far. Will have to see how well it works out in practice versus theory. - Second, Started adding preliminary RTMP/x264 output plugin code. To speed things up, I might just make a direct raw->FFmpeg output to create a quick output plugin that we can start using for testing all the subsystems.
2014-01-16 21:34:51 -08:00
}
libobs: Add `obs_enum_all_sources()` There is currently no way to enumerate *all* sources in OBS. Only inputs and scenes have a way to be enumerated. Some applications like obs-websocket have features that need to take advantage of enumerating all sources in order to function properly.
2021-05-13 23:56:54 -07:00
void obs_enum_all_sources(bool (*enum_proc)(void *, obs_source_t *),
void *param)
{
obs_enum(&obs->data.first_source, &obs->data.sources_mutex, enum_proc,
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
void obs_enum_outputs(bool (*enum_proc)(void *, obs_output_t *), void *param)
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08: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
obs_enum(&obs->data.first_output, &obs->data.outputs_mutex, enum_proc,
param);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
}
Add more checks for NULL pointers
2014-02-23 21:39:33 -08: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
void obs_enum_encoders(bool (*enum_proc)(void *, obs_encoder_t *), void *param)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -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
obs_enum(&obs->data.first_encoder, &obs->data.encoders_mutex, enum_proc,
param);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
}
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08: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
void obs_enum_services(bool (*enum_proc)(void *, obs_service_t *), void *param)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -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
obs_enum(&obs->data.first_service, &obs->data.services_mutex, enum_proc,
param);
made the getframe function a bit more safe and modified a few names for clarity
2013-11-22 15:18:31 -08:00
}
add obs_source functions to allow name manipulation and lookup based upon name, and a few other functions related to getting/setting source information
2013-12-20 18:35:12 -08:00
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
static inline void *get_context_by_name(void *vfirst, const char *name,
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
pthread_mutex_t *mutex,
void *(*addref)(void *))
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
{
struct obs_context_data **first = vfirst;
struct obs_context_data *context;
pthread_mutex_lock(mutex);
context = *first;
while (context) {
libobs: Allow "private" contexts The intention of this is to allow sources/outputs/etc to be created without being visible to the UI or save/load functions.
2016-01-09 13:05:44 -08:00
if (!context->private && strcmp(context->name, name) == 0) {
libobs: Add refcounting helpers
2015-05-03 16:37:14 -07:00
context = addref(context);
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
break;
libobs: Add refcounting helpers
2015-05-03 16:37:14 -07:00
}
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
context = context->next;
}
pthread_mutex_unlock(mutex);
return context;
}
libobs: Refactor obs_get_source_by_name Changes it to use obs_context_by_name
2016-01-09 13:37:27 -08:00
static inline void *obs_source_addref_safe_(void *ref)
{
return obs_source_get_ref(ref);
}
(API Change) libobs: Make obs_output refcounted
2015-05-03 16:55:43 -07:00
static inline void *obs_output_addref_safe_(void *ref)
{
return obs_output_get_ref(ref);
}
(API Change) libobs: Make obs_encoder refcounted
2015-05-03 17:01:38 -07:00
static inline void *obs_encoder_addref_safe_(void *ref)
{
return obs_encoder_get_ref(ref);
}
(API Change) libobs: Make obs_service refcounted
2015-05-03 17:07:43 -07:00
static inline void *obs_service_addref_safe_(void *ref)
{
return obs_service_get_ref(ref);
}
libobs: Add refcounting helpers
2015-05-03 16:37:14 -07:00
static inline void *obs_id_(void *data)
{
return data;
}
libobs: Refactor obs_get_source_by_name Changes it to use obs_context_by_name
2016-01-09 13:37:27 -08:00
obs_source_t *obs_get_source_by_name(const char *name)
{
return get_context_by_name(&obs->data.first_source, name,
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
&obs->data.sources_mutex,
obs_source_addref_safe_);
libobs: Refactor obs_get_source_by_name Changes it to use obs_context_by_name
2016-01-09 13:37:27 -08:00
}
libobs: Add obs_get_transition_by_name
2021-11-07 03:51:41 -08:00
obs_source_t *obs_get_transition_by_name(const char *name)
{
struct obs_source **first = &obs->data.first_source;
struct obs_source *source;
pthread_mutex_lock(&obs->data.sources_mutex);
source = *first;
while (source) {
if (source->info.type == OBS_SOURCE_TYPE_TRANSITION &&
strcmp(source->context.name, name) == 0) {
source = obs_source_addref_safe_(source);
break;
}
source = (void *)source->context.next;
}
pthread_mutex_unlock(&obs->data.sources_mutex);
return source;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_output_t *obs_get_output_by_name(const char *name)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
{
return get_context_by_name(&obs->data.first_output, name,
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
&obs->data.outputs_mutex,
obs_output_addref_safe_);
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_encoder_t *obs_get_encoder_by_name(const char *name)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
{
return get_context_by_name(&obs->data.first_encoder, name,
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
&obs->data.encoders_mutex,
obs_encoder_addref_safe_);
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_service_t *obs_get_service_by_name(const char *name)
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
{
return get_context_by_name(&obs->data.first_service, name,
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
&obs->data.services_mutex,
obs_service_addref_safe_);
obs-studio UI: Implement stream settings UI - Updated the services API so that it links up with an output and the output gets data from that service rather than via settings. This allows the service context to have control over how an output is used, and makes it so that the URL/key/etc isn't necessarily some static setting. Also, if the service is attached to an output, it will stick around until the output is destroyed. - The settings interface has been updated so that it can allow the usage of service plugins. What this means is that now you can create a service plugin that can control aspects of the stream, and it allows each service to create their own user interface if they create a service plugin module. - Testing out saving of current service information. Saves/loads from JSON in to obs_data_t, seems to be working quite nicely, and the service object information is saved/preserved on exit, and loaded again on startup. - I agonized over the settings user interface for days, and eventually I just decided that the only way that users weren't going to be fumbling over options was to split up the settings in to simple/basic output, pre-configured, and then advanced for advanced use (such as multiple outputs or services, which I'll implement later). This was particularly painful to really design right, I wanted more features and wanted to include everything in one interface but ultimately just realized from experience that users are just not technically knowledgable about it and will end up fumbling with the settings rather than getting things done. Basically, what this means is that casual users only have to enter in about 3 things to configure their stream: Stream key, audio bitrate, and video bitrate. I am really happy with this interface for those types of users, but it definitely won't be sufficient for advanced usage or for custom outputs, so that stuff will have to be separated. - Improved the JSON usage for the 'common streaming services' context, I realized that JSON arrays are there to ensure sorting, while forgetting that general items are optimized for hashing. So basically I'm just using arrays now to sort items in it.
2014-04-24 01:49:07 -07:00
}
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
gs_effect_t *obs_get_base_effect(enum obs_base_effect effect)
add major optimization to filter processing, and as a nice side effect, make it easier to create new filters and sources
2013-12-22 00:30:18 -08:00
{
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
switch (effect) {
case OBS_EFFECT_DEFAULT:
return obs->video.default_effect;
case OBS_EFFECT_DEFAULT_RECT:
return obs->video.default_rect_effect;
case OBS_EFFECT_OPAQUE:
return obs->video.opaque_effect;
case OBS_EFFECT_SOLID:
return obs->video.solid_effect;
UI: Add scene item canvas overflow to preview
2019-01-14 17:58:20 -08:00
case OBS_EFFECT_REPEAT:
return obs->video.repeat_effect;
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
case OBS_EFFECT_BICUBIC:
return obs->video.bicubic_effect;
case OBS_EFFECT_LANCZOS:
return obs->video.lanczos_effect;
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
case OBS_EFFECT_AREA:
return obs->video.area_effect;
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
case OBS_EFFECT_BILINEAR_LOWRES:
return obs->video.bilinear_lowres_effect;
libobs: Add premultiplied alpha base effect
2016-03-26 21:41:49 -07:00
case OBS_EFFECT_PREMULTIPLIED_ALPHA:
return obs->video.premultiplied_alpha_effect;
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
}
libobs: Add missing function definitions Add missing function definitions for the lanczos and bicubic effects
2015-04-06 07:02:44 -07:00
(API Change) libobs: Use single func for base effects API removed: -------------------- gs_effect_t *obs_get_default_effect(void); gs_effect_t *obs_get_default_rect_effect(void); gs_effect_t *obs_get_opaque_effect(void); gs_effect_t *obs_get_solid_effect(void); gs_effect_t *obs_get_bicubic_effect(void); gs_effect_t *obs_get_lanczos_effect(void); gs_effect_t *obs_get_bilinear_lowres_effect(void); API added: -------------------- gs_effect_t *obs_get_base_effect(enum obs_base_effect effect); Summary: -------------------- Combines multiple near-identical functions into a single function with an enum parameter.
2015-10-16 07:31:52 -07:00
return NULL;
libobs: Add low resolution bilinear scale effect This effect preserves detail of images that are scaled below half size by using sampling 9 pixels.
2015-04-06 07:09:47 -07:00
}
libobs: Rename DEPRECATED to OBS_DEPRECATED Avoid collisions with other libraries that define DEPRECATED.
2020-01-20 21:44:50 -08:00
/* OBS_DEPRECATED */
libobs: Put obs_get_default_rect_effect back in temporarily This function was removed even though the browser plugin was using this function on mac, so this is being put back in temporarily while the browser plugin is modified to remove this function.
2015-12-11 16:47:22 -08:00
gs_effect_t *obs_get_default_rect_effect(void)
{
return obs->video.default_rect_effect;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
signal_handler_t *obs_get_signal_handler(void)
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
{
return obs->signals;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
proc_handler_t *obs_get_proc_handler(void)
implement signal/procedure handling into libobs and individual sources
2013-12-26 22:10:15 -08:00
{
return obs->procs;
}
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
libobs: Rename DEPRECATED to OBS_DEPRECATED Avoid collisions with other libraries that define DEPRECATED.
2020-01-20 21:44:50 -08:00
/* OBS_DEPRECATED */
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
void obs_render_main_view(void)
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
{
Rename obs_viewport to obs_view I felt like the name could cause a bit of confusion with typical graphics viewports, so I just changed it to view instead.
2014-02-13 09:21:16 -08:00
obs_view_render(&obs->data.main_view);
Revamp rendering system to allow custom rendering Originally, the rendering system was designed to only display sources and such, but I realized there would be a flaw; if you wanted to render the main viewport in a custom way, or maybe even the entire application as a graphics-based front end, you wouldn't have been able to do that. Displays have now been separated in to viewports and displays. A viewport is used to store and draw sources, a display is used to handle draw callbacks. You can even use displays without using viewports to draw custom render displays containing graphics calls if you wish, but usually they would be used in combination with source viewports at least. This requires a tiny bit more work to create simple source displays, but in the end its worth it for the added flexibility and options it brings.
2014-02-13 07:58:31 -08:00
}
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
libobs: UI: Remove DrawBackdrop() to save fullscreen pass It's a waste of GPU time to do two fullscreen passes to render final mix previews. Use blend states to simulate the black background of DrawBackdrop() for the following situations: - Main preview window (Studio Mode off) - Studio Mode: Program This does not effect: - Studio Mode: Preview (still uses DrawBackdrop) - Fullscreen Projector (uses GPU clear to black) - Windowed Projector (uses GPU clear to black) intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 Before: DrawBackdrop: ~529 us main texture: ~367 us (Cheaper than drawing a black quad?) After: [DrawBackdrop optimized away] main texture: ~383 us
2019-07-18 08:44:09 -07:00
static void obs_render_main_texture_internal(enum gs_blend_type src_c,
enum gs_blend_type dest_c,
enum gs_blend_type src_a,
enum gs_blend_type dest_a)
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video;
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
gs_texture_t *tex;
gs_effect_t *effect;
gs_eparam_t *param;
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video = obs->video.main_mix;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
if (!video->texture_rendered)
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
return;
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
const enum gs_color_space source_space = video->render_space;
const enum gs_color_space current_space = gs_get_color_space();
const char *tech_name = "Draw";
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
float multiplier = 1.f;
switch (current_space) {
case GS_CS_SRGB:
case GS_CS_SRGB_16F:
if (source_space == GS_CS_709_EXTENDED)
tech_name = "DrawTonemap";
break;
case GS_CS_709_SCRGB:
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
tech_name = "DrawMultiply";
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
multiplier = obs_get_video_sdr_white_level() / 80.f;
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
}
const bool previous = gs_framebuffer_srgb_enabled();
gs_enable_framebuffer_srgb(true);
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
tex = video->render_texture;
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
effect = obs_get_base_effect(OBS_EFFECT_DEFAULT);
param = gs_effect_get_param_by_name(effect, "image");
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
gs_effect_set_texture_srgb(param, tex);
param = gs_effect_get_param_by_name(effect, "multiplier");
gs_effect_set_float(param, multiplier);
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_push();
libobs: UI: Remove DrawBackdrop() to save fullscreen pass It's a waste of GPU time to do two fullscreen passes to render final mix previews. Use blend states to simulate the black background of DrawBackdrop() for the following situations: - Main preview window (Studio Mode off) - Studio Mode: Program This does not effect: - Studio Mode: Preview (still uses DrawBackdrop) - Fullscreen Projector (uses GPU clear to black) - Windowed Projector (uses GPU clear to black) intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 Before: DrawBackdrop: ~529 us main texture: ~367 us (Cheaper than drawing a black quad?) After: [DrawBackdrop optimized away] main texture: ~383 us
2019-07-18 08:44:09 -07:00
gs_blend_function_separate(src_c, dest_c, src_a, dest_a);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
while (gs_effect_loop(effect, tech_name))
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
gs_draw_sprite(tex, 0, 0, 0);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_pop();
libobs: Render main texture for active color space Preview will draw SDR white luminance from settings (default 300 nits) when displayed on an HDR monitor rather than CCCS 80 nits.
2022-03-14 23:50:45 -07:00
gs_enable_framebuffer_srgb(previous);
libobs: Add obs_render_main_texture (Note: This commit also modifies UI and test) This makes it so that main preview panes are rendered with the main output texture rather than re-rendering the main view. The view will render all objects again, whereas the output texture will be a single texture render of the same exact thing. Also fixes some abnormal artifacting when scaling the main preview pane.
2018-01-01 18:33:44 -08:00
}
libobs: UI: Remove DrawBackdrop() to save fullscreen pass It's a waste of GPU time to do two fullscreen passes to render final mix previews. Use blend states to simulate the black background of DrawBackdrop() for the following situations: - Main preview window (Studio Mode off) - Studio Mode: Program This does not effect: - Studio Mode: Preview (still uses DrawBackdrop) - Fullscreen Projector (uses GPU clear to black) - Windowed Projector (uses GPU clear to black) intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 Before: DrawBackdrop: ~529 us main texture: ~367 us (Cheaper than drawing a black quad?) After: [DrawBackdrop optimized away] main texture: ~383 us
2019-07-18 08:44:09 -07:00
void obs_render_main_texture(void)
{
obs_render_main_texture_internal(GS_BLEND_ONE, GS_BLEND_INVSRCALPHA,
GS_BLEND_ONE, GS_BLEND_INVSRCALPHA);
}
void obs_render_main_texture_src_color_only(void)
{
obs_render_main_texture_internal(GS_BLEND_ONE, GS_BLEND_ZERO,
GS_BLEND_ONE, GS_BLEND_INVSRCALPHA);
}
libobs: Add function to get last main output texture Allows the ability to get the last rendered texture of the main output view.
2018-04-20 05:56:28 -07:00
gs_texture_t *obs_get_main_texture(void)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video;
libobs: Add function to get last main output texture Allows the ability to get the last rendered texture of the main output view.
2018-04-20 05:56:28 -07:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
video = obs->video.main_mix;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
if (!video->texture_rendered)
libobs: Add function to get last main output texture Allows the ability to get the last rendered texture of the main output view.
2018-04-20 05:56:28 -07:00
return NULL;
libobs: Remove unnecessary frame pipelining Remove three instances of unnecessary double-buffering. They are not needed to avoid stalls, and cause increased memory traffic when measured on Intel HD 530, presumably because texture data will remain in cache if sampled immediately after write. (Note: GPU timings from Intel GPA are volatile.) NV12, 3 Draws: RGBA -> UYVX: 628 us -> 543 us UYVX -> Y: 522 us -> 507 us UYVX -> UV: 315 us -> 187 us Total, Duration: 1594 us -> 1153 us Total, GTI Read Throughput: 25.2 MB -> 15.9 MB
2019-05-24 01:03:21 -07:00
return video->render_texture;
libobs: Add function to get last main output texture Allows the ability to get the last rendered texture of the main output view.
2018-04-20 05:56:28 -07:00
}
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
void obs_set_master_volume(float volume)
{
Add volume signals
2014-02-21 16:51:16 -08:00
struct calldata data = {0};
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_set_float(&data, "volume", volume);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
signal_handler_signal(obs->signals, "master_volume", &data);
volume = (float)calldata_float(&data, "volume");
Add volume signals
2014-02-21 16:51:16 -08:00
calldata_free(&data);
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
obs->audio.user_volume = volume;
}
float obs_get_master_volume(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->audio.user_volume;
Add more volume options Added a "master" volume for the entire audio subsystem. Also, added a "presentation" volume for both the master volume and for each invidiaul source. The presentation volume is used to control things like transitioning volumes, preventing sources from outputting any audio when they're inactive, as well as some other uses in the future.
2014-02-20 14:53:16 -08:00
}
libobs: Add function to load private sources If a private source is loaded with the obs_load_source function, it is loaded as a normal source, so add a new function to load private sources.
2022-02-12 13:39:31 -08:00
static obs_source_t *obs_load_source_type(obs_data_t *source_data,
bool is_private)
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
{
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
obs_data_array_t *filters = obs_data_get_array(source_data, "filters");
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_source_t *source;
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
const char *name = obs_data_get_string(source_data, "name");
const char *id = obs_data_get_string(source_data, "id");
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
const char *v_id = obs_data_get_string(source_data, "versioned_id");
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
obs_data_t *settings = obs_data_get_obj(source_data, "settings");
obs_data_t *hotkeys = obs_data_get_obj(source_data, "hotkeys");
double volume;
double balance;
int64_t sync;
libobs: Add "monitoring by default" source cap (This also modifies the UI module) Adds the ability for a source to monitor by default. This is mainly aimed at browser sources, so that they do not stop outputting audio by default like they used to.
2019-07-26 00:02:31 -07:00
uint32_t prev_ver;
uint32_t caps;
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
uint32_t flags;
uint32_t mixers;
int di_order;
int di_mode;
int monitoring_type;
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
libobs: Add API to get last OBS version of a source Allows the ability to change the behavior of a source depending on the previous OBS version.
2019-09-20 00:13:51 -07:00
prev_ver = (uint32_t)obs_data_get_int(source_data, "prev_ver");
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
if (!*v_id)
v_id = id;
source = obs_source_create_set_last_ver(v_id, name, settings, hotkeys,
libobs: Add function to load private sources If a private source is loaded with the obs_load_source function, it is loaded as a normal source, so add a new function to load private sources.
2022-02-12 13:39:31 -08:00
prev_ver, is_private);
libobs: Handle removed plugins for versioned sources When someone adds a source and the plugin is removed for whatever reason, it would cause a crash with the new source versioning system. This fixes that by ensuring the unversioned id is also backed up along with the normal id.
2020-03-09 16:53:44 -07:00
if (source->owns_info_id) {
bfree((void *)source->info.unversioned_id);
source->info.unversioned_id = bstrdup(id);
}
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
(API Change) libobs: Add hotkey data to *_create functions
2014-11-01 13:41:17 -07:00
obs_data_release(hotkeys);
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
libobs: Add "monitoring by default" source cap (This also modifies the UI module) Adds the ability for a source to monitor by default. This is mainly aimed at browser sources, so that they do not stop outputting audio by default like they used to.
2019-07-26 00:02:31 -07:00
caps = obs_source_get_output_flags(source);
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
obs_data_set_default_double(source_data, "volume", 1.0);
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 11:09:29 -07:00
volume = obs_data_get_double(source_data, "volume");
(API Change) Unsquish libobs (base) names Previous names: New names: ----------------------------------------------------------- obs_view_setsource obs_view_set_source obs_view_getsource obs_view_get_source obs_source_getdisplayname obs_source_get_display_name obs_source_getwidth obs_source_get_width obs_source_getheight obs_source_get_height obs_filter_getparent obs_filter_get_parent obs_filter_gettarget obs_filter_get_target obs_source_filter_setorder obs_source_filter_set_order obs_source_getsettings obs_source_get_settings obs_source_getname obs_source_get_name obs_source_setname obs_source_set_name obs_source_setvolume obs_source_set_volume obs_source_getvolume obs_source_get_volume obs_scene_getsource obs_scene_get_source obs_scene_fromsource obs_scene_from_source obs_scene_findsource obs_scene_find_source obs_output_getdisplayname obs_output_get_display_name obs_output_getname obs_output_get_name obs_encoder_getname obs_encoder_get_name obs_service_getdisplayname obs_service_get_display_name obs_service_getname obs_service_get_name
2014-08-04 08:41:15 -07:00
obs_source_set_volume(source, (float)volume);
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
UI: Implement stereo balancing
2017-10-08 03:15:28 -07:00
obs_data_set_default_double(source_data, "balance", 0.5);
balance = obs_data_get_double(source_data, "balance");
obs_source_set_balance_value(source, (float)balance);
libobs: Save/load source audio sync and flags When a source is being saved, include the audio sync as well as the flags.
2014-12-27 21:21:36 -08:00
sync = obs_data_get_int(source_data, "sync");
obs_source_set_sync_offset(source, sync);
libobs: Fix default mixer values There are 6 mixers, so we want 0x3F for 6 bits, not 0xF which is only 4 bits.
2019-08-26 08:24:02 -07:00
obs_data_set_default_int(source_data, "mixers", 0x3F);
(API Change) Add support for multiple audio mixers API changed: -------------------------- void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder); obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output); obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings); Changed to: -------------------------- /* 'idx' specifies the track index of the output */ void obs_output_set_audio_encoder( obs_output_t *output, obs_encoder_t *encoder, size_t idx); /* 'idx' specifies the track index of the output */ obs_encoder_t *obs_output_get_audio_encoder( const obs_output_t *output, size_t idx); /* 'mixer_idx' specifies the mixer index to capture audio from */ obs_encoder_t *obs_audio_encoder_create( const char *id, const char *name, obs_data_t *settings, size_t mixer_idx); Overview -------------------------- This feature allows multiple audio mixers to be used at a time. This capability was able to be added with surprisingly very little extra overhead. Audio will not be mixed unless it's assigned to a specific mixer, and mixers will not mix unless they have an active mix connection. Mostly this will be useful for being able to separate out specific audio for recording versus streaming, but will also be useful for certain streaming services that support multiple audio streams via RTMP. I didn't want to use a variable amount of mixers due to the desire to reduce heap allocations, so currently I set the limit to 4 simultaneous mixers; this number can be increased later if needed, but honestly I feel like it's just the right number to use. Sources: Sources can now specify which audio mixers their audio is mixed to; this can be a single mixer or multiple mixers at a time. The obs_source_set_audio_mixers function sets the audio mixer which an audio source applies to. For example, 0xF would mean that the source applies to all four mixers. Audio Encoders: Audio encoders now must specify which specific audio mixer they use when they encode audio data. Outputs: Outputs that use encoders can now support multiple audio tracks at once if they have the OBS_OUTPUT_MULTI_TRACK capability flag set. This is mostly only useful for certain types of RTMP transmissions, though may be useful for file formats that support multiple audio tracks as well later on.
2015-01-14 02:12:08 -08:00
mixers = (uint32_t)obs_data_get_int(source_data, "mixers");
obs_source_set_audio_mixers(source, mixers);
Revert "libobs: Allow source to fully control source flags (for now)" This reverts commit d85224bb9b01173b4ceed866482c435681f3f9b1. Would cause other flags to stop saving. Buffering needs to be split off from the source flags.
2017-05-13 23:30:36 -07:00
obs_data_set_default_int(source_data, "flags", source->default_flags);
flags = (uint32_t)obs_data_get_int(source_data, "flags");
obs_source_set_flags(source, flags);
libobs: Add ability to disable sources/filters
2015-03-17 18:15:50 -07:00
obs_data_set_default_bool(source_data, "enabled", true);
obs_source_set_enabled(source,
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
obs_data_get_bool(source_data, "enabled"));
libobs: Add ability to disable sources/filters
2015-03-17 18:15:50 -07:00
libobs: Add API to mute/unmute sources
2015-03-22 14:54:07 -07:00
obs_data_set_default_bool(source_data, "muted", false);
obs_source_set_muted(source, obs_data_get_bool(source_data, "muted"));
libobs: Fix saving/loading of push-to-mute settings
2015-05-12 12:31:08 -07:00
obs_data_set_default_bool(source_data, "push-to-mute", false);
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
obs_source_enable_push_to_mute(
source, obs_data_get_bool(source_data, "push-to-mute"));
libobs: Fix saving/loading of push-to-mute settings
2015-05-12 12:31:08 -07:00
obs_data_set_default_int(source_data, "push-to-mute-delay", 0);
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
obs_source_set_push_to_mute_delay(
source, obs_data_get_int(source_data, "push-to-mute-delay"));
libobs: Fix saving/loading of push-to-mute settings
2015-05-12 12:31:08 -07:00
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
obs_data_set_default_bool(source_data, "push-to-talk", false);
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
obs_source_enable_push_to_talk(
source, obs_data_get_bool(source_data, "push-to-talk"));
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
obs_data_set_default_int(source_data, "push-to-talk-delay", 0);
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
obs_source_set_push_to_talk_delay(
source, obs_data_get_int(source_data, "push-to-talk-delay"));
libobs: Add audio source hotkeys
2015-04-30 18:22:12 -07:00
libobs: Add deinterlacing API functions Adds deinterlacing API functions. Both standard and 2x variants are supported. Deinterlacing is set via obs_source_set_deinterlace_mode and obs_source_set_deinterlace_field_order. This was implemented in to the core itself because deinterlacing should happen before effect filters are processed, but after async filters are processed. If this were added as a filter, there is the possibility that a different filter is processed before deinterlacing, which could mess with the result. It was also a bit easier to implement this way due to the fact that that deinterlacing may need to have access to the previous async frame. Effects were split in to separate files to reduce load time (especially for yadif shaders which take a significant amount of time to compile).
2016-03-15 20:39:36 -07:00
di_mode = (int)obs_data_get_int(source_data, "deinterlace_mode");
obs_source_set_deinterlace_mode(source,
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
(enum obs_deinterlace_mode)di_mode);
libobs: Add deinterlacing API functions Adds deinterlacing API functions. Both standard and 2x variants are supported. Deinterlacing is set via obs_source_set_deinterlace_mode and obs_source_set_deinterlace_field_order. This was implemented in to the core itself because deinterlacing should happen before effect filters are processed, but after async filters are processed. If this were added as a filter, there is the possibility that a different filter is processed before deinterlacing, which could mess with the result. It was also a bit easier to implement this way due to the fact that that deinterlacing may need to have access to the previous async frame. Effects were split in to separate files to reduce load time (especially for yadif shaders which take a significant amount of time to compile).
2016-03-15 20:39:36 -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
di_order =
(int)obs_data_get_int(source_data, "deinterlace_field_order");
obs_source_set_deinterlace_field_order(
source, (enum obs_deinterlace_field_order)di_order);
libobs: Add deinterlacing API functions Adds deinterlacing API functions. Both standard and 2x variants are supported. Deinterlacing is set via obs_source_set_deinterlace_mode and obs_source_set_deinterlace_field_order. This was implemented in to the core itself because deinterlacing should happen before effect filters are processed, but after async filters are processed. If this were added as a filter, there is the possibility that a different filter is processed before deinterlacing, which could mess with the result. It was also a bit easier to implement this way due to the fact that that deinterlacing may need to have access to the previous async frame. Effects were split in to separate files to reduce load time (especially for yadif shaders which take a significant amount of time to compile).
2016-03-15 20:39:36 -07:00
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
monitoring_type = (int)obs_data_get_int(source_data, "monitoring_type");
libobs: Fix browser source settings resetting pre-24 Fixes an issue where the browser source settings will continually reset pre-24. Note that this is not 23.2.2, but the version is being temporarily updated in order to fix the issue for the release candidate build.
2019-08-17 06:18:37 -07:00
if (prev_ver < MAKE_SEMANTIC_VERSION(23, 2, 2)) {
libobs: Add "monitoring by default" source cap (This also modifies the UI module) Adds the ability for a source to monitor by default. This is mainly aimed at browser sources, so that they do not stop outputting audio by default like they used to.
2019-07-26 00:02:31 -07:00
if ((caps & OBS_SOURCE_MONITOR_BY_DEFAULT) != 0) {
/* updates older sources to enable monitoring
* automatically if they added monitoring by default in
* version 24 */
monitoring_type = OBS_MONITORING_TYPE_MONITOR_ONLY;
libobs: Fix default mixer values There are 6 mixers, so we want 0x3F for 6 bits, not 0xF which is only 4 bits.
2019-08-26 08:24:02 -07:00
obs_source_set_audio_mixers(source, 0x3F);
libobs: Add "monitoring by default" source cap (This also modifies the UI module) Adds the ability for a source to monitor by default. This is mainly aimed at browser sources, so that they do not stop outputting audio by default like they used to.
2019-07-26 00:02:31 -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
obs_source_set_monitoring_type(
source, (enum obs_monitoring_type)monitoring_type);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
obs_data_release(source->private_settings);
source->private_settings =
obs_data_get_obj(source_data, "private_settings");
if (!source->private_settings)
source->private_settings = obs_data_create();
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
if (filters) {
size_t count = obs_data_array_count(filters);
for (size_t i = 0; i < count; i++) {
obs_data_t *filter_data =
obs_data_array_item(filters, i);
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
obs_source_t *filter =
libobs: Add function to load private sources If a private source is loaded with the obs_load_source function, it is loaded as a normal source, so add a new function to load private sources.
2022-02-12 13:39:31 -08:00
obs_load_source_type(filter_data, true);
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
if (filter) {
obs_source_filter_add(source, filter);
obs_source_release(filter);
}
obs_data_release(filter_data);
}
obs_data_array_release(filters);
}
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
obs_data_release(settings);
return source;
}
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
obs_source_t *obs_load_source(obs_data_t *source_data)
{
libobs: Add function to load private sources If a private source is loaded with the obs_load_source function, it is loaded as a normal source, so add a new function to load private sources.
2022-02-12 13:39:31 -08:00
return obs_load_source_type(source_data, false);
}
obs_source_t *obs_load_private_source(obs_data_t *source_data)
{
return obs_load_source_type(source_data, true);
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
}
(API Change) libobs: Don't use signal for obs_load_sources (Note: This commit also changes the UI) Changed: ------------------- void obs_load_sources(obs_data_array_t *sources_list); To: ------------------- void obs_load_sources(obs_data_array_t *sources_list, obs_source_load_cb callback, void *private_data); Signals should really never be required to use to make some function work properly. The "source_load" signal was required for the obs_load_sources function, but it's meant more for loading private data in the settings, not for general loading of sources. This changes it so that a callback is explicitly required to load the sources.
2016-03-04 12:56:09 -08:00
void obs_load_sources(obs_data_array_t *array, obs_load_source_cb cb,
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 *private_data)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
struct obs_core_data *data = &obs->data;
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
DARRAY(obs_source_t *) sources;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
size_t count;
size_t i;
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
da_init(sources);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
count = obs_data_array_count(array);
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
da_reserve(sources, count);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
pthread_mutex_lock(&data->sources_mutex);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
for (i = 0; i < count; i++) {
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
obs_data_t *source_data = obs_data_array_item(array, i);
obs_source_t *source = obs_load_source(source_data);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
da_push_back(sources, &source);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_data_release(source_data);
}
/* tell sources that we want to load */
libobs: Implement transition sources Transition sources are implemented by registering a source type as OBS_SOURCE_TYPE_TRANSITION. They're automatically marked as video composite sources, and video_render/audio_render callbacks must be set when registering the source. get_width and get_height callbacks are unused for these types of sources, as transitions automatically handle width/height behind the scenes with the transition settings. In the video_render callback, the helper function obs_transition_video_render is used to assist in automatically processing and rendering the audio. A render callback is passed to the function, which in turn passes to/from textures that are automatically rendered in the back-end. Similarly, in the audio_render callback, the helper function obs_transition_audio_render is used to assist in automatically processing and rendering the audio. Two mix callbacks are used to handle how the source/destination sources are mixed together. To ensure the best possible quality, audio processing is per-sample. Transitions can be set to automatically resize, or they can be set to have a fixed size. Sources within transitions can be made to scale to the transition size (with or without aspect ratio), or to not scale unless they're bigger than the transition. They can have a specific alignment within the transition, or they just default to top-left. These features are implemented for the purpose of extending transitions to also act as "switch" sources later, where you can switch to/from two different sources using the transition animation. Planned (but not yet implemented and lower priority) features: - "Switch" transitions which allow the ability to switch back and forth between two sources with a transitioning animation without discarding the references - Easing options to allow the option to transition with a bezier or custom curve - Manual transitioning to allow the front-end/user to manually control the transition offset
2016-01-03 16:41:14 -08:00
for (i = 0; i < sources.num; i++) {
obs_source_t *source = sources.array[i];
obs_data_t *source_data = obs_data_array_item(array, i);
if (source) {
if (source->info.type == OBS_SOURCE_TYPE_TRANSITION)
obs_transition_load(source, source_data);
libobs: Add obs_source_load2() Allows loading a source and all of its filters automatically. Previously, the original obs_source_load would not load filters.
2021-04-06 11:52:46 -07:00
obs_source_load2(source);
libobs: Make callback optional for obs_load_sources Due to the ability to track creation of scenes via the "source_created" global signal, the callback parameter of obs_load_sources has become somewhat obsolete. This change allows the ability to pass NULL to the callback parameter in case the callback is not needed.
2018-05-04 11:44:19 -07:00
if (cb)
cb(private_data, source);
libobs: Implement transition sources Transition sources are implemented by registering a source type as OBS_SOURCE_TYPE_TRANSITION. They're automatically marked as video composite sources, and video_render/audio_render callbacks must be set when registering the source. get_width and get_height callbacks are unused for these types of sources, as transitions automatically handle width/height behind the scenes with the transition settings. In the video_render callback, the helper function obs_transition_video_render is used to assist in automatically processing and rendering the audio. A render callback is passed to the function, which in turn passes to/from textures that are automatically rendered in the back-end. Similarly, in the audio_render callback, the helper function obs_transition_audio_render is used to assist in automatically processing and rendering the audio. Two mix callbacks are used to handle how the source/destination sources are mixed together. To ensure the best possible quality, audio processing is per-sample. Transitions can be set to automatically resize, or they can be set to have a fixed size. Sources within transitions can be made to scale to the transition size (with or without aspect ratio), or to not scale unless they're bigger than the transition. They can have a specific alignment within the transition, or they just default to top-left. These features are implemented for the purpose of extending transitions to also act as "switch" sources later, where you can switch to/from two different sources using the transition animation. Planned (but not yet implemented and lower priority) features: - "Switch" transitions which allow the ability to switch back and forth between two sources with a transitioning animation without discarding the references - Easing options to allow the option to transition with a bezier or custom curve - Manual transitioning to allow the front-end/user to manually control the transition offset
2016-01-03 16:41:14 -08:00
}
obs_data_release(source_data);
}
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
for (i = 0; i < sources.num; i++)
obs_source_release(sources.array[i]);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
pthread_mutex_unlock(&data->sources_mutex);
da_free(sources);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_t *obs_save_source(obs_source_t *source)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
obs_data_array_t *filters = obs_data_array_create();
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_t *source_data = obs_data_create();
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
obs_data_t *settings = obs_source_get_settings(source);
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
obs_data_t *hotkey_data = source->context.hotkey_data;
obs_data_t *hotkeys;
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
float volume = obs_source_get_volume(source);
float balance = obs_source_get_balance_value(source);
uint32_t mixers = obs_source_get_audio_mixers(source);
int64_t sync = obs_source_get_sync_offset(source);
uint32_t flags = obs_source_get_flags(source);
const char *name = obs_source_get_name(source);
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
const char *id = source->info.unversioned_id;
const char *v_id = source->info.id;
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
bool enabled = obs_source_enabled(source);
bool muted = obs_source_muted(source);
bool push_to_mute = obs_source_push_to_mute_enabled(source);
uint64_t ptm_delay = obs_source_get_push_to_mute_delay(source);
bool push_to_talk = obs_source_push_to_talk_enabled(source);
uint64_t ptt_delay = obs_source_get_push_to_talk_delay(source);
int m_type = (int)obs_source_get_monitoring_type(source);
int di_mode = (int)obs_source_get_deinterlace_mode(source);
int di_order = (int)obs_source_get_deinterlace_field_order(source);
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
obs_source_save(source);
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
hotkeys = obs_hotkeys_save_source(source);
if (hotkeys) {
obs_data_release(hotkey_data);
source->context.hotkey_data = hotkeys;
hotkey_data = hotkeys;
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Add "monitoring by default" source cap (This also modifies the UI module) Adds the ability for a source to monitor by default. This is mainly aimed at browser sources, so that they do not stop outputting audio by default like they used to.
2019-07-26 00:02:31 -07:00
obs_data_set_int(source_data, "prev_ver", LIBOBS_API_VER);
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
obs_data_set_string(source_data, "name", name);
obs_data_set_string(source_data, "id", id);
libobs: Fix source type versioning system (This also modifies image-source, obs-text, text-freetype2, and UI) This improves source definition versioning. To do this, it now stores two identifier names. One "unversioned" which is the original name, and one "versioned" with the version number appended. This fixes both backward compatibility with older OBS versions, and fixes the inability to use "add existing" in OBS itself on sources created from older version definitions.
2020-03-09 06:03:10 -07:00
obs_data_set_string(source_data, "versioned_id", v_id);
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
obs_data_set_obj(source_data, "settings", settings);
obs_data_set_int(source_data, "mixers", mixers);
obs_data_set_int(source_data, "sync", sync);
obs_data_set_int(source_data, "flags", flags);
obs_data_set_double(source_data, "volume", volume);
obs_data_set_double(source_data, "balance", balance);
obs_data_set_bool(source_data, "enabled", enabled);
obs_data_set_bool(source_data, "muted", muted);
obs_data_set_bool(source_data, "push-to-mute", push_to_mute);
obs_data_set_int(source_data, "push-to-mute-delay", ptm_delay);
obs_data_set_bool(source_data, "push-to-talk", push_to_talk);
obs_data_set_int(source_data, "push-to-talk-delay", ptt_delay);
obs_data_set_obj(source_data, "hotkeys", hotkey_data);
obs_data_set_int(source_data, "deinterlace_mode", di_mode);
obs_data_set_int(source_data, "deinterlace_field_order", di_order);
obs_data_set_int(source_data, "monitoring_type", m_type);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
obs_data_set_obj(source_data, "private_settings",
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
source->private_settings);
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
libobs: Implement transition sources Transition sources are implemented by registering a source type as OBS_SOURCE_TYPE_TRANSITION. They're automatically marked as video composite sources, and video_render/audio_render callbacks must be set when registering the source. get_width and get_height callbacks are unused for these types of sources, as transitions automatically handle width/height behind the scenes with the transition settings. In the video_render callback, the helper function obs_transition_video_render is used to assist in automatically processing and rendering the audio. A render callback is passed to the function, which in turn passes to/from textures that are automatically rendered in the back-end. Similarly, in the audio_render callback, the helper function obs_transition_audio_render is used to assist in automatically processing and rendering the audio. Two mix callbacks are used to handle how the source/destination sources are mixed together. To ensure the best possible quality, audio processing is per-sample. Transitions can be set to automatically resize, or they can be set to have a fixed size. Sources within transitions can be made to scale to the transition size (with or without aspect ratio), or to not scale unless they're bigger than the transition. They can have a specific alignment within the transition, or they just default to top-left. These features are implemented for the purpose of extending transitions to also act as "switch" sources later, where you can switch to/from two different sources using the transition animation. Planned (but not yet implemented and lower priority) features: - "Switch" transitions which allow the ability to switch back and forth between two sources with a transitioning animation without discarding the references - Easing options to allow the option to transition with a bezier or custom curve - Manual transitioning to allow the front-end/user to manually control the transition offset
2016-01-03 16:41:14 -08:00
if (source->info.type == OBS_SOURCE_TYPE_TRANSITION)
obs_transition_save(source, source_data);
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
pthread_mutex_lock(&source->filter_mutex);
if (source->filters.num) {
libobs: Always enumerate filter list in reverse The "last" filter that's rendered is technically at filter index 0, so enumeration needs to be from the last index in the list to the first index in the list.
2015-03-14 07:02:23 -07:00
for (size_t i = source->filters.num; i > 0; i--) {
obs_source_t *filter = source->filters.array[i - 1];
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
obs_data_t *filter_data = obs_save_source(filter);
obs_data_array_push_back(filters, filter_data);
obs_data_release(filter_data);
}
obs_data_set_array(source_data, "filters", filters);
}
pthread_mutex_unlock(&source->filter_mutex);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_data_release(settings);
libobs: Save/load filters on sources to save data
2015-02-25 21:16:28 -08:00
obs_data_array_release(filters);
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
return source_data;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
libobs: Add obs_save_sources_filtered (skip) (Note: This commit breaks UI compilation. Skip if bisecting) Adds a means of saving specific sources that the front-end chooses, rather than being forced to use the now-removed "user list".
2015-10-30 03:10:06 -07:00
obs_data_array_t *obs_save_sources_filtered(obs_save_source_filter_cb cb,
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 *data_)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
struct obs_core_data *data = &obs->data;
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_array_t *array;
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
obs_source_t *source;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
array = obs_data_array_create();
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
pthread_mutex_lock(&data->sources_mutex);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
source = data->first_source;
Add (temporary terrible) volume controls - Add volume control These volume controls are basically nothing more than sliders. They look terrible and hopefully will be as temporary as they are terrible. - Allow saving of specific non-user sources via obs_load_source and obs_save_source functions. - Save data of desktop/mic audio sources (sync data, volume data, etc), and load the data on startup. - Make it so that a scene is created by default if first time using the application. On certain operating systems where supported, a default capture will be created. Desktop capture on mac, particularly. Not sure what to do about windows because monitor capture on windows 7 is completely terrible and is bad to start users off with.
2014-05-03 22:54:38 -07:00
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
while (source) {
(API Change) libobs: Remove source_type param from functions (Note: test and UI are also modified by this commit) API Changed (removed "enum obs_source_type type" parameter): ------------------------- obs_source_get_display_name obs_source_create obs_get_source_output_flags obs_get_source_defaults obs_get_source_properties Removes the "type" parameter from these functions. The "type" parameter really doesn't serve much of a purpose being a parameter in any of these cases, the type is just to indicate what it's used for.
2015-12-29 15:25:45 -08:00
if ((source->info.type != OBS_SOURCE_TYPE_FILTER) != 0 &&
libobs: Don't save removed sources
2020-04-17 05:05:36 -07:00
!source->context.private && !source->removed &&
libobs: Don't save temporarily removed sources The only references to these sources exist in the undo buffer, they are not attached to a scene and cause issues when loaded on the next startup.
2021-04-03 15:07:59 -07:00
!source->temp_removed && cb(data_, source)) {
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
obs_data_t *source_data = obs_save_source(source);
obs_data_array_push_back(array, source_data);
obs_data_release(source_data);
}
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
source = (obs_source_t *)source->context.next;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
(API Change) libobs: Remove "User sources list" (skip) (Note: This commit breaks UI compilation. Skip if bisecting) API Removed: ------------------------ obs_add_source API Changed: ------------------------ obs_source_remove: Now just marks/signals a source for removal The concept of "user sources" is flawed: it was something that the front-end was forced to deal with if it wanted to automate source saving/loading, and often it had to code around it. That's not how saving/loading should work, a front-end should be allowed to manage lists of sources in the way it explicitly chooses, and it should be able to choose which sources it wants to save/load.
2015-10-29 13:26:19 -07:00
pthread_mutex_unlock(&data->sources_mutex);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
return array;
}
libobs: Add obs_save_sources_filtered (skip) (Note: This commit breaks UI compilation. Skip if bisecting) Adds a means of saving specific sources that the front-end chooses, rather than being forced to use the now-removed "user list".
2015-10-30 03:10:06 -07:00
static bool save_source_filter(void *data, obs_source_t *source)
{
UNUSED_PARAMETER(data);
UNUSED_PARAMETER(source);
return true;
}
obs_data_array_t *obs_save_sources(void)
{
return obs_save_sources_filtered(save_source_filter, NULL);
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
/* ensures that names are never blank */
libobs: Allow "private" contexts The intention of this is to allow sources/outputs/etc to be created without being visible to the UI or save/load functions.
2016-01-09 13:05:44 -08:00
static inline char *dup_name(const char *name, bool private)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
{
libobs: Allow "private" contexts The intention of this is to allow sources/outputs/etc to be created without being visible to the UI or save/load functions.
2016-01-09 13:05:44 -08:00
if (private && !name)
return NULL;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (!name || !*name) {
struct dstr unnamed = {0};
libobs: Fix various string format warnings GCC 5.1+ seems to be more aggressive about spotting potentially non-matching printf format specifiers.
2015-08-30 23:41:09 -07:00
dstr_printf(&unnamed, "__unnamed%04lld",
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
obs->data.unnamed_index++);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return unnamed.array;
} else {
return bstrdup(name);
}
}
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
static inline bool obs_context_data_init_wrap(struct obs_context_data *context,
enum obs_obj_type type,
obs_data_t *settings,
const char *name,
obs_data_t *hotkey_data,
bool private)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
{
assert(context);
Remove unnecessary context initialization code There was no need to call the context free function in the initialization function, and it's safer to just initialize the memory to 0 before using (which also negates the need for da_init)
2014-07-02 21:05:46 -07:00
memset(context, 0, sizeof(*context));
libobs: Allow "private" contexts The intention of this is to allow sources/outputs/etc to be created without being visible to the UI or save/load functions.
2016-01-09 13:05:44 -08:00
context->private = private;
libobs: Add function to get obs object type
2016-02-26 18:18:00 -08:00
context->type = type;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
Add rename cache for thread safety This just ensures that if an obs object is renamed that the pointer to older names will still be valid. Prevents renames from causing any invalid memory access. When the obs object is destroyed, so are the cached names.
2014-07-02 20:58:30 -07:00
pthread_mutex_init_value(&context->rename_cache_mutex);
if (pthread_mutex_init(&context->rename_cache_mutex, NULL) < 0)
return false;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
context->signals = signal_handler_create();
Fix typo in signal handler creation check
2014-10-28 14:58:13 -07:00
if (!context->signals)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return false;
context->procs = proc_handler_create();
if (!context->procs)
return false;
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
context->name = dup_name(name, private);
context->settings = obs_data_newref(settings);
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
context->hotkey_data = obs_data_newref(hotkey_data);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return true;
}
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
bool obs_context_data_init(struct obs_context_data *context,
enum obs_obj_type type, obs_data_t *settings,
const char *name, obs_data_t *hotkey_data,
bool private)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
{
libobs: Add function to get obs object type
2016-02-26 18:18:00 -08:00
if (obs_context_data_init_wrap(context, type, settings, name,
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
hotkey_data, private)) {
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return true;
} else {
obs_context_data_free(context);
return false;
}
}
void obs_context_data_free(struct obs_context_data *context)
{
libobs: Add global hotkey support
2014-11-01 13:41:17 -07:00
obs_hotkeys_context_release(context);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
signal_handler_destroy(context->signals);
proc_handler_destroy(context->procs);
obs_data_release(context->settings);
obs_context_data_remove(context);
Add rename cache for thread safety This just ensures that if an obs object is renamed that the pointer to older names will still be valid. Prevents renames from causing any invalid memory access. When the obs object is destroyed, so are the cached names.
2014-07-02 20:58:30 -07:00
pthread_mutex_destroy(&context->rename_cache_mutex);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
bfree(context->name);
Add rename cache for thread safety This just ensures that if an obs object is renamed that the pointer to older names will still be valid. Prevents renames from causing any invalid memory access. When the obs object is destroyed, so are the cached names.
2014-07-02 20:58:30 -07:00
for (size_t i = 0; i < context->rename_cache.num; i++)
bfree(context->rename_cache.array[i]);
da_free(context->rename_cache);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
memset(context, 0, sizeof(*context));
}
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
void obs_context_init_control(struct obs_context_data *context, void *object,
obs_destroy_cb destroy)
{
context->control = bzalloc(sizeof(obs_weak_object_t));
context->control->object = object;
context->destroy = destroy;
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
void obs_context_data_insert(struct obs_context_data *context,
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
pthread_mutex_t *mutex, void *pfirst)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
{
struct obs_context_data **first = pfirst;
assert(context);
assert(mutex);
assert(first);
context->mutex = mutex;
pthread_mutex_lock(mutex);
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
context->prev_next = first;
context->next = *first;
*first = context;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (context->next)
context->next->prev_next = &context->next;
pthread_mutex_unlock(mutex);
}
void obs_context_data_remove(struct obs_context_data *context)
{
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
if (context && context->prev_next) {
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
pthread_mutex_lock(context->mutex);
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
*context->prev_next = context->next;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (context->next)
context->next->prev_next = context->prev_next;
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
context->prev_next = NULL;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
pthread_mutex_unlock(context->mutex);
}
}
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
void obs_context_wait(struct obs_context_data *context)
{
pthread_mutex_lock(context->mutex);
pthread_mutex_unlock(context->mutex);
}
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
void obs_context_data_setname(struct obs_context_data *context,
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
const char *name)
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
{
Add rename cache for thread safety This just ensures that if an obs object is renamed that the pointer to older names will still be valid. Prevents renames from causing any invalid memory access. When the obs object is destroyed, so are the cached names.
2014-07-02 20:58:30 -07:00
pthread_mutex_lock(&context->rename_cache_mutex);
if (context->name)
da_push_back(context->rename_cache, &context->name);
libobs: Allow "private" contexts The intention of this is to allow sources/outputs/etc to be created without being visible to the UI or save/load functions.
2016-01-09 13:05:44 -08:00
context->name = dup_name(name, context->private);
Add rename cache for thread safety This just ensures that if an obs object is renamed that the pointer to older names will still be valid. Prevents renames from causing any invalid memory access. When the obs object is destroyed, so are the cached names.
2014-07-02 20:58:30 -07:00
pthread_mutex_unlock(&context->rename_cache_mutex);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
}
(API Change) libobs: Add profile_name_store_t parameter to obs_startup Due to all the threads in libobs it wouldn't be safe to make that parameter reconfigurable after libobs is initialized without adding even more synchronization. On the other hand, adding a function to set the name store before calling obs_startup would solve the problem of passing a name store into libobs, but it can lead to more complicated semantics for obs_get_profiler_name_store (e.g., should it always return the current name store even if libobs isn't initialized until someone calls set_name_store(NULL)? should obs_shutdown call set_name_store(NULL)? Passing it as obs_startup parameter avoids these (and hopefully other) potential misunderstandings
2015-08-02 03:06:00 -07:00
profiler_name_store_t *obs_get_profiler_name_store(void)
{
return obs->name_store;
}
libobs: Add function to get current video time (in nanosec) Allows getting the timestamp for the video frame currently being rendered.
2016-01-17 17:39:32 -08:00
uint64_t obs_get_video_frame_time(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.video_time;
libobs: Add function to get current video time (in nanosec) Allows getting the timestamp for the video frame currently being rendered.
2016-01-17 17:39:32 -08:00
}
libobs: Add function to get obs object type
2016-02-26 18:18:00 -08:00
libobs: Add obs_get_active_fps function Allows getting the current active framerate that the core is rendering with. This takes in to account any rendering lag or stalls that may be occurring.
2016-08-22 12:04:23 -07:00
double obs_get_active_fps(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.video_fps;
libobs: Add obs_get_active_fps function Allows getting the current active framerate that the core is rendering with. This takes in to account any rendering lag or stalls that may be occurring.
2016-08-22 12:04:23 -07:00
}
libobs: Add function to get average render time Useful for real-time rendering statistics
2017-05-12 16:21:51 -07:00
uint64_t obs_get_average_frame_time_ns(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.video_avg_frame_time_ns;
libobs: Add function to get average render time Useful for real-time rendering statistics
2017-05-12 16:21:51 -07:00
}
libobs: Add obs_get_frame_interval_ns Returns the current video frame interval between frames, in nanoseconds.
2019-07-06 15:30:52 -07:00
uint64_t obs_get_frame_interval_ns(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.video_frame_interval_ns;
libobs: Add obs_get_frame_interval_ns Returns the current video frame interval between frames, in nanoseconds.
2019-07-06 15:30:52 -07:00
}
libobs: Add function to get obs object type
2016-02-26 18:18:00 -08:00
enum obs_obj_type obs_obj_get_type(void *obj)
{
struct obs_context_data *context = obj;
return context ? context->type : OBS_OBJ_TYPE_INVALID;
}
libobs: Add function to get obs object id
2016-02-26 18:19:58 -08:00
const char *obs_obj_get_id(void *obj)
{
struct obs_context_data *context = obj;
if (!context)
return NULL;
switch (context->type) {
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
case OBS_OBJ_TYPE_SOURCE:
return ((obs_source_t *)obj)->info.id;
case OBS_OBJ_TYPE_OUTPUT:
return ((obs_output_t *)obj)->info.id;
case OBS_OBJ_TYPE_ENCODER:
return ((obs_encoder_t *)obj)->info.id;
case OBS_OBJ_TYPE_SERVICE:
return ((obs_service_t *)obj)->info.id;
libobs: Add function to get obs object id
2016-02-26 18:19:58 -08:00
default:;
}
return NULL;
}
libobs: Add obs_obj_invalid function Determines whether an obs object was created successfully. If a plugin that's used for a saved object is removed (third party plugins), its data will become invalid, but the objects can often still be created for the sake of preserving user settings, but sometimes these objects can cause problems if they're actually used (such as using them for transitions).
2016-04-03 21:44:04 -07:00
bool obs_obj_invalid(void *obj)
{
struct obs_context_data *context = obj;
if (!context)
return true;
return !context->data;
}
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
libobs: Add function to get libobs object data
2019-03-13 00:50:19 -07:00
void *obs_obj_get_data(void *obj)
{
struct obs_context_data *context = obj;
if (!context)
return NULL;
return context->data;
}
libobs: Add obs_obj_is_private() Returns true if an obs object is considered private. (Author's note: the concept of "private" objects is not ideal, but we're stuck with it for now)
2021-04-06 11:54:37 -07:00
bool obs_obj_is_private(void *obj)
{
struct obs_context_data *context = obj;
if (!context)
return false;
return context->private;
}
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
bool obs_set_audio_monitoring_device(const char *name, const char *id)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
if (!name || !id || !*name || !*id)
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
return false;
libobs: Rename obs_audio_monitoring_supported to _available With the reasonable possibility of monitoring support becoming a runtime check, the phrase `available` is more fitting.
2021-12-21 19:08:14 -08:00
if (!obs_audio_monitoring_available())
libobs/UI: Stop using preprocessor directives for monitor **Code Cleanup** Stop using preprocessor directives to determine if audio monitoring is supported. Use runtime function instead
2021-08-31 04:53:02 -07:00
return false;
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
pthread_mutex_lock(&obs->audio.monitoring_mutex);
libobs: Add missing mutex unlock in audio monitoring
2017-02-26 13:02:05 -08:00
if (strcmp(id, obs->audio.monitoring_device_id) == 0) {
pthread_mutex_unlock(&obs->audio.monitoring_mutex);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
return true;
libobs: Add missing mutex unlock in audio monitoring
2017-02-26 13:02:05 -08:00
}
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
libobs: Remove unnecessary null check
2021-04-02 15:31:07 -07:00
bfree(obs->audio.monitoring_device_name);
bfree(obs->audio.monitoring_device_id);
libobs: Implement audio monitoring Adds functions to turn on audio monitoring to allow the user to hear playback of an audio source over the user's speaker. It can be set to turn off monitoring and only output to stream, or it can be set to output only to monitoring, or it can be set to both. On windows, audio monitoring uses WASAPI. Windows also is capable of syncing the audio to the video according to when the video frame itself was played. On mac, it uses AudioQueue. On linux, it's not currently implemented and won't do anything (to be implemented).
2017-02-05 21:37:35 -08:00
obs->audio.monitoring_device_name = bstrdup(name);
obs->audio.monitoring_device_id = bstrdup(id);
for (size_t i = 0; i < obs->audio.monitors.num; i++) {
struct audio_monitor *monitor = obs->audio.monitors.array[i];
audio_monitor_reset(monitor);
}
pthread_mutex_unlock(&obs->audio.monitoring_mutex);
return true;
}
void obs_get_audio_monitoring_device(const char **name, const char **id)
{
if (name)
*name = obs->audio.monitoring_device_name;
if (id)
*id = obs->audio.monitoring_device_id;
}
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -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
void obs_add_tick_callback(void (*tick)(void *param, float seconds),
void *param)
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-06 23:13:56 -08:00
{
struct tick_callback data = {tick, param};
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
da_insert(obs->data.tick_callbacks, 0, &data);
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
}
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 obs_remove_tick_callback(void (*tick)(void *param, float seconds),
void *param)
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-06 23:13:56 -08:00
{
struct tick_callback data = {tick, param};
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
da_erase_item(obs->data.tick_callbacks, &data);
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
}
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 obs_add_main_render_callback(void (*draw)(void *param, uint32_t cx,
uint32_t cy),
void *param)
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
{
struct draw_callback data = {draw, param};
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-06 23:13:56 -08:00
da_insert(obs->data.draw_callbacks, 0, &data);
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
}
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 obs_remove_main_render_callback(void (*draw)(void *param, uint32_t cx,
uint32_t cy),
void *param)
libobs: Add function to allow custom output drawing Optionally allows drawing directly to the primary output instead of having to use a source to draw.
2017-04-24 03:22:19 -07:00
{
struct draw_callback data = {draw, param};
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
da_erase_item(obs->data.draw_callbacks, &data);
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
}
libobs: Add functions to get total/lagged frames Useful for rendering statistics.
2017-05-12 17:29:59 -07:00
uint32_t obs_get_total_frames(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.total_frames;
libobs: Add functions to get total/lagged frames Useful for rendering statistics.
2017-05-12 17:29:59 -07:00
}
uint32_t obs_get_lagged_frames(void)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
return obs->video.lagged_frames;
libobs: Add functions to get total/lagged frames Useful for rendering statistics.
2017-05-12 17:29:59 -07:00
}
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *get_mix_for_video(video_t *v)
{
struct obs_core_video_mix *result = NULL;
pthread_mutex_lock(&obs->video.mixes_mutex);
for (size_t i = 0, num = obs->video.mixes.num; i < num; i++) {
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
struct obs_core_video_mix *mix = obs->video.mixes.array[i];
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (v == mix->video) {
result = mix;
break;
}
}
pthread_mutex_unlock(&obs->video.mixes_mutex);
return result;
}
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
void start_raw_video(video_t *v, const struct video_scale_info *conversion,
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 (*callback)(void *param, struct video_data *frame),
void *param)
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = get_mix_for_video(v);
if (video)
os_atomic_inc_long(&video->raw_active);
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
video_output_connect(v, conversion, callback, param);
}
void stop_raw_video(video_t *v,
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 (*callback)(void *param, struct video_data *frame),
void *param)
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = get_mix_for_video(v);
if (video)
os_atomic_dec_long(&video->raw_active);
libobs: Deactivate unnecessary GPU ops when not encoding Reduces GPU usage when encoding is not active. Does not perform color conversion, frame staging, or frame downloading unless encoding is explicitly active.
2018-01-31 18:54:36 -08:00
video_output_disconnect(v, callback, param);
}
libobs: Add functions to get raw video output Adds obs_add_raw_video_callback() and obs_remove_raw_video_callback() functions which allow the ability to get raw video frames without necessarily needing to create an output.
2018-04-23 09:05:32 -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
void obs_add_raw_video_callback(const struct video_scale_info *conversion,
void (*callback)(void *param,
struct video_data *frame),
void *param)
libobs: Add functions to get raw video output Adds obs_add_raw_video_callback() and obs_remove_raw_video_callback() functions which allow the ability to get raw video frames without necessarily needing to create an output.
2018-04-23 09:05:32 -07:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Add functions to get raw video output Adds obs_add_raw_video_callback() and obs_remove_raw_video_callback() functions which allow the ability to get raw video frames without necessarily needing to create an output.
2018-04-23 09:05:32 -07:00
start_raw_video(video->video, conversion, 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
void obs_remove_raw_video_callback(void (*callback)(void *param,
struct video_data *frame),
void *param)
libobs: Add functions to get raw video output Adds obs_add_raw_video_callback() and obs_remove_raw_video_callback() functions which allow the ability to get raw video frames without necessarily needing to create an output.
2018-04-23 09:05:32 -07:00
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Add functions to get raw video output Adds obs_add_raw_video_callback() and obs_remove_raw_video_callback() functions which allow the ability to get raw video frames without necessarily needing to create an output.
2018-04-23 09:05:32 -07:00
stop_raw_video(video->video, callback, param);
}
libobs: Add functions to get/set global private data Allows the ability to set custom global OBS context private data for allowing the frontend to communicate variables with plugins in an indirect way.
2018-08-10 06:01:22 -07:00
libobs: Add raw audio callback function This complements the already existing raw video callback function.
2021-11-16 23:01:46 -08:00
void obs_add_raw_audio_callback(size_t mix_idx,
const struct audio_convert_info *conversion,
audio_output_callback_t callback, void *param)
{
struct obs_core_audio *audio = &obs->audio;
libobs: Fix add/remove of raw audio callbacks
2021-11-28 02:49:04 -08:00
audio_output_connect(audio->audio, mix_idx, conversion, callback,
param);
libobs: Add raw audio callback function This complements the already existing raw video callback function.
2021-11-16 23:01:46 -08:00
}
void obs_remove_raw_audio_callback(size_t mix_idx,
audio_output_callback_t callback,
void *param)
{
struct obs_core_audio *audio = &obs->audio;
libobs: Fix add/remove of raw audio callbacks
2021-11-28 02:49:04 -08:00
audio_output_disconnect(audio->audio, mix_idx, callback, param);
libobs: Add raw audio callback function This complements the already existing raw video callback function.
2021-11-16 23:01:46 -08:00
}
libobs: Add functions to get/set global private data Allows the ability to set custom global OBS context private data for allowing the frontend to communicate variables with plugins in an indirect way.
2018-08-10 06:01:22 -07:00
void obs_apply_private_data(obs_data_t *settings)
{
libobs: Remove excessive null checks libobs functions check for a null obs_core inconsistently. If the core is null, the functions silently return with no indication of an error to the API user. This commit removes all null checks in libobs functions that require libobs to be initialized. For OBS Studio, we are (hopefully!) using the API properly so this should have no impact.
2020-06-01 06:53:01 -07:00
if (!settings)
libobs: Add functions to get/set global private data Allows the ability to set custom global OBS context private data for allowing the frontend to communicate variables with plugins in an indirect way.
2018-08-10 06:01:22 -07:00
return;
obs_data_apply(obs->data.private_data, settings);
}
void obs_set_private_data(obs_data_t *settings)
{
obs_data_clear(obs->data.private_data);
if (settings)
obs_data_apply(obs->data.private_data, settings);
}
obs_data_t *obs_get_private_data(void)
{
obs_data_t *private_data = obs->data.private_data;
obs_data_addref(private_data);
return private_data;
}
libobs: Add obs_video_active() function (This commit also modifies UI) Adds a universal function for determining whether video output is currently active, rather than having to use video_output_active() on the value returned by obs_get_video().
2018-10-05 19:36:51 -07:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
extern bool init_gpu_encoding(struct obs_core_video_mix *video);
extern void stop_gpu_encoding_thread(struct obs_core_video_mix *video);
extern void free_gpu_encoding(struct obs_core_video_mix *video);
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
bool start_gpu_encode(obs_encoder_t *encoder)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
bool success = true;
obs_enter_graphics();
pthread_mutex_lock(&video->gpu_encoder_mutex);
if (!video->gpu_encoders.num)
success = init_gpu_encoding(video);
if (success)
da_push_back(video->gpu_encoders, &encoder);
else
free_gpu_encoding(video);
pthread_mutex_unlock(&video->gpu_encoder_mutex);
obs_leave_graphics();
if (success) {
os_atomic_inc_long(&video->gpu_encoder_active);
video_output_inc_texture_encoders(video->video);
}
return success;
}
void stop_gpu_encode(obs_encoder_t *encoder)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
bool call_free = false;
os_atomic_dec_long(&video->gpu_encoder_active);
video_output_dec_texture_encoders(video->video);
pthread_mutex_lock(&video->gpu_encoder_mutex);
da_erase_item(video->gpu_encoders, &encoder);
if (!video->gpu_encoders.num)
call_free = true;
pthread_mutex_unlock(&video->gpu_encoder_mutex);
libobs: Fix texture-based encoder decklock Ensures that there are no textures being encoded before attempting to shut down a texture-based encoder.
2019-02-10 21:53:24 -08:00
os_event_wait(video->gpu_encode_inactive);
libobs: Add texture-based encoding support Allows the ability to encode by passing NV12 textures. This uses a separate thread for texture-based encoders with a small queue of textures. An output texture with a keyed mutex shared texture is locked between OBS and each encoder. A new encoder callback and capability flag is used to encode with textures.
2019-02-05 17:37:40 -08:00
if (call_free) {
stop_gpu_encoding_thread(video);
obs_enter_graphics();
pthread_mutex_lock(&video->gpu_encoder_mutex);
free_gpu_encoding(video);
pthread_mutex_unlock(&video->gpu_encoder_mutex);
obs_leave_graphics();
}
}
libobs: Add obs_video_active() function (This commit also modifies UI) Adds a universal function for determining whether video output is currently active, rather than having to use video_output_active() on the value returned by obs_get_video().
2018-10-05 19:36:51 -07:00
bool obs_video_active(void)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
bool result = false;
pthread_mutex_lock(&obs->video.mixes_mutex);
for (size_t i = 0, num = obs->video.mixes.num; i < num; i++) {
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-11 18:01:29 -07:00
struct obs_core_video_mix *video = obs->video.mixes.array[i];
libobs: Add obs_video_active() function (This commit also modifies UI) Adds a universal function for determining whether video output is currently active, rather than having to use video_output_active() on the value returned by obs_get_video().
2018-10-05 19:36:51 -07:00
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
if (os_atomic_load_long(&video->raw_active) > 0 ||
os_atomic_load_long(&video->gpu_encoder_active) > 0) {
result = true;
break;
}
}
pthread_mutex_unlock(&obs->video.mixes_mutex);
return result;
libobs: Add obs_video_active() function (This commit also modifies UI) Adds a universal function for determining whether video output is currently active, rather than having to use video_output_active() on the value returned by obs_get_video().
2018-10-05 19:36:51 -07:00
}
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
bool obs_nv12_tex_active(void)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Use NV12 textures when available
2018-10-05 20:18:15 -07:00
return video->using_nv12_tex;
}
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
bool obs_p010_tex_active(void)
{
libobs: Add support for multiple video mixes Split render_texture and derived fields in obs_core_video into new obs_core_video_mix struct. Add new APIs to add additional obs_view to the render loop, each with a separate render_texture / obs_core_video_mix.
2022-06-01 14:34:13 -07:00
struct obs_core_video_mix *video = obs->video.main_mix;
libobs: Add I010/P010 support, TRC enum
2022-04-03 00:00:38 -07:00
return video->using_p010_tex;
}
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
/* ------------------------------------------------------------------------- */
/* task stuff */
struct task_wait_info {
obs_task_t task;
void *param;
os_event_t *event;
};
static void task_wait_callback(void *param)
{
struct task_wait_info *info = param;
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
if (info->task)
info->task(info->param);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
os_event_signal(info->event);
}
THREAD_LOCAL bool is_graphics_thread = false;
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
THREAD_LOCAL bool is_audio_thread = false;
static void set_audio_thread(void *unused)
{
is_audio_thread = true;
UNUSED_PARAMETER(unused);
}
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
bool obs_in_task_thread(enum obs_task_type type)
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
{
if (type == OBS_TASK_GRAPHICS)
return is_graphics_thread;
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
else if (type == OBS_TASK_AUDIO)
return is_audio_thread;
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
else if (type == OBS_TASK_UI)
return is_ui_thread;
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
else if (type == OBS_TASK_DESTROY)
libobs: Fix destruction order for destruction task queue Destruction of the task queue should probably happen after the audio and video threads have been destroyed and all audio/video processing has stopped.
2021-12-21 11:46:42 -08:00
return os_task_queue_inside(obs->destruction_task_thread);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
assert(false);
return false;
}
void obs_queue_task(enum obs_task_type type, obs_task_t task, void *param,
bool wait)
{
if (type == OBS_TASK_UI) {
if (obs->ui_task_handler) {
obs->ui_task_handler(task, param, wait);
} else {
blog(LOG_ERROR, "UI task could not be queued, "
"there's no UI task handler!");
}
} else {
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
if (obs_in_task_thread(type)) {
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
task(param);
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
} else if (wait) {
struct task_wait_info info = {
.task = task,
.param = param,
};
os_event_init(&info.event, OS_EVENT_TYPE_MANUAL);
obs_queue_task(type, task_wait_callback, &info, false);
os_event_wait(info.event);
os_event_destroy(info.event);
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
} else if (type == OBS_TASK_GRAPHICS) {
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
struct obs_core_video *video = &obs->video;
struct obs_task_info info = {task, param};
pthread_mutex_lock(&video->task_mutex);
circlebuf_push_back(&video->tasks, &info, sizeof(info));
pthread_mutex_unlock(&video->task_mutex);
libobs: Add ability to queue audio task This is mostly framework for allowing the ability to wait for certain threads
2021-12-19 09:46:08 -08:00
} else if (type == OBS_TASK_AUDIO) {
struct obs_core_audio *audio = &obs->audio;
struct obs_task_info info = {task, param};
pthread_mutex_lock(&audio->task_mutex);
circlebuf_push_back(&audio->tasks, &info, sizeof(info));
pthread_mutex_unlock(&audio->task_mutex);
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
} else if (type == OBS_TASK_DESTROY) {
os_task_t os_task = (os_task_t)task;
libobs: Fix destruction order for destruction task queue Destruction of the task queue should probably happen after the audio and video threads have been destroyed and all audio/video processing has stopped.
2021-12-21 11:46:42 -08:00
os_task_queue_queue_task(obs->destruction_task_thread,
os_task, param);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
}
}
}
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
bool obs_wait_for_destroy_queue(void)
{
struct task_wait_info info = {0};
if (!obs->video.thread_initialized || !obs->audio.audio)
return false;
/* allow video and audio threads time to release objects */
os_event_init(&info.event, OS_EVENT_TYPE_AUTO);
obs_queue_task(OBS_TASK_GRAPHICS, task_wait_callback, &info, false);
os_event_wait(info.event);
obs_queue_task(OBS_TASK_AUDIO, task_wait_callback, &info, false);
os_event_wait(info.event);
os_event_destroy(info.event);
/* wait for destroy task queue */
libobs: Fix destruction order for destruction task queue Destruction of the task queue should probably happen after the audio and video threads have been destroyed and all audio/video processing has stopped.
2021-12-21 11:46:42 -08:00
return os_task_queue_wait(obs->destruction_task_thread);
libobs: Implement deferred destruction of sources (This also modifies the UI) The purpose of deferring destruction of sources is to ensure that: 1.) Hard locks from enumeration cannot occur with source destruction. For example, if the browser source is destroyed while in the graphics thread, the browser thread would wait for the graphics thread, but the graphics thread would still be waiting for the browser thread, causing a hard lock. 2.) When destroys occur during source enumeration, that the integrity of the context's next pointer in the linked list can no longer be compromised 3.) Source releases are fully asynchronous rather than having the risk of stalling the calling thread 4.) We can wait for source destruction when switching scene collections or when shutting down rather than hoping for threads to be finished with sources. This introduces a new requirement when cleaning up scene/source data: the obs_wait_for_destroy_queue() function. It is highly recommended that this function be called after cleaning up sources. It will return true if at least one or more sources were destroyed. Otherwise it will return false. Forks are highly advised to call this function manually on source cleanup -- preferably in a loop, in conjunction with processing outstanding OBS signals and UI events.
2021-12-19 09:55:51 -08:00
}
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
static void set_ui_thread(void *unused)
{
is_ui_thread = true;
UNUSED_PARAMETER(unused);
}
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -07:00
void obs_set_ui_task_handler(obs_task_handler_t handler)
{
obs->ui_task_handler = handler;
libobs: Add obs_in_task_thread() function Allows determining which thread the caller is currently in, if any
2021-12-19 09:53:54 -08:00
obs_queue_task(OBS_TASK_UI, set_ui_thread, NULL, false);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 10:39:24 -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
obs_object_t *obs_object_get_ref(obs_object_t *object)
{
if (!object)
return NULL;
return obs_weak_object_get_object(object->control);
}
void obs_object_release(obs_object_t *object)
{
if (!obs) {
blog(LOG_WARNING, "Tried to release an object when the OBS "
"core is shut down!");
return;
}
if (!object)
return;
obs_weak_object_t *control = object->control;
if (obs_ref_release(&control->ref)) {
object->destroy(object);
obs_weak_object_release(control);
}
}
void obs_weak_object_addref(obs_weak_object_t *weak)
{
if (!weak)
return;
obs_weak_ref_addref(&weak->ref);
}
void obs_weak_object_release(obs_weak_object_t *weak)
{
if (!weak)
return;
if (obs_weak_ref_release(&weak->ref))
bfree(weak);
}
obs_weak_object_t *obs_object_get_weak_object(obs_object_t *object)
{
if (!object)
return NULL;
obs_weak_object_t *weak = object->control;
obs_weak_object_addref(weak);
return weak;
}
obs_object_t *obs_weak_object_get_object(obs_weak_object_t *weak)
{
if (!weak)
return NULL;
if (obs_weak_ref_get_ref(&weak->ref))
return weak->object;
return NULL;
}
bool obs_weak_object_expired(obs_weak_object_t *weak)
{
return weak ? obs_weak_ref_expired(&weak->ref) : true;
}
bool obs_weak_object_references_object(obs_weak_object_t *weak,
obs_object_t *object)
{
return weak && object && weak->object == object;
}