Merge pull request #59 from BtbN/linux_fixes

Linux fixes and additions

libobs-d3d11/d3d11-subsystem.cpp

@@ -959,43 +959,90 @@ void device_setcuberendertarget(device_t device, texture_t tex, int side,
 	device->context->OMSetRenderTargets(1, &rt, zstencil->view);
 }
 
-inline void gs_device::CopyTex(ID3D11Texture2D *dst, texture_t src)
+inline void gs_device::CopyTex(ID3D11Texture2D *dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y,
+		uint32_t src_w, uint32_t src_h)
 {
 	if (src->type != GS_TEXTURE_2D)
 		throw "Source texture must be a 2D texture";
 
 	gs_texture_2d *tex2d = static_cast<gs_texture_2d*>(src);
-	context->CopyResource(dst, tex2d->texture);
+
+	if(dst_x == 0 && dst_y == 0 && src_x == 0 && src_y == 0 && src_w == 0 && src_h == 0)
+	{
+		context->CopyResource(dst, tex2d->texture);
+	}
+	else
+	{
+		D3D11_BOX sbox;
+
+		sbox.left = src_x;
+		if(src_w > 0)
+			sbox.right = src_x + src_w;
+		else
+			sbox.right = tex2d->width - 1;
+
+		sbox.top = src_y;
+		if(src_h > 0)
+			sbox.bottom = src_y + src_h;
+		else
+			sbox.bottom = tex2d->height - 1;
+
+		sbox.front = 0;
+		sbox.back = 1;
+
+		context->CopySubresourceRegion(dst, 0, dst_x, dst_y, 0, tex2d->texture, 0, &sbox);
+	}
 }
 
-void device_copy_texture(device_t device, texture_t dst, texture_t src)
+void device_copy_texture_region(device_t device,
+	texture_t dst, uint32_t dst_x, uint32_t dst_y,
+	texture_t src, uint32_t src_x, uint32_t src_y,
+	uint32_t src_w, uint32_t src_h)
 {
-	try {
+	try
+	{
 		gs_texture_2d *src2d = static_cast<gs_texture_2d*>(src);
 		gs_texture_2d *dst2d = static_cast<gs_texture_2d*>(dst);
 
-		if (!src)
+		if(!src)
 			throw "Source texture is NULL";
-		if (!dst)
+		if(!dst)
 			throw "Destination texture is NULL";
-		if (src->type != GS_TEXTURE_2D || dst->type != GS_TEXTURE_2D)
+		if(src->type != GS_TEXTURE_2D || dst->type != GS_TEXTURE_2D)
 			throw "Source and destination textures must be a 2D "
-			      "textures";
-		if (dst->format != src->format)
+			"textures";
+		if(dst->format != src->format)
 			throw "Source and destination formats do not match";
-		if (dst2d->width  != src2d->width ||
-		    dst2d->height != src2d->height)
-			throw "Source and destination must have the same "
-			      "dimensions";
+
+		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)
+			throw "Destination texture region is not big "
+			      "enough to hold the source region";
+
+		if(dst_x == 0 && dst_y == 0 && src_x == 0 && src_y == 0 && src_w == 0 && src_h == 0)
+		{
+			nw = 0;
+			nh = 0;
+		}
 
 		gs_texture_2d *tex2d = static_cast<gs_texture_2d*>(dst);
-		device->CopyTex(tex2d->texture, src);
+		device->CopyTex(tex2d->texture, dst_x, dst_y, src, src_x, src_y, nw, nh);
 
-	} catch (const char *error) {
+	}
+	catch(const char *error)
+	{
 		blog(LOG_ERROR, "device_copy_texture (D3D11): %s", error);
 	}
 }
 
+void device_copy_texture(device_t device, texture_t dst, texture_t src)
+{
+	device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
+}
+
 void device_stage_texture(device_t device, stagesurf_t dst, texture_t src)
 {
 	try {
@@ -1014,7 +1061,7 @@ void device_stage_texture(device_t device, stagesurf_t dst, texture_t src)
 			throw "Source and destination must have the same "
 			      "dimensions";
 
-		device->CopyTex(dst->texture, src);
+		device->CopyTex(dst->texture, 0, 0, src, 0, 0, 0, 0);
 
 	} catch (const char *error) {
 		blog(LOG_ERROR, "device_copy_texture (D3D11): %s", error);

libobs-d3d11/d3d11-subsystem.hpp

@@ -618,7 +618,9 @@ struct gs_device {
 	void UpdateRasterState();
 	void UpdateBlendState();
 
-	inline void CopyTex(ID3D11Texture2D *dst, texture_t src);
+	inline void CopyTex(ID3D11Texture2D *dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y,
+		uint32_t src_w, uint32_t src_h);
 
 	void UpdateViewProjMatrix();
 

libobs-opengl/CMakeLists.txt

@@ -8,9 +8,10 @@ include_directories(${OPENGL_INCLUDE_DIR})
 add_definitions(-DLIBOBS_EXPORTS)
 
 if(WIN32)
-	set(libobs-opengl_PLATFORM_SOURCES
-		gl-windows.c
+	set(obs-opengl_PLATFORM_SOURCES
 		GL/wgl_obs.c)
+	set(libobs-opengl_PLATFORM_SOURCES
+		gl-windows.c)
 elseif(APPLE)
 	set(libobs-opengl_PLATFORM_SOURCES
 		gl-cocoa.m)
@@ -32,10 +33,14 @@ elseif(APPLE)
 		${IOSURF})
 else()
 	set(libobs-opengl_PLATFORM_SOURCES
-		gl-x11.c
+		gl-x11.c)
+	set(obs-opengl_PLATFORM_SOURCES
 		GL/glx_obs.c)
 endif()
 
+set(obs-opengl_SOURCES
+	GL/gl_obs.c)
+
 set(libobs-opengl_SOURCES
 	${libobs-opengl_PLATFORM_SOURCES}
 	gl-helpers.c
@@ -47,14 +52,23 @@ set(libobs-opengl_SOURCES
 	gl-texture2d.c
 	gl-texturecube.c
 	gl-vertexbuffer.c
-	gl-zstencil.c
-	GL/gl_obs.c)
+	gl-zstencil.c)
 
 set(libobs-opengl_HEADERS
 	gl-helpers.h
 	gl-shaderparser.h
 	gl-subsystem.h)
 
+add_library(obs-opengl STATIC
+	${obs-opengl_SOURCES}
+	${obs-opengl_PLATFORM_SOURCES})
+if(NOT WIN32)
+	set_property(TARGET obs-opengl APPEND_STRING
+		PROPERTY COMPILE_FLAGS " -fPIC")
+endif()
+target_link_libraries(obs-opengl
+	${OPENGL_gl_LIBRARY})
+
 add_library(libobs-opengl MODULE
 	${libobs-opengl_SOURCES}
 	${libobs-opengl_HEADERS})
@@ -64,7 +78,7 @@ set_target_properties(libobs-opengl
 		PREFIX "")
 target_link_libraries(libobs-opengl
 	libobs
-	${libobs-opengl_PLATFORM_DEPS}
-	${OPENGL_gl_LIBRARY})
+	obs-opengl
+	${libobs-opengl_PLATFORM_DEPS})
 
 install_obs_core(libobs-opengl)

libobs-opengl/gl-cocoa.m

@@ -149,6 +149,18 @@ void gl_platform_destroy(struct gl_platform *platform)
 	bfree(platform);
 }
 
+bool gl_platform_init_swapchain(struct gs_swap_chain *swap)
+{
+	UNUSED_PARAMETER(swap);
+
+	return true;
+}
+
+void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
+{
+	UNUSED_PARAMETER(swap);
+}
+
 struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
 {
 	if(!info)

libobs-opengl/gl-helpers.c

@@ -57,8 +57,8 @@ bool gl_init_face(GLenum target, GLenum type, uint32_t num_levels,
 }
 
 static bool gl_copy_fbo(struct gs_device *device,
-		GLuint dst, GLenum dst_target,
-		GLuint src, GLenum src_target,
+		GLuint dst, GLenum dst_target, uint32_t dst_x, uint32_t dst_y,
+		GLuint src, GLenum src_target, uint32_t src_x, uint32_t src_y,
 		uint32_t width, uint32_t height,
 		enum gs_color_format format)
 {
@@ -85,7 +85,7 @@ static bool gl_copy_fbo(struct gs_device *device,
 	if (!gl_success("glReadBuffer"))
 		goto fail;
 
-	glCopyTexSubImage2D(dst_target, 0, 0, 0, 0, 0, width, height);
+	glCopyTexSubImage2D(dst_target, 0, dst_x, dst_y, src_x, src_y, width, height);
 	if (!gl_success("glCopyTexSubImage2D"))
 		goto fail;
 
@@ -101,27 +101,28 @@ fail:
 }
 
 bool gl_copy_texture(struct gs_device *device,
-                     GLuint dst, GLenum dst_target,
-                     GLuint src, GLenum src_target,
+					 GLuint dst, GLenum dst_target, uint32_t dst_x, uint32_t dst_y,
+					 GLuint src, GLenum src_target, uint32_t src_x, uint32_t src_y,
                      uint32_t width, uint32_t height,
                      enum gs_color_format format)
 {
 	bool success = false;
 
 	if (device->copy_type == COPY_TYPE_ARB) {
-		glCopyImageSubData(src, src_target, 0, 0, 0, 0,
-		                   dst, dst_target, 0, 0, 0, 0,
+		glCopyImageSubData(src, src_target, 0, src_x, src_y, 0,
+						   dst, dst_target, 0, dst_x, dst_y, 0,
 		                   width, height, 1);
 		success = gl_success("glCopyImageSubData");
 
 	} else if (device->copy_type == COPY_TYPE_NV) {
-		glCopyImageSubDataNV(src, src_target, 0, 0, 0, 0,
-		                     dst, dst_target, 0, 0, 0, 0,
+		glCopyImageSubDataNV(src, src_target, 0, src_x, src_y, 0,
+							 dst, dst_target, 0, dst_x, dst_y, 0,
 		                     width, height, 1);
 		success = gl_success("glCopyImageSubDataNV");
 
 	} else if (device->copy_type == COPY_TYPE_FBO_BLIT) {
-		if (gl_copy_fbo(device, dst, dst_target, src,  src_target,
+		if (gl_copy_fbo(device, dst, dst_target, dst_x, dst_y,
+					src, src_target, src_x, src_y,
 					width, height, format))
 			success = true;
 		else

libobs-opengl/gl-helpers.h

@@ -149,8 +149,8 @@ extern bool gl_init_face(GLenum target, GLenum type, uint32_t num_levels,
 		const void ***p_data);
 
 extern bool gl_copy_texture(struct gs_device *device,
-                            GLuint dst, GLenum dst_target,
-                            GLuint src, GLenum src_target,
+							GLuint dst, GLenum dst_target, uint32_t dst_x, uint32_t dst_y,
+							GLuint src, GLenum src_target, uint32_t src_x, uint32_t src_y,
                             uint32_t width, uint32_t height,
 			    enum gs_color_format format);
 

libobs-opengl/gl-subsystem.c

@@ -59,6 +59,9 @@ static void APIENTRY gl_debug_proc(
 	GLenum source, GLenum type, GLuint id, GLenum severity, 
 	GLsizei length, const GLchar *message, const GLvoid *data )
 {
+	UNUSED_PARAMETER(id);
+	UNUSED_PARAMETER(data);
+
 	blog(	LOG_DEBUG,
 		"[%s][%s]{%s}: %.*s",
 		debug_source_table[GL_DEBUG_SOURCE_OFFSET(source)],
@@ -230,6 +233,13 @@ swapchain_t device_create_swapchain(device_t device, struct gs_init_data *info)
 		return NULL;
 	}
 
+	if(!gl_platform_init_swapchain(swap))
+	{
+		blog(LOG_ERROR, "gl_platform_init_swapchain  failed");
+		swapchain_destroy(swap);
+		return NULL;
+	}
+
 	return swap;
 }
 
@@ -785,7 +795,10 @@ fail:
 	blog(LOG_ERROR, "device_setcuberendertarget (GL) failed");
 }
 
-void device_copy_texture(device_t device, texture_t dst, texture_t src)
+void device_copy_texture_region(device_t device,
+		texture_t dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y,
+		uint32_t src_w, uint32_t src_h)
 {
 	struct gs_texture_2d *src2d = (struct gs_texture_2d*)src;
 	struct gs_texture_2d *dst2d = (struct gs_texture_2d*)dst;
@@ -802,7 +815,7 @@ void device_copy_texture(device_t device, texture_t dst, texture_t src)
 
 	if (dst->type != GS_TEXTURE_2D || src->type != GS_TEXTURE_2D) {
 		blog(LOG_ERROR, "Source and destination textures must be 2D "
-		                "textures");
+						"textures");
 		goto fail;
 	}
 
@@ -811,15 +824,18 @@ void device_copy_texture(device_t device, texture_t dst, texture_t src)
 		goto fail;
 	}
 
-	if (dst2d->width != src2d->width || dst2d->height != src2d->height) {
-		blog(LOG_ERROR, "Source and destination must have "
-		                "the same dimensions");
+	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 "
+						"enough to hold the source region");
 		goto fail;
 	}
 
-	if (!gl_copy_texture(device, dst->texture, dst->gl_target,
-				src->texture, src->gl_target,
-				src2d->width, src2d->height, src->format))
+	if (!gl_copy_texture(device, dst->texture, dst->gl_target, dst_x, dst_y,
+				src->texture, src->gl_target, src_x, src_y,
+				nw, nh, src->format))
 		goto fail;
 
 	return;
@@ -828,6 +844,11 @@ fail:
 	blog(LOG_ERROR, "device_copy_texture (GL) failed");
 }
 
+void device_copy_texture(device_t device, texture_t dst, texture_t src)
+{
+	device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
+}
+
 void device_beginscene(device_t device)
 {
 	clear_textures(device);
@@ -1252,6 +1273,8 @@ void swapchain_destroy(swapchain_t swapchain)
 	if (swapchain->device->cur_swap == swapchain)
 		device_load_swapchain(swapchain->device, NULL);
 
+	gl_platform_cleanup_swapchain(swapchain);
+
 	gl_windowinfo_destroy(swapchain->wi);
 	bfree(swapchain);
 }

libobs-opengl/gl-subsystem.h

@@ -499,6 +499,9 @@ extern struct gl_platform   *gl_platform_create(device_t device,
 extern struct gs_swap_chain *gl_platform_getswap(struct gl_platform *platform);
 extern void                  gl_platform_destroy(struct gl_platform *platform);
 
+extern bool                  gl_platform_init_swapchain(struct gs_swap_chain *swap);
+extern void                  gl_platform_cleanup_swapchain(struct gs_swap_chain *swap);
+
 extern struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info);
 extern void                  gl_windowinfo_destroy(struct gl_windowinfo *wi);
 

libobs-opengl/gl-windows.c

@@ -432,6 +432,17 @@ void gl_platform_destroy(struct gl_platform *plat)
 	}
 }
 
+bool gl_platform_init_swapchain(struct gs_swap_chain *swap)
+{
+	UNUSED_PARAMETER(swap);
+	return true;
+}
+
+void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
+{
+	UNUSED_PARAMETER(swap);
+}
+
 struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
 {
 	struct gl_windowinfo *wi = gl_windowinfo_bare(info);

libobs-opengl/gl-x11.c

@@ -29,6 +29,8 @@ static const int fb_attribs[] = {
 	GLX_DEPTH_SIZE, 24, 
 	GLX_BUFFER_SIZE, 32, /* Color buffer depth */
 	GLX_DOUBLEBUFFER, True,
+	GLX_X_RENDERABLE, True,
+	GLX_RENDER_TYPE, GLX_RGBA_BIT,
 	None
 };
 
@@ -41,12 +43,15 @@ static const int ctx_attribs[] = {
 };
 
 struct gl_windowinfo {
-	uint32_t id;
 	Display *display;
+	uint32_t id;
+	uint32_t int_id;
+	uint32_t glxid;
 };
 
 struct gl_platform {
 	GLXContext context;
+	GLXFBConfig fbcfg;
 	struct gs_swap_chain swap;
 };
 
@@ -95,6 +100,41 @@ static void print_info_stuff(struct gs_init_data *info)
 	);
 }
 
+int wait_for_notify(Display *dpy, XEvent *e, char *arg)
+{
+	UNUSED_PARAMETER(dpy);
+	return (e->type == MapNotify) && (e->xmap.window == (Window)arg);
+}
+
+static bool got_x_error = false;
+static int err_handler(Display *disp, XErrorEvent *e)
+{
+	char estr[128];
+	XGetErrorText(disp, e->error_code, estr, 128);
+
+	blog(LOG_DEBUG, "Got X error: %s", estr);
+
+	got_x_error = true;
+
+	return 0;
+}
+
+static bool handle_x_error(Display *disp, const char *error_string)
+{
+	XSync(disp, 0);
+
+	if(got_x_error)
+	{
+		if(error_string)
+			blog(LOG_ERROR, "%s", error_string);
+
+		got_x_error = false;
+		return true;
+	}
+
+	return false;
+}
+
 struct gl_platform *gl_platform_create(device_t device,
 		struct gs_init_data *info)
 {
@@ -103,6 +143,8 @@ struct gl_platform *gl_platform_create(device_t device,
 	Display *display = info->window.display;
 	struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
 	GLXFBConfig* configs;
+	XWindowAttributes attrs;
+	int screen;
 
 	print_info_stuff(info);
 
@@ -112,7 +154,15 @@ struct gl_platform *gl_platform_create(device_t device,
 		goto fail0;
 	}
 
-	if (!glx_LoadFunctions(display, DefaultScreen(display))) {
+	if(!XGetWindowAttributes(display, info->window.id, &attrs))
+	{
+		blog(LOG_ERROR, "Failed getting window attributes");
+		goto fail0;
+	}
+
+	screen = XScreenNumberOfScreen(attrs.screen);
+
+	if (!glx_LoadFunctions(display, screen)) {
 		blog(LOG_ERROR, "Unable to load GLX entry functions.");
 		goto fail0;
 	}
@@ -139,7 +189,7 @@ struct gl_platform *gl_platform_create(device_t device,
 		goto fail0;
 	}
 
-	configs = glXChooseFBConfig(display, DefaultScreen(display),
+	configs = glXChooseFBConfig(display, screen,
 			fb_attribs, &num_configs);
 
 	if(!configs) {
@@ -148,20 +198,46 @@ struct gl_platform *gl_platform_create(device_t device,
 	}
 
 	if(num_configs == 0) {
+		XFree(configs);
 		blog(LOG_ERROR, "No framebuffer configurations found.");
-		goto fail1;
+		goto fail0;
 	}
 
+	plat->fbcfg = configs[0];
+
+	XFree(configs);
+
+	handle_x_error(display, NULL);
+
 	/* We just use the first configuration found... as it does everything
 	 * we want at the very least. */
-	plat->context = glXCreateContextAttribsARB(display, configs[0], NULL,
+	plat->context = glXCreateContextAttribsARB(display, plat->fbcfg, NULL,
 			True, ctx_attribs);
 	if(!plat->context) {
 		blog(LOG_ERROR, "Failed to create OpenGL context.");
-		goto fail1;
+		goto fail0;
 	}
 
-	if(!glXMakeCurrent(display, info->window.id, plat->context)) {
+	if(handle_x_error(display, "Failed to create OpenGL context."))
+		goto fail2;
+
+	device->plat = plat;
+
+	plat->swap.device = device;
+	plat->swap.info.window.id       = info->window.id;
+	plat->swap.info.window.display  = display;
+	plat->swap.info.format          = GS_RGBA;
+	plat->swap.info.zsformat        = GS_Z24_S8;
+	plat->swap.info.num_backbuffers = 1;
+	plat->swap.info.adapter         = info->adapter;
+	plat->swap.info.cx              = attrs.width;
+	plat->swap.info.cy              = attrs.height;
+	plat->swap.wi                   = gl_windowinfo_create(info);
+
+	if(!gl_platform_init_swapchain(&plat->swap))
+		goto fail2;
+
+	if(!glXMakeCurrent(display, plat->swap.wi->glxid, plat->context)) {
 		blog(LOG_ERROR, "Failed to make context current.");
 		goto fail2;
 	}
@@ -173,24 +249,25 @@ struct gl_platform *gl_platform_create(device_t device,
 
 	blog(LOG_INFO, "OpenGL version: %s\n", glGetString(GL_VERSION));
 
-	plat->swap.device = device;
-	plat->swap.info	  = *info;
-	plat->swap.wi     = gl_windowinfo_create(info);
-
-	device->cur_swap = &plat->swap; /* We assume later that cur_swap is already set. */
+	/* We assume later that cur_swap is already set. */
+	device->cur_swap = &plat->swap;
 
-	XFree(configs);
 	XSync(display, False);
 
+	blog(LOG_INFO, "Created new platform data");
+
 	return plat;
 
 fail2:
 	glXMakeCurrent(display, None, NULL);
 	glXDestroyContext(display, plat->context);
-fail1:
-	XFree(configs);
+
+	gl_platform_cleanup_swapchain(&plat->swap);
+
 fail0:
 	bfree(plat);
+	device->plat = 0;
+
 	return NULL;
 }
 
@@ -204,13 +281,99 @@ void gl_platform_destroy(struct gl_platform *platform)
 	glXMakeCurrent(dpy, None, NULL);
 	glXDestroyContext(dpy, platform->context);
 	gl_windowinfo_destroy(platform->swap.wi);
+	gl_platform_cleanup_swapchain(&platform->swap);
 	bfree(platform);
 }
 
+bool gl_platform_init_swapchain(struct gs_swap_chain *swap)
+{
+	Display *display = swap->wi->display;
+	struct gl_windowinfo *info = swap->wi;
+	struct gl_platform *plat = swap->device->plat;
+	XVisualInfo *vi = 0;
+	Colormap cmap = 0;
+	XSetWindowAttributes swa;
+	XWindowAttributes attrs;
+
+	XErrorHandler phandler = XSetErrorHandler(err_handler);
+
+	gl_platform_cleanup_swapchain(swap);
+
+	if(!XGetWindowAttributes(display, info->id, &attrs))
+	{
+		blog(LOG_ERROR, "Failed getting window attributes");
+		goto fail;
+	}
+
+	vi = glXGetVisualFromFBConfig(display, plat->fbcfg);
+
+	if(handle_x_error(display, "Failed to get visual from fb config."))
+		goto fail;
+
+	cmap = XCreateColormap(display, info->id, vi->visual, AllocNone);
+
+	if(handle_x_error(display, "Failed creating colormap"))
+		goto fail;
+
+	swa.colormap = cmap;
+	swa.border_pixel = 0;
+
+	info->int_id = XCreateWindow(display, info->id, 0, 0,
+	                             attrs.width, attrs.height,
+	                             0, 24, InputOutput, vi->visual,
+	                             CWBorderPixel|CWColormap, &swa);
+	XMapWindow(display, info->int_id);
+
+	if(handle_x_error(display, "Failed creating intermediate X window"))
+		goto fail;
+
+	info->glxid = glXCreateWindow(display, plat->fbcfg, info->int_id, 0);
+
+	if(handle_x_error(display, "Failed creating intermediate GLX window"))
+		goto fail;
+
+	XFreeColormap(display, cmap);
+	XFree(vi);
+
+	return true;
+
+fail:
+
+	gl_platform_cleanup_swapchain(swap);
+
+	if(cmap)
+		XFreeColormap(display, cmap);
+
+	if(vi)
+		XFree(vi);
+
+	XSetErrorHandler(phandler);
+
+	return false;
+}
+
+void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
+{
+	Display *display = swap->wi->display;
+	struct gl_windowinfo *info = swap->wi;
+
+	if(!info)
+		return;
+
+	if(info->glxid)
+		glXDestroyWindow(display, info->glxid);
+
+	if(info->int_id)
+		XDestroyWindow(display, info->int_id);
+
+	info->glxid = 0;
+	info->int_id = 0;
+}
+
 void device_entercontext(device_t device)
 {
 	GLXContext context = device->plat->context;
-	XID window = device->cur_swap->wi->id;
+	XID window = device->cur_swap->wi->glxid;
 	Display *display = device->cur_swap->wi->display;
 
 	if (!glXMakeCurrent(display, window, context)) {
@@ -229,8 +392,11 @@ void device_leavecontext(device_t device)
 
 void gl_update(device_t device)
 {
-	/* I don't know of anything we can do here. */
-	UNUSED_PARAMETER(device);
+	Display *display = device->cur_swap->wi->display;
+	XID window = device->cur_swap->wi->int_id;
+
+	XResizeWindow(display, window,
+				  device->cur_swap->info.cx, device->cur_swap->info.cy);
 }
 
 void device_load_swapchain(device_t device, swapchain_t swap)
@@ -242,7 +408,7 @@ void device_load_swapchain(device_t device, swapchain_t swap)
 		return;
 
 	Display *dpy = swap->wi->display;
-	XID window = swap->wi->id;
+	XID window = swap->wi->glxid;
 	GLXContext ctx = device->plat->context;
 
 	device->cur_swap = swap;
@@ -255,7 +421,7 @@ void device_load_swapchain(device_t device, swapchain_t swap)
 void device_present(device_t device)
 {
 	Display *display = device->cur_swap->wi->display;
-	XID window = device->cur_swap->wi->id;
+	XID window = device->cur_swap->wi->glxid;
 
 	glXSwapBuffers(display, window);
 }

libobs/graphics/device-exports.h

@@ -80,6 +80,9 @@ EXPORT void device_setrendertarget(device_t device, texture_t tex,
 EXPORT void device_setcuberendertarget(device_t device, texture_t cubetex,
 		int side, zstencil_t zstencil);
 EXPORT void device_copy_texture(device_t device, texture_t dst, texture_t src);
+EXPORT void device_copy_texture_region(device_t device,
+		texture_t dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y, uint32_t src_w, uint32_t src_h);
 EXPORT void device_stage_texture(device_t device, stagesurf_t dst,
 		texture_t src);
 EXPORT void device_beginscene(device_t device);

libobs/graphics/graphics-imports.c

@@ -74,6 +74,7 @@ bool load_graphics_imports(struct gs_exports *exports, void *module,
 	GRAPHICS_IMPORT(device_getzstenciltarget);
 	GRAPHICS_IMPORT(device_setrendertarget);
 	GRAPHICS_IMPORT(device_setcuberendertarget);
+	GRAPHICS_IMPORT(device_copy_texture_region);
 	GRAPHICS_IMPORT(device_copy_texture);
 	GRAPHICS_IMPORT(device_stage_texture);
 	GRAPHICS_IMPORT(device_beginscene);

libobs/graphics/graphics-internal.h

@@ -86,6 +86,10 @@ struct gs_exports {
 			int side, zstencil_t zstencil);
 	void (*device_copy_texture)(device_t device, texture_t dst,
 			texture_t src);
+	void (*device_copy_texture_region)(device_t device,
+			texture_t dst, uint32_t dst_x, uint32_t dst_y,
+			texture_t src, uint32_t src_x, uint32_t src_y,
+			uint32_t src_w, uint32_t src_h);
 	void (*device_stage_texture)(device_t device, stagesurf_t dst,
 			texture_t src);
 	void (*device_beginscene)(device_t device);

libobs/graphics/graphics.c

@@ -1243,6 +1243,18 @@ void gs_copy_texture(texture_t dst, texture_t src)
 	graphics->exports.device_copy_texture(graphics->device, dst, src);
 }
 
+void gs_copy_texture_region(texture_t dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y,
+		uint32_t src_w, uint32_t src_h)
+{
+	graphics_t graphics = thread_graphics;
+	if (!graphics) return;
+
+	graphics->exports.device_copy_texture_region(graphics->device,
+			dst, dst_x, dst_y,
+			src, src_x, src_y, src_w, src_h);
+}
+
 void gs_stage_texture(stagesurf_t dst, texture_t src)
 {
 	graphics_t graphics = thread_graphics;

libobs/graphics/graphics.h

@@ -580,6 +580,10 @@ EXPORT void gs_setcuberendertarget(texture_t cubetex, int side,
 		zstencil_t zstencil);
 
 EXPORT void gs_copy_texture(texture_t dst, texture_t src);
+EXPORT void gs_copy_texture_region(
+		texture_t dst, uint32_t dst_x, uint32_t dst_y,
+		texture_t src, uint32_t src_x, uint32_t src_y,
+		uint32_t src_w, uint32_t src_h);
 EXPORT void gs_stage_texture(stagesurf_t dst, texture_t src);
 
 EXPORT void gs_beginscene(void);

libobs/util/base.c

@@ -38,19 +38,23 @@ static void def_log_handler(int log_level, const char *format,
 	if (log_level <= log_output_level) {
 		switch (log_level) {
 		case LOG_DEBUG:
-			printf("debug: %s\n", out);
+			fprintf(stdout, "debug: %s\n", out);
+			fflush(stdout);
 			break;
 
 		case LOG_INFO:
-			printf("info: %s\n", out);
+			fprintf(stdout, "info: %s\n", out);
+			fflush(stdout);
 			break;
 
 		case LOG_WARNING:
-			printf("warning: %s\n", out);
+			fprintf(stdout, "warning: %s\n", out);
+			fflush(stdout);
 			break;
 
 		case LOG_ERROR:
 			fprintf(stderr, "error: %s\n", out);
+			fflush(stderr);
 		}
 	}
 }