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

Merge pull request #59 from BtbN/linux_fixes

Browse Source 
Linux fixes and additions
This commit is contained in:
Jim 2014-04-12 10:53:09 -07:00
commit b53e2a88a3
16 changed files with 385 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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<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_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<gs_texture_2d*>(src);
gs_texture_2d *dst2d = static_cast<gs_texture_2d*>(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<gs_texture_2d*>(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<gs_texture_2d*>(src);
gs_texture_2d *dst2d = static_cast<gs_texture_2d*>(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<gs_texture_2d*>(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);

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

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

28
libobs-opengl/CMakeLists.txt
View File

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

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

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

21
libobs-opengl/gl-helpers.c
View File

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

4
libobs-opengl/gl-helpers.h
View File

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

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

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

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

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

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

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

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

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

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

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

1
libobs/graphics/graphics-imports.c
View File

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

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

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

12
libobs/graphics/graphics.c
View File

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

4
libobs/graphics/graphics.h
View File

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

10
libobs/util/base.c
View File

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