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

247 lines
10 KiB
C
Raw Normal View History

first commit
2013-09-30 19:37:13 -07:00
/******************************************************************************
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
With the permission of my fellow contributors, I'm switching obs-studio back to GPL v2+ to prevent issues between this project and the original OBS project, and for personal reasons to avoid legal ambiguity (not political reasons, I admittedly would prefer GPL v3+)
2013-12-02 21:24:38 -08:00
the Free Software Foundation, either version 2 of the License, or
first commit
2013-09-30 19:37:13 -07:00
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
modernize header guards to #pragma once
2013-10-14 04:21:15 -07:00
#pragma once
first commit
2013-09-30 19:37:13 -07:00
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
#include "../util/threading.h"
first commit
2013-09-30 19:37:13 -07:00
#include "../util/darray.h"
#include "graphics.h"
#include "matrix3.h"
#include "matrix4.h"
struct gs_exports {
Add gs_device_name function This returns the name of the device, "Direct3D 11" or "OpenGL" respectively.
2014-07-20 15:31:45 -07:00
const char *(*device_name)(void);
Add gs_device_type function This allows a programatic way of determining the type of graphics module currently active.
2014-07-20 16:19:43 -07:00
int (*device_type)(void);
Make a number of key optimizations - Changed glMapBuffer to glMapBufferRange to allow invalidation. Using just glMapBuffer alone was causing some unacceptable stalls. - Changed dynamic buffers from GL_DYNAMIC_WRITE to GL_STREAM_WRITE because I had misunderstood the OpenGL specification - Added _OPENGL and _D3D11 builtin preprocessor macros to effects to allow special processing if needed - Added fmod support to shaders (NOTE: D3D and GL do not function identically with negative numbers when using this. Positive numbers however function identically) - Created a planar conversion shader that converts from packed YUV to planar 420 right on the GPU without any CPU processing. Reduces required GPU download size to approximately 37.5% of its normal rate as well. GPU usage down by 10 entire percentage points despite the extra required pass.
2014-02-16 18:28:21 -08:00
const char *(*device_preprocessor_name)(void);
(API Change) obs_reset_video: Use return codes Changed API functions: libobs: obs_reset_video Before, video initialization returned a boolean, but "failed" is too little information, if it fails due to lack of device capabilities or bad video device parameters, the front-end needs to know that. The OBS Basic UI has also been updated to reflect this API change.
2014-07-20 17:40:57 -07:00
int (*device_create)(device_t *device, struct gs_init_data *data);
first commit
2013-09-30 19:37:13 -07:00
void (*device_destroy)(device_t device);
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
void (*device_entercontext)(device_t device);
void (*device_leavecontext)(device_t device);
first commit
2013-09-30 19:37:13 -07:00
swapchain_t (*device_create_swapchain)(device_t device,
struct gs_init_data *data);
void (*device_resize)(device_t device, uint32_t x, uint32_t y);
void (*device_getsize)(device_t device, uint32_t *x, uint32_t *y);
uint32_t (*device_getwidth)(device_t device);
uint32_t (*device_getheight)(device_t device);
texture_t (*device_create_texture)(device_t device, uint32_t width,
uint32_t height, enum gs_color_format color_format,
Use uint8_t* instead of void* for texture data NOTE: In texture_setimage, I had to move variables to the top of the scope because microsoft's C compiler will give the legacy C90 error of: 'illegal use of this type as an expression'. To sum it up, microsoft's C compiler is still utter garbage.
2014-06-27 21:29:06 -07:00
uint32_t levels, const uint8_t **data, uint32_t flags);
first commit
2013-09-30 19:37:13 -07:00
texture_t (*device_create_cubetexture)(device_t device, uint32_t size,
update graphics subsystem code to add mipmap support and also add initial GL texture stuff and helper functions
2013-10-04 08:55:33 -07:00
enum gs_color_format color_format, uint32_t levels,
Use uint8_t* instead of void* for texture data NOTE: In texture_setimage, I had to move variables to the top of the scope because microsoft's C compiler will give the legacy C90 error of: 'illegal use of this type as an expression'. To sum it up, microsoft's C compiler is still utter garbage.
2014-06-27 21:29:06 -07:00
const uint8_t **data, uint32_t flags);
first commit
2013-09-30 19:37:13 -07:00
texture_t (*device_create_volumetexture)(device_t device,
uint32_t width, uint32_t height, uint32_t depth,
update graphics subsystem code to add mipmap support and also add initial GL texture stuff and helper functions
2013-10-04 08:55:33 -07:00
enum gs_color_format color_format, uint32_t levels,
Use uint8_t* instead of void* for texture data NOTE: In texture_setimage, I had to move variables to the top of the scope because microsoft's C compiler will give the legacy C90 error of: 'illegal use of this type as an expression'. To sum it up, microsoft's C compiler is still utter garbage.
2014-06-27 21:29:06 -07:00
const uint8_t **data, uint32_t flags);
first commit
2013-09-30 19:37:13 -07:00
zstencil_t (*device_create_zstencil)(device_t device,
uint32_t width, uint32_t height,
enum gs_zstencil_format format);
stagesurf_t (*device_create_stagesurface)(device_t device,
uint32_t width, uint32_t height,
enum gs_color_format color_format);
samplerstate_t (*device_create_samplerstate)(device_t device,
struct gs_sampler_info *info);
shader_t (*device_create_vertexshader)(device_t device,
const char *shader, const char *file,
char **error_string);
shader_t (*device_create_pixelshader)(device_t device,
const char *shader, const char *file,
char **error_string);
vertbuffer_t (*device_create_vertexbuffer)(device_t device,
struct vb_data *data, uint32_t flags);
indexbuffer_t (*device_create_indexbuffer)(device_t device,
enum gs_index_type type, void *indices, size_t num,
uint32_t flags);
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 14:13:36 -08:00
enum gs_texture_type (*device_gettexturetype)(texture_t texture);
first commit
2013-09-30 19:37:13 -07:00
void (*device_load_vertexbuffer)(device_t device,
vertbuffer_t vertbuffer);
void (*device_load_indexbuffer)(device_t device,
indexbuffer_t indexbuffer);
void (*device_load_texture)(device_t device, texture_t tex, int unit);
void (*device_load_samplerstate)(device_t device,
samplerstate_t samplerstate, int unit);
void (*device_load_vertexshader)(device_t device, shader_t vertshader);
void (*device_load_pixelshader)(device_t device, shader_t pixelshader);
void (*device_load_defaultsamplerstate)(device_t device, bool b_3d,
int unit);
shader_t (*device_getvertexshader)(device_t device);
shader_t (*device_getpixelshader)(device_t device);
texture_t (*device_getrendertarget)(device_t device);
zstencil_t (*device_getzstenciltarget)(device_t device);
void (*device_setrendertarget)(device_t device, texture_t tex,
zstencil_t zstencil);
void (*device_setcuberendertarget)(device_t device, texture_t cubetex,
int side, zstencil_t zstencil);
void (*device_copy_texture)(device_t device, texture_t dst,
texture_t src);
Add copy_texture_region function
2014-04-09 11:04:58 -07:00
void (*device_copy_texture_region)(device_t device,
texture_t dst, uint32_t dst_x, uint32_t dst_y,
texture_t src, uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h);
first commit
2013-09-30 19:37:13 -07:00
void (*device_stage_texture)(device_t device, stagesurf_t dst,
texture_t src);
void (*device_beginscene)(device_t device);
void (*device_draw)(device_t device, enum gs_draw_mode draw_mode,
uint32_t start_vert, uint32_t num_verts);
void (*device_endscene)(device_t device);
void (*device_load_swapchain)(device_t device, swapchain_t swaphchain);
void (*device_clear)(device_t device, uint32_t clear_flags,
struct vec4 *color, float depth, uint8_t stencil);
void (*device_present)(device_t device);
Add a 'flush' command to graphics subsystem ...I'm actually concerned that I went a bit overkill trying to prevent backwards compatibility issues with this abstraction design, because this is a large number of files that have to be modified just to add a single graphics subsystem export. Someone's going to strangle me, and when you know that someone might strangle you, that means that you did something wrong. We'll have to look in to simplifying this in the future without killing backward compatibility safety.
2014-06-25 19:32:34 -07:00
void (*device_flush)(device_t device);
first commit
2013-09-30 19:37:13 -07:00
void (*device_setcullmode)(device_t device, enum gs_cull_mode mode);
enum gs_cull_mode (*device_getcullmode)(device_t device);
void (*device_enable_blending)(device_t device, bool enable);
void (*device_enable_depthtest)(device_t device, bool enable);
void (*device_enable_stenciltest)(device_t device, bool enable);
void (*device_enable_stencilwrite)(device_t device, bool enable);
fill in the rest of the GL functions. finally
2013-10-12 20:18:05 -07:00
void (*device_enable_color)(device_t device, bool red, bool green,
bool blue, bool alpha);
first commit
2013-09-30 19:37:13 -07:00
void (*device_blendfunction)(device_t device, enum gs_blend_type src,
enum gs_blend_type dest);
void (*device_depthfunction)(device_t device, enum gs_depth_test test);
void (*device_stencilfunction)(device_t device,
enum gs_stencil_side side, enum gs_depth_test test);
void (*device_stencilop)(device_t device, enum gs_stencil_side side,
enum gs_stencil_op fail, enum gs_stencil_op zfail,
enum gs_stencil_op zpass);
void (*device_setviewport)(device_t device, int x, int y, int width,
int height);
void (*device_getviewport)(device_t device, struct gs_rect *rect);
void (*device_setscissorrect)(device_t device, struct gs_rect *rect);
void (*device_ortho)(device_t device, float left, float right,
float top, float bottom, float znear, float zfar);
void (*device_frustum)(device_t device, float left, float right,
float top, float bottom, float znear, float zfar);
void (*device_projection_push)(device_t device);
void (*device_projection_pop)(device_t device);
void (*swapchain_destroy)(swapchain_t swapchain);
void (*texture_destroy)(texture_t tex);
uint32_t (*texture_getwidth)(texture_t tex);
uint32_t (*texture_getheight)(texture_t tex);
enum gs_color_format (*texture_getcolorformat)(texture_t tex);
Use uint8_t* instead of void* for texture data NOTE: In texture_setimage, I had to move variables to the top of the scope because microsoft's C compiler will give the legacy C90 error of: 'illegal use of this type as an expression'. To sum it up, microsoft's C compiler is still utter garbage.
2014-06-27 21:29:06 -07:00
bool (*texture_map)(texture_t tex, uint8_t **ptr,
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 04:51:06 -08:00
uint32_t *linesize);
first commit
2013-09-30 19:37:13 -07:00
void (*texture_unmap)(texture_t tex);
add handling of GL_TEXTURE_RECTANGLE target, and add automatic handling if using it as a sprite
2013-12-20 11:36:38 -08:00
bool (*texture_isrect)(texture_t tex);
Add dummy GL texture flag & direct object access - Add dummy GL texture support to allow libobs texture references to be created for GL without - Add a texture_getobj function to allow the retrieval of the context-specific object, such as the D3D texture pointer, or the OpenGL texture object handle. - Also cleaned up the export stuff. I realized it was all totally superfluous. Kind of a dumb moment, but nice to clean it up regardless.
2014-03-29 17:19:31 -07:00
void *(*texture_getobj)(texture_t tex);
first commit
2013-09-30 19:37:13 -07:00
void (*cubetexture_destroy)(texture_t cubetex);
uint32_t (*cubetexture_getsize)(texture_t cubetex);
enum gs_color_format (*cubetexture_getcolorformat)(texture_t cubetex);
void (*volumetexture_destroy)(texture_t voltex);
uint32_t (*volumetexture_getwidth)(texture_t voltex);
uint32_t (*volumetexture_getheight)(texture_t voltex);
uint32_t (*volumetexture_getdepth)(texture_t voltex);
enum gs_color_format (*volumetexture_getcolorformat)(texture_t voltex);
void (*stagesurface_destroy)(stagesurf_t stagesurf);
uint32_t (*stagesurface_getwidth)(stagesurf_t stagesurf);
uint32_t (*stagesurface_getheight)(stagesurf_t stagesurf);
enum gs_color_format (*stagesurface_getcolorformat)(
stagesurf_t stagesurf);
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 14:13:36 -08:00
bool (*stagesurface_map)(stagesurf_t stagesurf,
Implement encoder interface (still preliminary) - Implement OBS encoder interface. It was previously incomplete, but now is reaching some level of completion, though probably should still be considered preliminary. I had originally implemented it so that encoders only have a 'reset' function to reset their parameters, but I felt that having both a 'start' and 'stop' function would be useful. Encoders are now assigned to a specific video/audio media output each rather than implicitely assigned to the main obs video/audio contexts. This allows separate encoder contexts that aren't necessarily assigned to the main video/audio context (which is useful for things such as recording specific sources). Will probably have to do this for regular obs outputs as well. When creating an encoder, you must now explicitely state whether that encoder is an audio or video encoder. Audio and video can optionally be automatically converted depending on what the encoder specifies. When something 'attaches' to an encoder, the first attachment starts the encoder, and the encoder automatically attaches to the media output context associated with it. Subsequent attachments won't have the same effect, they will just start receiving the same encoder data when the next keyframe plays (along with SEI if any). When detaching from the encoder, the last detachment will fully stop the encoder and detach the encoder from the media output context associated with the encoder. SEI must actually be exported separately; because new encoder attachments may not always be at the beginning of the stream, the first keyframe they get must have that SEI data in it. If the encoder has SEI data, it needs only add one small function to simply query that SEI data, and then that data will be handled automatically by libobs for all subsequent encoder attachments. - Implement x264 encoder plugin, move x264 files to separate plugin to separate necessary dependencies. - Change video/audio frame output structures to not use const qualifiers to prevent issues with non-const function usage elsewhere. This was an issue when writing the x264 encoder, as the x264 encoder expects non-const frame data. Change stagesurf_map to return a non-const data type to prevent this as well. - Change full range parameter of video scaler to be an enum rather than boolean
2014-03-16 16:21:34 -07:00
uint8_t **data, uint32_t *linesize);
first commit
2013-09-30 19:37:13 -07:00
void (*stagesurface_unmap)(stagesurf_t stagesurf);
void (*zstencil_destroy)(zstencil_t zstencil);
void (*samplerstate_destroy)(samplerstate_t samplerstate);
void (*vertexbuffer_destroy)(vertbuffer_t vertbuffer);
Remove 'rebuild' variable from vertexbuffer_flush This variable is currently somewhat pointless, I was originally going to use it to tell the graphics subsystem to completely rebuild the internal vertex buffers, but it would be bad/inefficient to allow that functionality.
2014-06-25 01:16:09 -07:00
void (*vertexbuffer_flush)(vertbuffer_t vertbuffer);
first commit
2013-09-30 19:37:13 -07:00
struct vb_data *(*vertexbuffer_getdata)(vertbuffer_t vertbuffer);
void (*indexbuffer_destroy)(indexbuffer_t indexbuffer);
void (*indexbuffer_flush)(indexbuffer_t indexbuffer);
void *(*indexbuffer_getdata)(indexbuffer_t indexbuffer);
size_t (*indexbuffer_numindices)(indexbuffer_t indexbuffer);
enum gs_index_type (*indexbuffer_gettype)(indexbuffer_t indexbuffer);
void (*shader_destroy)(shader_t shader);
int (*shader_numparams)(shader_t shader);
some static analysis cleanup
2013-10-17 17:21:42 -07:00
sparam_t (*shader_getparambyidx)(shader_t shader, uint32_t param);
first commit
2013-09-30 19:37:13 -07:00
sparam_t (*shader_getparambyname)(shader_t shader, const char *name);
sparam_t (*shader_getviewprojmatrix)(shader_t shader);
sparam_t (*shader_getworldmatrix)(shader_t shader);
Remove 'shader' param from shader param functions
2014-06-25 19:50:08 -07:00
void (*shader_getparaminfo)(sparam_t param,
struct shader_param_info *info);
void (*shader_setbool)(sparam_t param, bool val);
void (*shader_setfloat)(sparam_t param, float val);
void (*shader_setint)(sparam_t param, int val);
void (*shader_setmatrix3)(sparam_t param, const struct matrix3 *val);
void (*shader_setmatrix4)(sparam_t param, const struct matrix4 *val);
void (*shader_setvec2)(sparam_t param, const struct vec2 *val);
void (*shader_setvec3)(sparam_t param, const struct vec3 *val);
void (*shader_setvec4)(sparam_t param, const struct vec4 *val);
void (*shader_settexture)(sparam_t param, texture_t val);
void (*shader_setval)(sparam_t param, const void *val, size_t size);
void (*shader_setdefault)(sparam_t param);
add osx iosurface opengl integration
2013-12-23 07:34:56 -08:00
Reimplement monitor capture - Implement windows monitor capture (code is so much cleaner than in OBS1). Will implement duplication capture later - Add GDI texture support to d3d11 graphics library - Fix precision issue with sleep timing, you have to call timeBeginPeriod otherwise windows sleep will be totally erratic.
2014-03-05 09:43:14 -08:00
#ifdef __APPLE__
add osx iosurface opengl integration
2013-12-23 07:34:56 -08:00
/* OSX/Cocoa specific functions */
texture_t (*texture_create_from_iosurface)(device_t dev, void *iosurf);
bool (*texture_rebind_iosurface)(texture_t texture, void *iosurf);
Reimplement monitor capture - Implement windows monitor capture (code is so much cleaner than in OBS1). Will implement duplication capture later - Add GDI texture support to d3d11 graphics library - Fix precision issue with sleep timing, you have to call timeBeginPeriod otherwise windows sleep will be totally erratic.
2014-03-05 09:43:14 -08:00
#elif _WIN32
bool (*gdi_texture_available)(void);
texture_t (*device_create_gdi_texture)(device_t device,
uint32_t width, uint32_t height);
void *(*texture_get_dc)(texture_t gdi_tex);
void (*texture_release_dc)(texture_t gdi_tex);
#endif
first commit
2013-09-30 19:37:13 -07:00
};
Implement function to reset blend state I was implementing a pushing/popping attributes function like with GL, but I realized that for our particular purposes (and actually for most purposes) its usage was somewhat.. niche. I may still implement pushing/popping of attributes in the future, though right now I feel using a function to reset the state is sufficient for our purposes.
2014-07-03 13:57:40 -07:00
struct blend_state {
bool enabled;
enum gs_blend_type src;
enum gs_blend_type dest;
};
first commit
2013-09-30 19:37:13 -07:00
struct graphics_subsystem {
void *module;
device_t device;
struct gs_exports exports;
DARRAY(struct gs_rect) viewport_stack;
Change graphics subsystem to 4x4 matrices 4x4 matrices aren't as optimal, but are much more sensible to handle when you want to do more advanced stuff like scaling, skewing, or inversion.
2014-06-14 23:09:13 -07:00
DARRAY(struct matrix4) matrix_stack;
first commit
2013-09-30 19:37:13 -07:00
size_t cur_matrix;
struct matrix4 projection;
struct gs_effect *cur_effect;
vertbuffer_t sprite_buffer;
bool using_immediate;
struct vb_data *vbd;
vertbuffer_t immediate_vertbuffer;
DARRAY(struct vec3) verts;
DARRAY(struct vec3) norms;
DARRAY(uint32_t) colors;
DARRAY(struct vec2) texverts[16];
change names, fix some bugs, minor GL/D3D fixes, update tests, fix effect files, output a little more debug information
2013-10-14 12:37:52 -07:00
pthread_mutex_t mutex;
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
volatile long ref;
Implement function to reset blend state I was implementing a pushing/popping attributes function like with GL, but I realized that for our particular purposes (and actually for most purposes) its usage was somewhat.. niche. I may still implement pushing/popping of attributes in the future, though right now I feel using a function to reset the state is sufficient for our purposes.
2014-07-03 13:57:40 -07:00
struct blend_state cur_blend_state;
first commit
2013-09-30 19:37:13 -07:00
};