OBS/obs-studio
OBS/obs-studio
1
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-07-19 17:49:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
obs-studio/libobs/obs-video.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1314 lines
36 KiB
C
Raw Normal View History

first commit
2013-10-01 02:37:13 +00:00
/******************************************************************************
Update copyrights/names
2023-05-19 00:37:26 +00:00
Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
first commit
2013-10-01 02:37:13 +00: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-03 05:24:38 +00:00
the Free Software Foundation, either version 2 of the License, or
first commit
2013-10-01 02:37:13 +00: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/>.
******************************************************************************/
libobs: Initialize randomization seed in video thread Ensures that any rand() calls in the video thread will have a unique seed to start from.
2017-10-04 01:48:12 +00:00
#include <time.h>
#include <stdlib.h>
first commit
2013-10-01 02:37:13 +00:00
#include "obs.h"
Rename obs-data.h to obs-internal.h Renaming obs-data.h to avoid confusion about its usage
2014-01-27 01:48:14 +00:00
#include "obs-internal.h"
first commit
2013-10-01 02:37:13 +00:00
#include "graphics/vec4.h"
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
#include "media-io/format-conversion.h"
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 09:53:13 +00:00
#include "media-io/video-frame.h"
first commit
2013-10-01 02:37:13 +00:00
libobs: Pump Win32 messages on the graphics thread Necessary for upcoming Windows Graphics Capture support.
2019-11-28 00:38:35 +00:00
#ifdef _WIN32
#define WIN32_MEAN_AND_LEAN
#include <windows.h>
#endif
obs-video.c: Fix minor bug The pointer here is confusing, so I'm just going to remove it and have it return the value instead.
2014-04-19 13:33:11 +00:00
static uint64_t tick_sources(uint64_t cur_time, uint64_t last_time)
first commit
2013-10-01 02:37:13 +00: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-20 03:38:53 +00:00
struct obs_core_data *data = &obs->data;
struct obs_source *source;
uint64_t delta_time;
float seconds;
first commit
2013-10-01 02:37:13 +00:00
if (!last_time)
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
last_time = cur_time - obs->video.video_frame_interval_ns;
(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 22:07:54 +00:00
obs-video.c: Fix minor bug The pointer here is confusing, so I'm just going to remove it and have it return the value instead.
2014-04-19 13:33:11 +00:00
delta_time = cur_time - last_time;
first commit
2013-10-01 02:37:13 +00:00
seconds = (float)((double)delta_time / 1000000000.0);
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-07 07:13:56 +00:00
/* ------------------------------------- */
/* call tick callbacks */
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
pthread_mutex_lock(&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-07 07:13:56 +00:00
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
for (size_t i = data->tick_callbacks.num; i > 0; i--) {
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-07 07:13:56 +00:00
struct tick_callback *callback;
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
callback = data->tick_callbacks.array + (i - 1);
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-07 07:13:56 +00:00
callback->tick(callback->param, seconds);
}
first commit
2013-10-01 02:37:13 +00:00
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
pthread_mutex_unlock(&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-07 07:13:56 +00:00
/* ------------------------------------- */
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
/* get an array of all sources to tick */
libobs: Use da_clear() to clear obs_core_data::sources_to_tick Makes it a bit more clear what's going on
2023-06-10 21:30:44 +00:00
da_clear(data->sources_to_tick);
libobs: Add video tick callback functions Allows the ability to have a callback invoked every time video ticks. Particularly useful for scripting.
2017-12-07 07:13:56 +00:00
pthread_mutex_lock(&data->sources_mutex);
libobs: Use uthash for source objects All sources are part of a hash table that allows a lookup by UUID. Public sources additionally are in a hash table allowing lookup by name.
2023-02-09 07:34:08 +00:00
source = data->sources;
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-20 03:38:53 +00: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 17:55:51 +00:00
obs_source_t *s = obs_source_get_ref(source);
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
if (s)
da_push_back(data->sources_to_tick, &s);
libobs: Use uthash for source objects All sources are part of a hash table that allows a lookup by UUID. Public sources additionally are in a hash table allowing lookup by name.
2023-02-09 07:34:08 +00:00
source = (struct obs_source *)source->context.hh_uuid.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-20 03:38:53 +00:00
}
pthread_mutex_unlock(&data->sources_mutex);
libobs: Don't keep the sources mutex in tick_sources Allow other threads to use sources while the graphics thread does video_tick, update, activate and deactivate on sources
2023-06-09 06:51:45 +00:00
/* ------------------------------------- */
/* call the tick function of each source */
for (size_t i = 0; i < data->sources_to_tick.num; i++) {
obs_source_t *s = data->sources_to_tick.array[i];
obs_source_video_tick(s, seconds);
obs_source_release(s);
}
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-20 03:38:53 +00:00
return cur_time;
first commit
2013-10-01 02:37:13 +00: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 15:58:31 +00:00
/* in obs-display.c */
extern void render_display(struct obs_display *display);
first commit
2013-10-01 02:37:13 +00:00
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-19 03:25:13 +00:00
static inline void render_displays(void)
{
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-20 03:38:53 +00:00
struct obs_display *display;
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-24 00:00:42 +00:00
if (!obs->data.valid)
return;
(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-08 06:42:07 +00:00
gs_enter_context(obs->video.graphics);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00: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 22:00:16 +00:00
/* render extra displays/swaps */
pthread_mutex_lock(&obs->data.displays_mutex);
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-19 03:25:13 +00: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-20 03:38:53 +00:00
display = obs->data.first_display;
while (display) {
render_display(display);
display = display->next;
}
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-19 03:25:13 +00: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 22:00:16 +00:00
pthread_mutex_unlock(&obs->data.displays_mutex);
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-19 03:25:13 +00: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-08 06:42:07 +00:00
gs_leave_context();
make data access in the threads a bit more safe (note: probably will need some more safety measures later on)
2013-10-19 03:25:13 +00:00
}
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
static inline void set_render_size(uint32_t width, uint32_t height)
first commit
2013-10-01 02:37:13 +00: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-08 06:42:07 +00:00
gs_enable_depth_test(false);
gs_set_cull_mode(GS_NEITHER);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
gs_ortho(0.0f, (float)width, 0.0f, (float)height, -100.0f, 100.0f);
(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-08 06:42:07 +00:00
gs_set_viewport(0, 0, width, height);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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 21:34:13 +00:00
static inline void unmap_last_surface(struct obs_core_video_mix *video)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-27 06:21:41 +00:00
for (int c = 0; c < NUM_CHANNELS; ++c) {
if (video->mapped_surfaces[c]) {
gs_stagesurface_unmap(video->mapped_surfaces[c]);
video->mapped_surfaces[c] = NULL;
}
first commit
2013-10-01 02:37:13 +00:00
}
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
}
first commit
2013-10-01 02:37:13 +00:00
libobs: Reuse matching mix's render texture if possible Avoids re-rendering a view if a previous mix with identical settings has already rendered it
2023-11-28 13:42:06 +00:00
static inline bool can_reuse_mix_texture(const struct obs_core_video_mix *mix,
size_t *idx)
{
for (size_t i = 0, num = obs->video.mixes.num; i < num; i++) {
const struct obs_core_video_mix *other =
obs->video.mixes.array[i];
if (other == mix)
break;
if (other->view != mix->view)
continue;
if (other->render_space != mix->render_space)
continue;
if (other->ovi.base_width != mix->ovi.base_width ||
other->ovi.base_height != mix->ovi.base_height)
continue;
if (!other->texture_rendered)
continue;
*idx = i;
return true;
}
return false;
}
static inline void draw_mix_texture(const size_t mix_idx)
{
gs_texture_t *tex = obs->video.mixes.array[mix_idx]->render_texture;
gs_effect_t *effect = obs_get_base_effect(OBS_EFFECT_DEFAULT);
gs_eparam_t *param = gs_effect_get_param_by_name(effect, "image");
gs_effect_set_texture_srgb(param, tex);
gs_enable_framebuffer_srgb(true);
while (gs_effect_loop(effect, "Draw"))
gs_draw_sprite(tex, 0, 0, 0);
gs_enable_framebuffer_srgb(false);
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
static const char *render_main_texture_name = "render_main_texture";
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 21:34:13 +00:00
static inline void render_main_texture(struct obs_core_video_mix *video)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
{
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
uint32_t base_width = video->ovi.base_width;
uint32_t base_height = video->ovi.base_height;
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 21:34:13 +00:00
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(render_main_texture_name);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-03 06:23:37 +00:00
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_MAIN_TEXTURE,
render_main_texture_name);
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
struct vec4 clear_color;
Revert "libobs: libobs-d3d11: obs-filters: No excess alpha" This reverts commit d91bd327d7a8bb4597562fc26da4edb7b56874ff, which broke alpha with sources, scenes, and filter, causing them all to become opaque unintentionally.
2019-04-25 15:36:41 +00:00
vec4_set(&clear_color, 0.0f, 0.0f, 0.0f, 0.0f);
first commit
2013-10-01 02:37:13 +00: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-15 06:50:45 +00:00
gs_set_render_target_with_color_space(video->render_texture, NULL,
video->render_space);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
gs_clear(GS_CLEAR_COLOR, &clear_color, 1.0f, 0);
first commit
2013-10-01 02:37:13 +00: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 21:34:13 +00:00
set_render_size(base_width, base_height);
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 10:22:19 +00:00
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-07 07:13:56 +00:00
for (size_t i = obs->data.draw_callbacks.num; i > 0; i--) {
libobs: Add callback for main texture rendered Useful for redirecting main texture to DeckLink output for example.
2022-09-10 18:29:54 +00:00
struct draw_callback *const callback =
obs->data.draw_callbacks.array + (i - 1);
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
callback->draw(callback->param, base_width, base_height);
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 10:22:19 +00:00
}
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
libobs: Reuse matching mix's render texture if possible Avoids re-rendering a view if a previous mix with identical settings has already rendered it
2023-11-28 13:42:06 +00:00
/* In some cases we can reuse a previous mix's texture and save re-rendering everything */
size_t reuse_idx;
if (can_reuse_mix_texture(video, &reuse_idx))
draw_mix_texture(reuse_idx);
else
obs_view_render(video->view);
first commit
2013-10-01 02:37:13 +00: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 08:03:21 +00:00
video->texture_rendered = true;
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
libobs: Add callback for main texture rendered Useful for redirecting main texture to DeckLink output for example.
2022-09-10 18:29:54 +00:00
pthread_mutex_lock(&obs->data.draw_callbacks_mutex);
for (size_t i = 0; i < obs->data.rendered_callbacks.num; ++i) {
struct rendered_callback *const callback =
&obs->data.rendered_callbacks.array[i];
callback->rendered(callback->param);
}
pthread_mutex_unlock(&obs->data.draw_callbacks_mutex);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-03 06:23:37 +00:00
GS_DEBUG_MARKER_END();
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(render_main_texture_name);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
}
(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-15 07:45:44 +00:00
static inline gs_effect_t *
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 21:34:13 +00:00
get_scale_effect_internal(struct obs_core_video_mix *mix)
(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-15 07:45:44 +00: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 21:34:13 +00:00
struct obs_core_video *video = &obs->video;
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
const struct video_output_info *info =
video_output_get_info(mix->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 21:34:13 +00:00
libobs: Use bilinear low res scale effect The normal scaling methods cannot sample enough pixels to create an accurate output image when the output size is under half the base size, so use the bilinear low resolution scaling effect in that case instead to ensure a more accurate low resolution image.
2015-04-06 14:35:09 +00:00
/* if the dimension is under half the size of the original image,
* bicubic/lanczos can't sample enough pixels to create an accurate
* image, so use the bilinear low resolution effect instead */
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
if (info->width < (mix->ovi.base_width / 2) &&
info->height < (mix->ovi.base_height / 2)) {
libobs: Use bilinear low res scale effect The normal scaling methods cannot sample enough pixels to create an accurate output image when the output size is under half the base size, so use the bilinear low resolution scaling effect in that case instead to ensure a more accurate low resolution image.
2015-04-06 14:35:09 +00:00
return video->bilinear_lowres_effect;
}
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
switch (mix->ovi.scale_type) {
(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-15 07:45:44 +00:00
case OBS_SCALE_BILINEAR:
return video->default_effect;
case OBS_SCALE_LANCZOS:
return video->lanczos_effect;
libobs: UI: Add Area scaling for downscale output Now that Lanczos downscale blurring has been removed, the Area shader can attempt to fill the void.
2019-08-15 05:29:30 +00:00
case OBS_SCALE_AREA:
return video->area_effect;
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 13:08:54 +00:00
case OBS_SCALE_BICUBIC:
default:;
(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-15 07:45:44 +00:00
}
return video->bicubic_effect;
}
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
static inline bool resolution_close(struct obs_core_video_mix *mix,
(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-15 07:45:44 +00:00
uint32_t width, uint32_t height)
{
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
long width_cmp = (long)mix->ovi.base_width - (long)width;
long height_cmp = (long)mix->ovi.base_height - (long)height;
(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-15 07:45:44 +00:00
return labs(width_cmp) <= 16 && labs(height_cmp) <= 16;
}
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 21:34:13 +00:00
static inline gs_effect_t *get_scale_effect(struct obs_core_video_mix *mix,
(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-15 07:45:44 +00:00
uint32_t width, uint32_t height)
{
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 21:34:13 +00:00
struct obs_core_video *video = &obs->video;
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
if (resolution_close(mix, width, height)) {
(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-15 07:45:44 +00:00
return video->default_effect;
} else {
/* if the scale method couldn't be loaded, use either bicubic
* or bilinear by 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 21:34:13 +00:00
gs_effect_t *effect = get_scale_effect_internal(mix);
(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-15 07:45:44 +00:00
if (!effect)
effect = !!video->bicubic_effect
? video->bicubic_effect
: video->default_effect;
return effect;
}
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
static const char *render_output_texture_name = "render_output_texture";
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
static inline gs_texture_t *
render_output_texture(struct obs_core_video_mix *mix)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
{
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
struct obs_video_info *const ovi = &mix->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 21:34:13 +00:00
gs_texture_t *texture = mix->render_texture;
gs_texture_t *target = mix->output_texture;
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
const uint32_t width = gs_texture_get_width(target);
const uint32_t height = gs_texture_get_height(target);
if ((width == ovi->base_width) && (height == ovi->base_height))
return texture;
Decklink: Keyer support
2018-06-23 22:21:07 +00:00
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
profile_start(render_output_texture_name);
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
gs_effect_t *effect = get_scale_effect(mix, width, height);
gs_technique_t *tech = gs_effect_get_technique(effect, "Draw");
(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-26 00:44:05 +00:00
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-18 04:11:18 +00:00
gs_eparam_t *bres =
gs_effect_get_param_by_name(effect, "base_dimension");
(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-15 07:45:44 +00:00
gs_eparam_t *bres_i =
gs_effect_get_param_by_name(effect, "base_dimension_i");
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
size_t passes, i;
(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-08 06:42:07 +00:00
gs_set_render_target(target, NULL);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
set_render_size(width, height);
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
if (bres) {
struct vec2 base;
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
vec2_set(&base, (float)mix->ovi.base_width,
(float)mix->ovi.base_height);
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-18 04:11:18 +00:00
gs_effect_set_vec2(bres, &base);
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
}
if (bres_i) {
struct vec2 base_i;
libobs: Allow overriding video resolution per view
2022-11-10 05:05:32 +00:00
vec2_set(&base_i, 1.0f / (float)mix->ovi.base_width,
1.0f / (float)mix->ovi.base_height);
(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-15 07:45:44 +00:00
gs_effect_set_vec2(bres_i, &base_i);
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
}
(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-15 07:45:44 +00:00
libobs: Final downsample with SRGB formats
2019-09-11 03:06:17 +00:00
gs_effect_set_texture_srgb(image, texture);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
libobs: Final downsample with SRGB formats
2019-09-11 03:06:17 +00:00
gs_enable_framebuffer_srgb(true);
Disable blending for colorspace conversion and subsampling only This should fix blending issues on stream/recording that weren't visible in the preview
2014-10-14 15:40:34 +00:00
gs_enable_blending(false);
(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-08 06:42:07 +00:00
passes = gs_technique_begin(tech);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
for (i = 0; i < passes; i++) {
(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-08 06:42:07 +00:00
gs_technique_begin_pass(tech, i);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
gs_draw_sprite(texture, 0, width, height);
(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-08 06:42:07 +00:00
gs_technique_end_pass(tech);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-08 06:42:07 +00:00
gs_technique_end(tech);
Disable blending for colorspace conversion and subsampling only This should fix blending issues on stream/recording that weren't visible in the preview
2014-10-14 15:40:34 +00:00
gs_enable_blending(true);
libobs: Final downsample with SRGB formats
2019-09-11 03:06:17 +00:00
gs_enable_framebuffer_srgb(false);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(render_output_texture_name);
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
return target;
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
}
libobs: Fix video warnings
2019-08-31 05:13:03 +00:00
static void render_convert_plane(gs_effect_t *effect, gs_texture_t *target,
const char *tech_name)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-27 06:21:41 +00:00
gs_technique_t *tech = gs_effect_get_technique(effect, tech_name);
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00: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-27 06:21:41 +00:00
const uint32_t width = gs_texture_get_width(target);
const uint32_t height = gs_texture_get_height(target);
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-17 02:28:21 +00: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-08 06:42:07 +00:00
gs_set_render_target(target, 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-27 06:21:41 +00:00
set_render_size(width, height);
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-17 02:28:21 +00: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-27 06:21:41 +00:00
size_t passes = gs_technique_begin(tech);
for (size_t i = 0; i < passes; i++) {
(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-08 06:42:07 +00:00
gs_technique_begin_pass(tech, i);
libobs: Full-screen triangle format conversions The cache coherency of rasterization for full-screen passes is better using an oversized triangle that is clipped rather than two triangles. Traversal order of rasterization is GPU-specific, but will almost certainly be better using an undivided primitive. A smaller benefit is that quads along the diagonal are not evaluated multiple times, but that's minor in comparison. Redo format shaders to bypass vertex buffer, and input layout. Add global shader bool "obs_glsl_compile" to make API-specific decisions, i.e. handle upside-down UVs. gl_ortho is not needed for format conversion because the vertex shader does not use ViewProj anymore. This can be applied to more situations, but start small first. Testbed full screen passes, Intel HD Graphics 530: RGBA -> UYVX: 467 -> 439 us, ~6% savings UYVX -> uv: 295 -> 239 us, ~19% savings
2019-06-02 13:49:38 +00:00
gs_draw(GS_TRIS, 0, 3);
(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-08 06:42:07 +00:00
gs_technique_end_pass(tech);
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-17 02:28:21 +00: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-08 06:42:07 +00:00
gs_technique_end(tech);
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-17 02:28:21 +00: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-27 06:21:41 +00:00
static const char *render_convert_texture_name = "render_convert_texture";
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 21:34:13 +00:00
static void render_convert_texture(struct obs_core_video_mix *video,
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-03 06:19:51 +00:00
gs_texture_t *const *const convert_textures,
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-27 06:21:41 +00:00
gs_texture_t *texture)
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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-27 06:21:41 +00:00
profile_start(render_convert_texture_name);
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 21:34:13 +00:00
gs_effect_t *effect = obs->video.conversion_effect;
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
gs_eparam_t *color_vec0 =
gs_effect_get_param_by_name(effect, "color_vec0");
gs_eparam_t *color_vec1 =
gs_effect_get_param_by_name(effect, "color_vec1");
gs_eparam_t *color_vec2 =
gs_effect_get_param_by_name(effect, "color_vec2");
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00:00
gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image");
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-27 06:21:41 +00:00
gs_eparam_t *width_i = gs_effect_get_param_by_name(effect, "width_i");
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
gs_eparam_t *height_i = gs_effect_get_param_by_name(effect, "height_i");
gs_eparam_t *sdr_white_nits_over_maximum = gs_effect_get_param_by_name(
effect, "sdr_white_nits_over_maximum");
libobs: Add max_luminance to obs_source_frame Used in situations where source luminance is greater than HDR nominal peak setting to avoid clipping by applying BT.2408 maxRGB EETF.
2022-05-22 08:19:17 +00:00
gs_eparam_t *hdr_lw = gs_effect_get_param_by_name(effect, "hdr_lw");
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00:00
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
struct vec4 vec0, vec1, vec2;
vec4_set(&vec0, video->color_matrix[4], video->color_matrix[5],
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
video->color_matrix[6], video->color_matrix[7]);
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
vec4_set(&vec1, video->color_matrix[0], video->color_matrix[1],
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
video->color_matrix[2], video->color_matrix[3]);
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
vec4_set(&vec2, video->color_matrix[8], video->color_matrix[9],
libobs: Rework RGB to YUV conversion RGB to YUV converison was previously baked into every scale shader, but this work has been moved to the YUV packing shaders. The scale shaders now write RGBA instead. In the case where base and output resolutions are identical, the render texture is forwarded directly to the YUV pack step, skipping an entire fullscreen pass. Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12 1920x1080, Before: RGBA -> UYVX: ~321 us UYVX -> Y: ~480 us UYVX -> UV: ~127 us 1920x1080, After: [forward render texture] RGBA -> Y: ~487 us RGBA -> UV: ~131 us 1920x1080 -> 1280x720, Before: RGBA -> UYVX: ~268 us UYVX -> Y: ~209 us UYVX -> UV: ~57 us 1920x1080 -> 1280x720, After: RGBA -> RGBA (rescale): ~268 us RGBA -> Y: ~210 us RGBA -> UV: ~58 us
2019-07-22 08:12:35 +00:00
video->color_matrix[10], video->color_matrix[11]);
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00:00
gs_enable_blending(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-03 06:19:51 +00:00
if (convert_textures[0]) {
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 19:31:08 +00:00
const float hdr_nominal_peak_level =
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 21:34:13 +00:00
obs->video.hdr_nominal_peak_level;
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
const float multiplier =
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 19:31:08 +00:00
obs_get_video_sdr_white_level() / 10000.f;
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-27 06:21:41 +00:00
gs_effect_set_texture(image, texture);
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
gs_effect_set_vec4(color_vec0, &vec0);
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
gs_effect_set_float(sdr_white_nits_over_maximum, multiplier);
libobs: Add max_luminance to obs_source_frame Used in situations where source luminance is greater than HDR nominal peak setting to avoid clipping by applying BT.2408 maxRGB EETF.
2022-05-22 08:19:17 +00:00
gs_effect_set_float(hdr_lw, hdr_nominal_peak_level);
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-03 06:19:51 +00:00
render_convert_plane(effect, convert_textures[0],
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-27 06:21:41 +00:00
video->conversion_techs[0]);
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-03 06:19:51 +00:00
if (convert_textures[1]) {
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-27 06:21:41 +00:00
gs_effect_set_texture(image, texture);
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
gs_effect_set_vec4(color_vec1, &vec1);
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-03 06:19:51 +00:00
if (!convert_textures[2])
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
gs_effect_set_vec4(color_vec2, &vec2);
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-27 06:21:41 +00:00
gs_effect_set_float(width_i, video->conversion_width_i);
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
gs_effect_set_float(height_i,
video->conversion_height_i);
gs_effect_set_float(sdr_white_nits_over_maximum,
multiplier);
libobs: Add max_luminance to obs_source_frame Used in situations where source luminance is greater than HDR nominal peak setting to avoid clipping by applying BT.2408 maxRGB EETF.
2022-05-22 08:19:17 +00:00
gs_effect_set_float(hdr_lw, hdr_nominal_peak_level);
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-03 06:19:51 +00:00
render_convert_plane(effect, convert_textures[1],
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-27 06:21:41 +00:00
video->conversion_techs[1]);
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-03 06:19:51 +00:00
if (convert_textures[2]) {
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-27 06:21:41 +00:00
gs_effect_set_texture(image, texture);
libobs: Separate textures for YUV input The shaders to unpack YUV information from the same texture were rather complicated. Breaking them up into separate textures makes the shaders much simpler, and we can remove the PRECISION_OFFSET hack. Performance also gets a nice boost on Intel for planar textures. Intel GPA, SetStablePowerState, Intel HD Graphics 530, 1920x1080 UYVY: 473 us -> 457 us YUY2: 492 us -> 422 us YVYU: 491 us -> 441 us I420: 1637 us -> 505 us I422: 1644 us -> 482 us I444: 1653 us -> 504 us NV12: 1656 us -> 369 us Y800 (limited): 270 us -> 277 us Y800 (full): 263 us -> 289 us RGB (limited): 341 us -> 411 us BGR3 (limited): 512 us -> 509 us BGR3 (full): 527 us -> 534 us
2019-08-10 03:43:14 +00:00
gs_effect_set_vec4(color_vec2, &vec2);
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-27 06:21:41 +00:00
gs_effect_set_float(width_i,
video->conversion_width_i);
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
gs_effect_set_float(height_i,
video->conversion_height_i);
gs_effect_set_float(sdr_white_nits_over_maximum,
multiplier);
libobs: Add max_luminance to obs_source_frame Used in situations where source luminance is greater than HDR nominal peak setting to avoid clipping by applying BT.2408 maxRGB EETF.
2022-05-22 08:19:17 +00:00
gs_effect_set_float(hdr_lw,
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 19:31:08 +00:00
hdr_nominal_peak_level);
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-27 06:21:41 +00:00
render_convert_plane(
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-03 06:19:51 +00:00
effect, convert_textures[2],
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-27 06:21:41 +00:00
video->conversion_techs[2]);
}
}
}
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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-27 06:21:41 +00:00
gs_enable_blending(true);
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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 08:03:21 +00:00
video->texture_converted = true;
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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-27 06:21:41 +00:00
profile_end(render_convert_texture_name);
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00:00
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
static const char *stage_output_texture_name = "stage_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-03 06:19:51 +00:00
static inline 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 21:34:13 +00:00
stage_output_texture(struct obs_core_video_mix *video, int cur_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-03 06:19:51 +00:00
gs_texture_t *const *const convert_textures,
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
gs_texture_t *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-03 06:19:51 +00:00
gs_stagesurf_t *const *const copy_surfaces,
size_t channel_count)
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-17 02:28:21 +00:00
{
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(stage_output_texture_name);
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-17 02:28:21 +00:00
unmap_last_surface(video);
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-27 06:21:41 +00:00
if (!video->gpu_conversion) {
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-03 06:19:51 +00:00
gs_stagesurf_t *copy = copy_surfaces[0];
libobs: Ensure active copy surfaces are active Stale surfaces can cause improper downloads from GPU, and lead to video corruption in certain cases.
2022-06-03 04:58:42 +00:00
if (copy)
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
gs_stage_texture(copy, output_texture);
libobs: Ensure active copy surfaces are active Stale surfaces can cause improper downloads from GPU, and lead to video corruption in certain cases.
2022-06-03 04:58:42 +00:00
video->active_copy_surfaces[cur_texture][0] = copy;
for (size_t i = 1; i < NUM_CHANNELS; ++i)
video->active_copy_surfaces[cur_texture][i] = 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-27 06:21:41 +00:00
video->textures_copied[cur_texture] = true;
} else if (video->texture_converted) {
libobs: Fix sign mismatch
2022-04-04 07:20:28 +00:00
for (size_t i = 0; i < channel_count; 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-03 06:19:51 +00:00
gs_stagesurf_t *copy = copy_surfaces[i];
libobs: Ensure active copy surfaces are active Stale surfaces can cause improper downloads from GPU, and lead to video corruption in certain cases.
2022-06-03 04:58:42 +00:00
if (copy)
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-03 06:19:51 +00:00
gs_stage_texture(copy, convert_textures[i]);
libobs: Ensure active copy surfaces are active Stale surfaces can cause improper downloads from GPU, and lead to video corruption in certain cases.
2022-06-03 04:58:42 +00:00
video->active_copy_surfaces[cur_texture][i] = copy;
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-27 06:21:41 +00:00
}
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
libobs: Ensure active copy surfaces are active Stale surfaces can cause improper downloads from GPU, and lead to video corruption in certain cases.
2022-06-03 04:58:42 +00:00
for (size_t i = channel_count; i < NUM_CHANNELS; ++i)
video->active_copy_surfaces[cur_texture][i] = 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-27 06:21:41 +00:00
video->textures_copied[cur_texture] = true;
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(stage_output_texture_name);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
}
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
static inline bool queue_frame(struct obs_core_video_mix *video,
bool raw_active,
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 08:03:21 +00:00
struct obs_vframe_info *vframe_info)
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-06 01:37:40 +00:00
{
bool duplicate =
!video->gpu_encoder_avail_queue.size ||
(video->gpu_encoder_queue.size && vframe_info->count > 1);
if (duplicate) {
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
struct obs_tex_frame *tf =
deque_data(&video->gpu_encoder_queue,
video->gpu_encoder_queue.size - sizeof(*tf));
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-06 01:37:40 +00:00
/* texture-based encoding is stopping */
if (!tf) {
return false;
}
tf->count++;
os_sem_post(video->gpu_encode_semaphore);
goto finish;
}
struct obs_tex_frame tf;
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_pop_front(&video->gpu_encoder_avail_queue, &tf, sizeof(tf));
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-06 01:37:40 +00:00
if (tf.released) {
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00:00
#ifdef _WIN32
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-06 01:37:40 +00:00
gs_texture_acquire_sync(tf.tex, tf.lock_key, GS_WAIT_INFINITE);
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00:00
#endif
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-06 01:37:40 +00:00
tf.released = false;
}
/* the vframe_info->count > 1 case causing a copy can only happen if by
* some chance the very first frame has to be duplicated for whatever
* reason. otherwise, it goes to the 'duplicate' case above, which
* will ensure better performance. */
if (raw_active || vframe_info->count > 1) {
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-03 06:19:51 +00:00
gs_copy_texture(tf.tex, video->convert_textures_encode[0]);
libobs: Copy both converted textures on stall for OpenGL As the comment mentions this only occurs during an encoder stall on the first frame. On D3D both gs_texture_t's are actually a single D3D texture object and both planes are copied during gs_copy_texture, for everyone else we need to copy the textures separately as they are independent OpenGL textures.
2024-01-28 03:18:12 +00:00
#ifndef _WIN32
/* Y and UV textures are views of the same texture on D3D, and
* gs_copy_texture will copy all views of the underlying
* texture. On other platforms, these are two distinct textures
* that must be copied separately. */
gs_copy_texture(tf.tex_uv, video->convert_textures_encode[1]);
#endif
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-06 01:37:40 +00: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-03 06:19:51 +00:00
gs_texture_t *tex = video->convert_textures_encode[0];
gs_texture_t *tex_uv = video->convert_textures_encode[1];
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-06 01:37:40 +00: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-03 06:19:51 +00:00
video->convert_textures_encode[0] = tf.tex;
video->convert_textures_encode[1] = tf.tex_uv;
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-06 01:37:40 +00:00
tf.tex = tex;
tf.tex_uv = tex_uv;
}
tf.count = 1;
tf.timestamp = vframe_info->timestamp;
tf.released = true;
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00:00
#ifdef _WIN32
libobs: Always query shared texture handle for encoding Always query the texture's shared handle in case the texture had to be rebuilt from a driver crash.
2019-03-03 20:36:31 +00:00
tf.handle = gs_texture_get_shared_handle(tf.tex);
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-06 01:37:40 +00:00
gs_texture_release_sync(tf.tex, ++tf.lock_key);
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00:00
#endif
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_push_back(&video->gpu_encoder_queue, &tf, sizeof(tf));
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-06 01:37:40 +00:00
os_sem_post(video->gpu_encode_semaphore);
finish:
return --vframe_info->count;
}
extern void full_stop(struct obs_encoder *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 21:34:13 +00:00
static inline void encode_gpu(struct obs_core_video_mix *video, bool raw_active,
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 08:03:21 +00:00
struct obs_vframe_info *vframe_info)
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-06 01:37:40 +00: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 08:03:21 +00:00
while (queue_frame(video, raw_active, vframe_info))
;
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-06 01:37:40 +00:00
}
static const char *output_gpu_encoders_name = "output_gpu_encoders";
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
static void output_gpu_encoders(struct obs_core_video_mix *video,
bool raw_active)
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-06 01:37:40 +00:00
{
profile_start(output_gpu_encoders_name);
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 08:03:21 +00:00
if (!video->texture_converted)
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-06 01:37:40 +00:00
goto end;
libobs: Fix crash starting raw encoder before gpu encoder Fixes a crash when starting a raw encoder before a GPU encoder.
2019-02-11 06:22:31 +00:00
if (!video->vframe_info_buffer_gpu.size)
goto end;
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-06 01:37:40 +00:00
struct obs_vframe_info vframe_info;
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_pop_front(&video->vframe_info_buffer_gpu, &vframe_info,
sizeof(vframe_info));
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-06 01:37:40 +00:00
pthread_mutex_lock(&video->gpu_encoder_mutex);
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 08:03:21 +00:00
encode_gpu(video, raw_active, &vframe_info);
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-06 01:37:40 +00:00
pthread_mutex_unlock(&video->gpu_encoder_mutex);
end:
profile_end(output_gpu_encoders_name);
}
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
static inline void render_video(struct obs_core_video_mix *video,
bool raw_active, const bool gpu_active,
int cur_texture)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-08 06:42:07 +00:00
gs_begin_scene();
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-08 06:42:07 +00:00
gs_enable_depth_test(false);
gs_set_cull_mode(GS_NEITHER);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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 08:03:21 +00:00
render_main_texture(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-17 02:28:21 +00: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-06 01:37:40 +00:00
if (raw_active || gpu_active) {
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-03 06:19:51 +00:00
gs_texture_t *const *convert_textures = video->convert_textures;
gs_stagesurf_t *const *copy_surfaces =
video->copy_surfaces[cur_texture];
size_t channel_count = NUM_CHANNELS;
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
gs_texture_t *output_texture = render_output_texture(video);
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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-03 06:19:51 +00:00
if (gpu_active) {
convert_textures = video->convert_textures_encode;
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00: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-03 06:19:51 +00:00
copy_surfaces = video->copy_surfaces_encode;
channel_count = 1;
libobs,libobs-opengl: enable GPU encoding for OpenGL Enable all of the previously Windows only paths for OpenGL backends that support encode_texture2 Co-authored-by: Torge Matthies <openglfreak@googlemail.com>
2023-02-07 05:13:08 +00:00
#endif
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-06 01:37:40 +00:00
gs_flush();
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-03 06:19:51 +00: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-06 01:37:40 +00:00
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
if (video->gpu_conversion) {
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-03 06:19:51 +00:00
render_convert_texture(video, convert_textures,
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
output_texture);
}
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-02-01 02:54:36 +00: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-06 01:37:40 +00:00
if (gpu_active) {
gs_flush();
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 08:03:21 +00:00
output_gpu_encoders(video, raw_active);
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-06 01:37:40 +00: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-27 06:21:41 +00:00
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
if (raw_active) {
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-03 06:19:51 +00:00
stage_output_texture(video, cur_texture,
libobs: Keep output as premultiplied alpha Simplify code until someone needs straight alpha.
2022-09-08 07:35:26 +00:00
convert_textures, output_texture,
copy_surfaces, channel_count);
}
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-02-01 02:54:36 +00:00
}
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-08 06:42:07 +00:00
gs_set_render_target(NULL, NULL);
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-17 02:28:21 +00:00
gs_enable_blending(true);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-08 06:42:07 +00:00
gs_end_scene();
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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 21:34:13 +00:00
static inline bool download_frame(struct obs_core_video_mix *video,
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 20:37:56 +00:00
int prev_texture, struct video_data *frame)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
{
if (!video->textures_copied[prev_texture])
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
return false;
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-27 06:21:41 +00:00
for (int channel = 0; channel < NUM_CHANNELS; ++channel) {
gs_stagesurf_t *surface =
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-03 06:19:51 +00:00
video->active_copy_surfaces[prev_texture][channel];
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-27 06:21:41 +00:00
if (surface) {
if (!gs_stagesurface_map(surface, &frame->data[channel],
&frame->linesize[channel]))
return false;
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00: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-27 06:21:41 +00:00
video->mapped_surfaces[channel] = surface;
}
}
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
return true;
}
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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-27 06:21:41 +00:00
static const uint8_t *set_gpu_converted_plane(uint32_t width, uint32_t height,
uint32_t linesize_input,
uint32_t linesize_output,
const uint8_t *in, uint8_t *out)
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-17 02:28:21 +00: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-27 06:21:41 +00:00
if ((width == linesize_input) && (width == linesize_output)) {
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
size_t total = (size_t)width * (size_t)height;
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-27 06:21:41 +00:00
memcpy(out, in, total);
in += total;
} else {
for (size_t y = 0; y < height; y++) {
memcpy(out, in, width);
out += linesize_output;
in += linesize_input;
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-17 02:28:21 +00: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-27 06:21:41 +00:00
return in;
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-17 02:28:21 +00:00
}
libobs: Remove unused parameters
2022-07-20 06:07:04 +00:00
static void set_gpu_converted_data(struct video_frame *output,
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 09:53:13 +00:00
const struct video_data *input,
const struct video_output_info *info)
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-17 02:28:21 +00: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-03 06:19:51 +00:00
switch (info->format) {
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-27 06:21:41 +00:00
const uint32_t width = info->width;
const uint32_t height = 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-03 06:19:51 +00:00
set_gpu_converted_plane(width, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
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-27 06:21:41 +00: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-03 06:19:51 +00:00
const uint32_t width_d2 = width / 2;
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-27 06:21:41 +00:00
const uint32_t height_d2 = 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-03 06:19:51 +00:00
set_gpu_converted_plane(width_d2, height_d2, input->linesize[1],
output->linesize[1], input->data[1],
output->data[1]);
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-17 02:28:21 +00: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-03 06:19:51 +00:00
set_gpu_converted_plane(width_d2, height_d2, input->linesize[2],
output->linesize[2], input->data[2],
output->data[2]);
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-27 06:21:41 +00: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-03 06:19:51 +00:00
break;
}
case VIDEO_FORMAT_NV12: {
const uint32_t width = info->width;
const uint32_t height = info->height;
const uint32_t height_d2 = height / 2;
if (input->linesize[1]) {
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-27 06:21:41 +00:00
set_gpu_converted_plane(width, height,
input->linesize[0],
output->linesize[0],
input->data[0],
output->data[0]);
set_gpu_converted_plane(width, height_d2,
input->linesize[1],
output->linesize[1],
input->data[1],
output->data[1]);
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-03 06:19:51 +00:00
} else {
const uint8_t *const in_uv = set_gpu_converted_plane(
width, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
set_gpu_converted_plane(width, height_d2,
input->linesize[0],
output->linesize[1], in_uv,
output->data[1]);
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-27 06:21:41 +00: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-03 06:19:51 +00:00
break;
}
case VIDEO_FORMAT_I444: {
const uint32_t width = info->width;
const uint32_t height = info->height;
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-27 06:21:41 +00: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-03 06:19:51 +00:00
set_gpu_converted_plane(width, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
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-27 06:21:41 +00: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-03 06:19:51 +00:00
set_gpu_converted_plane(width, height, input->linesize[1],
output->linesize[1], input->data[1],
output->data[1]);
libobs: Use NV12 textures when available
2018-10-06 03:18:15 +00: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-03 06:19:51 +00:00
set_gpu_converted_plane(width, height, input->linesize[2],
output->linesize[2], input->data[2],
output->data[2]);
libobs: Fix video warnings
2019-08-31 05:13:03 +00: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-03 06:19:51 +00:00
break;
}
libobs: Add I010/P010 support, TRC enum
2022-04-03 07:00:38 +00:00
case VIDEO_FORMAT_I010: {
const uint32_t width = info->width;
const uint32_t height = info->height;
set_gpu_converted_plane(width * 2, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
const uint32_t height_d2 = height / 2;
set_gpu_converted_plane(width, height_d2, input->linesize[1],
output->linesize[1], input->data[1],
output->data[1]);
set_gpu_converted_plane(width, height_d2, input->linesize[2],
output->linesize[2], input->data[2],
output->data[2]);
break;
}
case VIDEO_FORMAT_P010: {
const uint32_t width_x2 = info->width * 2;
const uint32_t height = info->height;
const uint32_t height_d2 = height / 2;
if (input->linesize[1]) {
set_gpu_converted_plane(width_x2, height,
input->linesize[0],
output->linesize[0],
input->data[0],
output->data[0]);
set_gpu_converted_plane(width_x2, height_d2,
input->linesize[1],
output->linesize[1],
input->data[1],
output->data[1]);
} else {
const uint8_t *const in_uv = set_gpu_converted_plane(
width_x2, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
set_gpu_converted_plane(width_x2, height_d2,
input->linesize[0],
output->linesize[1], in_uv,
output->data[1]);
}
break;
}
libobs,UI: Add P216/P416 pixel formats Will be useful for ProRes.
2022-11-21 03:11:27 +00:00
case VIDEO_FORMAT_P216: {
const uint32_t width_x2 = info->width * 2;
const uint32_t height = info->height;
set_gpu_converted_plane(width_x2, height, input->linesize[0],
output->linesize[0], input->data[0],
output->data[0]);
set_gpu_converted_plane(width_x2, height, input->linesize[1],
output->linesize[1], input->data[1],
output->data[1]);
break;
}
case VIDEO_FORMAT_P416: {
const uint32_t height = info->height;
set_gpu_converted_plane(info->width * 2, height,
input->linesize[0], output->linesize[0],
input->data[0], output->data[0]);
set_gpu_converted_plane(info->width * 4, height,
input->linesize[1], output->linesize[1],
input->data[1], output->data[1]);
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-03 06:19:51 +00:00
case VIDEO_FORMAT_NONE:
case VIDEO_FORMAT_YVYU:
case VIDEO_FORMAT_YUY2:
case VIDEO_FORMAT_UYVY:
case VIDEO_FORMAT_RGBA:
case VIDEO_FORMAT_BGRA:
case VIDEO_FORMAT_BGRX:
case VIDEO_FORMAT_Y800:
case VIDEO_FORMAT_BGR3:
libobs: Add support for YUV422P10LE, YUV444P12LE, YUVA444P12LE
2022-04-19 17:37:07 +00:00
case VIDEO_FORMAT_I412:
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-03 06:19:51 +00:00
case VIDEO_FORMAT_I422:
libobs: Add support for YUV422P10LE, YUV444P12LE, YUVA444P12LE
2022-04-19 17:37:07 +00:00
case VIDEO_FORMAT_I210:
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-03 06:19:51 +00:00
case VIDEO_FORMAT_I40A:
case VIDEO_FORMAT_I42A:
case VIDEO_FORMAT_YUVA:
libobs: Add support for YUV422P10LE, YUV444P12LE, YUVA444P12LE
2022-04-19 17:37:07 +00:00
case VIDEO_FORMAT_YA2L:
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-03 06:19:51 +00:00
case VIDEO_FORMAT_AYUV:
libobs: Add missing VIDEO_FORMAT_V210 handling in switch statements Format was added to enum but not handled in all switch statement handling the enum.
2023-03-26 14:03:30 +00:00
case VIDEO_FORMAT_V210:
libobs: Add VIDEO_FORMAT_R10L Support 10-bit packed format that DeckLink uses.
2023-04-03 00:49:35 +00:00
case VIDEO_FORMAT_R10L:
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-03 06:19:51 +00:00
/* unimplemented */
;
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-17 02:28:21 +00:00
}
}
libobs: Fix RGB output RGB output wasn't occurring due to the fact that the frame simply wasn't being copied.
2015-04-16 01:41:09 +00:00
static inline void copy_rgbx_frame(struct video_frame *output,
const struct video_data *input,
const struct video_output_info *info)
{
uint8_t *in_ptr = input->data[0];
uint8_t *out_ptr = output->data[0];
libobs: Use one copy for RGBA output when possible A minor optimization: in copy_rgbx_frame (used when libobs is set to output RGBA frames instead of YUV frames), if the line sizes for the source and destination match, just use a single memcpy call for all of the data instead of multiple memcpy calls.
2015-07-21 15:58:37 +00:00
/* if the line sizes match, do a single copy */
if (input->linesize[0] == output->linesize[0]) {
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
memcpy(out_ptr, in_ptr,
(size_t)input->linesize[0] * (size_t)info->height);
libobs: Use one copy for RGBA output when possible A minor optimization: in copy_rgbx_frame (used when libobs is set to output RGBA frames instead of YUV frames), if the line sizes for the source and destination match, just use a single memcpy call for all of the data instead of multiple memcpy calls.
2015-07-21 15:58:37 +00:00
} else {
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
const size_t copy_size = (size_t)info->width * 4;
libobs: Use one copy for RGBA output when possible A minor optimization: in copy_rgbx_frame (used when libobs is set to output RGBA frames instead of YUV frames), if the line sizes for the source and destination match, just use a single memcpy call for all of the data instead of multiple memcpy calls.
2015-07-21 15:58:37 +00:00
for (size_t y = 0; y < info->height; y++) {
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
memcpy(out_ptr, in_ptr, copy_size);
libobs: Use one copy for RGBA output when possible A minor optimization: in copy_rgbx_frame (used when libobs is set to output RGBA frames instead of YUV frames), if the line sizes for the source and destination match, just use a single memcpy call for all of the data instead of multiple memcpy calls.
2015-07-21 15:58:37 +00:00
in_ptr += input->linesize[0];
out_ptr += output->linesize[0];
}
libobs: Fix RGB output RGB output wasn't occurring due to the fact that the frame simply wasn't being copied.
2015-04-16 01:41:09 +00: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 21:34:13 +00:00
static inline void output_video_data(struct obs_core_video_mix *video,
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 09:53:13 +00:00
struct video_data *input_frame, int count)
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
{
const struct video_output_info *info;
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 09:53:13 +00:00
struct video_frame output_frame;
bool locked;
(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 22:07:54 +00:00
info = video_output_get_info(video->video);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00: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 09:53:13 +00:00
locked = video_output_lock_frame(video->video, &output_frame, count,
input_frame->timestamp);
if (locked) {
if (video->gpu_conversion) {
libobs: Remove unused parameters
2022-07-20 06:07:04 +00:00
set_gpu_converted_data(&output_frame, input_frame,
info);
libobs: Fix RGB output RGB output wasn't occurring due to the fact that the frame simply wasn't being copied.
2015-04-16 01:41:09 +00:00
} else {
copy_rgbx_frame(&output_frame, input_frame, info);
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 09:53:13 +00: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-17 02:28:21 +00: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 09:53:13 +00:00
video_output_unlock_frame(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-17 02:28:21 +00: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 09:53:13 +00:00
}
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
libobs: Add `obs_encoder_group_keyframe_aligned_encoders` Ensures grouped encoders start on the same input frame
2023-09-06 16:59:12 +00:00
void add_ready_encoder_group(obs_encoder_t *encoder)
{
obs_weak_encoder_t *weak = obs_encoder_get_weak_encoder(encoder);
pthread_mutex_lock(&obs->video.encoder_group_mutex);
da_push_back(obs->video.ready_encoder_groups, &weak);
pthread_mutex_unlock(&obs->video.encoder_group_mutex);
}
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
static inline void video_sleep(struct obs_core_video *video, uint64_t *p_time,
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 09:53:13 +00:00
uint64_t interval_ns)
{
struct obs_vframe_info vframe_info;
uint64_t cur_time = *p_time;
uint64_t t = cur_time + interval_ns;
int count;
libobs: Fix sync bug in new frame handling code The return value of os_sleepto_ns is true if it waited to the specified time, and false if the current time is past the specified time. So it basically returns true if it successfully waited. I just didn't check the return value properly here, so it ended up just setting the count of frames to 1 if overshot, ultimately causing sync issues.
2015-01-05 22:07:22 +00:00
if (os_sleepto_ns(t)) {
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 09:53:13 +00:00
*p_time = t;
count = 1;
} else {
libobs: Clamp video timing for safety os_gettime_ns and os_sleepto_ns may not match up exactly.
2022-02-28 17:15:31 +00:00
const uint64_t udiff = os_gettime_ns() - cur_time;
int64_t diff;
memcpy(&diff, &udiff, sizeof(diff));
libobs: Fix sign-compare warning `diff` is used only if greater than `interval_ns` which is unsigned. So casting it as unsigned will not change its sign.
2022-03-18 07:37:36 +00:00
const uint64_t clamped_diff = (diff > (int64_t)interval_ns)
? (uint64_t)diff
: interval_ns;
libobs: Clamp video timing for safety os_gettime_ns and os_sleepto_ns may not match up exactly.
2022-02-28 17:15:31 +00:00
count = (int)(clamped_diff / interval_ns);
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 09:53:13 +00:00
*p_time = cur_time + interval_ns * count;
}
libobs: Report lost frame count due to rendering lag This has been missing for a bit too long, and should make it easier/faster to diagnose issues users might be having.
2016-01-25 11:58:51 +00:00
video->total_frames += count;
video->lagged_frames += count - 1;
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 09:53:13 +00:00
vframe_info.timestamp = cur_time;
vframe_info.count = count;
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-06 01:37:40 +00:00
libobs: Add `obs_encoder_group_keyframe_aligned_encoders` Ensures grouped encoders start on the same input frame
2023-09-06 16:59:12 +00:00
pthread_mutex_lock(&video->encoder_group_mutex);
for (size_t i = 0; i < video->ready_encoder_groups.num; i++) {
obs_encoder_t *encoder = obs_weak_encoder_get_encoder(
video->ready_encoder_groups.array[i]);
obs_weak_encoder_release(video->ready_encoder_groups.array[i]);
if (!encoder)
continue;
if (encoder->encoder_group) {
struct encoder_group *group = encoder->encoder_group;
pthread_mutex_lock(&group->mutex);
if (group->encoders_added == group->encoders_started &&
!group->start_timestamp) {
group->start_timestamp = *p_time;
}
pthread_mutex_unlock(&group->mutex);
}
obs_encoder_release(encoder);
}
da_clear(video->ready_encoder_groups);
pthread_mutex_unlock(&video->encoder_group_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 21:34:13 +00: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-12 01:01:29 +00:00
struct obs_core_video_mix *video = 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 21:34:13 +00:00
bool raw_active = video->raw_was_active;
bool gpu_active = video->gpu_was_active;
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
if (raw_active)
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_push_back(&video->vframe_info_buffer,
&vframe_info, sizeof(vframe_info));
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
if (gpu_active)
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_push_back(&video->vframe_info_buffer_gpu,
&vframe_info, sizeof(vframe_info));
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 21:34:13 +00:00
}
pthread_mutex_unlock(&obs->video.mixes_mutex);
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
static const char *output_frame_gs_context_name = "gs_context(video->graphics)";
static const char *output_frame_render_video_name = "render_video";
static const char *output_frame_download_frame_name = "download_frame";
static const char *output_frame_gs_flush_name = "gs_flush";
static const char *output_frame_output_video_data_name = "output_video_data";
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 21:34:13 +00:00
static inline void output_frame(struct obs_core_video_mix *video)
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00: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 21:34:13 +00:00
const bool raw_active = video->raw_was_active;
const bool gpu_active = video->gpu_was_active;
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
int cur_texture = video->cur_texture;
int prev_texture = cur_texture == 0 ? NUM_TEXTURES - 1
: cur_texture - 1;
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 20:37:56 +00:00
struct video_data frame;
libobs: Clear all compiler warnings
2019-02-20 22:26:21 +00:00
bool frame_ready = 0;
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
Implement automatic video scaling (if requested) Add a scaler interface (defaults to swscale), and if a separate output wants to use a different scale or format than the default output format, allow a scaler instance to be created automatically for that output, which will then receive the new scaled output.
2014-02-18 20:37:56 +00:00
memset(&frame, 0, sizeof(struct video_data));
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(output_frame_gs_context_name);
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 21:34:13 +00:00
gs_enter_context(obs->video.graphics);
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(output_frame_render_video_name);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-03 06:23:37 +00:00
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_RENDER_VIDEO,
output_frame_render_video_name);
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 08:03:21 +00:00
render_video(video, raw_active, gpu_active, cur_texture);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-03 06:23:37 +00:00
GS_DEBUG_MARKER_END();
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(output_frame_render_video_name);
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-02-01 02:54:36 +00:00
if (raw_active) {
profile_start(output_frame_download_frame_name);
frame_ready = download_frame(video, prev_texture, &frame);
profile_end(output_frame_download_frame_name);
}
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(output_frame_gs_flush_name);
libobs: Add flush to video pipeline On certain GPUs, if you don't flush and the window is minimized it can endlessly accumulate memory due to what I'm assuming are driver design flaws (though I can't know for sure). The flush seems to prevent this from happening, at least from my tests. It would be nice if this weren't necessary.
2014-12-04 06:14:23 +00:00
gs_flush();
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(output_frame_gs_flush_name);
(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-08 06:42:07 +00:00
gs_leave_context();
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(output_frame_gs_context_name);
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00: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-02-01 02:54:36 +00:00
if (raw_active && frame_ready) {
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 09:53:13 +00:00
struct obs_vframe_info vframe_info;
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_pop_front(&video->vframe_info_buffer, &vframe_info,
sizeof(vframe_info));
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-22 03:08:39 +00: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 09:53:13 +00:00
frame.timestamp = vframe_info.timestamp;
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_start(output_frame_output_video_data_name);
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 09:53:13 +00:00
output_video_data(video, &frame, vframe_info.count);
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
profile_end(output_frame_output_video_data_name);
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-22 03:08:39 +00:00
}
first commit
2013-10-01 02:37:13 +00:00
Implement output scaling/conversion/downloading - Implement texture scaling/conversion/downloading for the main view so we can finally start getting data to output. Also, redesign how it works a bit, it will now properly wait one full frame for each step in the process: rendering the main texture, scaling the main texture to an output texture, staging/downloading the ouput texture, and then outputting that staged data. This way, the GPU will have more than enough time to fully complete each step. - Fix a bug with OpenGL plugin's texture staging function. Was using glBindBuffer instead of what should have been used: glBindTexture. - Change the naming scheme of the variables in default.effect. It's now named with the idea of just "color matrix" in mind instead of "yuv matrix", and instead of DrawRGBToYUV, it's now just DrawMatrix.
2014-02-06 03:36:21 +00:00
if (++video->cur_texture == NUM_TEXTURES)
video->cur_texture = 0;
first commit
2013-10-01 02:37:13 +00: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 21:34:13 +00:00
static inline void output_frames(void)
{
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-12 01:01:29 +00: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 21:34:13 +00:00
if (mix->view) {
output_frame(mix);
} else {
libobs: Fix gpu thread termination when additional video mixes are added
2022-08-12 01:01:29 +00:00
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 21:34:13 +00:00
obs_free_video_mix(mix);
da_erase(obs->video.mixes, i);
i--;
num--;
}
}
pthread_mutex_unlock(&obs->video.mixes_mutex);
}
libobs: Use byte sequence for non-breaking spaces Use explicit UTF-8 byte sequence for the "no-break space" character. Prevents issues with certain editors, and fixes the following compiler warning on Visual C++: warning C4819: The file contains a character that cannot be represented in the current code page (X). Save the file in Unicode format to prevent data loss
2015-10-15 08:00:14 +00:00
#define NBSP "\xC2\xA0"
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 21:34:13 +00:00
static void clear_base_frame_data(struct obs_core_video_mix *video)
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-02-01 02:54:36 +00: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 08:03:21 +00:00
video->texture_rendered = false;
video->texture_converted = false;
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_free(&video->vframe_info_buffer);
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-02-01 02:54:36 +00:00
video->cur_texture = 0;
}
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 21:34:13 +00:00
static void clear_raw_frame_data(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-06 01:37:40 +00:00
{
memset(video->textures_copied, 0, sizeof(video->textures_copied));
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_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-06 01:37:40 +00: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 21:34:13 +00:00
static void clear_gpu_frame_data(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-06 01:37:40 +00:00
{
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_free(&video->vframe_info_buffer_gpu);
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-06 01:37:40 +00:00
}
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 17:39:24 +00:00
extern THREAD_LOCAL bool is_graphics_thread;
static void execute_graphics_tasks(void)
{
struct obs_core_video *video = &obs->video;
bool tasks_remaining = true;
while (tasks_remaining) {
pthread_mutex_lock(&video->task_mutex);
if (video->tasks.size) {
struct obs_task_info info;
libobs: Replace circlebuf with deque
2023-11-30 15:11:18 +00:00
deque_pop_front(&video->tasks, &info, sizeof(info));
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 17:39:24 +00:00
info.task(info.param);
}
tasks_remaining = !!video->tasks.size;
pthread_mutex_unlock(&video->task_mutex);
}
}
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
#ifdef _WIN32
struct winrt_exports {
void (*winrt_initialize)();
void (*winrt_uninitialize)();
struct winrt_disaptcher *(*winrt_dispatcher_init)();
void (*winrt_dispatcher_free)(struct winrt_disaptcher *dispatcher);
void (*winrt_capture_thread_start)();
void (*winrt_capture_thread_stop)();
};
#define WINRT_IMPORT(func) \
do { \
exports->func = os_dlsym(module, #func); \
if (!exports->func) { \
success = false; \
blog(LOG_ERROR, \
"Could not load function '%s' from " \
"module '%s'", \
#func, module_name); \
} \
} while (false)
static bool load_winrt_imports(struct winrt_exports *exports, void *module,
const char *module_name)
{
bool success = true;
WINRT_IMPORT(winrt_initialize);
WINRT_IMPORT(winrt_uninitialize);
WINRT_IMPORT(winrt_dispatcher_init);
WINRT_IMPORT(winrt_dispatcher_free);
WINRT_IMPORT(winrt_capture_thread_start);
WINRT_IMPORT(winrt_capture_thread_stop);
return success;
}
struct winrt_state {
bool loaded;
void *winrt_module;
struct winrt_exports exports;
struct winrt_disaptcher *dispatcher;
};
static void init_winrt_state(struct winrt_state *winrt)
{
static const char *const module_name = "libobs-winrt";
winrt->winrt_module = os_dlopen(module_name);
winrt->loaded = winrt->winrt_module &&
load_winrt_imports(&winrt->exports, winrt->winrt_module,
module_name);
winrt->dispatcher = NULL;
if (winrt->loaded) {
winrt->exports.winrt_initialize();
winrt->dispatcher = winrt->exports.winrt_dispatcher_init();
gs_enter_context(obs->video.graphics);
winrt->exports.winrt_capture_thread_start();
gs_leave_context();
}
}
static void uninit_winrt_state(struct winrt_state *winrt)
{
if (winrt->winrt_module) {
if (winrt->loaded) {
winrt->exports.winrt_capture_thread_stop();
if (winrt->dispatcher)
winrt->exports.winrt_dispatcher_free(
winrt->dispatcher);
winrt->exports.winrt_uninitialize();
}
os_dlclose(winrt->winrt_module);
}
}
#endif // #ifdef _WIN32
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
static const char *tick_sources_name = "tick_sources";
static const char *render_displays_name = "render_displays";
static const char *output_frame_name = "output_frame";
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 21:34:13 +00:00
static inline void update_active_state(struct obs_core_video_mix *video)
first commit
2013-10-01 02:37:13 +00: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 21:34:13 +00:00
const bool raw_was_active = video->raw_was_active;
const bool gpu_was_active = video->gpu_was_active;
const bool was_active = video->was_active;
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00: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 21:34:13 +00:00
bool raw_active = os_atomic_load_long(&video->raw_active) > 0;
libobs: Mark raw_active and gpu_encoder_active as volatile These were operated on by atomic functions but were not marked as volatile or loaded with os_atomic_load_long, potentially introducing subtle race conditions. Detected by ThreadSanitizer.
2022-01-16 18:08:41 +00:00
const bool gpu_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 21:34:13 +00:00
os_atomic_load_long(&video->gpu_encoder_active) > 0;
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
const bool active = raw_active || gpu_active;
first commit
2013-10-01 02:37:13 +00: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 21:34:13 +00:00
if (!was_active && active)
clear_base_frame_data(video);
if (!raw_was_active && raw_active)
clear_raw_frame_data(video);
if (!gpu_was_active && gpu_active)
clear_gpu_frame_data(video);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 17:39:24 +00: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 21:34:13 +00:00
video->gpu_was_active = gpu_active;
video->raw_was_active = raw_active;
video->was_active = active;
}
static inline void update_active_states(void)
{
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-12 01:01:29 +00:00
update_active_state(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 21:34:13 +00:00
pthread_mutex_unlock(&obs->video.mixes_mutex);
}
static inline bool stop_requested(void)
{
bool success = true;
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-12 01:01:29 +00:00
if (!video_output_stopped(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 21:34:13 +00:00
success = false;
pthread_mutex_unlock(&obs->video.mixes_mutex);
return success;
}
bool obs_graphics_thread_loop(struct obs_graphics_context *context)
{
uint64_t frame_start = os_gettime_ns();
uint64_t frame_time_ns;
update_active_states();
libobs: Save clamped video time The "clamped" video time is the system time per video frame that is closest to the current system time, but always divisible by the frame interval. For example, if the last frame system timestamp was 1600 and the new frame is 2500, but the frame interval is 800, then the "clamped" video time is 2400. This clamped value is useful to get the relative system time without any jitter.
2015-06-04 23:48:56 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_start(context->video_thread_name);
Set various thread names Helps identify which threads are which when debugging
2015-01-02 13:36:09 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
gs_enter_context(obs->video.graphics);
gs_begin_frame();
gs_leave_context();
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_start(tick_sources_name);
context->last_time =
tick_sources(obs->video.video_time, context->last_time);
profile_end(tick_sources_name);
libobs: Initialize randomization seed in video thread Ensures that any rand() calls in the video thread will have a unique seed to start from.
2017-10-04 01:48:12 +00: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-06 01:37:40 +00:00
#ifdef _WIN32
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
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-06 01:37:40 +00:00
#endif
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_start(output_frame_name);
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 21:34:13 +00:00
output_frames();
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_end(output_frame_name);
libobs: Clear all compiler warnings
2019-02-20 22:26:21 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_start(render_displays_name);
render_displays();
profile_end(render_displays_name);
libobs: Add function to get average render time Useful for real-time rendering statistics
2017-05-12 23:21:51 +00:00
libobs: Move position for calling execute_graphics_tasks The new order is as below: [message pump] output_frame render_displays execute_graphics_tasks
2021-12-24 02:06:13 +00:00
execute_graphics_tasks();
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
frame_time_ns = os_gettime_ns() - frame_start;
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_end(context->video_thread_name);
libobs: Add gs_begin_frame for duplicators We really shouldn't be resetting duplicator state as part of gs_flush. gs_begin_scene is not ideal because it is called twice per frame, and only after duplicators have been ticked. Even though it makes no user-facing difference, it makes more logical sense to reset at the top of the frame than the bottom.
2019-10-11 04:06:01 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
profile_reenable_thread();
Implement output, improve video/audio subsystems - Fill in the rest of the FFmpeg test output code for testing so it actually properly outputs data. - Improve the main video subsystem to be a bit more optimal and automatically output I420 or NV12 if needed. - Fix audio subsystem insertation and byte calculation. Now it will seamlessly insert new audio data in to the audio stream based upon its timestamp value. (Be extremely cautious when using floating point calculations for important things like this, and always round your values and check your values) - Use 32 byte alignment in case of future optimizations and export a function to get the current alignment. - Make os_sleepto_ns return true if slept, false if the time has already been passed before the call. - Fix sinewave output so that it actually properly calculates a middle C sinewave. - Change the use of row_bytes to linesize (also makes it a bit more consistent with FFmpeg's naming as well)
2014-02-09 12:51:06 +00:00
libobs: Format changes for multiple video mixes
2022-06-15 17:07:50 +00:00
video_sleep(&obs->video, &obs->video.video_time, context->interval);
libobs: Add task scheduling features (This commit also modifies the UI) Adds the ability to schedule tasks for certain threads
2020-03-14 17:39:24 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
context->frame_time_total_ns += frame_time_ns;
context->fps_total_ns += (obs->video.video_time - context->last_time);
context->fps_total_frames++;
libobs: Pump Win32 messages on the graphics thread Necessary for upcoming Windows Graphics Capture support.
2019-11-28 00:38:35 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
if (context->fps_total_ns >= 1000000000ULL) {
obs->video.video_fps =
(double)context->fps_total_frames /
((double)context->fps_total_ns / 1000000000.0);
obs->video.video_avg_frame_time_ns =
context->frame_time_total_ns /
(uint64_t)context->fps_total_frames;
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
context->frame_time_total_ns = 0;
context->fps_total_ns = 0;
context->fps_total_frames = 0;
}
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-02 02:33:44 +00: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 21:34:13 +00:00
return !stop_requested();
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
}
libobs: Add function to get average render time Useful for real-time rendering statistics
2017-05-12 23:21:51 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
void *obs_graphics_thread(void *param)
{
#ifdef _WIN32
struct winrt_state winrt;
init_winrt_state(&winrt);
#endif // #ifdef _WIN32
libobs: Add profiler calls
2015-07-11 06:04:46 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
is_graphics_thread = true;
libobs: Move video_sleep call
2015-07-08 12:25:07 +00: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 21:34:13 +00:00
const uint64_t interval = obs->video.video_frame_interval_ns;
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 19:04:23 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
obs->video.video_time = os_gettime_ns();
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 19:04:23 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
os_set_thread_name("libobs: graphics thread");
libobs: Add function to get average render time Useful for real-time rendering statistics
2017-05-12 23:21:51 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
const char *video_thread_name = profile_store_name(
obs_get_profiler_name_store(),
"obs_graphics_thread(%g" NBSP "ms)", interval / 1000000.);
profile_register_root(video_thread_name, interval);
libobs: Pump graphics loop one final time for cleanup
2020-02-24 03:43:10 +00:00
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
srand((unsigned int)time(NULL));
struct obs_graphics_context 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 21:34:13 +00:00
context.interval = interval;
libobs: Use autoreleasepool for graphics thread Apparently necessary to clean up macOS leaks.
2020-06-08 16:38:00 +00:00
context.frame_time_total_ns = 0;
context.fps_total_ns = 0;
context.fps_total_frames = 0;
context.last_time = 0;
context.video_thread_name = video_thread_name;
#ifdef __APPLE__
while (obs_graphics_thread_loop_autorelease(&context))
#else
while (obs_graphics_thread_loop(&context))
#endif
;
first commit
2013-10-01 02:37:13 +00:00
libobs: WinRT and dispatcher init on graphics thread Suspected necessary for WGC stability.
2020-05-21 07:23:26 +00:00
#ifdef _WIN32
uninit_winrt_state(&winrt);
#endif
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 22:13:36 +00:00
UNUSED_PARAMETER(param);
first commit
2013-10-01 02:37:13 +00:00
return NULL;
}
Reference in a new issue Copy permalink