(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.

libobs-d3d11/d3d11-samplerstate.cpp

@@ -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)
 {

libobs-d3d11/d3d11-shader.cpp

@@ -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)

libobs-d3d11/d3d11-subsystem.cpp

@@ -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;
 }

libobs-d3d11/d3d11-subsystem.hpp

@@ -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);
 };

libobs-opengl/gl-cocoa.m

@@ -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;

libobs-opengl/gl-indexbuffer.c

@@ -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;
 }

libobs-opengl/gl-shader.c

@@ -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;

libobs-opengl/gl-stagesurf.c

@@ -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;
 }

libobs-opengl/gl-subsystem.c

@@ -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);

libobs-opengl/gl-subsystem.h

@@ -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);

libobs-opengl/gl-texture2d.c

@@ -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;

libobs-opengl/gl-texturecube.c

@@ -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;
 }

libobs-opengl/gl-vertexbuffer.c

@@ -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;
 }

libobs-opengl/gl-windows.c

@@ -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;

libobs-opengl/gl-x11.c

@@ -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;

libobs/callback/calldata.c

@@ -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)

libobs/callback/calldata.h

@@ -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);

libobs/graphics/device-exports.h

@@ -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,

libobs/graphics/effect.c

@@ -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)

libobs/graphics/graphics-internal.h

@@ -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);

libobs/graphics/graphics.c

@@ -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;
 

libobs/graphics/graphics.h

@@ -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__
 

libobs/graphics/texture-render.c

@@ -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;
 }

libobs/media-io/audio-io.c

@@ -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;
 }

libobs/media-io/audio-io.h

@@ -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 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 bool audio_output_active(const 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);

libobs/media-io/video-io.c

@@ -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;
 }

libobs/media-io/video-io.h

@@ -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

libobs/obs-display.c

@@ -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;

libobs/obs-encoder.c

@@ -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)

libobs/obs-internal.h

@@ -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);
 
 

libobs/obs-output.c

@@ -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;
 

libobs/obs-scene.c

@@ -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)

libobs/obs-service.c

@@ -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);

libobs/obs-source.c

@@ -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;
 }

libobs/obs.c

@@ -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;

libobs/obs.h

@@ -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);
 
 
 /* ------------------------------------------------------------------------- */

libobs/util/config-file.c

@@ -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;

libobs/util/config-file.h

@@ -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,
-		const char *name);
-EXPORT int64_t config_get_int(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 uint64_t config_get_uint(config_t *config, const char *section,
+EXPORT uint64_t config_get_uint(const config_t *config, const char *section,
 		const char *name);
-EXPORT bool config_get_bool(config_t *config, const char *section,
+EXPORT bool config_get_bool(const 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
 }