From b9f0da026ee1cba8f8ab5f54e72cc3a377d3cec6 Mon Sep 17 00:00:00 2001 From: Timo R Date: Sat, 5 Apr 2014 20:21:19 +0200 Subject: [PATCH 1/4] Move opengl loader into a seperate static library, so plugins can use it --- libobs-opengl/CMakeLists.txt | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/libobs-opengl/CMakeLists.txt b/libobs-opengl/CMakeLists.txt index 172c589a8..33659f8aa 100644 --- a/libobs-opengl/CMakeLists.txt +++ b/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) From b312261abd49ec5e039651c22a02c293fb92e346 Mon Sep 17 00:00:00 2001 From: Timo R Date: Sat, 5 Apr 2014 22:09:25 +0200 Subject: [PATCH 2/4] Flush after logging --- libobs/util/base.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/libobs/util/base.c b/libobs/util/base.c index eb9862cd6..5c91cf9ef 100644 --- a/libobs/util/base.c +++ b/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); } } } From 97c94b183ae546155e9112b2ce6f2892cb707654 Mon Sep 17 00:00:00 2001 From: BtbN Date: Wed, 9 Apr 2014 20:04:58 +0200 Subject: [PATCH 3/4] Add copy_texture_region function --- libobs-d3d11/d3d11-subsystem.cpp | 101 ++++++++++++++++++++-------- libobs-d3d11/d3d11-subsystem.hpp | 4 +- libobs-opengl/gl-helpers.c | 21 +++--- libobs-opengl/gl-helpers.h | 4 +- libobs-opengl/gl-subsystem.c | 29 +++++--- libobs/graphics/device-exports.h | 3 + libobs/graphics/graphics-imports.c | 1 + libobs/graphics/graphics-internal.h | 4 ++ libobs/graphics/graphics.c | 12 ++++ libobs/graphics/graphics.h | 4 ++ 10 files changed, 135 insertions(+), 48 deletions(-) diff --git a/libobs-d3d11/d3d11-subsystem.cpp b/libobs-d3d11/d3d11-subsystem.cpp index 663ae912c..b81e93ce2 100644 --- a/libobs-d3d11/d3d11-subsystem.cpp +++ b/libobs-d3d11/d3d11-subsystem.cpp @@ -959,41 +959,88 @@ 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(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_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 + { + gs_texture_2d *src2d = static_cast(src); + gs_texture_2d *dst2d = static_cast(dst); + + if(!src) + throw "Source texture is NULL"; + if(!dst) + throw "Destination texture is NULL"; + 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) + throw "Source and destination formats do not match"; + + 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(dst); + device->CopyTex(tex2d->texture, dst_x, dst_y, src, src_x, src_y, nw, nh); + + } + 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) { - try { - gs_texture_2d *src2d = static_cast(src); - gs_texture_2d *dst2d = static_cast(dst); - - if (!src) - throw "Source texture is NULL"; - if (!dst) - throw "Destination texture is NULL"; - 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) - 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"; - - gs_texture_2d *tex2d = static_cast(dst); - device->CopyTex(tex2d->texture, src); - - } catch (const char *error) { - blog(LOG_ERROR, "device_copy_texture (D3D11): %s", error); - } + 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) @@ -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); diff --git a/libobs-d3d11/d3d11-subsystem.hpp b/libobs-d3d11/d3d11-subsystem.hpp index 24baa91a5..978047de6 100644 --- a/libobs-d3d11/d3d11-subsystem.hpp +++ b/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(); diff --git a/libobs-opengl/gl-helpers.c b/libobs-opengl/gl-helpers.c index c90a00d59..7cee49ebd 100644 --- a/libobs-opengl/gl-helpers.c +++ b/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 diff --git a/libobs-opengl/gl-helpers.h b/libobs-opengl/gl-helpers.h index f27b20af2..9c9756ef6 100644 --- a/libobs-opengl/gl-helpers.h +++ b/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); diff --git a/libobs-opengl/gl-subsystem.c b/libobs-opengl/gl-subsystem.c index 4e3253828..08be22346 100644 --- a/libobs-opengl/gl-subsystem.c +++ b/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)], @@ -785,7 +788,9 @@ 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 +807,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 +816,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 +836,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); diff --git a/libobs/graphics/device-exports.h b/libobs/graphics/device-exports.h index 20732d167..381f4e526 100644 --- a/libobs/graphics/device-exports.h +++ b/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); diff --git a/libobs/graphics/graphics-imports.c b/libobs/graphics/graphics-imports.c index 85dda6c9b..9d19e8d16 100644 --- a/libobs/graphics/graphics-imports.c +++ b/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); diff --git a/libobs/graphics/graphics-internal.h b/libobs/graphics/graphics-internal.h index a2fff6c30..acedfe5a2 100644 --- a/libobs/graphics/graphics-internal.h +++ b/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); diff --git a/libobs/graphics/graphics.c b/libobs/graphics/graphics.c index 9b421c7f3..4fc32dead 100644 --- a/libobs/graphics/graphics.c +++ b/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; diff --git a/libobs/graphics/graphics.h b/libobs/graphics/graphics.h index fafc9db67..747a7a98b 100644 --- a/libobs/graphics/graphics.h +++ b/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); From 0f9c6e550358d0f66cdd22ff87cea5b022723e4a Mon Sep 17 00:00:00 2001 From: BtbN Date: Sat, 12 Apr 2014 13:33:47 +0200 Subject: [PATCH 4/4] Create sub window for rendering, to avoid visual mismatch issues --- libobs-opengl/gl-cocoa.m | 12 ++ libobs-opengl/gl-subsystem.c | 12 +- libobs-opengl/gl-subsystem.h | 3 + libobs-opengl/gl-windows.c | 11 ++ libobs-opengl/gl-x11.c | 206 +++++++++++++++++++++++++++++++---- 5 files changed, 223 insertions(+), 21 deletions(-) diff --git a/libobs-opengl/gl-cocoa.m b/libobs-opengl/gl-cocoa.m index b17eb26a2..2b327933d 100644 --- a/libobs-opengl/gl-cocoa.m +++ b/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) diff --git a/libobs-opengl/gl-subsystem.c b/libobs-opengl/gl-subsystem.c index 08be22346..583490bed 100644 --- a/libobs-opengl/gl-subsystem.c +++ b/libobs-opengl/gl-subsystem.c @@ -233,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; } @@ -790,7 +797,8 @@ fail: 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) + 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; @@ -1265,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); } diff --git a/libobs-opengl/gl-subsystem.h b/libobs-opengl/gl-subsystem.h index 72c114420..1779d5091 100644 --- a/libobs-opengl/gl-subsystem.h +++ b/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); diff --git a/libobs-opengl/gl-windows.c b/libobs-opengl/gl-windows.c index b041bb4f3..06d4383ab 100644 --- a/libobs-opengl/gl-windows.c +++ b/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); diff --git a/libobs-opengl/gl-x11.c b/libobs-opengl/gl-x11.c index d2ab91456..cd2fb8245 100644 --- a/libobs-opengl/gl-x11.c +++ b/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); + /* We assume later that cur_swap is already set. */ + device->cur_swap = &plat->swap; - device->cur_swap = &plat->swap; /* We assume later that cur_swap is already set. */ - - 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); }