void
glx_ctx_pop()
{
assert(1 == ctx_stack.element_count);
glXMakeCurrent(ctx_stack.dpy, ctx_stack.wnd, ctx_stack.glc);
ctx_stack.element_count --;
glx_ctx_unlock();
}
void
glx_ctx_ref_glc_hash_table(Display *dpy, int screen)
{
glx_ctx_lock();
if (0 == glc_hash_table_ref_count) {
glc_hash_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, value_destroy_func);
glc_hash_table_ref_count = 1;
GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
root_vi = glXChooseVisual(dpy, screen, att);
if (NULL == root_vi) {
traceError("error (%s): glXChooseVisual failed\n", __func__);
glx_ctx_unlock();
return;
}
root_glc = glXCreateContext(dpy, root_vi, NULL, GL_TRUE);
} else {
glc_hash_table_ref_count ++;
}
glx_ctx_unlock();
}
void
glx_ctx_unref_glc_hash_table(Display *dpy)
{
glx_ctx_lock();
glc_hash_table_ref_count --;
if (0 == glc_hash_table_ref_count) {
g_hash_table_unref(glc_hash_table);
glc_hash_table = NULL;
glXDestroyContext(dpy, root_glc);
XFree(root_vi);
}
glx_ctx_unlock();
}
VdpStatus
vdpDeviceDestroy(VdpDevice device)
{
VdpStatus err_code;
VdpDeviceData *data = handle_acquire(device, HANDLETYPE_DEVICE);
if (NULL == data)
return VDP_STATUS_INVALID_HANDLE;
if (0 != data->refcount) {
// Buggy client forgot to destroy dependend objects or decided that destroying
// VdpDevice destroys all child object. Let's try to mitigate and prevent leakage.
traceError("warning (%s): non-zero reference count (%d). Trying to free child objects.\n",
__func__, data->refcount);
void *parent_object = data;
handle_execute_for_all(destroy_child_objects, parent_object);
}
if (0 != data->refcount) {
traceError("error (%s): still non-zero reference count (%d)\n", __func__, data->refcount);
traceError("Here is the list of objects:\n");
struct {
int cnt;
int total_cnt;
VdpDeviceData *deviceData;
} state = { .cnt = 0, .total_cnt = 0, .deviceData = data };
handle_execute_for_all(print_handle_type, &state);
traceError("Objects leaked: %d\n", state.cnt);
traceError("Objects visited during scan: %d\n", state.total_cnt);
err_code = VDP_STATUS_ERROR;
goto quit;
}
// cleaup libva
if (data->va_available)
vaTerminate(data->va_dpy);
glx_ctx_push_thread_local(data);
glDeleteTextures(1, &data->watermark_tex_id);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
destroy_shaders(data);
glx_ctx_pop();
glx_ctx_lock();
glXMakeCurrent(data->display, None, NULL);
glx_ctx_unlock();
glx_ctx_unref_glc_hash_table(data->display);
handle_xdpy_unref(data->display_orig);
handle_expunge(device);
pthread_mutex_destroy(&data->refcount_mutex);
free(data);
GLenum gl_error = glGetError();
if (GL_NO_ERROR != gl_error) {
traceError("error (%s): gl error %d\n", __func__, gl_error);
err_code = VDP_STATUS_ERROR;
goto quit_skip_release;
}
return VDP_STATUS_OK;
quit:
handle_release(device);
quit_skip_release:
return err_code;
}
VdpStatus
vdpDeviceCreateX11(Display *display_orig, int screen, VdpDevice *device,
VdpGetProcAddress **get_proc_address)
{
if (!display_orig || !device)
return VDP_STATUS_INVALID_POINTER;
// Let's get own connection to the X server
Display *display = handle_xdpy_ref(display_orig);
if (NULL == display)
return VDP_STATUS_ERROR;
if (global.quirks.buggy_XCloseDisplay) {
// XCloseDisplay could segfault on fglrx. To avoid calling XCloseDisplay,
// make one more reference to xdpy copy.
handle_xdpy_ref(display_orig);
}
VdpDeviceData *data = calloc(1, sizeof(VdpDeviceData));
if (NULL == data)
return VDP_STATUS_RESOURCES;
glx_ctx_lock(); // use glx lock to serialize X calls
data->type = HANDLETYPE_DEVICE;
data->display = display;
data->display_orig = display_orig; // save supplied pointer too
data->screen = screen;
data->refcount = 0;
pthread_mutex_init(&data->refcount_mutex, NULL);
data->root = DefaultRootWindow(display);
XWindowAttributes wnd_attrs;
XGetWindowAttributes(display, data->root, &wnd_attrs);
data->color_depth = wnd_attrs.depth;
data->fn.glXBindTexImageEXT =
(PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress((GLubyte *)"glXBindTexImageEXT");
data->fn.glXReleaseTexImageEXT =
(PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress((GLubyte *)"glXReleaseTexImageEXT");
glx_ctx_unlock();
if (!data->fn.glXBindTexImageEXT || !data->fn.glXReleaseTexImageEXT) {
traceError("error (%s): can't get glXBindTexImageEXT address\n");
free(data);
return VDP_STATUS_RESOURCES;
}
// create master GLX context to share data between further created ones
glx_ctx_ref_glc_hash_table(display, screen);
data->root_glc = glx_ctx_get_root_context();
glx_ctx_push_thread_local(data);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// initialize VAAPI
if (global.quirks.avoid_va) {
// pretend there is no VA-API available
data->va_available = 0;
} else {
data->va_dpy = vaGetDisplay(display);
data->va_available = 0;
VAStatus status = vaInitialize(data->va_dpy, &data->va_version_major,
&data->va_version_minor);
if (VA_STATUS_SUCCESS == status) {
data->va_available = 1;
traceInfo("libva (version %d.%d) library initialized\n",
data->va_version_major, data->va_version_minor);
} else {
data->va_available = 0;
traceInfo("warning: failed to initialize libva. "
"No video decode acceleration available.\n");
}
}
compile_shaders(data);
glGenTextures(1, &data->watermark_tex_id);
glBindTexture(GL_TEXTURE_2D, data->watermark_tex_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, watermark_width, watermark_height, 0, GL_BGRA,
GL_UNSIGNED_BYTE, watermark_data);
glFinish();
*device = handle_insert(data);
if (get_proc_address)
*get_proc_address = &vdpGetProcAddress;
GLenum gl_error = glGetError();
glx_ctx_pop();
if (GL_NO_ERROR != gl_error) {
traceError("error (%s): gl error %d\n", __func__, gl_error);
return VDP_STATUS_ERROR;
}
return VDP_STATUS_OK;
}