Merge pull request #270 from jp9000/remove-type-pointers

Remove type pointers

libobs-d3d11/d3d11-indexbuffer.cpp

@@ -37,7 +37,7 @@ void gs_index_buffer::InitBuffer()
 		throw HRError("Failed to create buffer", hr);
 }
 
-gs_index_buffer::gs_index_buffer(gs_device_t device, enum gs_index_type type,
+gs_index_buffer::gs_index_buffer(gs_device_t *device, enum gs_index_type type,
 		void *indices, size_t num, uint32_t flags)
 	: device  (device),
 	  type    (type),

libobs-d3d11/d3d11-samplerstate.cpp

@@ -59,7 +59,7 @@ 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, gs_sampler_info *info)
 	: device (device),
 	  info   (*info)
 {

libobs-d3d11/d3d11-shader.cpp

@@ -38,7 +38,7 @@ void gs_vertex_shader::GetBuffersExpected(
 	}
 }
 
-gs_vertex_shader::gs_vertex_shader(gs_device_t device, const char *file,
+gs_vertex_shader::gs_vertex_shader(gs_device_t *device, const char *file,
 		const char *shaderString)
 	: gs_shader   (device, GS_SHADER_VERTEX),
 	  hasNormals  (false),
@@ -76,7 +76,7 @@ gs_vertex_shader::gs_vertex_shader(gs_device_t device, const char *file,
 	world    = gs_shader_get_param_by_name(this, "World");
 }
 
-gs_pixel_shader::gs_pixel_shader(gs_device_t device, const char *file,
+gs_pixel_shader::gs_pixel_shader(gs_device_t *device, const char *file,
 		const char *shaderString)
 	: gs_shader(device, GS_SHADER_PIXEL)
 {
@@ -216,9 +216,9 @@ inline void gs_shader::UpdateParam(vector<uint8_t> &constData,
 			upload = true;
 			param.changed = false;
 		}
-	} else if (param.curValue.size() == sizeof(gs_texture_t)) {
-		gs_texture_t tex;
-		memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t));
+	} else if (param.curValue.size() == sizeof(gs_texture_t*)) {
+		gs_texture_t *tex;
+		memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t*));
 		device_load_texture(device, tex, param.textureID);
 	}
 }
@@ -250,22 +250,22 @@ void gs_shader::UploadParams()
 	}
 }
 
-void gs_shader_destroy(gs_shader_t shader)
+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(gs_shader_t *shader)
 {
 	return (int)shader->params.size();
 }
 
-gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader, uint32_t param)
+gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader, uint32_t param)
 {
 	return &shader->params[param];
 }
 
-gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader, const char *name)
+gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
 {
 	for (size_t i = 0; i < shader->params.size(); i++) {
 		gs_shader_param &param = shader->params[i];
@@ -276,7 +276,7 @@ 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(gs_shader_t *shader)
 {
 	if (shader->type != GS_SHADER_VERTEX)
 		return NULL;
@@ -284,7 +284,7 @@ gs_sparam_t gs_shader_get_viewproj_matrix(gs_shader_t shader)
 	return static_cast<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(gs_shader_t *shader)
 {
 	if (shader->type != GS_SHADER_VERTEX)
 		return NULL;
@@ -292,7 +292,7 @@ gs_sparam_t gs_shader_get_world_matrix(gs_shader_t shader)
 	return static_cast<gs_vertex_shader*>(shader)->world;
 }
 
-void gs_shader_get_param_info(gs_sparam_t param,
+void gs_shader_get_param_info(gs_sparam_t *param,
 		struct gs_shader_param_info *info)
 {
 	if (!param)
@@ -319,59 +319,59 @@ static inline void shader_setval_inline(gs_shader_param *param,
 	}
 }
 
-void gs_shader_set_bool(gs_sparam_t param, bool val)
+void gs_shader_set_bool(gs_sparam_t *param, bool val)
 {
 	shader_setval_inline(param, &val, sizeof(bool));
 }
 
-void gs_shader_set_float(gs_sparam_t param, float val)
+void gs_shader_set_float(gs_sparam_t *param, float val)
 {
 	shader_setval_inline(param, &val, sizeof(float));
 }
 
-void gs_shader_set_int(gs_sparam_t param, int val)
+void gs_shader_set_int(gs_sparam_t *param, int val)
 {
 	shader_setval_inline(param, &val, sizeof(int));
 }
 
-void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val)
+void gs_shader_setmatrix3(gs_sparam_t *param, const struct matrix3 *val)
 {
 	struct matrix4 mat;
 	matrix4_from_matrix3(&mat, val);
 	shader_setval_inline(param, &mat, sizeof(matrix4));
 }
 
-void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val)
+void gs_shader_set_matrix4(gs_sparam_t *param, const struct matrix4 *val)
 {
 	shader_setval_inline(param, val, sizeof(matrix4));
 }
 
-void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val)
+void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val)
 {
 	shader_setval_inline(param, val, sizeof(vec2));
 }
 
-void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val)
+void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val)
 {
 	shader_setval_inline(param, val, sizeof(float) * 3);
 }
 
-void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val)
+void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val)
 {
 	shader_setval_inline(param, val, sizeof(vec4));
 }
 
-void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val)
+void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val)
 {
-	shader_setval_inline(param, &val, sizeof(gs_texture_t));
+	shader_setval_inline(param, &val, sizeof(gs_texture_t*));
 }
 
-void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size)
+void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size)
 {
 	shader_setval_inline(param, val, size);
 }
 
-void gs_shader_set_default(gs_sparam_t param)
+void gs_shader_set_default(gs_sparam_t *param)
 {
 	if (param->defaultValue.size())
 		shader_setval_inline(param, param->defaultValue.data(),

libobs-d3d11/d3d11-shaderprocessor.cpp

@@ -180,7 +180,7 @@ void ShaderProcessor::BuildParams(vector<gs_shader_param> &params)
 		AddParam(parser.params.array[i], params, texCounter);
 }
 
-static inline void AddSampler(gs_device_t device, shader_sampler &sampler,
+static inline void AddSampler(gs_device_t *device, shader_sampler &sampler,
 		vector<ShaderSampler> &samplers)
 {
 	gs_sampler_info si;

libobs-d3d11/d3d11-shaderprocessor.hpp

@@ -25,7 +25,7 @@ struct ShaderParser : shader_parser {
 };
 
 struct ShaderProcessor {
-	gs_device_t device;
+	gs_device_t *device;
 	ShaderParser parser;
 
 	void BuildInputLayout(vector<D3D11_INPUT_ELEMENT_DESC> &inputs);
@@ -34,7 +34,7 @@ struct ShaderProcessor {
 	void BuildString(string &outputString);
 	void Process(const char *shader_string, const char *file);
 
-	inline ShaderProcessor(gs_device_t device) : device(device)
+	inline ShaderProcessor(gs_device_t *device) : device(device)
 	{
 	}
 };

libobs-d3d11/d3d11-stagesurf.cpp

@@ -17,7 +17,7 @@
 
 #include "d3d11-subsystem.hpp"
 
-gs_stage_surface::gs_stage_surface(gs_device_t device, uint32_t width,
+gs_stage_surface::gs_stage_surface(gs_device_t *device, uint32_t width,
 		uint32_t height, gs_color_format colorFormat)
 	: device     (device),
 	  width      (width),

libobs-d3d11/d3d11-subsystem.cpp

@@ -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, gs_init_data *data)
 {
 	gs_device *device = NULL;
 	int errorcode = GS_SUCCESS;
@@ -466,24 +466,24 @@ int device_create(gs_device_t *p_device, gs_init_data *data)
 	return errorcode;
 }
 
-void device_destroy(gs_device_t device)
+void device_destroy(gs_device_t *device)
 {
 	delete device;
 }
 
-void device_enter_context(gs_device_t device)
+void device_enter_context(gs_device_t *device)
 {
 	/* does nothing */
 	UNUSED_PARAMETER(device);
 }
 
-void device_leave_context(gs_device_t device)
+void device_leave_context(gs_device_t *device)
 {
 	/* does nothing */
 	UNUSED_PARAMETER(device);
 }
 
-gs_swapchain_t device_swapchain_create(gs_device_t device,
+gs_swapchain_t *device_swapchain_create(gs_device_t *device,
 		struct gs_init_data *data)
 {
 	gs_swap_chain *swap = NULL;
@@ -498,7 +498,7 @@ gs_swapchain_t device_swapchain_create(gs_device_t device,
 	return swap;
 }
 
-void device_resize(gs_device_t device, uint32_t cx, uint32_t cy)
+void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
 {
 	try {
 		ID3D11RenderTargetView *renderView = NULL;
@@ -520,23 +520,23 @@ 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(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(gs_device_t *device)
 {
 	return device->curSwapChain->target.width;
 }
 
-uint32_t device_get_height(gs_device_t device)
+uint32_t device_get_height(gs_device_t *device)
 {
 	return device->curSwapChain->target.height;
 }
 
-gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
+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)
 {
@@ -555,7 +555,7 @@ gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
 	return texture;
 }
 
-gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
+gs_texture_t *device_cubetexture_create(gs_device_t *device, uint32_t size,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
 {
@@ -576,7 +576,7 @@ gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
 	return texture;
 }
 
-gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
+gs_texture_t *device_voltexture_create(gs_device_t *device, uint32_t width,
 		uint32_t height, uint32_t depth,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
@@ -593,7 +593,7 @@ gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
 	return NULL;
 }
 
-gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
+gs_zstencil_t *device_zstencil_create(gs_device_t *device, uint32_t width,
 		uint32_t height, enum gs_zstencil_format format)
 {
 	gs_zstencil_buffer *zstencil = NULL;
@@ -608,7 +608,7 @@ gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
 	return zstencil;
 }
 
-gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
+gs_stagesurf_t *device_stagesurface_create(gs_device_t *device, uint32_t width,
 		uint32_t height, enum gs_color_format color_format)
 {
 	gs_stage_surface *surf = NULL;
@@ -624,7 +624,7 @@ gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
 	return surf;
 }
 
-gs_samplerstate_t device_samplerstate_create(gs_device_t device,
+gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
 		struct gs_sampler_info *info)
 {
 	gs_sampler_state *ss = NULL;
@@ -639,7 +639,7 @@ gs_samplerstate_t device_samplerstate_create(gs_device_t device,
 	return ss;
 }
 
-gs_shader_t device_vertexshader_create(gs_device_t device,
+gs_shader_t *device_vertexshader_create(gs_device_t *device,
 		const char *shader_string, const char *file,
 		char **error_string)
 {
@@ -668,7 +668,7 @@ gs_shader_t device_vertexshader_create(gs_device_t device,
 	return shader;
 }
 
-gs_shader_t device_pixelshader_create(gs_device_t device,
+gs_shader_t *device_pixelshader_create(gs_device_t *device,
 		const char *shader_string, const char *file,
 		char **error_string)
 {
@@ -697,7 +697,7 @@ gs_shader_t device_pixelshader_create(gs_device_t device,
 	return shader;
 }
 
-gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
+gs_vertbuffer_t *device_vertexbuffer_create(gs_device_t *device,
 		struct gs_vb_data *data, uint32_t flags)
 {
 	gs_vertex_buffer *buffer = NULL;
@@ -715,7 +715,7 @@ gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
 	return buffer;
 }
 
-gs_indexbuffer_t device_indexbuffer_create(gs_device_t device,
+gs_indexbuffer_t *device_indexbuffer_create(gs_device_t *device,
 		enum gs_index_type type, void *indices, size_t num,
 		uint32_t flags)
 {
@@ -730,12 +730,12 @@ 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(gs_texture_t *texture)
 {
 	return texture->type;
 }
 
-void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vertbuffer)
+void device_load_vertexbuffer(gs_device_t *device, gs_vertbuffer_t *vertbuffer)
 {
 	if (device->curVertexBuffer == vertbuffer)
 		return;
@@ -764,7 +764,7 @@ void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vertbuffer)
 			buffers.data(), strides.data(), offsets.data());
 }
 
-void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t indexbuffer)
+void device_load_indexbuffer(gs_device_t *device, gs_indexbuffer_t *indexbuffer)
 {
 	DXGI_FORMAT format;
 	ID3D11Buffer *buffer;
@@ -789,7 +789,7 @@ void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t indexbuffer)
 	device->context->IASetIndexBuffer(buffer, format, 0);
 }
 
-void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
+void device_load_texture(gs_device_t *device, gs_texture_t *tex, int unit)
 {
 	ID3D11ShaderResourceView *view = NULL;
 
@@ -803,8 +803,8 @@ void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
 	device->context->PSSetShaderResources(unit, 1, &view);
 }
 
-void device_load_samplerstate(gs_device_t device,
-		gs_samplerstate_t samplerstate, int unit)
+void device_load_samplerstate(gs_device_t *device,
+		gs_samplerstate_t *samplerstate, int unit)
 {
 	ID3D11SamplerState *state = NULL;
 
@@ -818,7 +818,7 @@ void device_load_samplerstate(gs_device_t device,
 	device->context->PSSetSamplers(unit, 1, &state);
 }
 
-void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
+void device_load_vertexshader(gs_device_t *device, gs_shader_t *vertshader)
 {
 	ID3D11VertexShader *shader    = NULL;
 	ID3D11InputLayout  *layout    = NULL;
@@ -855,7 +855,7 @@ void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
 		device_load_vertexbuffer(device, curVB);
 }
 
-static inline void clear_textures(gs_device_t device)
+static inline void clear_textures(gs_device_t *device)
 {
 	ID3D11ShaderResourceView *views[GS_MAX_TEXTURES];
 	memset(views,               0, sizeof(views));
@@ -863,7 +863,7 @@ static inline void clear_textures(gs_device_t device)
 	device->context->PSSetShaderResources(0, GS_MAX_TEXTURES, views);
 }
 
-void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
+void device_load_pixelshader(gs_device_t *device, gs_shader_t *pixelshader)
 {
 	ID3D11PixelShader  *shader    = NULL;
 	ID3D11Buffer       *constants = NULL;
@@ -902,7 +902,7 @@ void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
 			device->curSamplers[i] = nullptr;
 }
 
-void device_load_default_samplerstate(gs_device_t device, bool b_3d, int unit)
+void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit)
 {
 	/* TODO */
 	UNUSED_PARAMETER(device);
@@ -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(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(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(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(gs_device_t *device)
 {
 	if (device->curZStencilBuffer == &device->curSwapChain->zs)
 		return NULL;
@@ -936,8 +936,8 @@ gs_zstencil_t device_get_zstencil_target(gs_device_t device)
 	return device->curZStencilBuffer;
 }
 
-void device_set_render_target(gs_device_t device, gs_texture_t tex,
-		gs_zstencil_t zstencil)
+void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
+		gs_zstencil_t *zstencil)
 {
 	if (!tex)
 		tex = &device->curSwapChain->target;
@@ -969,8 +969,8 @@ void device_set_render_target(gs_device_t device, gs_texture_t tex,
 	device->context->OMSetRenderTargets(1, &rt, zstencil->view);
 }
 
-void device_set_cube_render_target(gs_device_t device, gs_texture_t tex,
-		int side, gs_zstencil_t zstencil)
+void device_set_cube_render_target(gs_device_t *device, gs_texture_t *tex,
+		int side, gs_zstencil_t *zstencil)
 {
 	if (!tex) {
 		tex = &device->curSwapChain->target;
@@ -1008,7 +1008,7 @@ void device_set_cube_render_target(gs_device_t device, gs_texture_t tex,
 
 inline void gs_device::CopyTex(ID3D11Texture2D *dst,
 		uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
+		gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h)
 {
 	if (src->type != GS_TEXTURE_2D)
@@ -1043,9 +1043,9 @@ inline void gs_device::CopyTex(ID3D11Texture2D *dst,
 	}
 }
 
-void device_copy_texture_region(gs_device_t device,
-		gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
+void device_copy_texture_region(gs_device_t *device,
+		gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+		gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h)
 {
 	try {
@@ -1092,13 +1092,14 @@ void device_copy_texture_region(gs_device_t device,
 	}
 }
 
-void device_copy_texture(gs_device_t device, gs_texture_t dst, gs_texture_t src)
+void device_copy_texture(gs_device_t *device, gs_texture_t *dst,
+		gs_texture_t *src)
 {
 	device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
 }
 
-void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
-		gs_texture_t src)
+void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
+		gs_texture_t *src)
 {
 	try {
 		gs_texture_2d *src2d = static_cast<gs_texture_2d*>(src);
@@ -1123,12 +1124,12 @@ void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
 	}
 }
 
-void device_begin_scene(gs_device_t device)
+void device_begin_scene(gs_device_t *device)
 {
 	clear_textures(device);
 }
 
-void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
+void device_draw(gs_device_t *device, enum gs_draw_mode draw_mode,
 		uint32_t start_vert, uint32_t num_verts)
 {
 	try {
@@ -1141,7 +1142,7 @@ void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
 		if (!device->curVertexBuffer)
 			throw "No vertex buffer specified";
 
-		gs_effect_t effect = gs_get_effect();
+		gs_effect_t *effect = gs_get_effect();
 		if (effect)
 			gs_effect_update_params(effect);
 
@@ -1179,16 +1180,16 @@ void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
 	}
 }
 
-void device_end_scene(gs_device_t device)
+void device_end_scene(gs_device_t *device)
 {
 	/* does nothing in D3D11 */
 	UNUSED_PARAMETER(device);
 }
 
-void device_load_swapchain(gs_device_t device, gs_swapchain_t swapchain)
+void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swapchain)
 {
-	gs_texture_t  target = device->curRenderTarget;
-	gs_zstencil_t zs     = device->curZStencilBuffer;
+	gs_texture_t  *target = device->curRenderTarget;
+	gs_zstencil_t *zs     = device->curZStencilBuffer;
 	bool is_cube = device->curRenderTarget->type == GS_TEXTURE_CUBE;
 
 	if (target == &device->curSwapChain->target)
@@ -1208,7 +1209,7 @@ 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,
+void device_clear(gs_device_t *device, uint32_t clear_flags, struct vec4 *color,
 		float depth, uint8_t stencil)
 {
 	int side = device->curRenderSide;
@@ -1231,17 +1232,17 @@ void device_clear(gs_device_t device, uint32_t clear_flags, struct vec4 *color,
 	}
 }
 
-void device_present(gs_device_t device)
+void device_present(gs_device_t *device)
 {
 	device->curSwapChain->swap->Present(0, 0);
 }
 
-void device_flush(gs_device_t device)
+void device_flush(gs_device_t *device)
 {
 	device->context->Flush();
 }
 
-void device_set_cull_mode(gs_device_t device, enum gs_cull_mode mode)
+void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode)
 {
 	if (mode == device->rasterState.cullMode)
 		return;
@@ -1250,12 +1251,12 @@ 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(gs_device_t *device)
 {
 	return device->rasterState.cullMode;
 }
 
-void device_enable_blending(gs_device_t device, bool enable)
+void device_enable_blending(gs_device_t *device, bool enable)
 {
 	if (enable == device->blendState.blendEnabled)
 		return;
@@ -1264,7 +1265,7 @@ void device_enable_blending(gs_device_t device, bool enable)
 	device->blendStateChanged = true;
 }
 
-void device_enable_depth_test(gs_device_t device, bool enable)
+void device_enable_depth_test(gs_device_t *device, bool enable)
 {
 	if (enable == device->zstencilState.depthEnabled)
 		return;
@@ -1273,7 +1274,7 @@ void device_enable_depth_test(gs_device_t device, bool enable)
 	device->zstencilStateChanged = true;
 }
 
-void device_enable_stencil_test(gs_device_t device, bool enable)
+void device_enable_stencil_test(gs_device_t *device, bool enable)
 {
 	if (enable == device->zstencilState.stencilEnabled)
 		return;
@@ -1282,7 +1283,7 @@ void device_enable_stencil_test(gs_device_t device, bool enable)
 	device->zstencilStateChanged = true;
 }
 
-void device_enable_stencil_write(gs_device_t device, bool enable)
+void device_enable_stencil_write(gs_device_t *device, bool enable)
 {
 	if (enable == device->zstencilState.stencilWriteEnabled)
 		return;
@@ -1291,7 +1292,7 @@ void device_enable_stencil_write(gs_device_t device, bool enable)
 	device->zstencilStateChanged = true;
 }
 
-void device_enable_color(gs_device_t device, bool red, bool green,
+void device_enable_color(gs_device_t *device, bool red, bool green,
 		bool blue, bool alpha)
 {
 	if (device->blendState.redEnabled   == red   &&
@@ -1307,7 +1308,7 @@ void device_enable_color(gs_device_t device, bool red, bool green,
 	device->blendStateChanged       = true;
 }
 
-void device_blend_function(gs_device_t device, enum gs_blend_type src,
+void device_blend_function(gs_device_t *device, enum gs_blend_type src,
 		enum gs_blend_type dest)
 {
 	if (device->blendState.srcFactor  == src &&
@@ -1319,7 +1320,7 @@ void device_blend_function(gs_device_t device, enum gs_blend_type src,
 	device->blendStateChanged     = true;
 }
 
-void device_depth_function(gs_device_t device, enum gs_depth_test test)
+void device_depth_function(gs_device_t *device, enum gs_depth_test test)
 {
 	if (device->zstencilState.depthFunc == test)
 		return;
@@ -1328,8 +1329,8 @@ void device_depth_function(gs_device_t device, enum gs_depth_test test)
 	device->zstencilStateChanged    = true;
 }
 
-static inline void update_stencilside_test(gs_device_t device, StencilSide &side,
-		gs_depth_test test)
+static inline void update_stencilside_test(gs_device_t *device,
+		StencilSide &side, gs_depth_test test)
 {
 	if (side.test == test)
 		return;
@@ -1338,7 +1339,7 @@ static inline void update_stencilside_test(gs_device_t device, StencilSide &side
 	device->zstencilStateChanged = true;
 }
 
-void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
+void device_stencil_function(gs_device_t *device, enum gs_stencil_side side,
 		enum gs_depth_test test)
 {
 	int sideVal = (int)side;
@@ -1351,7 +1352,7 @@ void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
 				device->zstencilState.stencilBack, test);
 }
 
-static inline void update_stencilside_op(gs_device_t device, StencilSide &side,
+static inline void update_stencilside_op(gs_device_t *device, StencilSide &side,
 		enum gs_stencil_op_type fail, enum gs_stencil_op_type zfail,
 		enum gs_stencil_op_type zpass)
 {
@@ -1364,7 +1365,7 @@ static inline void update_stencilside_op(gs_device_t device, StencilSide &side,
 	device->zstencilStateChanged = true;
 }
 
-void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
+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)
 {
@@ -1380,7 +1381,7 @@ void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
 				fail, zfail, zpass);
 }
 
-void device_set_viewport(gs_device_t device, int x, int y, int width,
+void device_set_viewport(gs_device_t *device, int x, int y, int width,
 		int height)
 {
 	D3D11_VIEWPORT vp;
@@ -1398,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(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, struct gs_rect *rect)
 {
 	D3D11_RECT d3drect;
 
@@ -1420,7 +1421,7 @@ void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect)
 	device->rasterStateChanged = true;
 }
 
-void device_ortho(gs_device_t device, float left, float right, float top,
+void device_ortho(gs_device_t *device, float left, float right, float top,
 		float bottom, float zNear, float zFar)
 {
 	matrix4 *dst = &device->curProjMatrix;
@@ -1446,7 +1447,7 @@ void device_ortho(gs_device_t device, float left, float right, float top,
 	dst->t.w = 1.0f;
 }
 
-void device_frustum(gs_device_t device, float left, float right, float top,
+void device_frustum(gs_device_t *device, float left, float right, float top,
 		float bottom, float zNear, float zFar)
 {
 	matrix4 *dst = &device->curProjMatrix;
@@ -1473,14 +1474,14 @@ void device_frustum(gs_device_t device, float left, float right, float top,
 	dst->z.w = 1.0f;
 }
 
-void device_projection_push(gs_device_t device)
+void device_projection_push(gs_device_t *device)
 {
 	mat4float mat;
 	memcpy(&mat, &device->curProjMatrix, sizeof(matrix4));
 	device->projStack.push_back(mat);
 }
 
-void device_projection_pop(gs_device_t device)
+void device_projection_pop(gs_device_t *device)
 {
 	if (!device->projStack.size())
 		return;
@@ -1493,7 +1494,7 @@ void device_projection_pop(gs_device_t device)
 	device->projStack.pop_back();
 }
 
-void gs_swapchain_destroy(gs_swapchain_t swapchain)
+void gs_swapchain_destroy(gs_swapchain_t *swapchain)
 {
 	if (!swapchain)
 		return;
@@ -1505,12 +1506,12 @@ void gs_swapchain_destroy(gs_swapchain_t swapchain)
 	delete swapchain;
 }
 
-void gs_texture_destroy(gs_texture_t tex)
+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(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return 0;
@@ -1518,7 +1519,7 @@ uint32_t gs_texture_get_width(gs_texture_t tex)
 	return static_cast<gs_texture_2d*>(tex)->width;
 }
 
-uint32_t gs_texture_get_height(gs_texture_t tex)
+uint32_t gs_texture_get_height(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return 0;
@@ -1526,7 +1527,7 @@ uint32_t gs_texture_get_height(gs_texture_t tex)
 	return static_cast<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(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return GS_UNKNOWN;
@@ -1534,7 +1535,7 @@ enum gs_color_format gs_texture_get_color_format(gs_texture_t tex)
 	return static_cast<gs_texture_2d*>(tex)->format;
 }
 
-bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
+bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr, uint32_t *linesize)
 {
 	HRESULT hr;
 
@@ -1554,7 +1555,7 @@ bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
 	return true;
 }
 
-void gs_texture_unmap(gs_texture_t tex)
+void gs_texture_unmap(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return;
@@ -1563,7 +1564,7 @@ void gs_texture_unmap(gs_texture_t tex)
 	tex2d->device->context->Unmap(tex2d->texture, 0);
 }
 
-void *gs_texture_get_obj(gs_texture_t tex)
+void *gs_texture_get_obj(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return nullptr;
@@ -1573,12 +1574,12 @@ void *gs_texture_get_obj(gs_texture_t tex)
 }
 
 
-void gs_cubetexture_destroy(gs_texture_t cubetex)
+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(gs_texture_t *cubetex)
 {
 	if (cubetex->type != GS_TEXTURE_CUBE)
 		return 0;
@@ -1587,7 +1588,7 @@ uint32_t gs_cubetexture_get_size(gs_texture_t 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(gs_texture_t *cubetex)
 {
 	if (cubetex->type != GS_TEXTURE_CUBE)
 		return GS_UNKNOWN;
@@ -1597,33 +1598,33 @@ enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t cubetex)
 }
 
 
-void gs_voltexture_destroy(gs_texture_t voltex)
+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(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(gs_texture_t *voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return 0;
 }
 
-uint32_t gs_voltexture_getdepth(gs_texture_t voltex)
+uint32_t gs_voltexture_getdepth(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(gs_texture_t *voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
@@ -1631,27 +1632,27 @@ enum gs_color_format gs_voltexture_get_color_format(gs_texture_t voltex)
 }
 
 
-void gs_stagesurface_destroy(gs_stagesurf_t stagesurf)
+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(gs_stagesurf_t *stagesurf)
 {
 	return stagesurf->width;
 }
 
-uint32_t gs_stagesurface_get_height(gs_stagesurf_t stagesurf)
+uint32_t gs_stagesurface_get_height(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(gs_stagesurf_t *stagesurf)
 {
 	return stagesurf->format;
 }
 
-bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
+bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
 		uint32_t *linesize)
 {
 	D3D11_MAPPED_SUBRESOURCE map;
@@ -1664,19 +1665,19 @@ bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
 	return true;
 }
 
-void gs_stagesurface_unmap(gs_stagesurf_t stagesurf)
+void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf)
 {
 	stagesurf->device->context->Unmap(stagesurf->texture, 0);
 }
 
 
-void gs_zstencil_destroy(gs_zstencil_t zstencil)
+void gs_zstencil_destroy(gs_zstencil_t *zstencil)
 {
 	delete zstencil;
 }
 
 
-void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
+void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate)
 {
 	if (!samplerstate)
 		return;
@@ -1691,12 +1692,12 @@ void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
 }
 
 
-void gs_vertexbuffer_destroy(gs_vertbuffer_t vertbuffer)
+void gs_vertexbuffer_destroy(gs_vertbuffer_t *vertbuffer)
 {
 	delete vertbuffer;
 }
 
-void gs_vertexbuffer_flush(gs_vertbuffer_t vertbuffer)
+void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer)
 {
 	if (!vertbuffer->dynamic) {
 		blog(LOG_ERROR, "gs_vertexbuffer_flush: vertex buffer is "
@@ -1726,18 +1727,18 @@ 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(gs_vertbuffer_t *vertbuffer)
 {
 	return vertbuffer->vbd.data;
 }
 
 
-void gs_indexbuffer_destroy(gs_indexbuffer_t indexbuffer)
+void gs_indexbuffer_destroy(gs_indexbuffer_t *indexbuffer)
 {
 	delete indexbuffer;
 }
 
-void gs_indexbuffer_flush(gs_indexbuffer_t indexbuffer)
+void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer)
 {
 	HRESULT hr;
 
@@ -1756,17 +1757,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(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(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(gs_indexbuffer_t *indexbuffer)
 {
 	return indexbuffer->type;
 }
@@ -1776,7 +1777,7 @@ extern "C" EXPORT bool device_gdi_texture_available(void)
 	return true;
 }
 
-extern "C" EXPORT gs_texture_t device_texture_create_gdi(gs_device_t device,
+extern "C" EXPORT gs_texture_t *device_texture_create_gdi(gs_device_t *device,
 		uint32_t width, uint32_t height)
 {
 	gs_texture *texture = nullptr;
@@ -1805,7 +1806,7 @@ static inline bool TextureGDICompatible(gs_texture_2d *tex2d, const char *func)
 	return true;
 }
 
-extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t tex)
+extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t *tex)
 {
 	HDC hDC = nullptr;
 
@@ -1820,7 +1821,7 @@ extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t tex)
 	return hDC;
 }
 
-extern "C" EXPORT void gs_texture_release_dc(gs_texture_t tex)
+extern "C" EXPORT void gs_texture_release_dc(gs_texture_t *tex)
 {
 	if (tex->type != GS_TEXTURE_2D)
 		return;

libobs-d3d11/d3d11-subsystem.hpp

@@ -182,7 +182,7 @@ struct gs_vertex_buffer {
 	ComPtr<ID3D11Buffer>         tangentBuffer;
 	vector<ComPtr<ID3D11Buffer>> uvBuffers;
 
-	gs_device_t       device;
+	gs_device_t       *device;
 	bool           dynamic;
 	VBDataPtr      vbd;
 	size_t         numVerts;
@@ -199,7 +199,7 @@ struct gs_vertex_buffer {
 			const size_t numVerts, void *array,
 			ID3D11Buffer **buffer);
 
-	gs_vertex_buffer(gs_device_t device, struct gs_vb_data *data,
+	gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
 			uint32_t flags);
 };
 
@@ -213,7 +213,7 @@ struct DataPtr {
 
 struct gs_index_buffer {
 	ComPtr<ID3D11Buffer> indexBuffer;
-	gs_device_t          device;
+	gs_device_t          *device;
 	bool                 dynamic;
 	gs_index_type        type;
 	size_t               indexSize;
@@ -222,7 +222,7 @@ struct gs_index_buffer {
 
 	void InitBuffer();
 
-	gs_index_buffer(gs_device_t device, enum gs_index_type type,
+	gs_index_buffer(gs_device_t *device, enum gs_index_type type,
 			void *indices, size_t num, uint32_t flags);
 };
 
@@ -279,7 +279,7 @@ struct gs_texture_2d : gs_texture {
 	{
 	}
 
-	gs_texture_2d(gs_device_t device, uint32_t width, uint32_t height,
+	gs_texture_2d(gs_device_t *device, uint32_t width, uint32_t height,
 			gs_color_format colorFormat, uint32_t levels,
 			const uint8_t **data, uint32_t flags,
 			gs_texture_type type, bool gdiCompatible, bool shared);
@@ -304,7 +304,7 @@ struct gs_zstencil_buffer {
 	{
 	}
 
-	gs_zstencil_buffer(gs_device_t device, uint32_t width, uint32_t height,
+	gs_zstencil_buffer(gs_device_t *device, uint32_t width, uint32_t height,
 			gs_zstencil_format format);
 };
 
@@ -316,16 +316,16 @@ struct gs_stage_surface {
 	gs_color_format format;
 	DXGI_FORMAT     dxgiFormat;
 
-	gs_stage_surface(gs_device_t device, uint32_t width, uint32_t height,
+	gs_stage_surface(gs_device_t *device, uint32_t width, uint32_t height,
 			gs_color_format colorFormat);
 };
 
 struct gs_sampler_state {
 	ComPtr<ID3D11SamplerState> state;
-	gs_device_t                device;
+	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, gs_sampler_info *info);
 };
 
 struct gs_shader_param {
@@ -357,7 +357,7 @@ struct ShaderError {
 };
 
 struct gs_shader {
-	gs_device_t             device;
+	gs_device_t             *device;
 	gs_shader_type          type;
 	vector<gs_shader_param> params;
 	ComPtr<ID3D11Buffer> constants;
@@ -371,7 +371,7 @@ struct gs_shader {
 	void Compile(const char *shaderStr, const char *file,
 			const char *target, ID3D10Blob **shader);
 
-	inline gs_shader(gs_device_t device, gs_shader_type type)
+	inline gs_shader(gs_device_t *device, gs_shader_type type)
 		: device       (device),
 		  type         (type),
 		  constantSize (0)
@@ -385,7 +385,7 @@ struct ShaderSampler {
 	string           name;
 	gs_sampler_state sampler;
 
-	inline ShaderSampler(const char *name, gs_device_t device,
+	inline ShaderSampler(const char *name, gs_device_t *device,
 			gs_sampler_info *info)
 		: name    (name),
 		  sampler (device, info)
@@ -416,7 +416,7 @@ struct gs_vertex_shader : gs_shader {
 
 	void GetBuffersExpected(const vector<D3D11_INPUT_ELEMENT_DESC> &inputs);
 
-	gs_vertex_shader(gs_device_t device, const char *file,
+	gs_vertex_shader(gs_device_t *device, const char *file,
 			const char *shaderString);
 };
 
@@ -433,7 +433,7 @@ struct gs_pixel_shader : gs_shader {
 			states[i] = NULL;
 	}
 
-	gs_pixel_shader(gs_device_t device, const char *file,
+	gs_pixel_shader(gs_device_t *device, const char *file,
 			const char *shaderString);
 };
 
@@ -623,9 +623,10 @@ struct gs_device {
 	void UpdateRasterState();
 	void UpdateBlendState();
 
-	inline void CopyTex(ID3D11Texture2D *dst, uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
-		uint32_t src_w, uint32_t src_h);
+	inline void CopyTex(ID3D11Texture2D *dst,
+			uint32_t dst_x, uint32_t dst_y,
+			gs_texture_t *src, uint32_t src_x, uint32_t src_y,
+			uint32_t src_w, uint32_t src_h);
 
 	void UpdateViewProjMatrix();
 

libobs-d3d11/d3d11-texture2d.cpp

@@ -141,8 +141,8 @@ void gs_texture_2d::InitRenderTargets()
 	}
 }
 
-gs_texture_2d::gs_texture_2d(gs_device_t device, uint32_t width, uint32_t height,
-		gs_color_format colorFormat, uint32_t levels,
+gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t width,
+		uint32_t height, gs_color_format colorFormat, uint32_t levels,
 		const uint8_t **data, uint32_t flags, gs_texture_type type,
 		bool gdiCompatible, bool shared)
 	: gs_texture      (device, type, levels, colorFormat),

libobs-d3d11/d3d11-vertexbuffer.cpp

@@ -93,7 +93,7 @@ inline void gs_vertex_buffer::InitBuffer(const size_t elementSize,
 		throw HRError("Failed to create buffer", hr);
 }
 
-gs_vertex_buffer::gs_vertex_buffer(gs_device_t device, struct gs_vb_data *data,
+gs_vertex_buffer::gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
 		uint32_t flags)
 	: device   (device),
 	  vbd      (data),

libobs-d3d11/d3d11-zstencilbuffer.cpp

@@ -47,7 +47,7 @@ void gs_zstencil_buffer::InitBuffer()
 		throw HRError("Failed to create depth stencil view", hr);
 }
 
-gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t device,
+gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t *device,
 		uint32_t width, uint32_t height,
 		gs_zstencil_format format)
 	: device     (device),

libobs-opengl/gl-cocoa.m

@@ -96,7 +96,7 @@ static NSOpenGLContext *gl_context_create(struct gs_init_data *info)
 	return context;
 }
 
-static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t dev,
+static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t *dev,
 		struct gs_init_data *info)
 {
 	if(!(plat->context = gl_context_create(info)))
@@ -109,7 +109,7 @@ static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t dev,
 	return plat->swap.wi != NULL;
 }
 
-struct gl_platform *gl_platform_create(gs_device_t device,
+struct gl_platform *gl_platform_create(gs_device_t *device,
 		struct gs_init_data *info)
 {
 	struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
@@ -186,24 +186,24 @@ void gl_windowinfo_destroy(struct gl_windowinfo *wi)
 	bfree(wi);
 }
 
-void gl_update(gs_device_t device)
+void gl_update(gs_device_t *device)
 {
 	[device->plat->context update];
 }
 
-void device_enter_context(gs_device_t device)
+void device_enter_context(gs_device_t *device)
 {
 	[device->plat->context makeCurrentContext];
 }
 
-void device_leave_context(gs_device_t device)
+void device_leave_context(gs_device_t *device)
 {
 	UNUSED_PARAMETER(device);
 
 	[NSOpenGLContext clearCurrentContext];
 }
 
-void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
+void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap)
 {
 	if(!swap)
 		swap = &device->plat->swap;
@@ -215,7 +215,7 @@ void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 	[device->plat->context setView:swap->wi->view];
 }
 
-void device_present(gs_device_t device)
+void device_present(gs_device_t *device)
 {
 	[device->plat->context flushBuffer];
 }
@@ -227,7 +227,7 @@ void gl_getclientsize(struct gs_swap_chain *swap, uint32_t *width,
 	if(height) *height = swap->info.cy;
 }
 
-gs_texture_t device_texture_create_from_iosurface(gs_device_t device,
+gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device,
 		void *iosurf)
 {
 	IOSurfaceRef ref = (IOSurfaceRef)iosurf;
@@ -285,15 +285,15 @@ gs_texture_t device_texture_create_from_iosurface(gs_device_t device,
 	if (!gl_bind_texture(tex->base.gl_target, 0))
 		goto fail;
 
-	return (gs_texture_t)tex;
+	return (gs_texture_t*)tex;
 
 fail:
-	gs_texture_destroy((gs_texture_t)tex);
+	gs_texture_destroy((gs_texture_t*)tex);
 	blog(LOG_ERROR, "device_texture_create_from_iosurface (GL) failed");
 	return NULL;
 }
 
-bool gs_texture_rebind_iosurface(gs_texture_t texture, void *iosurf)
+bool gs_texture_rebind_iosurface(gs_texture_t *texture, void *iosurf)
 {
 	if (!texture)
 		return false;

libobs-opengl/gl-indexbuffer.c

@@ -33,7 +33,7 @@ static inline bool init_ib(struct gs_index_buffer *ib)
 	return success;
 }
 
-gs_indexbuffer_t device_indexbuffer_create(gs_device_t device,
+gs_indexbuffer_t *device_indexbuffer_create(gs_device_t *device,
 		enum gs_index_type type, void *indices, size_t num,
 		uint32_t flags)
 {
@@ -59,7 +59,7 @@ gs_indexbuffer_t device_indexbuffer_create(gs_device_t device,
 	return ib;
 }
 
-void gs_indexbuffer_destroy(gs_indexbuffer_t ib)
+void gs_indexbuffer_destroy(gs_indexbuffer_t *ib)
 {
 	if (ib) {
 		if (ib->buffer)
@@ -70,7 +70,7 @@ void gs_indexbuffer_destroy(gs_indexbuffer_t ib)
 	}
 }
 
-void gs_indexbuffer_flush(gs_indexbuffer_t ib)
+void gs_indexbuffer_flush(gs_indexbuffer_t *ib)
 {
 	if (!ib->dynamic) {
 		blog(LOG_ERROR, "Index buffer is not dynamic");
@@ -86,22 +86,22 @@ fail:
 	blog(LOG_ERROR, "gs_indexbuffer_flush (GL) failed");
 }
 
-void *gs_indexbuffer_get_data(gs_indexbuffer_t ib)
+void *gs_indexbuffer_get_data(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(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(gs_indexbuffer_t *ib)
 {
 	return ib->type;
 }
 
-void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t ib)
+void device_load_indexbuffer(gs_device_t *device, gs_indexbuffer_t *ib)
 {
 	if (ib == device->cur_index_buffer)
 		return;

libobs-opengl/gl-shader.c

@@ -108,7 +108,7 @@ static inline bool gl_add_params(struct gs_shader *shader,
 static inline void gl_add_sampler(struct gs_shader *shader,
 		struct shader_sampler *sampler)
 {
-	gs_samplerstate_t new_sampler;
+	gs_samplerstate_t *new_sampler;
 	struct gs_sampler_info info;
 
 	shader_sampler_convert(sampler, &info);
@@ -236,7 +236,7 @@ static bool gl_shader_init(struct gs_shader *shader,
 	return success;
 }
 
-static struct gs_shader *shader_create(gs_device_t device,
+static struct gs_shader *shader_create(gs_device_t *device,
 		enum gs_shader_type type, const char *shader_str,
 		const char *file, char **error_string)
 {
@@ -262,7 +262,7 @@ static struct gs_shader *shader_create(gs_device_t device,
 	return shader;
 }
 
-gs_shader_t device_vertexshader_create(gs_device_t device,
+gs_shader_t *device_vertexshader_create(gs_device_t *device,
 		const char *shader, const char *file,
 		char **error_string)
 {
@@ -274,7 +274,7 @@ gs_shader_t device_vertexshader_create(gs_device_t device,
 	return ptr;
 }
 
-gs_shader_t device_pixelshader_create(gs_device_t device,
+gs_shader_t *device_pixelshader_create(gs_device_t *device,
 		const char *shader, const char *file,
 		char **error_string)
 {
@@ -309,7 +309,7 @@ static void remove_program_references(struct gs_shader *shader)
 	}
 }
 
-void gs_shader_destroy(gs_shader_t shader)
+void gs_shader_destroy(gs_shader_t *shader)
 {
 	size_t i;
 
@@ -338,18 +338,18 @@ 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(gs_shader_t *shader)
 {
 	return (int)shader->params.num;
 }
 
-gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader, uint32_t param)
+gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader, uint32_t param)
 {
 	assert(param < shader->params.num);
 	return shader->params.array+param;
 }
 
-gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader, const char *name)
+gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
 {
 	size_t i;
 	for (i = 0; i < shader->params.num; i++) {
@@ -362,40 +362,40 @@ 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(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(gs_shader_t *shader)
 {
 	return shader->world;
 }
 
-void gs_shader_get_param_info(gs_sparam_t param,
+void gs_shader_get_param_info(gs_sparam_t *param,
 		struct gs_shader_param_info *info)
 {
 	info->type = param->type;
 	info->name = param->name;
 }
 
-void gs_shader_set_bool(gs_sparam_t param, bool val)
+void gs_shader_set_bool(gs_sparam_t *param, bool val)
 {
 	int int_val = val;
 	da_copy_array(param->cur_value, &int_val, sizeof(int_val));
 }
 
-void gs_shader_set_float(gs_sparam_t param, float val)
+void gs_shader_set_float(gs_sparam_t *param, float val)
 {
 	da_copy_array(param->cur_value, &val, sizeof(val));
 }
 
-void gs_shader_set_int(gs_sparam_t param, int val)
+void gs_shader_set_int(gs_sparam_t *param, int val)
 {
 	da_copy_array(param->cur_value, &val, sizeof(val));
 }
 
-void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val)
+void gs_shader_setmatrix3(gs_sparam_t *param, const struct matrix3 *val)
 {
 	struct matrix4 mat;
 	matrix4_from_matrix3(&mat, val);
@@ -403,27 +403,27 @@ void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val)
 	da_copy_array(param->cur_value, &mat, sizeof(mat));
 }
 
-void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val)
+void gs_shader_set_matrix4(gs_sparam_t *param, const struct matrix4 *val)
 {
 	da_copy_array(param->cur_value, val, sizeof(*val));
 }
 
-void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val)
+void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val)
 {
 	da_copy_array(param->cur_value, val->ptr, sizeof(*val));
 }
 
-void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val)
+void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val)
 {
 	da_copy_array(param->cur_value, val->ptr, sizeof(*val));
 }
 
-void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val)
+void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val)
 {
 	da_copy_array(param->cur_value, val->ptr, sizeof(*val));
 }
 
-void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val)
+void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val)
 {
 	param->texture = val;
 }
@@ -681,7 +681,7 @@ void gs_program_destroy(struct gs_program *program)
 	bfree(program);
 }
 
-void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size)
+void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size)
 {
 	int count = param->array_count;
 	size_t expected_size = 0;
@@ -711,12 +711,12 @@ void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size)
 	}
 
 	if (param->type == GS_SHADER_PARAM_TEXTURE)
-		gs_shader_set_texture(param, *(gs_texture_t*)val);
+		gs_shader_set_texture(param, *(gs_texture_t**)val);
 	else
 		da_copy_array(param->cur_value, val, size);
 }
 
-void gs_shader_set_default(gs_sparam_t param)
+void gs_shader_set_default(gs_sparam_t *param)
 {
 	gs_shader_set_val(param, param->def_value.array, param->def_value.num);
 }

libobs-opengl/gl-stagesurf.c

@@ -42,7 +42,7 @@ static bool create_pixel_pack_buffer(struct gs_stage_surface *surf)
 	return success;
 }
 
-gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
+gs_stagesurf_t *device_stagesurface_create(gs_device_t *device, uint32_t width,
 		uint32_t height, enum gs_color_format color_format)
 {
 	struct gs_stage_surface *surf;
@@ -65,7 +65,7 @@ gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
 	return surf;
 }
 
-void gs_stagesurface_destroy(gs_stagesurf_t stagesurf)
+void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf)
 {
 	if (stagesurf) {
 		if (stagesurf->pack_buffer)
@@ -110,8 +110,8 @@ static bool can_stage(struct gs_stage_surface *dst, struct gs_texture_2d *src)
 
 /* Apparently for mac, PBOs won't do an asynchronous transfer unless you use
  * FBOs aong with glReadPixels, which is really dumb. */
-void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
-		gs_texture_t src)
+void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
+		gs_texture_t *src)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)src;
 	struct fbo_info *fbo;
@@ -156,8 +156,8 @@ failed:
 
 #else
 
-void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
-		gs_texture_t src)
+void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
+		gs_texture_t *src)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)src;
 	if (!can_stage(dst, tex2d))
@@ -186,22 +186,22 @@ failed:
 
 #endif
 
-uint32_t gs_stagesurface_get_width(gs_stagesurf_t stagesurf)
+uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
 {
 	return stagesurf->width;
 }
 
-uint32_t gs_stagesurface_get_height(gs_stagesurf_t stagesurf)
+uint32_t gs_stagesurface_get_height(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(gs_stagesurf_t *stagesurf)
 {
 	return stagesurf->format;
 }
 
-bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
+bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
 		uint32_t *linesize)
 {
 	if (!gl_bind_buffer(GL_PIXEL_PACK_BUFFER, stagesurf->pack_buffer))
@@ -221,7 +221,7 @@ fail:
 	return false;
 }
 
-void gs_stagesurface_unmap(gs_stagesurf_t stagesurf)
+void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf)
 {
 	if (!gl_bind_buffer(GL_PIXEL_PACK_BUFFER, stagesurf->pack_buffer))
 		return;

libobs-opengl/gl-subsystem.c

@@ -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, struct gs_init_data *info)
 {
 	struct gs_device *device = bzalloc(sizeof(struct gs_device));
 	int errorcode = GS_ERROR_FAIL;
@@ -221,7 +221,7 @@ fail:
 	return errorcode;
 }
 
-void device_destroy(gs_device_t device)
+void device_destroy(gs_device_t *device)
 {
 	if (device) {
 		size_t i;
@@ -239,7 +239,7 @@ void device_destroy(gs_device_t device)
 	}
 }
 
-gs_swapchain_t device_swapchain_create(gs_device_t device,
+gs_swapchain_t *device_swapchain_create(gs_device_t *device,
 		struct gs_init_data *info)
 {
 	struct gs_swap_chain *swap = bzalloc(sizeof(struct gs_swap_chain));
@@ -262,7 +262,7 @@ gs_swapchain_t device_swapchain_create(gs_device_t device,
 	return swap;
 }
 
-void device_resize(gs_device_t device, uint32_t cx, uint32_t cy)
+void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
 {
 	/* GL automatically resizes the device, so it doesn't do much */
 	device->cur_swap->info.cx = cx;
@@ -271,23 +271,23 @@ 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(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(gs_device_t *device)
 {
 	return device->cur_swap->info.cx;
 }
 
-uint32_t device_get_height(gs_device_t device)
+uint32_t device_get_height(gs_device_t *device)
 {
 	return device->cur_swap->info.cy;
 }
 
-gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
+gs_texture_t *device_voltexture_create(gs_device_t *device, uint32_t width,
 		uint32_t height, uint32_t depth,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
@@ -304,7 +304,7 @@ gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
 	return NULL;
 }
 
-gs_samplerstate_t device_samplerstate_create(gs_device_t device,
+gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
 		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(gs_texture_t *texture)
 {
 	return texture->type;
 }
@@ -350,7 +350,7 @@ static inline void apply_swizzle(struct gs_texture *tex)
 	}
 }
 
-static bool load_texture_sampler(gs_texture_t tex, gs_samplerstate_t ss)
+static bool load_texture_sampler(gs_texture_t *tex, gs_samplerstate_t *ss)
 {
 	bool  success = true;
 	GLint min_filter;
@@ -391,7 +391,7 @@ static bool load_texture_sampler(gs_texture_t tex, gs_samplerstate_t ss)
 	return success;
 }
 
-static inline struct gs_shader_param *get_texture_param(gs_device_t device,
+static inline struct gs_shader_param *get_texture_param(gs_device_t *device,
 		int unit)
 {
 	struct gs_shader *shader = device->cur_pixel_shader;
@@ -408,7 +408,7 @@ static inline struct gs_shader_param *get_texture_param(gs_device_t device,
 	return NULL;
 }
 
-void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
+void device_load_texture(gs_device_t *device, gs_texture_t *tex, int unit)
 {
 	struct gs_shader_param *param;
 	struct gs_sampler_state *sampler;
@@ -452,7 +452,7 @@ fail:
 	blog(LOG_ERROR, "device_load_texture (GL) failed");
 }
 
-static bool load_sampler_on_textures(gs_device_t device, gs_samplerstate_t ss,
+static bool load_sampler_on_textures(gs_device_t *device, gs_samplerstate_t *ss,
 		int sampler_unit)
 {
 	struct gs_shader *shader = device->cur_pixel_shader;
@@ -474,7 +474,7 @@ static bool load_sampler_on_textures(gs_device_t device, gs_samplerstate_t ss,
 	return true;
 }
 
-void device_load_samplerstate(gs_device_t device, gs_samplerstate_t ss,
+void device_load_samplerstate(gs_device_t *device, gs_samplerstate_t *ss,
 		int unit)
 {
 	/* need a pixel shader to properly bind samplers */
@@ -495,7 +495,7 @@ void device_load_samplerstate(gs_device_t device, gs_samplerstate_t ss,
 	return;
 }
 
-void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
+void device_load_vertexshader(gs_device_t *device, gs_shader_t *vertshader)
 {
 	if (device->cur_vertex_shader == vertshader)
 		return;
@@ -525,7 +525,7 @@ static void load_default_pixelshader_samplers(struct gs_device *device,
 		device->cur_samplers[i] = NULL;
 }
 
-void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
+void device_load_pixelshader(gs_device_t *device, gs_shader_t *pixelshader)
 {
 	if (device->cur_pixel_shader == pixelshader)
 		return;
@@ -547,7 +547,7 @@ fail:
 	blog(LOG_ERROR, "device_load_pixelshader (GL) failed");
 }
 
-void device_load_default_samplerstate(gs_device_t device, bool b_3d, int unit)
+void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit)
 {
 	/* TODO */
 	UNUSED_PARAMETER(device);
@@ -555,27 +555,27 @@ 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(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(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(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(gs_device_t *device)
 {
 	return device->cur_zstencil_buffer;
 }
 
-static bool get_tex_dimensions(gs_texture_t tex, uint32_t *width,
+static bool get_tex_dimensions(gs_texture_t *tex, uint32_t *width,
 		uint32_t *height)
 {
 	if (tex->type == GS_TEXTURE_2D) {
@@ -632,7 +632,7 @@ struct fbo_info *get_fbo(struct gs_device *device,
 }
 
 static inline struct fbo_info *get_fbo_by_tex(struct gs_device *device,
-		gs_texture_t tex)
+		gs_texture_t *tex)
 {
 	uint32_t width, height;
 	if (!get_tex_dimensions(tex, &width, &height))
@@ -641,7 +641,7 @@ static inline struct fbo_info *get_fbo_by_tex(struct gs_device *device,
 	return get_fbo(device, width, height, tex->format);
 }
 
-static bool set_current_fbo(gs_device_t device, struct fbo_info *fbo)
+static bool set_current_fbo(gs_device_t *device, struct fbo_info *fbo)
 {
 	if (device->cur_fbo != fbo) {
 		GLuint fbo_obj = fbo ? fbo->fbo : 0;
@@ -653,7 +653,7 @@ static bool set_current_fbo(gs_device_t device, struct fbo_info *fbo)
 	return true;
 }
 
-static bool attach_rendertarget(struct fbo_info *fbo, gs_texture_t tex,
+static bool attach_rendertarget(struct fbo_info *fbo, gs_texture_t *tex,
 		int side)
 {
 	if (fbo->cur_render_target == tex)
@@ -679,7 +679,7 @@ static bool attach_rendertarget(struct fbo_info *fbo, gs_texture_t tex,
 	return gl_success("glFramebufferTexture2D");
 }
 
-static bool attach_zstencil(struct fbo_info *fbo, gs_zstencil_t zs)
+static bool attach_zstencil(struct fbo_info *fbo, gs_zstencil_t *zs)
 {
 	GLuint zsbuffer = 0;
 	GLenum zs_attachment = GL_DEPTH_STENCIL_ATTACHMENT;
@@ -702,8 +702,8 @@ static bool attach_zstencil(struct fbo_info *fbo, gs_zstencil_t zs)
 	return true;
 }
 
-static bool set_target(gs_device_t device, gs_texture_t tex, int side,
-		gs_zstencil_t zs)
+static bool set_target(gs_device_t *device, gs_texture_t *tex, int side,
+		gs_zstencil_t *zs)
 {
 	struct fbo_info *fbo;
 
@@ -733,8 +733,8 @@ static bool set_target(gs_device_t device, gs_texture_t tex, int side,
 	return true;
 }
 
-void device_set_render_target(gs_device_t device, gs_texture_t tex,
-		gs_zstencil_t zstencil)
+void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
+		gs_zstencil_t *zstencil)
 {
 	if (tex) {
 		if (tex->type != GS_TEXTURE_2D) {
@@ -757,8 +757,8 @@ fail:
 	blog(LOG_ERROR, "device_set_render_target (GL) failed");
 }
 
-void device_set_cube_render_target(gs_device_t device, gs_texture_t cubetex,
-		int side, gs_zstencil_t zstencil)
+void device_set_cube_render_target(gs_device_t *device, gs_texture_t *cubetex,
+		int side, gs_zstencil_t *zstencil)
 {
 	if (cubetex) {
 		if (cubetex->type != GS_TEXTURE_CUBE) {
@@ -781,9 +781,9 @@ fail:
 	blog(LOG_ERROR, "device_set_cube_render_target (GL) failed");
 }
 
-void device_copy_texture_region(gs_device_t device,
-		gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
+void device_copy_texture_region(gs_device_t *device,
+		gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+		gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h)
 {
 	struct gs_texture_2d *src2d = (struct gs_texture_2d*)src;
@@ -810,8 +810,10 @@ void device_copy_texture_region(gs_device_t device,
 		goto fail;
 	}
 
-	uint32_t nw = (uint32_t)src_w ? (uint32_t)src_w : (src2d->width - src_x);
-	uint32_t nh = (uint32_t)src_h ? (uint32_t)src_h : (src2d->height - src_y);
+	uint32_t nw = (uint32_t)src_w ?
+		(uint32_t)src_w : (src2d->width - src_x);
+	uint32_t nh = (uint32_t)src_h ?
+		(uint32_t)src_h : (src2d->height - src_y);
 
 	if (dst2d->width - dst_x < nw || dst2d->height - dst_y < nh) {
 		blog(LOG_ERROR, "Destination texture region is not big "
@@ -830,17 +832,18 @@ fail:
 	blog(LOG_ERROR, "device_copy_texture (GL) failed");
 }
 
-void device_copy_texture(gs_device_t device, gs_texture_t dst, gs_texture_t src)
+void device_copy_texture(gs_device_t *device, gs_texture_t *dst,
+		gs_texture_t *src)
 {
 	device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
 }
 
-void device_begin_scene(gs_device_t device)
+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(gs_device_t *device)
 {
 	if (!device->cur_vertex_shader) {
 		blog(LOG_ERROR, "No vertex shader specified");
@@ -898,12 +901,12 @@ static inline struct gs_program *get_shader_program(struct gs_device *device)
 	return program;
 }
 
-void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
+void device_draw(gs_device_t *device, enum gs_draw_mode draw_mode,
 		uint32_t start_vert, uint32_t num_verts)
 {
 	struct gs_index_buffer *ib = device->cur_index_buffer;
 	GLenum  topology = convert_gs_topology(draw_mode);
-	gs_effect_t effect = gs_get_effect();
+	gs_effect_t *effect = gs_get_effect();
 	struct gs_program *program;
 
 	if (!can_render(device))
@@ -957,13 +960,13 @@ fail:
 	blog(LOG_ERROR, "device_draw (GL) failed");
 }
 
-void device_end_scene(gs_device_t device)
+void device_end_scene(gs_device_t *device)
 {
 	/* does nothing */
 	UNUSED_PARAMETER(device);
 }
 
-void device_clear(gs_device_t device, uint32_t clear_flags,
+void device_clear(gs_device_t *device, uint32_t clear_flags,
 		struct vec4 *color, float depth, uint8_t stencil)
 {
 	GLbitfield gl_flags = 0;
@@ -990,14 +993,14 @@ void device_clear(gs_device_t device, uint32_t clear_flags,
 	UNUSED_PARAMETER(device);
 }
 
-void device_flush(gs_device_t device)
+void device_flush(gs_device_t *device)
 {
 	glFlush();
 
 	UNUSED_PARAMETER(device);
 }
 
-void device_set_cull_mode(gs_device_t device, enum gs_cull_mode mode)
+void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode)
 {
 	if (device->cur_cull_mode == mode)
 		return;
@@ -1015,12 +1018,12 @@ 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(gs_device_t *device)
 {
 	return device->cur_cull_mode;
 }
 
-void device_enable_blending(gs_device_t device, bool enable)
+void device_enable_blending(gs_device_t *device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_BLEND);
@@ -1030,7 +1033,7 @@ void device_enable_blending(gs_device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_depth_test(gs_device_t device, bool enable)
+void device_enable_depth_test(gs_device_t *device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_DEPTH_TEST);
@@ -1040,7 +1043,7 @@ void device_enable_depth_test(gs_device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_stencil_test(gs_device_t device, bool enable)
+void device_enable_stencil_test(gs_device_t *device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_STENCIL_TEST);
@@ -1050,7 +1053,7 @@ void device_enable_stencil_test(gs_device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_stencil_write(gs_device_t device, bool enable)
+void device_enable_stencil_write(gs_device_t *device, bool enable)
 {
 	if (enable)
 		glStencilMask(0xFFFFFFFF);
@@ -1060,7 +1063,7 @@ void device_enable_stencil_write(gs_device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_color(gs_device_t device, bool red, bool green,
+void device_enable_color(gs_device_t *device, bool red, bool green,
 		bool blue, bool alpha)
 {
 	glColorMask(red, green, blue, alpha);
@@ -1068,7 +1071,7 @@ void device_enable_color(gs_device_t device, bool red, bool green,
 	UNUSED_PARAMETER(device);
 }
 
-void device_blend_function(gs_device_t device, enum gs_blend_type src,
+void device_blend_function(gs_device_t *device, enum gs_blend_type src,
 		enum gs_blend_type dest)
 {
 	GLenum gl_src = convert_gs_blend_type(src);
@@ -1081,7 +1084,7 @@ void device_blend_function(gs_device_t device, enum gs_blend_type src,
 	UNUSED_PARAMETER(device);
 }
 
-void device_depth_function(gs_device_t device, enum gs_depth_test test)
+void device_depth_function(gs_device_t *device, enum gs_depth_test test)
 {
 	GLenum gl_test = convert_gs_depth_test(test);
 
@@ -1092,7 +1095,7 @@ void device_depth_function(gs_device_t device, enum gs_depth_test test)
 	UNUSED_PARAMETER(device);
 }
 
-void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
+void device_stencil_function(gs_device_t *device, enum gs_stencil_side side,
 		enum gs_depth_test test)
 {
 	GLenum gl_side = convert_gs_stencil_side(side);
@@ -1105,7 +1108,7 @@ void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
 	UNUSED_PARAMETER(device);
 }
 
-void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
+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)
 {
@@ -1132,7 +1135,7 @@ static inline uint32_t get_target_height(struct gs_device *device)
 		return gs_cubetexture_get_size(device->cur_render_target);
 }
 
-void device_set_viewport(gs_device_t device, int x, int y, int width,
+void device_set_viewport(gs_device_t *device, int x, int y, int width,
 		int height)
 {
 	uint32_t base_height;
@@ -1155,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(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, struct gs_rect *rect)
 {
 	UNUSED_PARAMETER(device);
 
@@ -1176,7 +1179,7 @@ void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect)
 	blog(LOG_ERROR, "device_set_scissor_rect (GL) failed");
 }
 
-void device_ortho(gs_device_t device, float left, float right,
+void device_ortho(gs_device_t *device, float left, float right,
 		float top, float bottom, float near, float far)
 {
 	struct matrix4 *dst = &device->cur_proj;
@@ -1202,7 +1205,7 @@ void device_ortho(gs_device_t device, float left, float right,
 	dst->t.w = 1.0f;
 }
 
-void device_frustum(gs_device_t device, float left, float right,
+void device_frustum(gs_device_t *device, float left, float right,
 		float top, float bottom, float near, float far)
 {
 	struct matrix4 *dst = &device->cur_proj;
@@ -1229,12 +1232,12 @@ void device_frustum(gs_device_t device, float left, float right,
 	dst->z.w = -1.0f;
 }
 
-void device_projection_push(gs_device_t device)
+void device_projection_push(gs_device_t *device)
 {
 	da_push_back(device->proj_stack, &device->cur_proj);
 }
 
-void device_projection_pop(gs_device_t device)
+void device_projection_pop(gs_device_t *device)
 {
 	struct matrix4 *end;
 	if (!device->proj_stack.num)
@@ -1245,7 +1248,7 @@ void device_projection_pop(gs_device_t device)
 	da_pop_back(device->proj_stack);
 }
 
-void gs_swapchain_destroy(gs_swapchain_t swapchain)
+void gs_swapchain_destroy(gs_swapchain_t *swapchain)
 {
 	if (!swapchain)
 		return;
@@ -1259,41 +1262,41 @@ void gs_swapchain_destroy(gs_swapchain_t swapchain)
 	bfree(swapchain);
 }
 
-void gs_voltexture_destroy(gs_texture_t voltex)
+void gs_voltexture_destroy(gs_texture_t *voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 }
 
-uint32_t gs_voltexture_get_width(gs_texture_t voltex)
+uint32_t gs_voltexture_get_width(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(gs_texture_t *voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return 0;
 }
 
-uint32_t gs_voltexture_getdepth(gs_texture_t voltex)
+uint32_t gs_voltexture_getdepth(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(gs_texture_t *voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return GS_UNKNOWN;
 }
 
-void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
+void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate)
 {
 	if (!samplerstate)
 		return;

libobs-opengl/gl-subsystem.h

@@ -273,7 +273,7 @@ extern void convert_sampler_info(struct gs_sampler_state *sampler,
 		struct gs_sampler_info *info);
 
 struct gs_sampler_state {
-	gs_device_t          device;
+	gs_device_t          *device;
 	volatile long        ref;
 
 	GLint                min_filter;
@@ -284,12 +284,12 @@ struct gs_sampler_state {
 	GLint                max_anisotropy;
 };
 
-static inline void samplerstate_addref(gs_samplerstate_t ss)
+static inline void samplerstate_addref(gs_samplerstate_t *ss)
 {
 	os_atomic_inc_long(&ss->ref);
 }
 
-static inline void samplerstate_release(gs_samplerstate_t ss)
+static inline void samplerstate_release(gs_samplerstate_t *ss)
 {
 	if (os_atomic_dec_long(&ss->ref) == 0)
 		bfree(ss);
@@ -299,7 +299,7 @@ struct gs_shader_param {
 	enum gs_shader_param_type type;
 
 	char                 *name;
-	gs_shader_t          shader;
+	gs_shader_t          *shader;
 	GLint                texture_id;
 	size_t               sampler_id;
 	int                  array_count;
@@ -327,7 +327,7 @@ struct shader_attrib {
 };
 
 struct gs_shader {
-	gs_device_t          device;
+	gs_device_t          *device;
 	enum gs_shader_type  type;
 	GLuint               obj;
 
@@ -336,7 +336,7 @@ struct gs_shader {
 
 	DARRAY(struct shader_attrib)   attribs;
 	DARRAY(struct gs_shader_param) params;
-	DARRAY(gs_samplerstate_t)      samplers;
+	DARRAY(gs_samplerstate_t*)      samplers;
 };
 
 struct program_param {
@@ -345,7 +345,7 @@ struct program_param {
 };
 
 struct gs_program {
-	gs_device_t                  device;
+	gs_device_t                  *device;
 	GLuint                       obj;
 	struct gs_shader             *vertex_shader;
 	struct gs_shader             *pixel_shader;
@@ -370,7 +370,7 @@ struct gs_vertex_buffer {
 	DARRAY(GLuint)       uv_buffers;
 	DARRAY(size_t)       uv_sizes;
 
-	gs_device_t          device;
+	gs_device_t          *device;
 	size_t               num;
 	bool                 dynamic;
 	struct gs_vb_data    *data;
@@ -384,7 +384,7 @@ struct gs_index_buffer {
 	enum gs_index_type   type;
 	GLuint               gl_type;
 
-	gs_device_t          device;
+	gs_device_t          *device;
 	void                 *data;
 	size_t               num;
 	size_t               width;
@@ -393,7 +393,7 @@ struct gs_index_buffer {
 };
 
 struct gs_texture {
-	gs_device_t          device;
+	gs_device_t          *device;
 	enum gs_texture_type type;
 	enum gs_color_format format;
 	GLenum               gl_format;
@@ -407,7 +407,7 @@ struct gs_texture {
 	bool                 is_dummy;
 	bool                 gen_mipmaps;
 
-	gs_samplerstate_t    cur_sampler;
+	gs_samplerstate_t    *cur_sampler;
 };
 
 struct gs_texture_2d {
@@ -426,7 +426,7 @@ struct gs_texture_cube {
 };
 
 struct gs_stage_surface {
-	gs_device_t          device;
+	gs_device_t          *device;
 
 	enum gs_color_format format;
 	uint32_t             width;
@@ -440,14 +440,14 @@ struct gs_stage_surface {
 };
 
 struct gs_zstencil_buffer {
-	gs_device_t          device;
+	gs_device_t          *device;
 	GLuint               buffer;
 	GLuint               attachment;
 	GLenum               format;
 };
 
 struct gs_swap_chain {
-	gs_device_t             device;
+	gs_device_t             *device;
 	struct gl_windowinfo *wi;
 	struct gs_init_data  info;
 };
@@ -458,9 +458,9 @@ struct fbo_info {
 	uint32_t             height;
 	enum gs_color_format format;
 
-	gs_texture_t         cur_render_target;
+	gs_texture_t         *cur_render_target;
 	int                  cur_render_side;
-	gs_zstencil_t        cur_zstencil_buffer;
+	gs_zstencil_t        *cur_zstencil_buffer;
 };
 
 static inline void fbo_info_destroy(struct fbo_info *fbo)
@@ -477,16 +477,16 @@ struct gs_device {
 	struct gl_platform   *plat;
 	enum copy_type       copy_type;
 
-	gs_texture_t         cur_render_target;
-	gs_zstencil_t        cur_zstencil_buffer;
+	gs_texture_t         *cur_render_target;
+	gs_zstencil_t        *cur_zstencil_buffer;
 	int                  cur_render_side;
-	gs_texture_t         cur_textures[GS_MAX_TEXTURES];
-	gs_samplerstate_t    cur_samplers[GS_MAX_TEXTURES];
-	gs_vertbuffer_t      cur_vertex_buffer;
-	gs_indexbuffer_t     cur_index_buffer;
-	gs_shader_t          cur_vertex_shader;
-	gs_shader_t          cur_pixel_shader;
-	gs_swapchain_t       cur_swap;
+	gs_texture_t         *cur_textures[GS_MAX_TEXTURES];
+	gs_samplerstate_t    *cur_samplers[GS_MAX_TEXTURES];
+	gs_vertbuffer_t      *cur_vertex_buffer;
+	gs_indexbuffer_t     *cur_index_buffer;
+	gs_shader_t          *cur_vertex_shader;
+	gs_shader_t          *cur_pixel_shader;
+	gs_swapchain_t       *cur_swap;
 	struct gs_program    *cur_program;
 
 	struct gs_program    *first_program;
@@ -507,9 +507,9 @@ struct gs_device {
 extern struct fbo_info *get_fbo(struct gs_device *device,
 		uint32_t width, uint32_t height, enum gs_color_format format);
 
-extern void                  gl_update(gs_device_t device);
+extern void                  gl_update(gs_device_t *device);
 
-extern struct gl_platform   *gl_platform_create(gs_device_t device,
+extern struct gl_platform   *gl_platform_create(gs_device_t *device,
                                                 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);

libobs-opengl/gl-texture2d.c

@@ -74,7 +74,7 @@ static bool create_pixel_unpack_buffer(struct gs_texture_2d *tex)
 	return success;
 }
 
-gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
+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)
 {
@@ -104,15 +104,15 @@ gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
 			goto fail;
 	}
 
-	return (gs_texture_t)tex;
+	return (gs_texture_t*)tex;
 
 fail:
-	gs_texture_destroy((gs_texture_t)tex);
+	gs_texture_destroy((gs_texture_t*)tex);
 	blog(LOG_ERROR, "device_texture_create (GL) failed");
 	return NULL;
 }
 
-static inline bool is_texture_2d(gs_texture_t tex, const char *func)
+static inline bool is_texture_2d(gs_texture_t *tex, const char *func)
 {
 	bool is_tex2d = tex->type == GS_TEXTURE_2D;
 	if (!is_tex2d)
@@ -120,7 +120,7 @@ static inline bool is_texture_2d(gs_texture_t tex, const char *func)
 	return is_tex2d;
 }
 
-void gs_texture_destroy(gs_texture_t tex)
+void gs_texture_destroy(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!tex)
@@ -141,7 +141,7 @@ 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(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!is_texture_2d(tex, "gs_texture_get_width"))
@@ -150,7 +150,7 @@ uint32_t gs_texture_get_width(gs_texture_t tex)
 	return tex2d->width;
 }
 
-uint32_t gs_texture_get_height(gs_texture_t tex)
+uint32_t gs_texture_get_height(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!is_texture_2d(tex, "gs_texture_get_height"))
@@ -159,12 +159,12 @@ uint32_t gs_texture_get_height(gs_texture_t tex)
 	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(gs_texture_t *tex)
 {
 	return tex->format;
 }
 
-bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
+bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr, uint32_t *linesize)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 
@@ -194,7 +194,7 @@ fail:
 	return false;
 }
 
-void gs_texture_unmap(gs_texture_t tex)
+void gs_texture_unmap(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!is_texture_2d(tex, "gs_texture_unmap"))
@@ -226,7 +226,7 @@ failed:
 	blog(LOG_ERROR, "gs_texture_unmap (GL) failed");
 }
 
-bool gs_texture_is_rect(gs_texture_t tex)
+bool gs_texture_is_rect(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!is_texture_2d(tex, "gs_texture_unmap")) {
@@ -237,7 +237,7 @@ bool gs_texture_is_rect(gs_texture_t tex)
 	return tex2d->base.gl_target == GL_TEXTURE_RECTANGLE;
 }
 
-void *gs_texture_get_obj(gs_texture_t tex)
+void *gs_texture_get_obj(gs_texture_t *tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!is_texture_2d(tex, "gs_texture_unmap")) {

libobs-opengl/gl-texturecube.c

@@ -58,7 +58,7 @@ static inline bool upload_texture_cube(struct gs_texture_cube *tex,
 	return success;
 }
 
-gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
+gs_texture_t *device_cubetexture_create(gs_device_t *device, uint32_t size,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
 {
@@ -79,15 +79,15 @@ gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
 	if (!upload_texture_cube(tex, data))
 		goto fail;
 
-	return (gs_texture_t)tex;
+	return (gs_texture_t*)tex;
 
 fail:
-	gs_cubetexture_destroy((gs_texture_t)tex);
+	gs_cubetexture_destroy((gs_texture_t*)tex);
 	blog(LOG_ERROR, "device_cubetexture_create (GL) failed");
 	return NULL;
 }
 
-void gs_cubetexture_destroy(gs_texture_t tex)
+void gs_cubetexture_destroy(gs_texture_t *tex)
 {
 	if (!tex)
 		return;
@@ -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(gs_texture_t *tex, const char *func)
 {
 	bool is_texcube = tex->type == GS_TEXTURE_CUBE;
 	if (!is_texcube)
@@ -108,7 +108,7 @@ 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(gs_texture_t *cubetex)
 {
 	struct gs_texture_cube *cube = (struct gs_texture_cube*)cubetex;
 	if (!is_texture_cube(cubetex, "gs_cubetexture_get_size"))
@@ -117,7 +117,7 @@ uint32_t gs_cubetexture_get_size(gs_texture_t cubetex)
 	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(gs_texture_t *cubetex)
 {
 	return cubetex->format;
 }

libobs-opengl/gl-vertexbuffer.c

@@ -76,7 +76,7 @@ static bool create_buffers(struct gs_vertex_buffer *vb)
 	return true;
 }
 
-gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
+gs_vertbuffer_t *device_vertexbuffer_create(gs_device_t *device,
 		struct gs_vb_data *data, uint32_t flags)
 {
 	struct gs_vertex_buffer *vb = bzalloc(sizeof(struct gs_vertex_buffer));
@@ -94,7 +94,7 @@ gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
 	return vb;
 }
 
-void gs_vertexbuffer_destroy(gs_vertbuffer_t vb)
+void gs_vertexbuffer_destroy(gs_vertbuffer_t *vb)
 {
 	if (vb) {
 		if (vb->vertex_buffer)
@@ -120,7 +120,7 @@ void gs_vertexbuffer_destroy(gs_vertbuffer_t vb)
 	}
 }
 
-void gs_vertexbuffer_flush(gs_vertbuffer_t vb)
+void gs_vertexbuffer_flush(gs_vertbuffer_t *vb)
 {
 	size_t i;
 
@@ -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(gs_vertbuffer_t *vb)
 {
 	return vb->data;
 }
@@ -251,7 +251,7 @@ bool load_vb_buffers(struct gs_program *program, struct gs_vertex_buffer *vb)
 	return true;
 }
 
-void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vb)
+void device_load_vertexbuffer(gs_device_t *device, gs_vertbuffer_t *vb)
 {
 	device->cur_vertex_buffer = vb;
 }

libobs-opengl/gl-windows.c

@@ -350,7 +350,7 @@ static struct gl_windowinfo *gl_windowinfo_bare(struct gs_init_data *info)
 	return wi;
 }
 
-static bool init_default_swap(struct gl_platform *plat, gs_device_t device,
+static bool init_default_swap(struct gl_platform *plat, gs_device_t *device,
 		int pixel_format, PIXELFORMATDESCRIPTOR *pfd,
 		struct gs_init_data *info)
 {
@@ -366,13 +366,13 @@ static bool init_default_swap(struct gl_platform *plat, gs_device_t device,
 	return true;
 }
 
-void gl_update(gs_device_t device)
+void gl_update(gs_device_t *device)
 {
 	/* does nothing on windows */
 	UNUSED_PARAMETER(device);
 }
 
-struct gl_platform *gl_platform_create(gs_device_t device,
+struct gl_platform *gl_platform_create(gs_device_t *device,
 		struct gs_init_data *info)
 {
 	struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
@@ -475,7 +475,7 @@ void gl_windowinfo_destroy(struct gl_windowinfo *wi)
 	}
 }
 
-void device_enter_context(gs_device_t device)
+void device_enter_context(gs_device_t *device)
 {
 	HDC hdc = device->plat->swap.wi->hdc;
 	if (device->cur_swap)
@@ -485,13 +485,13 @@ void device_enter_context(gs_device_t device)
 		blog(LOG_ERROR, "device_load_swapchain (GL) failed");
 }
 
-void device_leave_context(gs_device_t device)
+void device_leave_context(gs_device_t *device)
 {
 	wglMakeCurrent(NULL, NULL);
 	UNUSED_PARAMETER(device);
 }
 
-void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
+void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap)
 {
 	HDC hdc;
 	if (!swap)
@@ -510,7 +510,7 @@ void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 	}
 }
 
-void device_present(gs_device_t device)
+void device_present(gs_device_t *device)
 {
 	if (!SwapBuffers(device->cur_swap->wi->hdc)) {
 		blog(LOG_ERROR, "SwapBuffers failed, GetLastError "

libobs-opengl/gl-x11.c

@@ -135,7 +135,7 @@ static bool handle_x_error(Display *disp, const char *error_string)
 	return false;
 }
 
-struct gl_platform *gl_platform_create(gs_device_t device,
+struct gl_platform *gl_platform_create(gs_device_t *device,
 		struct gs_init_data *info)
 {
 	int num_configs = 0;
@@ -366,7 +366,7 @@ void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
 	info->int_id = 0;
 }
 
-void device_enter_context(gs_device_t device)
+void device_enter_context(gs_device_t *device)
 {
 	GLXContext context = device->plat->context;
 	XID window = device->cur_swap->wi->glxid;
@@ -377,7 +377,7 @@ void device_enter_context(gs_device_t device)
 	}
 }
 
-void device_leave_context(gs_device_t device)
+void device_leave_context(gs_device_t *device)
 {
 	Display *display = device->cur_swap->wi->display;
 
@@ -386,7 +386,7 @@ void device_leave_context(gs_device_t device)
 	}
 }
 
-void gl_update(gs_device_t device)
+void gl_update(gs_device_t *device)
 {
 	Display *display = device->cur_swap->wi->display;
 	XID window = device->cur_swap->wi->int_id;
@@ -395,7 +395,7 @@ void gl_update(gs_device_t device)
 			device->cur_swap->info.cx, device->cur_swap->info.cy);
 }
 
-void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
+void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swap)
 {
 	if (!swap)
 		swap = &device->plat->swap;
@@ -414,7 +414,7 @@ void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 	}
 }
 
-void device_present(gs_device_t device)
+void device_present(gs_device_t *device)
 {
 	Display *display = device->cur_swap->wi->display;
 	XID window = device->cur_swap->wi->glxid;

libobs-opengl/gl-zstencil.c

@@ -48,7 +48,7 @@ static inline GLenum get_attachment(enum gs_zstencil_format format)
 	return 0;
 }
 
-gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
+gs_zstencil_t *device_zstencil_create(gs_device_t *device, uint32_t width,
 		uint32_t height, enum gs_zstencil_format format)
 {
 	struct gs_zstencil_buffer *zs;
@@ -67,7 +67,7 @@ gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
 	return zs;
 }
 
-void gs_zstencil_destroy(gs_zstencil_t zs)
+void gs_zstencil_destroy(gs_zstencil_t *zs)
 {
 	if (zs) {
 		if (zs->buffer) {

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(calldata_t *data, const char *name,
 		uint8_t **pos)
 {
 	size_t name_size;
@@ -114,7 +114,7 @@ static inline void cd_copy_data(uint8_t **pos, const void *in, size_t size)
 	}
 }
 
-static inline void cd_set_first_param(calldata_t data, const char *name,
+static inline void cd_set_first_param(calldata_t *data, const char *name,
 		const void *in, size_t size)
 {
 	uint8_t *pos;
@@ -136,7 +136,7 @@ static inline void cd_set_first_param(calldata_t data, const char *name,
 	*(size_t*)pos = 0;
 }
 
-static inline void cd_ensure_capacity(calldata_t data, uint8_t **pos,
+static inline void cd_ensure_capacity(calldata_t *data, uint8_t **pos,
 		size_t new_size)
 {
 	size_t offset;
@@ -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(calldata_t *data, const char *name, void *out,
 		size_t size)
 {
 	uint8_t *pos;
@@ -179,7 +179,7 @@ bool calldata_get_data(calldata_t data, const char *name, void *out,
 	return true;
 }
 
-void calldata_set_data(calldata_t data, const char *name, const void *in,
+void calldata_set_data(calldata_t *data, const char *name, const void *in,
 		size_t size)
 {
 	uint8_t *pos = NULL;
@@ -225,7 +225,7 @@ 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(calldata_t *data, const char *name, const char **str)
 {
 	uint8_t *pos;
 	if (!data || !name || !*name)

libobs/callback/calldata.h

@@ -49,7 +49,7 @@ struct calldata {
 	uint8_t *stack;
 };
 
-typedef struct calldata *calldata_t;
+typedef struct calldata calldata_t;
 
 static inline void calldata_init(struct calldata *data)
 {
@@ -61,10 +61,10 @@ static inline void calldata_free(struct calldata *data)
 	bfree(data->stack);
 }
 
-EXPORT bool calldata_get_data(calldata_t data, const char *name, void *out,
+EXPORT bool calldata_get_data(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);
+EXPORT void calldata_set_data(calldata_t *data, const char *name,
+		const void *in, size_t new_size);
 
 static inline void calldata_clear(struct calldata *data)
 {
@@ -78,65 +78,65 @@ 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(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 (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  (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   (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(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(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(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(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(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(calldata_t *data, const char *name)
 {
 	const char *val;
 	calldata_get_string(data, name, &val);
@@ -145,31 +145,31 @@ static inline const char *calldata_string(calldata_t data, const char *name)
 
 /* ------------------------------------------------------------------------- */
 
-static inline void calldata_set_int   (calldata_t data, const char *name,
+static inline void calldata_set_int   (calldata_t *data, const char *name,
 		long long val)
 {
 	calldata_set_data(data, name, &val, sizeof(val));
 }
 
-static inline void calldata_set_float (calldata_t data, const char *name,
+static inline void calldata_set_float (calldata_t *data, const char *name,
 		double val)
 {
 	calldata_set_data(data, name, &val, sizeof(val));
 }
 
-static inline void calldata_set_bool  (calldata_t data, const char *name,
+static inline void calldata_set_bool  (calldata_t *data, const char *name,
 		bool val)
 {
 	calldata_set_data(data, name, &val, sizeof(val));
 }
 
-static inline void calldata_set_ptr   (calldata_t data, const char *name,
+static inline void calldata_set_ptr   (calldata_t *data, const char *name,
 		void *ptr)
 {
 	calldata_set_data(data, name, &ptr, sizeof(ptr));
 }
 
-static inline void calldata_set_string(calldata_t data, const char *name,
+static inline void calldata_set_string(calldata_t *data, const char *name,
 		const char *str)
 {
 	if (str)

libobs/callback/proc.c

@@ -35,14 +35,14 @@ struct proc_handler {
 	DARRAY(struct proc_info) procs;
 };
 
-proc_handler_t proc_handler_create(void)
+proc_handler_t *proc_handler_create(void)
 {
 	struct proc_handler *handler = bmalloc(sizeof(struct proc_handler));
 	da_init(handler->procs);
 	return handler;
 }
 
-void proc_handler_destroy(proc_handler_t handler)
+void proc_handler_destroy(proc_handler_t *handler)
 {
 	if (handler) {
 		for (size_t i = 0; i < handler->procs.num; i++)
@@ -52,7 +52,7 @@ void proc_handler_destroy(proc_handler_t handler)
 	}
 }
 
-void proc_handler_add(proc_handler_t handler, const char *decl_string,
+void proc_handler_add(proc_handler_t *handler, const char *decl_string,
 		proc_handler_proc_t proc, void *data)
 {
 	if (!handler) return;
@@ -72,8 +72,8 @@ void proc_handler_add(proc_handler_t handler, const char *decl_string,
 	da_push_back(handler->procs, &pi);
 }
 
-bool proc_handler_call(proc_handler_t handler, const char *name,
-		calldata_t params)
+bool proc_handler_call(proc_handler_t *handler, const char *name,
+		calldata_t *params)
 {
 	if (!handler) return false;
 

libobs/callback/proc.h

@@ -33,21 +33,21 @@ extern "C" {
  */
 
 struct proc_handler;
-typedef struct proc_handler *proc_handler_t;
-typedef void (*proc_handler_proc_t)(void*, calldata_t);
+typedef struct proc_handler proc_handler_t;
+typedef void (*proc_handler_proc_t)(void*, calldata_t*);
 
-EXPORT proc_handler_t proc_handler_create(void);
-EXPORT void proc_handler_destroy(proc_handler_t handler);
+EXPORT proc_handler_t *proc_handler_create(void);
+EXPORT void proc_handler_destroy(proc_handler_t *handler);
 
-EXPORT void proc_handler_add(proc_handler_t handler, const char *decl_string,
+EXPORT void proc_handler_add(proc_handler_t *handler, const char *decl_string,
 		proc_handler_proc_t proc, void *data);
 
 /**
  * Calls a function in a procedure handler.  Returns false if the named
  * procedure is not found.
  */
-EXPORT bool proc_handler_call(proc_handler_t handler, const char *name,
-		calldata_t params);
+EXPORT bool proc_handler_call(proc_handler_t *handler, const char *name,
+		calldata_t *params);
 
 #ifdef __cplusplus
 }

libobs/callback/signal.c

@@ -91,7 +91,7 @@ struct signal_handler {
 	pthread_mutex_t    mutex;
 };
 
-static struct signal_info *getsignal(signal_handler_t handler,
+static struct signal_info *getsignal(signal_handler_t *handler,
 		const char *name, struct signal_info **p_last)
 {
 	struct signal_info *signal, *last= NULL;
@@ -112,7 +112,7 @@ static struct signal_info *getsignal(signal_handler_t handler,
 
 /* ------------------------------------------------------------------------- */
 
-signal_handler_t signal_handler_create(void)
+signal_handler_t *signal_handler_create(void)
 {
 	struct signal_handler *handler = bmalloc(sizeof(struct signal_handler));
 	handler->first = NULL;
@@ -126,7 +126,7 @@ signal_handler_t signal_handler_create(void)
 	return handler;
 }
 
-void signal_handler_destroy(signal_handler_t handler)
+void signal_handler_destroy(signal_handler_t *handler)
 {
 	if (handler) {
 		struct signal_info *sig = handler->first;
@@ -141,7 +141,7 @@ void signal_handler_destroy(signal_handler_t handler)
 	}
 }
 
-bool signal_handler_add(signal_handler_t handler, const char *signal_decl)
+bool signal_handler_add(signal_handler_t *handler, const char *signal_decl)
 {
 	struct decl_info func = {0};
 	struct signal_info *sig, *last;
@@ -172,7 +172,7 @@ bool signal_handler_add(signal_handler_t handler, const char *signal_decl)
 	return success;
 }
 
-void signal_handler_connect(signal_handler_t handler, const char *signal,
+void signal_handler_connect(signal_handler_t *handler, const char *signal,
 		signal_callback_t callback, void *data)
 {
 	struct signal_info *sig, *last;
@@ -203,7 +203,7 @@ void signal_handler_connect(signal_handler_t handler, const char *signal,
 	pthread_mutex_unlock(&sig->mutex);
 }
 
-static inline struct signal_info *getsignal_locked(signal_handler_t handler,
+static inline struct signal_info *getsignal_locked(signal_handler_t *handler,
 		const char *name)
 {
 	struct signal_info *sig;
@@ -218,7 +218,7 @@ static inline struct signal_info *getsignal_locked(signal_handler_t handler,
 	return sig;
 }
 
-void signal_handler_disconnect(signal_handler_t handler, const char *signal,
+void signal_handler_disconnect(signal_handler_t *handler, const char *signal,
 		signal_callback_t callback, void *data)
 {
 	struct signal_info *sig = getsignal_locked(handler, signal);
@@ -240,8 +240,8 @@ void signal_handler_disconnect(signal_handler_t handler, const char *signal,
 	pthread_mutex_unlock(&sig->mutex);
 }
 
-void signal_handler_signal(signal_handler_t handler, const char *signal,
-		calldata_t params)
+void signal_handler_signal(signal_handler_t *handler, const char *signal,
+		calldata_t *params)
 {
 	struct signal_info *sig = getsignal_locked(handler, signal);
 

libobs/callback/signal.h

@@ -32,16 +32,16 @@ extern "C" {
  */
 
 struct signal_handler;
-typedef struct signal_handler *signal_handler_t;
-typedef void (*signal_callback_t)(void*, calldata_t);
+typedef struct signal_handler signal_handler_t;
+typedef void (*signal_callback_t)(void*, calldata_t*);
 
-EXPORT signal_handler_t signal_handler_create(void);
-EXPORT void signal_handler_destroy(signal_handler_t handler);
+EXPORT signal_handler_t *signal_handler_create(void);
+EXPORT void signal_handler_destroy(signal_handler_t *handler);
 
-EXPORT bool signal_handler_add(signal_handler_t handler,
+EXPORT bool signal_handler_add(signal_handler_t *handler,
 		const char *signal_decl);
 
-static inline bool signal_handler_add_array(signal_handler_t handler,
+static inline bool signal_handler_add_array(signal_handler_t *handler,
 		const char **signal_decls)
 {
 	bool success = true;
@@ -55,13 +55,13 @@ static inline bool signal_handler_add_array(signal_handler_t handler,
 	return success;
 }
 
-EXPORT void signal_handler_connect(signal_handler_t handler, const char *signal,
-		signal_callback_t callback, void *data);
-EXPORT void signal_handler_disconnect(signal_handler_t handler,
+EXPORT void signal_handler_connect(signal_handler_t *handler,
+		const char *signal, signal_callback_t callback, void *data);
+EXPORT void signal_handler_disconnect(signal_handler_t *handler,
 		const char *signal, signal_callback_t callback, void *data);
 
-EXPORT void signal_handler_signal(signal_handler_t handler, const char *signal,
-		calldata_t params);
+EXPORT void signal_handler_signal(signal_handler_t *handler, const char *signal,
+		calldata_t *params);
 
 #ifdef __cplusplus
 }

libobs/graphics/device-exports.h

@@ -26,118 +26,121 @@ 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 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,
+EXPORT int device_create(gs_device_t **device, 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);
-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 gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
+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 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);
-EXPORT gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
-		enum gs_color_format color_format, uint32_t levels,
-		const uint8_t **data, uint32_t flags);
-EXPORT gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
-		uint32_t height, uint32_t depth,
+EXPORT gs_texture_t *device_cubetexture_create(gs_device_t *device,
+		uint32_t size, enum gs_color_format color_format,
+		uint32_t levels, const uint8_t **data, uint32_t flags);
+EXPORT gs_texture_t *device_voltexture_create(gs_device_t *device,
+		uint32_t width, uint32_t height, uint32_t depth,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags);
-EXPORT gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
-		uint32_t height, enum gs_zstencil_format format);
-EXPORT gs_stagesurf_t device_stagesurface_create(gs_device_t device,
+EXPORT gs_zstencil_t *device_zstencil_create(gs_device_t *device,
+		uint32_t width, uint32_t height,
+		enum gs_zstencil_format format);
+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,
+EXPORT gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
 		struct gs_sampler_info *info);
-EXPORT gs_shader_t device_vertexshader_create(gs_device_t device,
+EXPORT gs_shader_t *device_vertexshader_create(gs_device_t *device,
 		const char *shader, const char *file,
 		char **error_string);
-EXPORT gs_shader_t device_pixelshader_create(gs_device_t device,
+EXPORT gs_shader_t *device_pixelshader_create(gs_device_t *device,
 		const char *shader, const char *file,
 		char **error_string);
-EXPORT gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
+EXPORT gs_vertbuffer_t *device_vertexbuffer_create(gs_device_t *device,
 		struct gs_vb_data *data, uint32_t flags);
-EXPORT gs_indexbuffer_t device_indexbuffer_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 void device_load_vertexbuffer(gs_device_t device,
-		gs_vertbuffer_t vertbuffer);
-EXPORT void device_load_indexbuffer(gs_device_t device,
-		gs_indexbuffer_t indexbuffer);
-EXPORT void device_load_texture(gs_device_t device, gs_texture_t tex, int unit);
-EXPORT void device_load_samplerstate(gs_device_t device,
-		gs_samplerstate_t samplerstate, int unit);
-EXPORT void device_load_vertexshader(gs_device_t device,
-		gs_shader_t vertshader);
-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,
+EXPORT enum gs_texture_type device_get_texture_type(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,
+		gs_indexbuffer_t *indexbuffer);
+EXPORT void device_load_texture(gs_device_t *device, gs_texture_t *tex,
+		int unit);
+EXPORT void device_load_samplerstate(gs_device_t *device,
+		gs_samplerstate_t *samplerstate, int unit);
+EXPORT void device_load_vertexshader(gs_device_t *device,
+		gs_shader_t *vertshader);
+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 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,
-		gs_texture_t cubetex,
-		int side, gs_zstencil_t zstencil);
-EXPORT void device_copy_texture(gs_device_t device, gs_texture_t dst,
-		gs_texture_t src);
-EXPORT void device_copy_texture_region(gs_device_t device,
-		gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
+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 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,
+		gs_texture_t *cubetex,
+		int side, gs_zstencil_t *zstencil);
+EXPORT void device_copy_texture(gs_device_t *device, gs_texture_t *dst,
+		gs_texture_t *src);
+EXPORT void device_copy_texture_region(gs_device_t *device,
+		gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+		gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h);
-EXPORT void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
-		gs_texture_t src);
-EXPORT void device_begin_scene(gs_device_t device);
-EXPORT void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
+EXPORT void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
+		gs_texture_t *src);
+EXPORT void device_begin_scene(gs_device_t *device);
+EXPORT void device_draw(gs_device_t *device, enum gs_draw_mode draw_mode,
 		uint32_t start_vert, uint32_t num_verts);
-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,
+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);
-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 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);
-EXPORT void device_enable_stencil_write(gs_device_t device, bool enable);
-EXPORT void device_enable_color(gs_device_t device, bool red, bool green,
+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 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);
+EXPORT void device_enable_stencil_write(gs_device_t *device, bool enable);
+EXPORT void device_enable_color(gs_device_t *device, bool red, bool green,
 		bool blue, bool alpha);
-EXPORT void device_blend_function(gs_device_t device, enum gs_blend_type src,
+EXPORT void device_blend_function(gs_device_t *device, enum gs_blend_type src,
 		enum gs_blend_type dest);
-EXPORT void device_depth_function(gs_device_t device, enum gs_depth_test test);
-EXPORT void device_stencil_function(gs_device_t device,
+EXPORT void device_depth_function(gs_device_t *device, enum gs_depth_test test);
+EXPORT void device_stencil_function(gs_device_t *device,
 		enum gs_stencil_side side, enum gs_depth_test test);
-EXPORT void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
+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,
+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,
+EXPORT void device_getdisplaymode(gs_device_t *device,
 		struct gs_display_mode *mode);
-EXPORT void device_setcolorramp(gs_device_t device, float gamma,
+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,
+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_ortho(gs_device_t device, float left, float right,
+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_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,
+EXPORT void device_frustum(gs_device_t *device, float left, float right,
 		float top, float bottom, float znear, float zfar);
-EXPORT void device_projection_push(gs_device_t device);
-EXPORT void device_projection_pop(gs_device_t device);
+EXPORT void device_projection_push(gs_device_t *device);
+EXPORT void device_projection_pop(gs_device_t *device);
 
 #ifdef __cplusplus
 }

libobs/graphics/effect-parser.c

@@ -919,7 +919,7 @@ static bool ep_compile(struct effect_parser *ep);
 
 extern const char *gs_preprocessor_name(void);
 
-bool ep_parse(struct effect_parser *ep, gs_effect_t effect,
+bool ep_parse(struct effect_parser *ep, gs_effect_t *effect,
               const char *effect_string, const char *file)
 {
 	bool success;
@@ -1320,7 +1320,7 @@ static void ep_compile_param(struct effect_parser *ep, size_t idx)
 
 static bool ep_compile_pass_shaderparams(struct effect_parser *ep,
 		struct darray *pass_params, struct darray *used_params,
-		gs_shader_t shader)
+		gs_shader_t *shader)
 {
 	size_t i;
 	darray_resize(sizeof(struct pass_shaderparam), pass_params,
@@ -1357,7 +1357,7 @@ static inline bool ep_compile_pass_shader(struct effect_parser *ep,
 	struct dstr location;
 	struct darray used_params; /* struct dstr */
 	struct darray *pass_params = NULL; /* struct pass_shaderparam */
-	gs_shader_t shader = NULL;
+	gs_shader_t *shader = NULL;
 	bool success = true;
 
 	dstr_init(&shader_str);

libobs/graphics/effect-parser.h

@@ -243,7 +243,7 @@ static inline void ep_func_free(struct ep_func *epf)
 /* ------------------------------------------------------------------------- */
 
 struct effect_parser {
-	gs_effect_t effect;
+	gs_effect_t *effect;
 
 	DARRAY(struct ep_param)     params;
 	DARRAY(struct ep_struct)    structs;
@@ -275,7 +275,7 @@ static inline void ep_init(struct effect_parser *ep)
 
 extern void ep_free(struct effect_parser *ep);
 
-extern bool ep_parse(struct effect_parser *ep, gs_effect_t effect,
+extern bool ep_parse(struct effect_parser *ep, gs_effect_t *effect,
                      const char *effect_string, const char *file);
 
 #ifdef __cplusplus

libobs/graphics/effect.c

@@ -21,7 +21,7 @@
 #include "vec3.h"
 #include "vec4.h"
 
-void gs_effect_destroy(gs_effect_t effect)
+void gs_effect_destroy(gs_effect_t *effect)
 {
 	if (effect) {
 		effect_free(effect);
@@ -29,7 +29,7 @@ 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(gs_effect_t *effect, const char *name)
 {
 	if (!effect) return NULL;
 
@@ -42,7 +42,7 @@ gs_technique_t gs_effect_get_technique(gs_effect_t effect, const char *name)
 	return NULL;
 }
 
-size_t gs_technique_begin(gs_technique_t tech)
+size_t gs_technique_begin(gs_technique_t *tech)
 {
 	if (!tech) return 0;
 
@@ -52,7 +52,7 @@ size_t gs_technique_begin(gs_technique_t tech)
 	return tech->passes.num;
 }
 
-void gs_technique_end(gs_technique_t tech)
+void gs_technique_end(gs_technique_t *tech)
 {
 	if (!tech) return;
 
@@ -91,7 +91,7 @@ static void upload_shader_params(struct darray *pass_params, bool changed_only)
 	for (i = 0; i < pass_params->num; i++) {
 		struct pass_shaderparam *param = params+i;
 		struct gs_effect_param *eparam = param->eparam;
-		gs_sparam_t sparam = param->sparam;
+		gs_sparam_t *sparam = param->sparam;
 
 		if (changed_only && !eparam->changed)
 			continue;
@@ -125,13 +125,13 @@ static inline void upload_parameters(struct gs_effect *effect,
 	reset_params(pshader_params);
 }
 
-void gs_effect_update_params(gs_effect_t effect)	
+void gs_effect_update_params(gs_effect_t *effect)	
 {
 	if (effect)
 		upload_parameters(effect, true);
 }
 
-bool gs_technique_begin_pass(gs_technique_t tech, size_t idx)
+bool gs_technique_begin_pass(gs_technique_t *tech, size_t idx)
 {
 	struct gs_effect_pass *passes;
 	struct gs_effect_pass *cur_pass;
@@ -150,7 +150,7 @@ bool gs_technique_begin_pass(gs_technique_t tech, size_t idx)
 	return true;
 }
 
-bool gs_technique_begin_pass_by_name(gs_technique_t tech,
+bool gs_technique_begin_pass_by_name(gs_technique_t *tech,
 		const char *name)
 {
 	if (!tech)
@@ -181,7 +181,7 @@ static inline void clear_tex_params(struct darray *in_params)
 	}
 }
 
-void gs_technique_end_pass(gs_technique_t tech)
+void gs_technique_end_pass(gs_technique_t *tech)
 {
 	if (!tech) return;
 
@@ -194,12 +194,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(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(gs_effect_t *effect, size_t param)
 {
 	if (!effect) return NULL;
 
@@ -210,7 +210,7 @@ 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(gs_effect_t *effect, const char *name)
 {
 	if (!effect) return NULL;
 
@@ -226,17 +226,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(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(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(gs_eparam_t *param,
 		struct gs_effect_param_info *info)
 {
 	if (!param)
@@ -246,7 +246,7 @@ void gs_effect_get_param_info(gs_eparam_t param,
 	info->type = param->type;
 }
 
-static inline void effect_setval_inline(gs_eparam_t param,
+static inline void effect_setval_inline(gs_eparam_t *param,
 		const void *data, size_t size)
 {
 	bool size_changed;
@@ -272,52 +272,52 @@ static inline void effect_setval_inline(gs_eparam_t param,
 	}
 }
 
-void gs_effect_set_bool(gs_eparam_t param, bool val)
+void gs_effect_set_bool(gs_eparam_t *param, bool val)
 {
 	effect_setval_inline(param, &val, sizeof(bool));
 }
 
-void gs_effect_set_float(gs_eparam_t param, float val)
+void gs_effect_set_float(gs_eparam_t *param, float val)
 {
 	effect_setval_inline(param, &val, sizeof(float));
 }
 
-void gs_effect_set_int(gs_eparam_t param, int val)
+void gs_effect_set_int(gs_eparam_t *param, int val)
 {
 	effect_setval_inline(param, &val, sizeof(int));
 }
 
-void gs_effect_set_matrix4(gs_eparam_t param, const struct matrix4 *val)
+void gs_effect_set_matrix4(gs_eparam_t *param, const struct matrix4 *val)
 {
 	effect_setval_inline(param, val, sizeof(struct matrix4));
 }
 
-void gs_effect_set_vec2(gs_eparam_t param, const struct vec2 *val)
+void gs_effect_set_vec2(gs_eparam_t *param, const struct vec2 *val)
 {
 	effect_setval_inline(param, val, sizeof(struct vec2));
 }
 
-void gs_effect_set_vec3(gs_eparam_t param, const struct vec3 *val)
+void gs_effect_set_vec3(gs_eparam_t *param, const struct vec3 *val)
 {
 	effect_setval_inline(param, val, sizeof(float) * 3);
 }
 
-void gs_effect_set_vec4(gs_eparam_t param, const struct vec4 *val)
+void gs_effect_set_vec4(gs_eparam_t *param, const struct vec4 *val)
 {
 	effect_setval_inline(param, val, sizeof(struct vec4));
 }
 
-void gs_effect_set_texture(gs_eparam_t param, gs_texture_t val)
+void gs_effect_set_texture(gs_eparam_t *param, gs_texture_t *val)
 {
-	effect_setval_inline(param, &val, sizeof(gs_texture_t));
+	effect_setval_inline(param, &val, sizeof(gs_texture_t*));
 }
 
-void gs_effect_set_val(gs_eparam_t param, const void *val, size_t size)
+void gs_effect_set_val(gs_eparam_t *param, const void *val, size_t size)
 {
 	effect_setval_inline(param, val, size);
 }
 
-void gs_effect_set_default(gs_eparam_t param)
+void gs_effect_set_default(gs_eparam_t *param)
 {
 	effect_setval_inline(param, param->default_val.array,
 			param->default_val.num);

libobs/graphics/effect.h

@@ -56,7 +56,7 @@ struct gs_effect_param {
 	DARRAY(uint8_t) cur_val;
 	DARRAY(uint8_t) default_val;
 
-	gs_effect_t effect;
+	gs_effect_t *effect;
 
 	/*char *full_name;
 	float scroller_min, scroller_max, scroller_inc, scroller_mul;*/
@@ -75,22 +75,22 @@ static inline void effect_param_free(struct gs_effect_param *param)
 	da_free(param->default_val);
 }
 
-EXPORT void effect_param_parse_property(gs_eparam_t param,
+EXPORT void effect_param_parse_property(gs_eparam_t *param,
 		const char *property);
 
 /* ------------------------------------------------------------------------- */
 
 struct pass_shaderparam {
 	struct gs_effect_param *eparam;
-	gs_sparam_t sparam;
+	gs_sparam_t *sparam;
 };
 
 struct gs_effect_pass {
 	char *name;
 	enum effect_section section;
 
-	gs_shader_t vertshader;
-	gs_shader_t pixelshader;
+	gs_shader_t *vertshader;
+	gs_shader_t *pixelshader;
 	DARRAY(struct pass_shaderparam) vertshader_params;
 	DARRAY(struct pass_shaderparam) pixelshader_params;
 };
@@ -145,16 +145,16 @@ struct gs_effect {
 	struct gs_effect_technique *cur_technique;
 	struct gs_effect_pass *cur_pass;
 
-	gs_eparam_t view_proj, world, scale;
-	graphics_t graphics;
+	gs_eparam_t *view_proj, *world, *scale;
+	graphics_t *graphics;
 };
 
-static inline void effect_init(gs_effect_t effect)
+static inline void effect_init(gs_effect_t *effect)
 {
 	memset(effect, 0, sizeof(struct gs_effect));
 }
 
-static inline void effect_free(gs_effect_t effect)
+static inline void effect_free(gs_effect_t *effect)
 {
 	size_t i;
 	for (i = 0; i < effect->params.num; i++)
@@ -171,9 +171,10 @@ static inline void effect_free(gs_effect_t effect)
 	effect->effect_dir = NULL;
 }
 
-EXPORT void effect_upload_params(gs_effect_t effect, bool changed_only);
-EXPORT void effect_upload_shader_params(gs_effect_t effect, gs_shader_t shader,
-		struct darray *pass_params, bool changed_only);
+EXPORT void effect_upload_params(gs_effect_t *effect, bool changed_only);
+EXPORT void effect_upload_shader_params(gs_effect_t *effect,
+		gs_shader_t *shader, struct darray *pass_params,
+		bool changed_only);
 
 #ifdef __cplusplus
 }

libobs/graphics/graphics-ffmpeg.c

@@ -201,10 +201,10 @@ static inline enum gs_color_format convert_format(enum AVPixelFormat format)
 	return GS_BGRX;
 }
 
-gs_texture_t gs_texture_create_from_file(const char *file)
+gs_texture_t *gs_texture_create_from_file(const char *file)
 {
 	struct ffmpeg_image image;
-	gs_texture_t           tex = NULL;
+	gs_texture_t           *tex = NULL;
 
 	if (ffmpeg_image_init(&image, file)) {
 		uint8_t *data = malloc(image.cx * image.cy * 4);

libobs/graphics/graphics-internal.h

@@ -27,205 +27,207 @@ 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);
-	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,
+	int (*device_create)(gs_device_t **device, 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);
-	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);
-	gs_texture_t (*device_texture_create)(gs_device_t device,
+	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);
+	gs_texture_t *(*device_texture_create)(gs_device_t *device,
 			uint32_t width, uint32_t height,
 			enum gs_color_format color_format, uint32_t levels,
 			const uint8_t **data, uint32_t flags);
-	gs_texture_t (*device_cubetexture_create)(gs_device_t device,
+	gs_texture_t *(*device_cubetexture_create)(gs_device_t *device,
 			uint32_t size, enum gs_color_format color_format,
 			uint32_t levels, const uint8_t **data, uint32_t flags);
-	gs_texture_t (*device_voltexture_create)(gs_device_t device,
+	gs_texture_t *(*device_voltexture_create)(gs_device_t *device,
 			uint32_t width, uint32_t height, uint32_t depth,
 			enum gs_color_format color_format, uint32_t levels,
 			const uint8_t **data, uint32_t flags);
-	gs_zstencil_t (*device_zstencil_create)(gs_device_t device,
+	gs_zstencil_t *(*device_zstencil_create)(gs_device_t *device,
 			uint32_t width, uint32_t height,
 			enum gs_zstencil_format format);
-	gs_stagesurf_t (*device_stagesurface_create)(gs_device_t device,
+	gs_stagesurf_t *(*device_stagesurface_create)(gs_device_t *device,
 			uint32_t width, uint32_t height,
 			enum gs_color_format color_format);
-	gs_samplerstate_t (*device_samplerstate_create)(gs_device_t device,
+	gs_samplerstate_t *(*device_samplerstate_create)(gs_device_t *device,
 			struct gs_sampler_info *info);
-	gs_shader_t (*device_vertexshader_create)(gs_device_t device,
+	gs_shader_t *(*device_vertexshader_create)(gs_device_t *device,
 			const char *shader, const char *file,
 			char **error_string);
-	gs_shader_t (*device_pixelshader_create)(gs_device_t device,
+	gs_shader_t *(*device_pixelshader_create)(gs_device_t *device,
 			const char *shader, const char *file,
 			char **error_string);
-	gs_vertbuffer_t (*device_vertexbuffer_create)(gs_device_t device,
+	gs_vertbuffer_t *(*device_vertexbuffer_create)(gs_device_t *device,
 			struct gs_vb_data *data, uint32_t flags);
-	gs_indexbuffer_t (*device_indexbuffer_create)(gs_device_t device,
+	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);
-	void (*device_load_vertexbuffer)(gs_device_t device,
-			gs_vertbuffer_t vertbuffer);
-	void (*device_load_indexbuffer)(gs_device_t device,
-			gs_indexbuffer_t indexbuffer);
-	void (*device_load_texture)(gs_device_t device, gs_texture_t tex,
+	enum gs_texture_type (*device_get_texture_type)(gs_texture_t *texture);
+	void (*device_load_vertexbuffer)(gs_device_t *device,
+			gs_vertbuffer_t *vertbuffer);
+	void (*device_load_indexbuffer)(gs_device_t *device,
+			gs_indexbuffer_t *indexbuffer);
+	void (*device_load_texture)(gs_device_t *device, gs_texture_t *tex,
 			int unit);
-	void (*device_load_samplerstate)(gs_device_t device,
-			gs_samplerstate_t samplerstate, int unit);
-	void (*device_load_vertexshader)(gs_device_t device,
-			gs_shader_t vertshader);
-	void (*device_load_pixelshader)(gs_device_t device,
-			gs_shader_t pixelshader);
-	void (*device_load_default_samplerstate)(gs_device_t device,
+	void (*device_load_samplerstate)(gs_device_t *device,
+			gs_samplerstate_t *samplerstate, int unit);
+	void (*device_load_vertexshader)(gs_device_t *device,
+			gs_shader_t *vertshader);
+	void (*device_load_pixelshader)(gs_device_t *device,
+			gs_shader_t *pixelshader);
+	void (*device_load_default_samplerstate)(gs_device_t *device,
 			bool b_3d, int unit);
-	gs_shader_t (*device_get_vertex_shader)(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);
-	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,
-			gs_texture_t cubetex, int side, gs_zstencil_t zstencil);
-	void (*device_copy_texture)(gs_device_t device, gs_texture_t dst,
-			gs_texture_t src);
-	void (*device_copy_texture_region)(gs_device_t device,
-			gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
-			gs_texture_t src, uint32_t src_x, uint32_t src_y,
+	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);
+	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,
+			gs_texture_t *cubetex, int side, gs_zstencil_t *zstencil);
+	void (*device_copy_texture)(gs_device_t *device, gs_texture_t *dst,
+			gs_texture_t *src);
+	void (*device_copy_texture_region)(gs_device_t *device,
+			gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+			gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 			uint32_t src_w, uint32_t src_h);
-	void (*device_stage_texture)(gs_device_t device, gs_stagesurf_t dst,
-			gs_texture_t src);
-	void (*device_begin_scene)(gs_device_t device);
-	void (*device_draw)(gs_device_t device, enum gs_draw_mode draw_mode,
+	void (*device_stage_texture)(gs_device_t *device, gs_stagesurf_t *dst,
+			gs_texture_t *src);
+	void (*device_begin_scene)(gs_device_t *device);
+	void (*device_draw)(gs_device_t *device, enum gs_draw_mode draw_mode,
 			uint32_t start_vert, uint32_t num_verts);
-	void (*device_end_scene)(gs_device_t device);
-	void (*device_load_swapchain)(gs_device_t device,
-			gs_swapchain_t swaphchain);
-	void (*device_clear)(gs_device_t device, uint32_t clear_flags,
+	void (*device_end_scene)(gs_device_t *device);
+	void (*device_load_swapchain)(gs_device_t *device,
+			gs_swapchain_t *swaphchain);
+	void (*device_clear)(gs_device_t *device, uint32_t clear_flags,
 			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,
+	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);
-	void (*device_enable_blending)(gs_device_t device, bool enable);
-	void (*device_enable_depth_test)(gs_device_t device, bool enable);
-	void (*device_enable_stencil_test)(gs_device_t device, bool enable);
-	void (*device_enable_stencil_write)(gs_device_t device, bool enable);
-	void (*device_enable_color)(gs_device_t device, bool red, bool green,
+	enum gs_cull_mode (*device_get_cull_mode)(gs_device_t *device);
+	void (*device_enable_blending)(gs_device_t *device, bool enable);
+	void (*device_enable_depth_test)(gs_device_t *device, bool enable);
+	void (*device_enable_stencil_test)(gs_device_t *device, bool enable);
+	void (*device_enable_stencil_write)(gs_device_t *device, bool enable);
+	void (*device_enable_color)(gs_device_t *device, bool red, bool green,
 			bool blue, bool alpha);
-	void (*device_blend_function)(gs_device_t device,
+	void (*device_blend_function)(gs_device_t *device,
 			enum gs_blend_type src, enum gs_blend_type dest);
-	void (*device_depth_function)(gs_device_t device,
+	void (*device_depth_function)(gs_device_t *device,
 			enum gs_depth_test test);
-	void (*device_stencil_function)(gs_device_t device,
+	void (*device_stencil_function)(gs_device_t *device,
 			enum gs_stencil_side side, enum gs_depth_test test);
-	void (*device_stencil_op)(gs_device_t device, enum gs_stencil_side side,
+	void (*device_stencil_op)(gs_device_t *device,
+			enum gs_stencil_side side,
 			enum gs_stencil_op_type fail,
 			enum gs_stencil_op_type zfail,
 			enum gs_stencil_op_type zpass);
-	void (*device_set_viewport)(gs_device_t device, int x, int y, int width,
-			int height);
-	void (*device_get_viewport)(gs_device_t device, struct gs_rect *rect);
-	void (*device_set_scissor_rect)(gs_device_t device,
+	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,
 			struct gs_rect *rect);
-	void (*device_ortho)(gs_device_t device, float left, float right,
+	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,
+	void (*device_frustum)(gs_device_t *device, float left, float right,
 			float top, float bottom, float znear, float zfar);
-	void (*device_projection_push)(gs_device_t device);
-	void (*device_projection_pop)(gs_device_t device);
+	void (*device_projection_push)(gs_device_t *device);
+	void (*device_projection_pop)(gs_device_t *device);
 
-	void     (*gs_swapchain_destroy)(gs_swapchain_t swapchain);
+	void     (*gs_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);
-	bool     (*gs_texture_map)(gs_texture_t tex, uint8_t **ptr,
+	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);
+	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);
+	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);
 
-	void     (*gs_cubetexture_destroy)(gs_texture_t cubetex);
-	uint32_t (*gs_cubetexture_get_size)(gs_texture_t cubetex);
+	void     (*gs_cubetexture_destroy)(gs_texture_t *cubetex);
+	uint32_t (*gs_cubetexture_get_size)(gs_texture_t *cubetex);
 	enum gs_color_format (*gs_cubetexture_get_color_format)(
-			gs_texture_t cubetex);
+			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);
+	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);
 	enum gs_color_format (*gs_voltexture_get_color_format)(
-			gs_texture_t voltex);
+			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);
+	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);
 	enum gs_color_format (*gs_stagesurface_get_color_format)(
-			gs_stagesurf_t stagesurf);
-	bool     (*gs_stagesurface_map)(gs_stagesurf_t stagesurf,
+			gs_stagesurf_t *stagesurf);
+	bool     (*gs_stagesurface_map)(gs_stagesurf_t *stagesurf,
 			uint8_t **data, uint32_t *linesize);
-	void     (*gs_stagesurface_unmap)(gs_stagesurf_t stagesurf);
+	void     (*gs_stagesurface_unmap)(gs_stagesurf_t *stagesurf);
 
-	void (*gs_zstencil_destroy)(gs_zstencil_t zstencil);
+	void (*gs_zstencil_destroy)(gs_zstencil_t *zstencil);
 
-	void (*gs_samplerstate_destroy)(gs_samplerstate_t samplerstate);
+	void (*gs_samplerstate_destroy)(gs_samplerstate_t *samplerstate);
 
-	void (*gs_vertexbuffer_destroy)(gs_vertbuffer_t vertbuffer);
-	void (*gs_vertexbuffer_flush)(gs_vertbuffer_t vertbuffer);
+	void (*gs_vertexbuffer_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);
+			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_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);
 	enum gs_index_type (*gs_indexbuffer_get_type)(
-			gs_indexbuffer_t indexbuffer);
+			gs_indexbuffer_t *indexbuffer);
 
-	void (*gs_shader_destroy)(gs_shader_t shader);
-	int (*gs_shader_get_num_params)(gs_shader_t shader);
-	gs_sparam_t (*gs_shader_get_param_by_idx)(gs_shader_t shader,
+	void (*gs_shader_destroy)(gs_shader_t *shader);
+	int (*gs_shader_get_num_params)(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,
+	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)(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,
 			struct gs_shader_param_info *info);
-	void (*gs_shader_set_bool)(gs_sparam_t param, bool val);
-	void (*gs_shader_set_float)(gs_sparam_t param, float val);
-	void (*gs_shader_set_int)(gs_sparam_t param, int val);
-	void (*gs_shader_setmatrix3)(gs_sparam_t param,
+	void (*gs_shader_set_bool)(gs_sparam_t *param, bool val);
+	void (*gs_shader_set_float)(gs_sparam_t *param, float val);
+	void (*gs_shader_set_int)(gs_sparam_t *param, int val);
+	void (*gs_shader_setmatrix3)(gs_sparam_t *param,
 			const struct matrix3 *val);
-	void (*gs_shader_set_matrix4)(gs_sparam_t param,
+	void (*gs_shader_set_matrix4)(gs_sparam_t *param,
 			const struct matrix4 *val);
-	void (*gs_shader_set_vec2)(gs_sparam_t param, const struct vec2 *val);
-	void (*gs_shader_set_vec3)(gs_sparam_t param, const struct vec3 *val);
-	void (*gs_shader_set_vec4)(gs_sparam_t param, const struct vec4 *val);
-	void (*gs_shader_set_texture)(gs_sparam_t param, gs_texture_t val);
-	void (*gs_shader_set_val)(gs_sparam_t param, const void *val,
+	void (*gs_shader_set_vec2)(gs_sparam_t *param, const struct vec2 *val);
+	void (*gs_shader_set_vec3)(gs_sparam_t *param, const struct vec3 *val);
+	void (*gs_shader_set_vec4)(gs_sparam_t *param, const struct vec4 *val);
+	void (*gs_shader_set_texture)(gs_sparam_t *param, gs_texture_t *val);
+	void (*gs_shader_set_val)(gs_sparam_t *param, const void *val,
 			size_t size);
-	void (*gs_shader_set_default)(gs_sparam_t param);
+	void (*gs_shader_set_default)(gs_sparam_t *param);
 
 #ifdef __APPLE__
 	/* OSX/Cocoa specific functions */
-	gs_texture_t (*device_texture_create_from_iosurface)(gs_device_t dev,
+	gs_texture_t *(*device_texture_create_from_iosurface)(gs_device_t *dev,
+			void *iosurf);
+	bool (*gs_texture_rebind_iosurface)(gs_texture_t *texture,
 			void *iosurf);
-	bool (*gs_texture_rebind_iosurface)(gs_texture_t texture, void *iosurf);
 
 #elif _WIN32
 	bool (*device_gdi_texture_available)(void);
-	gs_texture_t (*device_texture_create_gdi)(gs_device_t device,
+	gs_texture_t *(*device_texture_create_gdi)(gs_device_t *device,
 			uint32_t width, uint32_t height);
 
-	void *(*gs_texture_get_dc)(gs_texture_t gdi_tex);
-	void (*gs_texture_release_dc)(gs_texture_t gdi_tex);
+	void *(*gs_texture_get_dc)(gs_texture_t *gdi_tex);
+	void (*gs_texture_release_dc)(gs_texture_t *gdi_tex);
 #endif
 };
 
@@ -237,7 +239,7 @@ struct blend_state {
 
 struct graphics_subsystem {
 	void                   *module;
-	gs_device_t            device;
+	gs_device_t            *device;
 	struct gs_exports      exports;
 
 	DARRAY(struct gs_rect) viewport_stack;
@@ -248,11 +250,11 @@ struct graphics_subsystem {
 	struct matrix4         projection;
 	struct gs_effect       *cur_effect;
 
-	gs_vertbuffer_t        sprite_buffer;
+	gs_vertbuffer_t        *sprite_buffer;
 
 	bool                   using_immediate;
 	struct gs_vb_data      *vbd;
-	gs_vertbuffer_t        immediate_vertbuffer;
+	gs_vertbuffer_t        *immediate_vertbuffer;
 	DARRAY(struct vec3)    verts;
 	DARRAY(struct vec3)    norms;
 	DARRAY(uint32_t)       colors;

libobs/graphics/graphics-magick.c

@@ -14,9 +14,9 @@ void gs_free_image_deps()
 	MagickCoreTerminus();
 }
 
-gs_texture_t gs_texture_create_from_file(const char *file)
+gs_texture_t *gs_texture_create_from_file(const char *file)
 {
-	gs_texture_t  tex = NULL;
+	gs_texture_t  *tex = NULL;
 	ImageInfo     *info;
 	ExceptionInfo *exception;
 	Image         *image;

libobs/graphics/graphics.h

@@ -247,21 +247,21 @@ struct gs_effect_param;
 struct gs_device;
 struct graphics_subsystem;
 
-typedef struct gs_texture          *gs_texture_t;
-typedef struct gs_stage_surface    *gs_stagesurf_t;
-typedef struct gs_zstencil_buffer  *gs_zstencil_t;
-typedef struct gs_vertex_buffer    *gs_vertbuffer_t;
-typedef struct gs_index_buffer     *gs_indexbuffer_t;
-typedef struct gs_sampler_state    *gs_samplerstate_t;
-typedef struct gs_swap_chain       *gs_swapchain_t;
-typedef struct gs_texture_render   *gs_texrender_t;
-typedef struct gs_shader           *gs_shader_t;
-typedef struct gs_shader_param     *gs_sparam_t;
-typedef struct gs_effect           *gs_effect_t;
-typedef struct gs_effect_technique *gs_technique_t;
-typedef struct gs_effect_param     *gs_eparam_t;
-typedef struct gs_device           *gs_device_t;
-typedef struct graphics_subsystem  *graphics_t;
+typedef struct gs_texture          gs_texture_t;
+typedef struct gs_stage_surface    gs_stagesurf_t;
+typedef struct gs_zstencil_buffer  gs_zstencil_t;
+typedef struct gs_vertex_buffer    gs_vertbuffer_t;
+typedef struct gs_index_buffer     gs_indexbuffer_t;
+typedef struct gs_sampler_state    gs_samplerstate_t;
+typedef struct gs_swap_chain       gs_swapchain_t;
+typedef struct gs_texture_render   gs_texrender_t;
+typedef struct gs_shader           gs_shader_t;
+typedef struct gs_shader_param     gs_sparam_t;
+typedef struct gs_effect           gs_effect_t;
+typedef struct gs_effect_technique gs_technique_t;
+typedef struct gs_effect_param     gs_eparam_t;
+typedef struct gs_device           gs_device_t;
+typedef struct graphics_subsystem  graphics_t;
 
 /* ---------------------------------------------------
  * shader functions
@@ -290,30 +290,30 @@ enum gs_shader_type {
 	GS_SHADER_PIXEL,
 };
 
-EXPORT void gs_shader_destroy(gs_shader_t shader);
+EXPORT void gs_shader_destroy(gs_shader_t *shader);
 
-EXPORT int gs_shader_get_num_params(gs_shader_t shader);
-EXPORT gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader,
+EXPORT int gs_shader_get_num_params(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,
+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(gs_shader_t *shader);
+EXPORT gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader);
 
-EXPORT void gs_shader_get_param_info(gs_sparam_t param,
+EXPORT void gs_shader_get_param_info(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);
-EXPORT void gs_shader_set_int(gs_sparam_t param, int val);
-EXPORT void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val);
-EXPORT void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val);
-EXPORT void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val);
-EXPORT void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val);
-EXPORT void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val);
-EXPORT void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val);
-EXPORT void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size);
-EXPORT void gs_shader_set_default(gs_sparam_t param);
+EXPORT void gs_shader_set_bool(gs_sparam_t *param, bool val);
+EXPORT void gs_shader_set_float(gs_sparam_t *param, float val);
+EXPORT void gs_shader_set_int(gs_sparam_t *param, int val);
+EXPORT void gs_shader_setmatrix3(gs_sparam_t *param, const struct matrix3 *val);
+EXPORT void gs_shader_set_matrix4(gs_sparam_t *param, const struct matrix4 *val);
+EXPORT void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val);
+EXPORT void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val);
+EXPORT void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val);
+EXPORT void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val);
+EXPORT void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size);
+EXPORT void gs_shader_set_default(gs_sparam_t *param);
 
 /* ---------------------------------------------------
  * effect functions
@@ -337,54 +337,55 @@ struct gs_effect_param_info {
 	float min, max, inc, mul; */
 };
 
-EXPORT void gs_effect_destroy(gs_effect_t effect);
+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(gs_effect_t *effect,
 		const char *name);
 
-EXPORT size_t gs_technique_begin(gs_technique_t technique);
-EXPORT void gs_technique_end(gs_technique_t technique);
-EXPORT bool gs_technique_begin_pass(gs_technique_t technique, size_t pass);
-EXPORT bool gs_technique_begin_pass_by_name(gs_technique_t technique,
+EXPORT size_t gs_technique_begin(gs_technique_t *technique);
+EXPORT void gs_technique_end(gs_technique_t *technique);
+EXPORT bool gs_technique_begin_pass(gs_technique_t *technique, size_t pass);
+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 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(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,
 		const char *name);
 
 /** used internally */
-EXPORT void gs_effect_update_params(gs_effect_t effect);
+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(gs_effect_t *effect);
+EXPORT gs_eparam_t *gs_effect_get_world_matrix(gs_effect_t *effect);
 
-EXPORT void gs_effect_get_param_info(gs_eparam_t param,
+EXPORT void gs_effect_get_param_info(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);
-EXPORT void gs_effect_set_int(gs_eparam_t param, int val);
-EXPORT void gs_effect_set_matrix4(gs_eparam_t param, const struct matrix4 *val);
-EXPORT void gs_effect_set_vec2(gs_eparam_t param, const struct vec2 *val);
-EXPORT void gs_effect_set_vec3(gs_eparam_t param, const struct vec3 *val);
-EXPORT void gs_effect_set_vec4(gs_eparam_t param, const struct vec4 *val);
-EXPORT void gs_effect_set_texture(gs_eparam_t param, gs_texture_t val);
-EXPORT void gs_effect_set_val(gs_eparam_t param, const void *val, size_t size);
-EXPORT void gs_effect_set_default(gs_eparam_t param);
+EXPORT void gs_effect_set_bool(gs_eparam_t *param, bool val);
+EXPORT void gs_effect_set_float(gs_eparam_t *param, float val);
+EXPORT void gs_effect_set_int(gs_eparam_t *param, int val);
+EXPORT void gs_effect_set_matrix4(gs_eparam_t *param,
+		const struct matrix4 *val);
+EXPORT void gs_effect_set_vec2(gs_eparam_t *param, const struct vec2 *val);
+EXPORT void gs_effect_set_vec3(gs_eparam_t *param, const struct vec3 *val);
+EXPORT void gs_effect_set_vec4(gs_eparam_t *param, const struct vec4 *val);
+EXPORT void gs_effect_set_texture(gs_eparam_t *param, gs_texture_t *val);
+EXPORT void gs_effect_set_val(gs_eparam_t *param, const void *val, size_t size);
+EXPORT void gs_effect_set_default(gs_eparam_t *param);
 
 /* ---------------------------------------------------
  * texture render helper functions
  * --------------------------------------------------- */
 
-EXPORT gs_texrender_t gs_texrender_create(enum gs_color_format format,
+EXPORT gs_texrender_t *gs_texrender_create(enum gs_color_format format,
 		enum gs_zstencil_format zsformat);
-EXPORT void gs_texrender_destroy(gs_texrender_t texrender);
-EXPORT bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx,
+EXPORT void gs_texrender_destroy(gs_texrender_t *texrender);
+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 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);
 
 /* ---------------------------------------------------
  * graphics subsystem
@@ -430,13 +431,13 @@ struct gs_init_data {
 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,
+EXPORT int gs_create(graphics_t **graphics, const char *module,
 		struct gs_init_data *data);
-EXPORT void gs_destroy(graphics_t graphics);
+EXPORT void gs_destroy(graphics_t *graphics);
 
-EXPORT void gs_enter_context(graphics_t graphics);
+EXPORT void gs_enter_context(graphics_t *graphics);
 EXPORT void gs_leave_context(void);
-EXPORT graphics_t gs_get_context(void);
+EXPORT graphics_t *gs_get_context(void);
 
 EXPORT void gs_matrix_push(void);
 EXPORT void gs_matrix_pop(void);
@@ -455,7 +456,7 @@ EXPORT void gs_matrix_scale3f(float x, float y, float z);
 
 EXPORT void gs_render_start(bool b_new);
 EXPORT void gs_render_stop(enum gs_draw_mode mode);
-EXPORT gs_vertbuffer_t gs_render_save(void);
+EXPORT gs_vertbuffer_t *gs_render_save(void);
 EXPORT void gs_vertex2f(float x, float y);
 EXPORT void gs_vertex3f(float x, float y, float z);
 EXPORT void gs_normal3f(float x, float y, float z);
@@ -467,20 +468,20 @@ EXPORT void gs_normal3v(const struct vec3 *v);
 EXPORT void gs_color4v(const struct vec4 *v);
 EXPORT void gs_texcoord2v(const struct vec2 *v, int unit);
 
-EXPORT input_t gs_get_input(void);
-EXPORT gs_effect_t gs_get_effect(void);
+EXPORT input_t *gs_get_input(void);
+EXPORT gs_effect_t *gs_get_effect(void);
 
-EXPORT gs_effect_t gs_effect_create_from_file(const char *file,
+EXPORT gs_effect_t *gs_effect_create_from_file(const char *file,
 		char **error_string);
-EXPORT gs_effect_t gs_effect_create(const char *effect_string,
+EXPORT gs_effect_t *gs_effect_create(const char *effect_string,
 		const char *filename, char **error_string);
 
-EXPORT gs_shader_t gs_vertexshader_create_from_file(const char *file,
+EXPORT gs_shader_t *gs_vertexshader_create_from_file(const char *file,
 		char **error_string);
-EXPORT gs_shader_t gs_pixelshader_create_from_file(const char *file,
+EXPORT gs_shader_t *gs_pixelshader_create_from_file(const char *file,
 		char **error_string);
 
-EXPORT gs_texture_t gs_texture_create_from_file(const char *file);
+EXPORT gs_texture_t *gs_texture_create_from_file(const char *file);
 
 #define GS_FLIP_U (1<<0)
 #define GS_FLIP_V (1<<1)
@@ -492,10 +493,10 @@ EXPORT gs_texture_t gs_texture_create_from_file(const char *file);
  * The flip value specifies whether the texture shoudl be flipped on the U or V
  * axis with GS_FLIP_U and GS_FLIP_V.
  */
-EXPORT void gs_draw_sprite(gs_texture_t tex, uint32_t flip, uint32_t width,
+EXPORT void gs_draw_sprite(gs_texture_t *tex, uint32_t flip, uint32_t width,
 		uint32_t height);
 
-EXPORT void gs_draw_cube_backdrop(gs_texture_t cubetex, const struct quat *rot,
+EXPORT void gs_draw_cube_backdrop(gs_texture_t *cubetex, const struct quat *rot,
 		float left, float right, float top, float bottom, float znear);
 
 /** sets the viewport to current swap chain size */
@@ -509,9 +510,9 @@ EXPORT void gs_set_3d_mode(double fovy, double znear, double zvar);
 EXPORT void gs_viewport_push(void);
 EXPORT void gs_viewport_pop(void);
 
-EXPORT void gs_texture_set_image(gs_texture_t tex, const uint8_t *data,
+EXPORT void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,
 		uint32_t linesize, bool invert);
-EXPORT void gs_cubetexture_set_image(gs_texture_t cubetex, uint32_t side,
+EXPORT void gs_cubetexture_set_image(gs_texture_t *cubetex, uint32_t side,
 		const void *data, uint32_t linesize, bool invert);
 
 EXPORT void gs_perspective(float fovy, float aspect, float znear, float zfar);
@@ -521,68 +522,68 @@ 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(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);
 EXPORT uint32_t gs_get_width(void);
 EXPORT uint32_t gs_get_height(void);
 
-EXPORT gs_texture_t gs_texture_create(uint32_t width, uint32_t height,
+EXPORT gs_texture_t *gs_texture_create(uint32_t width, uint32_t height,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags);
-EXPORT gs_texture_t gs_cubetexture_create(uint32_t size,
+EXPORT gs_texture_t *gs_cubetexture_create(uint32_t size,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags);
-EXPORT gs_texture_t gs_voltexture_create(uint32_t width, uint32_t height,
+EXPORT gs_texture_t *gs_voltexture_create(uint32_t width, uint32_t height,
 		uint32_t depth, enum gs_color_format color_format,
 		uint32_t levels, const uint8_t **data, uint32_t flags);
 
-EXPORT gs_zstencil_t gs_zstencil_create(uint32_t width, uint32_t height,
+EXPORT gs_zstencil_t *gs_zstencil_create(uint32_t width, uint32_t height,
 		enum gs_zstencil_format format);
 
-EXPORT gs_stagesurf_t gs_stagesurface_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(struct gs_sampler_info *info);
 
-EXPORT gs_shader_t gs_vertexshader_create(const char *shader,
+EXPORT gs_shader_t *gs_vertexshader_create(const char *shader,
 		const char *file, char **error_string);
-EXPORT gs_shader_t gs_pixelshader_create(const char *shader,
+EXPORT gs_shader_t *gs_pixelshader_create(const char *shader,
 		const char *file, char **error_string);
 
-EXPORT gs_vertbuffer_t gs_vertexbuffer_create(struct gs_vb_data *data,
+EXPORT gs_vertbuffer_t *gs_vertexbuffer_create(struct gs_vb_data *data,
 		uint32_t flags);
-EXPORT gs_indexbuffer_t gs_indexbuffer_create(enum gs_index_type type,
+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(gs_texture_t *texture);
 
-EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t vertbuffer);
-EXPORT void gs_load_indexbuffer(gs_indexbuffer_t indexbuffer);
-EXPORT void gs_load_texture(gs_texture_t tex, int unit);
-EXPORT void gs_load_samplerstate(gs_samplerstate_t samplerstate, int unit);
-EXPORT void gs_load_vertexshader(gs_shader_t vertshader);
-EXPORT void gs_load_pixelshader(gs_shader_t pixelshader);
+EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t *vertbuffer);
+EXPORT void gs_load_indexbuffer(gs_indexbuffer_t *indexbuffer);
+EXPORT void gs_load_texture(gs_texture_t *tex, int unit);
+EXPORT void gs_load_samplerstate(gs_samplerstate_t *samplerstate, int unit);
+EXPORT void gs_load_vertexshader(gs_shader_t *vertshader);
+EXPORT void gs_load_pixelshader(gs_shader_t *pixelshader);
 
 EXPORT void gs_load_default_samplerstate(bool b_3d, int unit);
 
-EXPORT gs_shader_t gs_get_vertex_shader(void);
-EXPORT gs_shader_t gs_get_pixel_shader(void);
+EXPORT gs_shader_t *gs_get_vertex_shader(void);
+EXPORT gs_shader_t *gs_get_pixel_shader(void);
 
-EXPORT gs_texture_t  gs_get_render_target(void);
-EXPORT gs_zstencil_t gs_get_zstencil_target(void);
+EXPORT gs_texture_t  *gs_get_render_target(void);
+EXPORT gs_zstencil_t *gs_get_zstencil_target(void);
 
-EXPORT void gs_set_render_target(gs_texture_t tex, gs_zstencil_t zstencil);
-EXPORT void gs_set_cube_render_target(gs_texture_t cubetex, int side,
-		gs_zstencil_t zstencil);
+EXPORT void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil);
+EXPORT void gs_set_cube_render_target(gs_texture_t *cubetex, int side,
+		gs_zstencil_t *zstencil);
 
-EXPORT void gs_copy_texture(gs_texture_t dst, gs_texture_t src);
+EXPORT void gs_copy_texture(gs_texture_t *dst, gs_texture_t *src);
 EXPORT void gs_copy_texture_region(
-		gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
-		gs_texture_t src, uint32_t src_x, uint32_t src_y,
+		gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+		gs_texture_t *src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h);
-EXPORT void gs_stage_texture(gs_stagesurf_t dst, gs_texture_t src);
+EXPORT void gs_stage_texture(gs_stagesurf_t *dst, gs_texture_t *src);
 
 EXPORT void gs_begin_scene(void);
 EXPORT void gs_draw(enum gs_draw_mode draw_mode, uint32_t start_vert,
@@ -593,7 +594,7 @@ EXPORT void gs_end_scene(void);
 #define GS_CLEAR_DEPTH   (1<<1)
 #define GS_CLEAR_STENCIL (1<<2)
 
-EXPORT void gs_load_swapchain(gs_swapchain_t swapchain);
+EXPORT void gs_load_swapchain(gs_swapchain_t *swapchain);
 EXPORT void gs_clear(uint32_t clear_flags, struct vec4 *color,
 		float depth, uint8_t stencil);
 EXPORT void gs_present(void);
@@ -630,75 +631,78 @@ EXPORT void gs_frustum(float left, float right, float top, float bottom,
 EXPORT void gs_projection_push(void);
 EXPORT void gs_projection_pop(void);
 
-EXPORT void     gs_swapchain_destroy(gs_swapchain_t swapchain);
+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 bool     gs_texture_map(gs_texture_t tex, uint8_t **ptr,
+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 bool     gs_texture_map(gs_texture_t *tex, uint8_t **ptr,
 		uint32_t *linesize);
-EXPORT void     gs_texture_unmap(gs_texture_t tex);
+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(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*.
  */
-EXPORT void    *gs_texture_get_obj(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 void     gs_cubetexture_destroy(gs_texture_t *cubetex);
+EXPORT uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex);
 EXPORT enum gs_color_format gs_cubetexture_get_color_format(
-		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 enum gs_color_format gs_voltexture_get_color_format(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);
+		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 enum gs_color_format gs_voltexture_get_color_format(
+		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 enum gs_color_format gs_stagesurface_get_color_format(
-		gs_stagesurf_t stagesurf);
-EXPORT bool     gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
+		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);
+EXPORT void     gs_stagesurface_unmap(gs_stagesurf_t *stagesurf);
 
-EXPORT void     gs_zstencil_destroy(gs_zstencil_t zstencil);
+EXPORT void     gs_zstencil_destroy(gs_zstencil_t *zstencil);
 
-EXPORT void     gs_samplerstate_destroy(gs_samplerstate_t samplerstate);
+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 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 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 enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t indexbuffer);
+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 enum gs_index_type gs_indexbuffer_get_type(
+		gs_indexbuffer_t *indexbuffer);
 
 #ifdef __APPLE__
 
 /** platform specific function for creating (GL_TEXTURE_RECTANGLE) textures
  * from shared surface resources */
-EXPORT gs_texture_t gs_texture_create_from_iosurface(void *iosurf);
-EXPORT bool     gs_texture_rebind_iosurface(gs_texture_t texture, void *iosurf);
+EXPORT gs_texture_t *gs_texture_create_from_iosurface(void *iosurf);
+EXPORT bool     gs_texture_rebind_iosurface(gs_texture_t *texture,
+		void *iosurf);
 
 #elif _WIN32
 
 EXPORT bool gs_gdi_texture_available(void);
 
 /** creates a windows GDI-lockable texture */
-EXPORT gs_texture_t gs_texture_create_gdi(uint32_t width, uint32_t height);
+EXPORT gs_texture_t *gs_texture_create_gdi(uint32_t width, uint32_t height);
 
-EXPORT void *gs_texture_get_dc(gs_texture_t gdi_tex);
-EXPORT void gs_texture_release_dc(gs_texture_t gdi_tex);
+EXPORT void *gs_texture_get_dc(gs_texture_t *gdi_tex);
+EXPORT void gs_texture_release_dc(gs_texture_t *gdi_tex);
 
 #endif
 

libobs/graphics/input.h

@@ -143,9 +143,9 @@ extern "C" {
 
 /* wrapped opaque data types */
 struct input_subsystem;
-typedef struct input_subsystem* input_t;
+typedef struct input_subsystem input_t;
 
-EXPORT int input_getbuttonstate(input_t input, uint32_t button);
+EXPORT int input_getbuttonstate(input_t *input, uint32_t button);
 
 #ifdef __cplusplus
 }

libobs/graphics/texture-render.c

@@ -24,8 +24,8 @@
 #include "graphics.h"
 
 struct gs_texture_render {
-	gs_texture_t  target, prev_target;
-	gs_zstencil_t zs, prev_zs;
+	gs_texture_t  *target, *prev_target;
+	gs_zstencil_t *zs, *prev_zs;
 
 	uint32_t cx, cy;
 
@@ -35,7 +35,7 @@ struct gs_texture_render {
 	bool rendered;
 };
 
-gs_texrender_t gs_texrender_create(enum gs_color_format format,
+gs_texrender_t *gs_texrender_create(enum gs_color_format format,
 		enum gs_zstencil_format zsformat)
 {
 	struct gs_texture_render *texrender;
@@ -46,7 +46,7 @@ gs_texrender_t gs_texrender_create(enum gs_color_format format,
 	return texrender;
 }
 
-void gs_texrender_destroy(gs_texrender_t texrender)
+void gs_texrender_destroy(gs_texrender_t *texrender)
 {
 	if (texrender) {
 		gs_texture_destroy(texrender->target);
@@ -55,7 +55,7 @@ void gs_texrender_destroy(gs_texrender_t texrender)
 	}
 }
 
-static bool texrender_resetbuffer(gs_texrender_t texrender, uint32_t cx,
+static bool texrender_resetbuffer(gs_texrender_t *texrender, uint32_t cx,
 		uint32_t cy)
 {
 	if (!texrender)
@@ -87,7 +87,7 @@ static bool texrender_resetbuffer(gs_texrender_t texrender, uint32_t cx,
 	return true;
 }
 
-bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx, uint32_t cy)
+bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx, uint32_t cy)
 {
 	if (!texrender || texrender->rendered)
 		return false;
@@ -119,7 +119,7 @@ bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx, uint32_t cy)
 	return true;
 }
 
-void gs_texrender_end(gs_texrender_t texrender)
+void gs_texrender_end(gs_texrender_t *texrender)
 {
 	if (!texrender)
 		return;
@@ -133,13 +133,13 @@ void gs_texrender_end(gs_texrender_t texrender)
 	texrender->rendered = true;
 }
 
-void gs_texrender_reset(gs_texrender_t texrender)
+void gs_texrender_reset(gs_texrender_t *texrender)
 {
 	if (texrender)
 		texrender->rendered = false;
 }
 
-gs_texture_t gs_texrender_get_texture(gs_texrender_t texrender)
+gs_texture_t *gs_texrender_get_texture(gs_texrender_t *texrender)
 {
 	return texrender ? texrender->target : NULL;
 }

libobs/media-io/audio-io.c

@@ -32,7 +32,7 @@
 
 struct audio_input {
 	struct audio_convert_info conversion;
-	audio_resampler_t         resampler;
+	audio_resampler_t         *resampler;
 
 	void (*callback)(void *param, struct audio_data *data);
 	void *param;
@@ -82,7 +82,7 @@ struct audio_output {
 	size_t                     planes;
 
 	pthread_t                  thread;
-	os_event_t                 stop_event;
+	os_event_t                 *stop_event;
 
 	DARRAY(uint8_t)            mix_buffers[MAX_AV_PLANES];
 
@@ -112,7 +112,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(audio_t *audio, uint64_t ts)
 {
 	double audio_offset_d = (double)ts;
 	audio_offset_d /= 1000000000.0;
@@ -126,19 +126,19 @@ 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(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(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(audio_t *audio, uint32_t frames)
 {
 	return (uint64_t)frames * 1000000000ULL /
 		(uint64_t)audio->info.samples_per_sec;
@@ -369,7 +369,7 @@ static void *audio_thread(void *param)
 
 /* ------------------------------------------------------------------------- */
 
-static size_t audio_get_input_idx(audio_t video,
+static size_t audio_get_input_idx(audio_t *video,
 		void (*callback)(void *param, struct audio_data *data),
 		void *param)
 {
@@ -413,7 +413,7 @@ static inline bool audio_input_init(struct audio_input *input,
 	return true;
 }
 
-bool audio_output_connect(audio_t audio,
+bool audio_output_connect(audio_t *audio,
 		const struct audio_convert_info *conversion,
 		void (*callback)(void *param, struct audio_data *data),
 		void *param)
@@ -456,7 +456,7 @@ bool audio_output_connect(audio_t audio,
 	return success;
 }
 
-void audio_output_disconnect(audio_t audio,
+void audio_output_disconnect(audio_t *audio,
 		void (*callback)(void *param, struct audio_data *data),
 		void *param)
 {
@@ -479,7 +479,7 @@ static inline bool valid_audio_params(struct audio_output_info *info)
 	       info->speakers > 0;
 }
 
-int audio_output_open(audio_t *audio, struct audio_output_info *info)
+int audio_output_open(audio_t **audio, struct audio_output_info *info)
 {
 	struct audio_output *out;
 	pthread_mutexattr_t attr;
@@ -521,7 +521,7 @@ fail:
 	return AUDIO_OUTPUT_FAIL;
 }
 
-void audio_output_close(audio_t audio)
+void audio_output_close(audio_t *audio)
 {
 	void *thread_ret;
 	struct audio_line *line;
@@ -553,7 +553,7 @@ void audio_output_close(audio_t audio)
 	bfree(audio);
 }
 
-audio_line_t audio_output_create_line(audio_t audio, const char *name)
+audio_line_t *audio_output_create_line(audio_t *audio, const char *name)
 {
 	if (!audio) return NULL;
 
@@ -584,7 +584,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(audio_t *audio)
 {
 	return audio ? &audio->info : NULL;
 }
@@ -599,28 +599,28 @@ void audio_line_destroy(struct audio_line *line)
 	}
 }
 
-bool audio_output_active(audio_t audio)
+bool audio_output_active(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(audio_t *audio)
 {
 	return audio ? audio->block_size : 0;
 }
 
-size_t audio_output_get_planes(audio_t audio)
+size_t audio_output_get_planes(audio_t *audio)
 {
 	return audio ? audio->planes : 0;
 }
 
-size_t audio_output_get_channels(audio_t audio)
+size_t audio_output_get_channels(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(audio_t *audio)
 {
 	return audio ? audio->info.samples_per_sec : 0;
 }
@@ -706,7 +706,7 @@ static inline bool valid_timestamp_range(struct audio_line *line, uint64_t ts)
 	return ts >= line->base_timestamp && ts < max_ts;
 }
 
-void audio_line_output(audio_line_t line, const struct audio_data *data)
+void audio_line_output(audio_line_t *line, const struct audio_data *data)
 {
 	if (!line || !data) return;
 

libobs/media-io/audio-io.h

@@ -31,8 +31,8 @@ extern "C" {
 
 struct audio_output;
 struct audio_line;
-typedef struct audio_output *audio_t;
-typedef struct audio_line   *audio_line_t;
+typedef struct audio_output audio_t;
+typedef struct audio_line   audio_line_t;
 
 enum audio_format {
 	AUDIO_FORMAT_UNKNOWN,
@@ -169,28 +169,28 @@ static inline size_t get_audio_size(enum audio_format format,
 #define AUDIO_OUTPUT_INVALIDPARAM -1
 #define AUDIO_OUTPUT_FAIL         -2
 
-EXPORT int audio_output_open(audio_t *audio, struct audio_output_info *info);
-EXPORT void audio_output_close(audio_t audio);
+EXPORT int audio_output_open(audio_t **audio, struct audio_output_info *info);
+EXPORT void audio_output_close(audio_t *audio);
 
-EXPORT bool audio_output_connect(audio_t video,
+EXPORT bool audio_output_connect(audio_t *video,
 		const struct audio_convert_info *conversion,
 		void (*callback)(void *param, struct audio_data *data),
 		void *param);
-EXPORT void audio_output_disconnect(audio_t video,
+EXPORT void audio_output_disconnect(audio_t *video,
 		void (*callback)(void *param, struct audio_data *data),
 		void *param);
 
-EXPORT bool audio_output_active(audio_t audio);
+EXPORT bool audio_output_active(audio_t *audio);
 
-EXPORT size_t audio_output_get_block_size(audio_t audio);
-EXPORT size_t audio_output_get_planes(audio_t audio);
-EXPORT size_t audio_output_get_channels(audio_t audio);
-EXPORT uint32_t audio_output_get_sample_rate(audio_t audio);
-EXPORT const struct audio_output_info *audio_output_get_info(audio_t audio);
+EXPORT size_t audio_output_get_block_size(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 audio_line_t audio_output_create_line(audio_t audio, const char *name);
-EXPORT void audio_line_destroy(audio_line_t line);
-EXPORT void audio_line_output(audio_line_t line, const struct audio_data *data);
+EXPORT audio_line_t *audio_output_create_line(audio_t *audio, const char *name);
+EXPORT void audio_line_destroy(audio_line_t *line);
+EXPORT void audio_line_output(audio_line_t *line, const struct audio_data *data);
 
 
 #ifdef __cplusplus

libobs/media-io/audio-resampler-ffmpeg.c

@@ -77,7 +77,7 @@ static inline uint64_t convert_speaker_layout(enum speaker_layout layout)
 	return 0;
 }
 
-audio_resampler_t audio_resampler_create(const struct resample_info *dst,
+audio_resampler_t *audio_resampler_create(const struct resample_info *dst,
 		const struct resample_info *src)
 {
 	struct audio_resampler *rs = bzalloc(sizeof(struct audio_resampler));
@@ -116,7 +116,7 @@ audio_resampler_t audio_resampler_create(const struct resample_info *dst,
 	return rs;
 }
 
-void audio_resampler_destroy(audio_resampler_t rs)
+void audio_resampler_destroy(audio_resampler_t *rs)
 {
 	if (rs) {
 		if (rs->context)
@@ -128,7 +128,7 @@ void audio_resampler_destroy(audio_resampler_t rs)
 	}
 }
 
-bool audio_resampler_resample(audio_resampler_t rs,
+bool audio_resampler_resample(audio_resampler_t *rs,
 		 uint8_t *output[], uint32_t *out_frames, uint64_t *ts_offset,
 		 const uint8_t *const input[], uint32_t in_frames)
 {

libobs/media-io/audio-resampler.h

@@ -25,7 +25,7 @@ extern "C" {
 #endif
 
 struct audio_resampler;
-typedef struct audio_resampler *audio_resampler_t;
+typedef struct audio_resampler audio_resampler_t;
 
 struct resample_info {
 	uint32_t            samples_per_sec;
@@ -33,11 +33,11 @@ struct resample_info {
 	enum speaker_layout speakers;
 };
 
-EXPORT audio_resampler_t audio_resampler_create(const struct resample_info *dst,
+EXPORT audio_resampler_t *audio_resampler_create(const struct resample_info *dst,
 		const struct resample_info *src);
-EXPORT void audio_resampler_destroy(audio_resampler_t resampler);
+EXPORT void audio_resampler_destroy(audio_resampler_t *resampler);
 
-EXPORT bool audio_resampler_resample(audio_resampler_t resampler,
+EXPORT bool audio_resampler_resample(audio_resampler_t *resampler,
 		 uint8_t *output[], uint32_t *out_frames, uint64_t *ts_offset,
 		 const uint8_t *const input[], uint32_t in_frames);
 

libobs/media-io/video-io.c

@@ -30,7 +30,7 @@
 
 struct video_input {
 	struct video_scale_info   conversion;
-	video_scaler_t            scaler;
+	video_scaler_t            *scaler;
 	struct video_frame        frame[MAX_CONVERT_BUFFERS];
 	int                       cur_frame;
 
@@ -50,13 +50,13 @@ struct video_output {
 
 	pthread_t                  thread;
 	pthread_mutex_t            data_mutex;
-	os_event_t                 stop_event;
+	os_event_t                 *stop_event;
 
 	struct video_data          cur_frame;
 	struct video_data          next_frame;
 	bool                       new_frame;
 
-	os_event_t                 update_event;
+	os_event_t                 *update_event;
 	uint64_t                   frame_time;
 	volatile uint64_t          cur_video_time;
 	uint32_t                   skipped_frames;
@@ -181,7 +181,7 @@ static inline bool valid_video_params(struct video_output_info *info)
 	       info->fps_num != 0;
 }
 
-int video_output_open(video_t *video, struct video_output_info *info)
+int video_output_open(video_t **video, struct video_output_info *info)
 {
 	struct video_output *out;
 
@@ -217,7 +217,7 @@ fail:
 	return VIDEO_OUTPUT_FAIL;
 }
 
-void video_output_close(video_t video)
+void video_output_close(video_t *video)
 {
 	if (!video)
 		return;
@@ -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(video_t *video,
 		void (*callback)(void *param, struct video_data *frame),
 		void *param)
 {
@@ -284,7 +284,7 @@ static inline bool video_input_init(struct video_input *input,
 	return true;
 }
 
-bool video_output_connect(video_t video,
+bool video_output_connect(video_t *video,
 		const struct video_scale_info *conversion,
 		void (*callback)(void *param, struct video_data *frame),
 		void *param)
@@ -326,7 +326,7 @@ bool video_output_connect(video_t video,
 	return success;
 }
 
-void video_output_disconnect(video_t video,
+void video_output_disconnect(video_t *video,
 		void (*callback)(void *param, struct video_data *frame),
 		void *param)
 {
@@ -344,18 +344,18 @@ void video_output_disconnect(video_t video,
 	pthread_mutex_unlock(&video->input_mutex);
 }
 
-bool video_output_active(video_t video)
+bool video_output_active(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(video_t *video)
 {
 	return video ? &video->info : NULL;
 }
 
-void video_output_swap_frame(video_t video, struct video_data *frame)
+void video_output_swap_frame(video_t *video, struct video_data *frame)
 {
 	if (!video) return;
 
@@ -365,7 +365,7 @@ void video_output_swap_frame(video_t video, struct video_data *frame)
 	pthread_mutex_unlock(&video->data_mutex);
 }
 
-bool video_output_wait(video_t video)
+bool video_output_wait(video_t *video)
 {
 	if (!video) return false;
 
@@ -373,17 +373,17 @@ 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(video_t *video)
 {
 	return video ? video->frame_time : 0;
 }
 
-uint64_t video_output_get_time(video_t video)
+uint64_t video_output_get_time(video_t *video)
 {
 	return video ? video->cur_video_time : 0;
 }
 
-void video_output_stop(video_t video)
+void video_output_stop(video_t *video)
 {
 	void *thread_ret;
 
@@ -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(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(video_t *video)
 {
 	return video ? video->info.width : 0;
 }
 
-uint32_t video_output_get_height(video_t video)
+uint32_t video_output_get_height(video_t *video)
 {
 	return video ? video->info.height : 0;
 }
 
-double video_output_get_frame_rate(video_t video)
+double video_output_get_frame_rate(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(video_t *video)
 {
 	return video->skipped_frames;
 }
 
-uint32_t video_output_get_total_frames(video_t video)
+uint32_t video_output_get_total_frames(video_t *video)
 {
 	return video->total_frames;
 }

libobs/media-io/video-io.h

@@ -26,7 +26,7 @@ extern "C" {
 /* Base video output component.  Use this to create a video output track. */
 
 struct video_output;
-typedef struct video_output *video_t;
+typedef struct video_output video_t;
 
 enum video_format {
 	VIDEO_FORMAT_NONE,
@@ -119,33 +119,33 @@ EXPORT bool video_format_get_parameters(enum video_colorspace color_space,
 #define VIDEO_OUTPUT_INVALIDPARAM -1
 #define VIDEO_OUTPUT_FAIL         -2
 
-EXPORT int video_output_open(video_t *video, struct video_output_info *info);
-EXPORT void video_output_close(video_t video);
+EXPORT int video_output_open(video_t **video, struct video_output_info *info);
+EXPORT void video_output_close(video_t *video);
 
-EXPORT bool video_output_connect(video_t video,
+EXPORT bool video_output_connect(video_t *video,
 		const struct video_scale_info *conversion,
 		void (*callback)(void *param, struct video_data *frame),
 		void *param);
-EXPORT void video_output_disconnect(video_t video,
+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(video_t *video);
 
-EXPORT const struct video_output_info *video_output_get_info(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 void video_output_stop(video_t video);
+EXPORT const struct video_output_info *video_output_get_info(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 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(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 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(video_t *video);
+EXPORT uint32_t video_output_get_total_frames(video_t *video);
 
 
 #ifdef __cplusplus

libobs/media-io/video-scaler-ffmpeg.c

@@ -80,7 +80,7 @@ static inline int get_ffmpeg_range_type(enum video_range_type type)
 
 #define FIXED_1_0 (1<<16)
 
-int video_scaler_create(video_scaler_t *scaler_out,
+int video_scaler_create(video_scaler_t **scaler_out,
 		const struct video_scale_info *dst,
 		const struct video_scale_info *src,
 		enum video_scale_type type)
@@ -132,7 +132,7 @@ fail:
 	return VIDEO_SCALER_FAILED;
 }
 
-void video_scaler_destroy(video_scaler_t scaler)
+void video_scaler_destroy(video_scaler_t *scaler)
 {
 	if (scaler) {
 		sws_freeContext(scaler->swscale);
@@ -140,7 +140,7 @@ void video_scaler_destroy(video_scaler_t scaler)
 	}
 }
 
-bool video_scaler_scale(video_scaler_t scaler,
+bool video_scaler_scale(video_scaler_t *scaler,
 		uint8_t *output[], const uint32_t out_linesize[],
 		const uint8_t *const input[], const uint32_t in_linesize[])
 {

libobs/media-io/video-scaler.h

@@ -25,19 +25,19 @@ extern "C" {
 #endif
 
 struct video_scaler;
-typedef struct video_scaler *video_scaler_t;
+typedef struct video_scaler video_scaler_t;
 
 #define VIDEO_SCALER_SUCCESS         0
 #define VIDEO_SCALER_BAD_CONVERSION -1
 #define VIDEO_SCALER_FAILED         -2
 
-EXPORT int video_scaler_create(video_scaler_t *scaler,
+EXPORT int video_scaler_create(video_scaler_t **scaler,
 		const struct video_scale_info *dst,
 		const struct video_scale_info *src,
 		enum video_scale_type type);
-EXPORT void video_scaler_destroy(video_scaler_t scaler);
+EXPORT void video_scaler_destroy(video_scaler_t *scaler);
 
-EXPORT bool video_scaler_scale(video_scaler_t scaler,
+EXPORT bool video_scaler_scale(video_scaler_t *scaler,
 		uint8_t *output[], const uint32_t out_linesize[],
 		const uint8_t *const input[], const uint32_t in_linesize[]);
 

libobs/obs-data.h

@@ -38,9 +38,9 @@ struct quat;
 struct obs_data;
 struct obs_data_item;
 struct obs_data_array;
-typedef struct obs_data       *obs_data_t;
-typedef struct obs_data_item  *obs_data_item_t;
-typedef struct obs_data_array *obs_data_array_t;
+typedef struct obs_data       obs_data_t;
+typedef struct obs_data_item  obs_data_item_t;
+typedef struct obs_data_array obs_data_array_t;
 
 enum obs_data_type {
 	OBS_DATA_NULL,
@@ -60,248 +60,248 @@ enum obs_data_number_type {
 /* ------------------------------------------------------------------------- */
 /* Main usage functions */
 
-EXPORT obs_data_t obs_data_create();
-EXPORT obs_data_t obs_data_create_from_json(const char *json_string);
-EXPORT void obs_data_addref(obs_data_t data);
-EXPORT void obs_data_release(obs_data_t data);
+EXPORT obs_data_t *obs_data_create();
+EXPORT obs_data_t *obs_data_create_from_json(const char *json_string);
+EXPORT void obs_data_addref(obs_data_t *data);
+EXPORT void obs_data_release(obs_data_t *data);
 
-EXPORT const char *obs_data_get_json(obs_data_t data);
+EXPORT const char *obs_data_get_json(obs_data_t *data);
 
-EXPORT void obs_data_apply(obs_data_t target, obs_data_t apply_data);
+EXPORT void obs_data_apply(obs_data_t *target, obs_data_t *apply_data);
 
-EXPORT void obs_data_erase(obs_data_t data, const char *name);
+EXPORT void obs_data_erase(obs_data_t *data, const char *name);
 
 /* Set functions */
-EXPORT void obs_data_set_string(obs_data_t data, const char *name,
+EXPORT void obs_data_set_string(obs_data_t *data, const char *name,
 		const char *val);
-EXPORT void obs_data_set_int(obs_data_t data, const char *name,
+EXPORT void obs_data_set_int(obs_data_t *data, const char *name,
 		long long val);
-EXPORT void obs_data_set_double(obs_data_t data, const char *name, double val);
-EXPORT void obs_data_set_bool(obs_data_t data, const char *name, bool val);
-EXPORT void obs_data_set_obj(obs_data_t data, const char *name, obs_data_t obj);
-EXPORT void obs_data_set_array(obs_data_t data, const char *name,
-		obs_data_array_t array);
+EXPORT void obs_data_set_double(obs_data_t *data, const char *name, double val);
+EXPORT void obs_data_set_bool(obs_data_t *data, const char *name, bool val);
+EXPORT void obs_data_set_obj(obs_data_t *data, const char *name, obs_data_t *obj);
+EXPORT void obs_data_set_array(obs_data_t *data, const char *name,
+		obs_data_array_t *array);
 
 /*
  * Default value functions.
  */
-EXPORT void obs_data_set_default_string(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_string(obs_data_t *data, const char *name,
 		const char *val);
-EXPORT void obs_data_set_default_int(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_int(obs_data_t *data, const char *name,
 		long long val);
-EXPORT void obs_data_set_default_double(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_double(obs_data_t *data, const char *name,
 		double val);
-EXPORT void obs_data_set_default_bool(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_bool(obs_data_t *data, const char *name,
 		bool val);
-EXPORT void obs_data_set_default_obj(obs_data_t data, const char *name,
-		obs_data_t obj);
+EXPORT void obs_data_set_default_obj(obs_data_t *data, const char *name,
+		obs_data_t *obj);
 
 /*
  * Application overrides
  * Use these to communicate the actual values of settings in case the user
  * settings aren't appropriate
  */
-EXPORT void obs_data_set_autoselect_string(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_string(obs_data_t *data, const char *name,
 		const char *val);
-EXPORT void obs_data_set_autoselect_int(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_int(obs_data_t *data, const char *name,
 		long long val);
-EXPORT void obs_data_set_autoselect_double(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_double(obs_data_t *data, const char *name,
 		double val);
-EXPORT void obs_data_set_autoselect_bool(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_bool(obs_data_t *data, const char *name,
 		bool val);
-EXPORT void obs_data_set_autoselect_obj(obs_data_t data, const char *name,
-		obs_data_t obj);
+EXPORT void obs_data_set_autoselect_obj(obs_data_t *data, const char *name,
+		obs_data_t *obj);
 
 /*
  * Get functions
  */
-EXPORT const char *obs_data_get_string(obs_data_t data, const char *name);
-EXPORT long long obs_data_get_int(obs_data_t data, const char *name);
-EXPORT double obs_data_get_double(obs_data_t data, const char *name);
-EXPORT bool obs_data_get_bool(obs_data_t data, const char *name);
-EXPORT obs_data_t obs_data_get_obj(obs_data_t data, const char *name);
-EXPORT obs_data_array_t obs_data_get_array(obs_data_t data, const char *name);
-
-EXPORT const char *obs_data_get_default_string(obs_data_t data,
+EXPORT const char *obs_data_get_string(obs_data_t *data, const char *name);
+EXPORT long long obs_data_get_int(obs_data_t *data, const char *name);
+EXPORT double obs_data_get_double(obs_data_t *data, const char *name);
+EXPORT bool obs_data_get_bool(obs_data_t *data, const char *name);
+EXPORT obs_data_t *obs_data_get_obj(obs_data_t *data, const char *name);
+EXPORT obs_data_array_t *obs_data_get_array(obs_data_t *data, const char *name);
+
+EXPORT const char *obs_data_get_default_string(obs_data_t *data,
 		const char *name);
-EXPORT long long obs_data_get_default_int(obs_data_t data, const char *name);
-EXPORT double obs_data_get_default_double(obs_data_t data, const char *name);
-EXPORT bool obs_data_get_default_bool(obs_data_t data, const char *name);
-EXPORT obs_data_t obs_data_get_default_obj(obs_data_t data, const char *name);
-EXPORT obs_data_array_t obs_data_get_default_array(obs_data_t data,
+EXPORT long long obs_data_get_default_int(obs_data_t *data, const char *name);
+EXPORT double obs_data_get_default_double(obs_data_t *data, const char *name);
+EXPORT bool obs_data_get_default_bool(obs_data_t *data, const char *name);
+EXPORT obs_data_t *obs_data_get_default_obj(obs_data_t *data, const char *name);
+EXPORT obs_data_array_t *obs_data_get_default_array(obs_data_t *data,
 		const char *name);
 
-EXPORT const char *obs_data_get_autoselect_string(obs_data_t data,
+EXPORT const char *obs_data_get_autoselect_string(obs_data_t *data,
 		const char *name);
-EXPORT long long obs_data_get_autoselect_int(obs_data_t data, const char *name);
-EXPORT double obs_data_get_autoselect_double(obs_data_t data, const char *name);
-EXPORT bool obs_data_get_autoselect_bool(obs_data_t data, const char *name);
-EXPORT obs_data_t obs_data_get_autoselect_obj(obs_data_t data,
+EXPORT long long obs_data_get_autoselect_int(obs_data_t *data, const char *name);
+EXPORT double obs_data_get_autoselect_double(obs_data_t *data, const char *name);
+EXPORT bool obs_data_get_autoselect_bool(obs_data_t *data, const char *name);
+EXPORT obs_data_t *obs_data_get_autoselect_obj(obs_data_t *data,
 		const char *name);
-EXPORT obs_data_array_t obs_data_get_autoselect_array(obs_data_t data,
+EXPORT obs_data_array_t *obs_data_get_autoselect_array(obs_data_t *data,
 		const char *name);
 
 /* Array functions */
-EXPORT obs_data_array_t obs_data_array_create();
-EXPORT void obs_data_array_addref(obs_data_array_t array);
-EXPORT void obs_data_array_release(obs_data_array_t array);
+EXPORT obs_data_array_t *obs_data_array_create();
+EXPORT void obs_data_array_addref(obs_data_array_t *array);
+EXPORT void obs_data_array_release(obs_data_array_t *array);
 
-EXPORT size_t obs_data_array_count(obs_data_array_t array);
-EXPORT obs_data_t obs_data_array_item(obs_data_array_t array, size_t idx);
-EXPORT size_t obs_data_array_push_back(obs_data_array_t array, obs_data_t obj);
-EXPORT void obs_data_array_insert(obs_data_array_t array, size_t idx,
-		obs_data_t obj);
-EXPORT void obs_data_array_erase(obs_data_array_t array, size_t idx);
+EXPORT size_t obs_data_array_count(obs_data_array_t *array);
+EXPORT obs_data_t *obs_data_array_item(obs_data_array_t *array, size_t idx);
+EXPORT size_t obs_data_array_push_back(obs_data_array_t *array, obs_data_t *obj);
+EXPORT void obs_data_array_insert(obs_data_array_t *array, size_t idx,
+		obs_data_t *obj);
+EXPORT void obs_data_array_erase(obs_data_array_t *array, size_t idx);
 
 /* ------------------------------------------------------------------------- */
 /* Item status inspection */
 
-EXPORT bool obs_data_has_user_value(obs_data_t data, const char *name);
-EXPORT bool obs_data_has_default_value(obs_data_t data, const char *name);
-EXPORT bool obs_data_has_autoselect_value(obs_data_t data, const char *name);
+EXPORT bool obs_data_has_user_value(obs_data_t *data, const char *name);
+EXPORT bool obs_data_has_default_value(obs_data_t *data, const char *name);
+EXPORT bool obs_data_has_autoselect_value(obs_data_t *data, const char *name);
 
-EXPORT bool obs_data_item_has_user_value(obs_data_item_t data);
-EXPORT bool obs_data_item_has_default_value(obs_data_item_t data);
-EXPORT bool obs_data_item_has_autoselect_value(obs_data_item_t data);
+EXPORT bool obs_data_item_has_user_value(obs_data_item_t *data);
+EXPORT bool obs_data_item_has_default_value(obs_data_item_t *data);
+EXPORT bool obs_data_item_has_autoselect_value(obs_data_item_t *data);
 
 /* ------------------------------------------------------------------------- */
 /* Clearing data values */
 
-EXPORT void obs_data_unset_user_value(obs_data_t data, const char *name);
-EXPORT void obs_data_unset_default_value(obs_data_t data, const char *name);
-EXPORT void obs_data_unset_autoselect_value(obs_data_t data, const char *name);
+EXPORT void obs_data_unset_user_value(obs_data_t *data, const char *name);
+EXPORT void obs_data_unset_default_value(obs_data_t *data, const char *name);
+EXPORT void obs_data_unset_autoselect_value(obs_data_t *data, const char *name);
 
-EXPORT void obs_data_item_unset_user_value(obs_data_item_t data);
-EXPORT void obs_data_item_unset_default_value(obs_data_item_t data);
-EXPORT void obs_data_item_unset_autoselect_value(obs_data_item_t data);
+EXPORT void obs_data_item_unset_user_value(obs_data_item_t *data);
+EXPORT void obs_data_item_unset_default_value(obs_data_item_t *data);
+EXPORT void obs_data_item_unset_autoselect_value(obs_data_item_t *data);
 
 /* ------------------------------------------------------------------------- */
 /* Item iteration */
 
-EXPORT obs_data_item_t obs_data_first(obs_data_t data);
-EXPORT obs_data_item_t obs_data_item_byname(obs_data_t data, const char *name);
-EXPORT bool obs_data_item_next(obs_data_item_t *item);
-EXPORT void obs_data_item_release(obs_data_item_t *item);
-EXPORT void obs_data_item_remove(obs_data_item_t *item);
+EXPORT obs_data_item_t *obs_data_first(obs_data_t *data);
+EXPORT obs_data_item_t *obs_data_item_byname(obs_data_t *data, const char *name);
+EXPORT bool obs_data_item_next(obs_data_item_t **item);
+EXPORT void obs_data_item_release(obs_data_item_t **item);
+EXPORT void obs_data_item_remove(obs_data_item_t **item);
 
 /* Gets Item type */
-EXPORT enum obs_data_type obs_data_item_gettype(obs_data_item_t item);
-EXPORT enum obs_data_number_type obs_data_item_numtype(obs_data_item_t item);
+EXPORT enum obs_data_type obs_data_item_gettype(obs_data_item_t *item);
+EXPORT enum obs_data_number_type obs_data_item_numtype(obs_data_item_t *item);
 
 /* Item set functions */
-EXPORT void obs_data_item_set_string(obs_data_item_t *item, const char *val);
-EXPORT void obs_data_item_set_int(obs_data_item_t *item, long long val);
-EXPORT void obs_data_item_set_double(obs_data_item_t *item, double val);
-EXPORT void obs_data_item_set_bool(obs_data_item_t *item, bool val);
-EXPORT void obs_data_item_set_obj(obs_data_item_t *item, obs_data_t val);
-EXPORT void obs_data_item_set_array(obs_data_item_t *item,
-		obs_data_array_t val);
-
-EXPORT void obs_data_item_set_default_string(obs_data_item_t *item,
+EXPORT void obs_data_item_set_string(obs_data_item_t **item, const char *val);
+EXPORT void obs_data_item_set_int(obs_data_item_t **item, long long val);
+EXPORT void obs_data_item_set_double(obs_data_item_t **item, double val);
+EXPORT void obs_data_item_set_bool(obs_data_item_t **item, bool val);
+EXPORT void obs_data_item_set_obj(obs_data_item_t **item, obs_data_t *val);
+EXPORT void obs_data_item_set_array(obs_data_item_t **item,
+		obs_data_array_t *val);
+
+EXPORT void obs_data_item_set_default_string(obs_data_item_t **item,
 		const char *val);
-EXPORT void obs_data_item_set_default_int(obs_data_item_t *item, long long val);
-EXPORT void obs_data_item_set_default_double(obs_data_item_t *item, double val);
-EXPORT void obs_data_item_set_default_bool(obs_data_item_t *item, bool val);
-EXPORT void obs_data_item_set_default_obj(obs_data_item_t *item,
-		obs_data_t val);
-EXPORT void obs_data_item_set_default_array(obs_data_item_t *item,
-		obs_data_array_t val);
-
-EXPORT void obs_data_item_set_autoselect_string(obs_data_item_t *item,
+EXPORT void obs_data_item_set_default_int(obs_data_item_t **item, long long val);
+EXPORT void obs_data_item_set_default_double(obs_data_item_t **item, double val);
+EXPORT void obs_data_item_set_default_bool(obs_data_item_t **item, bool val);
+EXPORT void obs_data_item_set_default_obj(obs_data_item_t **item,
+		obs_data_t *val);
+EXPORT void obs_data_item_set_default_array(obs_data_item_t **item,
+		obs_data_array_t *val);
+
+EXPORT void obs_data_item_set_autoselect_string(obs_data_item_t **item,
 		const char *val);
-EXPORT void obs_data_item_set_autoselect_int(obs_data_item_t *item,
+EXPORT void obs_data_item_set_autoselect_int(obs_data_item_t **item,
 		long long val);
-EXPORT void obs_data_item_set_autoselect_double(obs_data_item_t *item,
+EXPORT void obs_data_item_set_autoselect_double(obs_data_item_t **item,
 		double val);
-EXPORT void obs_data_item_set_autoselect_bool(obs_data_item_t *item, bool val);
-EXPORT void obs_data_item_set_autoselect_obj(obs_data_item_t *item,
-		obs_data_t val);
-EXPORT void obs_data_item_set_autoselect_array(obs_data_item_t *item,
-		obs_data_array_t val);
+EXPORT void obs_data_item_set_autoselect_bool(obs_data_item_t **item, bool val);
+EXPORT void obs_data_item_set_autoselect_obj(obs_data_item_t **item,
+		obs_data_t *val);
+EXPORT void obs_data_item_set_autoselect_array(obs_data_item_t **item,
+		obs_data_array_t *val);
 
 /* Item get functions */
-EXPORT const char *obs_data_item_get_string(obs_data_item_t item);
-EXPORT long long obs_data_item_get_int(obs_data_item_t item);
-EXPORT double obs_data_item_get_double(obs_data_item_t item);
-EXPORT bool obs_data_item_get_bool(obs_data_item_t item);
-EXPORT obs_data_t obs_data_item_get_obj(obs_data_item_t item);
-EXPORT obs_data_array_t obs_data_item_get_array(obs_data_item_t item);
-
-EXPORT const char *obs_data_item_get_default_string(obs_data_item_t item);
-EXPORT long long obs_data_item_get_default_int(obs_data_item_t item);
-EXPORT double obs_data_item_get_default_double(obs_data_item_t item);
-EXPORT bool obs_data_item_get_default_bool(obs_data_item_t item);
-EXPORT obs_data_t obs_data_item_get_default_obj(obs_data_item_t item);
-EXPORT obs_data_array_t obs_data_item_get_default_array(obs_data_item_t item);
-
-EXPORT const char *obs_data_item_get_autoselect_string(obs_data_item_t item);
-EXPORT long long obs_data_item_get_autoselect_int(obs_data_item_t item);
-EXPORT double obs_data_item_get_autoselect_double(obs_data_item_t item);
-EXPORT bool obs_data_item_get_autoselect_bool(obs_data_item_t item);
-EXPORT obs_data_t obs_data_item_get_autoselect_obj(obs_data_item_t item);
-EXPORT obs_data_array_t obs_data_item_get_autoselect_array(
-		obs_data_item_t item);
+EXPORT const char *obs_data_item_get_string(obs_data_item_t *item);
+EXPORT long long obs_data_item_get_int(obs_data_item_t *item);
+EXPORT double obs_data_item_get_double(obs_data_item_t *item);
+EXPORT bool obs_data_item_get_bool(obs_data_item_t *item);
+EXPORT obs_data_t *obs_data_item_get_obj(obs_data_item_t *item);
+EXPORT obs_data_array_t *obs_data_item_get_array(obs_data_item_t *item);
+
+EXPORT const char *obs_data_item_get_default_string(obs_data_item_t *item);
+EXPORT long long obs_data_item_get_default_int(obs_data_item_t *item);
+EXPORT double obs_data_item_get_default_double(obs_data_item_t *item);
+EXPORT bool obs_data_item_get_default_bool(obs_data_item_t *item);
+EXPORT obs_data_t *obs_data_item_get_default_obj(obs_data_item_t *item);
+EXPORT obs_data_array_t *obs_data_item_get_default_array(obs_data_item_t *item);
+
+EXPORT const char *obs_data_item_get_autoselect_string(obs_data_item_t *item);
+EXPORT long long obs_data_item_get_autoselect_int(obs_data_item_t *item);
+EXPORT double obs_data_item_get_autoselect_double(obs_data_item_t *item);
+EXPORT bool obs_data_item_get_autoselect_bool(obs_data_item_t *item);
+EXPORT obs_data_t *obs_data_item_get_autoselect_obj(obs_data_item_t *item);
+EXPORT obs_data_array_t *obs_data_item_get_autoselect_array(
+		obs_data_item_t *item);
 
 /* ------------------------------------------------------------------------- */
 /* Helper functions for certain structures */
-EXPORT void obs_data_set_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_set_vec2(obs_data_t *data, const char *name,
 		const struct vec2 *val);
-EXPORT void obs_data_set_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_set_vec3(obs_data_t *data, const char *name,
 		const struct vec3 *val);
-EXPORT void obs_data_set_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_set_vec4(obs_data_t *data, const char *name,
 		const struct vec4 *val);
-EXPORT void obs_data_set_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_set_quat(obs_data_t *data, const char *name,
 		const struct quat *val);
 
-EXPORT void obs_data_set_default_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_vec2(obs_data_t *data, const char *name,
 		const struct vec2 *val);
-EXPORT void obs_data_set_default_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_vec3(obs_data_t *data, const char *name,
 		const struct vec3 *val);
-EXPORT void obs_data_set_default_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_vec4(obs_data_t *data, const char *name,
 		const struct vec4 *val);
-EXPORT void obs_data_set_default_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_set_default_quat(obs_data_t *data, const char *name,
 		const struct quat *val);
 
-EXPORT void obs_data_set_autoselect_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_vec2(obs_data_t *data, const char *name,
 		const struct vec2 *val);
-EXPORT void obs_data_set_autoselect_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_vec3(obs_data_t *data, const char *name,
 		const struct vec3 *val);
-EXPORT void obs_data_set_autoselect_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_vec4(obs_data_t *data, const char *name,
 		const struct vec4 *val);
-EXPORT void obs_data_set_autoselect_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_set_autoselect_quat(obs_data_t *data, const char *name,
 		const struct quat *val);
 
-EXPORT void obs_data_get_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_get_vec2(obs_data_t *data, const char *name,
 		struct vec2 *val);
-EXPORT void obs_data_get_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_get_vec3(obs_data_t *data, const char *name,
 		struct vec3 *val);
-EXPORT void obs_data_get_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_get_vec4(obs_data_t *data, const char *name,
 		struct vec4 *val);
-EXPORT void obs_data_get_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_get_quat(obs_data_t *data, const char *name,
 		struct quat *val);
 
-EXPORT void obs_data_get_default_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_get_default_vec2(obs_data_t *data, const char *name,
 		struct vec2 *val);
-EXPORT void obs_data_get_default_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_get_default_vec3(obs_data_t *data, const char *name,
 		struct vec3 *val);
-EXPORT void obs_data_get_default_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_get_default_vec4(obs_data_t *data, const char *name,
 		struct vec4 *val);
-EXPORT void obs_data_get_default_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_get_default_quat(obs_data_t *data, const char *name,
 		struct quat *val);
 
-EXPORT void obs_data_get_autoselect_vec2(obs_data_t data, const char *name,
+EXPORT void obs_data_get_autoselect_vec2(obs_data_t *data, const char *name,
 		struct vec2 *val);
-EXPORT void obs_data_get_autoselect_vec3(obs_data_t data, const char *name,
+EXPORT void obs_data_get_autoselect_vec3(obs_data_t *data, const char *name,
 		struct vec3 *val);
-EXPORT void obs_data_get_autoselect_vec4(obs_data_t data, const char *name,
+EXPORT void obs_data_get_autoselect_vec4(obs_data_t *data, const char *name,
 		struct vec4 *val);
-EXPORT void obs_data_get_autoselect_quat(obs_data_t data, const char *name,
+EXPORT void obs_data_get_autoselect_quat(obs_data_t *data, const char *name,
 		struct quat *val);
 
 /* ------------------------------------------------------------------------- */
 /* OBS-specific functions */
 
-static inline obs_data_t obs_data_newref(obs_data_t data)
+static inline obs_data_t *obs_data_newref(obs_data_t *data)
 {
 	if (data)
 		obs_data_addref(data);

libobs/obs-display.c

@@ -44,7 +44,7 @@ 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(struct gs_init_data *graphics_data)
 {
 	struct obs_display *display = bzalloc(sizeof(struct obs_display));
 
@@ -71,7 +71,7 @@ obs_display_t obs_display_create(struct gs_init_data *graphics_data)
 	return display;
 }
 
-void obs_display_free(obs_display_t display)
+void obs_display_free(obs_display_t *display)
 {
 	pthread_mutex_destroy(&display->draw_callbacks_mutex);
 	da_free(display->draw_callbacks);
@@ -82,7 +82,7 @@ void obs_display_free(obs_display_t display)
 	}
 }
 
-void obs_display_destroy(obs_display_t display)
+void obs_display_destroy(obs_display_t *display)
 {
 	if (display) {
 		pthread_mutex_lock(&obs->data.displays_mutex);
@@ -99,7 +99,7 @@ void obs_display_destroy(obs_display_t display)
 	}
 }
 
-void obs_display_resize(obs_display_t display, uint32_t cx, uint32_t cy)
+void obs_display_resize(obs_display_t *display, uint32_t cx, uint32_t cy)
 {
 	if (!display) return;
 
@@ -112,7 +112,7 @@ void obs_display_resize(obs_display_t display, uint32_t cx, uint32_t cy)
 	pthread_mutex_unlock(&display->draw_callbacks_mutex);
 }
 
-void obs_display_add_draw_callback(obs_display_t display,
+void obs_display_add_draw_callback(obs_display_t *display,
 		void (*draw)(void *param, uint32_t cx, uint32_t cy),
 		void *param)
 {
@@ -125,7 +125,7 @@ void obs_display_add_draw_callback(obs_display_t display,
 	pthread_mutex_unlock(&display->draw_callbacks_mutex);
 }
 
-void obs_display_remove_draw_callback(obs_display_t display,
+void obs_display_remove_draw_callback(obs_display_t *display,
 		void (*draw)(void *param, uint32_t cx, uint32_t cy),
 		void *param)
 {

libobs/obs-encoder.c

@@ -37,7 +37,7 @@ const char *obs_encoder_get_display_name(const char *id)
 }
 
 static bool init_encoder(struct obs_encoder *encoder, const char *name,
-		obs_data_t settings)
+		obs_data_t *settings)
 {
 	pthread_mutex_init_value(&encoder->callbacks_mutex);
 	pthread_mutex_init_value(&encoder->outputs_mutex);
@@ -57,7 +57,7 @@ static bool init_encoder(struct obs_encoder *encoder, const char *name,
 
 static struct obs_encoder *create_encoder(const char *id,
 		enum obs_encoder_type type, const char *name,
-		obs_data_t settings)
+		obs_data_t *settings)
 {
 	struct obs_encoder *encoder;
 	struct obs_encoder_info *ei = find_encoder(id);
@@ -83,15 +83,15 @@ static struct obs_encoder *create_encoder(const char *id,
 	return encoder;
 }
 
-obs_encoder_t obs_video_encoder_create(const char *id, const char *name,
-		obs_data_t settings)
+obs_encoder_t *obs_video_encoder_create(const char *id, const char *name,
+		obs_data_t *settings)
 {
 	if (!name || !id) return NULL;
 	return create_encoder(id, OBS_ENCODER_VIDEO, name, settings);
 }
 
-obs_encoder_t obs_audio_encoder_create(const char *id, const char *name,
-		obs_data_t settings)
+obs_encoder_t *obs_audio_encoder_create(const char *id, const char *name,
+		obs_data_t *settings)
 {
 	if (!name || !id) return NULL;
 	return create_encoder(id, OBS_ENCODER_AUDIO, name, settings);
@@ -193,7 +193,7 @@ static inline void free_audio_buffers(struct obs_encoder *encoder)
 	}
 }
 
-static void obs_encoder_actually_destroy(obs_encoder_t encoder)
+static void obs_encoder_actually_destroy(obs_encoder_t *encoder)
 {
 	if (encoder) {
 		pthread_mutex_lock(&encoder->outputs_mutex);
@@ -220,7 +220,7 @@ static void obs_encoder_actually_destroy(obs_encoder_t encoder)
 
 /* does not actually destroy the encoder until all connections to it have been
  * removed. (full reference counting really would have been superfluous) */
-void obs_encoder_destroy(obs_encoder_t encoder)
+void obs_encoder_destroy(obs_encoder_t *encoder)
 {
 	if (encoder) {
 		bool destroy;
@@ -238,31 +238,31 @@ void obs_encoder_destroy(obs_encoder_t encoder)
 	}
 }
 
-const char *obs_encoder_get_name(obs_encoder_t encoder)
+const char *obs_encoder_get_name(obs_encoder_t *encoder)
 {
 	return encoder ? encoder->context.name : NULL;
 }
 
-static inline obs_data_t get_defaults(const struct obs_encoder_info *info)
+static inline obs_data_t *get_defaults(const struct obs_encoder_info *info)
 {
-	obs_data_t settings = obs_data_create();
+	obs_data_t *settings = obs_data_create();
 	if (info->get_defaults)
 		info->get_defaults(settings);
 	return settings;
 }
 
-obs_data_t obs_encoder_defaults(const char *id)
+obs_data_t *obs_encoder_defaults(const char *id)
 {
 	const struct obs_encoder_info *info = find_encoder(id);
 	return (info) ? get_defaults(info) : NULL;
 }
 
-obs_properties_t obs_get_encoder_properties(const char *id)
+obs_properties_t *obs_get_encoder_properties(const char *id)
 {
 	const struct obs_encoder_info *ei = find_encoder(id);
 	if (ei && ei->get_properties) {
-		obs_data_t       defaults = get_defaults(ei);
-		obs_properties_t properties;
+		obs_data_t       *defaults = get_defaults(ei);
+		obs_properties_t *properties;
 
 		properties = ei->get_properties();
 		obs_properties_apply_settings(properties, defaults);
@@ -272,10 +272,10 @@ 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(obs_encoder_t *encoder)
 {
 	if (encoder && encoder->info.get_properties) {
-		obs_properties_t props;
+		obs_properties_t *props;
 		props = encoder->info.get_properties();
 		obs_properties_apply_settings(props, encoder->context.settings);
 		return props;
@@ -283,7 +283,7 @@ obs_properties_t obs_encoder_properties(obs_encoder_t encoder)
 	return NULL;
 }
 
-void obs_encoder_update(obs_encoder_t encoder, obs_data_t settings)
+void obs_encoder_update(obs_encoder_t *encoder, obs_data_t *settings)
 {
 	if (!encoder) return;
 
@@ -294,7 +294,7 @@ 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,
+bool obs_encoder_get_extra_data(obs_encoder_t *encoder, uint8_t **extra_data,
 		size_t *size)
 {
 	if (encoder && encoder->info.get_extra_data && encoder->context.data)
@@ -304,7 +304,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(obs_encoder_t *encoder)
 {
 	if (!encoder) return NULL;
 
@@ -336,7 +336,7 @@ static void intitialize_audio_encoder(struct obs_encoder *encoder)
 	reset_audio_buffers(encoder);
 }
 
-bool obs_encoder_initialize(obs_encoder_t encoder)
+bool obs_encoder_initialize(obs_encoder_t *encoder)
 {
 	if (!encoder) return false;
 
@@ -375,7 +375,7 @@ static inline size_t get_callback_idx(
 	return DARRAY_INVALID;
 }
 
-void obs_encoder_start(obs_encoder_t encoder,
+void obs_encoder_start(obs_encoder_t *encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param)
 {
@@ -400,7 +400,7 @@ void obs_encoder_start(obs_encoder_t encoder,
 	}
 }
 
-void obs_encoder_stop(obs_encoder_t encoder,
+void obs_encoder_stop(obs_encoder_t *encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param)
 {
@@ -427,12 +427,12 @@ void obs_encoder_stop(obs_encoder_t encoder,
 	}
 }
 
-const char *obs_encoder_get_codec(obs_encoder_t encoder)
+const char *obs_encoder_get_codec(obs_encoder_t *encoder)
 {
 	return encoder ? encoder->info.codec : NULL;
 }
 
-void obs_encoder_set_scaled_size(obs_encoder_t encoder, uint32_t width,
+void obs_encoder_set_scaled_size(obs_encoder_t *encoder, uint32_t width,
 		uint32_t height)
 {
 	if (!encoder || encoder->info.type != OBS_ENCODER_VIDEO)
@@ -449,7 +449,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(obs_encoder_t *encoder)
 {
 	if (!encoder || !encoder->media ||
 	    encoder->info.type != OBS_ENCODER_VIDEO)
@@ -460,7 +460,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(obs_encoder_t *encoder)
 {
 	if (!encoder || !encoder->media ||
 	    encoder->info.type != OBS_ENCODER_VIDEO)
@@ -471,7 +471,7 @@ uint32_t obs_encoder_get_height(obs_encoder_t encoder)
 		video_output_get_height(encoder->media);
 }
 
-void obs_encoder_set_video(obs_encoder_t encoder, video_t video)
+void obs_encoder_set_video(obs_encoder_t *encoder, video_t *video)
 {
 	const struct video_output_info *voi;
 
@@ -485,7 +485,7 @@ void obs_encoder_set_video(obs_encoder_t encoder, video_t video)
 	encoder->timebase_den = voi->fps_num;
 }
 
-void obs_encoder_set_audio(obs_encoder_t encoder, audio_t audio)
+void obs_encoder_set_audio(obs_encoder_t *encoder, audio_t *audio)
 {
 	if (!audio || !encoder || encoder->info.type != OBS_ENCODER_AUDIO)
 		return;
@@ -495,19 +495,19 @@ 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(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(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(obs_encoder_t *encoder)
 {
 	return encoder ? encoder->active : false;
 }

libobs/obs-encoder.h

@@ -114,7 +114,7 @@ struct obs_encoder_info {
 	 * @return           Data associated with this encoder context, or
 	 *                   NULL if initialization failed.
 	 */
-	void *(*create)(obs_data_t settings, obs_encoder_t encoder);
+	void *(*create)(obs_data_t *settings, obs_encoder_t *encoder);
 
 	/**
 	 * Destroys the encoder data
@@ -149,14 +149,14 @@ struct obs_encoder_info {
 	 *
 	 * @param[out]  settings  Data to assign default settings to
 	 */
-	void (*get_defaults)(obs_data_t settings);
+	void (*get_defaults)(obs_data_t *settings);
 
 	/** 
 	 * Gets the property information of this encoder
 	 *
 	 * @return         The properties data
 	 */
-	obs_properties_t (*get_properties)(void);
+	obs_properties_t *(*get_properties)(void);
 
 	/**
 	 * Updates the settings for this encoder (usually used for things like
@@ -166,7 +166,7 @@ struct obs_encoder_info {
 	 * @param  settings  New settings for this encoder
 	 * @return           true if successful, false otherwise
 	 */
-	bool (*update)(void *data, obs_data_t settings);
+	bool (*update)(void *data, obs_data_t *settings);
 
 	/**
 	 * Returns extra data associated with this encoder (usually header)

libobs/obs-internal.h

@@ -62,7 +62,7 @@ struct obs_module {
 	void        (*set_locale)(const char *locale);
 	void        (*free_locale)(void);
 	uint32_t    (*ver)(void);
-	void        (*set_pointer)(obs_module_t module);
+	void        (*set_pointer)(obs_module_t *module);
 	const char *(*name)(void);
 	const char *(*description)(void);
 	const char *(*author)(void);
@@ -100,7 +100,7 @@ static inline bool check_path(const char *data, const char *path,
 
 struct obs_view {
 	pthread_mutex_t                 channels_mutex;
-	obs_source_t                    channels[MAX_CHANNELS];
+	obs_source_t                    *channels[MAX_CHANNELS];
 };
 
 extern bool obs_view_init(struct obs_view *view);
@@ -113,7 +113,7 @@ extern void obs_view_free(struct obs_view *view);
 struct obs_display {
 	bool                            size_changed;
 	uint32_t                        cx, cy;
-	gs_swapchain_t                  swap;
+	gs_swapchain_t                  *swap;
 	pthread_mutex_t                 draw_callbacks_mutex;
 	DARRAY(struct draw_callback)    draw_callbacks;
 
@@ -130,23 +130,23 @@ extern void obs_display_free(struct obs_display *display);
 /* core */
 
 struct obs_core_video {
-	graphics_t                      graphics;
-	gs_stagesurf_t                  copy_surfaces[NUM_TEXTURES];
-	gs_texture_t                    render_textures[NUM_TEXTURES];
-	gs_texture_t                    output_textures[NUM_TEXTURES];
-	gs_texture_t                    convert_textures[NUM_TEXTURES];
+	graphics_t                      *graphics;
+	gs_stagesurf_t                  *copy_surfaces[NUM_TEXTURES];
+	gs_texture_t                    *render_textures[NUM_TEXTURES];
+	gs_texture_t                    *output_textures[NUM_TEXTURES];
+	gs_texture_t                    *convert_textures[NUM_TEXTURES];
 	bool                            textures_rendered[NUM_TEXTURES];
 	bool                            textures_output[NUM_TEXTURES];
 	bool                            textures_copied[NUM_TEXTURES];
 	bool                            textures_converted[NUM_TEXTURES];
 	struct obs_source_frame         convert_frames[NUM_TEXTURES];
-	gs_effect_t                     default_effect;
-	gs_effect_t                     solid_effect;
-	gs_effect_t                     conversion_effect;
-	gs_stagesurf_t                  mapped_surface;
+	gs_effect_t                     *default_effect;
+	gs_effect_t                     *solid_effect;
+	gs_effect_t                     *conversion_effect;
+	gs_stagesurf_t                  *mapped_surface;
 	int                             cur_texture;
 
-	video_t                         video;
+	video_t                         *video;
 	pthread_t                       video_thread;
 	bool                            thread_initialized;
 
@@ -167,7 +167,7 @@ struct obs_core_video {
 
 struct obs_core_audio {
 	/* TODO: sound output subsystem */
-	audio_t                         audio;
+	audio_t                         *audio;
 
 	float                           user_volume;
 	float                           present_volume;
@@ -210,8 +210,8 @@ struct obs_core {
 	DARRAY(struct obs_modal_ui)     modal_ui_callbacks;
 	DARRAY(struct obs_modeless_ui)  modeless_ui_callbacks;
 
-	signal_handler_t                signals;
-	proc_handler_t                  procs;
+	signal_handler_t                *signals;
+	proc_handler_t                  *procs;
 
 	char                            *locale;
 
@@ -233,9 +233,9 @@ extern void *obs_video_thread(void *param);
 struct obs_context_data {
 	char                            *name;
 	void                            *data;
-	obs_data_t                      settings;
-	signal_handler_t                signals;
-	proc_handler_t                  procs;
+	obs_data_t                      *settings;
+	signal_handler_t                *signals;
+	proc_handler_t                  *procs;
 
 	DARRAY(char*)                   rename_cache;
 	pthread_mutex_t                 rename_cache_mutex;
@@ -247,7 +247,7 @@ struct obs_context_data {
 
 extern bool obs_context_data_init(
 		struct obs_context_data *context,
-		obs_data_t              settings,
+		obs_data_t              *settings,
 		const char              *name);
 extern void obs_context_data_free(struct obs_context_data *context);
 
@@ -298,8 +298,8 @@ struct obs_source {
 	/* audio */
 	bool                            audio_failed;
 	struct resample_info            sample_info;
-	audio_resampler_t               resampler;
-	audio_line_t                    audio_line;
+	audio_resampler_t               *resampler;
+	audio_line_t                    *audio_line;
 	pthread_mutex_t                 audio_mutex;
 	struct obs_audio_data           audio_data;
 	size_t                          audio_storage_size;
@@ -321,8 +321,8 @@ struct obs_source {
 	float                           transition_volume;
 
 	/* async video data */
-	gs_texture_t                    async_texture;
-	gs_texrender_t                  async_convert_texrender;
+	gs_texture_t                    *async_texture;
+	gs_texrender_t                  *async_convert_texrender;
 	bool                            async_gpu_conversion;
 	enum video_format               async_format;
 	enum gs_color_format            async_texture_format;
@@ -344,14 +344,14 @@ struct obs_source {
 	struct obs_source               *filter_target;
 	DARRAY(struct obs_source*)      filters;
 	pthread_mutex_t                 filter_mutex;
-	gs_texrender_t                  filter_texrender;
+	gs_texrender_t                  *filter_texrender;
 	bool                            rendering_filter;
 };
 
 extern const struct obs_source_info *find_source(struct darray *list,
 		const char *id);
 extern bool obs_source_init_context(struct obs_source *source,
-		obs_data_t settings, const char *name);
+		obs_data_t *settings, const char *name);
 extern bool obs_source_init(struct obs_source *source,
 		const struct obs_source_info *info);
 
@@ -362,9 +362,9 @@ enum view_type {
 	AUX_VIEW
 };
 
-extern void obs_source_activate(obs_source_t source, enum view_type type);
-extern void obs_source_deactivate(obs_source_t source, enum view_type type);
-extern void obs_source_video_tick(obs_source_t source, float seconds);
+extern void obs_source_activate(obs_source_t *source, enum view_type type);
+extern void obs_source_deactivate(obs_source_t *source, enum view_type type);
+extern void obs_source_video_tick(obs_source_t *source, float seconds);
 
 
 /* ------------------------------------------------------------------------- */
@@ -389,7 +389,7 @@ struct obs_output {
 	int                             reconnect_retries;
 	bool                            reconnecting;
 	pthread_t                       reconnect_thread;
-	os_event_t                      reconnect_stop_event;
+	os_event_t                      *reconnect_stop_event;
 	volatile bool                   reconnect_thread_active;
 
 	uint32_t                        starting_frame_count;
@@ -398,11 +398,11 @@ struct obs_output {
 	int                             total_frames;
 
 	bool                            active;
-	video_t                         video;
-	audio_t                         audio;
-	obs_encoder_t                   video_encoder;
-	obs_encoder_t                   audio_encoder;
-	obs_service_t                   service;
+	video_t                         *video;
+	audio_t                         *audio;
+	obs_encoder_t                   *video_encoder;
+	obs_encoder_t                   *audio_encoder;
+	obs_service_t                   *service;
 
 	uint32_t                        scaled_width;
 	uint32_t                        scaled_height;
@@ -462,11 +462,11 @@ struct obs_encoder {
 	uint64_t                        start_ts;
 
 	pthread_mutex_t                 outputs_mutex;
-	DARRAY(obs_output_t)            outputs;
+	DARRAY(obs_output_t*)            outputs;
 
 	bool                            destroy_on_stop;
 
-	/* stores the video/audio media output pointer.  video_t or audio_t */
+	/* stores the video/audio media output pointer.  video_t *or audio_t **/
 	void                            *media;
 
 	pthread_mutex_t                 callbacks_mutex;
@@ -475,12 +475,12 @@ struct obs_encoder {
 
 extern struct obs_encoder_info *find_encoder(const char *id);
 
-extern bool obs_encoder_initialize(obs_encoder_t encoder);
+extern bool obs_encoder_initialize(obs_encoder_t *encoder);
 
-extern void obs_encoder_start(obs_encoder_t encoder,
+extern void obs_encoder_start(obs_encoder_t *encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param);
-extern void obs_encoder_stop(obs_encoder_t encoder,
+extern void obs_encoder_stop(obs_encoder_t *encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param);
 

libobs/obs-module.c

@@ -56,7 +56,7 @@ static int load_module_exports(struct obs_module *mod, const char *path)
 	return MODULE_SUCCESS;
 }
 
-int obs_open_module(obs_module_t *module, const char *path,
+int obs_open_module(obs_module_t **module, const char *path,
 		const char *data_path)
 {
 	struct obs_module mod = {0};
@@ -91,7 +91,7 @@ int obs_open_module(obs_module_t *module, const char *path,
 	return MODULE_SUCCESS;
 }
 
-bool obs_init_module(obs_module_t module)
+bool obs_init_module(obs_module_t *module)
 {
 	if (!module || !obs)
 		return false;
@@ -106,37 +106,37 @@ bool obs_init_module(obs_module_t module)
 	return module->loaded;
 }
 
-const char *obs_get_module_file_name(obs_module_t module)
+const char *obs_get_module_file_name(obs_module_t *module)
 {
 	return module ? module->file : NULL;
 }
 
-const char *obs_get_module_name(obs_module_t module)
+const char *obs_get_module_name(obs_module_t *module)
 {
 	return (module && module->name) ? module->name() : NULL;
 }
 
-const char *obs_get_module_author(obs_module_t module)
+const char *obs_get_module_author(obs_module_t *module)
 {
 	return (module && module->author) ? module->author() : NULL;
 }
 
-const char *obs_get_module_description(obs_module_t module)
+const char *obs_get_module_description(obs_module_t *module)
 {
 	return (module && module->description) ? module->description() : NULL;
 }
 
-const char *obs_get_module_binary_path(obs_module_t module)
+const char *obs_get_module_binary_path(obs_module_t *module)
 {
 	return module ? module->bin_path : NULL;
 }
 
-const char *obs_get_module_data_path(obs_module_t module)
+const char *obs_get_module_data_path(obs_module_t *module)
 {
 	return module ? module->data_path : NULL;
 }
 
-char *obs_find_module_file(obs_module_t module, const char *file)
+char *obs_find_module_file(obs_module_t *module, const char *file)
 {
 	struct dstr output = {0};
 
@@ -166,7 +166,7 @@ void obs_add_module_path(const char *bin, const char *data)
 
 static void load_all_callback(void *param, const struct obs_module_info *info)
 {
-	obs_module_t module;
+	obs_module_t *module;
 
 	int code = obs_open_module(&module, info->bin_path, info->data_path);
 	if (code != MODULE_SUCCESS) {
@@ -287,7 +287,7 @@ static void find_modules_in_path(struct obs_module_path *omp,
 	struct dstr search_path = {0};
 	char *module_start;
 	bool search_directories = false;
-	os_glob_t gi;
+	os_glob_t *gi;
 
 	dstr_copy(&search_path, omp->bin);
 
@@ -365,11 +365,11 @@ void free_module(struct obs_module *mod)
 	bfree(mod);
 }
 
-lookup_t obs_module_load_locale(obs_module_t module, const char *default_locale,
-		const char *locale)
+lookup_t *obs_module_load_locale(obs_module_t *module,
+		const char *default_locale, const char *locale)
 {
 	struct dstr str    = {0};
-	lookup_t    lookup = NULL;
+	lookup_t    *lookup = NULL;
 
 	if (!module || !default_locale || !locale) {
 		blog(LOG_WARNING, "obs_module_load_locale: Invalid parameters");

libobs/obs-module.h

@@ -35,13 +35,13 @@
 
 /** Required: Declares a libobs module. */
 #define OBS_DECLARE_MODULE() \
-	static obs_module_t obs_module_pointer; \
-	MODULE_EXPORT void obs_module_set_pointer(obs_module_t module); \
-	void obs_module_set_pointer(obs_module_t module) \
+	static obs_module_t *obs_module_pointer; \
+	MODULE_EXPORT void obs_module_set_pointer(obs_module_t *module); \
+	void obs_module_set_pointer(obs_module_t *module) \
 	{ \
 		obs_module_pointer = module; \
 	} \
-	obs_module_t obs_current_module(void) {return obs_module_pointer;} \
+	obs_module_t *obs_current_module(void) {return obs_module_pointer;} \
 	MODULE_EXPORT uint32_t obs_module_ver(void); \
 	uint32_t obs_module_ver(void) {return LIBOBS_API_VER;}
 
@@ -66,7 +66,7 @@ MODULE_EXPORT void obs_module_free_locale(void);
 
 /** Optional: Use this macro in a module to use default locale handling. */
 #define OBS_MODULE_USE_DEFAULT_LOCALE(module_name, default_locale) \
-	lookup_t obs_module_lookup = NULL; \
+	lookup_t *obs_module_lookup = NULL; \
 	const char *obs_module_text(const char *val) \
 	{ \
 		const char *out = val; \
@@ -89,7 +89,7 @@ MODULE_EXPORT void obs_module_free_locale(void);
 MODULE_EXTERN const char *obs_module_text(const char *lookup_string);
 
 /** Helper function that returns the current module */
-MODULE_EXTERN obs_module_t obs_current_module(void);
+MODULE_EXTERN obs_module_t *obs_current_module(void);
 
 /**
  * Returns the location to a module data file associated with the current

libobs/obs-output.c

@@ -47,7 +47,7 @@ static const char *output_signals[] = {
 };
 
 static bool init_output_handlers(struct obs_output *output, const char *name,
-		obs_data_t settings)
+		obs_data_t *settings)
 {
 	if (!obs_context_data_init(&output->context, settings, name))
 		return false;
@@ -56,8 +56,8 @@ static bool init_output_handlers(struct obs_output *output, const char *name,
 	return true;
 }
 
-obs_output_t obs_output_create(const char *id, const char *name,
-		obs_data_t settings)
+obs_output_t *obs_output_create(const char *id, const char *name,
+		obs_data_t *settings)
 {
 	const struct obs_output_info *info = find_output(id);
 	struct obs_output *output;
@@ -114,7 +114,7 @@ static inline void free_packets(struct obs_output *output)
 	da_free(output->interleaved_packets);
 }
 
-void obs_output_destroy(obs_output_t output)
+void obs_output_destroy(obs_output_t *output)
 {
 	if (output) {
 		obs_context_data_remove(&output->context);
@@ -147,12 +147,12 @@ void obs_output_destroy(obs_output_t output)
 	}
 }
 
-const char *obs_output_get_name(obs_output_t output)
+const char *obs_output_get_name(obs_output_t *output)
 {
 	return output ? output->context.name : NULL;
 }
 
-bool obs_output_start(obs_output_t output)
+bool obs_output_start(obs_output_t *output)
 {
 	bool success;
 
@@ -192,7 +192,7 @@ static void log_frame_info(struct obs_output *output)
 				skipped, percentage_skipped);
 }
 
-void obs_output_stop(obs_output_t output)
+void obs_output_stop(obs_output_t *output)
 {
 	if (output) {
 		os_event_signal(output->reconnect_stop_event);
@@ -207,32 +207,32 @@ void obs_output_stop(obs_output_t output)
 	}
 }
 
-bool obs_output_active(obs_output_t output)
+bool obs_output_active(obs_output_t *output)
 {
 	return (output != NULL) ?
 		(output->active || output->reconnecting) : false;
 }
 
-static inline obs_data_t get_defaults(const struct obs_output_info *info)
+static inline obs_data_t *get_defaults(const struct obs_output_info *info)
 {
-	obs_data_t settings = obs_data_create();
+	obs_data_t *settings = obs_data_create();
 	if (info->get_defaults)
 		info->get_defaults(settings);
 	return settings;
 }
 
-obs_data_t obs_output_defaults(const char *id)
+obs_data_t *obs_output_defaults(const char *id)
 {
 	const struct obs_output_info *info = find_output(id);
 	return (info) ? get_defaults(info) : NULL;
 }
 
-obs_properties_t obs_get_output_properties(const char *id)
+obs_properties_t *obs_get_output_properties(const char *id)
 {
 	const struct obs_output_info *info = find_output(id);
 	if (info && info->get_properties) {
-		obs_data_t       defaults = get_defaults(info);
-		obs_properties_t properties;
+		obs_data_t       *defaults = get_defaults(info);
+		obs_properties_t *properties;
 
 		properties = info->get_properties();
 		obs_properties_apply_settings(properties, defaults);
@@ -242,10 +242,10 @@ 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(obs_output_t *output)
 {
 	if (output && output->info.get_properties) {
-		obs_properties_t props;
+		obs_properties_t *props;
 		props = output->info.get_properties();
 		obs_properties_apply_settings(props, output->context.settings);
 		return props;
@@ -254,7 +254,7 @@ obs_properties_t obs_output_properties(obs_output_t output)
 	return NULL;
 }
 
-void obs_output_update(obs_output_t output, obs_data_t settings)
+void obs_output_update(obs_output_t *output, obs_data_t *settings)
 {
 	if (!output) return;
 
@@ -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(obs_output_t *output)
 {
 	if (!output)
 		return NULL;
@@ -274,28 +274,28 @@ 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(obs_output_t *output)
 {
 	return output ? (output->info.pause != NULL) : false;
 }
 
-void obs_output_pause(obs_output_t output)
+void obs_output_pause(obs_output_t *output)
 {
 	if (output && output->info.pause)
 		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(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(obs_output_t *output)
 {
 	return output ? output->context.procs : NULL;
 }
 
-void obs_output_set_media(obs_output_t output, video_t video, audio_t audio)
+void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
 {
 	if (!output)
 		return;
@@ -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(obs_output_t *output)
 {
 	return output ? output->video : NULL;
 }
 
-audio_t obs_output_audio(obs_output_t output)
+audio_t *obs_output_audio(obs_output_t *output)
 {
 	return output ? output->audio : NULL;
 }
@@ -325,7 +325,7 @@ void obs_output_remove_encoder(struct obs_output *output,
 		output->audio_encoder = NULL;
 }
 
-void obs_output_set_video_encoder(obs_output_t output, obs_encoder_t encoder)
+void obs_output_set_video_encoder(obs_output_t *output, obs_encoder_t *encoder)
 {
 	if (!output) return;
 	if (output->video_encoder == encoder) return;
@@ -341,7 +341,7 @@ void obs_output_set_video_encoder(obs_output_t output, obs_encoder_t encoder)
 				output->scaled_width, output->scaled_height);
 }
 
-void obs_output_set_audio_encoder(obs_output_t output, obs_encoder_t encoder)
+void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder)
 {
 	if (!output) return;
 	if (output->audio_encoder == encoder) return;
@@ -352,17 +352,17 @@ 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(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(obs_output_t *output)
 {
 	return output ? output->audio_encoder : NULL;
 }
 
-void obs_output_set_service(obs_output_t output, obs_service_t service)
+void obs_output_set_service(obs_output_t *output, obs_service_t *service)
 {
 	if (!output || output->active || !service || service->active) return;
 
@@ -373,12 +373,12 @@ 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(obs_output_t *output)
 {
 	return output ? output->service : NULL;
 }
 
-void obs_output_set_reconnect_settings(obs_output_t output,
+void obs_output_set_reconnect_settings(obs_output_t *output,
 		int retry_count, int retry_sec)
 {
 	if (!output) return;
@@ -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(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(obs_output_t *output)
 {
 	if (!output || !output->info.get_dropped_frames)
 		return 0;
@@ -403,12 +403,12 @@ 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(obs_output_t *output)
 {
 	return output ? output->total_frames : 0;
 }
 
-void obs_output_set_preferred_size(obs_output_t output, uint32_t width,
+void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
 		uint32_t height)
 {
 	if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 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(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(obs_output_t *output)
 {
 	if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
 		return 0;
@@ -457,7 +457,7 @@ uint32_t obs_output_get_height(obs_output_t output)
 			video_output_get_height(output->video);
 }
 
-void obs_output_set_video_conversion(obs_output_t output,
+void obs_output_set_video_conversion(obs_output_t *output,
 		const struct video_scale_info *conversion)
 {
 	if (!output || !conversion) return;
@@ -466,7 +466,7 @@ void obs_output_set_video_conversion(obs_output_t output,
 	output->video_conversion_set = true;
 }
 
-void obs_output_set_audio_conversion(obs_output_t output,
+void obs_output_set_audio_conversion(obs_output_t *output,
 		const struct audio_convert_info *conversion)
 {
 	if (!output || !conversion) return;
@@ -760,7 +760,7 @@ 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(obs_output_t *output, uint32_t flags)
 {
 	bool encoded, has_video, has_audio, has_service;
 
@@ -774,7 +774,7 @@ bool obs_output_can_begin_data_capture(obs_output_t output, uint32_t flags)
 			has_service);
 }
 
-bool obs_output_initialize_encoders(obs_output_t output, uint32_t flags)
+bool obs_output_initialize_encoders(obs_output_t *output, uint32_t flags)
 {
 	bool encoded, has_video, has_audio, has_service;
 
@@ -803,7 +803,7 @@ bool obs_output_initialize_encoders(obs_output_t output, uint32_t flags)
 	return true;
 }
 
-bool obs_output_begin_data_capture(obs_output_t output, uint32_t flags)
+bool obs_output_begin_data_capture(obs_output_t *output, uint32_t flags)
 {
 	bool encoded, has_video, has_audio, has_service;
 
@@ -836,7 +836,7 @@ bool obs_output_begin_data_capture(obs_output_t output, uint32_t flags)
 	return true;
 }
 
-void obs_output_end_data_capture(obs_output_t output)
+void obs_output_end_data_capture(obs_output_t *output)
 {
 	bool encoded, has_video, has_audio, has_service;
 	void (*encoded_callback)(void *data, struct encoder_packet *packet);
@@ -925,7 +925,7 @@ static void output_reconnect(struct obs_output *output)
 	}
 }
 
-void obs_output_signal_stop(obs_output_t output, int code)
+void obs_output_signal_stop(obs_output_t *output, int code)
 {
 	if (!output)
 		return;

libobs/obs-output.h

@@ -33,7 +33,7 @@ struct obs_output_info {
 
 	const char *(*get_name)(void);
 
-	void *(*create)(obs_data_t settings, obs_output_t output);
+	void *(*create)(obs_data_t *settings, obs_output_t *output);
 	void (*destroy)(void *data);
 
 	bool (*start)(void *data);
@@ -45,11 +45,11 @@ struct obs_output_info {
 	void (*encoded_packet)(void *data, struct encoder_packet *packet);
 
 	/* optional */
-	void (*update)(void *data, obs_data_t settings);
+	void (*update)(void *data, obs_data_t *settings);
 
-	void (*get_defaults)(obs_data_t settings);
+	void (*get_defaults)(obs_data_t *settings);
 
-	obs_properties_t (*get_properties)(void);
+	obs_properties_t *(*get_properties)(void);
 
 	void (*pause)(void *data);
 

libobs/obs-properties.c

@@ -110,7 +110,7 @@ struct obs_properties {
 	struct obs_property     **last;
 };
 
-obs_properties_t obs_properties_create(void)
+obs_properties_t *obs_properties_create(void)
 {
 	struct obs_properties *props;
 	props = bzalloc(sizeof(struct obs_properties));
@@ -118,7 +118,7 @@ obs_properties_t obs_properties_create(void)
 	return props;
 }
 
-void obs_properties_set_param(obs_properties_t props,
+void obs_properties_set_param(obs_properties_t *props,
 		void *param, void (*destroy)(void *param))
 {
 	if (!props)
@@ -131,12 +131,12 @@ void obs_properties_set_param(obs_properties_t props,
 	props->destroy = destroy;
 }
 
-void *obs_properties_get_param(obs_properties_t props)
+void *obs_properties_get_param(obs_properties_t *props)
 {
 	return props ? props->param : NULL;
 }
 
-obs_properties_t obs_properties_create_param(void *param,
+obs_properties_t *obs_properties_create_param(void *param,
 		void (*destroy)(void *param))
 {
 	struct obs_properties *props = obs_properties_create();
@@ -154,7 +154,7 @@ static void obs_property_destroy(struct obs_property *property)
 	bfree(property);
 }
 
-void obs_properties_destroy(obs_properties_t props)
+void obs_properties_destroy(obs_properties_t *props)
 {
 	if (props) {
 		struct obs_property *p = props->first_property;
@@ -172,12 +172,12 @@ void obs_properties_destroy(obs_properties_t props)
 	}
 }
 
-obs_property_t obs_properties_first(obs_properties_t props)
+obs_property_t *obs_properties_first(obs_properties_t *props)
 {
 	return (props != NULL) ? props->first_property : NULL;
 }
 
-obs_property_t obs_properties_get(obs_properties_t props, const char *name)
+obs_property_t *obs_properties_get(obs_properties_t *props, const char *name)
 {
 	struct obs_property *property;
 
@@ -195,7 +195,7 @@ obs_property_t obs_properties_get(obs_properties_t props, const char *name)
 	return NULL;
 }
 
-void obs_properties_apply_settings(obs_properties_t props, obs_data_t settings)
+void obs_properties_apply_settings(obs_properties_t *props, obs_data_t *settings)
 {
 	struct obs_property *p = props->first_property;
 
@@ -282,15 +282,15 @@ static inline void *get_type_data(struct obs_property *prop,
 	return get_property_data(prop);
 }
 
-obs_property_t obs_properties_add_bool(obs_properties_t props, const char *name,
-		const char *desc)
+obs_property_t *obs_properties_add_bool(obs_properties_t *props,
+		const char *name, const char *desc)
 {
 	if (!props || has_prop(props, name)) return NULL;
 	return new_prop(props, name, desc, OBS_PROPERTY_BOOL);
 }
 
-obs_property_t obs_properties_add_int(obs_properties_t props, const char *name,
-		const char *desc, int min, int max, int step)
+obs_property_t *obs_properties_add_int(obs_properties_t *props,
+		const char *name, const char *desc, int min, int max, int step)
 {
 	if (!props || has_prop(props, name)) return NULL;
 
@@ -302,7 +302,7 @@ obs_property_t obs_properties_add_int(obs_properties_t props, const char *name,
 	return p;
 }
 
-obs_property_t obs_properties_add_float(obs_properties_t props,
+obs_property_t *obs_properties_add_float(obs_properties_t *props,
 		const char *name, const char *desc,
 		double min, double max, double step)
 {
@@ -317,8 +317,8 @@ obs_property_t obs_properties_add_float(obs_properties_t props,
 	return p;
 }
 
-obs_property_t obs_properties_add_text(obs_properties_t props, const char *name,
-		const char *desc, enum obs_text_type type)
+obs_property_t *obs_properties_add_text(obs_properties_t *props,
+		const char *name, const char *desc, enum obs_text_type type)
 {
 	if (!props || has_prop(props, name)) return NULL;
 
@@ -328,9 +328,9 @@ obs_property_t obs_properties_add_text(obs_properties_t props, const char *name,
 	return p;
 }
 
-obs_property_t obs_properties_add_path(obs_properties_t props, const char *name,
-		const char *desc, enum obs_path_type type, const char *filter,
-		const char *default_path)
+obs_property_t *obs_properties_add_path(obs_properties_t *props,
+		const char *name, const char *desc, enum obs_path_type type,
+		const char *filter, const char *default_path)
 {
 	if (!props || has_prop(props, name)) return NULL;
 
@@ -345,7 +345,7 @@ obs_property_t obs_properties_add_path(obs_properties_t props, const char *name,
 	return p;
 }
 
-obs_property_t obs_properties_add_list(obs_properties_t props,
+obs_property_t *obs_properties_add_list(obs_properties_t *props,
 		const char *name, const char *desc,
 		enum obs_combo_type type,
 		enum obs_combo_format format)
@@ -367,14 +367,14 @@ obs_property_t obs_properties_add_list(obs_properties_t props,
 	return p;
 }
 
-obs_property_t obs_properties_add_color(obs_properties_t props,
+obs_property_t *obs_properties_add_color(obs_properties_t *props,
 		const char *name, const char *desc)
 {
 	if (!props || has_prop(props, name)) return NULL;
 	return new_prop(props, name, desc, OBS_PROPERTY_COLOR);
 }
 
-obs_property_t obs_properties_add_button(obs_properties_t props,
+obs_property_t *obs_properties_add_button(obs_properties_t *props,
 		const char *name, const char *text,
 		obs_property_clicked_t callback)
 {
@@ -387,7 +387,7 @@ obs_property_t obs_properties_add_button(obs_properties_t props,
 	return p;
 }
 
-obs_property_t obs_properties_add_font(obs_properties_t props,
+obs_property_t *obs_properties_add_font(obs_properties_t *props,
 		const char *name, const char *desc)
 {
 	if (!props || has_prop(props, name)) return NULL;
@@ -416,7 +416,7 @@ static inline struct list_data *get_list_fmt_data(struct obs_property *p,
 
 /* ------------------------------------------------------------------------- */
 
-bool obs_property_next(obs_property_t *p)
+bool obs_property_next(obs_property_t **p)
 {
 	if (!p || !*p)
 		return false;
@@ -425,20 +425,20 @@ bool obs_property_next(obs_property_t *p)
 	return *p != NULL;
 }
 
-void obs_property_set_modified_callback(obs_property_t p,
+void obs_property_set_modified_callback(obs_property_t *p,
 		obs_property_modified_t modified)
 {
 	if (p) p->modified = modified;
 }
 
-bool obs_property_modified(obs_property_t p, obs_data_t settings)
+bool obs_property_modified(obs_property_t *p, obs_data_t *settings)
 {
 	if (p && p->modified)
 		return p->modified(p->parent, p, settings);
 	return false;
 }
 
-bool obs_property_button_clicked(obs_property_t p, void *obj)
+bool obs_property_button_clicked(obs_property_t *p, void *obj)
 {
 	struct obs_context_data *context = obj;
 	if (p) {
@@ -451,114 +451,114 @@ bool obs_property_button_clicked(obs_property_t p, void *obj)
 	return false;
 }
 
-void obs_property_set_visible(obs_property_t p, bool visible)
+void obs_property_set_visible(obs_property_t *p, bool visible)
 {
 	if (p) p->visible = visible;
 }
 
-void obs_property_set_enabled(obs_property_t p, bool enabled)
+void obs_property_set_enabled(obs_property_t *p, bool enabled)
 {
 	if (p) p->enabled = enabled;
 }
 
-const char *obs_property_name(obs_property_t p)
+const char *obs_property_name(obs_property_t *p)
 {
 	return p ? p->name : NULL;
 }
 
-const char *obs_property_description(obs_property_t p)
+const char *obs_property_description(obs_property_t *p)
 {
 	return p ? p->desc : NULL;
 }
 
-enum obs_property_type obs_property_get_type(obs_property_t p)
+enum obs_property_type obs_property_get_type(obs_property_t *p)
 {
 	return p ? p->type : OBS_PROPERTY_INVALID;
 }
 
-bool obs_property_enabled(obs_property_t p)
+bool obs_property_enabled(obs_property_t *p)
 {
 	return p ? p->enabled : false;
 }
 
-bool obs_property_visible(obs_property_t p)
+bool obs_property_visible(obs_property_t *p)
 {
 	return p ? p->visible : false;
 }
 
-int obs_property_int_min(obs_property_t p)
+int obs_property_int_min(obs_property_t *p)
 {
 	struct int_data *data = get_type_data(p, OBS_PROPERTY_INT);
 	return data ? data->min : 0;
 }
 
-int obs_property_int_max(obs_property_t p)
+int obs_property_int_max(obs_property_t *p)
 {
 	struct int_data *data = get_type_data(p, OBS_PROPERTY_INT);
 	return data ? data->max : 0;
 }
 
-int obs_property_int_step(obs_property_t p)
+int obs_property_int_step(obs_property_t *p)
 {
 	struct int_data *data = get_type_data(p, OBS_PROPERTY_INT);
 	return data ? data->step : 0;
 }
 
-double obs_property_float_min(obs_property_t p)
+double obs_property_float_min(obs_property_t *p)
 {
 	struct float_data *data = get_type_data(p, OBS_PROPERTY_FLOAT);
 	return data ? data->min : 0;
 }
 
-double obs_property_float_max(obs_property_t p)
+double obs_property_float_max(obs_property_t *p)
 {
 	struct float_data *data = get_type_data(p, OBS_PROPERTY_FLOAT);
 	return data ? data->max : 0;
 }
 
-double obs_property_float_step(obs_property_t p)
+double obs_property_float_step(obs_property_t *p)
 {
 	struct float_data *data = get_type_data(p, OBS_PROPERTY_FLOAT);
 	return data ? data->step : 0;
 }
 
-enum obs_text_type obs_proprety_text_type(obs_property_t p)
+enum obs_text_type obs_proprety_text_type(obs_property_t *p)
 {
 	struct text_data *data = get_type_data(p, OBS_PROPERTY_TEXT);
 	return data ? data->type : OBS_TEXT_DEFAULT;
 }
 
-enum obs_path_type obs_property_path_type(obs_property_t p)
+enum obs_path_type obs_property_path_type(obs_property_t *p)
 {
 	struct path_data *data = get_type_data(p, OBS_PROPERTY_PATH);
 	return data ? data->type : OBS_PATH_DIRECTORY;
 }
 
-const char *obs_property_path_filter(obs_property_t p)
+const char *obs_property_path_filter(obs_property_t *p)
 {
 	struct path_data *data = get_type_data(p, OBS_PROPERTY_PATH);
 	return data ? data->filter : NULL;
 }
 
-const char *obs_property_path_default_path(obs_property_t p)
+const char *obs_property_path_default_path(obs_property_t *p)
 {
 	struct path_data *data = get_type_data(p, OBS_PROPERTY_PATH);
 	return data ? data->default_path : NULL;
 }
 
-enum obs_combo_type obs_property_list_type(obs_property_t p)
+enum obs_combo_type obs_property_list_type(obs_property_t *p)
 {
 	struct list_data *data = get_list_data(p);
 	return data ? data->type : OBS_COMBO_TYPE_INVALID;
 }
 
-enum obs_combo_format obs_property_list_format(obs_property_t p)
+enum obs_combo_format obs_property_list_format(obs_property_t *p)
 {
 	struct list_data *data = get_list_data(p);
 	return data ? data->format : OBS_COMBO_FORMAT_INVALID;
 }
 
-void obs_property_list_clear(obs_property_t p)
+void obs_property_list_clear(obs_property_t *p)
 {
 	struct list_data *data = get_list_data(p);
 	if (data)
@@ -581,7 +581,7 @@ static size_t add_item(struct list_data *data, const char *name,
 	return da_push_back(data->items, &item);
 }
 
-size_t obs_property_list_add_string(obs_property_t p,
+size_t obs_property_list_add_string(obs_property_t *p,
 		const char *name, const char *val)
 {
 	struct list_data *data = get_list_data(p);
@@ -590,7 +590,7 @@ size_t obs_property_list_add_string(obs_property_t p,
 	return 0;
 }
 
-size_t obs_property_list_add_int(obs_property_t p,
+size_t obs_property_list_add_int(obs_property_t *p,
 		const char *name, long long val)
 {
 	struct list_data *data = get_list_data(p);
@@ -599,7 +599,7 @@ size_t obs_property_list_add_int(obs_property_t p,
 	return 0;
 }
 
-size_t obs_property_list_add_float(obs_property_t p,
+size_t obs_property_list_add_float(obs_property_t *p,
 		const char *name, double val)
 {
 	struct list_data *data = get_list_data(p);
@@ -608,7 +608,7 @@ size_t obs_property_list_add_float(obs_property_t p,
 	return 0;
 }
 
-void obs_property_list_item_remove(obs_property_t p, size_t idx)
+void obs_property_list_item_remove(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_data(p);
 	if (data && idx < data->items.num) {
@@ -617,20 +617,21 @@ void obs_property_list_item_remove(obs_property_t p, size_t idx)
 	}
 }
 
-size_t obs_property_list_item_count(obs_property_t p)
+size_t obs_property_list_item_count(obs_property_t *p)
 {
 	struct list_data *data = get_list_data(p);
 	return data ? data->items.num : 0;
 }
 
-bool obs_property_list_item_disabled(obs_property_t p, size_t idx)
+bool obs_property_list_item_disabled(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_data(p);
 	return (data && idx < data->items.num) ?
 		data->items.array[idx].disabled : false;
 }
 
-void obs_property_list_item_disable(obs_property_t p, size_t idx, bool disabled)
+void obs_property_list_item_disable(obs_property_t *p, size_t idx,
+		bool disabled)
 {
 	struct list_data *data = get_list_data(p);
 	if (!data || idx >= data->items.num)
@@ -638,28 +639,28 @@ void obs_property_list_item_disable(obs_property_t p, size_t idx, bool disabled)
 	data->items.array[idx].disabled = disabled;
 }
 
-const char *obs_property_list_item_name(obs_property_t p, size_t idx)
+const char *obs_property_list_item_name(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_data(p);
 	return (data && idx < data->items.num) ?
 		data->items.array[idx].name : NULL;
 }
 
-const char *obs_property_list_item_string(obs_property_t p, size_t idx)
+const char *obs_property_list_item_string(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_fmt_data(p, OBS_COMBO_FORMAT_STRING);
 	return (data && idx < data->items.num) ?
 		data->items.array[idx].str : "";
 }
 
-long long obs_property_list_item_int(obs_property_t p, size_t idx)
+long long obs_property_list_item_int(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_fmt_data(p, OBS_COMBO_FORMAT_INT);
 	return (data && idx < data->items.num) ?
 		data->items.array[idx].ll : 0;
 }
 
-double obs_property_list_item_float(obs_property_t p, size_t idx)
+double obs_property_list_item_float(obs_property_t *p, size_t idx)
 {
 	struct list_data *data = get_list_fmt_data(p, OBS_COMBO_FORMAT_FLOAT);
 	return (data && idx < data->items.num) ?

libobs/obs-properties.h

@@ -68,28 +68,28 @@ enum obs_text_type {
 
 struct obs_properties;
 struct obs_property;
-typedef struct obs_properties *obs_properties_t;
-typedef struct obs_property   *obs_property_t;
+typedef struct obs_properties obs_properties_t;
+typedef struct obs_property   obs_property_t;
 
 /* ------------------------------------------------------------------------- */
 
-EXPORT obs_properties_t obs_properties_create(void);
-EXPORT obs_properties_t obs_properties_create_param(void *param,
+EXPORT obs_properties_t *obs_properties_create(void);
+EXPORT obs_properties_t *obs_properties_create_param(void *param,
 		void (*destroy)(void *param));
-EXPORT void obs_properties_destroy(obs_properties_t props);
+EXPORT void obs_properties_destroy(obs_properties_t *props);
 
-EXPORT void obs_properties_set_param(obs_properties_t props,
+EXPORT void obs_properties_set_param(obs_properties_t *props,
 		void *param, void (*destroy)(void *param));
-EXPORT void *obs_properties_get_param(obs_properties_t props);
+EXPORT void *obs_properties_get_param(obs_properties_t *props);
 
-EXPORT obs_property_t obs_properties_first(obs_properties_t props);
+EXPORT obs_property_t *obs_properties_first(obs_properties_t *props);
 
-EXPORT obs_property_t obs_properties_get(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_get(obs_properties_t *props,
 		const char *property);
 
 /* used internally by libobs */
-extern void obs_properties_apply_settings(obs_properties_t props,
-		obs_data_t settings);
+extern void obs_properties_apply_settings(obs_properties_t *props,
+		obs_data_t *settings);
 
 /* ------------------------------------------------------------------------- */
 
@@ -98,21 +98,21 @@ extern void obs_properties_apply_settings(obs_properties_t props,
  * need to be refreshed due to changes to the property layout, return true,
  * otherwise return false.
  */
-typedef bool (*obs_property_clicked_t)(obs_properties_t props,
-		obs_property_t property, void *data);
+typedef bool (*obs_property_clicked_t)(obs_properties_t *props,
+		obs_property_t *property, void *data);
 
-EXPORT obs_property_t obs_properties_add_bool(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_bool(obs_properties_t *props,
 		const char *name, const char *description);
 
-EXPORT obs_property_t obs_properties_add_int(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_int(obs_properties_t *props,
 		const char *name, const char *description,
 		int min, int max, int step);
 
-EXPORT obs_property_t obs_properties_add_float(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_float(obs_properties_t *props,
 		const char *name, const char *description,
 		double min, double max, double step);
 
-EXPORT obs_property_t obs_properties_add_text(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_text(obs_properties_t *props,
 		const char *name, const char *description,
 		enum obs_text_type type);
 
@@ -132,19 +132,19 @@ EXPORT obs_property_t obs_properties_add_text(obs_properties_t props,
  *                      double semi-colens.  If multiple file types in a
  *                      filter, separate with space.
  */
-EXPORT obs_property_t obs_properties_add_path(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_path(obs_properties_t *props,
 		const char *name, const char *description,
 		enum obs_path_type type, const char *filter,
 		const char *default_path);
 
-EXPORT obs_property_t obs_properties_add_list(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_list(obs_properties_t *props,
 		const char *name, const char *description,
 		enum obs_combo_type type, enum obs_combo_format format);
 
-EXPORT obs_property_t obs_properties_add_color(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_color(obs_properties_t *props,
 		const char *name, const char *description);
 
-EXPORT obs_property_t obs_properties_add_button(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_button(obs_properties_t *props,
 		const char *name, const char *text,
 		obs_property_clicked_t callback);
 
@@ -157,7 +157,7 @@ EXPORT obs_property_t obs_properties_add_button(obs_properties_t props,
  *   size:   size integer
  *   flags:  font flags integer (OBS_FONT_* defined above)
  */
-EXPORT obs_property_t obs_properties_add_font(obs_properties_t props,
+EXPORT obs_property_t *obs_properties_add_font(obs_properties_t *props,
 		const char *name, const char *description);
 
 /* ------------------------------------------------------------------------- */
@@ -167,59 +167,59 @@ EXPORT obs_property_t obs_properties_add_font(obs_properties_t props,
  * need to be refreshed due to changes to the property layout, return true,
  * otherwise return false.
  */
-typedef bool (*obs_property_modified_t)(obs_properties_t props,
-		obs_property_t property, obs_data_t settings);
+typedef bool (*obs_property_modified_t)(obs_properties_t *props,
+		obs_property_t *property, obs_data_t *settings);
 
-EXPORT void obs_property_set_modified_callback(obs_property_t p,
+EXPORT void obs_property_set_modified_callback(obs_property_t *p,
 		obs_property_modified_t modified);
 
-EXPORT bool obs_property_modified(obs_property_t p, obs_data_t settings);
-EXPORT bool obs_property_button_clicked(obs_property_t p, void *obj);
+EXPORT bool obs_property_modified(obs_property_t *p, obs_data_t *settings);
+EXPORT bool obs_property_button_clicked(obs_property_t *p, void *obj);
 
-EXPORT void obs_property_set_visible(obs_property_t p, bool visible);
-EXPORT void obs_property_set_enabled(obs_property_t p, bool enabled);
+EXPORT void obs_property_set_visible(obs_property_t *p, bool visible);
+EXPORT void obs_property_set_enabled(obs_property_t *p, bool enabled);
 
-EXPORT const char *           obs_property_name(obs_property_t p);
-EXPORT const char *           obs_property_description(obs_property_t p);
-EXPORT enum obs_property_type obs_property_get_type(obs_property_t p);
-EXPORT bool                   obs_property_enabled(obs_property_t p);
-EXPORT bool                   obs_property_visible(obs_property_t p);
+EXPORT const char *           obs_property_name(obs_property_t *p);
+EXPORT const char *           obs_property_description(obs_property_t *p);
+EXPORT enum obs_property_type obs_property_get_type(obs_property_t *p);
+EXPORT bool                   obs_property_enabled(obs_property_t *p);
+EXPORT bool                   obs_property_visible(obs_property_t *p);
 
-EXPORT bool                   obs_property_next(obs_property_t *p);
+EXPORT bool                   obs_property_next(obs_property_t **p);
 
-EXPORT int                    obs_property_int_min(obs_property_t p);
-EXPORT int                    obs_property_int_max(obs_property_t p);
-EXPORT int                    obs_property_int_step(obs_property_t p);
-EXPORT double                 obs_property_float_min(obs_property_t p);
-EXPORT double                 obs_property_float_max(obs_property_t p);
-EXPORT double                 obs_property_float_step(obs_property_t p);
-EXPORT enum obs_text_type     obs_proprety_text_type(obs_property_t p);
-EXPORT enum obs_path_type     obs_property_path_type(obs_property_t p);
-EXPORT const char *           obs_property_path_filter(obs_property_t p);
-EXPORT const char *           obs_property_path_default_path(obs_property_t p);
-EXPORT enum obs_combo_type    obs_property_list_type(obs_property_t p);
-EXPORT enum obs_combo_format  obs_property_list_format(obs_property_t p);
+EXPORT int                    obs_property_int_min(obs_property_t *p);
+EXPORT int                    obs_property_int_max(obs_property_t *p);
+EXPORT int                    obs_property_int_step(obs_property_t *p);
+EXPORT double                 obs_property_float_min(obs_property_t *p);
+EXPORT double                 obs_property_float_max(obs_property_t *p);
+EXPORT double                 obs_property_float_step(obs_property_t *p);
+EXPORT enum obs_text_type     obs_proprety_text_type(obs_property_t *p);
+EXPORT enum obs_path_type     obs_property_path_type(obs_property_t *p);
+EXPORT const char *           obs_property_path_filter(obs_property_t *p);
+EXPORT const char *           obs_property_path_default_path(obs_property_t *p);
+EXPORT enum obs_combo_type    obs_property_list_type(obs_property_t *p);
+EXPORT enum obs_combo_format  obs_property_list_format(obs_property_t *p);
 
-EXPORT void obs_property_list_clear(obs_property_t p);
+EXPORT void obs_property_list_clear(obs_property_t *p);
 
-EXPORT size_t obs_property_list_add_string(obs_property_t p,
+EXPORT size_t obs_property_list_add_string(obs_property_t *p,
 		const char *name, const char *val);
-EXPORT size_t obs_property_list_add_int(obs_property_t p,
+EXPORT size_t obs_property_list_add_int(obs_property_t *p,
 		const char *name, long long val);
-EXPORT size_t obs_property_list_add_float(obs_property_t p,
+EXPORT size_t obs_property_list_add_float(obs_property_t *p,
 		const char *name, double val);
 
-EXPORT void obs_property_list_item_disable(obs_property_t p, size_t idx,
+EXPORT void obs_property_list_item_disable(obs_property_t *p, size_t idx,
 								bool disabled);
-EXPORT bool obs_property_list_item_disabled(obs_property_t p, size_t idx);
+EXPORT bool obs_property_list_item_disabled(obs_property_t *p, size_t idx);
 
-EXPORT void obs_property_list_item_remove(obs_property_t p, size_t idx);
+EXPORT void obs_property_list_item_remove(obs_property_t *p, size_t idx);
 
-EXPORT size_t      obs_property_list_item_count(obs_property_t p);
-EXPORT const char *obs_property_list_item_name(obs_property_t p, size_t idx);
-EXPORT const char *obs_property_list_item_string(obs_property_t p, size_t idx);
-EXPORT long long   obs_property_list_item_int(obs_property_t p, size_t idx);
-EXPORT double      obs_property_list_item_float(obs_property_t p, size_t idx);
+EXPORT size_t      obs_property_list_item_count(obs_property_t *p);
+EXPORT const char *obs_property_list_item_name(obs_property_t *p, size_t idx);
+EXPORT const char *obs_property_list_item_string(obs_property_t *p, size_t idx);
+EXPORT long long   obs_property_list_item_int(obs_property_t *p, size_t idx);
+EXPORT double      obs_property_list_item_float(obs_property_t *p, size_t idx);
 
 #ifdef __cplusplus
 }

libobs/obs-scene.c

@@ -49,7 +49,7 @@ static const char *scene_getname(void)
 	return "Scene";
 }
 
-static void *scene_create(obs_data_t settings, struct obs_source *source)
+static void *scene_create(obs_data_t *settings, struct obs_source *source)
 {
 	pthread_mutexattr_t attr;
 	struct obs_scene *scene = bmalloc(sizeof(struct obs_scene));
@@ -297,7 +297,7 @@ static inline bool source_size_changed(struct obs_scene_item *item)
 	return item->last_width != width || item->last_height != height;
 }
 
-static void scene_video_render(void *data, gs_effect_t effect)
+static void scene_video_render(void *data, gs_effect_t *effect)
 {
 	struct obs_scene *scene = data;
 	struct obs_scene_item *item;
@@ -331,10 +331,10 @@ static void scene_video_render(void *data, gs_effect_t effect)
 	UNUSED_PARAMETER(effect);
 }
 
-static void scene_load_item(struct obs_scene *scene, obs_data_t item_data)
+static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data)
 {
 	const char            *name = obs_data_get_string(item_data, "name");
-	obs_source_t          source = obs_get_source_by_name(name);
+	obs_source_t          *source = obs_get_source_by_name(name);
 	struct obs_scene_item *item;
 
 	if (!source) {
@@ -366,9 +366,9 @@ static void scene_load_item(struct obs_scene *scene, obs_data_t item_data)
 	update_item_transform(item);
 }
 
-static void scene_load(void *scene, obs_data_t settings)
+static void scene_load(void *scene, obs_data_t *settings)
 {
-	obs_data_array_t items = obs_data_get_array(settings, "items");
+	obs_data_array_t *items = obs_data_get_array(settings, "items");
 	size_t           count, i;
 
 	remove_all_items(scene);
@@ -378,7 +378,7 @@ static void scene_load(void *scene, obs_data_t settings)
 	count = obs_data_array_count(items);
 
 	for (i = 0; i < count; i++) {
-		obs_data_t item_data = obs_data_array_item(items, i);
+		obs_data_t *item_data = obs_data_array_item(items, i);
 		scene_load_item(scene, item_data);
 		obs_data_release(item_data);
 	}
@@ -386,9 +386,10 @@ static void scene_load(void *scene, obs_data_t settings)
 	obs_data_array_release(items);
 }
 
-static void scene_save_item(obs_data_array_t array, struct obs_scene_item *item)
+static void scene_save_item(obs_data_array_t *array,
+		struct obs_scene_item *item)
 {
-	obs_data_t item_data = obs_data_create();
+	obs_data_t *item_data = obs_data_create();
 	const char *name     = obs_source_get_name(item->source);
 
 	obs_data_set_string(item_data, "name",         name);
@@ -405,10 +406,10 @@ static void scene_save_item(obs_data_array_t array, struct obs_scene_item *item)
 	obs_data_release(item_data);
 }
 
-static void scene_save(void *data, obs_data_t settings)
+static void scene_save(void *data, obs_data_t *settings)
 {
 	struct obs_scene      *scene = data;
-	obs_data_array_t      array  = obs_data_array_create();
+	obs_data_array_t      *array  = obs_data_array_create();
 	struct obs_scene_item *item;
 
 	pthread_mutex_lock(&scene->mutex);
@@ -453,31 +454,31 @@ const struct obs_source_info scene_info =
 	.enum_sources  = scene_enum_sources
 };
 
-obs_scene_t obs_scene_create(const char *name)
+obs_scene_t *obs_scene_create(const char *name)
 {
 	struct obs_source *source =
 		obs_source_create(OBS_SOURCE_TYPE_INPUT, "scene", name, NULL);
 	return source->context.data;
 }
 
-void obs_scene_addref(obs_scene_t scene)
+void obs_scene_addref(obs_scene_t *scene)
 {
 	if (scene)
 		obs_source_addref(scene->source);
 }
 
-void obs_scene_release(obs_scene_t scene)
+void obs_scene_release(obs_scene_t *scene)
 {
 	if (scene)
 		obs_source_release(scene->source);
 }
 
-obs_source_t obs_scene_get_source(obs_scene_t scene)
+obs_source_t *obs_scene_get_source(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(obs_source_t *source)
 {
 	if (!source || source->info.id != scene_info.id)
 		return NULL;
@@ -485,7 +486,7 @@ obs_scene_t obs_scene_from_source(obs_source_t source)
 	return source->context.data;
 }
 
-obs_sceneitem_t obs_scene_find_source(obs_scene_t scene, const char *name)
+obs_sceneitem_t *obs_scene_find_source(obs_scene_t *scene, const char *name)
 {
 	struct obs_scene_item *item;
 
@@ -507,8 +508,8 @@ obs_sceneitem_t obs_scene_find_source(obs_scene_t scene, const char *name)
 	return item;
 }
 
-void obs_scene_enum_items(obs_scene_t scene,
-		bool (*callback)(obs_scene_t, obs_sceneitem_t, void*),
+void obs_scene_enum_items(obs_scene_t *scene,
+		bool (*callback)(obs_scene_t*, obs_sceneitem_t*, void*),
 		void *param)
 {
 	struct obs_scene_item *item;
@@ -537,7 +538,7 @@ void obs_scene_enum_items(obs_scene_t scene,
 	pthread_mutex_unlock(&scene->mutex);
 }
 
-obs_sceneitem_t obs_scene_add(obs_scene_t scene, obs_source_t source)
+obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source)
 {
 	struct obs_scene_item *last;
 	struct obs_scene_item *item;
@@ -588,7 +589,7 @@ obs_sceneitem_t obs_scene_add(obs_scene_t scene, obs_source_t source)
 	return item;
 }
 
-static void obs_sceneitem_destroy(obs_sceneitem_t item)
+static void obs_sceneitem_destroy(obs_sceneitem_t *item)
 {
 	if (item) {
 		if (item->source)
@@ -597,13 +598,13 @@ static void obs_sceneitem_destroy(obs_sceneitem_t item)
 	}
 }
 
-void obs_sceneitem_addref(obs_sceneitem_t item)
+void obs_sceneitem_addref(obs_sceneitem_t *item)
 {
 	if (item)
 		os_atomic_inc_long(&item->ref);
 }
 
-void obs_sceneitem_release(obs_sceneitem_t item)
+void obs_sceneitem_release(obs_sceneitem_t *item)
 {
 	if (!item)
 		return;
@@ -612,9 +613,9 @@ void obs_sceneitem_release(obs_sceneitem_t item)
 		obs_sceneitem_destroy(item);
 }
 
-void obs_sceneitem_remove(obs_sceneitem_t item)
+void obs_sceneitem_remove(obs_sceneitem_t *item)
 {
-	obs_scene_t scene;
+	obs_scene_t *scene;
 
 	if (!item)
 		return;
@@ -644,17 +645,17 @@ 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(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(obs_sceneitem_t *item)
 {
 	return item ? item->source : NULL;
 }
 
-void obs_sceneitem_select(obs_sceneitem_t item, bool select)
+void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
 {
 	struct calldata params = {0};
 	const char *command = select ? "item_select" : "item_deselect";
@@ -672,12 +673,12 @@ 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(obs_sceneitem_t *item)
 {
 	return item ? item->selected : false;
 }
 
-void obs_sceneitem_set_pos(obs_sceneitem_t item, const struct vec2 *pos)
+void obs_sceneitem_set_pos(obs_sceneitem_t *item, const struct vec2 *pos)
 {
 	if (item) {
 		vec2_copy(&item->pos, pos);
@@ -685,7 +686,7 @@ void obs_sceneitem_set_pos(obs_sceneitem_t item, const struct vec2 *pos)
 	}
 }
 
-void obs_sceneitem_set_rot(obs_sceneitem_t item, float rot)
+void obs_sceneitem_set_rot(obs_sceneitem_t *item, float rot)
 {
 	if (item) {
 		item->rot = rot;
@@ -693,7 +694,7 @@ void obs_sceneitem_set_rot(obs_sceneitem_t item, float rot)
 	}
 }
 
-void obs_sceneitem_set_scale(obs_sceneitem_t item, const struct vec2 *scale)
+void obs_sceneitem_set_scale(obs_sceneitem_t *item, const struct vec2 *scale)
 {
 	if (item) {
 		vec2_copy(&item->scale, scale);
@@ -701,7 +702,7 @@ void obs_sceneitem_set_scale(obs_sceneitem_t item, const struct vec2 *scale)
 	}
 }
 
-void obs_sceneitem_set_alignment(obs_sceneitem_t item, uint32_t alignment)
+void obs_sceneitem_set_alignment(obs_sceneitem_t *item, uint32_t alignment)
 {
 	if (item) {
 		item->align = alignment;
@@ -731,7 +732,7 @@ static inline void signal_move_dir(struct obs_scene_item *item,
 	calldata_free(&params);
 }
 
-void obs_sceneitem_set_order(obs_sceneitem_t item,
+void obs_sceneitem_set_order(obs_sceneitem_t *item,
 		enum obs_order_movement movement)
 {
 	if (!item) return;
@@ -774,7 +775,7 @@ void obs_sceneitem_set_order(obs_sceneitem_t item,
 	obs_scene_release(scene);
 }
 
-void obs_sceneitem_set_bounds_type(obs_sceneitem_t item,
+void obs_sceneitem_set_bounds_type(obs_sceneitem_t *item,
 		enum obs_bounds_type type)
 {
 	if (item) {
@@ -783,7 +784,7 @@ void obs_sceneitem_set_bounds_type(obs_sceneitem_t item,
 	}
 }
 
-void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t item,
+void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t *item,
 		uint32_t alignment)
 {
 	if (item) {
@@ -792,7 +793,7 @@ void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t item,
 	}
 }
 
-void obs_sceneitem_set_bounds(obs_sceneitem_t item, const struct vec2 *bounds)
+void obs_sceneitem_set_bounds(obs_sceneitem_t *item, const struct vec2 *bounds)
 {
 	if (item) {
 		item->bounds = *bounds;
@@ -800,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(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(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(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(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(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(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(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(obs_sceneitem_t *item,
 		struct obs_transform_info *info)
 {
 	if (item && info) {
@@ -852,7 +853,7 @@ void obs_sceneitem_get_info(obs_sceneitem_t item,
 	}
 }
 
-void obs_sceneitem_set_info(obs_sceneitem_t item,
+void obs_sceneitem_set_info(obs_sceneitem_t *item,
 		const struct obs_transform_info *info)
 {
 	if (item && info) {
@@ -867,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(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(obs_sceneitem_t *item,
 		struct matrix4 *transform)
 {
 	if (item)

libobs/obs-service.c

@@ -33,8 +33,8 @@ const char *obs_service_get_display_name(const char *id)
 	return (info != NULL) ? info->get_name() : NULL;
 }
 
-obs_service_t obs_service_create(const char *id, const char *name,
-		obs_data_t settings)
+obs_service_t *obs_service_create(const char *id, const char *name,
+		obs_data_t *settings)
 {
 	const struct obs_service_info *info = find_service(id);
 	struct obs_service *service;
@@ -82,7 +82,7 @@ static void actually_destroy_service(struct obs_service *service)
 	bfree(service);
 }
 
-void obs_service_destroy(obs_service_t service)
+void obs_service_destroy(obs_service_t *service)
 {
 	if (service) {
 		obs_context_data_remove(&service->context);
@@ -96,31 +96,31 @@ void obs_service_destroy(obs_service_t service)
 	}
 }
 
-const char *obs_service_get_name(obs_service_t service)
+const char *obs_service_get_name(obs_service_t *service)
 {
 	return service ? service->context.name : NULL;
 }
 
-static inline obs_data_t get_defaults(const struct obs_service_info *info)
+static inline obs_data_t *get_defaults(const struct obs_service_info *info)
 {
-	obs_data_t settings = obs_data_create();
+	obs_data_t *settings = obs_data_create();
 	if (info->get_defaults)
 		info->get_defaults(settings);
 	return settings;
 }
 
-obs_data_t obs_service_defaults(const char *id)
+obs_data_t *obs_service_defaults(const char *id)
 {
 	const struct obs_service_info *info = find_service(id);
 	return (info) ? get_defaults(info) : NULL;
 }
 
-obs_properties_t obs_get_service_properties(const char *id)
+obs_properties_t *obs_get_service_properties(const char *id)
 {
 	const struct obs_service_info *info = find_service(id);
 	if (info && info->get_properties) {
-		obs_data_t       defaults = get_defaults(info);
-		obs_properties_t properties;
+		obs_data_t       *defaults = get_defaults(info);
+		obs_properties_t *properties;
 
 		properties = info->get_properties();
 		obs_properties_apply_settings(properties, defaults);
@@ -130,10 +130,10 @@ 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(obs_service_t *service)
 {
 	if (service && service->info.get_properties) {
-		obs_properties_t props;
+		obs_properties_t *props;
 		props = service->info.get_properties();
 		obs_properties_apply_settings(props, service->context.settings);
 		return props;
@@ -142,12 +142,12 @@ 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(obs_service_t *service)
 {
 	return service ? service->info.id : NULL;
 }
 
-void obs_service_update(obs_service_t service, obs_data_t settings)
+void obs_service_update(obs_service_t *service, obs_data_t *settings)
 {
 	if (!service) return;
 
@@ -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(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(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(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(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(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(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(obs_service_t *service)
 {
 	if (!service || !service->info.get_password) return NULL;
 	return service->info.get_password(service->context.data);

libobs/obs-service.h

@@ -22,18 +22,18 @@ struct obs_service_info {
 	const char *id;
 
 	const char *(*get_name)(void);
-	void *(*create)(obs_data_t settings, obs_service_t service);
+	void *(*create)(obs_data_t *settings, obs_service_t *service);
 	void (*destroy)(void *data);
 
 	/* optional */
-	void (*activate)(void *data, obs_data_t settings);
+	void (*activate)(void *data, obs_data_t *settings);
 	void (*deactivate)(void *data);
 
-	void (*update)(void *data, obs_data_t settings);
+	void (*update)(void *data, obs_data_t *settings);
 
-	void (*get_defaults)(obs_data_t settings);
+	void (*get_defaults)(obs_data_t *settings);
 
-	obs_properties_t (*get_properties)(void);
+	obs_properties_t *(*get_properties)(void);
 
 	/**
 	 * Called when getting ready to start up an output, before the encoders
@@ -44,7 +44,7 @@ struct obs_service_info {
 	 * @eturn          true to allow the output to start up,
 	 *                 false to prevent output from starting up
 	 */
-	bool (*initialize)(void *data, obs_output_t output);
+	bool (*initialize)(void *data, obs_output_t *output);
 
 	const char *(*get_url)(void *data);
 	const char *(*get_key)(void *data);

libobs/obs-source.c

@@ -86,7 +86,7 @@ static const char *source_signals[] = {
 };
 
 bool obs_source_init_context(struct obs_source *source,
-		obs_data_t settings, const char *name)
+		obs_data_t *settings, const char *name)
 {
 	if (!obs_context_data_init(&source->context, settings, name))
 		return false;
@@ -152,8 +152,8 @@ static inline void obs_source_dosignal(struct obs_source *source,
 	calldata_free(&data);
 }
 
-obs_source_t obs_source_create(enum obs_source_type type, const char *id,
-		const char *name, obs_data_t settings)
+obs_source_t *obs_source_create(enum obs_source_type type, const char *id,
+		const char *name, obs_data_t *settings)
 {
 	struct obs_source *source = bzalloc(sizeof(struct obs_source));
 
@@ -266,13 +266,13 @@ void obs_source_destroy(struct obs_source *source)
 	bfree(source);
 }
 
-void obs_source_addref(obs_source_t source)
+void obs_source_addref(obs_source_t *source)
 {
 	if (source)
 		os_atomic_inc_long(&source->refs);
 }
 
-void obs_source_release(obs_source_t source)
+void obs_source_release(obs_source_t *source)
 {
 	if (!source)
 		return;
@@ -281,7 +281,7 @@ void obs_source_release(obs_source_t source)
 		obs_source_destroy(source);
 }
 
-void obs_source_remove(obs_source_t source)
+void obs_source_remove(obs_source_t *source)
 {
 	struct obs_core_data *data = &obs->data;
 	size_t id;
@@ -313,32 +313,32 @@ void obs_source_remove(obs_source_t source)
 	obs_source_release(source);
 }
 
-bool obs_source_removed(obs_source_t source)
+bool obs_source_removed(obs_source_t *source)
 {
 	return source ? source->removed : true;
 }
 
-static inline obs_data_t get_defaults(const struct obs_source_info *info)
+static inline obs_data_t *get_defaults(const struct obs_source_info *info)
 {
-	obs_data_t settings = obs_data_create();
+	obs_data_t *settings = obs_data_create();
 	if (info->get_defaults)
 		info->get_defaults(settings);
 	return settings;
 }
 
-obs_data_t obs_source_settings(enum obs_source_type type, const char *id)
+obs_data_t *obs_source_settings(enum obs_source_type type, const char *id)
 {
 	const struct obs_source_info *info = get_source_info(type, id);
 	return (info) ? get_defaults(info) : NULL;
 }
 
-obs_properties_t obs_get_source_properties(enum obs_source_type type,
+obs_properties_t *obs_get_source_properties(enum obs_source_type type,
 		const char *id)
 {
 	const struct obs_source_info *info = get_source_info(type, id);
 	if (info && info->get_properties) {
-		obs_data_t       defaults = get_defaults(info);
-		obs_properties_t properties;
+		obs_data_t       *defaults = get_defaults(info);
+		obs_properties_t *properties;
 
 		properties = info->get_properties();
 		obs_properties_apply_settings(properties, defaults);
@@ -348,10 +348,10 @@ 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(obs_source_t *source)
 {
 	if (source_valid(source) && source->info.get_properties) {
-		obs_properties_t props;
+		obs_properties_t *props;
 		props = source->info.get_properties();
 		obs_properties_apply_settings(props, source->context.settings);
 		return props;
@@ -360,12 +360,12 @@ 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(obs_source_t *source)
 {
 	return source ? source->info.output_flags : 0;
 }
 
-static void obs_source_deferred_update(obs_source_t source)
+static void obs_source_deferred_update(obs_source_t *source)
 {
 	if (source->context.data && source->info.update)
 		source->info.update(source->context.data,
@@ -374,7 +374,7 @@ static void obs_source_deferred_update(obs_source_t source)
 	source->defer_update = false;
 }
 
-void obs_source_update(obs_source_t source, obs_data_t settings)
+void obs_source_update(obs_source_t *source, obs_data_t *settings)
 {
 	if (!source) return;
 
@@ -389,7 +389,7 @@ void obs_source_update(obs_source_t source, obs_data_t settings)
 	}
 }
 
-void obs_source_send_mouse_click(obs_source_t source,
+void obs_source_send_mouse_click(obs_source_t *source,
 		const struct obs_mouse_event *event,
 		int32_t type, bool mouse_up,
 		uint32_t click_count)
@@ -405,7 +405,7 @@ void obs_source_send_mouse_click(obs_source_t source,
 	}
 }
 
-void obs_source_send_mouse_move(obs_source_t source,
+void obs_source_send_mouse_move(obs_source_t *source,
 		const struct obs_mouse_event *event, bool mouse_leave)
 {
 	if (!source)
@@ -419,7 +419,7 @@ void obs_source_send_mouse_move(obs_source_t source,
 	}
 }
 
-void obs_source_send_mouse_wheel(obs_source_t source,
+void obs_source_send_mouse_wheel(obs_source_t *source,
 		const struct obs_mouse_event *event, int x_delta, int y_delta)
 {
 	if (!source)
@@ -433,7 +433,7 @@ void obs_source_send_mouse_wheel(obs_source_t source,
 	}
 }
 
-void obs_source_send_focus(obs_source_t source, bool focus)
+void obs_source_send_focus(obs_source_t *source, bool focus)
 {
 	if (!source)
 		return;
@@ -445,7 +445,7 @@ void obs_source_send_focus(obs_source_t source, bool focus)
 	}
 }
 
-void obs_source_send_key_click(obs_source_t source,
+void obs_source_send_key_click(obs_source_t *source,
 		const struct obs_key_event *event, bool key_up)
 {
 	if (!source)
@@ -459,35 +459,36 @@ void obs_source_send_key_click(obs_source_t source,
 	}
 }
 
-static void activate_source(obs_source_t source)
+static void activate_source(obs_source_t *source)
 {
 	if (source->context.data && source->info.activate)
 		source->info.activate(source->context.data);
 	obs_source_dosignal(source, "source_activate", "activate");
 }
 
-static void deactivate_source(obs_source_t source)
+static void deactivate_source(obs_source_t *source)
 {
 	if (source->context.data && source->info.deactivate)
 		source->info.deactivate(source->context.data);
 	obs_source_dosignal(source, "source_deactivate", "deactivate");
 }
 
-static void show_source(obs_source_t source)
+static void show_source(obs_source_t *source)
 {
 	if (source->context.data && source->info.show)
 		source->info.show(source->context.data);
 	obs_source_dosignal(source, "source_show", "show");
 }
 
-static void hide_source(obs_source_t source)
+static void hide_source(obs_source_t *source)
 {
 	if (source->context.data && source->info.hide)
 		source->info.hide(source->context.data);
 	obs_source_dosignal(source, "source_hide", "hide");
 }
 
-static void activate_tree(obs_source_t parent, obs_source_t child, void *param)
+static void activate_tree(obs_source_t *parent, obs_source_t *child,
+		void *param)
 {
 	if (os_atomic_inc_long(&child->activate_refs) == 1)
 		activate_source(child);
@@ -496,7 +497,7 @@ static void activate_tree(obs_source_t parent, obs_source_t child, void *param)
 	UNUSED_PARAMETER(param);
 }
 
-static void deactivate_tree(obs_source_t parent, obs_source_t child,
+static void deactivate_tree(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	if (os_atomic_dec_long(&child->activate_refs) == 0)
@@ -506,7 +507,7 @@ static void deactivate_tree(obs_source_t parent, obs_source_t child,
 	UNUSED_PARAMETER(param);
 }
 
-static void show_tree(obs_source_t parent, obs_source_t child, void *param)
+static void show_tree(obs_source_t *parent, obs_source_t *child, void *param)
 {
 	if (os_atomic_inc_long(&child->show_refs) == 1)
 		show_source(child);
@@ -515,7 +516,7 @@ static void show_tree(obs_source_t parent, obs_source_t child, void *param)
 	UNUSED_PARAMETER(param);
 }
 
-static void hide_tree(obs_source_t parent, obs_source_t child, void *param)
+static void hide_tree(obs_source_t *parent, obs_source_t *child, void *param)
 {
 	if (os_atomic_dec_long(&child->show_refs) == 0)
 		hide_source(child);
@@ -524,7 +525,7 @@ static void hide_tree(obs_source_t parent, obs_source_t child, void *param)
 	UNUSED_PARAMETER(param);
 }
 
-void obs_source_activate(obs_source_t source, enum view_type type)
+void obs_source_activate(obs_source_t *source, enum view_type type)
 {
 	if (!source) return;
 
@@ -542,7 +543,7 @@ void obs_source_activate(obs_source_t source, enum view_type type)
 	}
 }
 
-void obs_source_deactivate(obs_source_t source, enum view_type type)
+void obs_source_deactivate(obs_source_t *source, enum view_type type)
 {
 	if (!source) return;
 
@@ -560,7 +561,7 @@ void obs_source_deactivate(obs_source_t source, enum view_type type)
 	}
 }
 
-void obs_source_video_tick(obs_source_t source, float seconds)
+void obs_source_video_tick(obs_source_t *source, float seconds)
 {
 	if (!source) return;
 
@@ -592,13 +593,13 @@ static inline uint64_t conv_frames_to_time(size_t frames)
 /* maximum time that timestamp can jump in nanoseconds */
 #define MAX_TIMESTAMP_JUMP  2000000000ULL
 
-static inline void reset_audio_timing(obs_source_t source, uint64_t timetamp)
+static inline void reset_audio_timing(obs_source_t *source, uint64_t timetamp)
 {
 	source->timing_set    = true;
 	source->timing_adjust = os_gettime_ns() - timetamp;
 }
 
-static inline void handle_ts_jump(obs_source_t source, uint64_t expected,
+static inline void handle_ts_jump(obs_source_t *source, uint64_t expected,
 		uint64_t ts, uint64_t diff)
 {
 	blog(LOG_DEBUG, "Timestamp for source '%s' jumped by '%"PRIu64"', "
@@ -626,7 +627,7 @@ static void calc_volume_levels(struct obs_source *source, float *array,
 	float max_val = 0.0f;
 	float rms_val = 0.0f;
 
-	audio_t        audio          = obs_get_audio();
+	audio_t        *audio          = obs_get_audio();
 	const uint32_t sample_rate    = audio_output_get_sample_rate(audio);
 	const size_t   channels       = audio_output_get_channels(audio);
 	const size_t   count          = frames * channels;
@@ -669,7 +670,7 @@ static void calc_volume_levels(struct obs_source *source, float *array,
 }
 
 /* TODO update peak/etc later */
-static void obs_source_update_volume_level(obs_source_t source,
+static void obs_source_update_volume_level(obs_source_t *source,
 		struct audio_data *in)
 {
 	if (source && in) {
@@ -692,7 +693,7 @@ static void obs_source_update_volume_level(obs_source_t source,
 	}
 }
 
-static void source_output_audio_line(obs_source_t source,
+static void source_output_audio_line(obs_source_t *source,
 		const struct audio_data *data)
 {
 	struct audio_data in = *data;
@@ -870,7 +871,7 @@ static inline bool set_async_texture_size(struct obs_source *source,
 	return true;
 }
 
-static void upload_raw_frame(gs_texture_t tex,
+static void upload_raw_frame(gs_texture_t *tex,
 		const struct obs_source_frame *frame)
 {
 	switch (get_convert_type(frame->format)) {
@@ -924,17 +925,17 @@ static const char *select_conversion_technique(enum video_format format)
 	return NULL;
 }
 
-static inline void set_eparam(gs_effect_t effect, const char *name, float val)
+static inline void set_eparam(gs_effect_t *effect, const char *name, float val)
 {
-	gs_eparam_t param = gs_effect_get_param_by_name(effect, name);
+	gs_eparam_t *param = gs_effect_get_param_by_name(effect, name);
 	gs_effect_set_float(param, val);
 }
 
 static bool update_async_texrender(struct obs_source *source,
 		const struct obs_source_frame *frame)
 {
-	gs_texture_t   tex       = source->async_texture;
-	gs_texrender_t texrender = source->async_convert_texrender;
+	gs_texture_t   *tex       = source->async_texture;
+	gs_texrender_t *texrender = source->async_convert_texrender;
 
 	gs_texrender_reset(texrender);
 
@@ -946,8 +947,8 @@ static bool update_async_texrender(struct obs_source *source,
 	float convert_width  = (float)source->async_convert_width;
 	float convert_height = (float)source->async_convert_height;
 
-	gs_effect_t conv = obs->video.conversion_effect;
-	gs_technique_t tech = gs_effect_get_technique(conv,
+	gs_effect_t *conv = obs->video.conversion_effect;
+	gs_technique_t *tech = gs_effect_get_technique(conv,
 			select_conversion_technique(frame->format));
 
 	if (!gs_texrender_begin(texrender, cx, cy))
@@ -991,8 +992,8 @@ static bool update_async_texrender(struct obs_source *source,
 static bool update_async_texture(struct obs_source *source,
 		const struct obs_source_frame *frame)
 {
-	gs_texture_t      tex       = source->async_texture;
-	gs_texrender_t    texrender = source->async_convert_texrender;
+	gs_texture_t      *tex       = source->async_texture;
+	gs_texrender_t    *texrender = source->async_convert_texrender;
 	enum convert_type type      = get_convert_type(frame->format);
 	uint8_t           *ptr;
 	uint32_t          linesize;
@@ -1042,11 +1043,11 @@ static bool update_async_texture(struct obs_source *source,
 }
 
 static inline void obs_source_draw_texture(struct obs_source *source,
-		gs_effect_t effect, float *color_matrix,
+		gs_effect_t *effect, float *color_matrix,
 		float const *color_range_min, float const *color_range_max)
 {
-	gs_texture_t tex = source->async_texture;
-	gs_eparam_t  param;
+	gs_texture_t *tex = source->async_texture;
+	gs_eparam_t  *param;
 
 	if (source->async_convert_texrender)
 		tex = gs_texrender_get_texture(source->async_convert_texrender);
@@ -1076,12 +1077,12 @@ static inline void obs_source_draw_texture(struct obs_source *source,
 
 static void obs_source_draw_async_texture(struct obs_source *source)
 {
-	gs_effect_t    effect        = gs_get_effect();
+	gs_effect_t    *effect        = gs_get_effect();
 	bool           yuv           = format_is_yuv(source->async_format);
 	bool           limited_range = yuv && !source->async_full_range;
 	const char     *type         = yuv ? "DrawMatrix" : "Draw";
 	bool           def_draw      = (!effect);
-	gs_technique_t tech          = NULL;
+	gs_technique_t *tech          = NULL;
 
 	if (def_draw) {
 		effect = obs_get_default_effect();
@@ -1101,7 +1102,7 @@ static void obs_source_draw_async_texture(struct obs_source *source)
 	}
 }
 
-static void obs_source_render_async_video(obs_source_t source)
+static void obs_source_render_async_video(obs_source_t *source)
 {
 	if (!source->async_rendered) {
 		struct obs_source_frame *frame = obs_source_get_frame(source);
@@ -1121,19 +1122,19 @@ static void obs_source_render_async_video(obs_source_t source)
 		obs_source_draw_async_texture(source);
 }
 
-static inline void obs_source_render_filters(obs_source_t source)
+static inline void obs_source_render_filters(obs_source_t *source)
 {
 	source->rendering_filter = true;
 	obs_source_video_render(source->filters.array[0]);
 	source->rendering_filter = false;
 }
 
-static inline void obs_source_default_render(obs_source_t source,
+static inline void obs_source_default_render(obs_source_t *source,
 		bool color_matrix)
 {
-	gs_effect_t    effect     = obs->video.default_effect;
+	gs_effect_t    *effect     = obs->video.default_effect;
 	const char     *tech_name = color_matrix ? "DrawMatrix" : "Draw";
-	gs_technique_t tech       = gs_effect_get_technique(effect, tech_name);
+	gs_technique_t *tech       = gs_effect_get_technique(effect, tech_name);
 	size_t         passes, i;
 
 	passes = gs_technique_begin(tech);
@@ -1146,7 +1147,7 @@ static inline void obs_source_default_render(obs_source_t source,
 	gs_technique_end(tech);
 }
 
-static inline void obs_source_main_render(obs_source_t source)
+static inline void obs_source_main_render(obs_source_t *source)
 {
 	uint32_t flags      = source->info.output_flags;
 	bool color_matrix   = (flags & OBS_SOURCE_COLOR_MATRIX) != 0;
@@ -1162,7 +1163,7 @@ static inline void obs_source_main_render(obs_source_t source)
 				custom_draw ? NULL : gs_get_effect());
 }
 
-void obs_source_video_render(obs_source_t source)
+void obs_source_video_render(obs_source_t *source)
 {
 	if (!source_valid(source)) return;
 
@@ -1179,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(obs_source_t *source)
 {
 	if (!source_valid(source)) return 0;
 
@@ -1188,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(obs_source_t *source)
 {
 	if (!source_valid(source)) return 0;
 
@@ -1197,17 +1198,17 @@ 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(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(obs_source_t *filter)
 {
 	return filter ? filter->filter_target : NULL;
 }
 
-void obs_source_filter_add(obs_source_t source, obs_source_t filter)
+void obs_source_filter_add(obs_source_t *source, obs_source_t *filter)
 {
 	if (!source || !filter)
 		return;
@@ -1221,7 +1222,7 @@ void obs_source_filter_add(obs_source_t source, obs_source_t filter)
 	}
 
 	if (source->filters.num) {
-		obs_source_t *back = da_end(source->filters);
+		obs_source_t **back = da_end(source->filters);
 		(*back)->filter_target = filter;
 	}
 
@@ -1233,7 +1234,7 @@ void obs_source_filter_add(obs_source_t source, obs_source_t filter)
 	filter->filter_target = source;
 }
 
-void obs_source_filter_remove(obs_source_t source, obs_source_t filter)
+void obs_source_filter_remove(obs_source_t *source, obs_source_t *filter)
 {
 	size_t idx;
 
@@ -1247,7 +1248,7 @@ void obs_source_filter_remove(obs_source_t source, obs_source_t filter)
 		return;
 
 	if (idx > 0) {
-		obs_source_t prev = source->filters.array[idx-1];
+		obs_source_t *prev = source->filters.array[idx-1];
 		prev->filter_target = filter->filter_target;
 	}
 
@@ -1259,7 +1260,7 @@ void obs_source_filter_remove(obs_source_t source, obs_source_t filter)
 	filter->filter_target = NULL;
 }
 
-void obs_source_filter_set_order(obs_source_t source, obs_source_t filter,
+void obs_source_filter_set_order(obs_source_t *source, obs_source_t *filter,
 		enum obs_order_movement movement)
 {
 	size_t idx, i;
@@ -1294,13 +1295,13 @@ void obs_source_filter_set_order(obs_source_t source, obs_source_t filter,
 
 	/* reorder filter targets, not the nicest way of dealing with things */
 	for (i = 0; i < source->filters.num; i++) {
-		obs_source_t next_filter = (i == source->filters.num-1) ?
+		obs_source_t *next_filter = (i == source->filters.num-1) ?
 			source : source->filters.array[idx+1];
 		source->filters.array[i]->filter_target = next_filter;
 	}
 }
 
-obs_data_t obs_source_get_settings(obs_source_t source)
+obs_data_t *obs_source_get_settings(obs_source_t *source)
 {
 	if (!source) return NULL;
 
@@ -1308,7 +1309,7 @@ obs_data_t obs_source_get_settings(obs_source_t source)
 	return source->context.settings;
 }
 
-static inline struct obs_source_frame *filter_async_video(obs_source_t source,
+static inline struct obs_source_frame *filter_async_video(obs_source_t *source,
 		struct obs_source_frame *in)
 {
 	size_t i;
@@ -1396,7 +1397,7 @@ static inline struct obs_source_frame *cache_video(
 	return new_frame;
 }
 
-static bool ready_async_frame(obs_source_t source, uint64_t sys_time);
+static bool ready_async_frame(obs_source_t *source, uint64_t sys_time);
 
 static inline void cycle_frames(struct obs_source *source)
 {
@@ -1404,7 +1405,7 @@ static inline void cycle_frames(struct obs_source *source)
 		ready_async_frame(source, os_gettime_ns());
 }
 
-void obs_source_output_video(obs_source_t source,
+void obs_source_output_video(obs_source_t *source,
 		const struct obs_source_frame *frame)
 {
 	if (!source || !frame)
@@ -1424,7 +1425,7 @@ void obs_source_output_video(obs_source_t source,
 	}
 }
 
-static inline struct obs_audio_data *filter_async_audio(obs_source_t source,
+static inline struct obs_audio_data *filter_async_audio(obs_source_t *source,
 		struct obs_audio_data *in)
 {
 	size_t i;
@@ -1442,7 +1443,7 @@ static inline struct obs_audio_data *filter_async_audio(obs_source_t source,
 	return in;
 }
 
-static inline void reset_resampler(obs_source_t source,
+static inline void reset_resampler(obs_source_t *source,
 		const struct obs_source_audio *audio)
 {
 	const struct audio_output_info *obs_info;
@@ -1474,7 +1475,7 @@ static inline void reset_resampler(obs_source_t source,
 		blog(LOG_ERROR, "creation of resampler failed");
 }
 
-static inline void copy_audio_data(obs_source_t source,
+static inline void copy_audio_data(obs_source_t *source,
 		const uint8_t *const data[], uint32_t frames, uint64_t ts)
 {
 	size_t planes    = audio_output_get_planes(obs->audio.audio);
@@ -1500,7 +1501,7 @@ static inline void copy_audio_data(obs_source_t source,
 }
 
 /* resamples/remixes new audio to the designated main audio output format */
-static void process_audio(obs_source_t source,
+static void process_audio(obs_source_t *source,
 		const struct obs_source_audio *audio)
 {
 	if (source->sample_info.samples_per_sec != audio->samples_per_sec ||
@@ -1530,7 +1531,7 @@ static void process_audio(obs_source_t source,
 	}
 }
 
-void obs_source_output_audio(obs_source_t source,
+void obs_source_output_audio(obs_source_t *source,
 		const struct obs_source_audio *audio)
 {
 	uint32_t flags;
@@ -1569,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(obs_source_t *source, uint64_t ts)
 {
 	if (ts < source->last_frame_ts)
 		return ((source->last_frame_ts - ts) > MAX_TIMESTAMP_JUMP);
@@ -1579,7 +1580,7 @@ static inline bool frame_out_of_bounds(obs_source_t source, uint64_t ts)
 
 /* #define DEBUG_ASYNC_FRAMES 1 */
 
-static bool ready_async_frame(obs_source_t source, uint64_t sys_time)
+static bool ready_async_frame(obs_source_t *source, uint64_t sys_time)
 {
 	struct obs_source_frame *next_frame = source->video_frames.array[0];
 	struct obs_source_frame *frame      = NULL;
@@ -1657,7 +1658,7 @@ static bool ready_async_frame(obs_source_t source, uint64_t sys_time)
 	return frame != NULL;
 }
 
-static inline struct obs_source_frame *get_closest_frame(obs_source_t source,
+static inline struct obs_source_frame *get_closest_frame(obs_source_t *source,
 		uint64_t sys_time)
 {
 	if (ready_async_frame(source, sys_time)) {
@@ -1675,7 +1676,7 @@ static inline struct obs_source_frame *get_closest_frame(obs_source_t source,
  * the frame with the closest timing to ensure sync.  Also ensures that timing
  * with audio is synchronized.
  */
-struct obs_source_frame *obs_source_get_frame(obs_source_t source)
+struct obs_source_frame *obs_source_get_frame(obs_source_t *source)
 {
 	struct obs_source_frame *frame = NULL;
 	uint64_t sys_time;
@@ -1716,7 +1717,7 @@ unlock:
 	return frame;
 }
 
-void obs_source_release_frame(obs_source_t source,
+void obs_source_release_frame(obs_source_t *source,
 		struct obs_source_frame *frame)
 {
 	if (source && frame) {
@@ -1725,12 +1726,12 @@ 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(obs_source_t *source)
 {
 	return source ? source->context.name : NULL;
 }
 
-void obs_source_set_name(obs_source_t source, const char *name)
+void obs_source_set_name(obs_source_t *source, const char *name)
 {
 	if (!source) return;
 
@@ -1750,21 +1751,21 @@ 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(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(obs_source_t *source)
 {
 	return source ? source->info.id : NULL;
 }
 
-static inline void render_filter_bypass(obs_source_t target, gs_effect_t effect,
-		bool use_matrix)
+static inline void render_filter_bypass(obs_source_t *target,
+		gs_effect_t *effect, bool use_matrix)
 {
 	const char  *tech_name = use_matrix ? "DrawMatrix" : "Draw";
-	gs_technique_t tech    = gs_effect_get_technique(effect, tech_name);
+	gs_technique_t *tech    = gs_effect_get_technique(effect, tech_name);
 	size_t      passes, i;
 
 	passes = gs_technique_begin(tech);
@@ -1776,12 +1777,12 @@ static inline void render_filter_bypass(obs_source_t target, gs_effect_t effect,
 	gs_technique_end(tech);
 }
 
-static inline void render_filter_tex(gs_texture_t tex, gs_effect_t effect,
+static inline void render_filter_tex(gs_texture_t *tex, gs_effect_t *effect,
 		uint32_t width, uint32_t height, bool use_matrix)
 {
 	const char  *tech_name = use_matrix ? "DrawMatrix" : "Draw";
-	gs_technique_t tech    = gs_effect_get_technique(effect, tech_name);
-	gs_eparam_t    image   = gs_effect_get_param_by_name(effect, "image");
+	gs_technique_t *tech    = gs_effect_get_technique(effect, tech_name);
+	gs_eparam_t    *image   = gs_effect_get_param_by_name(effect, "image");
 	size_t      passes, i;
 
 	gs_effect_set_texture(image, tex);
@@ -1795,11 +1796,11 @@ static inline void render_filter_tex(gs_texture_t tex, gs_effect_t effect,
 	gs_technique_end(tech);
 }
 
-void obs_source_process_filter(obs_source_t filter, gs_effect_t effect,
+void obs_source_process_filter(obs_source_t *filter, gs_effect_t *effect,
 		uint32_t width, uint32_t height, enum gs_color_format format,
 		enum obs_allow_direct_render allow_direct)
 {
-	obs_source_t target, parent;
+	obs_source_t *target, *parent;
 	uint32_t     target_flags, parent_flags;
 	int          cx, cy;
 	bool         use_matrix, expects_def, can_directly;
@@ -1844,17 +1845,17 @@ 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(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(obs_source_t *source)
 {
 	return source ? source->context.procs : NULL;
 }
 
-void obs_source_set_volume(obs_source_t source, float volume)
+void obs_source_set_volume(obs_source_t *source, float volume)
 {
 	if (source) {
 		struct calldata data = {0};
@@ -1871,7 +1872,7 @@ void obs_source_set_volume(obs_source_t source, float volume)
 	}
 }
 
-static void set_tree_preset_vol(obs_source_t parent, obs_source_t child,
+static void set_tree_preset_vol(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	float *vol = param;
@@ -1880,7 +1881,7 @@ static void set_tree_preset_vol(obs_source_t parent, obs_source_t child,
 	UNUSED_PARAMETER(parent);
 }
 
-void obs_source_set_present_volume(obs_source_t source, float volume)
+void obs_source_set_present_volume(obs_source_t *source, float volume)
 {
 	if (source) {
 		source->present_volume = volume;
@@ -1894,23 +1895,23 @@ 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(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(obs_source_t *source)
 {
 	return source ? source->present_volume : 0.0f;
 }
 
-void obs_source_set_sync_offset(obs_source_t source, int64_t offset)
+void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
 {
 	if (source)
 		source->sync_offset = offset;
 }
 
-int64_t obs_source_get_sync_offset(obs_source_t source)
+int64_t obs_source_get_sync_offset(obs_source_t *source)
 {
 	return source ? source->sync_offset : 0;
 }
@@ -1920,7 +1921,7 @@ struct source_enum_data {
 	void *param;
 };
 
-static void enum_source_tree_callback(obs_source_t parent, obs_source_t child,
+static void enum_source_tree_callback(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	struct source_enum_data *data = param;
@@ -1938,7 +1939,7 @@ static void enum_source_tree_callback(obs_source_t parent, obs_source_t child,
 	data->enum_callback(parent, child, data->param);
 }
 
-void obs_source_enum_sources(obs_source_t source,
+void obs_source_enum_sources(obs_source_t *source,
 		obs_source_enum_proc_t enum_callback,
 		void *param)
 {
@@ -1956,7 +1957,7 @@ void obs_source_enum_sources(obs_source_t source,
 	obs_source_release(source);
 }
 
-void obs_source_enum_tree(obs_source_t source,
+void obs_source_enum_tree(obs_source_t *source,
 		obs_source_enum_proc_t enum_callback,
 		void *param)
 {
@@ -1978,7 +1979,7 @@ void obs_source_enum_tree(obs_source_t source,
 	obs_source_release(source);
 }
 
-void obs_source_add_child(obs_source_t parent, obs_source_t child)
+void obs_source_add_child(obs_source_t *parent, obs_source_t *child)
 {
 	if (!parent || !child) return;
 
@@ -1989,7 +1990,7 @@ void obs_source_add_child(obs_source_t parent, obs_source_t child)
 	}
 }
 
-void obs_source_remove_child(obs_source_t parent, obs_source_t child)
+void obs_source_remove_child(obs_source_t *parent, obs_source_t *child)
 {
 	if (!parent || !child) return;
 
@@ -2000,7 +2001,7 @@ void obs_source_remove_child(obs_source_t parent, obs_source_t child)
 	}
 }
 
-static void reset_transition_vol(obs_source_t parent, obs_source_t child,
+static void reset_transition_vol(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	child->transition_volume = 0.0f;
@@ -2009,7 +2010,7 @@ static void reset_transition_vol(obs_source_t parent, obs_source_t child,
 	UNUSED_PARAMETER(param);
 }
 
-static void add_transition_vol(obs_source_t parent, obs_source_t child,
+static void add_transition_vol(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	float *vol = param;
@@ -2018,7 +2019,7 @@ static void add_transition_vol(obs_source_t parent, obs_source_t child,
 	UNUSED_PARAMETER(parent);
 }
 
-static void apply_transition_vol(obs_source_t parent, obs_source_t child,
+static void apply_transition_vol(obs_source_t *parent, obs_source_t *child,
 		void *param)
 {
 	child->present_volume = child->transition_volume;
@@ -2027,13 +2028,13 @@ static void apply_transition_vol(obs_source_t parent, obs_source_t child,
 	UNUSED_PARAMETER(param);
 }
 
-void obs_transition_begin_frame(obs_source_t transition)
+void obs_transition_begin_frame(obs_source_t *transition)
 {
 	if (!transition) return;
 	obs_source_enum_tree(transition, reset_transition_vol, NULL);
 }
 
-void obs_source_set_transition_vol(obs_source_t source, float vol)
+void obs_source_set_transition_vol(obs_source_t *source, float vol)
 {
 	if (!source) return;
 
@@ -2041,19 +2042,19 @@ void obs_source_set_transition_vol(obs_source_t source, float vol)
 	obs_source_enum_tree(source, add_transition_vol, &vol);
 }
 
-void obs_transition_end_frame(obs_source_t transition)
+void obs_transition_end_frame(obs_source_t *transition)
 {
 	if (!transition) return;
 	obs_source_enum_tree(transition, apply_transition_vol, NULL);
 }
 
-void obs_source_save(obs_source_t source)
+void obs_source_save(obs_source_t *source)
 {
 	if (!source_valid(source) || !source->info.save) return;
 	source->info.save(source->context.data, source->context.settings);
 }
 
-void obs_source_load(obs_source_t source)
+void obs_source_load(obs_source_t *source)
 {
 	if (!source_valid(source) || !source->info.load) return;
 	source->info.load(source->context.data, source->context.settings);

libobs/obs-source.h

@@ -98,8 +98,8 @@ enum obs_source_type {
 
 /** @} */
 
-typedef void (*obs_source_enum_proc_t)(obs_source_t parent, obs_source_t child,
-		void *param);
+typedef void (*obs_source_enum_proc_t)(obs_source_t *parent,
+		obs_source_t *child, void *param);
 
 /**
  * Source definition structure
@@ -137,7 +137,7 @@ struct obs_source_info {
 	 * @param  source    Source that this data is assoicated with
 	 * @return           The data associated with this source
 	 */
-	void *(*create)(obs_data_t settings, obs_source_t source);
+	void *(*create)(obs_data_t *settings, obs_source_t *source);
 
 	/**
 	 * Destroys the private data for the source
@@ -163,14 +163,14 @@ struct obs_source_info {
 	 *
 	 * @param[out]  settings  Data to assign default settings to
 	 */
-	void (*get_defaults)(obs_data_t settings);
+	void (*get_defaults)(obs_data_t *settings);
 
 	/** 
 	 * Gets the property information of this source
 	 *
 	 * @return         The properties data
 	 */
-	obs_properties_t (*get_properties)(void);
+	obs_properties_t *(*get_properties)(void);
 
 	/**
 	 * Updates the settings for this source
@@ -178,7 +178,7 @@ struct obs_source_info {
 	 * @param data      Source data
 	 * @param settings  New settings for this source
 	 */
-	void (*update)(void *data, obs_data_t settings);
+	void (*update)(void *data, obs_data_t *settings);
 
 	/** Called when the source has been activated in the main view */
 	void (*activate)(void *data);
@@ -230,7 +230,7 @@ struct obs_source_info {
 	 *                be NULL, and the source is expected to process with
 	 *                an effect manually.
 	 */
-	void (*video_render)(void *data, gs_effect_t effect);
+	void (*video_render)(void *data, gs_effect_t *effect);
 
 	/**
 	 * Called to filter raw async video data.
@@ -280,7 +280,7 @@ struct obs_source_info {
 	 * @param  data      Source data
 	 * @param  settings  Settings
 	 */
-	void (*save)(void *data, obs_data_t settings);
+	void (*save)(void *data, obs_data_t *settings);
 
 	/**
 	 * Called when loading a source from saved data.  This should be called
@@ -290,7 +290,7 @@ struct obs_source_info {
 	 * @param  data      Source data
 	 * @param  settings  Settings
 	 */
-	void (*load)(void *data, obs_data_t settings);
+	void (*load)(void *data, obs_data_t *settings);
 
 	/**
 	 * Called when interacting with a source and a mouse-down or mouse-up

libobs/obs-video.c

@@ -113,16 +113,16 @@ static inline void render_main_texture(struct obs_core_video *video,
 static inline void render_output_texture(struct obs_core_video *video,
 		int cur_texture, int prev_texture)
 {
-	gs_texture_t texture = video->render_textures[prev_texture];
-	gs_texture_t target  = video->output_textures[cur_texture];
+	gs_texture_t *texture = video->render_textures[prev_texture];
+	gs_texture_t *target  = video->output_textures[cur_texture];
 	uint32_t     width   = gs_texture_get_width(target);
 	uint32_t     height  = gs_texture_get_height(target);
 
 	/* TODO: replace with actual downscalers or unpackers */
-	gs_effect_t    effect  = video->default_effect;
-	gs_technique_t tech    = gs_effect_get_technique(effect, "DrawMatrix");
-	gs_eparam_t    image   = gs_effect_get_param_by_name(effect, "image");
-	gs_eparam_t    matrix  = gs_effect_get_param_by_name(effect,
+	gs_effect_t    *effect  = video->default_effect;
+	gs_technique_t *tech    = gs_effect_get_technique(effect, "DrawMatrix");
+	gs_eparam_t    *image   = gs_effect_get_param_by_name(effect, "image");
+	gs_eparam_t    *matrix  = gs_effect_get_param_by_name(effect,
 			"color_matrix");
 	size_t      passes, i;
 
@@ -155,24 +155,24 @@ static inline void render_output_texture(struct obs_core_video *video,
 	video->textures_output[cur_texture] = true;
 }
 
-static inline void set_eparam(gs_effect_t effect, const char *name, float val)
+static inline void set_eparam(gs_effect_t *effect, const char *name, float val)
 {
-	gs_eparam_t param = gs_effect_get_param_by_name(effect, name);
+	gs_eparam_t *param = gs_effect_get_param_by_name(effect, name);
 	gs_effect_set_float(param, val);
 }
 
 static void render_convert_texture(struct obs_core_video *video,
 		int cur_texture, int prev_texture)
 {
-	gs_texture_t texture = video->output_textures[prev_texture];
-	gs_texture_t target  = video->convert_textures[cur_texture];
+	gs_texture_t *texture = video->output_textures[prev_texture];
+	gs_texture_t *target  = video->convert_textures[cur_texture];
 	float        fwidth  = (float)video->output_width;
 	float        fheight = (float)video->output_height;
 	size_t       passes, i;
 
-	gs_effect_t    effect  = video->conversion_effect;
-	gs_eparam_t    image   = gs_effect_get_param_by_name(effect, "image");
-	gs_technique_t tech    = gs_effect_get_technique(effect,
+	gs_effect_t    *effect  = video->conversion_effect;
+	gs_eparam_t    *image   = gs_effect_get_param_by_name(effect, "image");
+	gs_technique_t *tech    = gs_effect_get_technique(effect,
 			video->conversion_tech);
 
 	if (!video->textures_output[prev_texture])
@@ -210,9 +210,9 @@ static void render_convert_texture(struct obs_core_video *video,
 static inline void stage_output_texture(struct obs_core_video *video,
 		int cur_texture, int prev_texture)
 {
-	gs_texture_t   texture;
+	gs_texture_t   *texture;
 	bool        texture_ready;
-	gs_stagesurf_t copy = video->copy_surfaces[cur_texture];
+	gs_stagesurf_t *copy = video->copy_surfaces[cur_texture];
 
 	if (video->gpu_conversion) {
 		texture = video->convert_textures[prev_texture];
@@ -256,7 +256,7 @@ static inline void render_video(struct obs_core_video *video, int cur_texture,
 static inline bool download_frame(struct obs_core_video *video,
 		int prev_texture, struct video_data *frame)
 {
-	gs_stagesurf_t surface = video->copy_surfaces[prev_texture];
+	gs_stagesurf_t *surface = video->copy_surfaces[prev_texture];
 
 	if (!video->textures_copied[prev_texture])
 		return false;

libobs/obs-view.c

@@ -32,7 +32,7 @@ bool obs_view_init(struct obs_view *view)
 	return true;
 }
 
-obs_view_t obs_view_create(void)
+obs_view_t *obs_view_create(void)
 {
 	struct obs_view *view = bzalloc(sizeof(struct obs_view));
 
@@ -55,7 +55,7 @@ void obs_view_free(struct obs_view *view)
 	pthread_mutex_destroy(&view->channels_mutex);
 }
 
-void obs_view_destroy(obs_view_t view)
+void obs_view_destroy(obs_view_t *view)
 {
 	if (view) {
 		obs_view_free(view);
@@ -63,9 +63,9 @@ void obs_view_destroy(obs_view_t view)
 	}
 }
 
-obs_source_t obs_view_get_source(obs_view_t view, uint32_t channel)
+obs_source_t *obs_view_get_source(obs_view_t *view, uint32_t channel)
 {
-	obs_source_t source;
+	obs_source_t *source;
 	assert(channel < MAX_CHANNELS);
 
 	if (!view) return NULL;
@@ -82,8 +82,8 @@ obs_source_t obs_view_get_source(obs_view_t view, uint32_t channel)
 	return source;
 }
 
-void obs_view_set_source(obs_view_t view, uint32_t channel,
-		obs_source_t source)
+void obs_view_set_source(obs_view_t *view, uint32_t channel,
+		obs_source_t *source)
 {
 	struct obs_source *prev_source;
 
@@ -110,7 +110,7 @@ void obs_view_set_source(obs_view_t view, uint32_t channel,
 	}
 }
 
-void obs_view_render(obs_view_t view)
+void obs_view_render(obs_view_t *view)
 {
 	if (!view) return;
 

libobs/obs.c

@@ -805,12 +805,12 @@ void obs_leave_graphics(void)
 		gs_leave_context();
 }
 
-audio_t obs_get_audio(void)
+audio_t *obs_get_audio(void)
 {
 	return (obs != NULL) ? obs->audio.audio : NULL;
 }
 
-video_t obs_get_video(void)
+video_t *obs_get_video(void)
 {
 	return (obs != NULL) ? obs->video.video : NULL;
 }
@@ -875,7 +875,7 @@ void *obs_create_ui(const char *name, const char *task, const char *target,
 	return callback ? callback->create(data, ui_data) : NULL;
 }
 
-bool obs_add_source(obs_source_t source)
+bool obs_add_source(obs_source_t *source)
 {
 	struct calldata params = {0};
 
@@ -894,13 +894,13 @@ bool obs_add_source(obs_source_t source)
 	return true;
 }
 
-obs_source_t obs_get_output_source(uint32_t channel)
+obs_source_t *obs_get_output_source(uint32_t channel)
 {
 	if (!obs) return NULL;
 	return obs_view_get_source(&obs->data.main_view, channel);
 }
 
-void obs_set_output_source(uint32_t channel, obs_source_t source)
+void obs_set_output_source(uint32_t channel, obs_source_t *source)
 {
 	assert(channel < MAX_CHANNELS);
 
@@ -937,7 +937,7 @@ void obs_set_output_source(uint32_t channel, obs_source_t source)
 	}
 }
 
-void obs_enum_sources(bool (*enum_proc)(void*, obs_source_t), void *param)
+void obs_enum_sources(bool (*enum_proc)(void*, obs_source_t*), void *param)
 {
 	if (!obs) return;
 
@@ -975,28 +975,28 @@ static inline void obs_enum(void *pstart, pthread_mutex_t *mutex, void *proc,
 	pthread_mutex_unlock(mutex);
 }
 
-void obs_enum_outputs(bool (*enum_proc)(void*, obs_output_t), void *param)
+void obs_enum_outputs(bool (*enum_proc)(void*, obs_output_t*), void *param)
 {
 	if (!obs) return;
 	obs_enum(&obs->data.first_output, &obs->data.outputs_mutex,
 			enum_proc, param);
 }
 
-void obs_enum_encoders(bool (*enum_proc)(void*, obs_encoder_t), void *param)
+void obs_enum_encoders(bool (*enum_proc)(void*, obs_encoder_t*), void *param)
 {
 	if (!obs) return;
 	obs_enum(&obs->data.first_encoder, &obs->data.encoders_mutex,
 			enum_proc, param);
 }
 
-void obs_enum_services(bool (*enum_proc)(void*, obs_service_t), void *param)
+void obs_enum_services(bool (*enum_proc)(void*, obs_service_t*), void *param)
 {
 	if (!obs) return;
 	obs_enum(&obs->data.first_service, &obs->data.services_mutex,
 			enum_proc, param);
 }
 
-obs_source_t obs_get_source_by_name(const char *name)
+obs_source_t *obs_get_source_by_name(const char *name)
 {
 	struct obs_core_data *data = &obs->data;
 	struct obs_source *source = NULL;
@@ -1038,46 +1038,46 @@ static inline void *get_context_by_name(void *vfirst, const char *name,
 	return context;
 }
 
-obs_output_t obs_get_output_by_name(const char *name)
+obs_output_t *obs_get_output_by_name(const char *name)
 {
 	if (!obs) return NULL;
 	return get_context_by_name(&obs->data.first_output, name,
 			&obs->data.outputs_mutex);
 }
 
-obs_encoder_t obs_get_encoder_by_name(const char *name)
+obs_encoder_t *obs_get_encoder_by_name(const char *name)
 {
 	if (!obs) return NULL;
 	return get_context_by_name(&obs->data.first_encoder, name,
 			&obs->data.encoders_mutex);
 }
 
-obs_service_t obs_get_service_by_name(const char *name)
+obs_service_t *obs_get_service_by_name(const char *name)
 {
 	if (!obs) return NULL;
 	return get_context_by_name(&obs->data.first_service, name,
 			&obs->data.services_mutex);
 }
 
-gs_effect_t obs_get_default_effect(void)
+gs_effect_t *obs_get_default_effect(void)
 {
 	if (!obs) return NULL;
 	return obs->video.default_effect;
 }
 
-gs_effect_t obs_get_solid_effect(void)
+gs_effect_t *obs_get_solid_effect(void)
 {
 	if (!obs) return NULL;
 	return obs->video.solid_effect;
 }
 
-signal_handler_t obs_get_signal_handler(void)
+signal_handler_t *obs_get_signal_handler(void)
 {
 	if (!obs) return NULL;
 	return obs->signals;
 }
 
-proc_handler_t obs_get_proc_handler(void)
+proc_handler_t *obs_get_proc_handler(void)
 {
 	if (!obs) return NULL;
 	return obs->procs;
@@ -1143,12 +1143,12 @@ float obs_get_present_volume(void)
 	return obs ? obs->audio.present_volume : 0.0f;
 }
 
-obs_source_t obs_load_source(obs_data_t source_data)
+obs_source_t *obs_load_source(obs_data_t *source_data)
 {
-	obs_source_t source;
+	obs_source_t *source;
 	const char   *name    = obs_data_get_string(source_data, "name");
 	const char   *id      = obs_data_get_string(source_data, "id");
-	obs_data_t   settings = obs_data_get_obj(source_data, "settings");
+	obs_data_t   *settings = obs_data_get_obj(source_data, "settings");
 	double       volume;
 
 	source = obs_source_create(OBS_SOURCE_TYPE_INPUT, id, name, settings);
@@ -1162,7 +1162,7 @@ obs_source_t obs_load_source(obs_data_t source_data)
 	return source;
 }
 
-void obs_load_sources(obs_data_array_t array)
+void obs_load_sources(obs_data_array_t *array)
 {
 	size_t count;
 	size_t i;
@@ -1174,8 +1174,8 @@ void obs_load_sources(obs_data_array_t array)
 	pthread_mutex_lock(&obs->data.user_sources_mutex);
 
 	for (i = 0; i < count; i++) {
-		obs_data_t   source_data = obs_data_array_item(array, i);
-		obs_source_t source      = obs_load_source(source_data);
+		obs_data_t   *source_data = obs_data_array_item(array, i);
+		obs_source_t *source      = obs_load_source(source_data);
 
 		obs_add_source(source);
 
@@ -1190,10 +1190,10 @@ void obs_load_sources(obs_data_array_t array)
 	pthread_mutex_unlock(&obs->data.user_sources_mutex);
 }
 
-obs_data_t obs_save_source(obs_source_t source)
+obs_data_t *obs_save_source(obs_source_t *source)
 {
-	obs_data_t source_data = obs_data_create();
-	obs_data_t settings    = obs_source_get_settings(source);
+	obs_data_t *source_data = obs_data_create();
+	obs_data_t *settings    = obs_source_get_settings(source);
 	float      volume      = obs_source_get_volume(source);
 	const char *name       = obs_source_get_name(source);
 	const char *id         = obs_source_get_id(source);
@@ -1210,9 +1210,9 @@ obs_data_t obs_save_source(obs_source_t source)
 	return source_data;
 }
 
-obs_data_array_t obs_save_sources(void)
+obs_data_array_t *obs_save_sources(void)
 {
-	obs_data_array_t array;
+	obs_data_array_t *array;
 	size_t i;
 
 	if (!obs) return NULL;
@@ -1222,8 +1222,8 @@ obs_data_array_t obs_save_sources(void)
 	pthread_mutex_lock(&obs->data.user_sources_mutex);
 
 	for (i = 0; i < obs->data.user_sources.num; i++) {
-		obs_source_t source      = obs->data.user_sources.array[i];
-		obs_data_t   source_data = obs_save_source(source);
+		obs_source_t *source      = obs->data.user_sources.array[i];
+		obs_data_t   *source_data = obs_save_source(source);
 
 		obs_data_array_push_back(array, source_data);
 		obs_data_release(source_data);
@@ -1250,7 +1250,7 @@ static inline char *dup_name(const char *name)
 
 static inline bool obs_context_data_init_wrap(
 		struct obs_context_data *context,
-		obs_data_t              settings,
+		obs_data_t              *settings,
 		const char              *name)
 {
 	assert(context);
@@ -1275,7 +1275,7 @@ static inline bool obs_context_data_init_wrap(
 
 bool obs_context_data_init(
 		struct obs_context_data *context,
-		obs_data_t              settings,
+		obs_data_t              *settings,
 		const char              *name)
 {
 	if (obs_context_data_init_wrap(context, settings, name)) {

libobs/obs.h

@@ -48,15 +48,15 @@ struct obs_encoder;
 struct obs_service;
 struct obs_module;
 
-typedef struct obs_display    *obs_display_t;
-typedef struct obs_view       *obs_view_t;
-typedef struct obs_source     *obs_source_t;
-typedef struct obs_scene      *obs_scene_t;
-typedef struct obs_scene_item *obs_sceneitem_t;
-typedef struct obs_output     *obs_output_t;
-typedef struct obs_encoder    *obs_encoder_t;
-typedef struct obs_service    *obs_service_t;
-typedef struct obs_module     *obs_module_t;
+typedef struct obs_display    obs_display_t;
+typedef struct obs_view       obs_view_t;
+typedef struct obs_source     obs_source_t;
+typedef struct obs_scene      obs_scene_t;
+typedef struct obs_scene_item obs_sceneitem_t;
+typedef struct obs_output     obs_output_t;
+typedef struct obs_encoder    obs_encoder_t;
+typedef struct obs_service    obs_service_t;
+typedef struct obs_module     obs_module_t;
 
 #include "obs-source.h"
 #include "obs-encoder.h"
@@ -280,7 +280,7 @@ EXPORT bool obs_get_audio_info(struct audio_output_info *ai);
  *                    MODULE_MISSING_EXPORTS if required exports are missing
  *                    MODULE_INCOMPATIBLE_VER if incompatible version
  */
-EXPORT int obs_open_module(obs_module_t *module, const char *path,
+EXPORT int obs_open_module(obs_module_t **module, const char *path,
 		const char *data_path);
 
 /**
@@ -288,25 +288,25 @@ EXPORT int obs_open_module(obs_module_t *module, const char *path,
  * module is alrady loaded, then this function does nothing and returns
  * successful.
  */
-EXPORT bool obs_init_module(obs_module_t module);
+EXPORT bool obs_init_module(obs_module_t *module);
 
 /** Returns the module file name */
-EXPORT const char *obs_get_module_file_name(obs_module_t module);
+EXPORT const char *obs_get_module_file_name(obs_module_t *module);
 
 /** Returns the module full name */
-EXPORT const char *obs_get_module_name(obs_module_t module);
+EXPORT const char *obs_get_module_name(obs_module_t *module);
 
 /** Returns the module author(s) */
-EXPORT const char *obs_get_module_author(obs_module_t module);
+EXPORT const char *obs_get_module_author(obs_module_t *module);
 
 /** Returns the module description */
-EXPORT const char *obs_get_module_description(obs_module_t module);
+EXPORT const char *obs_get_module_description(obs_module_t *module);
 
 /** Returns the module binary path */
-EXPORT const char *obs_get_module_binary_path(obs_module_t module);
+EXPORT const char *obs_get_module_binary_path(obs_module_t *module);
 
 /** Returns the module data path */
-EXPORT const char *obs_get_module_data_path(obs_module_t module);
+EXPORT const char *obs_get_module_data_path(obs_module_t *module);
 
 /**
  * Adds a module search path to be used with obs_find_modules.  If the search
@@ -332,13 +332,13 @@ typedef void (*obs_find_module_callback_t)(void *param,
 /** Finds all modules within the search paths added by obs_add_module_path. */
 EXPORT void obs_find_modules(obs_find_module_callback_t callback, void *param);
 
-typedef void (*obs_enum_module_callback_t)(void *param, obs_module_t module);
+typedef void (*obs_enum_module_callback_t)(void *param, obs_module_t *module);
 
 /** Enumerates all loaded modules */
 EXPORT void obs_enum_modules(obs_enum_module_callback_t callback, void *param);
 
 /** Helper function for using default module locale */
-EXPORT lookup_t obs_module_load_locale(obs_module_t module,
+EXPORT lookup_t *obs_module_load_locale(obs_module_t *module,
 		const char *default_locale, const char *locale);
 
 /**
@@ -352,7 +352,7 @@ EXPORT lookup_t obs_module_load_locale(obs_module_t module,
  * @param  file    The file to locate
  * @return         Path string, or NULL if not found.  Use bfree to free string.
  */
-EXPORT char *obs_find_module_file(obs_module_t module, const char *file);
+EXPORT char *obs_find_module_file(obs_module_t *module, const char *file);
 
 /**
  * Enumerates all available inputs source types.
@@ -394,10 +394,10 @@ EXPORT void obs_enter_graphics(void);
 EXPORT void obs_leave_graphics(void);
 
 /** Gets the main audio output handler for this OBS context */
-EXPORT audio_t obs_get_audio(void);
+EXPORT audio_t *obs_get_audio(void);
 
 /** Gets the main video output handler for this OBS context */
-EXPORT video_t obs_get_video(void);
+EXPORT video_t *obs_get_video(void);
 
 /**
  * Adds a source to the user source list and increments the reference counter
@@ -407,16 +407,16 @@ EXPORT video_t obs_get_video(void);
  * Typically when a transition is active, it is not meant to be accessible by
  * users, so there's no reason for a user to see such a source.
  */
-EXPORT bool obs_add_source(obs_source_t source);
+EXPORT bool obs_add_source(obs_source_t *source);
 
 /** Sets the primary output source for a channel. */
-EXPORT void obs_set_output_source(uint32_t channel, obs_source_t source);
+EXPORT void obs_set_output_source(uint32_t channel, obs_source_t *source);
 
 /**
  * Gets the primary output source for a channel and increments the reference
  * counter for that source.  Use obs_source_release to release.
  */
-EXPORT obs_source_t obs_get_output_source(uint32_t channel);
+EXPORT obs_source_t *obs_get_output_source(uint32_t channel);
 
 /**
  * Enumerates user sources
@@ -424,19 +424,19 @@ EXPORT obs_source_t obs_get_output_source(uint32_t channel);
  *   Callback function returns true to continue enumeration, or false to end
  * enumeration.
  */
-EXPORT void obs_enum_sources(bool (*enum_proc)(void*, obs_source_t),
+EXPORT void obs_enum_sources(bool (*enum_proc)(void*, obs_source_t*),
 		void *param);
 
 /** Enumerates outputs */
-EXPORT void obs_enum_outputs(bool (*enum_proc)(void*, obs_output_t),
+EXPORT void obs_enum_outputs(bool (*enum_proc)(void*, obs_output_t*),
 		void *param);
 
 /** Enumerates encoders */
-EXPORT void obs_enum_encoders(bool (*enum_proc)(void*, obs_encoder_t),
+EXPORT void obs_enum_encoders(bool (*enum_proc)(void*, obs_encoder_t*),
 		void *param);
 
 /** Enumerates encoders */
-EXPORT void obs_enum_services(bool (*enum_proc)(void*, obs_service_t),
+EXPORT void obs_enum_services(bool (*enum_proc)(void*, obs_service_t*),
 		void *param);
 
 /**
@@ -445,28 +445,28 @@ EXPORT void obs_enum_services(bool (*enum_proc)(void*, obs_service_t),
  *   Increments the source reference counter, use obs_source_release to
  * release it when complete.
  */
-EXPORT obs_source_t obs_get_source_by_name(const char *name);
+EXPORT obs_source_t *obs_get_source_by_name(const char *name);
 
 /** Gets an output by its name. */
-EXPORT obs_output_t obs_get_output_by_name(const char *name);
+EXPORT obs_output_t *obs_get_output_by_name(const char *name);
 
 /** Gets an encoder by its name. */
-EXPORT obs_encoder_t obs_get_encoder_by_name(const char *name);
+EXPORT obs_encoder_t *obs_get_encoder_by_name(const char *name);
 
 /** Gets an service by its name. */
-EXPORT obs_service_t obs_get_service_by_name(const char *name);
+EXPORT obs_service_t *obs_get_service_by_name(const char *name);
 
 /** Returns the default effect for generic RGB/YUV drawing */
-EXPORT gs_effect_t obs_get_default_effect(void);
+EXPORT gs_effect_t *obs_get_default_effect(void);
 
 /** Returns the solid effect for drawing solid colors */
-EXPORT gs_effect_t obs_get_solid_effect(void);
+EXPORT gs_effect_t *obs_get_solid_effect(void);
 
 /** Returns the primary obs signal handler */
-EXPORT signal_handler_t obs_get_signal_handler(void);
+EXPORT signal_handler_t *obs_get_signal_handler(void);
 
 /** Returns the primary obs procedure handler */
-EXPORT proc_handler_t obs_get_proc_handler(void);
+EXPORT proc_handler_t *obs_get_proc_handler(void);
 
 /** Adds a draw callback to the main render context */
 EXPORT void obs_add_draw_callback(
@@ -497,16 +497,16 @@ EXPORT float obs_get_master_volume(void);
 EXPORT float obs_get_present_volume(void);
 
 /** Saves a source to settings data */
-EXPORT obs_data_t obs_save_source(obs_source_t source);
+EXPORT obs_data_t *obs_save_source(obs_source_t *source);
 
 /** Loads a source from settings data */
-EXPORT obs_source_t obs_load_source(obs_data_t data);
+EXPORT obs_source_t *obs_load_source(obs_data_t *data);
 
 /** Loads sources from a data array */
-EXPORT void obs_load_sources(obs_data_array_t array);
+EXPORT void obs_load_sources(obs_data_array_t *array);
 
 /** Saves sources to a data array */
-EXPORT obs_data_array_t obs_save_sources(void);
+EXPORT obs_data_array_t *obs_save_sources(void);
 
 
 /* ------------------------------------------------------------------------- */
@@ -518,21 +518,21 @@ EXPORT obs_data_array_t obs_save_sources(void);
  *   A view can be used for things like separate previews, or drawing
  * sources separately.
  */
-EXPORT obs_view_t obs_view_create(void);
+EXPORT obs_view_t *obs_view_create(void);
 
 /** Destroys this view context */
-EXPORT void obs_view_destroy(obs_view_t view);
+EXPORT void obs_view_destroy(obs_view_t *view);
 
 /** Sets the source to be used for this view context. */
-EXPORT void obs_view_set_source(obs_view_t view, uint32_t channel,
-		obs_source_t source);
+EXPORT void obs_view_set_source(obs_view_t *view, uint32_t channel,
+		obs_source_t *source);
 
 /** Gets the source currently in use for this view context */
-EXPORT obs_source_t obs_view_get_source(obs_view_t view,
+EXPORT obs_source_t *obs_view_get_source(obs_view_t *view,
 		uint32_t channel);
 
 /** Renders the sources of this view context */
-EXPORT void obs_view_render(obs_view_t view);
+EXPORT void obs_view_render(obs_view_t *view);
 
 
 /* ------------------------------------------------------------------------- */
@@ -545,13 +545,14 @@ 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(struct gs_init_data *graphics_data);
 
 /** Destroys a display context */
-EXPORT void obs_display_destroy(obs_display_t display);
+EXPORT void obs_display_destroy(obs_display_t *display);
 
 /** Changes the size of this display */
-EXPORT void obs_display_resize(obs_display_t display, uint32_t cx, uint32_t cy);
+EXPORT void obs_display_resize(obs_display_t *display, uint32_t cx,
+		uint32_t cy);
 
 /**
  * Adds a draw callback for this display context
@@ -561,12 +562,12 @@ EXPORT void obs_display_resize(obs_display_t display, uint32_t cx, uint32_t cy);
  *                  updates.
  * @param  param    The user data to be associated with this draw callback.
  */
-EXPORT void obs_display_add_draw_callback(obs_display_t display,
+EXPORT void obs_display_add_draw_callback(obs_display_t *display,
 		void (*draw)(void *param, uint32_t cx, uint32_t cy),
 		void *param);
 
 /** Removes a draw callback for this display context */
-EXPORT void obs_display_remove_draw_callback(obs_display_t display,
+EXPORT void obs_display_remove_draw_callback(obs_display_t *display,
 		void (*draw)(void *param, uint32_t cx, uint32_t cy),
 		void *param);
 
@@ -584,120 +585,121 @@ EXPORT const char *obs_source_get_display_name(enum obs_source_type type,
  *   The "source" context is used for anything related to presenting
  * or modifying video/audio.  Use obs_source_release to release it.
  */
-EXPORT obs_source_t obs_source_create(enum obs_source_type type,
-		const char *id, const char *name, obs_data_t settings);
+EXPORT obs_source_t *obs_source_create(enum obs_source_type type,
+		const char *id, const char *name, obs_data_t *settings);
 
 /**
  * Adds/releases a reference to a source.  When the last reference is
  * released, the source is destroyed.
  */
-EXPORT void obs_source_addref(obs_source_t source);
-EXPORT void obs_source_release(obs_source_t source);
+EXPORT void obs_source_addref(obs_source_t *source);
+EXPORT void obs_source_release(obs_source_t *source);
 
 /** Notifies all references that the source should be released */
-EXPORT void obs_source_remove(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(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(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,
+EXPORT obs_data_t *obs_get_source_defaults(enum obs_source_type type,
 		const char *id);
 
 /** Returns the property list, if any.  Free with obs_properties_destroy */
-EXPORT obs_properties_t obs_get_source_properties(enum obs_source_type type,
+EXPORT obs_properties_t *obs_get_source_properties(enum obs_source_type type,
 		const char *id);
 
 /**
  * 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(obs_source_t *source);
 
 /** Updates settings for this source */
-EXPORT void obs_source_update(obs_source_t source, obs_data_t settings);
+EXPORT void obs_source_update(obs_source_t *source, obs_data_t *settings);
 
 /** Renders a video source. */
-EXPORT void obs_source_video_render(obs_source_t source);
+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(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(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(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(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);
+EXPORT void obs_source_filter_add(obs_source_t *source, obs_source_t *filter);
 
 /** Removes a filter from the source */
-EXPORT void obs_source_filter_remove(obs_source_t source, obs_source_t filter);
+EXPORT void obs_source_filter_remove(obs_source_t *source,
+		obs_source_t *filter);
 
 /** Modifies the order of a specific filter */
-EXPORT void obs_source_filter_set_order(obs_source_t source,
-		obs_source_t filter, enum obs_order_movement movement);
+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(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(obs_source_t *source);
 
 /** Sets the name of a source */
-EXPORT void obs_source_set_name(obs_source_t source, const char *name);
+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(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(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(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(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);
+EXPORT void obs_source_set_volume(obs_source_t *source, float volume);
 
 /** Sets the presentation volume for a source */
-EXPORT void obs_source_set_present_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(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(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);
+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(obs_source_t *source);
 
 /** Enumerates child sources used by this source */
-EXPORT void obs_source_enum_sources(obs_source_t source,
+EXPORT void obs_source_enum_sources(obs_source_t *source,
 		obs_source_enum_proc_t enum_callback,
 		void *param);
 
 /** Enumerates the entire child source tree used by this source */
-EXPORT void obs_source_enum_tree(obs_source_t source,
+EXPORT void obs_source_enum_tree(obs_source_t *source,
 		obs_source_enum_proc_t enum_callback,
 		void *param);
 
 /** Returns true if active, false if not */
-EXPORT bool obs_source_active(obs_source_t source);
+EXPORT bool obs_source_active(obs_source_t *source);
 
 /**
  * Sometimes sources need to be told when to save their settings so they
@@ -705,7 +707,7 @@ EXPORT bool obs_source_active(obs_source_t source);
  * call the source's 'save' callback if any, which will save its current
  * data to its settings.
  */
-EXPORT void obs_source_save(obs_source_t source);
+EXPORT void obs_source_save(obs_source_t *source);
 
 /**
  * Sometimes sources need to be told when they are loading their settings
@@ -713,28 +715,28 @@ EXPORT void obs_source_save(obs_source_t source);
  * it's meant to be used after the source has been created and loaded from
  * somewhere (such as a saved file).
  */
-EXPORT void obs_source_load(obs_source_t source);
+EXPORT void obs_source_load(obs_source_t *source);
 
 /* ------------------------------------------------------------------------- */
 /* Functions used by sources */
 
 /** Outputs asynchronous video data */
-EXPORT void obs_source_output_video(obs_source_t source,
+EXPORT void obs_source_output_video(obs_source_t *source,
 		const struct obs_source_frame *frame);
 
 /** Outputs audio data (always asynchronous) */
-EXPORT void obs_source_output_audio(obs_source_t source,
+EXPORT void obs_source_output_audio(obs_source_t *source,
 		const struct obs_source_audio *audio);
 
 /** Gets the current async video frame */
-EXPORT struct obs_source_frame *obs_source_get_frame(obs_source_t source);
+EXPORT struct obs_source_frame *obs_source_get_frame(obs_source_t *source);
 
 /** Releases the current async video frame */
-EXPORT void obs_source_release_frame(obs_source_t source,
+EXPORT void obs_source_release_frame(obs_source_t *source,
 		struct obs_source_frame *frame);
 
 /** Default RGB filter handler for generic effect filters */
-EXPORT void obs_source_process_filter(obs_source_t filter, gs_effect_t effect,
+EXPORT void obs_source_process_filter(obs_source_t *filter, gs_effect_t *effect,
 		uint32_t width, uint32_t height, enum gs_color_format format,
 		enum obs_allow_direct_render allow_direct);
 
@@ -743,47 +745,47 @@ EXPORT void obs_source_process_filter(obs_source_t filter, gs_effect_t effect,
  * when the child is added.  This ensures that the source is properly activated
  * if the parent is active.
  */
-EXPORT void obs_source_add_child(obs_source_t parent, obs_source_t child);
+EXPORT void obs_source_add_child(obs_source_t *parent, obs_source_t *child);
 
 /**
  * Removes a child source.  Must be called by parent sources on child sources
  * when the child is removed.  This ensures that the source is properly
  * deactivated if the parent is active.
  */
-EXPORT void obs_source_remove_child(obs_source_t parent, obs_source_t child);
+EXPORT void obs_source_remove_child(obs_source_t *parent, obs_source_t *child);
 
 /** Sends a mouse down/up event to a source */
-EXPORT void obs_source_send_mouse_click(obs_source_t source,
+EXPORT void obs_source_send_mouse_click(obs_source_t *source,
 		const struct obs_mouse_event *event,
 		int32_t type, bool mouse_up,
 		uint32_t click_count);
 
 /** Sends a mouse move event to a source. */
-EXPORT void obs_source_send_mouse_move(obs_source_t source,
+EXPORT void obs_source_send_mouse_move(obs_source_t *source,
 		const struct obs_mouse_event *event, bool mouse_leave);
 
 /** Sends a mouse wheel event to a source */
-EXPORT void obs_source_send_mouse_wheel(obs_source_t source,
+EXPORT void obs_source_send_mouse_wheel(obs_source_t *source,
 		const struct obs_mouse_event *event, int x_delta, int y_delta);
 
 /** Sends a got-focus or lost-focus event to a source */
-EXPORT void obs_source_send_focus(obs_source_t source, bool focus);
+EXPORT void obs_source_send_focus(obs_source_t *source, bool focus);
 
 /** Sends a key up/down event to a source */
-EXPORT void obs_source_send_key_click(obs_source_t source,
+EXPORT void obs_source_send_key_click(obs_source_t *source,
 		const struct obs_key_event *event, bool key_up);
 
 /** Begins transition frame.  Sets all transitioning volume values to 0.0f. */
-EXPORT void obs_transition_begin_frame(obs_source_t transition);
+EXPORT void obs_transition_begin_frame(obs_source_t *transition);
 
 /**
  * Adds a transitioning volume value to a source that's being transitioned.
  * This value is applied to all the sources within the the source.
  */
-EXPORT void obs_source_set_transition_vol(obs_source_t source, float vol);
+EXPORT void obs_source_set_transition_vol(obs_source_t *source, float vol);
 
 /** Ends transition frame and applies new presentation volumes to all sources */
-EXPORT void obs_transition_end_frame(obs_source_t transition);
+EXPORT void obs_transition_end_frame(obs_source_t *transition);
 
 
 /* ------------------------------------------------------------------------- */
@@ -795,78 +797,80 @@ EXPORT void obs_transition_end_frame(obs_source_t transition);
  *   A scene is a source which is a container of other sources with specific
  * display oriantations.  Scenes can also be used like any other source.
  */
-EXPORT obs_scene_t obs_scene_create(const char *name);
+EXPORT obs_scene_t *obs_scene_create(const char *name);
 
-EXPORT void        obs_scene_addref(obs_scene_t scene);
-EXPORT void        obs_scene_release(obs_scene_t scene);
+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(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(obs_source_t *source);
 
 /** Determines whether a source is within a scene */
-EXPORT obs_sceneitem_t obs_scene_find_source(obs_scene_t scene,
+EXPORT obs_sceneitem_t *obs_scene_find_source(obs_scene_t *scene,
 		const char *name);
 
 /** Enumerates sources within a scene */
-EXPORT void obs_scene_enum_items(obs_scene_t scene,
-		bool (*callback)(obs_scene_t, obs_sceneitem_t, void*),
+EXPORT void obs_scene_enum_items(obs_scene_t *scene,
+		bool (*callback)(obs_scene_t*, obs_sceneitem_t*, void*),
 		void *param);
 
 /** Adds/creates a new scene item for a source */
-EXPORT obs_sceneitem_t obs_scene_add(obs_scene_t scene, obs_source_t source);
+EXPORT obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source);
 
-EXPORT void obs_sceneitem_addref(obs_sceneitem_t item);
-EXPORT void obs_sceneitem_release(obs_sceneitem_t item);
+EXPORT void obs_sceneitem_addref(obs_sceneitem_t *item);
+EXPORT void obs_sceneitem_release(obs_sceneitem_t *item);
 
 /** Removes a scene item. */
-EXPORT void obs_sceneitem_remove(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(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(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 void obs_sceneitem_select(obs_sceneitem_t *item, bool select);
+EXPORT bool obs_sceneitem_selected(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);
-EXPORT void obs_sceneitem_set_rot(obs_sceneitem_t item, float rot_deg);
-EXPORT void obs_sceneitem_set_scale(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_set_pos(obs_sceneitem_t *item, const struct vec2 *pos);
+EXPORT void obs_sceneitem_set_rot(obs_sceneitem_t *item, float rot_deg);
+EXPORT void obs_sceneitem_set_scale(obs_sceneitem_t *item,
 		const struct vec2 *scale);
-EXPORT void obs_sceneitem_set_alignment(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_set_alignment(obs_sceneitem_t *item,
 		uint32_t alignment);
-EXPORT void obs_sceneitem_set_order(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_set_order(obs_sceneitem_t *item,
 		enum obs_order_movement movement);
 
-EXPORT void obs_sceneitem_set_bounds_type(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_set_bounds_type(obs_sceneitem_t *item,
 		enum obs_bounds_type type);
-EXPORT void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t *item,
 		uint32_t alignment);
-EXPORT void obs_sceneitem_set_bounds(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(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 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, struct vec2 *bounds);
+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,
+		struct vec2 *bounds);
 
-EXPORT void obs_sceneitem_get_info(obs_sceneitem_t item,
+EXPORT void obs_sceneitem_get_info(obs_sceneitem_t *item,
 		struct obs_transform_info *info);
-EXPORT void obs_sceneitem_set_info(obs_sceneitem_t item,
+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(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(obs_sceneitem_t *item,
 		struct matrix4 *transform);
 
 
@@ -881,105 +885,106 @@ EXPORT const char *obs_output_get_display_name(const char *id);
  *   Outputs allow outputting to file, outputting to network, outputting to
  * directshow, or other custom outputs.
  */
-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 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(obs_output_t *output);
 
 /** Starts the output. */
-EXPORT bool obs_output_start(obs_output_t output);
+EXPORT bool obs_output_start(obs_output_t *output);
 
 /** Stops the output. */
-EXPORT void obs_output_stop(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(obs_output_t *output);
 
 /** Gets the default settings for an output type */
-EXPORT obs_data_t obs_output_defaults(const char *id);
+EXPORT obs_data_t *obs_output_defaults(const char *id);
 
 /** Returns the property list, if any.  Free with obs_properties_destroy */
-EXPORT obs_properties_t obs_get_output_properties(const char *id);
+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(obs_output_t *output);
 
 /** Updates the settings for this output context */
-EXPORT void obs_output_update(obs_output_t output, obs_data_t settings);
+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(obs_output_t *output);
 
 /** Pauses the output (if the functionality is allowed by the output */
-EXPORT void obs_output_pause(obs_output_t 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(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(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(obs_output_t *output);
 
 /**
  * Sets the current video media context associated with this output,
  * required for non-encoded outputs
  */
-EXPORT void obs_output_set_video(obs_output_t output, video_t video);
+EXPORT void obs_output_set_video(obs_output_t *output, video_t *video);
 
 /**
  * Sets the current audio/video media contexts associated with this output,
  * required for non-encoded outputs.  Can be null.
  */
-EXPORT void obs_output_set_media(obs_output_t output,
-		video_t video, audio_t audio);
+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(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(obs_output_t *output);
 
 /**
  * Sets the current video encoder associated with this output,
  * required for encoded outputs
  */
-EXPORT void obs_output_set_video_encoder(obs_output_t output,
-		obs_encoder_t encoder);
+EXPORT void obs_output_set_video_encoder(obs_output_t *output,
+		obs_encoder_t *encoder);
 
 /**
  * Sets the current audio encoder associated with this output,
  * required for encoded outputs
  */
-EXPORT void obs_output_set_audio_encoder(obs_output_t output,
-		obs_encoder_t encoder);
+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(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(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);
+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(obs_output_t *output);
 
 /**
  * Sets the reconnect settings.  Set retry_count to 0 to disable reconnecting.
  */
-EXPORT void obs_output_set_reconnect_settings(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(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);
 
 /**
  * Sets the preferred scaled resolution for this output.  Set width and height
@@ -989,32 +994,33 @@ EXPORT int obs_output_get_total_frames(obs_output_t output);
  * the encoder before the stream is started.  If the encoder is already active,
  * then this function will trigger a warning and do nothing.
  */
-EXPORT void obs_output_set_preferred_size(obs_output_t output, uint32_t width,
+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(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(obs_output_t *output);
 
 /* ------------------------------------------------------------------------- */
 /* Functions used by outputs */
 
 /** Optionally sets the video conversion info.  Used only for raw output */
-EXPORT void obs_output_set_video_conversion(obs_output_t output,
+EXPORT void obs_output_set_video_conversion(obs_output_t *output,
 		const struct video_scale_info *conversion);
 
 /** Optionally sets the audio conversion info.  Used only for raw output */
-EXPORT void obs_output_set_audio_conversion(obs_output_t output,
+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(obs_output_t *output,
 		uint32_t flags);
 
 /** Initializes encoders (if any) */
-EXPORT bool obs_output_initialize_encoders(obs_output_t output, uint32_t flags);
+EXPORT bool obs_output_initialize_encoders(obs_output_t *output,
+		uint32_t flags);
 
 /**
  * Begins data capture from media/encoders.
@@ -1028,10 +1034,10 @@ EXPORT bool obs_output_initialize_encoders(obs_output_t output, uint32_t flags);
  *                 and video.
  * @return         true if successful, false otherwise.
  */
-EXPORT bool obs_output_begin_data_capture(obs_output_t output, uint32_t flags);
+EXPORT bool obs_output_begin_data_capture(obs_output_t *output, uint32_t flags);
 
 /** Ends data capture from media/encoders */
-EXPORT void obs_output_end_data_capture(obs_output_t output);
+EXPORT void obs_output_end_data_capture(obs_output_t *output);
 
 /**
  * Signals that the output has stopped itself.
@@ -1039,7 +1045,7 @@ EXPORT void obs_output_end_data_capture(obs_output_t output);
  * @param  output  Output context
  * @param  code    Error code (or OBS_OUTPUT_SUCCESS if not an error)
  */
-EXPORT void obs_output_signal_stop(obs_output_t output, int code);
+EXPORT void obs_output_signal_stop(obs_output_t *output, int code);
 
 
 /* ------------------------------------------------------------------------- */
@@ -1055,8 +1061,8 @@ EXPORT const char *obs_encoder_getdisplayname(const char *id);
  * @param  settings  Settings
  * @return           The video encoder context, or NULL if failed or not found.
  */
-EXPORT obs_encoder_t obs_video_encoder_create(const char *id, const char *name,
-		obs_data_t settings);
+EXPORT obs_encoder_t *obs_video_encoder_create(const char *id, const char *name,
+		obs_data_t *settings);
 
 /**
  * Creates an audio encoder context
@@ -1066,76 +1072,76 @@ EXPORT obs_encoder_t obs_video_encoder_create(const char *id, const char *name,
  * @param  settings  Settings
  * @return           The video encoder context, or NULL if failed or not found.
  */
-EXPORT obs_encoder_t obs_audio_encoder_create(const char *id, const char *name,
-		obs_data_t settings);
+EXPORT obs_encoder_t *obs_audio_encoder_create(const char *id, const char *name,
+		obs_data_t *settings);
 
 /** Destroys an encoder context */
-EXPORT void obs_encoder_destroy(obs_encoder_t encoder);
+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(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(obs_encoder_t *encoder);
 
 /**
  * Sets the scaled resolution for a video encoder.  Set width and height to 0
  * to disable scaling.  If the encoder is active, this function will trigger
  * a warning, and do nothing.
  */
-EXPORT void obs_encoder_set_scaled_size(obs_encoder_t encoder, uint32_t width,
+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(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(obs_encoder_t *encoder);
 
 /** Gets the default settings for an encoder type */
-EXPORT obs_data_t obs_encoder_defaults(const char *id);
+EXPORT obs_data_t *obs_encoder_defaults(const char *id);
 
 /** Returns the property list, if any.  Free with obs_properties_destroy */
-EXPORT obs_properties_t obs_get_encoder_properties(const char *id);
+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(obs_encoder_t *encoder);
 
 /**
  * Updates the settings of the encoder context.  Usually used for changing
  * bitrate while active
  */
-EXPORT void obs_encoder_update(obs_encoder_t encoder, obs_data_t settings);
+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(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(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);
+EXPORT void obs_encoder_set_video(obs_encoder_t *encoder, video_t *video);
 
 /** Sets the audio output context to be used with this encoder */
-EXPORT void obs_encoder_set_audio(obs_encoder_t encoder, audio_t audio);
+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(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(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(obs_encoder_t *encoder);
 
 /** Duplicates an encoder packet */
 EXPORT void obs_duplicate_encoder_packet(struct encoder_packet *dst,
@@ -1149,44 +1155,44 @@ EXPORT void obs_free_encoder_packet(struct encoder_packet *packet);
 
 EXPORT const char *obs_service_get_display_name(const char *id);
 
-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 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(obs_service_t *service);
 
 /** Gets the default settings for a service */
-EXPORT obs_data_t obs_service_defaults(const char *id);
+EXPORT obs_data_t *obs_service_defaults(const char *id);
 
 /** Returns the property list, if any.  Free with obs_properties_destroy */
-EXPORT obs_properties_t obs_get_service_properties(const char *id);
+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(obs_service_t *service);
 
 /** Gets the service type */
-EXPORT const char *obs_service_gettype(obs_service_t service);
+EXPORT const char *obs_service_gettype(obs_service_t *service);
 
 /** Updates the settings of the service context */
-EXPORT void obs_service_update(obs_service_t service, obs_data_t settings);
+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(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(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(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(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(obs_service_t *service);
 
 
 /* ------------------------------------------------------------------------- */

libobs/obs.hpp

@@ -62,12 +62,12 @@ public:
 	inline bool operator!=(T p) const {return val != p;}
 };
 
-using OBSSource = OBSRef<obs_source_t, obs_source_addref, obs_source_release>;
-using OBSScene = OBSRef<obs_scene_t,  obs_scene_addref,  obs_scene_release>;
-using OBSSceneItem = OBSRef<obs_sceneitem_t, obs_sceneitem_addref,
+using OBSSource = OBSRef<obs_source_t*, obs_source_addref, obs_source_release>;
+using OBSScene = OBSRef<obs_scene_t*,  obs_scene_addref,  obs_scene_release>;
+using OBSSceneItem = OBSRef<obs_sceneitem_t*, obs_sceneitem_addref,
 						obs_sceneitem_release>;
-using OBSData = OBSRef<obs_data_t, obs_data_addref, obs_data_release>;
-using OBSDataArray = OBSRef<obs_data_array_t, obs_data_array_addref,
+using OBSData = OBSRef<obs_data_t*, obs_data_addref, obs_data_release>;
+using OBSDataArray = OBSRef<obs_data_array_t*, obs_data_array_addref,
 						obs_data_array_release>;
 
 /* objects that are not meant to be instanced */
@@ -94,14 +94,14 @@ public:
 	inline bool operator!=(T p) const {return obj != p;}
 };
 
-using OBSDisplay = OBSObj<obs_display_t, obs_display_destroy>;
-using OBSEncoder = OBSObj<obs_encoder_t, obs_encoder_destroy>;
-using OBSView    = OBSObj<obs_view_t,    obs_view_destroy>;
-using OBSOutput  = OBSObj<obs_output_t,  obs_output_destroy>;
+using OBSDisplay = OBSObj<obs_display_t*, obs_display_destroy>;
+using OBSEncoder = OBSObj<obs_encoder_t*, obs_encoder_destroy>;
+using OBSView    = OBSObj<obs_view_t*,    obs_view_destroy>;
+using OBSOutput  = OBSObj<obs_output_t*,  obs_output_destroy>;
 
 /* signal handler connection */
 class OBSSignal {
-	signal_handler_t  handler;
+	signal_handler_t  *handler;
 	const char        *signal;
 	signal_callback_t callback;
 	void              *param;
@@ -114,7 +114,7 @@ public:
 		  param    (nullptr)
 	{}
 
-	inline OBSSignal(signal_handler_t handler_,
+	inline OBSSignal(signal_handler_t *handler_,
 			const char        *signal_,
 			signal_callback_t callback_,
 			void              *param_)
@@ -137,7 +137,7 @@ public:
 
 	inline ~OBSSignal() {Disconnect();}
 
-	inline void Connect(signal_handler_t handler_,
+	inline void Connect(signal_handler_t *handler_,
 			const char *signal_,
 			signal_callback_t callback_,
 			void *param_)

libobs/util/config-file.c

@@ -58,7 +58,7 @@ struct config_data {
 	struct darray defaults; /* struct config_section */
 };
 
-config_t config_create(const char *file)
+config_t *config_create(const char *file)
 {
 	struct config_data *config;
 	FILE *f;
@@ -224,7 +224,7 @@ complete:
 	return CONFIG_SUCCESS;
 }
 
-int config_open(config_t *config, const char *file,
+int config_open(config_t **config, const char *file,
 		enum config_open_type open_type)
 {
 	int errorcode;
@@ -249,7 +249,7 @@ int config_open(config_t *config, const char *file,
 	return errorcode;
 }
 
-int config_open_defaults(config_t config, const char *file)
+int config_open_defaults(config_t *config, const char *file)
 {
 	if (!config)
 		return CONFIG_ERROR;
@@ -257,7 +257,7 @@ int config_open_defaults(config_t config, const char *file)
 	return config_parse(&config->defaults, file, false);
 }
 
-int config_save(config_t config)
+int config_save(config_t *config)
 {
 	FILE *f;
 	struct dstr str;
@@ -306,7 +306,7 @@ int config_save(config_t config)
 	return CONFIG_SUCCESS;
 }
 
-void config_close(config_t config)
+void config_close(config_t *config)
 {
 	struct config_section *defaults, *sections;
 	size_t i;
@@ -327,12 +327,12 @@ void config_close(config_t config)
 	bfree(config);
 }
 
-size_t config_num_sections(config_t config)
+size_t config_num_sections(config_t *config)
 {
 	return config->sections.num;
 }
 
-const char *config_get_section(config_t config, size_t idx)
+const char *config_get_section(config_t *config, size_t idx)
 {
 	struct config_section *section;
 
@@ -408,7 +408,7 @@ static void config_set_item(struct darray *sections, const char *section,
 	item->value = value;
 }
 
-void config_set_string(config_t config, const char *section,
+void config_set_string(config_t *config, const char *section,
 		const char *name, const char *value)
 {
 	if (!value)
@@ -416,7 +416,7 @@ void config_set_string(config_t config, const char *section,
 	config_set_item(&config->sections, section, name, bstrdup(value));
 }
 
-void config_set_int(config_t config, const char *section,
+void config_set_int(config_t *config, const char *section,
 		const char *name, int64_t value)
 {
 	struct dstr str;
@@ -425,7 +425,7 @@ void config_set_int(config_t config, const char *section,
 	config_set_item(&config->sections, section, name, str.array);
 }
 
-void config_set_uint(config_t config, const char *section,
+void config_set_uint(config_t *config, const char *section,
 		const char *name, uint64_t value)
 {
 	struct dstr str;
@@ -434,14 +434,14 @@ void config_set_uint(config_t config, const char *section,
 	config_set_item(&config->sections, section, name, str.array);
 }
 
-void config_set_bool(config_t config, const char *section,
+void config_set_bool(config_t *config, const char *section,
 		const char *name, bool value)
 {
 	char *str = bstrdup(value ? "true" : "false");
 	config_set_item(&config->sections, section, name, str);
 }
 
-void config_set_double(config_t config, const char *section,
+void config_set_double(config_t *config, const char *section,
 		const char *name, double value)
 {
 	struct dstr str;
@@ -450,7 +450,7 @@ void config_set_double(config_t config, const char *section,
 	config_set_item(&config->sections, section, name, str.array);
 }
 
-void config_set_default_string(config_t config, const char *section,
+void config_set_default_string(config_t *config, const char *section,
 		const char *name, const char *value)
 {
 	if (!value)
@@ -458,7 +458,7 @@ void config_set_default_string(config_t config, const char *section,
 	config_set_item(&config->defaults, section, name, bstrdup(value));
 }
 
-void config_set_default_int(config_t config, const char *section,
+void config_set_default_int(config_t *config, const char *section,
 		const char *name, int64_t value)
 {
 	struct dstr str;
@@ -467,7 +467,7 @@ void config_set_default_int(config_t config, const char *section,
 	config_set_item(&config->defaults, section, name, str.array);
 }
 
-void config_set_default_uint(config_t config, const char *section,
+void config_set_default_uint(config_t *config, const char *section,
 		const char *name, uint64_t value)
 {
 	struct dstr str;
@@ -476,14 +476,14 @@ void config_set_default_uint(config_t config, const char *section,
 	config_set_item(&config->defaults, section, name, str.array);
 }
 
-void config_set_default_bool(config_t config, const char *section,
+void config_set_default_bool(config_t *config, const char *section,
 		const char *name, bool value)
 {
 	char *str = bstrdup(value ? "true" : "false");
 	config_set_item(&config->defaults, section, name, str);
 }
 
-void config_set_default_double(config_t config, const char *section,
+void config_set_default_double(config_t *config, const char *section,
 		const char *name, double value)
 {
 	struct dstr str;
@@ -492,7 +492,7 @@ 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(config_t *config, const char *section,
 		const char *name)
 {
 	struct config_item *item = config_find_item(&config->sections,
@@ -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(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(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(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(config_t *config, const char *section,
 		const char *name)
 {
 	const char *value = config_get_string(config, section, name);
@@ -546,7 +546,7 @@ 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 *config_get_default_string(config_t *config, const char *section,
 		const char *name)
 {
 	struct config_item *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(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(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(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(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(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(config_t *config, const char *section,
 		const char *name)
 {
 	return config_find_item(&config->defaults, section, name) != NULL;

libobs/util/config-file.h

@@ -30,7 +30,7 @@ extern "C" {
 #endif
 
 struct config_data;
-typedef struct config_data *config_t;
+typedef struct config_data config_t;
 
 #define CONFIG_SUCCESS      0
 #define CONFIG_FILENOTFOUND -1
@@ -41,35 +41,35 @@ enum config_open_type {
 	CONFIG_OPEN_ALWAYS,
 };
 
-EXPORT config_t config_create(const char *file);
-EXPORT int config_open(config_t *config, const char *file,
+EXPORT config_t *config_create(const char *file);
+EXPORT int config_open(config_t **config, const char *file,
 		enum config_open_type open_type);
-EXPORT int config_save(config_t config);
-EXPORT void config_close(config_t config);
+EXPORT int config_save(config_t *config);
+EXPORT void config_close(config_t *config);
 
-EXPORT size_t config_num_sections(config_t config);
-EXPORT const char *config_get_section(config_t config, size_t idx);
+EXPORT size_t config_num_sections(config_t *config);
+EXPORT const char *config_get_section(config_t *config, size_t idx);
 
-EXPORT void config_set_string(config_t config, const char *section,
+EXPORT void config_set_string(config_t *config, const char *section,
 		const char *name, const char *value);
-EXPORT void config_set_int(config_t config, const char *section,
+EXPORT void config_set_int(config_t *config, const char *section,
 		const char *name, int64_t value);
-EXPORT void config_set_uint(config_t config, const char *section,
+EXPORT void config_set_uint(config_t *config, const char *section,
 		const char *name, uint64_t value);
-EXPORT void config_set_bool(config_t config, const char *section,
+EXPORT void config_set_bool(config_t *config, const char *section,
 		const char *name, bool value);
-EXPORT void config_set_double(config_t config, const char *section,
+EXPORT void config_set_double(config_t *config, const char *section,
 		const char *name, double value);
 
-EXPORT const char *config_get_string(config_t config, const char *section,
+EXPORT const char *config_get_string(config_t *config, const char *section,
 		const char *name);
-EXPORT int64_t config_get_int(config_t config, const char *section,
+EXPORT int64_t config_get_int(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(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(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(config_t *config, const char *section,
 		const char *name);
 
 /*
@@ -86,35 +86,35 @@ EXPORT double config_get_double(config_t config, const char *section,
  * functions (recommended for most cases), or you can initialize it via a file
  * with config_open_defaults.
  */
-EXPORT int config_open_defaults(config_t config, const char *file);
+EXPORT int config_open_defaults(config_t *config, const char *file);
 
-EXPORT void config_set_default_string(config_t config, const char *section,
+EXPORT void config_set_default_string(config_t *config, const char *section,
 		const char *name, const char *value);
-EXPORT void config_set_default_int(config_t config, const char *section,
+EXPORT void config_set_default_int(config_t *config, const char *section,
 		const char *name, int64_t value);
-EXPORT void config_set_default_uint(config_t config, const char *section,
+EXPORT void config_set_default_uint(config_t *config, const char *section,
 		const char *name, uint64_t value);
-EXPORT void config_set_default_bool(config_t config, const char *section,
+EXPORT void config_set_default_bool(config_t *config, const char *section,
 		const char *name, bool value);
-EXPORT void config_set_default_double(config_t config, const char *section,
+EXPORT void config_set_default_double(config_t *config, const char *section,
 		const char *name, double value);
 
 /* 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(config_t *config,
 		const char *section, const char *name);
-EXPORT int64_t config_get_default_int(config_t config, const char *section,
+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,
+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,
+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,
+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,
+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,
+EXPORT bool config_has_default_value(config_t *config, const char *section,
 		const char *name);
 
 #ifdef __cplusplus

libobs/util/platform-cocoa.m

@@ -146,7 +146,7 @@ static bool get_time_info(int64_t *cpu_time, int64_t *sys_time)
 	return true;
 }
 
-os_cpu_usage_info_t os_cpu_usage_info_start(void)
+os_cpu_usage_info_t *os_cpu_usage_info_start(void)
 {
 	struct os_cpu_usage_info *info = bmalloc(sizeof(*info));
 
@@ -159,7 +159,7 @@ os_cpu_usage_info_t os_cpu_usage_info_start(void)
 	return info;
 }
 
-double os_cpu_usage_info_query(os_cpu_usage_info_t info)
+double os_cpu_usage_info_query(os_cpu_usage_info_t *info)
 {
 	int64_t sys_time,       cpu_time;
 	int64_t sys_time_delta, cpu_time_delta;
@@ -180,13 +180,13 @@ double os_cpu_usage_info_query(os_cpu_usage_info_t info)
 		(double)info->core_count;
 }
 
-void os_cpu_usage_info_destroy(os_cpu_usage_info_t info)
+void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info)
 {
 	if (info)
 		bfree(info);
 }
 
-os_performance_token_t os_request_high_performance(const char *reason)
+os_performance_token_t *os_request_high_performance(const char *reason)
 {
 	@autoreleasepool {
 		NSProcessInfo *pi = [NSProcessInfo processInfo];
@@ -202,7 +202,7 @@ os_performance_token_t os_request_high_performance(const char *reason)
 	}
 }
 
-void os_end_high_performance(os_performance_token_t token)
+void os_end_high_performance(os_performance_token_t *token)
 {
 	@autoreleasepool {
 		NSProcessInfo *pi = [NSProcessInfo processInfo];

libobs/util/platform-nix.c

@@ -70,7 +70,7 @@ struct os_cpu_usage_info {
 	int core_count;
 };
 
-os_cpu_usage_info_t os_cpu_usage_info_start(void)
+os_cpu_usage_info_t *os_cpu_usage_info_start(void)
 {
 	struct os_cpu_usage_info *info = bmalloc(sizeof(*info));
 	struct tms               time_sample;
@@ -82,7 +82,7 @@ os_cpu_usage_info_t os_cpu_usage_info_start(void)
 	return info;
 }
 
-double os_cpu_usage_info_query(os_cpu_usage_info_t info)
+double os_cpu_usage_info_query(os_cpu_usage_info_t *info)
 {
 	struct tms time_sample;
 	clock_t    cur_cpu_time;
@@ -109,7 +109,7 @@ double os_cpu_usage_info_query(os_cpu_usage_info_t info)
 	return percent * 100.0;
 }
 
-void os_cpu_usage_info_destroy(os_cpu_usage_info_t info)
+void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info)
 {
 	if (info)
 		bfree(info);
@@ -181,7 +181,7 @@ struct os_dir {
 	struct os_dirent out;
 };
 
-os_dir_t os_opendir(const char *path)
+os_dir_t *os_opendir(const char *path)
 {
 	struct os_dir *dir;
 	DIR           *dir_val;
@@ -206,7 +206,7 @@ static inline bool is_dir(const char *path)
 	return false;
 }
 
-struct os_dirent *os_readdir(os_dir_t dir)
+struct os_dirent *os_readdir(os_dir_t *dir)
 {
 	struct dstr file_path = {0};
 
@@ -229,7 +229,7 @@ struct os_dirent *os_readdir(os_dir_t dir)
 	return &dir->out;
 }
 
-void os_closedir(os_dir_t dir)
+void os_closedir(os_dir_t *dir)
 {
 	if (dir) {
 		closedir(dir->dir);
@@ -242,7 +242,7 @@ struct posix_glob_info {
 	glob_t gl;
 };
 
-int os_glob(const char *pattern, int flags, os_glob_t *pglob)
+int os_glob(const char *pattern, int flags, os_glob_t **pglob)
 {
 	struct posix_glob_info pgi;
 	int ret = glob(pattern, 0, NULL, &pgi.gl);
@@ -271,7 +271,7 @@ int os_glob(const char *pattern, int flags, os_glob_t *pglob)
 	return ret;
 }
 
-void os_globfree(os_glob_t pglob)
+void os_globfree(os_glob_t *pglob)
 {
 	if (pglob) {
 		struct posix_glob_info *pgi = (struct posix_glob_info*)pglob;
@@ -296,13 +296,13 @@ int os_mkdir(const char *path)
 }
 
 #if !defined(__APPLE__)
-os_performance_token_t os_request_high_performance(const char *reason)
+os_performance_token_t *os_request_high_performance(const char *reason)
 {
 	UNUSED_PARAMETER(reason);
 	return NULL;
 }
 
-void os_end_high_performance(os_performance_token_t token)
+void os_end_high_performance(os_performance_token_t *token)
 {
 	UNUSED_PARAMETER(token);
 }

libobs/util/platform-windows.c

@@ -97,7 +97,7 @@ struct os_cpu_usage_info {
 	DWORD core_count;
 };
 
-os_cpu_usage_info_t os_cpu_usage_info_start(void)
+os_cpu_usage_info_t *os_cpu_usage_info_start(void)
 {
 	struct os_cpu_usage_info *info = bzalloc(sizeof(*info));
 	SYSTEM_INFO           si;
@@ -112,7 +112,7 @@ os_cpu_usage_info_t os_cpu_usage_info_start(void)
 	return info;
 }
 
-double os_cpu_usage_info_query(os_cpu_usage_info_t info)
+double os_cpu_usage_info_query(os_cpu_usage_info_t *info)
 {
 	union time_data cur_time, cur_sys_time, cur_user_time;
 	FILETIME        dummy;
@@ -137,7 +137,7 @@ double os_cpu_usage_info_query(os_cpu_usage_info_t info)
 	return percent * 100.0;
 }
 
-void os_cpu_usage_info_destroy(os_cpu_usage_info_t info)
+void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info)
 {
 	if (info)
 		bfree(info);
@@ -231,7 +231,7 @@ struct os_dir {
 	struct os_dirent out;
 };
 
-os_dir_t os_opendir(const char *path)
+os_dir_t *os_opendir(const char *path)
 {
 	struct dstr     path_str = {0};
 	struct os_dir   *dir     = NULL;
@@ -264,7 +264,7 @@ static inline bool is_dir(WIN32_FIND_DATA *wfd)
 	return !!(wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 }
 
-struct os_dirent *os_readdir(os_dir_t dir)
+struct os_dirent *os_readdir(os_dir_t *dir)
 {
 	if (!dir)
 		return NULL;
@@ -284,7 +284,7 @@ struct os_dirent *os_readdir(os_dir_t dir)
 	return &dir->out;
 }
 
-void os_closedir(os_dir_t dir)
+void os_closedir(os_dir_t *dir)
 {
 	if (dir) {
 		FindClose(dir->handle);
@@ -314,13 +314,13 @@ static void make_globent(struct os_globent *ent, WIN32_FIND_DATA *wfd,
 	dstr_free(&name);
 }
 
-int os_glob(const char *pattern, int flags, os_glob_t *pglob)
+int os_glob(const char *pattern, int flags, os_glob_t **pglob)
 {
 	DARRAY(struct os_globent) files;
 	HANDLE                    handle;
 	WIN32_FIND_DATA           wfd;
 	int                       ret = -1;
-	os_glob_t                 out = NULL;
+	os_glob_t                 *out = NULL;
 	wchar_t                   *w_path;
 
 	da_init(files);
@@ -353,7 +353,7 @@ int os_glob(const char *pattern, int flags, os_glob_t *pglob)
 	return ret;
 }
 
-void os_globfree(os_glob_t pglob)
+void os_globfree(os_glob_t *pglob)
 {
 	if (pglob) {
 		for (size_t i = 0; i < pglob->gl_pathc; i++)
@@ -433,13 +433,13 @@ BOOL WINAPI DllMain(HINSTANCE hinst_dll, DWORD reason, LPVOID reserved)
 	return true;
 }
 
-os_performance_token_t os_request_high_performance(const char *reason)
+os_performance_token_t *os_request_high_performance(const char *reason)
 {
 	UNUSED_PARAMETER(reason);
 	return NULL;
 }
 
-void os_end_high_performance(os_performance_token_t token)
+void os_end_high_performance(os_performance_token_t *token)
 {
 	UNUSED_PARAMETER(token);
 }

libobs/util/platform.h

@@ -70,15 +70,15 @@ EXPORT void *os_dlsym(void *module, const char *func);
 EXPORT void os_dlclose(void *module);
 
 struct os_cpu_usage_info;
-typedef struct os_cpu_usage_info *os_cpu_usage_info_t;
+typedef struct os_cpu_usage_info os_cpu_usage_info_t;
 
-EXPORT os_cpu_usage_info_t os_cpu_usage_info_start(void);
-EXPORT double              os_cpu_usage_info_query(os_cpu_usage_info_t info);
-EXPORT void                os_cpu_usage_info_destroy(os_cpu_usage_info_t info);
+EXPORT os_cpu_usage_info_t *os_cpu_usage_info_start(void);
+EXPORT double              os_cpu_usage_info_query(os_cpu_usage_info_t *info);
+EXPORT void                os_cpu_usage_info_destroy(os_cpu_usage_info_t *info);
 
-typedef const void *os_performance_token_t;
-EXPORT os_performance_token_t os_request_high_performance(const char *reason);
-EXPORT void                   os_end_high_performance(os_performance_token_t);
+typedef const void os_performance_token_t;
+EXPORT os_performance_token_t *os_request_high_performance(const char *reason);
+EXPORT void                   os_end_high_performance(os_performance_token_t *);
 
 /**
  * Sleeps to a specific time (in nanoseconds).  Doesn't have to be super
@@ -95,16 +95,16 @@ EXPORT char *os_get_config_path(const char *name);
 EXPORT bool os_file_exists(const char *path);
 
 struct os_dir;
-typedef struct os_dir *os_dir_t;
+typedef struct os_dir os_dir_t;
 
 struct os_dirent {
 	char d_name[256];
 	bool directory;
 };
 
-EXPORT os_dir_t os_opendir(const char *path);
-EXPORT struct os_dirent *os_readdir(os_dir_t dir);
-EXPORT void os_closedir(os_dir_t dir);
+EXPORT os_dir_t *os_opendir(const char *path);
+EXPORT struct os_dirent *os_readdir(os_dir_t *dir);
+EXPORT void os_closedir(os_dir_t *dir);
 
 struct os_globent {
 	char *path;
@@ -116,12 +116,12 @@ struct os_glob_info {
 	struct os_globent *gl_pathv;
 };
 
-typedef struct os_glob_info *os_glob_t;
+typedef struct os_glob_info os_glob_t;
 
 /* currently no flags available */
 
-EXPORT int os_glob(const char *pattern, int flags, os_glob_t *pglob);
-EXPORT void os_globfree(os_glob_t pglob);
+EXPORT int os_glob(const char *pattern, int flags, os_glob_t **pglob);
+EXPORT void os_globfree(os_glob_t *pglob);
 
 EXPORT int os_unlink(const char *path);
 

libobs/util/text-lookup.c

@@ -358,7 +358,7 @@ static inline bool lookup_getstring(const char *lookup_val,
 
 /* ------------------------------------------------------------------------- */
 
-lookup_t text_lookup_create(const char *path)
+lookup_t *text_lookup_create(const char *path)
 {
 	struct text_lookup *lookup = bzalloc(sizeof(struct text_lookup));
 
@@ -370,7 +370,7 @@ lookup_t text_lookup_create(const char *path)
 	return lookup;
 }
 
-bool text_lookup_add(lookup_t lookup, const char *path)
+bool text_lookup_add(lookup_t *lookup, const char *path)
 {
 	struct dstr file_str;
 	char *temp = NULL;
@@ -397,7 +397,7 @@ bool text_lookup_add(lookup_t lookup, const char *path)
 	return true;
 }
 
-void text_lookup_destroy(lookup_t lookup)
+void text_lookup_destroy(lookup_t *lookup)
 {
 	if (lookup) {
 		dstr_free(&lookup->language);
@@ -407,7 +407,7 @@ void text_lookup_destroy(lookup_t lookup)
 	}
 }
 
-bool text_lookup_getstr(lookup_t lookup, const char *lookup_val,
+bool text_lookup_getstr(lookup_t *lookup, const char *lookup_val,
 		const char **out)
 {
 	if (lookup)

libobs/util/text-lookup.h

@@ -32,13 +32,13 @@ extern "C" {
 
 /* opaque typdef */
 struct text_lookup;
-typedef struct text_lookup *lookup_t;
+typedef struct text_lookup lookup_t;
 
 /* functions */
-EXPORT lookup_t text_lookup_create(const char *path);
-EXPORT bool text_lookup_add(lookup_t lookup, const char *path);
-EXPORT void text_lookup_destroy(lookup_t lookup);
-EXPORT bool text_lookup_getstr(lookup_t lookup, const char *lookup_val,
+EXPORT lookup_t *text_lookup_create(const char *path);
+EXPORT bool text_lookup_add(lookup_t *lookup, const char *path);
+EXPORT void text_lookup_destroy(lookup_t *lookup);
+EXPORT bool text_lookup_getstr(lookup_t *lookup, const char *lookup_val,
 		const char **out);
 
 #ifdef __cplusplus

libobs/util/threading-posix.c

@@ -33,7 +33,7 @@ struct os_event_data {
 	bool            manual;
 };
 
-int os_event_init(os_event_t *event, enum os_event_type type)
+int os_event_init(os_event_t **event, enum os_event_type type)
 {
 	int code = 0;
 
@@ -57,7 +57,7 @@ int os_event_init(os_event_t *event, enum os_event_type type)
 	return 0;
 }
 
-void os_event_destroy(os_event_t event)
+void os_event_destroy(os_event_t *event)
 {
 	if (event) {
 		pthread_mutex_destroy(&event->mutex);
@@ -66,7 +66,7 @@ void os_event_destroy(os_event_t event)
 	}
 }
 
-int os_event_wait(os_event_t event)
+int os_event_wait(os_event_t *event)
 {
 	int code = 0;
 	pthread_mutex_lock(&event->mutex);
@@ -93,7 +93,7 @@ static inline void add_ms_to_ts(struct timespec *ts,
 	}
 }
 
-int os_event_timedwait(os_event_t event, unsigned long milliseconds)
+int os_event_timedwait(os_event_t *event, unsigned long milliseconds)
 {
 	int code = 0;
 	pthread_mutex_lock(&event->mutex);
@@ -121,7 +121,7 @@ int os_event_timedwait(os_event_t event, unsigned long milliseconds)
 	return code;
 }
 
-int os_event_try(os_event_t event)
+int os_event_try(os_event_t *event)
 {
 	int ret = EAGAIN;
 
@@ -136,7 +136,7 @@ int os_event_try(os_event_t event)
 	return ret;
 }
 
-int os_event_signal(os_event_t event)
+int os_event_signal(os_event_t *event)
 {
 	int code = 0;
 
@@ -148,7 +148,7 @@ int os_event_signal(os_event_t event)
 	return code;
 }
 
-void os_event_reset(os_event_t event)
+void os_event_reset(os_event_t *event)
 {
 	pthread_mutex_lock(&event->mutex);
 	event->signalled = false;
@@ -162,7 +162,7 @@ struct os_sem_data {
 	task_t      task;
 };
 
-int  os_sem_init(os_sem_t *sem, int value)
+int  os_sem_init(os_sem_t **sem, int value)
 {
 	semaphore_t new_sem;
 	task_t      task = mach_task_self();
@@ -179,7 +179,7 @@ int  os_sem_init(os_sem_t *sem, int value)
 	return 0;
 }
 
-void os_sem_destroy(os_sem_t sem)
+void os_sem_destroy(os_sem_t *sem)
 {
 	if (sem) {
 		semaphore_destroy(sem->task, sem->sem);
@@ -187,13 +187,13 @@ void os_sem_destroy(os_sem_t sem)
 	}
 }
 
-int  os_sem_post(os_sem_t sem)
+int  os_sem_post(os_sem_t *sem)
 {
 	if (!sem) return -1;
 	return (semaphore_signal(sem->sem) == KERN_SUCCESS) ? 0 : -1;
 }
 
-int  os_sem_wait(os_sem_t sem)
+int  os_sem_wait(os_sem_t *sem)
 {
 	if (!sem) return -1;
 	return (semaphore_wait(sem->sem) == KERN_SUCCESS) ? 0 : -1;
@@ -205,7 +205,7 @@ struct os_sem_data {
 	sem_t sem;
 };
 
-int  os_sem_init(os_sem_t *sem, int value)
+int  os_sem_init(os_sem_t **sem, int value)
 {
 	sem_t new_sem;
 	int ret = sem_init(&new_sem, 0, value);
@@ -217,7 +217,7 @@ int  os_sem_init(os_sem_t *sem, int value)
 	return 0;
 }
 
-void os_sem_destroy(os_sem_t sem)
+void os_sem_destroy(os_sem_t *sem)
 {
 	if (sem) {
 		sem_destroy(&sem->sem);
@@ -225,13 +225,13 @@ void os_sem_destroy(os_sem_t sem)
 	}
 }
 
-int  os_sem_post(os_sem_t sem)
+int  os_sem_post(os_sem_t *sem)
 {
 	if (!sem) return -1;
 	return sem_post(&sem->sem);
 }
 
-int  os_sem_wait(os_sem_t sem)
+int  os_sem_wait(os_sem_t *sem)
 {
 	if (!sem) return -1;
 	return sem_wait(&sem->sem);

libobs/util/threading-windows.c

@@ -28,7 +28,7 @@ struct os_sem_data {
 	HANDLE handle;
 };
 
-int os_event_init(os_event_t *event, enum os_event_type type)
+int os_event_init(os_event_t **event, enum os_event_type type)
 {
 	HANDLE handle;
 	struct os_event_data *data;
@@ -44,7 +44,7 @@ int os_event_init(os_event_t *event, enum os_event_type type)
 	return 0;
 }
 
-void os_event_destroy(os_event_t event)
+void os_event_destroy(os_event_t *event)
 {
 	if (event) {
 		CloseHandle(event->handle);
@@ -52,7 +52,7 @@ void os_event_destroy(os_event_t event)
 	}
 }
 
-int os_event_wait(os_event_t event)
+int os_event_wait(os_event_t *event)
 {
 	DWORD code;
 
@@ -66,7 +66,7 @@ int os_event_wait(os_event_t event)
 	return 0;
 }
 
-int os_event_timedwait(os_event_t event, unsigned long milliseconds)
+int os_event_timedwait(os_event_t *event, unsigned long milliseconds)
 {
 	DWORD code;
 
@@ -82,7 +82,7 @@ int os_event_timedwait(os_event_t event, unsigned long milliseconds)
 	return 0;
 }
 
-int os_event_try(os_event_t event)
+int os_event_try(os_event_t *event)
 {
 	DWORD code;
 
@@ -98,7 +98,7 @@ int os_event_try(os_event_t event)
 	return 0;
 }
 
-int os_event_signal(os_event_t event)
+int os_event_signal(os_event_t *event)
 {
 	if (!event)
 		return EINVAL;
@@ -109,7 +109,7 @@ int os_event_signal(os_event_t event)
 	return 0;
 }
 
-void os_event_reset(os_event_t event)
+void os_event_reset(os_event_t *event)
 {
 	if (!event)
 		return;
@@ -117,7 +117,7 @@ void os_event_reset(os_event_t event)
 	ResetEvent(event->handle);
 }
 
-int  os_sem_init(os_sem_t *sem, int value)
+int  os_sem_init(os_sem_t **sem, int value)
 {
 	HANDLE handle = CreateSemaphore(NULL, (LONG)value, 0x7FFFFFFF, NULL);
 	if (!handle)
@@ -128,7 +128,7 @@ int  os_sem_init(os_sem_t *sem, int value)
 	return 0;
 }
 
-void os_sem_destroy(os_sem_t sem)
+void os_sem_destroy(os_sem_t *sem)
 {
 	if (sem) {
 		CloseHandle(sem->handle);
@@ -136,13 +136,13 @@ void os_sem_destroy(os_sem_t sem)
 	}
 }
 
-int  os_sem_post(os_sem_t sem)
+int  os_sem_post(os_sem_t *sem)
 {
 	if (!sem) return -1;
 	return ReleaseSemaphore(sem->handle, 1, NULL) ? 0 : -1;
 }
 
-int  os_sem_wait(os_sem_t sem)
+int  os_sem_wait(os_sem_t *sem)
 {
 	DWORD ret;
 

libobs/util/threading.h

@@ -54,21 +54,21 @@ enum os_event_type {
 
 struct os_event_data;
 struct os_sem_data;
-typedef struct os_event_data *os_event_t;
-typedef struct os_sem_data   *os_sem_t;
+typedef struct os_event_data os_event_t;
+typedef struct os_sem_data   os_sem_t;
 
-EXPORT int  os_event_init(os_event_t *event, enum os_event_type type);
-EXPORT void os_event_destroy(os_event_t event);
-EXPORT int  os_event_wait(os_event_t event);
-EXPORT int  os_event_timedwait(os_event_t event, unsigned long milliseconds);
-EXPORT int  os_event_try(os_event_t event);
-EXPORT int  os_event_signal(os_event_t event);
-EXPORT void os_event_reset(os_event_t event);
+EXPORT int  os_event_init(os_event_t **event, enum os_event_type type);
+EXPORT void os_event_destroy(os_event_t *event);
+EXPORT int  os_event_wait(os_event_t *event);
+EXPORT int  os_event_timedwait(os_event_t *event, unsigned long milliseconds);
+EXPORT int  os_event_try(os_event_t *event);
+EXPORT int  os_event_signal(os_event_t *event);
+EXPORT void os_event_reset(os_event_t *event);
 
-EXPORT int  os_sem_init(os_sem_t *sem, int value);
-EXPORT void os_sem_destroy(os_sem_t sem);
-EXPORT int  os_sem_post(os_sem_t sem);
-EXPORT int  os_sem_wait(os_sem_t sem);
+EXPORT int  os_sem_init(os_sem_t **sem, int value);
+EXPORT void os_sem_destroy(os_sem_t *sem);
+EXPORT int  os_sem_post(os_sem_t *sem);
+EXPORT int  os_sem_wait(os_sem_t *sem);
 
 EXPORT long os_atomic_inc_long(volatile long *val);
 EXPORT long os_atomic_dec_long(volatile long *val);

libobs/util/util.hpp

@@ -49,7 +49,7 @@ public:
 };
 
 class ConfigFile {
-	config_t config;
+	config_t *config;
 
 	ConfigFile(ConfigFile const&) = delete;
 	ConfigFile &operator=(ConfigFile const&) = delete;
@@ -89,32 +89,32 @@ public:
 		config = NULL;
 	}
 
-	inline operator config_t() const {return config;}
+	inline operator config_t*() const {return config;}
 };
 
 class TextLookup {
-	lookup_t lookup;
+	lookup_t *lookup;
 
 	TextLookup(TextLookup const&) = delete;
 
 	TextLookup &operator=(TextLookup const&) = delete;
 
 public:
-	inline TextLookup(lookup_t lookup=nullptr) : lookup(lookup) {}
+	inline TextLookup(lookup_t *lookup=nullptr) : lookup(lookup) {}
 	inline TextLookup(TextLookup &&other) : lookup(other.lookup)
 	{
 		other.lookup = nullptr;
 	}
 	inline ~TextLookup() {text_lookup_destroy(lookup);}
 
-	inline TextLookup& operator=(lookup_t val)
+	inline TextLookup& operator=(lookup_t *val)
 	{
 		text_lookup_destroy(lookup);
 		lookup = val;
 		return *this;
 	}
 
-	inline operator lookup_t() const {return lookup;}
+	inline operator lookup_t*() const {return lookup;}
 
 	inline const char *GetString(const char *lookupVal) const
 	{

obs/obs-app.cpp

@@ -415,7 +415,7 @@ static void delete_oldest_log(void)
 	unsigned int maxLogs = (unsigned int)config_get_uint(
 			App()->GlobalConfig(), "General", "MaxLogs");
 
-	os_dir_t dir = os_opendir(logDir);
+	os_dir_t *dir = os_opendir(logDir);
 	if (dir) {
 		unsigned int count = 0;
 
@@ -450,7 +450,7 @@ static void get_last_log(void)
 {
 	BPtr<char>       logDir(os_get_config_path("obs-studio/logs"));
 	struct os_dirent *entry;
-	os_dir_t         dir        = os_opendir(logDir);
+	os_dir_t         *dir        = os_opendir(logDir);
 	uint64_t         highest_ts = 0;
 
 	if (dir) {

obs/obs-app.hpp

@@ -71,14 +71,14 @@ public:
 
 	inline QMainWindow *GetMainWindow() const {return mainWindow.data();}
 
-	inline config_t GlobalConfig() const {return globalConfig;}
+	inline config_t *GlobalConfig() const {return globalConfig;}
 
 	inline const char *GetLocale() const
 	{
 		return locale.c_str();
 	}
 
-	inline lookup_t GetTextLookup() const {return textLookup;}
+	inline lookup_t *GetTextLookup() const {return textLookup;}
 
 	inline const char *GetString(const char *lookupVal) const
 	{
@@ -98,7 +98,7 @@ public:
 
 inline OBSApp *App() {return static_cast<OBSApp*>(qApp);}
 
-inline config_t GetGlobalConfig() {return App()->GlobalConfig();}
+inline config_t *GetGlobalConfig() {return App()->GlobalConfig();}
 
 std::vector<std::pair<std::string, std::string>> GetLocaleNames();
 inline const char *Str(const char *lookup) {return App()->GetString(lookup);}

obs/properties-view.cpp

@@ -58,7 +58,7 @@ void OBSPropertiesView::RefreshProperties()
 	layout->setSizeConstraint(QLayout::SetMaximumSize);
 	layout->setLabelAlignment(Qt::AlignRight);
 
-	obs_property_t property = obs_properties_first(properties);
+	obs_property_t *property = obs_properties_first(properties);
 
 	while (property) {
 		AddProperty(property, layout);
@@ -77,7 +77,7 @@ void OBSPropertiesView::RefreshProperties()
 }
 
 OBSPropertiesView::OBSPropertiesView(OBSData settings_,
-		obs_properties_t properties_, void *obj_,
+		obs_properties_t *properties_, void *obj_,
 		PropertiesUpdateCallback callback_, int minSize_)
 	: QScrollArea (nullptr),
 	  widget      (nullptr),
@@ -98,7 +98,7 @@ void OBSPropertiesView::resizeEvent(QResizeEvent *event)
 	UNUSED_PARAMETER(event);
 }
 
-QWidget *OBSPropertiesView::NewWidget(obs_property_t prop, QWidget *widget,
+QWidget *OBSPropertiesView::NewWidget(obs_property_t *prop, QWidget *widget,
 		const char *signal)
 {
 	WidgetInfo *info = new WidgetInfo(this, prop, widget);
@@ -107,7 +107,7 @@ QWidget *OBSPropertiesView::NewWidget(obs_property_t prop, QWidget *widget,
 	return widget;
 }
 
-QWidget *OBSPropertiesView::AddCheckbox(obs_property_t prop)
+QWidget *OBSPropertiesView::AddCheckbox(obs_property_t *prop)
 {
 	const char *name = obs_property_name(prop);
 	const char *desc = obs_property_description(prop);
@@ -118,7 +118,7 @@ QWidget *OBSPropertiesView::AddCheckbox(obs_property_t prop)
 	return NewWidget(prop, checkbox, SIGNAL(stateChanged(int)));
 }
 
-QWidget *OBSPropertiesView::AddText(obs_property_t prop)
+QWidget *OBSPropertiesView::AddText(obs_property_t *prop)
 {
 	const char    *name = obs_property_name(prop);
 	const char    *val  = obs_data_get_string(settings, name);
@@ -139,7 +139,7 @@ QWidget *OBSPropertiesView::AddText(obs_property_t prop)
 	return NewWidget(prop, edit, SIGNAL(textEdited(const QString &)));
 }
 
-void OBSPropertiesView::AddPath(obs_property_t prop, QFormLayout *layout,
+void OBSPropertiesView::AddPath(obs_property_t *prop, QFormLayout *layout,
 		QLabel **label)
 {
 	const char  *name      = obs_property_name(prop);
@@ -162,7 +162,7 @@ void OBSPropertiesView::AddPath(obs_property_t prop, QFormLayout *layout,
 	layout->addRow(*label, subLayout);
 }
 
-QWidget *OBSPropertiesView::AddInt(obs_property_t prop)
+QWidget *OBSPropertiesView::AddInt(obs_property_t *prop)
 {
 	const char *name = obs_property_name(prop);
 	int        val   = (int)obs_data_get_int(settings, name);
@@ -176,7 +176,7 @@ QWidget *OBSPropertiesView::AddInt(obs_property_t prop)
 	return NewWidget(prop, spin, SIGNAL(valueChanged(int)));
 }
 
-QWidget *OBSPropertiesView::AddFloat(obs_property_t prop)
+QWidget *OBSPropertiesView::AddFloat(obs_property_t *prop)
 {
 	const char     *name = obs_property_name(prop);
 	double         val   = obs_data_get_double(settings, name);
@@ -190,7 +190,7 @@ QWidget *OBSPropertiesView::AddFloat(obs_property_t prop)
 	return NewWidget(prop, spin, SIGNAL(valueChanged(double)));
 }
 
-static void AddComboItem(QComboBox *combo, obs_property_t prop,
+static void AddComboItem(QComboBox *combo, obs_property_t *prop,
 		obs_combo_format format, size_t idx)
 {
 	const char *name = obs_property_list_item_name(prop, idx);
@@ -226,10 +226,10 @@ static void AddComboItem(QComboBox *combo, obs_property_t prop,
 	item->setFlags(Qt::NoItemFlags);
 }
 
-template <long long get_int(obs_data_t, const char*),
-	 double get_double(obs_data_t, const char*),
-	 const char *get_string(obs_data_t, const char*)>
-static string from_obs_data(obs_data_t data, const char *name,
+template <long long get_int(obs_data_t*, const char*),
+	 double get_double(obs_data_t*, const char*),
+	 const char *get_string(obs_data_t*, const char*)>
+static string from_obs_data(obs_data_t *data, const char *name,
 		obs_combo_format format)
 {
 	switch (format) {
@@ -244,14 +244,14 @@ static string from_obs_data(obs_data_t data, const char *name,
 	}
 }
 
-static string from_obs_data(obs_data_t data, const char *name,
+static string from_obs_data(obs_data_t *data, const char *name,
 		obs_combo_format format)
 {
 	return from_obs_data<obs_data_get_int, obs_data_get_double,
 	       obs_data_get_string>(data, name, format);
 }
 
-static string from_obs_data_autoselect(obs_data_t data, const char *name,
+static string from_obs_data_autoselect(obs_data_t *data, const char *name,
 		obs_combo_format format)
 {
 	return from_obs_data<obs_data_get_autoselect_int,
@@ -259,7 +259,7 @@ static string from_obs_data_autoselect(obs_data_t data, const char *name,
 	       obs_data_get_autoselect_string>(data, name, format);
 }
 
-QWidget *OBSPropertiesView::AddList(obs_property_t prop, bool &warning)
+QWidget *OBSPropertiesView::AddList(obs_property_t *prop, bool &warning)
 {
 	const char       *name  = obs_property_name(prop);
 	QComboBox        *combo = new QComboBox();
@@ -321,7 +321,7 @@ QWidget *OBSPropertiesView::AddList(obs_property_t prop, bool &warning)
 	return combo;
 }
 
-QWidget *OBSPropertiesView::AddButton(obs_property_t prop)
+QWidget *OBSPropertiesView::AddButton(obs_property_t *prop)
 {
 	const char *desc = obs_property_description(prop);
 
@@ -330,7 +330,7 @@ QWidget *OBSPropertiesView::AddButton(obs_property_t prop)
 	return NewWidget(prop, button, SIGNAL(clicked()));
 }
 
-void OBSPropertiesView::AddColor(obs_property_t prop, QFormLayout *layout,
+void OBSPropertiesView::AddColor(obs_property_t *prop, QFormLayout *layout,
 		QLabel *&label)
 {
 	QPushButton *button     = new QPushButton;
@@ -361,7 +361,7 @@ void OBSPropertiesView::AddColor(obs_property_t prop, QFormLayout *layout,
 	layout->addRow(label, subLayout);
 }
 
-static void MakeQFont(obs_data_t font_obj, QFont &font)
+static void MakeQFont(obs_data_t *font_obj, QFont &font)
 {
 	const char *face  = obs_data_get_string(font_obj, "face");
 	const char *style = obs_data_get_string(font_obj, "style");
@@ -382,11 +382,11 @@ static void MakeQFont(obs_data_t font_obj, QFont &font)
 	if (flags & OBS_FONT_STRIKEOUT) font.setStrikeOut(true);
 }
 
-void OBSPropertiesView::AddFont(obs_property_t prop, QFormLayout *layout,
+void OBSPropertiesView::AddFont(obs_property_t *prop, QFormLayout *layout,
 		QLabel *&label)
 {
 	const char  *name      = obs_property_name(prop);
-	obs_data_t  font_obj   = obs_data_get_obj(settings, name);
+	obs_data_t  *font_obj   = obs_data_get_obj(settings, name);
 	const char  *face      = obs_data_get_string(font_obj, "face");
 	const char  *style     = obs_data_get_string(font_obj, "style");
 	QPushButton *button    = new QPushButton;
@@ -419,7 +419,7 @@ void OBSPropertiesView::AddFont(obs_property_t prop, QFormLayout *layout,
 	obs_data_release(font_obj);
 }
 
-void OBSPropertiesView::AddProperty(obs_property_t property,
+void OBSPropertiesView::AddProperty(obs_property_t *property,
 		QFormLayout *layout)
 {
 	const char        *name = obs_property_name(property);
@@ -619,7 +619,7 @@ bool WidgetInfo::ColorChanged(const char *setting)
 
 bool WidgetInfo::FontChanged(const char *setting)
 {
-	obs_data_t font_obj = obs_data_get_obj(view->settings, setting);
+	obs_data_t *font_obj = obs_data_get_obj(view->settings, setting);
 	bool       success;
 	uint32_t   flags;
 	QFont      font;

obs/properties-view.hpp

@@ -9,7 +9,7 @@ class QFormLayout;
 class OBSPropertiesView;
 class QLabel;
 
-typedef void (*PropertiesUpdateCallback)(void *obj, obs_data_t settings);
+typedef void (*PropertiesUpdateCallback)(void *obj, obs_data_t *settings);
 
 /* ------------------------------------------------------------------------- */
 
@@ -18,7 +18,7 @@ class WidgetInfo : public QObject {
 
 private:
 	OBSPropertiesView *view;
-	obs_property_t    property;
+	obs_property_t    *property;
 	QWidget           *widget;
 
 	void BoolChanged(const char *setting);
@@ -32,7 +32,7 @@ private:
 	void ButtonClicked();
 
 public:
-	inline WidgetInfo(OBSPropertiesView *view_, obs_property_t prop,
+	inline WidgetInfo(OBSPropertiesView *view_, obs_property_t *prop,
 			QWidget *widget_)
 		: view(view_), property(prop), widget(widget_)
 	{}
@@ -50,7 +50,7 @@ class OBSPropertiesView : public QScrollArea {
 
 private:
 	QWidget                                  *widget;
-	obs_properties_t                         properties;
+	obs_properties_t                         *properties;
 	OBSData                                  settings;
 	void                                     *obj;
 	PropertiesUpdateCallback                 callback;
@@ -59,20 +59,20 @@ private:
 	std::string                              lastFocused;
 	QWidget                                  *lastWidget;
 
-	QWidget *NewWidget(obs_property_t prop, QWidget *widget,
+	QWidget *NewWidget(obs_property_t *prop, QWidget *widget,
 			const char *signal);
 
-	QWidget *AddCheckbox(obs_property_t prop);
-	QWidget *AddText(obs_property_t prop);
-	void AddPath(obs_property_t prop, QFormLayout *layout, QLabel **label);
-	QWidget *AddInt(obs_property_t prop);
-	QWidget *AddFloat(obs_property_t prop);
-	QWidget *AddList(obs_property_t prop, bool &warning);
-	QWidget *AddButton(obs_property_t prop);
-	void AddColor(obs_property_t prop, QFormLayout *layout, QLabel *&label);
-	void AddFont(obs_property_t prop, QFormLayout *layout, QLabel *&label);
+	QWidget *AddCheckbox(obs_property_t *prop);
+	QWidget *AddText(obs_property_t *prop);
+	void AddPath(obs_property_t *prop, QFormLayout *layout, QLabel **label);
+	QWidget *AddInt(obs_property_t *prop);
+	QWidget *AddFloat(obs_property_t *prop);
+	QWidget *AddList(obs_property_t *prop, bool &warning);
+	QWidget *AddButton(obs_property_t *prop);
+	void AddColor(obs_property_t *prop, QFormLayout *layout, QLabel *&label);
+	void AddFont(obs_property_t *prop, QFormLayout *layout, QLabel *&label);
 
-	void AddProperty(obs_property_t property, QFormLayout *layout);
+	void AddProperty(obs_property_t *property, QFormLayout *layout);
 
 	void resizeEvent(QResizeEvent *event) override;
 
@@ -84,7 +84,7 @@ signals:
 
 public:
 	OBSPropertiesView(OBSData settings,
-			obs_properties_t properties,
+			obs_properties_t *properties,
 			void *obj, PropertiesUpdateCallback callback,
 			int minSize = 0);
 

obs/volume-control.cpp

@@ -37,7 +37,7 @@ static inline float DBToLinear(float db_full)
 	return (DBToLog(db) - VOL_MIN_LOG) / (VOL_MAX_LOG - VOL_MIN_LOG);
 }
 
-void VolControl::OBSVolumeChanged(void *data, calldata_t calldata)
+void VolControl::OBSVolumeChanged(void *data, calldata_t *calldata)
 {
 	VolControl *volControl = static_cast<VolControl*>(data);
 	int vol = (int)(calldata_float(calldata, "volume") * 100.0f + 0.5f);
@@ -45,7 +45,7 @@ void VolControl::OBSVolumeChanged(void *data, calldata_t calldata)
 	QMetaObject::invokeMethod(volControl, "VolumeChanged", Q_ARG(int, vol));
 }
 
-void VolControl::OBSVolumeLevel(void *data, calldata_t calldata)
+void VolControl::OBSVolumeLevel(void *data, calldata_t *calldata)
 {
 	VolControl *volControl = static_cast<VolControl*>(data);
 	float peak      = calldata_float(calldata, "level");

obs/volume-control.hpp

@@ -37,8 +37,8 @@ private:
 	float           levelTotal;
 	float           levelCount;
 
-	static void OBSVolumeChanged(void *param, calldata_t calldata);
-	static void OBSVolumeLevel(void *data, calldata_t calldata);
+	static void OBSVolumeChanged(void *param, calldata_t *calldata);
+	static void OBSVolumeLevel(void *data, calldata_t *calldata);
 
 private slots:
 	void VolumeChanged(int vol);
@@ -49,7 +49,7 @@ public:
 	VolControl(OBSSource source);
 	~VolControl();
 
-	inline obs_source_t GetSource() const {return source;}
+	inline obs_source_t *GetSource() const {return source;}
 
 	QString GetName() const;
 	void SetName(const QString &newName);

obs/window-basic-interaction.cpp

@@ -107,7 +107,7 @@ OBSEventFilter *OBSBasicInteraction::BuildEventFilter()
 	});
 }
 
-void OBSBasicInteraction::SourceRemoved(void *data, calldata_t params)
+void OBSBasicInteraction::SourceRemoved(void *data, calldata_t *params)
 {
 	QMetaObject::invokeMethod(static_cast<OBSBasicInteraction*>(data),
 			"close");

obs/window-basic-interaction.hpp

@@ -44,7 +44,7 @@ private:
 	OBSSignal  removedSignal;
 	std::unique_ptr<OBSEventFilter> eventFilter;
 
-	static void SourceRemoved(void *data, calldata_t params);
+	static void SourceRemoved(void *data, calldata_t *params);
 	static void DrawPreview(void *data, uint32_t cx, uint32_t cy);
 
 	bool GetSourceRelativeXY(int mouseX, int mouseY, int &x, int &y);

obs/window-basic-main.cpp

@@ -120,13 +120,13 @@ OBSBasic::OBSBasic(QWidget *parent)
 #endif
 }
 
-static void SaveAudioDevice(const char *name, int channel, obs_data_t parent)
+static void SaveAudioDevice(const char *name, int channel, obs_data_t *parent)
 {
-	obs_source_t source = obs_get_output_source(channel);
+	obs_source_t *source = obs_get_output_source(channel);
 	if (!source)
 		return;
 
-	obs_data_t data = obs_save_source(source);
+	obs_data_t *data = obs_save_source(source);
 
 	obs_data_set_obj(parent, name, data);
 
@@ -134,11 +134,11 @@ static void SaveAudioDevice(const char *name, int channel, obs_data_t parent)
 	obs_source_release(source);
 }
 
-static obs_data_t GenerateSaveData()
+static obs_data_t *GenerateSaveData()
 {
-	obs_data_t       saveData     = obs_data_create();
-	obs_data_array_t sourcesArray = obs_save_sources();
-	obs_source_t     currentScene = obs_get_output_source(0);
+	obs_data_t       *saveData     = obs_data_create();
+	obs_data_array_t *sourcesArray = obs_save_sources();
+	obs_source_t     *currentScene = obs_get_output_source(0);
 	const char       *sceneName   = obs_source_get_name(currentScene);
 
 	SaveAudioDevice(DESKTOP_AUDIO_1, 1, saveData);
@@ -169,7 +169,7 @@ void OBSBasic::ClearVolumeControls()
 
 void OBSBasic::Save(const char *file)
 {
-	obs_data_t saveData  = GenerateSaveData();
+	obs_data_t *saveData  = GenerateSaveData();
 	const char *jsonData = obs_data_get_json(saveData);
 
 	/* TODO maybe a message box here? */
@@ -179,13 +179,13 @@ void OBSBasic::Save(const char *file)
 	obs_data_release(saveData);
 }
 
-static void LoadAudioDevice(const char *name, int channel, obs_data_t parent)
+static void LoadAudioDevice(const char *name, int channel, obs_data_t *parent)
 {
-	obs_data_t data = obs_data_get_obj(parent, name);
+	obs_data_t *data = obs_data_get_obj(parent, name);
 	if (!data)
 		return;
 
-	obs_source_t source = obs_load_source(data);
+	obs_source_t *source = obs_load_source(data);
 	if (source) {
 		obs_set_output_source(channel, source);
 		obs_source_release(source);
@@ -196,8 +196,8 @@ static void LoadAudioDevice(const char *name, int channel, obs_data_t parent)
 
 void OBSBasic::CreateDefaultScene()
 {
-	obs_scene_t  scene  = obs_scene_create(Str("Basic.Scene"));
-	obs_source_t source = obs_scene_get_source(scene);
+	obs_scene_t  *scene  = obs_scene_create(Str("Basic.Scene"));
+	obs_source_t *source = obs_scene_get_source(scene);
 
 	obs_add_source(source);
 
@@ -229,11 +229,11 @@ void OBSBasic::Load(const char *file)
 		return;
 	}
 
-	obs_data_t       data       = obs_data_create_from_json(jsonData);
-	obs_data_array_t sources    = obs_data_get_array(data, "sources");
+	obs_data_t       *data       = obs_data_create_from_json(jsonData);
+	obs_data_array_t *sources    = obs_data_get_array(data, "sources");
 	const char       *sceneName = obs_data_get_string(data,
 			"current_scene");
-	obs_source_t     curScene;
+	obs_source_t     *curScene;
 
 	LoadAudioDevice(DESKTOP_AUDIO_1, 1, data);
 	LoadAudioDevice(DESKTOP_AUDIO_2, 2, data);
@@ -254,14 +254,14 @@ void OBSBasic::Load(const char *file)
 static inline bool HasAudioDevices(const char *source_id)
 {
 	const char *output_id = source_id;
-	obs_properties_t props = obs_get_source_properties(
+	obs_properties_t *props = obs_get_source_properties(
 			OBS_SOURCE_TYPE_INPUT, output_id);
 	size_t count = 0;
 
 	if (!props)
 		return false;
 
-	obs_property_t devices = obs_properties_get(props, "device_id");
+	obs_property_t *devices = obs_properties_get(props, "device_id");
 	if (devices)
 		count = obs_property_list_item_count(devices);
 
@@ -270,21 +270,21 @@ static inline bool HasAudioDevices(const char *source_id)
 	return count != 0;
 }
 
-static void OBSStartStreaming(void *data, calldata_t params)
+static void OBSStartStreaming(void *data, calldata_t *params)
 {
 	UNUSED_PARAMETER(params);
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"StreamingStart");
 }
 
-static void OBSStopStreaming(void *data, calldata_t params)
+static void OBSStopStreaming(void *data, calldata_t *params)
 {
 	int code = (int)calldata_int(params, "code");
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"StreamingStop", Q_ARG(int, code));
 }
 
-static void OBSStartRecording(void *data, calldata_t params)
+static void OBSStartRecording(void *data, calldata_t *params)
 {
 	UNUSED_PARAMETER(params);
 
@@ -292,7 +292,7 @@ static void OBSStartRecording(void *data, calldata_t params)
 			"RecordingStart");
 }
 
-static void OBSStopRecording(void *data, calldata_t params)
+static void OBSStopRecording(void *data, calldata_t *params)
 {
 	UNUSED_PARAMETER(params);
 
@@ -311,8 +311,8 @@ void OBSBasic::SaveService()
 	if (!serviceJsonPath)
 		return;
 
-	obs_data_t data     = obs_data_create();
-	obs_data_t settings = obs_service_get_settings(service);
+	obs_data_t *data     = obs_data_create();
+	obs_data_t *settings = obs_service_get_settings(service);
 
 	obs_data_set_string(data, "type", obs_service_gettype(service));
 	obs_data_set_obj(data, "settings", settings);
@@ -337,12 +337,12 @@ bool OBSBasic::LoadService()
 	if (!jsonText)
 		return false;
 
-	obs_data_t data = obs_data_create_from_json(jsonText);
+	obs_data_t *data = obs_data_create_from_json(jsonText);
 
 	obs_data_set_default_string(data, "type", "rtmp_common");
 	type = obs_data_get_string(data, "type");
 
-	obs_data_t settings = obs_data_get_obj(data, "settings");
+	obs_data_t *settings = obs_data_get_obj(data, "settings");
 
 	service = obs_service_create(type, "default_service", settings);
 
@@ -643,7 +643,7 @@ void OBSBasic::UpdateSources(OBSScene scene)
 	ui->sources->clear();
 
 	obs_scene_enum_items(scene,
-			[] (obs_scene_t scene, obs_sceneitem_t item, void *p)
+			[] (obs_scene_t *scene, obs_sceneitem_t *item, void *p)
 			{
 				OBSBasic *window = static_cast<OBSBasic*>(p);
 				window->InsertSceneItem(item);
@@ -653,9 +653,9 @@ void OBSBasic::UpdateSources(OBSScene scene)
 			}, this);
 }
 
-void OBSBasic::InsertSceneItem(obs_sceneitem_t item)
+void OBSBasic::InsertSceneItem(obs_sceneitem_t *item)
 {
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 	const char   *name  = obs_source_get_name(source);
 
 	QListWidgetItem *listItem = new QListWidgetItem(QT_UTF8(name));
@@ -671,7 +671,7 @@ void OBSBasic::InsertSceneItem(obs_sceneitem_t item)
 		CreatePropertiesWindow(source);
 }
 
-void OBSBasic::CreateInteractionWindow(obs_source_t source)
+void OBSBasic::CreateInteractionWindow(obs_source_t *source)
 {
 	if (interaction)
 		interaction->close();
@@ -681,7 +681,7 @@ void OBSBasic::CreateInteractionWindow(obs_source_t source)
 	interaction->setAttribute(Qt::WA_DeleteOnClose, true);
 }
 
-void OBSBasic::CreatePropertiesWindow(obs_source_t source)
+void OBSBasic::CreatePropertiesWindow(obs_source_t *source)
 {
 	if (properties)
 		properties->close();
@@ -696,14 +696,14 @@ void OBSBasic::CreatePropertiesWindow(obs_source_t source)
 void OBSBasic::AddScene(OBSSource source)
 {
 	const char *name  = obs_source_get_name(source);
-	obs_scene_t scene = obs_scene_from_source(source);
+	obs_scene_t *scene = obs_scene_from_source(source);
 
 	QListWidgetItem *item = new QListWidgetItem(QT_UTF8(name));
 	item->setFlags(item->flags() | Qt::ItemIsEditable);
 	item->setData(Qt::UserRole, QVariant::fromValue(OBSScene(scene)));
 	ui->scenes->addItem(item);
 
-	signal_handler_t handler = obs_source_get_signal_handler(source);
+	signal_handler_t *handler = obs_source_get_signal_handler(source);
 	signal_handler_connect(handler, "item_add",
 			OBSBasic::SceneItemAdded, this);
 	signal_handler_connect(handler, "item_remove",
@@ -735,8 +735,8 @@ void OBSBasic::RemoveScene(OBSSource source)
 
 void OBSBasic::AddSceneItem(OBSSceneItem item)
 {
-	obs_scene_t  scene  = obs_sceneitem_get_scene(item);
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_scene_t  *scene  = obs_sceneitem_get_scene(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 
 	if (GetCurrentScene() == scene)
 		InsertSceneItem(item);
@@ -746,7 +746,7 @@ void OBSBasic::AddSceneItem(OBSSceneItem item)
 
 void OBSBasic::RemoveSceneItem(OBSSceneItem item)
 {
-	obs_scene_t scene = obs_sceneitem_get_scene(item);
+	obs_scene_t *scene = obs_sceneitem_get_scene(item);
 
 	if (GetCurrentScene() == scene) {
 		for (int i = 0; i < ui->sources->count(); i++) {
@@ -760,7 +760,7 @@ void OBSBasic::RemoveSceneItem(OBSSceneItem item)
 		}
 	}
 
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 
 	int scenes = sourceSceneRefs[source] - 1;
 	sourceSceneRefs[source] = scenes;
@@ -774,7 +774,7 @@ void OBSBasic::RemoveSceneItem(OBSSceneItem item)
 void OBSBasic::UpdateSceneSelection(OBSSource source)
 {
 	if (source) {
-		obs_scene_t scene = obs_scene_from_source(source);
+		obs_scene_t *scene = obs_scene_from_source(source);
 		const char *name = obs_source_get_name(source);
 
 		if (!scene)
@@ -869,7 +869,7 @@ void OBSBasic::DeactivateAudioSource(OBSSource source)
 	}
 }
 
-bool OBSBasic::QueryRemoveSource(obs_source_t source)
+bool OBSBasic::QueryRemoveSource(obs_source_t *source)
 {
 	const char *name  = obs_source_get_name(source);
 
@@ -955,8 +955,8 @@ void OBSBasic::updateFileFinished()
 	if (!jsonReply || !*jsonReply)
 		return;
 
-	obs_data_t returnData   = obs_data_create_from_json(jsonReply);
-	obs_data_t versionData  = obs_data_get_obj(returnData, VERSION_ENTRY);
+	obs_data_t *returnData   = obs_data_create_from_json(jsonReply);
+	obs_data_t *versionData  = obs_data_get_obj(returnData, VERSION_ENTRY);
 	const char *description = obs_data_get_string(returnData,
 			"description");
 	const char *download    = obs_data_get_string(versionData, "download");
@@ -1004,7 +1004,7 @@ void OBSBasic::RemoveSelectedScene()
 {
 	OBSScene scene = GetCurrentScene();
 	if (scene) {
-		obs_source_t source = obs_scene_get_source(scene);
+		obs_source_t *source = obs_scene_get_source(scene);
 		if (QueryRemoveSource(source))
 			obs_source_remove(source);
 	}
@@ -1014,7 +1014,7 @@ void OBSBasic::RemoveSelectedSceneItem()
 {
 	OBSSceneItem item = GetCurrentSceneItem();
 	if (item) {
-		obs_source_t source = obs_sceneitem_get_source(item);
+		obs_source_t *source = obs_sceneitem_get_source(item);
 		if (QueryRemoveSource(source))
 			obs_sceneitem_remove(item);
 	}
@@ -1022,30 +1022,30 @@ void OBSBasic::RemoveSelectedSceneItem()
 
 /* OBS Callbacks */
 
-void OBSBasic::SceneItemAdded(void *data, calldata_t params)
+void OBSBasic::SceneItemAdded(void *data, calldata_t *params)
 {
 	OBSBasic *window = static_cast<OBSBasic*>(data);
 
-	obs_sceneitem_t item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	obs_sceneitem_t *item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 
 	QMetaObject::invokeMethod(window, "AddSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)));
 }
 
-void OBSBasic::SceneItemRemoved(void *data, calldata_t params)
+void OBSBasic::SceneItemRemoved(void *data, calldata_t *params)
 {
 	OBSBasic *window = static_cast<OBSBasic*>(data);
 
-	obs_sceneitem_t item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	obs_sceneitem_t *item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 
 	QMetaObject::invokeMethod(window, "RemoveSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)));
 }
 
-void OBSBasic::SourceAdded(void *data, calldata_t params)
+void OBSBasic::SourceAdded(void *data, calldata_t *params)
 {
 	OBSBasic *window = static_cast<OBSBasic*>(data);
-	obs_source_t source = (obs_source_t)calldata_ptr(params, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(params, "source");
 
 	if (obs_scene_from_source(source) != NULL)
 		QMetaObject::invokeMethod(window,
@@ -1053,9 +1053,9 @@ void OBSBasic::SourceAdded(void *data, calldata_t params)
 				Q_ARG(OBSSource, OBSSource(source)));
 }
 
-void OBSBasic::SourceRemoved(void *data, calldata_t params)
+void OBSBasic::SourceRemoved(void *data, calldata_t *params)
 {
-	obs_source_t source = (obs_source_t)calldata_ptr(params, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(params, "source");
 
 	if (obs_scene_from_source(source) != NULL)
 		QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
@@ -1063,9 +1063,9 @@ void OBSBasic::SourceRemoved(void *data, calldata_t params)
 				Q_ARG(OBSSource, OBSSource(source)));
 }
 
-void OBSBasic::SourceActivated(void *data, calldata_t params)
+void OBSBasic::SourceActivated(void *data, calldata_t *params)
 {
-	obs_source_t source = (obs_source_t)calldata_ptr(params, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(params, "source");
 	uint32_t     flags  = obs_source_get_output_flags(source);
 
 	if (flags & OBS_SOURCE_AUDIO)
@@ -1074,9 +1074,9 @@ void OBSBasic::SourceActivated(void *data, calldata_t params)
 				Q_ARG(OBSSource, OBSSource(source)));
 }
 
-void OBSBasic::SourceDeactivated(void *data, calldata_t params)
+void OBSBasic::SourceDeactivated(void *data, calldata_t *params)
 {
-	obs_source_t source = (obs_source_t)calldata_ptr(params, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(params, "source");
 	uint32_t     flags  = obs_source_get_output_flags(source);
 
 	if (flags & OBS_SOURCE_AUDIO)
@@ -1085,7 +1085,7 @@ void OBSBasic::SourceDeactivated(void *data, calldata_t params)
 				Q_ARG(OBSSource, OBSSource(source)));
 }
 
-void OBSBasic::SourceRenamed(void *data, calldata_t params)
+void OBSBasic::SourceRenamed(void *data, calldata_t *params)
 {
 	const char *newName  = calldata_string(params, "new_name");
 	const char *prevName = calldata_string(params, "prev_name");
@@ -1096,9 +1096,9 @@ void OBSBasic::SourceRenamed(void *data, calldata_t params)
 			Q_ARG(QString, QT_UTF8(prevName)));
 }
 
-void OBSBasic::ChannelChanged(void *data, calldata_t params)
+void OBSBasic::ChannelChanged(void *data, calldata_t *params)
 {
-	obs_source_t source = (obs_source_t)calldata_ptr(params, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(params, "source");
 	uint32_t channel = (uint32_t)calldata_int(params, "channel");
 
 	if (channel == 0)
@@ -1112,9 +1112,9 @@ void OBSBasic::DrawBackdrop(float cx, float cy)
 	if (!box)
 		return;
 
-	gs_effect_t    solid = obs_get_solid_effect();
-	gs_eparam_t    color = gs_effect_get_param_by_name(solid, "color");
-	gs_technique_t tech  = gs_effect_get_technique(solid, "Solid");
+	gs_effect_t    *solid = obs_get_solid_effect();
+	gs_eparam_t    *color = gs_effect_get_param_by_name(solid, "color");
+	gs_technique_t *tech  = gs_effect_get_technique(solid, "Solid");
 
 	vec4 colorVal;
 	vec4_set(&colorVal, 0.0f, 0.0f, 0.0f, 1.0f);
@@ -1183,36 +1183,36 @@ void OBSBasic::RenderMain(void *data, uint32_t cx, uint32_t cy)
 	UNUSED_PARAMETER(cy);
 }
 
-void OBSBasic::SceneItemMoveUp(void *data, calldata_t params)
+void OBSBasic::SceneItemMoveUp(void *data, calldata_t *params)
 {
-	OBSSceneItem item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	OBSSceneItem item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"MoveSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)),
 			Q_ARG(obs_order_movement, OBS_ORDER_MOVE_UP));
 }
 
-void OBSBasic::SceneItemMoveDown(void *data, calldata_t params)
+void OBSBasic::SceneItemMoveDown(void *data, calldata_t *params)
 {
-	OBSSceneItem item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	OBSSceneItem item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"MoveSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)),
 			Q_ARG(obs_order_movement, OBS_ORDER_MOVE_DOWN));
 }
 
-void OBSBasic::SceneItemMoveTop(void *data, calldata_t params)
+void OBSBasic::SceneItemMoveTop(void *data, calldata_t *params)
 {
-	OBSSceneItem item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	OBSSceneItem item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"MoveSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)),
 			Q_ARG(obs_order_movement, OBS_ORDER_MOVE_TOP));
 }
 
-void OBSBasic::SceneItemMoveBottom(void *data, calldata_t params)
+void OBSBasic::SceneItemMoveBottom(void *data, calldata_t *params)
 {
-	OBSSceneItem item = (obs_sceneitem_t)calldata_ptr(params, "item");
+	OBSSceneItem item = (obs_sceneitem_t*)calldata_ptr(params, "item");
 	QMetaObject::invokeMethod(static_cast<OBSBasic*>(data),
 			"MoveSceneItem",
 			Q_ARG(OBSSceneItem, OBSSceneItem(item)),
@@ -1221,14 +1221,14 @@ void OBSBasic::SceneItemMoveBottom(void *data, calldata_t params)
 
 /* Main class functions */
 
-obs_service_t OBSBasic::GetService()
+obs_service_t *OBSBasic::GetService()
 {
 	if (!service)
 		service = obs_service_create("rtmp_common", NULL, NULL);
 	return service;
 }
 
-void OBSBasic::SetService(obs_service_t newService)
+void OBSBasic::SetService(obs_service_t *newService)
 {
 	if (newService) {
 		if (service)
@@ -1335,8 +1335,8 @@ void OBSBasic::ResetAudioDevice(const char *sourceId, const char *deviceName,
 {
 	const char *deviceId = config_get_string(basicConfig, "Audio",
 			deviceName);
-	obs_source_t source;
-	obs_data_t settings;
+	obs_source_t *source;
+	obs_data_t *settings;
 	bool same = false;
 
 	source = obs_get_output_source(channel);
@@ -1354,7 +1354,7 @@ void OBSBasic::ResetAudioDevice(const char *sourceId, const char *deviceName,
 		obs_set_output_source(channel, nullptr);
 
 	if (!same && strcmp(deviceId, "disabled") != 0) {
-		obs_data_t settings = obs_data_create();
+		obs_data_t *settings = obs_data_create();
 		obs_data_set_string(settings, "device_id", deviceId);
 		source = obs_source_create(OBS_SOURCE_TYPE_INPUT,
 				sourceId, deviceDesc, settings);
@@ -1469,13 +1469,13 @@ void OBSBasic::on_action_Settings_triggered()
 void OBSBasic::on_scenes_currentItemChanged(QListWidgetItem *current,
 		QListWidgetItem *prev)
 {
-	obs_source_t source = NULL;
+	obs_source_t *source = NULL;
 
 	if (sceneChanging)
 		return;
 
 	if (current) {
-		obs_scene_t scene;
+		obs_scene_t *scene;
 
 		scene = current->data(Qt::UserRole).value<OBSScene>();
 		source = obs_scene_get_source(scene);
@@ -1514,7 +1514,7 @@ void OBSBasic::on_actionAddScene_triggered()
 
 	int i = 1;
 	QString placeHolderText = format.arg(i);
-	obs_source_t source = nullptr;
+	obs_source_t *source = nullptr;
 	while ((source = obs_get_source_by_name(QT_TO_UTF8(placeHolderText)))) {
 		obs_source_release(source);
 		placeHolderText = format.arg(++i);
@@ -1535,7 +1535,7 @@ void OBSBasic::on_actionAddScene_triggered()
 			return;
 		}
 
-		obs_source_t source = obs_get_source_by_name(name.c_str());
+		obs_source_t *source = obs_get_source_by_name(name.c_str());
 		if (source) {
 			QMessageBox::information(this,
 					QTStr("NameExists.Title"),
@@ -1546,7 +1546,7 @@ void OBSBasic::on_actionAddScene_triggered()
 			return;
 		}
 
-		obs_scene_t scene = obs_scene_create(name.c_str());
+		obs_scene_t *scene = obs_scene_create(name.c_str());
 		source = obs_scene_get_source(scene);
 		obs_add_source(source);
 		obs_scene_release(scene);
@@ -1558,7 +1558,7 @@ void OBSBasic::on_actionAddScene_triggered()
 void OBSBasic::on_actionRemoveScene_triggered()
 {
 	OBSScene     scene  = GetCurrentScene();
-	obs_source_t source = obs_scene_get_source(scene);
+	obs_source_t *source = obs_scene_get_source(scene);
 
 	if (source && QueryRemoveSource(source))
 		obs_source_remove(source);
@@ -1582,10 +1582,10 @@ void OBSBasic::on_actionSceneDown_triggered()
 void OBSBasic::on_sources_currentItemChanged(QListWidgetItem *current,
 		QListWidgetItem *prev)
 {
-	auto select_one = [] (obs_scene_t scene, obs_sceneitem_t item,
+	auto select_one = [] (obs_scene_t *scene, obs_sceneitem_t *item,
 			void *param)
 	{
-		obs_sceneitem_t selectedItem =
+		obs_sceneitem_t *selectedItem =
 			*reinterpret_cast<OBSSceneItem*>(param);
 		obs_sceneitem_select(item, (selectedItem == item));
 
@@ -1597,7 +1597,7 @@ void OBSBasic::on_sources_currentItemChanged(QListWidgetItem *current,
 		return;
 
 	OBSSceneItem item = current->data(Qt::UserRole).value<OBSSceneItem>();
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 	if ((obs_source_get_output_flags(source) & OBS_SOURCE_VIDEO) == 0)
 		return;
 
@@ -1625,7 +1625,7 @@ void OBSBasic::on_sources_customContextMenuRequested(const QPoint &pos)
 			popup.addSeparator();
 
 		OBSSceneItem sceneItem = GetSceneItem(item);
-		obs_source_t source = obs_sceneitem_get_source(sceneItem);
+		obs_source_t *source = obs_sceneitem_get_source(sceneItem);
 		QAction *action;
 
 		popup.addAction(QTStr("Rename"), this,
@@ -1722,7 +1722,7 @@ void OBSBasic::on_actionAddSource_triggered()
 void OBSBasic::on_actionRemoveSource_triggered()
 {
 	OBSSceneItem item   = GetCurrentSceneItem();
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 
 	if (source && QueryRemoveSource(source))
 		obs_sceneitem_remove(item);
@@ -1809,7 +1809,7 @@ void OBSBasic::UploadLog(const char *file)
 
 	ui->menuLogFiles->setEnabled(false);
 
-	auto data_deleter = [](obs_data_t d) { obs_data_release(d); };
+	auto data_deleter = [](obs_data_t *d) { obs_data_release(d); };
 	using data_t = unique_ptr<struct obs_data, decltype(data_deleter)>;
 
 	data_t content{obs_data_create(), data_deleter};
@@ -1886,7 +1886,7 @@ void OBSBasic::logUploadFinished()
 	if (!jsonReply || !*jsonReply)
 		return;
 
-	obs_data_t returnData = obs_data_create_from_json(jsonReply);
+	obs_data_t *returnData = obs_data_create_from_json(jsonReply);
 	QString logURL = obs_data_get_string(returnData, "html_url");
 	obs_data_release(returnData);
 
@@ -1897,10 +1897,10 @@ void OBSBasic::logUploadFinished()
 }
 
 static void RenameListItem(OBSBasic *parent, QListWidget *listWidget,
-		obs_source_t source, const string &name)
+		obs_source_t *source, const string &name)
 {
 	const char      *prevName   = obs_source_get_name(source);
-	obs_source_t    foundSource = obs_get_source_by_name(name.c_str());
+	obs_source_t    *foundSource = obs_get_source_by_name(name.c_str());
 	QListWidgetItem *listItem   = listWidget->currentItem();
 
 	if (foundSource || name.compare(prevName) == 0 || name.empty()) {
@@ -1933,7 +1933,7 @@ void OBSBasic::SceneNameEdited(QWidget *editor,
 	if (!scene)
 		return;
 
-	obs_source_t source = obs_scene_get_source(scene);
+	obs_source_t *source = obs_scene_get_source(scene);
 	RenameListItem(this, ui->scenes, source, text);
 
 	UNUSED_PARAMETER(endHint);
@@ -1949,7 +1949,7 @@ void OBSBasic::SceneItemNameEdited(QWidget *editor,
 	if (!item)
 		return;
 
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 	RenameListItem(this, ui->sources, source, text);
 
 	UNUSED_PARAMETER(endHint);
@@ -2017,8 +2017,8 @@ void OBSBasic::RecordingStop()
 void OBSBasic::SetupEncoders()
 {
 	if (activeRefs == 0) {
-		obs_data_t x264Settings = obs_data_create();
-		obs_data_t aacSettings  = obs_data_create();
+		obs_data_t *x264Settings = obs_data_create();
+		obs_data_t *aacSettings  = obs_data_create();
 
 		int videoBitrate = config_get_uint(basicConfig, "SimpleOutput",
 				"VBitrate");
@@ -2101,7 +2101,7 @@ void OBSBasic::on_recordButton_clicked()
 		const char *path = config_get_string(basicConfig,
 				"SimpleOutput", "FilePath");
 
-		os_dir_t dir = path ? os_opendir(path) : nullptr;
+		os_dir_t *dir = path ? os_opendir(path) : nullptr;
 
 		if (!dir) {
 			QMessageBox::information(this,
@@ -2126,7 +2126,7 @@ void OBSBasic::on_recordButton_clicked()
 		obs_output_set_video_encoder(fileOutput, x264);
 		obs_output_set_audio_encoder(fileOutput, aac);
 
-		obs_data_t settings = obs_data_create();
+		obs_data_t *settings = obs_data_create();
 		obs_data_set_string(settings, "path", strPath.c_str());
 
 		obs_output_update(fileOutput, settings);
@@ -2211,7 +2211,7 @@ void OBSBasic::GetConfigFPS(uint32_t &num, uint32_t &den) const
 		GetFPSCommon(num, den);
 }
 
-config_t OBSBasic::Config() const
+config_t *OBSBasic::Config() const
 {
 	return basicConfig;
 }
@@ -2228,7 +2228,7 @@ void OBSBasic::on_actionEditTransform_triggered()
 
 void OBSBasic::on_actionResetTransform_triggered()
 {
-	auto func = [] (obs_scene_t scene, obs_sceneitem_t item, void *param)
+	auto func = [] (obs_scene_t *scene, obs_sceneitem_t *item, void *param)
 	{
 		if (!obs_sceneitem_selected(item))
 			return true;
@@ -2251,7 +2251,7 @@ void OBSBasic::on_actionResetTransform_triggered()
 	obs_scene_enum_items(GetCurrentScene(), func, nullptr);
 }
 
-static void GetItemBox(obs_sceneitem_t item, vec3 &tl, vec3 &br)
+static void GetItemBox(obs_sceneitem_t *item, vec3 &tl, vec3 &br)
 {
 	matrix4 boxTransform;
 	obs_sceneitem_get_box_transform(item, &boxTransform);
@@ -2274,14 +2274,14 @@ static void GetItemBox(obs_sceneitem_t item, vec3 &tl, vec3 &br)
 	GetMinPos(1.0f, 1.0f);
 }
 
-static vec3 GetItemTL(obs_sceneitem_t item)
+static vec3 GetItemTL(obs_sceneitem_t *item)
 {
 	vec3 tl, br;
 	GetItemBox(item, tl, br);
 	return tl;
 }
 
-static void SetItemTL(obs_sceneitem_t item, const vec3 &tl)
+static void SetItemTL(obs_sceneitem_t *item, const vec3 &tl)
 {
 	vec3 newTL;
 	vec2 pos;
@@ -2293,7 +2293,7 @@ static void SetItemTL(obs_sceneitem_t item, const vec3 &tl)
 	obs_sceneitem_set_pos(item, &pos);
 }
 
-static bool RotateSelectedSources(obs_scene_t scene, obs_sceneitem_t item,
+static bool RotateSelectedSources(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	if (!obs_sceneitem_selected(item))
@@ -2333,7 +2333,7 @@ void OBSBasic::on_actionRotate180_triggered()
 	obs_scene_enum_items(GetCurrentScene(), RotateSelectedSources, &f180);
 }
 
-static bool MultiplySelectedItemScale(obs_scene_t scene, obs_sceneitem_t item,
+static bool MultiplySelectedItemScale(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	vec2 &mul = *reinterpret_cast<vec2*>(param);
@@ -2370,7 +2370,7 @@ void OBSBasic::on_actionFlipVertical_triggered()
 			&scale);
 }
 
-static bool CenterAlignSelectedItems(obs_scene_t scene, obs_sceneitem_t item,
+static bool CenterAlignSelectedItems(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	obs_bounds_type boundsType = *reinterpret_cast<obs_bounds_type*>(param);
@@ -2414,7 +2414,7 @@ void OBSBasic::on_actionStretchToScreen_triggered()
 
 void OBSBasic::on_actionCenterToScreen_triggered()
 {
-	auto func = [] (obs_scene_t scene, obs_sceneitem_t item, void *param)
+	auto func = [] (obs_scene_t *scene, obs_sceneitem_t *item, void *param)
 	{
 		vec3 tl, br, itemCenter, screenCenter, offset;
 		obs_video_info ovi;

obs/window-basic-main.hpp

@@ -52,7 +52,7 @@ class OBSBasic : public OBSMainWindow {
 	friend class OBSBasicPreview;
 
 private:
-	std::unordered_map<obs_source_t, int> sourceSceneRefs;
+	std::unordered_map<obs_source_t*, int> sourceSceneRefs;
 
 	std::vector<VolControl*> volumes;
 
@@ -65,7 +65,7 @@ private:
 	QNetworkAccessManager networkManager;
 
 	QPointer<QTimer>    cpuUsageTimer;
-	os_cpu_usage_info_t cpuUsageInfo = nullptr;
+	os_cpu_usage_info_t *cpuUsageInfo = nullptr;
 
 	QBuffer       logUploadPostData;
 	QNetworkReply *logUploadReply = nullptr;
@@ -75,14 +75,14 @@ private:
 	QNetworkReply *updateReply = nullptr;
 	QByteArray    updateReturnData;
 
-	obs_output_t  fileOutput = nullptr;
-	obs_output_t  streamOutput = nullptr;
-	obs_service_t service = nullptr;
-	obs_encoder_t aac = nullptr;
-	obs_encoder_t x264 = nullptr;
+	obs_output_t  *fileOutput = nullptr;
+	obs_output_t  *streamOutput = nullptr;
+	obs_service_t *service = nullptr;
+	obs_encoder_t *aac = nullptr;
+	obs_encoder_t *x264 = nullptr;
 
-	gs_vertbuffer_t box = nullptr;
-	gs_vertbuffer_t circle = nullptr;
+	gs_vertbuffer_t *box = nullptr;
+	gs_vertbuffer_t *circle = nullptr;
 
 	bool          sceneChanging = false;
 
@@ -125,7 +125,7 @@ private:
 	OBSSceneItem  GetSceneItem(QListWidgetItem *item);
 	OBSSceneItem  GetCurrentSceneItem();
 
-	bool          QueryRemoveSource(obs_source_t source);
+	bool          QueryRemoveSource(obs_source_t *source);
 
 	void          TimedCheckForUpdates();
 	void          CheckForUpdates();
@@ -137,14 +137,14 @@ private:
 	void GetConfigFPS(uint32_t &num, uint32_t &den) const;
 
 	void UpdateSources(OBSScene scene);
-	void InsertSceneItem(obs_sceneitem_t item);
+	void InsertSceneItem(obs_sceneitem_t *item);
 
 	void TempFileOutput(const char *path, int vBitrate, int aBitrate);
 	void TempStreamOutput(const char *url, const char *key,
 			int vBitrate, int aBitrate);
 
-	void CreateInteractionWindow(obs_source_t source);
-	void CreatePropertiesWindow(obs_source_t source);
+	void CreateInteractionWindow(obs_source_t *source);
+	void CreatePropertiesWindow(obs_source_t *source);
 
 public slots:
 	void StreamingStart();
@@ -171,20 +171,20 @@ private slots:
 
 private:
 	/* OBS Callbacks */
-	static void SceneItemAdded(void *data, calldata_t params);
-	static void SceneItemRemoved(void *data, calldata_t params);
-	static void SourceAdded(void *data, calldata_t params);
-	static void SourceRemoved(void *data, calldata_t params);
-	static void SourceActivated(void *data, calldata_t params);
-	static void SourceDeactivated(void *data, calldata_t params);
-	static void SourceRenamed(void *data, calldata_t params);
-	static void ChannelChanged(void *data, calldata_t params);
+	static void SceneItemAdded(void *data, calldata_t *params);
+	static void SceneItemRemoved(void *data, calldata_t *params);
+	static void SourceAdded(void *data, calldata_t *params);
+	static void SourceRemoved(void *data, calldata_t *params);
+	static void SourceActivated(void *data, calldata_t *params);
+	static void SourceDeactivated(void *data, calldata_t *params);
+	static void SourceRenamed(void *data, calldata_t *params);
+	static void ChannelChanged(void *data, calldata_t *params);
 	static void RenderMain(void *data, uint32_t cx, uint32_t cy);
 
-	static void SceneItemMoveUp(void *data, calldata_t params);
-	static void SceneItemMoveDown(void *data, calldata_t params);
-	static void SceneItemMoveTop(void *data, calldata_t params);
-	static void SceneItemMoveBottom(void *data, calldata_t params);
+	static void SceneItemMoveUp(void *data, calldata_t *params);
+	static void SceneItemMoveDown(void *data, calldata_t *params);
+	static void SceneItemMoveTop(void *data, calldata_t *params);
+	static void SceneItemMoveBottom(void *data, calldata_t *params);
 
 	void ResizePreview(uint32_t cx, uint32_t cy);
 
@@ -195,8 +195,8 @@ private:
 public:
 	OBSScene      GetCurrentScene();
 
-	obs_service_t GetService();
-	void          SetService(obs_service_t service);
+	obs_service_t *GetService();
+	void          SetService(obs_service_t *service);
 
 	int  ResetVideo();
 	bool ResetAudio();
@@ -299,7 +299,7 @@ public:
 
 	virtual void OBSInit() override;
 
-	virtual config_t Config() const override;
+	virtual config_t *Config() const override;
 
 private:
 	std::unique_ptr<Ui::OBSBasic> ui;

obs/window-basic-preview.cpp

@@ -49,14 +49,15 @@ struct SceneFindData {
 	{}
 };
 
-static bool SceneItemHasVideo(obs_sceneitem_t item)
+static bool SceneItemHasVideo(obs_sceneitem_t *item)
 {
-	obs_source_t source = obs_sceneitem_get_source(item);
+	obs_source_t *source = obs_sceneitem_get_source(item);
 	uint32_t flags = obs_source_get_output_flags(source);
 	return (flags & OBS_SOURCE_VIDEO) != 0;
 }
 
-static bool FindItemAtPos(obs_scene_t scene, obs_sceneitem_t item, void *param)
+static bool FindItemAtPos(obs_scene_t *scene, obs_sceneitem_t *item,
+		void *param)
 {
 	SceneFindData *data = reinterpret_cast<SceneFindData*>(param);
 	matrix4       transform;
@@ -159,7 +160,7 @@ OBSSceneItem OBSBasicPreview::GetItemAtPos(const vec2 &pos, bool selectBelow)
 	return data.item;
 }
 
-static bool CheckItemSelected(obs_scene_t scene, obs_sceneitem_t item,
+static bool CheckItemSelected(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	SceneFindData *data = reinterpret_cast<SceneFindData*>(param);
@@ -220,7 +221,7 @@ struct HandleFindData {
 	{}
 };
 
-static bool FindHandleAtPos(obs_scene_t scene, obs_sceneitem_t item,
+static bool FindHandleAtPos(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	if (!obs_sceneitem_selected(item))
@@ -263,7 +264,7 @@ static bool FindHandleAtPos(obs_scene_t scene, obs_sceneitem_t item,
 	return true;
 }
 
-static vec2 GetItemSize(obs_sceneitem_t item)
+static vec2 GetItemSize(obs_sceneitem_t *item)
 {
 	obs_bounds_type boundsType = obs_sceneitem_get_bounds_type(item);
 	vec2 size;
@@ -271,7 +272,7 @@ static vec2 GetItemSize(obs_sceneitem_t item)
 	if (boundsType != OBS_BOUNDS_NONE) {
 		obs_sceneitem_get_bounds(item, &size);
 	} else {
-		obs_source_t source = obs_sceneitem_get_source(item);
+		obs_source_t *source = obs_sceneitem_get_source(item);
 		vec2 scale;
 
 		obs_sceneitem_get_scale(item, &scale);
@@ -345,9 +346,10 @@ void OBSBasicPreview::mousePressEvent(QMouseEvent *event)
 	vec2_zero(&lastMoveOffset);
 }
 
-static bool select_one(obs_scene_t scene, obs_sceneitem_t item, void *param)
+static bool select_one(obs_scene_t *scene, obs_sceneitem_t *item, void *param)
 {
-	obs_sceneitem_t selectedItem = reinterpret_cast<obs_sceneitem_t>(param);
+	obs_sceneitem_t *selectedItem =
+		reinterpret_cast<obs_sceneitem_t*>(param);
 	obs_sceneitem_select(item, (selectedItem == item));
 
 	UNUSED_PARAMETER(scene);
@@ -361,7 +363,7 @@ void OBSBasicPreview::DoSelect(const vec2 &pos)
 	OBSScene     scene = main->GetCurrentScene();
 	OBSSceneItem item  = GetItemAtPos(pos, true);
 
-	obs_scene_enum_items(scene, select_one, (obs_sceneitem_t)item);
+	obs_scene_enum_items(scene, select_one, (obs_sceneitem_t*)item);
 }
 
 void OBSBasicPreview::DoCtrlSelect(const vec2 &pos)
@@ -403,7 +405,7 @@ struct SelectedItemBounds {
 	vec3 tl, br;
 };
 
-static bool AddItemBounds(obs_scene_t scene, obs_sceneitem_t item,
+static bool AddItemBounds(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param)
 {
 	SelectedItemBounds *data = reinterpret_cast<SelectedItemBounds*>(param);
@@ -454,7 +456,7 @@ void OBSBasicPreview::SnapItemMovement(vec2 &offset)
 	offset.y += snapOffset.y;
 }
 
-static bool move_items(obs_scene_t scene, obs_sceneitem_t item, void *param)
+static bool move_items(obs_scene_t *scene, obs_sceneitem_t *item, void *param)
 {
 	vec2 *offset = reinterpret_cast<vec2*>(param);
 
@@ -613,7 +615,7 @@ void OBSBasicPreview::StretchItem(const vec2 &pos)
 	if (!(modifiers & Qt::ControlModifier))
 		SnapStretchingToScreen(tl, br);
 
-	obs_source_t source = obs_sceneitem_get_source(stretchItem);
+	obs_source_t *source = obs_sceneitem_get_source(stretchItem);
 
 	vec2 baseSize;
 	vec2_set(&baseSize,
@@ -687,8 +689,8 @@ static void DrawCircleAtPos(float x, float y, matrix4 &matrix,
 	gs_matrix_pop();
 }
 
-bool OBSBasicPreview::DrawSelectedItem(obs_scene_t scene, obs_sceneitem_t item,
-		void *param)
+bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
+		obs_sceneitem_t *item, void *param)
 {
 	if (!obs_sceneitem_selected(item))
 		return true;
@@ -727,8 +729,8 @@ void OBSBasicPreview::DrawSceneEditing()
 {
 	OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
 
-	gs_effect_t    solid = obs_get_solid_effect();
-	gs_technique_t tech  = gs_effect_get_technique(solid, "Solid");
+	gs_effect_t    *solid = obs_get_solid_effect();
+	gs_technique_t *tech  = gs_effect_get_technique(solid, "Solid");
 
 	vec4 color;
 	vec4_set(&color, 1.0f, 0.0f, 0.0f, 1.0f);

obs/window-basic-preview.hpp

@@ -43,7 +43,7 @@ private:
 	bool         mouseOverItems = false;
 
 	static vec2 GetMouseEventPos(QMouseEvent *event);
-	static bool DrawSelectedItem(obs_scene_t scene, obs_sceneitem_t item,
+	static bool DrawSelectedItem(obs_scene_t *scene, obs_sceneitem_t *item,
 		void *param);
 
 	static OBSSceneItem GetItemAtPos(const vec2 &pos, bool selectBelow);

obs/window-basic-properties.cpp

@@ -71,7 +71,7 @@ OBSBasicProperties::OBSBasicProperties(QWidget *parent, OBSSource source_)
 	setWindowTitle(QTStr("Basic.PropertiesWindow").arg(QT_UTF8(name)));
 }
 
-void OBSBasicProperties::SourceRemoved(void *data, calldata_t params)
+void OBSBasicProperties::SourceRemoved(void *data, calldata_t *params)
 {
 	QMetaObject::invokeMethod(static_cast<OBSBasicProperties*>(data),
 			"close");

obs/window-basic-properties.hpp

@@ -41,7 +41,7 @@ private:
 	OBSSignal  removedSignal;
 	OBSPropertiesView *view;
 
-	static void SourceRemoved(void *data, calldata_t params);
+	static void SourceRemoved(void *data, calldata_t *params);
 	static void DrawPreview(void *data, uint32_t cx, uint32_t cy);
 
 private slots:

obs/window-basic-settings.cpp

@@ -237,9 +237,9 @@ void OBSBasicSettings::LoadServiceTypes()
 void OBSBasicSettings::LoadServiceInfo()
 {
 	QLayout          *layout    = ui->streamContainer->layout();
-	obs_service_t    service    = main->GetService();
-	obs_data_t       settings   = obs_service_get_settings(service);
-	obs_properties_t properties = obs_service_properties(service);
+	obs_service_t    *service    = main->GetService();
+	obs_data_t       *settings   = obs_service_get_settings(service);
+	obs_properties_t *properties = obs_service_properties(service);
 
 	delete streamProperties;
 	streamProperties = new OBSPropertiesView(
@@ -475,7 +475,7 @@ static inline void LoadListValue(QComboBox *widget, const char *text,
 	widget->addItem(QT_UTF8(text), QT_UTF8(val));
 }
 
-void OBSBasicSettings::LoadListValues(QComboBox *widget, obs_property_t prop,
+void OBSBasicSettings::LoadListValues(QComboBox *widget, obs_property_t *prop,
 		const char *configName)
 {
 	size_t count = obs_property_list_item_count(prop);
@@ -506,13 +506,13 @@ void OBSBasicSettings::LoadAudioDevices()
 	const char *input_id  = App()->InputAudioSource();
 	const char *output_id = App()->OutputAudioSource();
 
-	obs_properties_t input_props = obs_get_source_properties(
+	obs_properties_t *input_props = obs_get_source_properties(
 			OBS_SOURCE_TYPE_INPUT, input_id);
-	obs_properties_t output_props = obs_get_source_properties(
+	obs_properties_t *output_props = obs_get_source_properties(
 			OBS_SOURCE_TYPE_INPUT, output_id);
 
 	if (input_props) {
-		obs_property_t inputs  = obs_properties_get(input_props,
+		obs_property_t *inputs  = obs_properties_get(input_props,
 				"device_id");
 		LoadListValues(ui->auxAudioDevice1, inputs, "AuxDevice1");
 		LoadListValues(ui->auxAudioDevice2, inputs, "AuxDevice2");
@@ -521,7 +521,7 @@ void OBSBasicSettings::LoadAudioDevices()
 	}
 
 	if (output_props) {
-		obs_property_t outputs = obs_properties_get(output_props,
+		obs_property_t *outputs = obs_properties_get(output_props,
 				"device_id");
 		LoadListValues(ui->desktopAudioDevice1, outputs,
 				"DesktopDevice1");
@@ -738,7 +738,7 @@ void OBSBasicSettings::on_buttonBox_clicked(QAbstractButton *button)
 void OBSBasicSettings::on_streamType_currentIndexChanged(int idx)
 {
 	QString val = ui->streamType->itemData(idx).toString();
-	obs_service_t newService;
+	obs_service_t *newService;
 
 	if (loading)
 		return;

obs/window-basic-settings.hpp

@@ -97,7 +97,7 @@ private:
 	void LoadSimpleOutputSettings();
 
 	/* audio */
-	void LoadListValues(QComboBox *widget, obs_property_t prop,
+	void LoadListValues(QComboBox *widget, obs_property_t *prop,
 		const char *configName);
 	void LoadAudioDevices();
 

obs/window-basic-source-select.cpp

@@ -21,7 +21,7 @@
 #include "qt-wrappers.hpp"
 #include "obs-app.hpp"
 
-bool OBSBasicSourceSelect::EnumSources(void *data, obs_source_t source)
+bool OBSBasicSourceSelect::EnumSources(void *data, obs_source_t *source)
 {
 	OBSBasicSourceSelect *window = static_cast<OBSBasicSourceSelect*>(data);
 	const char *name = obs_source_get_name(source);
@@ -33,19 +33,19 @@ bool OBSBasicSourceSelect::EnumSources(void *data, obs_source_t source)
 	return true;
 }
 
-void OBSBasicSourceSelect::OBSSourceAdded(void *data, calldata_t calldata)
+void OBSBasicSourceSelect::OBSSourceAdded(void *data, calldata_t *calldata)
 {
 	OBSBasicSourceSelect *window = static_cast<OBSBasicSourceSelect*>(data);
-	obs_source_t source = (obs_source_t)calldata_ptr(calldata, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(calldata, "source");
 
 	QMetaObject::invokeMethod(window, "SourceAdded",
 			Q_ARG(OBSSource, source));
 }
 
-void OBSBasicSourceSelect::OBSSourceRemoved(void *data, calldata_t calldata)
+void OBSBasicSourceSelect::OBSSourceRemoved(void *data, calldata_t *calldata)
 {
 	OBSBasicSourceSelect *window = static_cast<OBSBasicSourceSelect*>(data);
-	obs_source_t source = (obs_source_t)calldata_ptr(calldata, "source");
+	obs_source_t *source = (obs_source_t*)calldata_ptr(calldata, "source");
 
 	QMetaObject::invokeMethod(window, "SourceRemoved",
 			Q_ARG(OBSSource, source));
@@ -81,8 +81,8 @@ void OBSBasicSourceSelect::SourceRemoved(OBSSource source)
 
 static void AddExisting(const char *name)
 {
-	obs_source_t source = obs_get_output_source(0);
-	obs_scene_t  scene  = obs_scene_from_source(source);
+	obs_source_t *source = obs_get_output_source(0);
+	obs_scene_t  *scene  = obs_scene_from_source(source);
 	if (!scene)
 		return;
 
@@ -97,8 +97,8 @@ static void AddExisting(const char *name)
 
 bool AddNew(QWidget *parent, const char *id, const char *name)
 {
-	obs_source_t source  = obs_get_output_source(0);
-	obs_scene_t  scene   = obs_scene_from_source(source);
+	obs_source_t *source  = obs_get_output_source(0);
+	obs_scene_t  *scene   = obs_scene_from_source(source);
 	bool         success = false;
 	if (!source)
 		return false;
@@ -169,7 +169,7 @@ OBSBasicSourceSelect::OBSBasicSourceSelect(OBSBasic *parent, const char *id_)
 
 	QString text{placeHolderText};
 	int i = 1;
-	obs_source_t source = nullptr;
+	obs_source_t *source = nullptr;
 	while ((source = obs_get_source_by_name(QT_TO_UTF8(text)))) {
 		obs_source_release(source);
 		text = QString("%1 %2").arg(placeHolderText).arg(i++);