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

(API Change) Use const params where applicable 

This Fixes a minor flaw with the API where data had to always be mutable
to be usable by the API.

Functions that do not modify the fundamental underlying data of a
structure should be marked as constant, both for safety and to signify
that the parameter is input only and will not be modified by the
function using it.
master
jp9000 2014-09-26 15:25:59 -07:00
parent 05ac1aea2c
commit 41fad2d1a4
38 changed files with 529 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libobs-d3d11/d3d11-samplerstate.cpp
View File

@ -59,7 +59,8 @@ static inline D3D11_FILTER ConvertGSFilter( gs_sample_filter filter)
return D3D11_FILTER_MIN_MAG_MIP_POINT;
}
gs_sampler_state::gs_sampler_state(gs_device_t *device, gs_sampler_info *info)
gs_sampler_state::gs_sampler_state(gs_device_t *device,
const gs_sampler_info *info)
: device (device),
info (*info)
{

12
libobs-d3d11/d3d11-shader.cpp
View File

@ -255,7 +255,7 @@ void gs_shader_destroy(gs_shader_t *shader)
delete shader;
}
int gs_shader_get_num_params(gs_shader_t *shader)
int gs_shader_get_num_params(const gs_shader_t *shader)
{
return (int)shader->params.size();
}
@ -276,23 +276,23 @@ gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
return NULL;
}
gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader)
{
if (shader->type != GS_SHADER_VERTEX)
return NULL;
return static_cast<gs_vertex_shader*>(shader)->viewProj;
return static_cast<const gs_vertex_shader*>(shader)->viewProj;
}
gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader)
{
if (shader->type != GS_SHADER_VERTEX)
return NULL;
return static_cast<gs_vertex_shader*>(shader)->world;
return static_cast<const gs_vertex_shader*>(shader)->world;
}
void gs_shader_get_param_info(gs_sparam_t *param,
void gs_shader_get_param_info(const gs_sparam_t *param,
struct gs_shader_param_info *info)
{
if (!param)

86
libobs-d3d11/d3d11-subsystem.cpp
View File

@ -36,7 +36,7 @@ static const IID dxgiFactory2 =
{0x50c83a1c, 0xe072, 0x4c48, {0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0}};
static inline void make_swap_desc(DXGI_SWAP_CHAIN_DESC &desc,
gs_init_data *data)
const gs_init_data *data)
{
memset(&desc, 0, sizeof(desc));
desc.BufferCount = data->num_backbuffers;
@ -104,7 +104,7 @@ void gs_swap_chain::Resize(uint32_t cx, uint32_t cy)
InitZStencilBuffer(cx, cy);
}
void gs_swap_chain::Init(gs_init_data *data)
void gs_swap_chain::Init(const gs_init_data *data)
{
target.device = device;
target.isRenderTarget = true;
@ -118,7 +118,7 @@ void gs_swap_chain::Init(gs_init_data *data)
InitZStencilBuffer(data->cx, data->cy);
}
gs_swap_chain::gs_swap_chain(gs_device *device, gs_init_data *data)
gs_swap_chain::gs_swap_chain(gs_device *device, const gs_init_data *data)
: device (device),
numBuffers (data->num_backbuffers),
hwnd ((HWND)data->window.hwnd)
@ -158,7 +158,7 @@ const static D3D_FEATURE_LEVEL featureLevels[] =
D3D_FEATURE_LEVEL_9_3,
};
void gs_device::InitDevice(gs_init_data *data, IDXGIAdapter *adapter)
void gs_device::InitDevice(const gs_init_data *data, IDXGIAdapter *adapter)
{
wstring adapterName;
DXGI_SWAP_CHAIN_DESC swapDesc;
@ -393,7 +393,7 @@ void gs_device::UpdateViewProjMatrix()
&curViewProjMatrix);
}
gs_device::gs_device(gs_init_data *data)
gs_device::gs_device(const gs_init_data *data)
: curRenderTarget (NULL),
curZStencilBuffer (NULL),
curRenderSide (0),
@ -443,7 +443,7 @@ const char *device_preprocessor_name(void)
return "_D3D11";
}
int device_create(gs_device_t **p_device, gs_init_data *data)
int device_create(gs_device_t **p_device, const gs_init_data *data)
{
gs_device *device = NULL;
int errorcode = GS_SUCCESS;
@ -484,7 +484,7 @@ void device_leave_context(gs_device_t *device)
}
gs_swapchain_t *device_swapchain_create(gs_device_t *device,
struct gs_init_data *data)
const struct gs_init_data *data)
{
gs_swap_chain *swap = NULL;
@ -520,18 +520,18 @@ void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
}
}
void device_get_size(gs_device_t *device, uint32_t *cx, uint32_t *cy)
void device_get_size(const gs_device_t *device, uint32_t *cx, uint32_t *cy)
{
*cx = device->curSwapChain->target.width;
*cy = device->curSwapChain->target.height;
}
uint32_t device_get_width(gs_device_t *device)
uint32_t device_get_width(const gs_device_t *device)
{
return device->curSwapChain->target.width;
}
uint32_t device_get_height(gs_device_t *device)
uint32_t device_get_height(const gs_device_t *device)
{
return device->curSwapChain->target.height;
}
@ -625,7 +625,7 @@ gs_stagesurf_t *device_stagesurface_create(gs_device_t *device, uint32_t width,
}
gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
struct gs_sampler_info *info)
const struct gs_sampler_info *info)
{
gs_sampler_state *ss = NULL;
try {
@ -730,7 +730,7 @@ gs_indexbuffer_t *device_indexbuffer_create(gs_device_t *device,
return buffer;
}
enum gs_texture_type device_get_texture_type(gs_texture_t *texture)
enum gs_texture_type device_get_texture_type(const gs_texture_t *texture)
{
return texture->type;
}
@ -910,17 +910,17 @@ void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit)
UNUSED_PARAMETER(unit);
}
gs_shader_t *device_get_vertex_shader(gs_device_t *device)
gs_shader_t *device_get_vertex_shader(const gs_device_t *device)
{
return device->curVertexShader;
}
gs_shader_t *device_get_pixel_shader(gs_device_t *device)
gs_shader_t *device_get_pixel_shader(const gs_device_t *device)
{
return device->curPixelShader;
}
gs_texture_t *device_get_render_target(gs_device_t *device)
gs_texture_t *device_get_render_target(const gs_device_t *device)
{
if (device->curRenderTarget == &device->curSwapChain->target)
return NULL;
@ -928,7 +928,7 @@ gs_texture_t *device_get_render_target(gs_device_t *device)
return device->curRenderTarget;
}
gs_zstencil_t *device_get_zstencil_target(gs_device_t *device)
gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device)
{
if (device->curZStencilBuffer == &device->curSwapChain->zs)
return NULL;
@ -1209,8 +1209,8 @@ void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swapchain)
device_set_render_target(device, target, zs);
}
void device_clear(gs_device_t *device, uint32_t clear_flags, struct vec4 *color,
float depth, uint8_t stencil)
void device_clear(gs_device_t *device, uint32_t clear_flags,
const struct vec4 *color, float depth, uint8_t stencil)
{
int side = device->curRenderSide;
if ((clear_flags & GS_CLEAR_COLOR) != 0 && device->curRenderTarget)
@ -1251,7 +1251,7 @@ void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode)
device->rasterStateChanged = true;
}
enum gs_cull_mode device_get_cull_mode(gs_device_t *device)
enum gs_cull_mode device_get_cull_mode(const gs_device_t *device)
{
return device->rasterState.cullMode;
}
@ -1399,12 +1399,12 @@ void device_set_viewport(gs_device_t *device, int x, int y, int width,
device->viewport.cy = height;
}
void device_get_viewport(gs_device_t *device, struct gs_rect *rect)
void device_get_viewport(const gs_device_t *device, struct gs_rect *rect)
{
memcpy(rect, &device->viewport, sizeof(gs_rect));
}
void device_set_scissor_rect(gs_device_t *device, struct gs_rect *rect)
void device_set_scissor_rect(gs_device_t *device, const struct gs_rect *rect)
{
D3D11_RECT d3drect;
@ -1511,28 +1511,28 @@ void gs_texture_destroy(gs_texture_t *tex)
delete tex;
}
uint32_t gs_texture_get_width(gs_texture_t *tex)
uint32_t gs_texture_get_width(const gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return 0;
return static_cast<gs_texture_2d*>(tex)->width;
return static_cast<const gs_texture_2d*>(tex)->width;
}
uint32_t gs_texture_get_height(gs_texture_t *tex)
uint32_t gs_texture_get_height(const gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return 0;
return static_cast<gs_texture_2d*>(tex)->height;
return static_cast<const gs_texture_2d*>(tex)->height;
}
enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex)
enum gs_color_format gs_texture_get_color_format(const gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return GS_UNKNOWN;
return static_cast<gs_texture_2d*>(tex)->format;
return static_cast<const gs_texture_2d*>(tex)->format;
}
bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr, uint32_t *linesize)
@ -1579,21 +1579,22 @@ void gs_cubetexture_destroy(gs_texture_t *cubetex)
delete cubetex;
}
uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex)
uint32_t gs_cubetexture_get_size(const gs_texture_t *cubetex)
{
if (cubetex->type != GS_TEXTURE_CUBE)
return 0;
gs_texture_2d *tex = static_cast<gs_texture_2d*>(cubetex);
const gs_texture_2d *tex = static_cast<const gs_texture_2d*>(cubetex);
return tex->width;
}
enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t *cubetex)
enum gs_color_format gs_cubetexture_get_color_format(
const gs_texture_t *cubetex)
{
if (cubetex->type != GS_TEXTURE_CUBE)
return GS_UNKNOWN;
gs_texture_2d *tex = static_cast<gs_texture_2d*>(cubetex);
const gs_texture_2d *tex = static_cast<const gs_texture_2d*>(cubetex);
return tex->format;
}
@ -1603,28 +1604,28 @@ void gs_voltexture_destroy(gs_texture_t *voltex)
delete voltex;
}
uint32_t gs_voltexture_get_width(gs_texture_t *voltex)
uint32_t gs_voltexture_get_width(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_get_height(gs_texture_t *voltex)
uint32_t gs_voltexture_get_height(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_getdepth(gs_texture_t *voltex)
uint32_t gs_voltexture_getdepth(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
enum gs_color_format gs_voltexture_get_color_format(gs_texture_t *voltex)
enum gs_color_format gs_voltexture_get_color_format(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
@ -1637,17 +1638,18 @@ void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf)
delete stagesurf;
}
uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_width(const gs_stagesurf_t *stagesurf)
{
return stagesurf->width;
}
uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_height(const gs_stagesurf_t *stagesurf)
{
return stagesurf->height;
}
enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t *stagesurf)
enum gs_color_format gs_stagesurface_get_color_format(
const gs_stagesurf_t *stagesurf)
{
return stagesurf->format;
}
@ -1727,7 +1729,7 @@ void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer)
}
}
struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vertbuffer)
struct gs_vb_data *gs_vertexbuffer_get_data(const gs_vertbuffer_t *vertbuffer)
{
return vertbuffer->vbd.data;
}
@ -1757,17 +1759,17 @@ void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer)
indexbuffer->device->context->Unmap(indexbuffer->indexBuffer, 0);
}
void *gs_indexbuffer_get_data(gs_indexbuffer_t *indexbuffer)
void *gs_indexbuffer_get_data(const gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->indices.data;
}
size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer)
size_t gs_indexbuffer_get_num_indices(const gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->num;
}
enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t *indexbuffer)
enum gs_index_type gs_indexbuffer_get_type(const gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->type;
}

10
libobs-d3d11/d3d11-subsystem.hpp
View File

@ -325,7 +325,7 @@ struct gs_sampler_state {
gs_device_t *device;
gs_sampler_info info;
gs_sampler_state(gs_device_t *device, gs_sampler_info *info);
gs_sampler_state(gs_device_t *device, const gs_sampler_info *info);
};
struct gs_shader_param {
@ -449,7 +449,7 @@ struct gs_swap_chain {
void InitTarget(uint32_t cx, uint32_t cy);
void InitZStencilBuffer(uint32_t cx, uint32_t cy);
void Resize(uint32_t cx, uint32_t cy);
void Init(gs_init_data *data);
void Init(const gs_init_data *data);
inline gs_swap_chain()
: device (NULL),
@ -458,7 +458,7 @@ struct gs_swap_chain {
{
}
gs_swap_chain(gs_device *device, gs_init_data *data);
gs_swap_chain(gs_device *device, const gs_init_data *data);
};
struct BlendState {
@ -614,7 +614,7 @@ struct gs_device {
matrix4 curViewProjMatrix;
void InitFactory(uint32_t adapterIdx, IDXGIAdapter1 **adapter);
void InitDevice(gs_init_data *data, IDXGIAdapter *adapter);
void InitDevice(const gs_init_data *data, IDXGIAdapter *adapter);
ID3D11DepthStencilState *AddZStencilState();
ID3D11RasterizerState *AddRasterState();
@ -630,5 +630,5 @@ struct gs_device {
void UpdateViewProjMatrix();
gs_device(gs_init_data *data);
gs_device(const gs_init_data *data);
};

10
libobs-opengl/gl-cocoa.m
View File

@ -34,7 +34,7 @@ struct gl_platform {
struct gs_swap_chain swap;
};
static NSOpenGLContext *gl_context_create(struct gs_init_data *info)
static NSOpenGLContext *gl_context_create(const struct gs_init_data *info)
{
unsigned attrib_count = 0;
@ -97,7 +97,7 @@ static NSOpenGLContext *gl_context_create(struct gs_init_data *info)
}
static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t *dev,
struct gs_init_data *info)
const struct gs_init_data *info)
{
if(!(plat->context = gl_context_create(info)))
return false;
@ -110,7 +110,7 @@ static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t *dev,
}
struct gl_platform *gl_platform_create(gs_device_t *device,
struct gs_init_data *info)
const struct gs_init_data *info)
{
struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
@ -161,7 +161,7 @@ void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
UNUSED_PARAMETER(swap);
}
struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info)
{
if(!info)
return NULL;
@ -220,7 +220,7 @@ void device_present(gs_device_t *device)
[device->plat->context flushBuffer];
}
void gl_getclientsize(struct gs_swap_chain *swap, uint32_t *width,
void gl_getclientsize(const struct gs_swap_chain *swap, uint32_t *width,
uint32_t *height)
{
if(width) *width = swap->info.cx;

6
libobs-opengl/gl-indexbuffer.c
View File

@ -86,17 +86,17 @@ fail:
blog(LOG_ERROR, "gs_indexbuffer_flush (GL) failed");
}
void *gs_indexbuffer_get_data(gs_indexbuffer_t *ib)
void *gs_indexbuffer_get_data(const gs_indexbuffer_t *ib)
{
return ib->data;
}
size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *ib)
size_t gs_indexbuffer_get_num_indices(const gs_indexbuffer_t *ib)
{
return ib->num;
}
enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t *ib)
enum gs_index_type gs_indexbuffer_get_type(const gs_indexbuffer_t *ib)
{
return ib->type;
}

8
libobs-opengl/gl-shader.c
View File

@ -338,7 +338,7 @@ void gs_shader_destroy(gs_shader_t *shader)
bfree(shader);
}
int gs_shader_get_num_params(gs_shader_t *shader)
int gs_shader_get_num_params(const gs_shader_t *shader)
{
return (int)shader->params.num;
}
@ -362,17 +362,17 @@ gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
return NULL;
}
gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader)
{
return shader->viewproj;
}
gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader)
{
return shader->world;
}
void gs_shader_get_param_info(gs_sparam_t *param,
void gs_shader_get_param_info(const gs_sparam_t *param,
struct gs_shader_param_info *info)
{
info->type = param->type;

7
libobs-opengl/gl-stagesurf.c
View File

@ -186,17 +186,18 @@ failed:
#endif
uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_width(const gs_stagesurf_t *stagesurf)
{
return stagesurf->width;
}
uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_height(const gs_stagesurf_t *stagesurf)
{
return stagesurf->height;
}
enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t *stagesurf)
enum gs_color_format gs_stagesurface_get_color_format(
const gs_stagesurf_t *stagesurf)
{
return stagesurf->format;
}

46
libobs-opengl/gl-subsystem.c
View File

@ -147,7 +147,7 @@ static void clear_textures(struct gs_device *device)
}
void convert_sampler_info(struct gs_sampler_state *sampler,
struct gs_sampler_info *info)
const struct gs_sampler_info *info)
{
GLint max_anisotropy_max;
convert_filter(info->filter, &sampler->min_filter,
@ -191,7 +191,7 @@ const char *device_preprocessor_name(void)
return "_OPENGL";
}
int device_create(gs_device_t **p_device, struct gs_init_data *info)
int device_create(gs_device_t **p_device, const struct gs_init_data *info)
{
struct gs_device *device = bzalloc(sizeof(struct gs_device));
int errorcode = GS_ERROR_FAIL;
@ -240,7 +240,7 @@ void device_destroy(gs_device_t *device)
}
gs_swapchain_t *device_swapchain_create(gs_device_t *device,
struct gs_init_data *info)
const struct gs_init_data *info)
{
struct gs_swap_chain *swap = bzalloc(sizeof(struct gs_swap_chain));
@ -271,18 +271,18 @@ void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
gl_update(device);
}
void device_get_size(gs_device_t *device, uint32_t *cx, uint32_t *cy)
void device_get_size(const gs_device_t *device, uint32_t *cx, uint32_t *cy)
{
*cx = device->cur_swap->info.cx;
*cy = device->cur_swap->info.cy;
}
uint32_t device_get_width(gs_device_t *device)
uint32_t device_get_width(const gs_device_t *device)
{
return device->cur_swap->info.cx;
}
uint32_t device_get_height(gs_device_t *device)
uint32_t device_get_height(const gs_device_t *device)
{
return device->cur_swap->info.cy;
}
@ -305,7 +305,7 @@ gs_texture_t *device_voltexture_create(gs_device_t *device, uint32_t width,
}
gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
struct gs_sampler_info *info)
const struct gs_sampler_info *info)
{
struct gs_sampler_state *sampler;
@ -317,7 +317,7 @@ gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
return sampler;
}
enum gs_texture_type device_get_texture_type(gs_texture_t *texture)
enum gs_texture_type device_get_texture_type(const gs_texture_t *texture)
{
return texture->type;
}
@ -555,22 +555,22 @@ void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit)
UNUSED_PARAMETER(unit);
}
gs_shader_t *device_get_vertex_shader(gs_device_t *device)
gs_shader_t *device_get_vertex_shader(const gs_device_t *device)
{
return device->cur_vertex_shader;
}
gs_shader_t *device_get_pixel_shader(gs_device_t *device)
gs_shader_t *device_get_pixel_shader(const gs_device_t *device)
{
return device->cur_pixel_shader;
}
gs_texture_t *device_get_render_target(gs_device_t *device)
gs_texture_t *device_get_render_target(const gs_device_t *device)
{
return device->cur_render_target;
}
gs_zstencil_t *device_get_zstencil_target(gs_device_t *device)
gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device)
{
return device->cur_zstencil_buffer;
}
@ -843,7 +843,7 @@ void device_begin_scene(gs_device_t *device)
clear_textures(device);
}
static inline bool can_render(gs_device_t *device)
static inline bool can_render(const gs_device_t *device)
{
if (!device->cur_vertex_shader) {
blog(LOG_ERROR, "No vertex shader specified");
@ -876,7 +876,7 @@ static void update_viewproj_matrix(struct gs_device *device)
gs_shader_set_matrix4(vs->viewproj, &device->cur_viewproj);
}
static inline struct gs_program *find_program(struct gs_device *device)
static inline struct gs_program *find_program(const struct gs_device *device)
{
struct gs_program *program = device->first_program;
@ -967,7 +967,7 @@ void device_end_scene(gs_device_t *device)
}
void device_clear(gs_device_t *device, uint32_t clear_flags,
struct vec4 *color, float depth, uint8_t stencil)
const struct vec4 *color, float depth, uint8_t stencil)
{
GLbitfield gl_flags = 0;
@ -1018,7 +1018,7 @@ void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode)
gl_disable(GL_CULL_FACE);
}
enum gs_cull_mode device_get_cull_mode(gs_device_t *device)
enum gs_cull_mode device_get_cull_mode(const gs_device_t *device)
{
return device->cur_cull_mode;
}
@ -1124,7 +1124,7 @@ void device_stencil_op(gs_device_t *device, enum gs_stencil_side side,
UNUSED_PARAMETER(device);
}
static inline uint32_t get_target_height(struct gs_device *device)
static inline uint32_t get_target_height(const struct gs_device *device)
{
if (!device->cur_render_target)
return device_get_height(device);
@ -1158,12 +1158,12 @@ void device_set_viewport(gs_device_t *device, int x, int y, int width,
device->cur_viewport.cy = height;
}
void device_get_viewport(gs_device_t *device, struct gs_rect *rect)
void device_get_viewport(const gs_device_t *device, struct gs_rect *rect)
{
*rect = device->cur_viewport;
}
void device_set_scissor_rect(gs_device_t *device, struct gs_rect *rect)
void device_set_scissor_rect(gs_device_t *device, const struct gs_rect *rect)
{
UNUSED_PARAMETER(device);
@ -1268,28 +1268,28 @@ void gs_voltexture_destroy(gs_texture_t *voltex)
UNUSED_PARAMETER(voltex);
}
uint32_t gs_voltexture_get_width(gs_texture_t *voltex)
uint32_t gs_voltexture_get_width(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_get_height(gs_texture_t *voltex)
uint32_t gs_voltexture_get_height(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_getdepth(gs_texture_t *voltex)
uint32_t gs_voltexture_getdepth(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
enum gs_color_format gs_voltexture_get_color_format(gs_texture_t *voltex)
enum gs_color_format gs_voltexture_get_color_format(const gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);

9
libobs-opengl/gl-subsystem.h
View File

@ -270,7 +270,7 @@ static inline GLenum convert_gs_topology(enum gs_draw_mode mode)
}
extern void convert_sampler_info(struct gs_sampler_state *sampler,
struct gs_sampler_info *info);
const struct gs_sampler_info *info);
struct gs_sampler_state {
gs_device_t *device;
@ -510,16 +510,17 @@ extern struct fbo_info *get_fbo(struct gs_device *device,
extern void gl_update(gs_device_t *device);
extern struct gl_platform *gl_platform_create(gs_device_t *device,
struct gs_init_data *info);
const struct gs_init_data *info);
extern struct gs_swap_chain *gl_platform_getswap(struct gl_platform *platform);
extern void gl_platform_destroy(struct gl_platform *platform);
extern bool gl_platform_init_swapchain(struct gs_swap_chain *swap);
extern void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap);
extern struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info);
extern struct gl_windowinfo *gl_windowinfo_create(
const struct gs_init_data *info);
extern void gl_windowinfo_destroy(struct gl_windowinfo *wi);
extern void gl_getclientsize(struct gs_swap_chain *swap,
extern void gl_getclientsize(const struct gs_swap_chain *swap,
uint32_t *width,
uint32_t *height);

16
libobs-opengl/gl-texture2d.c
View File

@ -112,7 +112,7 @@ fail:
return NULL;
}
static inline bool is_texture_2d(gs_texture_t *tex, const char *func)
static inline bool is_texture_2d(const gs_texture_t *tex, const char *func)
{
bool is_tex2d = tex->type == GS_TEXTURE_2D;
if (!is_tex2d)
@ -141,25 +141,25 @@ void gs_texture_destroy(gs_texture_t *tex)
bfree(tex);
}
uint32_t gs_texture_get_width(gs_texture_t *tex)
uint32_t gs_texture_get_width(const gs_texture_t *tex)
{
struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
const struct gs_texture_2d *tex2d = (const struct gs_texture_2d*)tex;
if (!is_texture_2d(tex, "gs_texture_get_width"))
return 0;
return tex2d->width;
}
uint32_t gs_texture_get_height(gs_texture_t *tex)
uint32_t gs_texture_get_height(const gs_texture_t *tex)
{
struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
const struct gs_texture_2d *tex2d = (const struct gs_texture_2d*)tex;
if (!is_texture_2d(tex, "gs_texture_get_height"))
return 0;
return tex2d->height;
}
enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex)
enum gs_color_format gs_texture_get_color_format(const gs_texture_t *tex)
{
return tex->format;
}
@ -226,9 +226,9 @@ failed:
blog(LOG_ERROR, "gs_texture_unmap (GL) failed");
}
bool gs_texture_is_rect(gs_texture_t *tex)
bool gs_texture_is_rect(const gs_texture_t *tex)
{
struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
const struct gs_texture_2d *tex2d = (const struct gs_texture_2d*)tex;
if (!is_texture_2d(tex, "gs_texture_unmap")) {
blog(LOG_ERROR, "gs_texture_is_rect (GL) failed");
return false;

11
libobs-opengl/gl-texturecube.c
View File

@ -100,7 +100,7 @@ void gs_cubetexture_destroy(gs_texture_t *tex)
bfree(tex);
}
static inline bool is_texture_cube(gs_texture_t *tex, const char *func)
static inline bool is_texture_cube(const gs_texture_t *tex, const char *func)
{
bool is_texcube = tex->type == GS_TEXTURE_CUBE;
if (!is_texcube)
@ -108,16 +108,19 @@ static inline bool is_texture_cube(gs_texture_t *tex, const char *func)
return is_texcube;
}
uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex)
uint32_t gs_cubetexture_get_size(const gs_texture_t *cubetex)
{
struct gs_texture_cube *cube = (struct gs_texture_cube*)cubetex;
const struct gs_texture_cube *cube =
(const struct gs_texture_cube*)cubetex;
if (!is_texture_cube(cubetex, "gs_cubetexture_get_size"))
return 0;
return cube->size;
}
enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t *cubetex)
enum gs_color_format gs_cubetexture_get_color_format(
const gs_texture_t *cubetex)
{
return cubetex->format;
}

2
libobs-opengl/gl-vertexbuffer.c
View File

@ -170,7 +170,7 @@ failed:
blog(LOG_ERROR, "gs_vertexbuffer_flush (GL) failed");
}
struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vb)
struct gs_vb_data *gs_vertexbuffer_get_data(const gs_vertbuffer_t *vb)
{
return vb->data;
}

14
libobs-opengl/gl-windows.c
View File

@ -267,7 +267,7 @@ static inline void add_attrib(struct darray *list, int attrib, int val)
}
/* Creates the real pixel format for the target window */
static int gl_choose_pixel_format(HDC hdc, struct gs_init_data *info)
static int gl_choose_pixel_format(HDC hdc, const struct gs_init_data *info)
{
struct darray attribs;
int color_bits = get_color_format_bits(info->format);
@ -307,7 +307,7 @@ static int gl_choose_pixel_format(HDC hdc, struct gs_init_data *info)
return format;
}
static inline bool gl_getpixelformat(HDC hdc, struct gs_init_data *info,
static inline bool gl_getpixelformat(HDC hdc, const struct gs_init_data *info,
int *format, PIXELFORMATDESCRIPTOR *pfd)
{
if (!format)
@ -335,7 +335,7 @@ static inline bool gl_setpixelformat(HDC hdc, int format,
return true;
}
static struct gl_windowinfo *gl_windowinfo_bare(struct gs_init_data *info)
static struct gl_windowinfo *gl_windowinfo_bare(const struct gs_init_data *info)
{
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
wi->hwnd = info->window.hwnd;
@ -352,7 +352,7 @@ static struct gl_windowinfo *gl_windowinfo_bare(struct gs_init_data *info)
static bool init_default_swap(struct gl_platform *plat, gs_device_t *device,
int pixel_format, PIXELFORMATDESCRIPTOR *pfd,
struct gs_init_data *info)
const struct gs_init_data *info)
{
plat->swap.device = device;
plat->swap.info = *info;
@ -373,7 +373,7 @@ void gl_update(gs_device_t *device)
}
struct gl_platform *gl_platform_create(gs_device_t *device,
struct gs_init_data *info)
const struct gs_init_data *info)
{
struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
struct dummy_context dummy;
@ -444,7 +444,7 @@ void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
UNUSED_PARAMETER(swap);
}
struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
struct gl_windowinfo *gl_windowinfo_create(const struct gs_init_data *info)
{
struct gl_windowinfo *wi = gl_windowinfo_bare(info);
PIXELFORMATDESCRIPTOR pfd;
@ -519,7 +519,7 @@ void device_present(gs_device_t *device)
}
}
extern void gl_getclientsize(struct gs_swap_chain *swap,
extern void gl_getclientsize(const struct gs_swap_chain *swap,
uint32_t *width, uint32_t *height)
{
RECT rc;

9
libobs-opengl/gl-x11.c
View File

@ -61,7 +61,8 @@ extern struct gs_swap_chain *gl_platform_getswap(struct gl_platform *platform)
return &platform->swap;
}
extern struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
extern struct gl_windowinfo *gl_windowinfo_create(
const struct gs_init_data *info)
{
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
wi->id = info->window.id;
@ -75,7 +76,7 @@ extern void gl_windowinfo_destroy(struct gl_windowinfo *wi)
bfree(wi);
}
extern void gl_getclientsize(struct gs_swap_chain *swap,
extern void gl_getclientsize(const struct gs_swap_chain *swap,
uint32_t *width, uint32_t *height)
{
XWindowAttributes info = { 0 };
@ -86,7 +87,7 @@ extern void gl_getclientsize(struct gs_swap_chain *swap,
*width = info.width;
}
static void print_info_stuff(struct gs_init_data *info)
static void print_info_stuff(const struct gs_init_data *info)
{
blog( LOG_INFO,
"X and Y: %i %i\n"
@ -136,7 +137,7 @@ static bool handle_x_error(Display *disp, const char *error_string)
}
struct gl_platform *gl_platform_create(gs_device_t *device,
struct gs_init_data *info)
const struct gs_init_data *info)
{
int num_configs = 0;
int error_base = 0, event_base = 0;

7
libobs/callback/calldata.c
View File

@ -63,7 +63,7 @@ static inline const char *cd_serialize_string(uint8_t **pos)
return (size != 0) ? str : NULL;
}
static bool cd_getparam(calldata_t *data, const char *name,
static bool cd_getparam(const calldata_t *data, const char *name,
uint8_t **pos)
{
size_t name_size;
@ -159,7 +159,7 @@ static inline void cd_ensure_capacity(calldata_t *data, uint8_t **pos,
/* ------------------------------------------------------------------------- */
bool calldata_get_data(calldata_t *data, const char *name, void *out,
bool calldata_get_data(const calldata_t *data, const char *name, void *out,
size_t size)
{
uint8_t *pos;
@ -225,7 +225,8 @@ void calldata_set_data(calldata_t *data, const char *name, const void *in,
}
}
bool calldata_get_string(calldata_t *data, const char *name, const char **str)
bool calldata_get_string(const calldata_t *data, const char *name,
const char **str)
{
uint8_t *pos;
if (!data || !name || !*name)

25
libobs/callback/calldata.h
View File

@ -61,8 +61,8 @@ static inline void calldata_free(struct calldata *data)
bfree(data->stack);
}
EXPORT bool calldata_get_data(calldata_t *data, const char *name, void *out,
size_t size);
EXPORT bool calldata_get_data(const calldata_t *data, const char *name,
void *out, size_t size);
EXPORT void calldata_set_data(calldata_t *data, const char *name,
const void *in, size_t new_size);
@ -78,65 +78,66 @@ static inline void calldata_clear(struct calldata *data)
/* NOTE: 'get' functions return true only if paramter exists, and is the
* same type. They return false otherwise. */
static inline bool calldata_get_int(calldata_t *data, const char *name,
static inline bool calldata_get_int(const calldata_t *data, const char *name,
long long *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_float (calldata_t *data, const char *name,
static inline bool calldata_get_float (const calldata_t *data, const char *name,
double *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_bool (calldata_t *data, const char *name,
static inline bool calldata_get_bool (const calldata_t *data, const char *name,
bool *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_ptr (calldata_t *data, const char *name,
static inline bool calldata_get_ptr (const calldata_t *data, const char *name,
void *p_ptr)
{
return calldata_get_data(data, name, p_ptr, sizeof(p_ptr));
}
EXPORT bool calldata_get_string(calldata_t *data, const char *name,
EXPORT bool calldata_get_string(const calldata_t *data, const char *name,
const char **str);
/* ------------------------------------------------------------------------- */
/* call if you know your data is valid */
static inline long long calldata_int(calldata_t *data, const char *name)
static inline long long calldata_int(const calldata_t *data, const char *name)
{
long long val = 0;
calldata_get_int(data, name, &val);
return val;
}
static inline double calldata_float(calldata_t *data, const char *name)
static inline double calldata_float(const calldata_t *data, const char *name)
{
double val = 0.0;
calldata_get_float(data, name, &val);
return val;
}
static inline bool calldata_bool(calldata_t *data, const char *name)
static inline bool calldata_bool(const calldata_t *data, const char *name)
{
bool val = false;
calldata_get_bool(data, name, &val);
return val;
}
static inline void *calldata_ptr(calldata_t *data, const char *name)
static inline void *calldata_ptr(const calldata_t *data, const char *name)
{
void *val;
calldata_get_ptr(data, name, &val);
return val;
}
static inline const char *calldata_string(calldata_t *data, const char *name)
static inline const char *calldata_string(const calldata_t *data,
const char *name)
{
const char *val;
calldata_get_string(data, name, &val);

41
libobs/graphics/device-exports.h
View File

@ -26,16 +26,16 @@ extern "C" {
EXPORT const char *device_get_name(void);
EXPORT int device_get_type(void);
EXPORT const char *device_preprocessor_name(void);
EXPORT int device_create(gs_device_t **device, struct gs_init_data *data);
EXPORT int device_create(gs_device_t **device, const struct gs_init_data *data);
EXPORT void device_destroy(gs_device_t *device);
EXPORT void device_enter_context(gs_device_t *device);
EXPORT void device_leave_context(gs_device_t *device);
EXPORT gs_swapchain_t *device_swapchain_create(gs_device_t *device,
struct gs_init_data *data);
const struct gs_init_data *data);
EXPORT void device_resize(gs_device_t *device, uint32_t x, uint32_t y);
EXPORT void device_get_size(gs_device_t *device, uint32_t *x, uint32_t *y);
EXPORT uint32_t device_get_width(gs_device_t *device);
EXPORT uint32_t device_get_height(gs_device_t *device);
EXPORT void device_get_size(const gs_device_t *device, uint32_t *x, uint32_t *y);
EXPORT uint32_t device_get_width(const gs_device_t *device);
EXPORT uint32_t device_get_height(const gs_device_t *device);
EXPORT 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);
@ -53,7 +53,7 @@ EXPORT gs_stagesurf_t *device_stagesurface_create(gs_device_t *device,
uint32_t width, uint32_t height,
enum gs_color_format color_format);
EXPORT gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
struct gs_sampler_info *info);
const struct gs_sampler_info *info);
EXPORT gs_shader_t *device_vertexshader_create(gs_device_t *device,
const char *shader, const char *file,
char **error_string);
@ -65,7 +65,8 @@ EXPORT gs_vertbuffer_t *device_vertexbuffer_create(gs_device_t *device,
EXPORT gs_indexbuffer_t *device_indexbuffer_create(gs_device_t *device,
enum gs_index_type type, void *indices, size_t num,
uint32_t flags);
EXPORT enum gs_texture_type device_get_texture_type(gs_texture_t *texture);
EXPORT enum gs_texture_type device_get_texture_type(
const gs_texture_t *texture);
EXPORT void device_load_vertexbuffer(gs_device_t *device,
gs_vertbuffer_t *vertbuffer);
EXPORT void device_load_indexbuffer(gs_device_t *device,
@ -80,10 +81,10 @@ EXPORT void device_load_pixelshader(gs_device_t *device,
gs_shader_t *pixelshader);
EXPORT void device_load_default_samplerstate(gs_device_t *device, bool b_3d,
int unit);
EXPORT gs_shader_t *device_get_vertex_shader(gs_device_t *device);
EXPORT gs_shader_t *device_get_pixel_shader(gs_device_t *device);
EXPORT gs_texture_t *device_get_render_target(gs_device_t *device);
EXPORT gs_zstencil_t *device_get_zstencil_target(gs_device_t *device);
EXPORT gs_shader_t *device_get_vertex_shader(const gs_device_t *device);
EXPORT gs_shader_t *device_get_pixel_shader(const gs_device_t *device);
EXPORT gs_texture_t *device_get_render_target(const gs_device_t *device);
EXPORT gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device);
EXPORT void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil);
EXPORT void device_set_cube_render_target(gs_device_t *device,
@ -104,11 +105,11 @@ EXPORT void device_end_scene(gs_device_t *device);
EXPORT void device_load_swapchain(gs_device_t *device,
gs_swapchain_t *swapchain);
EXPORT void device_clear(gs_device_t *device, uint32_t clear_flags,
struct vec4 *color, float depth, uint8_t stencil);
const struct vec4 *color, float depth, uint8_t stencil);
EXPORT void device_present(gs_device_t *device);
EXPORT void device_flush(gs_device_t *device);
EXPORT void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode);
EXPORT enum gs_cull_mode device_get_cull_mode(gs_device_t *device);
EXPORT enum gs_cull_mode device_get_cull_mode(const gs_device_t *device);
EXPORT void device_enable_blending(gs_device_t *device, bool enable);
EXPORT void device_enable_depth_test(gs_device_t *device, bool enable);
EXPORT void device_enable_stencil_test(gs_device_t *device, bool enable);
@ -123,18 +124,12 @@ EXPORT void device_stencil_function(gs_device_t *device,
EXPORT 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);
EXPORT void device_enable_fullscreen(gs_device_t *device, bool enable);
EXPORT int device_fullscreen_enabled(gs_device_t *device);
EXPORT void device_setdisplaymode(gs_device_t *device,
const struct gs_display_mode *mode);
EXPORT void device_getdisplaymode(gs_device_t *device,
struct gs_display_mode *mode);
EXPORT void device_setcolorramp(gs_device_t *device, float gamma,
float brightness, float contrast);
EXPORT void device_set_viewport(gs_device_t *device, int x, int y, int width,
int height);
EXPORT void device_get_viewport(gs_device_t *device, struct gs_rect *rect);
EXPORT void device_set_scissor_rect(gs_device_t *device, struct gs_rect *rect);
EXPORT void device_get_viewport(const gs_device_t *device,
struct gs_rect *rect);
EXPORT void device_set_scissor_rect(gs_device_t *device,
const struct gs_rect *rect);
EXPORT void device_ortho(gs_device_t *device, float left, float right,
float top, float bottom, float znear, float zfar);
EXPORT void device_frustum(gs_device_t *device, float left, float right,

16
libobs/graphics/effect.c
View File

@ -29,7 +29,8 @@ void gs_effect_destroy(gs_effect_t *effect)
}
}
gs_technique_t *gs_effect_get_technique(gs_effect_t *effect, const char *name)
gs_technique_t *gs_effect_get_technique(const gs_effect_t *effect,
const char *name)
{
if (!effect) return NULL;
@ -194,12 +195,12 @@ void gs_technique_end_pass(gs_technique_t *tech)
tech->effect->cur_pass = NULL;
}
size_t gs_effect_get_num_params(gs_effect_t *effect)
size_t gs_effect_get_num_params(const gs_effect_t *effect)
{
return effect ? effect->params.num : 0;
}
gs_eparam_t *gs_effect_get_param_by_idx(gs_effect_t *effect, size_t param)
gs_eparam_t *gs_effect_get_param_by_idx(const gs_effect_t *effect, size_t param)
{
if (!effect) return NULL;
@ -210,7 +211,8 @@ gs_eparam_t *gs_effect_get_param_by_idx(gs_effect_t *effect, size_t param)
return params+param;
}
gs_eparam_t *gs_effect_get_param_by_name(gs_effect_t *effect, const char *name)
gs_eparam_t *gs_effect_get_param_by_name(const gs_effect_t *effect,
const char *name)
{
if (!effect) return NULL;
@ -226,17 +228,17 @@ gs_eparam_t *gs_effect_get_param_by_name(gs_effect_t *effect, const char *name)
return NULL;
}
gs_eparam_t *gs_effect_get_viewproj_matrix(gs_effect_t *effect)
gs_eparam_t *gs_effect_get_viewproj_matrix(const gs_effect_t *effect)
{
return effect ? effect->view_proj : NULL;
}
gs_eparam_t *gs_effect_get_world_matrix(gs_effect_t *effect)
gs_eparam_t *gs_effect_get_world_matrix(const gs_effect_t *effect)
{
return effect ? effect->world : NULL;
}
void gs_effect_get_param_info(gs_eparam_t *param,
void gs_effect_get_param_info(const gs_eparam_t *param,
struct gs_effect_param_info *info)
{
if (!param)

81
libobs/graphics/graphics-internal.h
View File

@ -27,16 +27,18 @@ struct gs_exports {
const char *(*device_get_name)(void);
int (*device_get_type)(void);
const char *(*device_preprocessor_name)(void);
int (*device_create)(gs_device_t **device, struct gs_init_data *data);
int (*device_create)(gs_device_t **device,
const struct gs_init_data *data);
void (*device_destroy)(gs_device_t *device);
void (*device_enter_context)(gs_device_t *device);
void (*device_leave_context)(gs_device_t *device);
gs_swapchain_t *(*device_swapchain_create)(gs_device_t *device,
struct gs_init_data *data);
const struct gs_init_data *data);
void (*device_resize)(gs_device_t *device, uint32_t x, uint32_t y);
void (*device_get_size)(gs_device_t *device, uint32_t *x, uint32_t *y);
uint32_t (*device_get_width)(gs_device_t *device);
uint32_t (*device_get_height)(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,
@ -55,7 +57,7 @@ struct gs_exports {
uint32_t width, uint32_t height,
enum gs_color_format color_format);
gs_samplerstate_t *(*device_samplerstate_create)(gs_device_t *device,
struct gs_sampler_info *info);
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);
@ -67,7 +69,8 @@ struct gs_exports {
gs_indexbuffer_t *(*device_indexbuffer_create)(gs_device_t *device,
enum gs_index_type type, void *indices, size_t num,
uint32_t flags);
enum gs_texture_type (*device_get_texture_type)(gs_texture_t *texture);
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,
@ -82,10 +85,10 @@ struct gs_exports {
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)(gs_device_t *device);
gs_shader_t *(*device_get_pixel_shader)(gs_device_t *device);
gs_texture_t *(*device_get_render_target)(gs_device_t *device);
gs_zstencil_t *(*device_get_zstencil_target)(gs_device_t *device);
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_cube_render_target)(gs_device_t *device,
@ -105,12 +108,12 @@ struct gs_exports {
void (*device_load_swapchain)(gs_device_t *device,
gs_swapchain_t *swaphchain);
void (*device_clear)(gs_device_t *device, uint32_t clear_flags,
struct vec4 *color, float depth, uint8_t stencil);
const struct vec4 *color, float depth, uint8_t stencil);
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)(gs_device_t *device);
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);
@ -130,9 +133,10 @@ struct gs_exports {
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)(gs_device_t *device, struct gs_rect *rect);
void (*device_set_scissor_rect)(gs_device_t *device,
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,
@ -143,32 +147,33 @@ struct gs_exports {
void (*gs_swapchain_destroy)(gs_swapchain_t *swapchain);
void (*gs_texture_destroy)(gs_texture_t *tex);
uint32_t (*gs_texture_get_width)(gs_texture_t *tex);
uint32_t (*gs_texture_get_height)(gs_texture_t *tex);
enum gs_color_format (*gs_texture_get_color_format)(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)(gs_texture_t *tex);
void *(*gs_texture_get_obj)(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)(gs_texture_t *cubetex);
uint32_t (*gs_cubetexture_get_size)(const gs_texture_t *cubetex);
enum gs_color_format (*gs_cubetexture_get_color_format)(
gs_texture_t *cubetex);
const gs_texture_t *cubetex);
void (*gs_voltexture_destroy)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_get_width)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_get_height)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_getdepth)(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_getdepth)(const gs_texture_t *voltex);
enum gs_color_format (*gs_voltexture_get_color_format)(
gs_texture_t *voltex);
const gs_texture_t *voltex);
void (*gs_stagesurface_destroy)(gs_stagesurf_t *stagesurf);
uint32_t (*gs_stagesurface_get_width)(gs_stagesurf_t *stagesurf);
uint32_t (*gs_stagesurface_get_height)(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)(
gs_stagesurf_t *stagesurf);
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);
@ -180,24 +185,26 @@ struct gs_exports {
void (*gs_vertexbuffer_destroy)(gs_vertbuffer_t *vertbuffer);
void (*gs_vertexbuffer_flush)(gs_vertbuffer_t *vertbuffer);
struct gs_vb_data *(*gs_vertexbuffer_get_data)(
gs_vertbuffer_t *vertbuffer);
const gs_vertbuffer_t *vertbuffer);
void (*gs_indexbuffer_destroy)(gs_indexbuffer_t *indexbuffer);
void (*gs_indexbuffer_flush)(gs_indexbuffer_t *indexbuffer);
void *(*gs_indexbuffer_get_data)(gs_indexbuffer_t *indexbuffer);
size_t (*gs_indexbuffer_get_num_indices)(gs_indexbuffer_t *indexbuffer);
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)(
gs_indexbuffer_t *indexbuffer);
const gs_indexbuffer_t *indexbuffer);
void (*gs_shader_destroy)(gs_shader_t *shader);
int (*gs_shader_get_num_params)(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)(gs_shader_t *shader);
gs_sparam_t *(*gs_shader_get_world_matrix)(gs_shader_t *shader);
void (*gs_shader_get_param_info)(gs_sparam_t *param,
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);

56
libobs/graphics/graphics.c
View File

@ -117,7 +117,7 @@ static bool graphics_init(struct graphics_subsystem *graphics)
}
int gs_create(graphics_t **pgraphics, const char *module,
struct gs_init_data *data)
const struct gs_init_data *data)
{
struct gs_init_data new_data = *data;
int errcode = GS_ERROR_FAIL;
@ -958,7 +958,7 @@ const char *gs_preprocessor_name(void)
return graphics->exports.device_preprocessor_name();
}
gs_swapchain_t *gs_swapchain_create(struct gs_init_data *data)
gs_swapchain_t *gs_swapchain_create(const struct gs_init_data *data)
{
struct gs_init_data new_data = *data;
@ -1106,7 +1106,7 @@ gs_stagesurf_t *gs_stagesurface_create(uint32_t width, uint32_t height,
width, height, color_format);
}
gs_samplerstate_t *gs_samplerstate_create(struct gs_sampler_info *info)
gs_samplerstate_t *gs_samplerstate_create(const struct gs_sampler_info *info)
{
graphics_t *graphics = thread_graphics;
if (!graphics) return NULL;
@ -1155,7 +1155,7 @@ gs_indexbuffer_t *gs_indexbuffer_create(enum gs_index_type type,
type, indices, num, flags);
}
enum gs_texture_type gs_get_texture_type(gs_texture_t *texture)
enum gs_texture_type gs_get_texture_type(const gs_texture_t *texture)
{
graphics_t *graphics = thread_graphics;
if (!graphics) return GS_TEXTURE_2D;
@ -1338,7 +1338,7 @@ void gs_load_swapchain(gs_swapchain_t *swapchain)
graphics->exports.device_load_swapchain(graphics->device, swapchain);
}
void gs_clear(uint32_t clear_flags, struct vec4 *color, float depth,
void gs_clear(uint32_t clear_flags, const struct vec4 *color, float depth,
uint8_t stencil)
{
graphics_t *graphics = thread_graphics;
@ -1473,7 +1473,7 @@ void gs_get_viewport(struct gs_rect *rect)
graphics->exports.device_get_viewport(graphics->device, rect);
}
void gs_set_scissor_rect(struct gs_rect *rect)
void gs_set_scissor_rect(const struct gs_rect *rect)
{
graphics_t *graphics = thread_graphics;
if (!graphics) return;
@ -1533,7 +1533,7 @@ void gs_shader_destroy(gs_shader_t *shader)
graphics->exports.gs_shader_destroy(shader);
}
int gs_shader_get_num_params(gs_shader_t *shader)
int gs_shader_get_num_params(const gs_shader_t *shader)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !shader) return 0;
@ -1557,7 +1557,7 @@ gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
return graphics->exports.gs_shader_get_param_by_name(shader, name);
}
gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !shader) return NULL;
@ -1565,7 +1565,7 @@ gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader)
return graphics->exports.gs_shader_get_viewproj_matrix(shader);
}
gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader)
gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !shader) return NULL;
@ -1573,7 +1573,7 @@ gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader)
return graphics->exports.gs_shader_get_world_matrix(shader);
}
void gs_shader_get_param_info(gs_sparam_t *param,
void gs_shader_get_param_info(const gs_sparam_t *param,
struct gs_shader_param_info *info)
{
graphics_t *graphics = thread_graphics;
@ -1678,7 +1678,7 @@ void gs_texture_destroy(gs_texture_t *tex)
graphics->exports.gs_texture_destroy(tex);
}
uint32_t gs_texture_get_width(gs_texture_t *tex)
uint32_t gs_texture_get_width(const gs_texture_t *tex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !tex) return 0;
@ -1686,7 +1686,7 @@ uint32_t gs_texture_get_width(gs_texture_t *tex)
return graphics->exports.gs_texture_get_width(tex);
}
uint32_t gs_texture_get_height(gs_texture_t *tex)
uint32_t gs_texture_get_height(const gs_texture_t *tex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !tex) return 0;
@ -1694,7 +1694,7 @@ uint32_t gs_texture_get_height(gs_texture_t *tex)
return graphics->exports.gs_texture_get_height(tex);
}
enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex)
enum gs_color_format gs_texture_get_color_format(const gs_texture_t *tex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !tex) return GS_UNKNOWN;
@ -1718,7 +1718,7 @@ void gs_texture_unmap(gs_texture_t *tex)
graphics->exports.gs_texture_unmap(tex);
}
bool gs_texture_is_rect(gs_texture_t *tex)
bool gs_texture_is_rect(const gs_texture_t *tex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !tex) return false;
@ -1745,7 +1745,7 @@ void gs_cubetexture_destroy(gs_texture_t *cubetex)
graphics->exports.gs_cubetexture_destroy(cubetex);
}
uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex)
uint32_t gs_cubetexture_get_size(const gs_texture_t *cubetex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !cubetex) return 0;
@ -1753,7 +1753,8 @@ uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex)
return graphics->exports.gs_cubetexture_get_size(cubetex);
}
enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t *cubetex)
enum gs_color_format gs_cubetexture_get_color_format(
const gs_texture_t *cubetex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !cubetex) return GS_UNKNOWN;
@ -1769,7 +1770,7 @@ void gs_voltexture_destroy(gs_texture_t *voltex)
graphics->exports.gs_voltexture_destroy(voltex);
}
uint32_t gs_voltexture_get_width(gs_texture_t *voltex)
uint32_t gs_voltexture_get_width(const gs_texture_t *voltex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !voltex) return 0;
@ -1777,7 +1778,7 @@ uint32_t gs_voltexture_get_width(gs_texture_t *voltex)
return graphics->exports.gs_voltexture_get_width(voltex);
}
uint32_t gs_voltexture_get_height(gs_texture_t *voltex)
uint32_t gs_voltexture_get_height(const gs_texture_t *voltex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !voltex) return 0;
@ -1785,7 +1786,7 @@ uint32_t gs_voltexture_get_height(gs_texture_t *voltex)
return graphics->exports.gs_voltexture_get_height(voltex);
}
uint32_t gs_voltexture_getdepth(gs_texture_t *voltex)
uint32_t gs_voltexture_getdepth(const gs_texture_t *voltex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !voltex) return 0;
@ -1793,7 +1794,7 @@ uint32_t gs_voltexture_getdepth(gs_texture_t *voltex)
return graphics->exports.gs_voltexture_getdepth(voltex);
}
enum gs_color_format gs_voltexture_get_color_format(gs_texture_t *voltex)
enum gs_color_format gs_voltexture_get_color_format(const gs_texture_t *voltex)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !voltex) return GS_UNKNOWN;
@ -1809,7 +1810,7 @@ void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf)
graphics->exports.gs_stagesurface_destroy(stagesurf);
}
uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_width(const gs_stagesurf_t *stagesurf)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !stagesurf) return 0;
@ -1817,7 +1818,7 @@ uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
return graphics->exports.gs_stagesurface_get_width(stagesurf);
}
uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf)
uint32_t gs_stagesurface_get_height(const gs_stagesurf_t *stagesurf)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !stagesurf) return 0;
@ -1825,7 +1826,8 @@ uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf)
return graphics->exports.gs_stagesurface_get_height(stagesurf);
}
enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t *stagesurf)
enum gs_color_format gs_stagesurface_get_color_format(
const gs_stagesurf_t *stagesurf)
{
graphics_t *graphics = thread_graphics;
if (!graphics || !stagesurf) return GS_UNKNOWN;
@ -1879,7 +1881,7 @@ void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer)
thread_graphics->exports.gs_vertexbuffer_flush(vertbuffer);
}
struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vertbuffer)
struct gs_vb_data *gs_vertexbuffer_get_data(const gs_vertbuffer_t *vertbuffer)
{
if (!thread_graphics || !vertbuffer) return NULL;
@ -1901,14 +1903,14 @@ void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer)
thread_graphics->exports.gs_indexbuffer_flush(indexbuffer);
}
void *gs_indexbuffer_get_data(gs_indexbuffer_t *indexbuffer)
void *gs_indexbuffer_get_data(const gs_indexbuffer_t *indexbuffer)
{
if (!thread_graphics || !indexbuffer) return NULL;
return thread_graphics->exports.gs_indexbuffer_get_data(indexbuffer);
}
size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer)
size_t gs_indexbuffer_get_num_indices(const gs_indexbuffer_t *indexbuffer)
{
if (!thread_graphics || !indexbuffer) return 0;
@ -1916,7 +1918,7 @@ size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer)
indexbuffer);
}
enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t *indexbuffer)
enum gs_index_type gs_indexbuffer_get_type(const gs_indexbuffer_t *indexbuffer)
{
if (!thread_graphics || !indexbuffer) return (enum gs_index_type)0;

75
libobs/graphics/graphics.h
View File

@ -292,16 +292,16 @@ enum gs_shader_type {
EXPORT void gs_shader_destroy(gs_shader_t *shader);
EXPORT int gs_shader_get_num_params(gs_shader_t *shader);
EXPORT int gs_shader_get_num_params(const gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader,
uint32_t param);
EXPORT gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader,
const char *name);
EXPORT gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader);
EXPORT void gs_shader_get_param_info(gs_sparam_t *param,
EXPORT void gs_shader_get_param_info(const gs_sparam_t *param,
struct gs_shader_param_info *info);
EXPORT void gs_shader_set_bool(gs_sparam_t *param, bool val);
EXPORT void gs_shader_set_float(gs_sparam_t *param, float val);
@ -339,7 +339,7 @@ struct gs_effect_param_info {
EXPORT void gs_effect_destroy(gs_effect_t *effect);
EXPORT gs_technique_t *gs_effect_get_technique(gs_effect_t *effect,
EXPORT gs_technique_t *gs_effect_get_technique(const gs_effect_t *effect,
const char *name);
EXPORT size_t gs_technique_begin(gs_technique_t *technique);
@ -349,18 +349,19 @@ EXPORT bool gs_technique_begin_pass_by_name(gs_technique_t *technique,
const char *name);
EXPORT void gs_technique_end_pass(gs_technique_t *technique);
EXPORT size_t gs_effect_get_num_params(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_param_by_idx(gs_effect_t *effect, size_t param);
EXPORT gs_eparam_t *gs_effect_get_param_by_name(gs_effect_t *effect,
EXPORT size_t gs_effect_get_num_params(const gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_param_by_idx(const gs_effect_t *effect,
size_t param);
EXPORT gs_eparam_t *gs_effect_get_param_by_name(const gs_effect_t *effect,
const char *name);
/** used internally */
EXPORT void gs_effect_update_params(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_viewproj_matrix(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_world_matrix(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_viewproj_matrix(const gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_world_matrix(const gs_effect_t *effect);
EXPORT void gs_effect_get_param_info(gs_eparam_t *param,
EXPORT void gs_effect_get_param_info(const gs_eparam_t *param,
struct gs_effect_param_info *info);
EXPORT void gs_effect_set_bool(gs_eparam_t *param, bool val);
EXPORT void gs_effect_set_float(gs_eparam_t *param, float val);
@ -385,7 +386,7 @@ EXPORT bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx,
uint32_t cy);
EXPORT void gs_texrender_end(gs_texrender_t *texrender);
EXPORT void gs_texrender_reset(gs_texrender_t *texrender);
EXPORT gs_texture_t *gs_texrender_get_texture(gs_texrender_t *texrender);
EXPORT gs_texture_t *gs_texrender_get_texture(const gs_texrender_t *texrender);
/* ---------------------------------------------------
* graphics subsystem
@ -432,7 +433,7 @@ EXPORT const char *gs_get_device_name(void);
EXPORT int gs_get_device_type(void);
EXPORT int gs_create(graphics_t **graphics, const char *module,
struct gs_init_data *data);
const struct gs_init_data *data);
EXPORT void gs_destroy(graphics_t *graphics);
EXPORT void gs_enter_context(graphics_t *graphics);
@ -522,7 +523,7 @@ EXPORT void gs_reset_blend_state(void);
/* -------------------------- */
/* library-specific functions */
EXPORT gs_swapchain_t *gs_swapchain_create(struct gs_init_data *data);
EXPORT gs_swapchain_t *gs_swapchain_create(const struct gs_init_data *data);
EXPORT void gs_resize(uint32_t x, uint32_t y);
EXPORT void gs_get_size(uint32_t *x, uint32_t *y);
@ -545,7 +546,8 @@ EXPORT gs_zstencil_t *gs_zstencil_create(uint32_t width, uint32_t height,
EXPORT gs_stagesurf_t *gs_stagesurface_create(uint32_t width, uint32_t height,
enum gs_color_format color_format);
EXPORT gs_samplerstate_t *gs_samplerstate_create(struct gs_sampler_info *info);
EXPORT gs_samplerstate_t *gs_samplerstate_create(
const struct gs_sampler_info *info);
EXPORT gs_shader_t *gs_vertexshader_create(const char *shader,
const char *file, char **error_string);
@ -557,7 +559,7 @@ EXPORT gs_vertbuffer_t *gs_vertexbuffer_create(struct gs_vb_data *data,
EXPORT gs_indexbuffer_t *gs_indexbuffer_create(enum gs_index_type type,
void *indices, size_t num, uint32_t flags);
EXPORT enum gs_texture_type gs_get_texture_type(gs_texture_t *texture);
EXPORT enum gs_texture_type gs_get_texture_type(const gs_texture_t *texture);
EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t *vertbuffer);
EXPORT void gs_load_indexbuffer(gs_indexbuffer_t *indexbuffer);
@ -595,7 +597,7 @@ EXPORT void gs_end_scene(void);
#define GS_CLEAR_STENCIL (1<<2)
EXPORT void gs_load_swapchain(gs_swapchain_t *swapchain);
EXPORT void gs_clear(uint32_t clear_flags, struct vec4 *color,
EXPORT void gs_clear(uint32_t clear_flags, const struct vec4 *color,
float depth, uint8_t stencil);
EXPORT void gs_present(void);
EXPORT void gs_flush(void);
@ -621,7 +623,7 @@ EXPORT void gs_stencil_op(enum gs_stencil_side side,
EXPORT void gs_set_viewport(int x, int y, int width, int height);
EXPORT void gs_get_viewport(struct gs_rect *rect);
EXPORT void gs_set_scissor_rect(struct gs_rect *rect);
EXPORT void gs_set_scissor_rect(const struct gs_rect *rect);
EXPORT void gs_ortho(float left, float right, float top, float bottom,
float znear, float zfar);
@ -634,16 +636,17 @@ EXPORT void gs_projection_pop(void);
EXPORT void gs_swapchain_destroy(gs_swapchain_t *swapchain);
EXPORT void gs_texture_destroy(gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_width(gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_height(gs_texture_t *tex);
EXPORT enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_width(const gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_height(const gs_texture_t *tex);
EXPORT enum gs_color_format gs_texture_get_color_format(
const gs_texture_t *tex);
EXPORT bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr,
uint32_t *linesize);
EXPORT void gs_texture_unmap(gs_texture_t *tex);
/** special-case function (GL only) - specifies whether the texture is a
* GL_TEXTURE_RECTANGLE type, which doesn't use normalized texture
* coordinates, doesn't support mipmapping, and requires address clamping */
EXPORT bool gs_texture_is_rect(gs_texture_t *tex);
EXPORT bool gs_texture_is_rect(const gs_texture_t *tex);
/**
* Gets a pointer to the context-specific object associated with the texture.
* For example, for GL, this is a GLuint*. For D3D11, ID3D11Texture2D*.
@ -651,22 +654,22 @@ EXPORT bool gs_texture_is_rect(gs_texture_t *tex);
EXPORT void *gs_texture_get_obj(gs_texture_t *tex);
EXPORT void gs_cubetexture_destroy(gs_texture_t *cubetex);
EXPORT uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex);
EXPORT uint32_t gs_cubetexture_get_size(const gs_texture_t *cubetex);
EXPORT enum gs_color_format gs_cubetexture_get_color_format(
gs_texture_t *cubetex);
const gs_texture_t *cubetex);
EXPORT void gs_voltexture_destroy(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_width(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_height(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_getdepth(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_width(const gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_height(const gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_getdepth(const gs_texture_t *voltex);
EXPORT enum gs_color_format gs_voltexture_get_color_format(
gs_texture_t *voltex);
const gs_texture_t *voltex);
EXPORT void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_width(const gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_height(const gs_stagesurf_t *stagesurf);
EXPORT enum gs_color_format gs_stagesurface_get_color_format(
gs_stagesurf_t *stagesurf);
const gs_stagesurf_t *stagesurf);
EXPORT bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
uint32_t *linesize);
EXPORT void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf);
@ -677,14 +680,16 @@ EXPORT void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate);
EXPORT void gs_vertexbuffer_destroy(gs_vertbuffer_t *vertbuffer);
EXPORT void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer);
EXPORT struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vertbuffer);
EXPORT struct gs_vb_data *gs_vertexbuffer_get_data(
const gs_vertbuffer_t *vertbuffer);
EXPORT void gs_indexbuffer_destroy(gs_indexbuffer_t *indexbuffer);
EXPORT void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer);
EXPORT void *gs_indexbuffer_get_data(gs_indexbuffer_t *indexbuffer);
EXPORT size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer);
EXPORT void *gs_indexbuffer_get_data(const gs_indexbuffer_t *indexbuffer);
EXPORT size_t gs_indexbuffer_get_num_indices(
const gs_indexbuffer_t *indexbuffer);
EXPORT enum gs_index_type gs_indexbuffer_get_type(
gs_indexbuffer_t *indexbuffer);
const gs_indexbuffer_t *indexbuffer);
#ifdef __APPLE__

2
libobs/graphics/texture-render.c
View File

@ -139,7 +139,7 @@ void gs_texrender_reset(gs_texrender_t *texrender)
texrender->rendered = false;
}
gs_texture_t *gs_texrender_get_texture(gs_texrender_t *texrender)
gs_texture_t *gs_texrender_get_texture(const gs_texrender_t *texrender)
{
return texrender ? texrender->target : NULL;
}

25
libobs/media-io/audio-io.c
View File

@ -113,7 +113,7 @@ static inline void audio_output_removeline(struct audio_output *audio,
* timestamps. this will actually work accurately as long as you handle the
* values correctly */
static inline double ts_to_frames(audio_t *audio, uint64_t ts)
static inline double ts_to_frames(const audio_t *audio, uint64_t ts)
{
double audio_offset_d = (double)ts;
audio_offset_d /= 1000000000.0;
@ -127,19 +127,20 @@ static inline double positive_round(double val)
return floor(val+0.5);
}
static size_t ts_diff_frames(audio_t *audio, uint64_t ts1, uint64_t ts2)
static size_t ts_diff_frames(const audio_t *audio, uint64_t ts1, uint64_t ts2)
{
double diff = ts_to_frames(audio, ts1) - ts_to_frames(audio, ts2);
return (size_t)positive_round(diff);
}
static size_t ts_diff_bytes(audio_t *audio, uint64_t ts1, uint64_t ts2)
static size_t ts_diff_bytes(const audio_t *audio, uint64_t ts1, uint64_t ts2)
{
return ts_diff_frames(audio, ts1, ts2) * audio->block_size;
}
/* unless the value is 3+ hours worth of frames, this won't overflow */
static inline uint64_t conv_frames_to_time(audio_t *audio, uint32_t frames)
static inline uint64_t conv_frames_to_time(const audio_t *audio,
uint32_t frames)
{
return (uint64_t)frames * 1000000000ULL /
(uint64_t)audio->info.samples_per_sec;
@ -370,7 +371,7 @@ static void *audio_thread(void *param)
/* ------------------------------------------------------------------------- */
static size_t audio_get_input_idx(audio_t *video,
static size_t audio_get_input_idx(const audio_t *video,
void (*callback)(void *param, struct audio_data *data),
void *param)
{
@ -474,7 +475,7 @@ void audio_output_disconnect(audio_t *audio,
pthread_mutex_unlock(&audio->input_mutex);
}
static inline bool valid_audio_params(struct audio_output_info *info)
static inline bool valid_audio_params(const struct audio_output_info *info)
{
return info->format && info->name && info->samples_per_sec > 0 &&
info->speakers > 0;
@ -585,7 +586,7 @@ audio_line_t *audio_output_create_line(audio_t *audio, const char *name)
return line;
}
const struct audio_output_info *audio_output_get_info(audio_t *audio)
const struct audio_output_info *audio_output_get_info(const audio_t *audio)
{
return audio ? &audio->info : NULL;
}
@ -600,28 +601,28 @@ void audio_line_destroy(struct audio_line *line)
}
}
bool audio_output_active(audio_t *audio)
bool audio_output_active(const audio_t *audio)
{
if (!audio) return false;
return audio->inputs.num != 0;
}
size_t audio_output_get_block_size(audio_t *audio)
size_t audio_output_get_block_size(const audio_t *audio)
{
return audio ? audio->block_size : 0;
}
size_t audio_output_get_planes(audio_t *audio)
size_t audio_output_get_planes(const audio_t *audio)
{
return audio ? audio->planes : 0;
}
size_t audio_output_get_channels(audio_t *audio)
size_t audio_output_get_channels(const audio_t *audio)
{
return audio ? audio->channels : 0;
}
uint32_t audio_output_get_sample_rate(audio_t *audio)
uint32_t audio_output_get_sample_rate(const audio_t *audio)
{
return audio ? audio->info.samples_per_sec : 0;
}

13
libobs/media-io/audio-io.h
View File

@ -180,13 +180,14 @@ EXPORT void audio_output_disconnect(audio_t *video,
void (*callback)(void *param, struct audio_data *data),
void *param);
EXPORT bool audio_output_active(audio_t *audio);
EXPORT bool audio_output_active(const audio_t *audio);
EXPORT size_t audio_output_get_block_size(audio_t *audio);
EXPORT size_t audio_output_get_planes(audio_t *audio);
EXPORT size_t audio_output_get_channels(audio_t *audio);
EXPORT uint32_t audio_output_get_sample_rate(audio_t *audio);
EXPORT const struct audio_output_info *audio_output_get_info(audio_t *audio);
EXPORT size_t audio_output_get_block_size(const audio_t *audio);
EXPORT size_t audio_output_get_planes(const audio_t *audio);
EXPORT size_t audio_output_get_channels(const audio_t *audio);
EXPORT uint32_t audio_output_get_sample_rate(const audio_t *audio);
EXPORT const struct audio_output_info *audio_output_get_info(
const audio_t *audio);
EXPORT audio_line_t *audio_output_create_line(audio_t *audio, const char *name);
EXPORT void audio_line_destroy(audio_line_t *line);

24
libobs/media-io/video-io.c
View File

@ -175,7 +175,7 @@ static void *video_thread(void *param)
/* ------------------------------------------------------------------------- */
static inline bool valid_video_params(struct video_output_info *info)
static inline bool valid_video_params(const struct video_output_info *info)
{
return info->height != 0 && info->width != 0 && info->fps_den != 0 &&
info->fps_num != 0;
@ -235,7 +235,7 @@ void video_output_close(video_t *video)
bfree(video);
}
static size_t video_get_input_idx(video_t *video,
static size_t video_get_input_idx(const video_t *video,
void (*callback)(void *param, struct video_data *frame),
void *param)
{
@ -344,13 +344,13 @@ void video_output_disconnect(video_t *video,
pthread_mutex_unlock(&video->input_mutex);
}
bool video_output_active(video_t *video)
bool video_output_active(const video_t *video)
{
if (!video) return false;
return video->inputs.num != 0;
}
const struct video_output_info *video_output_get_info(video_t *video)
const struct video_output_info *video_output_get_info(const video_t *video)
{
return video ? &video->info : NULL;
}
@ -373,12 +373,12 @@ bool video_output_wait(video_t *video)
return os_event_try(video->stop_event) == EAGAIN;
}
uint64_t video_output_get_frame_time(video_t *video)
uint64_t video_output_get_frame_time(const video_t *video)
{
return video ? video->frame_time : 0;
}
uint64_t video_output_get_time(video_t *video)
uint64_t video_output_get_time(const video_t *video)
{
return video ? video->cur_video_time : 0;
}
@ -398,22 +398,22 @@ void video_output_stop(video_t *video)
}
}
enum video_format video_output_get_format(video_t *video)
enum video_format video_output_get_format(const video_t *video)
{
return video ? video->info.format : VIDEO_FORMAT_NONE;
}
uint32_t video_output_get_width(video_t *video)
uint32_t video_output_get_width(const video_t *video)
{
return video ? video->info.width : 0;
}
uint32_t video_output_get_height(video_t *video)
uint32_t video_output_get_height(const video_t *video)
{
return video ? video->info.height : 0;
}
double video_output_get_frame_rate(video_t *video)
double video_output_get_frame_rate(const video_t *video)
{
if (!video)
return 0.0;
@ -421,12 +421,12 @@ double video_output_get_frame_rate(video_t *video)
return (double)video->info.fps_num / (double)video->info.fps_den;
}
uint32_t video_output_get_skipped_frames(video_t *video)
uint32_t video_output_get_skipped_frames(const video_t *video)
{
return video->skipped_frames;
}
uint32_t video_output_get_total_frames(video_t *video)
uint32_t video_output_get_total_frames(const video_t *video)
{
return video->total_frames;
}

21
libobs/media-io/video-io.h
View File

@ -130,22 +130,23 @@ EXPORT void video_output_disconnect(video_t *video,
void (*callback)(void *param, struct video_data *frame),
void *param);
EXPORT bool video_output_active(video_t *video);
EXPORT bool video_output_active(const video_t *video);
EXPORT const struct video_output_info *video_output_get_info(video_t *video);
EXPORT const struct video_output_info *video_output_get_info(
const video_t *video);
EXPORT void video_output_swap_frame(video_t *video, struct video_data *frame);
EXPORT bool video_output_wait(video_t *video);
EXPORT uint64_t video_output_get_frame_time(video_t *video);
EXPORT uint64_t video_output_get_time(video_t *video);
EXPORT uint64_t video_output_get_frame_time(const video_t *video);
EXPORT uint64_t video_output_get_time(const video_t *video);
EXPORT void video_output_stop(video_t *video);
EXPORT enum video_format video_output_get_format(video_t *video);
EXPORT uint32_t video_output_get_width(video_t *video);
EXPORT uint32_t video_output_get_height(video_t *video);
EXPORT double video_output_get_frame_rate(video_t *video);
EXPORT enum video_format video_output_get_format(const video_t *video);
EXPORT uint32_t video_output_get_width(const video_t *video);
EXPORT uint32_t video_output_get_height(const video_t *video);
EXPORT double video_output_get_frame_rate(const video_t *video);
EXPORT uint32_t video_output_get_skipped_frames(video_t *video);
EXPORT uint32_t video_output_get_total_frames(video_t *video);
EXPORT uint32_t video_output_get_skipped_frames(const video_t *video);
EXPORT uint32_t video_output_get_total_frames(const video_t *video);
#ifdef __cplusplus

7
libobs/obs-display.c
View File

@ -20,7 +20,7 @@
#include "obs-internal.h"
bool obs_display_init(struct obs_display *display,
struct gs_init_data *graphics_data)
const struct gs_init_data *graphics_data)
{
pthread_mutex_init_value(&display->draw_callbacks_mutex);
@ -44,15 +44,12 @@ bool obs_display_init(struct obs_display *display,
return true;
}
obs_display_t *obs_display_create(struct gs_init_data *graphics_data)
obs_display_t *obs_display_create(const struct gs_init_data *graphics_data)
{
struct obs_display *display = bzalloc(sizeof(struct obs_display));
gs_enter_context(obs->video.graphics);
if (!graphics_data->num_backbuffers)
graphics_data->num_backbuffers = 1;
if (!obs_display_init(display, graphics_data)) {
obs_display_destroy(display);
display = NULL;

34
libobs/obs-encoder.c
View File

@ -101,7 +101,8 @@ static void receive_video(void *param, struct video_data *frame);
static void receive_audio(void *param, struct audio_data *data);
static inline struct audio_convert_info *get_audio_info(
struct obs_encoder *encoder, struct audio_convert_info *info)
const struct obs_encoder *encoder,
struct audio_convert_info *info)
{
const struct audio_output_info *aoi;
aoi = audio_output_get_info(encoder->media);
@ -121,7 +122,8 @@ static inline struct audio_convert_info *get_audio_info(
}
static inline struct video_scale_info *get_video_info(
struct obs_encoder *encoder, struct video_scale_info *info)
const struct obs_encoder *encoder,
struct video_scale_info *info)
{
if (encoder->info.get_video_info)
if (encoder->info.get_video_info(encoder->context.data, info))
@ -130,7 +132,7 @@ static inline struct video_scale_info *get_video_info(
return NULL;
}
static inline bool has_scaling(struct obs_encoder *encoder)
static inline bool has_scaling(const struct obs_encoder *encoder)
{
uint32_t video_width = video_output_get_width(encoder->media);
uint32_t video_height = video_output_get_height(encoder->media);
@ -238,7 +240,7 @@ void obs_encoder_destroy(obs_encoder_t *encoder)
}
}
const char *obs_encoder_get_name(obs_encoder_t *encoder)
const char *obs_encoder_get_name(const obs_encoder_t *encoder)
{
return encoder ? encoder->context.name : NULL;
}
@ -272,7 +274,7 @@ obs_properties_t *obs_get_encoder_properties(const char *id)
return NULL;
}
obs_properties_t *obs_encoder_properties(obs_encoder_t *encoder)
obs_properties_t *obs_encoder_properties(const obs_encoder_t *encoder)
{
if (encoder && encoder->info.get_properties) {
obs_properties_t *props;
@ -294,8 +296,8 @@ void obs_encoder_update(obs_encoder_t *encoder, obs_data_t *settings)
encoder->context.settings);
}
bool obs_encoder_get_extra_data(obs_encoder_t *encoder, uint8_t **extra_data,
size_t *size)
bool obs_encoder_get_extra_data(const obs_encoder_t *encoder,
uint8_t **extra_data, size_t *size)
{
if (encoder && encoder->info.get_extra_data && encoder->context.data)
return encoder->info.get_extra_data(encoder->context.data,
@ -304,7 +306,7 @@ bool obs_encoder_get_extra_data(obs_encoder_t *encoder, uint8_t **extra_data,
return false;
}
obs_data_t *obs_encoder_get_settings(obs_encoder_t *encoder)
obs_data_t *obs_encoder_get_settings(const obs_encoder_t *encoder)
{
if (!encoder) return NULL;
@ -361,7 +363,7 @@ bool obs_encoder_initialize(obs_encoder_t *encoder)
}
static inline size_t get_callback_idx(
struct obs_encoder *encoder,
const struct obs_encoder *encoder,
void (*new_packet)(void *param, struct encoder_packet *packet),
void *param)
{
@ -427,7 +429,7 @@ void obs_encoder_stop(obs_encoder_t *encoder,
}
}
const char *obs_encoder_get_codec(obs_encoder_t *encoder)
const char *obs_encoder_get_codec(const obs_encoder_t *encoder)
{
return encoder ? encoder->info.codec : NULL;
}
@ -449,7 +451,7 @@ void obs_encoder_set_scaled_size(obs_encoder_t *encoder, uint32_t width,
encoder->scaled_height = height;
}
uint32_t obs_encoder_get_width(obs_encoder_t *encoder)
uint32_t obs_encoder_get_width(const obs_encoder_t *encoder)
{
if (!encoder || !encoder->media ||
encoder->info.type != OBS_ENCODER_VIDEO)
@ -460,7 +462,7 @@ uint32_t obs_encoder_get_width(obs_encoder_t *encoder)
video_output_get_width(encoder->media);
}
uint32_t obs_encoder_get_height(obs_encoder_t *encoder)
uint32_t obs_encoder_get_height(const obs_encoder_t *encoder)
{
if (!encoder || !encoder->media ||
encoder->info.type != OBS_ENCODER_VIDEO)
@ -495,24 +497,24 @@ void obs_encoder_set_audio(obs_encoder_t *encoder, audio_t *audio)
encoder->timebase_den = audio_output_get_sample_rate(audio);
}
video_t *obs_encoder_video(obs_encoder_t *encoder)
video_t *obs_encoder_video(const obs_encoder_t *encoder)
{
return (encoder && encoder->info.type == OBS_ENCODER_VIDEO) ?
encoder->media : NULL;
}
audio_t *obs_encoder_audio(obs_encoder_t *encoder)
audio_t *obs_encoder_audio(const obs_encoder_t *encoder)
{
return (encoder && encoder->info.type == OBS_ENCODER_AUDIO) ?
encoder->media : NULL;
}
bool obs_encoder_active(obs_encoder_t *encoder)
bool obs_encoder_active(const obs_encoder_t *encoder)
{
return encoder ? encoder->active : false;
}
static inline bool get_sei(struct obs_encoder *encoder,
static inline bool get_sei(const struct obs_encoder *encoder,
uint8_t **sei, size_t *size)
{
if (encoder->info.get_sei_data)

2
libobs/obs-internal.h
View File

@ -122,7 +122,7 @@ struct obs_display {
};
extern bool obs_display_init(struct obs_display *display,
struct gs_init_data *graphics_data);
const struct gs_init_data *graphics_data);
extern void obs_display_free(struct obs_display *display);

47
libobs/obs-output.c
View File

@ -147,7 +147,7 @@ void obs_output_destroy(obs_output_t *output)
}
}
const char *obs_output_get_name(obs_output_t *output)
const char *obs_output_get_name(const obs_output_t *output)
{
return output ? output->context.name : NULL;
}
@ -207,7 +207,7 @@ void obs_output_stop(obs_output_t *output)
}
}
bool obs_output_active(obs_output_t *output)
bool obs_output_active(const obs_output_t *output)
{
return (output != NULL) ?
(output->active || output->reconnecting) : false;
@ -242,7 +242,7 @@ obs_properties_t *obs_get_output_properties(const char *id)
return NULL;
}
obs_properties_t *obs_output_properties(obs_output_t *output)
obs_properties_t *obs_output_properties(const obs_output_t *output)
{
if (output && output->info.get_properties) {
obs_properties_t *props;
@ -265,7 +265,7 @@ void obs_output_update(obs_output_t *output, obs_data_t *settings)
output->context.settings);
}
obs_data_t *obs_output_get_settings(obs_output_t *output)
obs_data_t *obs_output_get_settings(const obs_output_t *output)
{
if (!output)
return NULL;
@ -274,7 +274,7 @@ obs_data_t *obs_output_get_settings(obs_output_t *output)
return output->context.settings;
}
bool obs_output_canpause(obs_output_t *output)
bool obs_output_canpause(const obs_output_t *output)
{
return output ? (output->info.pause != NULL) : false;
}
@ -285,12 +285,12 @@ void obs_output_pause(obs_output_t *output)
output->info.pause(output->context.data);
}
signal_handler_t *obs_output_get_signal_handler(obs_output_t *output)
signal_handler_t *obs_output_get_signal_handler(const obs_output_t *output)
{
return output ? output->context.signals : NULL;
}
proc_handler_t *obs_output_get_proc_handler(obs_output_t *output)
proc_handler_t *obs_output_get_proc_handler(const obs_output_t *output)
{
return output ? output->context.procs : NULL;
}
@ -304,12 +304,12 @@ void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
output->audio = audio;
}
video_t *obs_output_video(obs_output_t *output)
video_t *obs_output_video(const obs_output_t *output)
{
return output ? output->video : NULL;
}
audio_t *obs_output_audio(obs_output_t *output)
audio_t *obs_output_audio(const obs_output_t *output)
{
return output ? output->audio : NULL;
}
@ -352,12 +352,12 @@ void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder)
output->audio_encoder = encoder;
}
obs_encoder_t *obs_output_get_video_encoder(obs_output_t *output)
obs_encoder_t *obs_output_get_video_encoder(const obs_output_t *output)
{
return output ? output->video_encoder : NULL;
}
obs_encoder_t *obs_output_get_audio_encoder(obs_output_t *output)
obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output)
{
return output ? output->audio_encoder : NULL;
}
@ -373,7 +373,7 @@ void obs_output_set_service(obs_output_t *output, obs_service_t *service)
service->output = output;
}
obs_service_t *obs_output_get_service(obs_output_t *output)
obs_service_t *obs_output_get_service(const obs_output_t *output)
{
return output ? output->service : NULL;
}
@ -387,7 +387,7 @@ void obs_output_set_reconnect_settings(obs_output_t *output,
output->reconnect_retry_sec = retry_sec;
}
uint64_t obs_output_get_total_bytes(obs_output_t *output)
uint64_t obs_output_get_total_bytes(const obs_output_t *output)
{
if (!output || !output->info.get_total_bytes)
return 0;
@ -395,7 +395,7 @@ uint64_t obs_output_get_total_bytes(obs_output_t *output)
return output->info.get_total_bytes(output->context.data);
}
int obs_output_get_frames_dropped(obs_output_t *output)
int obs_output_get_frames_dropped(const obs_output_t *output)
{
if (!output || !output->info.get_dropped_frames)
return 0;
@ -403,7 +403,7 @@ int obs_output_get_frames_dropped(obs_output_t *output)
return output->info.get_dropped_frames(output->context.data);
}
int obs_output_get_total_frames(obs_output_t *output)
int obs_output_get_total_frames(const obs_output_t *output)
{
return output ? output->total_frames : 0;
}
@ -431,7 +431,7 @@ void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
}
}
uint32_t obs_output_get_width(obs_output_t *output)
uint32_t obs_output_get_width(const obs_output_t *output)
{
if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
return 0;
@ -444,7 +444,7 @@ uint32_t obs_output_get_width(obs_output_t *output)
video_output_get_width(output->video);
}
uint32_t obs_output_get_height(obs_output_t *output)
uint32_t obs_output_get_height(const obs_output_t *output)
{
if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
return 0;
@ -475,8 +475,8 @@ void obs_output_set_audio_conversion(obs_output_t *output,
output->audio_conversion_set = true;
}
static bool can_begin_data_capture(struct obs_output *output, bool encoded,
bool has_video, bool has_audio, bool has_service)
static bool can_begin_data_capture(const struct obs_output *output,
bool encoded, bool has_video, bool has_audio, bool has_service)
{
if (has_video) {
if (encoded) {
@ -504,7 +504,7 @@ static bool can_begin_data_capture(struct obs_output *output, bool encoded,
return true;
}
static inline bool has_scaling(struct obs_output *output)
static inline bool has_scaling(const struct obs_output *output)
{
uint32_t video_width = video_output_get_width(output->video);
uint32_t video_height = video_output_get_height(output->video);
@ -745,8 +745,8 @@ static inline void signal_stop(struct obs_output *output, int code)
calldata_free(&params);
}
static inline void convert_flags(struct obs_output *output, uint32_t flags,
bool *encoded, bool *has_video, bool *has_audio,
static inline void convert_flags(const struct obs_output *output,
uint32_t flags, bool *encoded, bool *has_video, bool *has_audio,
bool *has_service)
{
*encoded = (output->info.flags & OBS_OUTPUT_ENCODED) != 0;
@ -760,7 +760,8 @@ static inline void convert_flags(struct obs_output *output, uint32_t flags,
*has_service = (flags & OBS_OUTPUT_SERVICE) != 0;
}
bool obs_output_can_begin_data_capture(obs_output_t *output, uint32_t flags)
bool obs_output_can_begin_data_capture(const obs_output_t *output,
uint32_t flags)
{
bool encoded, has_video, has_audio, has_service;

30
libobs/obs-scene.c
View File

@ -473,12 +473,12 @@ void obs_scene_release(obs_scene_t *scene)
obs_source_release(scene->source);
}
obs_source_t *obs_scene_get_source(obs_scene_t *scene)
obs_source_t *obs_scene_get_source(const obs_scene_t *scene)
{
return scene ? scene->source : NULL;
}
obs_scene_t *obs_scene_from_source(obs_source_t *source)
obs_scene_t *obs_scene_from_source(const obs_source_t *source)
{
if (!source || source->info.id != scene_info.id)
return NULL;
@ -645,12 +645,12 @@ void obs_sceneitem_remove(obs_sceneitem_t *item)
obs_sceneitem_release(item);
}
obs_scene_t *obs_sceneitem_get_scene(obs_sceneitem_t *item)
obs_scene_t *obs_sceneitem_get_scene(const obs_sceneitem_t *item)
{
return item ? item->parent : NULL;
}
obs_source_t *obs_sceneitem_get_source(obs_sceneitem_t *item)
obs_source_t *obs_sceneitem_get_source(const obs_sceneitem_t *item)
{
return item ? item->source : NULL;
}
@ -673,7 +673,7 @@ void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
calldata_free(&params);
}
bool obs_sceneitem_selected(obs_sceneitem_t *item)
bool obs_sceneitem_selected(const obs_sceneitem_t *item)
{
return item ? item->selected : false;
}
@ -801,45 +801,45 @@ void obs_sceneitem_set_bounds(obs_sceneitem_t *item, const struct vec2 *bounds)
}
}
void obs_sceneitem_get_pos(obs_sceneitem_t *item, struct vec2 *pos)
void obs_sceneitem_get_pos(const obs_sceneitem_t *item, struct vec2 *pos)
{
if (item)
vec2_copy(pos, &item->pos);
}
float obs_sceneitem_get_rot(obs_sceneitem_t *item)
float obs_sceneitem_get_rot(const obs_sceneitem_t *item)
{
return item ? item->rot : 0.0f;
}
void obs_sceneitem_get_scale(obs_sceneitem_t *item, struct vec2 *scale)
void obs_sceneitem_get_scale(const obs_sceneitem_t *item, struct vec2 *scale)
{
if (item)
vec2_copy(scale, &item->scale);
}
uint32_t obs_sceneitem_get_alignment(obs_sceneitem_t *item)
uint32_t obs_sceneitem_get_alignment(const obs_sceneitem_t *item)
{
return item ? item->align : 0;
}
enum obs_bounds_type obs_sceneitem_get_bounds_type(obs_sceneitem_t *item)
enum obs_bounds_type obs_sceneitem_get_bounds_type(const obs_sceneitem_t *item)
{
return item ? item->bounds_type : OBS_BOUNDS_NONE;
}
uint32_t obs_sceneitem_get_bounds_alignment(obs_sceneitem_t *item)
uint32_t obs_sceneitem_get_bounds_alignment(const obs_sceneitem_t *item)
{
return item ? item->bounds_align : 0;
}
void obs_sceneitem_get_bounds(obs_sceneitem_t *item, struct vec2 *bounds)
void obs_sceneitem_get_bounds(const obs_sceneitem_t *item, struct vec2 *bounds)
{
if (item)
*bounds = item->bounds;
}
void obs_sceneitem_get_info(obs_sceneitem_t *item,
void obs_sceneitem_get_info(const obs_sceneitem_t *item,
struct obs_transform_info *info)
{
if (item && info) {
@ -868,14 +868,14 @@ void obs_sceneitem_set_info(obs_sceneitem_t *item,
}
}
void obs_sceneitem_get_draw_transform(obs_sceneitem_t *item,
void obs_sceneitem_get_draw_transform(const obs_sceneitem_t *item,
struct matrix4 *transform)
{
if (item)
matrix4_copy(transform, &item->draw_transform);
}
void obs_sceneitem_get_box_transform(obs_sceneitem_t *item,
void obs_sceneitem_get_box_transform(const obs_sceneitem_t *item,
struct matrix4 *transform)
{
if (item)

20
libobs/obs-service.c
View File

@ -96,7 +96,7 @@ void obs_service_destroy(obs_service_t *service)
}
}
const char *obs_service_get_name(obs_service_t *service)
const char *obs_service_get_name(const obs_service_t *service)
{
return service ? service->context.name : NULL;
}
@ -130,7 +130,7 @@ obs_properties_t *obs_get_service_properties(const char *id)
return NULL;
}
obs_properties_t *obs_service_properties(obs_service_t *service)
obs_properties_t *obs_service_properties(const obs_service_t *service)
{
if (service && service->info.get_properties) {
obs_properties_t *props;
@ -142,7 +142,7 @@ obs_properties_t *obs_service_properties(obs_service_t *service)
return NULL;
}
const char *obs_service_gettype(obs_service_t *service)
const char *obs_service_gettype(const obs_service_t *service)
{
return service ? service->info.id : NULL;
}
@ -158,7 +158,7 @@ void obs_service_update(obs_service_t *service, obs_data_t *settings)
service->context.settings);
}
obs_data_t *obs_service_get_settings(obs_service_t *service)
obs_data_t *obs_service_get_settings(const obs_service_t *service)
{
if (!service)
return NULL;
@ -167,35 +167,35 @@ obs_data_t *obs_service_get_settings(obs_service_t *service)
return service->context.settings;
}
signal_handler_t *obs_service_get_signal_handler(obs_service_t *service)
signal_handler_t *obs_service_get_signal_handler(const obs_service_t *service)
{
return service ? service->context.signals : NULL;
}
proc_handler_t *obs_service_get_proc_handler(obs_service_t *service)
proc_handler_t *obs_service_get_proc_handler(const obs_service_t *service)
{
return service ? service->context.procs : NULL;
}
const char *obs_service_get_url(obs_service_t *service)
const char *obs_service_get_url(const obs_service_t *service)
{
if (!service || !service->info.get_url) return NULL;
return service->info.get_url(service->context.data);
}
const char *obs_service_get_key(obs_service_t *service)
const char *obs_service_get_key(const obs_service_t *service)
{
if (!service || !service->info.get_key) return NULL;
return service->info.get_key(service->context.data);
}
const char *obs_service_get_username(obs_service_t *service)
const char *obs_service_get_username(const obs_service_t *service)
{
if (!service || !service->info.get_username) return NULL;
return service->info.get_username(service->context.data);
}
const char *obs_service_get_password(obs_service_t *service)
const char *obs_service_get_password(const obs_service_t *service)
{
if (!service || !service->info.get_password) return NULL;
return service->info.get_password(service->context.data);

36
libobs/obs-source.c
View File

@ -29,7 +29,7 @@
#include "obs.h"
#include "obs-internal.h"
static inline bool source_valid(struct obs_source *source)
static inline bool source_valid(const struct obs_source *source)
{
return source && source->context.data;
}
@ -313,7 +313,7 @@ void obs_source_remove(obs_source_t *source)
obs_source_release(source);
}
bool obs_source_removed(obs_source_t *source)
bool obs_source_removed(const obs_source_t *source)
{
return source ? source->removed : true;
}
@ -348,7 +348,7 @@ obs_properties_t *obs_get_source_properties(enum obs_source_type type,
return NULL;
}
obs_properties_t *obs_source_properties(obs_source_t *source)
obs_properties_t *obs_source_properties(const obs_source_t *source)
{
if (source_valid(source) && source->info.get_properties) {
obs_properties_t *props;
@ -360,7 +360,7 @@ obs_properties_t *obs_source_properties(obs_source_t *source)
return NULL;
}
uint32_t obs_source_get_output_flags(obs_source_t *source)
uint32_t obs_source_get_output_flags(const obs_source_t *source)
{
return source ? source->info.output_flags : 0;
}
@ -1180,7 +1180,7 @@ void obs_source_video_render(obs_source_t *source)
obs_source_render_async_video(source);
}
uint32_t obs_source_get_width(obs_source_t *source)
uint32_t obs_source_get_width(const obs_source_t *source)
{
if (!source_valid(source)) return 0;
@ -1189,7 +1189,7 @@ uint32_t obs_source_get_width(obs_source_t *source)
return source->async_width;
}
uint32_t obs_source_get_height(obs_source_t *source)
uint32_t obs_source_get_height(const obs_source_t *source)
{
if (!source_valid(source)) return 0;
@ -1198,12 +1198,12 @@ uint32_t obs_source_get_height(obs_source_t *source)
return source->async_height;
}
obs_source_t *obs_filter_get_parent(obs_source_t *filter)
obs_source_t *obs_filter_get_parent(const obs_source_t *filter)
{
return filter ? filter->filter_parent : NULL;
}
obs_source_t *obs_filter_get_target(obs_source_t *filter)
obs_source_t *obs_filter_get_target(const obs_source_t *filter)
{
return filter ? filter->filter_target : NULL;
}
@ -1301,7 +1301,7 @@ void obs_source_filter_set_order(obs_source_t *source, obs_source_t *filter,
}
}
obs_data_t *obs_source_get_settings(obs_source_t *source)
obs_data_t *obs_source_get_settings(const obs_source_t *source)
{
if (!source) return NULL;
@ -1570,7 +1570,7 @@ void obs_source_output_audio(obs_source_t *source,
pthread_mutex_unlock(&source->filter_mutex);
}
static inline bool frame_out_of_bounds(obs_source_t *source, uint64_t ts)
static inline bool frame_out_of_bounds(const obs_source_t *source, uint64_t ts)
{
if (ts < source->last_frame_ts)
return ((source->last_frame_ts - ts) > MAX_TIMESTAMP_JUMP);
@ -1726,7 +1726,7 @@ void obs_source_release_frame(obs_source_t *source,
}
}
const char *obs_source_get_name(obs_source_t *source)
const char *obs_source_get_name(const obs_source_t *source)
{
return source ? source->context.name : NULL;
}
@ -1751,12 +1751,12 @@ void obs_source_set_name(obs_source_t *source, const char *name)
}
}
enum obs_source_type obs_source_get_type(obs_source_t *source)
enum obs_source_type obs_source_get_type(const obs_source_t *source)
{
return source ? source->info.type : OBS_SOURCE_TYPE_INPUT;
}
const char *obs_source_get_id(obs_source_t *source)
const char *obs_source_get_id(const obs_source_t *source)
{
return source ? source->info.id : NULL;
}
@ -1845,12 +1845,12 @@ void obs_source_process_filter(obs_source_t *filter, gs_effect_t *effect,
effect, width, height, use_matrix);
}
signal_handler_t *obs_source_get_signal_handler(obs_source_t *source)
signal_handler_t *obs_source_get_signal_handler(const obs_source_t *source)
{
return source ? source->context.signals : NULL;
}
proc_handler_t *obs_source_get_proc_handler(obs_source_t *source)
proc_handler_t *obs_source_get_proc_handler(const obs_source_t *source)
{
return source ? source->context.procs : NULL;
}
@ -1895,12 +1895,12 @@ void obs_source_set_present_volume(obs_source_t *source, float volume)
}
}
float obs_source_get_volume(obs_source_t *source)
float obs_source_get_volume(const obs_source_t *source)
{
return source ? source->user_volume : 0.0f;
}
float obs_source_get_present_volume(obs_source_t *source)
float obs_source_get_present_volume(const obs_source_t *source)
{
return source ? source->present_volume : 0.0f;
}
@ -1911,7 +1911,7 @@ void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
source->sync_offset = offset;
}
int64_t obs_source_get_sync_offset(obs_source_t *source)
int64_t obs_source_get_sync_offset(const obs_source_t *source)
{
return source ? source->sync_offset : 0;
}

2
libobs/obs.c
View File

@ -28,7 +28,7 @@ extern void add_default_module_paths(void);
extern char *find_libobs_data_file(const char *file);
static inline void make_gs_init_data(struct gs_init_data *gid,
struct obs_video_info *ovi)
const struct obs_video_info *ovi)
{
memcpy(&gid->window, &ovi->window, sizeof(struct gs_window));
gid->cx = ovi->window_width;

143
libobs/obs.h
View File

@ -545,7 +545,8 @@ EXPORT void obs_view_render(obs_view_t *view);
* @param graphics_data The swap chain initialization data.
* @return The new display context, or NULL if failed.
*/
EXPORT obs_display_t *obs_display_create(struct gs_init_data *graphics_data);
EXPORT obs_display_t *obs_display_create(
const struct gs_init_data *graphics_data);
/** Destroys a display context */
EXPORT void obs_display_destroy(obs_display_t *display);
@ -599,12 +600,12 @@ EXPORT void obs_source_release(obs_source_t *source);
EXPORT void obs_source_remove(obs_source_t *source);
/** Returns true if the source should be released */
EXPORT bool obs_source_removed(obs_source_t *source);
EXPORT bool obs_source_removed(const obs_source_t *source);
/**
* Retrieves flags that specify what type of data the source presents/modifies.
*/
EXPORT uint32_t obs_source_get_output_flags(obs_source_t *source);
EXPORT uint32_t obs_source_get_output_flags(const obs_source_t *source);
/** Gets the default settings for a source type */
EXPORT obs_data_t *obs_get_source_defaults(enum obs_source_type type,
@ -618,7 +619,7 @@ EXPORT obs_properties_t *obs_get_source_properties(enum obs_source_type type,
* Returns the properties list for a specific existing source. Free with
* obs_properties_destroy
*/
EXPORT obs_properties_t *obs_source_properties(obs_source_t *source);
EXPORT obs_properties_t *obs_source_properties(const obs_source_t *source);
/** Updates settings for this source */
EXPORT void obs_source_update(obs_source_t *source, obs_data_t *settings);
@ -627,16 +628,16 @@ EXPORT void obs_source_update(obs_source_t *source, obs_data_t *settings);
EXPORT void obs_source_video_render(obs_source_t *source);
/** Gets the width of a source (if it has video) */
EXPORT uint32_t obs_source_get_width(obs_source_t *source);
EXPORT uint32_t obs_source_get_width(const obs_source_t *source);
/** Gets the height of a source (if it has video) */
EXPORT uint32_t obs_source_get_height(obs_source_t *source);
EXPORT uint32_t obs_source_get_height(const obs_source_t *source);
/** If the source is a filter, returns the parent source of the filter */
EXPORT obs_source_t *obs_filter_get_parent(obs_source_t *filter);
EXPORT obs_source_t *obs_filter_get_parent(const obs_source_t *filter);
/** If the source is a filter, returns the target source of the filter */
EXPORT obs_source_t *obs_filter_get_target(obs_source_t *filter);
EXPORT obs_source_t *obs_filter_get_target(const obs_source_t *filter);
/** Adds a filter to the source (which is used whenever the source is used) */
EXPORT void obs_source_filter_add(obs_source_t *source, obs_source_t *filter);
@ -650,25 +651,26 @@ EXPORT void obs_source_filter_set_order(obs_source_t *source,
obs_source_t *filter, enum obs_order_movement movement);
/** Gets the settings string for a source */
EXPORT obs_data_t *obs_source_get_settings(obs_source_t *source);
EXPORT obs_data_t *obs_source_get_settings(const obs_source_t *source);
/** Gets the name of a source */
EXPORT const char *obs_source_get_name(obs_source_t *source);
EXPORT const char *obs_source_get_name(const obs_source_t *source);
/** Sets the name of a source */
EXPORT void obs_source_set_name(obs_source_t *source, const char *name);
/** Gets the source type */
EXPORT enum obs_source_type obs_source_get_type(obs_source_t *source);
EXPORT enum obs_source_type obs_source_get_type(const obs_source_t *source);
/** Gets the source identifier */
EXPORT const char *obs_source_get_id(obs_source_t *source);
EXPORT const char *obs_source_get_id(const obs_source_t *source);
/** Returns the signal handler for a source */
EXPORT signal_handler_t *obs_source_get_signal_handler(obs_source_t *source);
EXPORT signal_handler_t *obs_source_get_signal_handler(
const obs_source_t *source);
/** Returns the procedure handler for a source */
EXPORT proc_handler_t *obs_source_get_proc_handler(obs_source_t *source);
EXPORT proc_handler_t *obs_source_get_proc_handler(const obs_source_t *source);
/** Sets the user volume for a source that has audio output */
EXPORT void obs_source_set_volume(obs_source_t *source, float volume);
@ -677,16 +679,16 @@ EXPORT void obs_source_set_volume(obs_source_t *source, float volume);
EXPORT void obs_source_set_present_volume(obs_source_t *source, float volume);
/** Gets the user volume for a source that has audio output */
EXPORT float obs_source_get_volume(obs_source_t *source);
EXPORT float obs_source_get_volume(const obs_source_t *source);
/** Gets the presentation volume for a source */
EXPORT float obs_source_get_present_volume(obs_source_t *source);
EXPORT float obs_source_get_present_volume(const obs_source_t *source);
/** Sets the audio sync offset (in nanoseconds) for a source */
EXPORT void obs_source_set_sync_offset(obs_source_t *source, int64_t offset);
/** Gets the audio sync offset (in nanoseconds) for a source */
EXPORT int64_t obs_source_get_sync_offset(obs_source_t *source);
EXPORT int64_t obs_source_get_sync_offset(const obs_source_t *source);
/** Enumerates child sources used by this source */
EXPORT void obs_source_enum_sources(obs_source_t *source,
@ -699,7 +701,7 @@ EXPORT void obs_source_enum_tree(obs_source_t *source,
void *param);
/** Returns true if active, false if not */
EXPORT bool obs_source_active(obs_source_t *source);
EXPORT bool obs_source_active(const obs_source_t *source);
/**
* Sometimes sources need to be told when to save their settings so they
@ -803,10 +805,10 @@ EXPORT void obs_scene_addref(obs_scene_t *scene);
EXPORT void obs_scene_release(obs_scene_t *scene);
/** Gets the scene's source context */
EXPORT obs_source_t *obs_scene_get_source(obs_scene_t *scene);
EXPORT obs_source_t *obs_scene_get_source(const obs_scene_t *scene);
/** Gets the scene from its source, or NULL if not a scene */
EXPORT obs_scene_t *obs_scene_from_source(obs_source_t *source);
EXPORT obs_scene_t *obs_scene_from_source(const obs_source_t *source);
/** Determines whether a source is within a scene */
EXPORT obs_sceneitem_t *obs_scene_find_source(obs_scene_t *scene,
@ -827,13 +829,13 @@ EXPORT void obs_sceneitem_release(obs_sceneitem_t *item);
EXPORT void obs_sceneitem_remove(obs_sceneitem_t *item);
/** Gets the scene parent associated with the scene item. */
EXPORT obs_scene_t *obs_sceneitem_get_scene(obs_sceneitem_t *item);
EXPORT obs_scene_t *obs_sceneitem_get_scene(const obs_sceneitem_t *item);
/** Gets the source of a scene item. */
EXPORT obs_source_t *obs_sceneitem_get_source(obs_sceneitem_t *item);
EXPORT obs_source_t *obs_sceneitem_get_source(const obs_sceneitem_t *item);
EXPORT void obs_sceneitem_select(obs_sceneitem_t *item, bool select);
EXPORT bool obs_sceneitem_selected(obs_sceneitem_t *item);
EXPORT bool obs_sceneitem_selected(const obs_sceneitem_t *item);
/* Functions for gettings/setting specific orientation of a scene item */
EXPORT void obs_sceneitem_set_pos(obs_sceneitem_t *item, const struct vec2 *pos);
@ -852,25 +854,27 @@ EXPORT void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t *item,
EXPORT void obs_sceneitem_set_bounds(obs_sceneitem_t *item,
const struct vec2 *bounds);
EXPORT void obs_sceneitem_get_pos(obs_sceneitem_t *item, struct vec2 *pos);
EXPORT float obs_sceneitem_get_rot(obs_sceneitem_t *item);
EXPORT void obs_sceneitem_get_scale(obs_sceneitem_t *item, struct vec2 *scale);
EXPORT uint32_t obs_sceneitem_get_alignment(obs_sceneitem_t *item);
EXPORT void obs_sceneitem_get_pos(const obs_sceneitem_t *item,
struct vec2 *pos);
EXPORT float obs_sceneitem_get_rot(const obs_sceneitem_t *item);
EXPORT void obs_sceneitem_get_scale(const obs_sceneitem_t *item,
struct vec2 *scale);
EXPORT uint32_t obs_sceneitem_get_alignment(const obs_sceneitem_t *item);
EXPORT enum obs_bounds_type obs_sceneitem_get_bounds_type(
obs_sceneitem_t *item);
EXPORT uint32_t obs_sceneitem_get_bounds_alignment(obs_sceneitem_t *item);
EXPORT void obs_sceneitem_get_bounds(obs_sceneitem_t *item,
const obs_sceneitem_t *item);
EXPORT uint32_t obs_sceneitem_get_bounds_alignment(const obs_sceneitem_t *item);
EXPORT void obs_sceneitem_get_bounds(const obs_sceneitem_t *item,
struct vec2 *bounds);
EXPORT void obs_sceneitem_get_info(obs_sceneitem_t *item,
EXPORT void obs_sceneitem_get_info(const obs_sceneitem_t *item,
struct obs_transform_info *info);
EXPORT void obs_sceneitem_set_info(obs_sceneitem_t *item,
const struct obs_transform_info *info);
EXPORT void obs_sceneitem_get_draw_transform(obs_sceneitem_t *item,
EXPORT void obs_sceneitem_get_draw_transform(const obs_sceneitem_t *item,
struct matrix4 *transform);
EXPORT void obs_sceneitem_get_box_transform(obs_sceneitem_t *item,
EXPORT void obs_sceneitem_get_box_transform(const obs_sceneitem_t *item,
struct matrix4 *transform);
@ -889,7 +893,7 @@ EXPORT obs_output_t *obs_output_create(const char *id, const char *name,
obs_data_t *settings);
EXPORT void obs_output_destroy(obs_output_t *output);
EXPORT const char *obs_output_get_name(obs_output_t *output);
EXPORT const char *obs_output_get_name(const obs_output_t *output);
/** Starts the output. */
EXPORT bool obs_output_start(obs_output_t *output);
@ -898,7 +902,7 @@ EXPORT bool obs_output_start(obs_output_t *output);
EXPORT void obs_output_stop(obs_output_t *output);
/** Returns whether the output is active */
EXPORT bool obs_output_active(obs_output_t *output);
EXPORT bool obs_output_active(const obs_output_t *output);
/** Gets the default settings for an output type */
EXPORT obs_data_t *obs_output_defaults(const char *id);
@ -910,25 +914,26 @@ EXPORT obs_properties_t *obs_get_output_properties(const char *id);
* Returns the property list of an existing output, if any. Free with
* obs_properties_destroy
*/
EXPORT obs_properties_t *obs_output_properties(obs_output_t *output);
EXPORT obs_properties_t *obs_output_properties(const obs_output_t *output);
/** Updates the settings for this output context */
EXPORT void obs_output_update(obs_output_t *output, obs_data_t *settings);
/** Specifies whether the output can be paused */
EXPORT bool obs_output_canpause(obs_output_t *output);
EXPORT bool obs_output_canpause(const obs_output_t *output);
/** Pauses the output (if the functionality is allowed by the output */
EXPORT void obs_output_pause(obs_output_t *output);
/* Gets the current output settings string */
EXPORT obs_data_t *obs_output_get_settings(obs_output_t *output);
EXPORT obs_data_t *obs_output_get_settings(const obs_output_t *output);
/** Returns the signal handler for an output */
EXPORT signal_handler_t *obs_output_get_signal_handler(obs_output_t *output);
EXPORT signal_handler_t *obs_output_get_signal_handler(
const obs_output_t *output);
/** Returns the procedure handler for an output */
EXPORT proc_handler_t *obs_output_get_proc_handler(obs_output_t *output);
EXPORT proc_handler_t *obs_output_get_proc_handler(const obs_output_t *output);
/**
* Sets the current video media context associated with this output,
@ -944,10 +949,10 @@ EXPORT void obs_output_set_media(obs_output_t *output,
video_t *video, audio_t *audio);
/** Returns the video media context associated with this output */
EXPORT video_t *obs_output_video(obs_output_t *output);
EXPORT video_t *obs_output_video(const obs_output_t *output);
/** Returns the audio media context associated with this output */
EXPORT audio_t *obs_output_audio(obs_output_t *output);
EXPORT audio_t *obs_output_audio(const obs_output_t *output);
/**
* Sets the current video encoder associated with this output,
@ -964,17 +969,17 @@ EXPORT void obs_output_set_audio_encoder(obs_output_t *output,
obs_encoder_t *encoder);
/** Returns the current video encoder associated with this output */
EXPORT obs_encoder_t *obs_output_get_video_encoder(obs_output_t *output);
EXPORT obs_encoder_t *obs_output_get_video_encoder(const obs_output_t *output);
/** Returns the current audio encoder associated with this output */
EXPORT obs_encoder_t *obs_output_get_audio_encoder(obs_output_t *output);
EXPORT obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output);
/** Sets the current service associated with this output. */
EXPORT void obs_output_set_service(obs_output_t *output,
obs_service_t *service);
/** Gets the current service associated with this output. */
EXPORT obs_service_t *obs_output_get_service(obs_output_t *output);
EXPORT obs_service_t *obs_output_get_service(const obs_output_t *output);
/**
* Sets the reconnect settings. Set retry_count to 0 to disable reconnecting.
@ -982,9 +987,9 @@ EXPORT obs_service_t *obs_output_get_service(obs_output_t *output);
EXPORT void obs_output_set_reconnect_settings(obs_output_t *output,
int retry_count, int retry_sec);
EXPORT uint64_t obs_output_get_total_bytes(obs_output_t *output);
EXPORT int obs_output_get_frames_dropped(obs_output_t *output);
EXPORT int obs_output_get_total_frames(obs_output_t *output);
EXPORT uint64_t obs_output_get_total_bytes(const obs_output_t *output);
EXPORT int obs_output_get_frames_dropped(const obs_output_t *output);
EXPORT int obs_output_get_total_frames(const obs_output_t *output);
/**
* Sets the preferred scaled resolution for this output. Set width and height
@ -998,10 +1003,10 @@ EXPORT void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
uint32_t height);
/** For video outputs, returns the width of the encoded image */
EXPORT uint32_t obs_output_get_width(obs_output_t *output);
EXPORT uint32_t obs_output_get_width(const obs_output_t *output);
/** For video outputs, returns the height of the encoded image */
EXPORT uint32_t obs_output_get_height(obs_output_t *output);
EXPORT uint32_t obs_output_get_height(const obs_output_t *output);
/* ------------------------------------------------------------------------- */
/* Functions used by outputs */
@ -1015,7 +1020,7 @@ EXPORT void obs_output_set_audio_conversion(obs_output_t *output,
const struct audio_convert_info *conversion);
/** Returns whether data capture can begin with the specified flags */
EXPORT bool obs_output_can_begin_data_capture(obs_output_t *output,
EXPORT bool obs_output_can_begin_data_capture(const obs_output_t *output,
uint32_t flags);
/** Initializes encoders (if any) */
@ -1078,10 +1083,10 @@ EXPORT obs_encoder_t *obs_audio_encoder_create(const char *id, const char *name,
/** Destroys an encoder context */
EXPORT void obs_encoder_destroy(obs_encoder_t *encoder);
EXPORT const char *obs_encoder_get_name(obs_encoder_t *encoder);
EXPORT const char *obs_encoder_get_name(const obs_encoder_t *encoder);
/** Returns the codec of the encoder */
EXPORT const char *obs_encoder_get_codec(obs_encoder_t *encoder);
EXPORT const char *obs_encoder_get_codec(const obs_encoder_t *encoder);
/**
* Sets the scaled resolution for a video encoder. Set width and height to 0
@ -1092,10 +1097,10 @@ EXPORT void obs_encoder_set_scaled_size(obs_encoder_t *encoder, uint32_t width,
uint32_t height);
/** For video encoders, returns the width of the encoded image */
EXPORT uint32_t obs_encoder_get_width(obs_encoder_t *encoder);
EXPORT uint32_t obs_encoder_get_width(const obs_encoder_t *encoder);
/** For video encoders, returns the height of the encoded image */
EXPORT uint32_t obs_encoder_get_height(obs_encoder_t *encoder);
EXPORT uint32_t obs_encoder_get_height(const obs_encoder_t *encoder);
/** Gets the default settings for an encoder type */
EXPORT obs_data_t *obs_encoder_defaults(const char *id);
@ -1107,7 +1112,7 @@ EXPORT obs_properties_t *obs_get_encoder_properties(const char *id);
* Returns the property list of an existing encoder, if any. Free with
* obs_properties_destroy
*/
EXPORT obs_properties_t *obs_encoder_properties(obs_encoder_t *encoder);
EXPORT obs_properties_t *obs_encoder_properties(const obs_encoder_t *encoder);
/**
* Updates the settings of the encoder context. Usually used for changing
@ -1116,11 +1121,11 @@ EXPORT obs_properties_t *obs_encoder_properties(obs_encoder_t *encoder);
EXPORT void obs_encoder_update(obs_encoder_t *encoder, obs_data_t *settings);
/** Gets extra data (headers) associated with this context */
EXPORT bool obs_encoder_get_extra_data(obs_encoder_t *encoder,
EXPORT bool obs_encoder_get_extra_data(const obs_encoder_t *encoder,
uint8_t **extra_data, size_t *size);
/** Returns the current settings for this encoder */
EXPORT obs_data_t *obs_encoder_get_settings(obs_encoder_t *encoder);
EXPORT obs_data_t *obs_encoder_get_settings(const obs_encoder_t *encoder);
/** Sets the video output context to be used with this encoder */
EXPORT void obs_encoder_set_video(obs_encoder_t *encoder, video_t *video);
@ -1132,16 +1137,16 @@ EXPORT void obs_encoder_set_audio(obs_encoder_t *encoder, audio_t *audio);
* Returns the video output context used with this encoder, or NULL if not
* a video context
*/
EXPORT video_t *obs_encoder_video(obs_encoder_t *encoder);
EXPORT video_t *obs_encoder_video(const obs_encoder_t *encoder);
/**
* Returns the audio output context used with this encoder, or NULL if not
* a audio context
*/
EXPORT audio_t *obs_encoder_audio(obs_encoder_t *encoder);
EXPORT audio_t *obs_encoder_audio(const obs_encoder_t *encoder);
/** Returns true if encoder is active, false otherwise */
EXPORT bool obs_encoder_active(obs_encoder_t *encoder);
EXPORT bool obs_encoder_active(const obs_encoder_t *encoder);
/** Duplicates an encoder packet */
EXPORT void obs_duplicate_encoder_packet(struct encoder_packet *dst,
@ -1159,7 +1164,7 @@ EXPORT obs_service_t *obs_service_create(const char *id, const char *name,
obs_data_t *settings);
EXPORT void obs_service_destroy(obs_service_t *service);
EXPORT const char *obs_service_get_name(obs_service_t *service);
EXPORT const char *obs_service_get_name(const obs_service_t *service);
/** Gets the default settings for a service */
EXPORT obs_data_t *obs_service_defaults(const char *id);
@ -1171,28 +1176,28 @@ EXPORT obs_properties_t *obs_get_service_properties(const char *id);
* Returns the property list of an existing service context, if any. Free with
* obs_properties_destroy
*/
EXPORT obs_properties_t *obs_service_properties(obs_service_t *service);
EXPORT obs_properties_t *obs_service_properties(const obs_service_t *service);
/** Gets the service type */
EXPORT const char *obs_service_gettype(obs_service_t *service);
EXPORT const char *obs_service_gettype(const obs_service_t *service);
/** Updates the settings of the service context */
EXPORT void obs_service_update(obs_service_t *service, obs_data_t *settings);
/** Returns the current settings for this service */
EXPORT obs_data_t *obs_service_get_settings(obs_service_t *service);
EXPORT obs_data_t *obs_service_get_settings(const obs_service_t *service);
/** Returns the URL for this service context */
EXPORT const char *obs_service_get_url(obs_service_t *service);
EXPORT const char *obs_service_get_url(const obs_service_t *service);
/** Returns the stream key (if any) for this service context */
EXPORT const char *obs_service_get_key(obs_service_t *service);
EXPORT const char *obs_service_get_key(const obs_service_t *service);
/** Returns the username (if any) for this service context */
EXPORT const char *obs_service_get_username(obs_service_t *service);
EXPORT const char *obs_service_get_username(const obs_service_t *service);
/** Returns the password (if any) for this service context */
EXPORT const char *obs_service_get_password(obs_service_t *service);
EXPORT const char *obs_service_get_password(const obs_service_t *service);
/* ------------------------------------------------------------------------- */

34
libobs/util/config-file.c
View File

@ -345,13 +345,13 @@ const char *config_get_section(config_t *config, size_t idx)
return section->name;
}
static struct config_item *config_find_item(struct darray *sections,
static const struct config_item *config_find_item(const struct darray *sections,
const char *section, const char *name)
{
size_t i, j;
for (i = 0; i < sections->num; i++) {
struct config_section *sec = darray_item(
const struct config_section *sec = darray_item(
sizeof(struct config_section), sections, i);
if (astrcmpi(sec->name, section) == 0) {
@ -492,10 +492,10 @@ void config_set_default_double(config_t *config, const char *section,
config_set_item(&config->defaults, section, name, str.array);
}
const char *config_get_string(config_t *config, const char *section,
const char *config_get_string(const config_t *config, const char *section,
const char *name)
{
struct config_item *item = config_find_item(&config->sections,
const struct config_item *item = config_find_item(&config->sections,
section, name);
if (!item)
item = config_find_item(&config->defaults, section, name);
@ -505,7 +505,7 @@ const char *config_get_string(config_t *config, const char *section,
return item->value;
}
int64_t config_get_int(config_t *config, const char *section,
int64_t config_get_int(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_string(config, section, name);
@ -515,7 +515,7 @@ int64_t config_get_int(config_t *config, const char *section,
return 0;
}
uint64_t config_get_uint(config_t *config, const char *section,
uint64_t config_get_uint(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_string(config, section, name);
@ -525,7 +525,7 @@ uint64_t config_get_uint(config_t *config, const char *section,
return 0;
}
bool config_get_bool(config_t *config, const char *section,
bool config_get_bool(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_string(config, section, name);
@ -536,7 +536,7 @@ bool config_get_bool(config_t *config, const char *section,
return false;
}
double config_get_double(config_t *config, const char *section,
double config_get_double(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_string(config, section, name);
@ -546,10 +546,10 @@ double config_get_double(config_t *config, const char *section,
return 0.0;
}
const char *config_get_default_string(config_t *config, const char *section,
const char *name)
const char *config_get_default_string(const config_t *config,
const char *section, const char *name)
{
struct config_item *item;
const struct config_item *item;
item = config_find_item(&config->defaults, section, name);
if (!item)
@ -558,7 +558,7 @@ const char *config_get_default_string(config_t *config, const char *section,
return item->value;
}
int64_t config_get_default_int(config_t *config, const char *section,
int64_t config_get_default_int(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_default_string(config, section, name);
@ -568,7 +568,7 @@ int64_t config_get_default_int(config_t *config, const char *section,
return 0;
}
uint64_t config_get_default_uint(config_t *config, const char *section,
uint64_t config_get_default_uint(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_default_string(config, section, name);
@ -578,7 +578,7 @@ uint64_t config_get_default_uint(config_t *config, const char *section,
return 0;
}
bool config_get_default_bool(config_t *config, const char *section,
bool config_get_default_bool(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_default_string(config, section, name);
@ -589,7 +589,7 @@ bool config_get_default_bool(config_t *config, const char *section,
return false;
}
double config_get_default_double(config_t *config, const char *section,
double config_get_default_double(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_default_string(config, section, name);
@ -599,13 +599,13 @@ double config_get_default_double(config_t *config, const char *section,
return 0.0;
}
bool config_has_user_value(config_t *config, const char *section,
bool config_has_user_value(const config_t *config, const char *section,
const char *name)
{
return config_find_item(&config->sections, section, name) != NULL;
}
bool config_has_default_value(config_t *config, const char *section,
bool config_has_default_value(const config_t *config, const char *section,
const char *name)
{
return config_find_item(&config->defaults, section, name) != NULL;

38
libobs/util/config-file.h
View File

@ -61,15 +61,15 @@ EXPORT void config_set_bool(config_t *config, const char *section,
EXPORT void config_set_double(config_t *config, const char *section,
const char *name, double value);
EXPORT const char *config_get_string(config_t *config, const char *section,
EXPORT const char *config_get_string(const config_t *config,
const char *section, const char *name);
EXPORT int64_t config_get_int(const config_t *config, const char *section,
const char *name);
EXPORT int64_t config_get_int(config_t *config, const char *section,
EXPORT uint64_t config_get_uint(const config_t *config, const char *section,
const char *name);
EXPORT uint64_t config_get_uint(config_t *config, const char *section,
EXPORT bool config_get_bool(const config_t *config, const char *section,
const char *name);
EXPORT bool config_get_bool(config_t *config, const char *section,
const char *name);
EXPORT double config_get_double(config_t *config, const char *section,
EXPORT double config_get_double(const config_t *config, const char *section,
const char *name);
/*
@ -101,21 +101,21 @@ EXPORT void config_set_default_double(config_t *config, const char *section,
/* These functions allow you to get the current default values rather than get
* the actual values. Probably almost never really needed */
EXPORT const char *config_get_default_string(config_t *config,
EXPORT const char *config_get_default_string(const config_t *config,
const char *section, const char *name);
EXPORT int64_t config_get_default_int(const config_t *config,
const char *section, const char *name);
EXPORT uint64_t config_get_default_uint(const config_t *config,
const char *section, const char *name);
EXPORT bool config_get_default_bool(const config_t *config,
const char *section, const char *name);
EXPORT double config_get_default_double(const config_t *config,
const char *section, const char *name);
EXPORT int64_t config_get_default_int(config_t *config, const char *section,
const char *name);
EXPORT uint64_t config_get_default_uint(config_t *config, const char *section,
const char *name);
EXPORT bool config_get_default_bool(config_t *config, const char *section,
const char *name);
EXPORT double config_get_default_double(config_t *config, const char *section,
const char *name);
EXPORT bool config_has_user_value(config_t *config, const char *section,
const char *name);
EXPORT bool config_has_default_value(config_t *config, const char *section,
const char *name);
EXPORT bool config_has_user_value(const config_t *config,
const char *section, const char *name);
EXPORT bool config_has_default_value(const config_t *config,
const char *section, const char *name);
#ifdef __cplusplus
}