4fe6803fe4
Some users stream projectors, so don't let them tear. Use the waitable object to check the flip queue, and only flip if there's space. Metal and Vulkan can probably perform similar flip throttling once OBS starts using them.
414 lines
17 KiB
C
414 lines
17 KiB
C
/******************************************************************************
|
|
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(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/>.
|
|
******************************************************************************/
|
|
|
|
#pragma once
|
|
|
|
#include "../util/threading.h"
|
|
#include "../util/darray.h"
|
|
#include "graphics.h"
|
|
#include "matrix3.h"
|
|
#include "matrix4.h"
|
|
|
|
struct gs_exports {
|
|
const char *(*device_get_name)(void);
|
|
int (*device_get_type)(void);
|
|
bool (*device_enum_adapters)(bool (*callback)(void *, const char *,
|
|
uint32_t),
|
|
void *);
|
|
const char *(*device_preprocessor_name)(void);
|
|
int (*device_create)(gs_device_t **device, uint32_t adapter);
|
|
void (*device_destroy)(gs_device_t *device);
|
|
void (*device_enter_context)(gs_device_t *device);
|
|
void (*device_leave_context)(gs_device_t *device);
|
|
void *(*device_get_device_obj)(gs_device_t *device);
|
|
gs_swapchain_t *(*device_swapchain_create)(
|
|
gs_device_t *device, const struct gs_init_data *data);
|
|
void (*device_resize)(gs_device_t *device, uint32_t x, uint32_t y);
|
|
enum gs_color_space (*device_get_color_space)(gs_device_t *device);
|
|
void (*device_update_color_space)(gs_device_t *device);
|
|
void (*device_get_size)(const gs_device_t *device, uint32_t *x,
|
|
uint32_t *y);
|
|
uint32_t (*device_get_width)(const gs_device_t *device);
|
|
uint32_t (*device_get_height)(const gs_device_t *device);
|
|
gs_texture_t *(*device_texture_create)(
|
|
gs_device_t *device, uint32_t width, uint32_t height,
|
|
enum gs_color_format color_format, uint32_t levels,
|
|
const uint8_t **data, uint32_t flags);
|
|
gs_texture_t *(*device_cubetexture_create)(
|
|
gs_device_t *device, uint32_t size,
|
|
enum gs_color_format color_format, uint32_t levels,
|
|
const uint8_t **data, uint32_t flags);
|
|
gs_texture_t *(*device_voltexture_create)(
|
|
gs_device_t *device, uint32_t width, uint32_t height,
|
|
uint32_t depth, enum gs_color_format color_format,
|
|
uint32_t levels, const uint8_t *const *data, uint32_t flags);
|
|
gs_zstencil_t *(*device_zstencil_create)(
|
|
gs_device_t *device, uint32_t width, uint32_t height,
|
|
enum gs_zstencil_format format);
|
|
gs_stagesurf_t *(*device_stagesurface_create)(
|
|
gs_device_t *device, uint32_t width, uint32_t height,
|
|
enum gs_color_format color_format);
|
|
gs_samplerstate_t *(*device_samplerstate_create)(
|
|
gs_device_t *device, const struct gs_sampler_info *info);
|
|
gs_shader_t *(*device_vertexshader_create)(gs_device_t *device,
|
|
const char *shader,
|
|
const char *file,
|
|
char **error_string);
|
|
gs_shader_t *(*device_pixelshader_create)(gs_device_t *device,
|
|
const char *shader,
|
|
const char *file,
|
|
char **error_string);
|
|
gs_vertbuffer_t *(*device_vertexbuffer_create)(gs_device_t *device,
|
|
struct gs_vb_data *data,
|
|
uint32_t flags);
|
|
gs_indexbuffer_t *(*device_indexbuffer_create)(gs_device_t *device,
|
|
enum gs_index_type type,
|
|
void *indices,
|
|
size_t num,
|
|
uint32_t flags);
|
|
gs_timer_t *(*device_timer_create)(gs_device_t *device);
|
|
gs_timer_range_t *(*device_timer_range_create)(gs_device_t *device);
|
|
enum gs_texture_type (*device_get_texture_type)(
|
|
const gs_texture_t *texture);
|
|
void (*device_load_vertexbuffer)(gs_device_t *device,
|
|
gs_vertbuffer_t *vertbuffer);
|
|
void (*device_load_indexbuffer)(gs_device_t *device,
|
|
gs_indexbuffer_t *indexbuffer);
|
|
void (*device_load_texture)(gs_device_t *device, gs_texture_t *tex,
|
|
int unit);
|
|
void (*device_load_samplerstate)(gs_device_t *device,
|
|
gs_samplerstate_t *samplerstate,
|
|
int unit);
|
|
void (*device_load_vertexshader)(gs_device_t *device,
|
|
gs_shader_t *vertshader);
|
|
void (*device_load_pixelshader)(gs_device_t *device,
|
|
gs_shader_t *pixelshader);
|
|
void (*device_load_default_samplerstate)(gs_device_t *device, bool b_3d,
|
|
int unit);
|
|
gs_shader_t *(*device_get_vertex_shader)(const gs_device_t *device);
|
|
gs_shader_t *(*device_get_pixel_shader)(const gs_device_t *device);
|
|
gs_texture_t *(*device_get_render_target)(const gs_device_t *device);
|
|
gs_zstencil_t *(*device_get_zstencil_target)(const gs_device_t *device);
|
|
void (*device_set_render_target)(gs_device_t *device, gs_texture_t *tex,
|
|
gs_zstencil_t *zstencil);
|
|
void (*device_set_render_target_with_color_space)(
|
|
gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil,
|
|
enum gs_color_space space);
|
|
void (*device_set_cube_render_target)(gs_device_t *device,
|
|
gs_texture_t *cubetex, int side,
|
|
gs_zstencil_t *zstencil);
|
|
void (*device_enable_framebuffer_srgb)(gs_device_t *device,
|
|
bool enable);
|
|
bool (*device_framebuffer_srgb_enabled)(gs_device_t *device);
|
|
void (*device_copy_texture)(gs_device_t *device, gs_texture_t *dst,
|
|
gs_texture_t *src);
|
|
void (*device_copy_texture_region)(gs_device_t *device,
|
|
gs_texture_t *dst, uint32_t dst_x,
|
|
uint32_t dst_y, gs_texture_t *src,
|
|
uint32_t src_x, uint32_t src_y,
|
|
uint32_t src_w, uint32_t src_h);
|
|
void (*device_stage_texture)(gs_device_t *device, gs_stagesurf_t *dst,
|
|
gs_texture_t *src);
|
|
void (*device_begin_frame)(gs_device_t *device);
|
|
void (*device_begin_scene)(gs_device_t *device);
|
|
void (*device_draw)(gs_device_t *device, enum gs_draw_mode draw_mode,
|
|
uint32_t start_vert, uint32_t num_verts);
|
|
void (*device_end_scene)(gs_device_t *device);
|
|
void (*device_load_swapchain)(gs_device_t *device,
|
|
gs_swapchain_t *swaphchain);
|
|
void (*device_clear)(gs_device_t *device, uint32_t clear_flags,
|
|
const struct vec4 *color, float depth,
|
|
uint8_t stencil);
|
|
bool (*device_is_present_ready)(gs_device_t *device);
|
|
void (*device_present)(gs_device_t *device);
|
|
void (*device_flush)(gs_device_t *device);
|
|
void (*device_set_cull_mode)(gs_device_t *device,
|
|
enum gs_cull_mode mode);
|
|
enum gs_cull_mode (*device_get_cull_mode)(const gs_device_t *device);
|
|
void (*device_enable_blending)(gs_device_t *device, bool enable);
|
|
void (*device_enable_depth_test)(gs_device_t *device, bool enable);
|
|
void (*device_enable_stencil_test)(gs_device_t *device, bool enable);
|
|
void (*device_enable_stencil_write)(gs_device_t *device, bool enable);
|
|
void (*device_enable_color)(gs_device_t *device, bool red, bool green,
|
|
bool blue, bool alpha);
|
|
void (*device_blend_function)(gs_device_t *device,
|
|
enum gs_blend_type src,
|
|
enum gs_blend_type dest);
|
|
void (*device_blend_function_separate)(gs_device_t *device,
|
|
enum gs_blend_type src_c,
|
|
enum gs_blend_type dest_c,
|
|
enum gs_blend_type src_a,
|
|
enum gs_blend_type dest_a);
|
|
void (*device_blend_op)(gs_device_t *device, enum gs_blend_op_type op);
|
|
|
|
void (*device_depth_function)(gs_device_t *device,
|
|
enum gs_depth_test test);
|
|
void (*device_stencil_function)(gs_device_t *device,
|
|
enum gs_stencil_side side,
|
|
enum gs_depth_test test);
|
|
void (*device_stencil_op)(gs_device_t *device,
|
|
enum gs_stencil_side side,
|
|
enum gs_stencil_op_type fail,
|
|
enum gs_stencil_op_type zfail,
|
|
enum gs_stencil_op_type zpass);
|
|
void (*device_set_viewport)(gs_device_t *device, int x, int y,
|
|
int width, int height);
|
|
void (*device_get_viewport)(const gs_device_t *device,
|
|
struct gs_rect *rect);
|
|
void (*device_set_scissor_rect)(gs_device_t *device,
|
|
const struct gs_rect *rect);
|
|
void (*device_ortho)(gs_device_t *device, float left, float right,
|
|
float top, float bottom, float znear, float zfar);
|
|
void (*device_frustum)(gs_device_t *device, float left, float right,
|
|
float top, float bottom, float znear,
|
|
float zfar);
|
|
void (*device_projection_push)(gs_device_t *device);
|
|
void (*device_projection_pop)(gs_device_t *device);
|
|
|
|
void (*gs_swapchain_destroy)(gs_swapchain_t *swapchain);
|
|
|
|
void (*gs_texture_destroy)(gs_texture_t *tex);
|
|
uint32_t (*gs_texture_get_width)(const gs_texture_t *tex);
|
|
uint32_t (*gs_texture_get_height)(const gs_texture_t *tex);
|
|
enum gs_color_format (*gs_texture_get_color_format)(
|
|
const gs_texture_t *tex);
|
|
bool (*gs_texture_map)(gs_texture_t *tex, uint8_t **ptr,
|
|
uint32_t *linesize);
|
|
void (*gs_texture_unmap)(gs_texture_t *tex);
|
|
bool (*gs_texture_is_rect)(const gs_texture_t *tex);
|
|
void *(*gs_texture_get_obj)(const gs_texture_t *tex);
|
|
|
|
void (*gs_cubetexture_destroy)(gs_texture_t *cubetex);
|
|
uint32_t (*gs_cubetexture_get_size)(const gs_texture_t *cubetex);
|
|
enum gs_color_format (*gs_cubetexture_get_color_format)(
|
|
const gs_texture_t *cubetex);
|
|
|
|
void (*gs_voltexture_destroy)(gs_texture_t *voltex);
|
|
uint32_t (*gs_voltexture_get_width)(const gs_texture_t *voltex);
|
|
uint32_t (*gs_voltexture_get_height)(const gs_texture_t *voltex);
|
|
uint32_t (*gs_voltexture_get_depth)(const gs_texture_t *voltex);
|
|
enum gs_color_format (*gs_voltexture_get_color_format)(
|
|
const gs_texture_t *voltex);
|
|
|
|
void (*gs_stagesurface_destroy)(gs_stagesurf_t *stagesurf);
|
|
uint32_t (*gs_stagesurface_get_width)(const gs_stagesurf_t *stagesurf);
|
|
uint32_t (*gs_stagesurface_get_height)(const gs_stagesurf_t *stagesurf);
|
|
enum gs_color_format (*gs_stagesurface_get_color_format)(
|
|
const gs_stagesurf_t *stagesurf);
|
|
bool (*gs_stagesurface_map)(gs_stagesurf_t *stagesurf, uint8_t **data,
|
|
uint32_t *linesize);
|
|
void (*gs_stagesurface_unmap)(gs_stagesurf_t *stagesurf);
|
|
|
|
void (*gs_zstencil_destroy)(gs_zstencil_t *zstencil);
|
|
|
|
void (*gs_samplerstate_destroy)(gs_samplerstate_t *samplerstate);
|
|
|
|
void (*gs_vertexbuffer_destroy)(gs_vertbuffer_t *vertbuffer);
|
|
void (*gs_vertexbuffer_flush)(gs_vertbuffer_t *vertbuffer);
|
|
void (*gs_vertexbuffer_flush_direct)(gs_vertbuffer_t *vertbuffer,
|
|
const struct gs_vb_data *data);
|
|
struct gs_vb_data *(*gs_vertexbuffer_get_data)(
|
|
const gs_vertbuffer_t *vertbuffer);
|
|
|
|
void (*gs_indexbuffer_destroy)(gs_indexbuffer_t *indexbuffer);
|
|
void (*gs_indexbuffer_flush)(gs_indexbuffer_t *indexbuffer);
|
|
void (*gs_indexbuffer_flush_direct)(gs_indexbuffer_t *indexbuffer,
|
|
const void *data);
|
|
void *(*gs_indexbuffer_get_data)(const gs_indexbuffer_t *indexbuffer);
|
|
size_t (*gs_indexbuffer_get_num_indices)(
|
|
const gs_indexbuffer_t *indexbuffer);
|
|
enum gs_index_type (*gs_indexbuffer_get_type)(
|
|
const gs_indexbuffer_t *indexbuffer);
|
|
|
|
void (*gs_timer_destroy)(gs_timer_t *timer);
|
|
void (*gs_timer_begin)(gs_timer_t *timer);
|
|
void (*gs_timer_end)(gs_timer_t *timer);
|
|
bool (*gs_timer_get_data)(gs_timer_t *timer, uint64_t *ticks);
|
|
void (*gs_timer_range_destroy)(gs_timer_range_t *range);
|
|
bool (*gs_timer_range_begin)(gs_timer_range_t *range);
|
|
bool (*gs_timer_range_end)(gs_timer_range_t *range);
|
|
bool (*gs_timer_range_get_data)(gs_timer_range_t *range, bool *disjoint,
|
|
uint64_t *frequency);
|
|
|
|
void (*gs_shader_destroy)(gs_shader_t *shader);
|
|
int (*gs_shader_get_num_params)(const gs_shader_t *shader);
|
|
gs_sparam_t *(*gs_shader_get_param_by_idx)(gs_shader_t *shader,
|
|
uint32_t param);
|
|
gs_sparam_t *(*gs_shader_get_param_by_name)(gs_shader_t *shader,
|
|
const char *name);
|
|
gs_sparam_t *(*gs_shader_get_viewproj_matrix)(const gs_shader_t *shader);
|
|
gs_sparam_t *(*gs_shader_get_world_matrix)(const gs_shader_t *shader);
|
|
void (*gs_shader_get_param_info)(const gs_sparam_t *param,
|
|
struct gs_shader_param_info *info);
|
|
void (*gs_shader_set_bool)(gs_sparam_t *param, bool val);
|
|
void (*gs_shader_set_float)(gs_sparam_t *param, float val);
|
|
void (*gs_shader_set_int)(gs_sparam_t *param, int val);
|
|
void (*gs_shader_set_matrix3)(gs_sparam_t *param,
|
|
const struct matrix3 *val);
|
|
void (*gs_shader_set_matrix4)(gs_sparam_t *param,
|
|
const struct matrix4 *val);
|
|
void (*gs_shader_set_vec2)(gs_sparam_t *param, const struct vec2 *val);
|
|
void (*gs_shader_set_vec3)(gs_sparam_t *param, const struct vec3 *val);
|
|
void (*gs_shader_set_vec4)(gs_sparam_t *param, const struct vec4 *val);
|
|
void (*gs_shader_set_texture)(gs_sparam_t *param, gs_texture_t *val);
|
|
void (*gs_shader_set_val)(gs_sparam_t *param, const void *val,
|
|
size_t size);
|
|
void (*gs_shader_set_default)(gs_sparam_t *param);
|
|
void (*gs_shader_set_next_sampler)(gs_sparam_t *param,
|
|
gs_samplerstate_t *sampler);
|
|
|
|
bool (*device_nv12_available)(gs_device_t *device);
|
|
bool (*device_p010_available)(gs_device_t *device);
|
|
|
|
bool (*device_is_monitor_hdr)(gs_device_t *device, void *monitor);
|
|
|
|
void (*device_debug_marker_begin)(gs_device_t *device,
|
|
const char *markername,
|
|
const float color[4]);
|
|
void (*device_debug_marker_end)(gs_device_t *device);
|
|
|
|
#ifdef __APPLE__
|
|
/* OSX/Cocoa specific functions */
|
|
gs_texture_t *(*device_texture_create_from_iosurface)(gs_device_t *dev,
|
|
void *iosurf);
|
|
gs_texture_t *(*device_texture_open_shared)(gs_device_t *dev,
|
|
uint32_t handle);
|
|
bool (*gs_texture_rebind_iosurface)(gs_texture_t *texture,
|
|
void *iosurf);
|
|
bool (*device_shared_texture_available)(void);
|
|
|
|
#elif _WIN32
|
|
bool (*device_gdi_texture_available)(void);
|
|
bool (*device_shared_texture_available)(void);
|
|
|
|
bool (*device_get_duplicator_monitor_info)(
|
|
gs_device_t *device, int monitor_idx,
|
|
struct gs_monitor_info *monitor_info);
|
|
int (*device_duplicator_get_monitor_index)(gs_device_t *device,
|
|
void *monitor);
|
|
|
|
gs_duplicator_t *(*device_duplicator_create)(gs_device_t *device,
|
|
int monitor_idx);
|
|
void (*gs_duplicator_destroy)(gs_duplicator_t *duplicator);
|
|
|
|
bool (*gs_duplicator_update_frame)(gs_duplicator_t *duplicator);
|
|
gs_texture_t *(*gs_duplicator_get_texture)(gs_duplicator_t *duplicator);
|
|
|
|
uint32_t (*gs_get_adapter_count)(void);
|
|
|
|
gs_texture_t *(*device_texture_create_gdi)(gs_device_t *device,
|
|
uint32_t width,
|
|
uint32_t height);
|
|
|
|
void *(*gs_texture_get_dc)(gs_texture_t *gdi_tex);
|
|
void (*gs_texture_release_dc)(gs_texture_t *gdi_tex);
|
|
|
|
gs_texture_t *(*device_texture_open_shared)(gs_device_t *device,
|
|
uint32_t handle);
|
|
gs_texture_t *(*device_texture_open_nt_shared)(gs_device_t *device,
|
|
uint32_t handle);
|
|
uint32_t (*device_texture_get_shared_handle)(gs_texture_t *tex);
|
|
gs_texture_t *(*device_texture_wrap_obj)(gs_device_t *device,
|
|
void *obj);
|
|
int (*device_texture_acquire_sync)(gs_texture_t *tex, uint64_t key,
|
|
uint32_t ms);
|
|
int (*device_texture_release_sync)(gs_texture_t *tex, uint64_t key);
|
|
bool (*device_texture_create_nv12)(gs_device_t *device,
|
|
gs_texture_t **tex_y,
|
|
gs_texture_t **tex_uv,
|
|
uint32_t width, uint32_t height,
|
|
uint32_t flags);
|
|
bool (*device_texture_create_p010)(gs_device_t *device,
|
|
gs_texture_t **tex_y,
|
|
gs_texture_t **tex_uv,
|
|
uint32_t width, uint32_t height,
|
|
uint32_t flags);
|
|
|
|
gs_stagesurf_t *(*device_stagesurface_create_nv12)(gs_device_t *device,
|
|
uint32_t width,
|
|
uint32_t height);
|
|
gs_stagesurf_t *(*device_stagesurface_create_p010)(gs_device_t *device,
|
|
uint32_t width,
|
|
uint32_t height);
|
|
void (*device_register_loss_callbacks)(
|
|
gs_device_t *device, const struct gs_device_loss *callbacks);
|
|
void (*device_unregister_loss_callbacks)(gs_device_t *device,
|
|
void *data);
|
|
#elif __linux__
|
|
struct gs_texture *(*device_texture_create_from_dmabuf)(
|
|
gs_device_t *device, unsigned int width, unsigned int height,
|
|
uint32_t drm_format, enum gs_color_format color_format,
|
|
uint32_t n_planes, const int *fds, const uint32_t *strides,
|
|
const uint32_t *offsets, const uint64_t *modifiers);
|
|
bool (*device_query_dmabuf_capabilities)(
|
|
gs_device_t *device, enum gs_dmabuf_flags *dmabuf_flags,
|
|
uint32_t **drm_formats, size_t *n_formats);
|
|
bool (*device_query_dmabuf_modifiers_for_format)(gs_device_t *device,
|
|
uint32_t drm_format,
|
|
uint64_t **modifiers,
|
|
size_t *n_modifiers);
|
|
struct gs_texture *(*device_texture_create_from_pixmap)(
|
|
gs_device_t *device, uint32_t width, uint32_t height,
|
|
enum gs_color_format color_format, uint32_t target,
|
|
void *pixmap);
|
|
#endif
|
|
};
|
|
|
|
struct blend_state {
|
|
bool enabled;
|
|
enum gs_blend_type src_c;
|
|
enum gs_blend_type dest_c;
|
|
enum gs_blend_type src_a;
|
|
enum gs_blend_type dest_a;
|
|
enum gs_blend_op_type op;
|
|
};
|
|
|
|
struct graphics_subsystem {
|
|
void *module;
|
|
gs_device_t *device;
|
|
struct gs_exports exports;
|
|
|
|
DARRAY(struct gs_rect) viewport_stack;
|
|
|
|
DARRAY(struct matrix4) matrix_stack;
|
|
size_t cur_matrix;
|
|
|
|
struct matrix4 projection;
|
|
struct gs_effect *cur_effect;
|
|
|
|
gs_vertbuffer_t *sprite_buffer;
|
|
|
|
bool using_immediate;
|
|
struct gs_vb_data *vbd;
|
|
gs_vertbuffer_t *immediate_vertbuffer;
|
|
DARRAY(struct vec3) verts;
|
|
DARRAY(struct vec3) norms;
|
|
DARRAY(uint32_t) colors;
|
|
DARRAY(struct vec2) texverts[16];
|
|
|
|
pthread_mutex_t effect_mutex;
|
|
struct gs_effect *first_effect;
|
|
|
|
pthread_mutex_t mutex;
|
|
volatile long ref;
|
|
|
|
struct blend_state cur_blend_state;
|
|
DARRAY(struct blend_state) blend_state_stack;
|
|
|
|
bool linear_srgb;
|
|
};
|