void mpgl_uninit(MPGLContext *ctx)
{
set_current_context(NULL);
if (ctx)
ctx->driver->uninit(ctx);
talloc_free(ctx);
}
void rapi_context_set(RapiContext* context)
{
RapiContext *old_context = NULL;
/* Get the current context, if any */
old_context = get_current_context();
set_current_context(context);
if (context)
rapi_context_ref(context);
if (old_context)
rapi_context_unref(old_context);
}
RapiContext* rapi_context_current()/*{{{*/
{
RapiContext *context = NULL;
context = get_current_context();
/* If the current context is not initialized, setup
a new one and return it
*/
if (!context)
{
RapiContext *new_context = rapi_context_new();
set_current_context(new_context);
context = get_current_context();
}
return context;
}/*}}}*/
static void rapi_context_free(RapiContext* context)/*{{{*/
{
if (!context)
return;
/* check it against the current context,
* this should never happen
*/
RapiContext* check_context = get_current_context();
if (check_context == context)
set_current_context(NULL);
rapi_buffer_free(context->send_buffer);
rapi_buffer_free(context->recv_buffer);
synce_socket_free(context->socket);
if (context->own_info && context->info)
synce_info_destroy(context->info);
free(context);
}/*}}}*/
static MPGLContext *init_backend(struct vo *vo, const struct mpgl_driver *driver,
bool probing, int vo_flags)
{
MPGLContext *ctx = talloc_ptrtype(NULL, ctx);
*ctx = (MPGLContext) {
.gl = talloc_zero(ctx, GL),
.vo = vo,
.driver = driver,
};
if (probing)
vo_flags |= VOFLAG_PROBING;
bool old_probing = vo->probing;
vo->probing = probing; // hack; kill it once backends are separate
MP_VERBOSE(vo, "Initializing OpenGL backend '%s'\n", ctx->driver->name);
ctx->priv = talloc_zero_size(ctx, ctx->driver->priv_size);
if (ctx->driver->init(ctx, vo_flags) < 0) {
vo->probing = old_probing;
talloc_free(ctx);
return NULL;
}
vo->probing = old_probing;
if (!ctx->gl->version && !ctx->gl->es)
goto cleanup;
if (probing && ctx->gl->es && (vo_flags & VOFLAG_NO_GLES)) {
MP_VERBOSE(ctx->vo, "Skipping GLES backend.\n");
goto cleanup;
}
if (ctx->gl->mpgl_caps & MPGL_CAP_SW) {
MP_WARN(ctx->vo, "Suspected software renderer or indirect context.\n");
if (vo->probing && !(vo_flags & VOFLAG_SW))
goto cleanup;
}
ctx->gl->debug_context = !!(vo_flags & VOFLAG_GL_DEBUG);
set_current_context(ctx);
return ctx;
cleanup:
mpgl_uninit(ctx);
return NULL;
}
// Create a VO window and create a GL context on it.
// vo_flags: passed to the backend's create window function
MPGLContext *mpgl_init(struct vo *vo, const char *backend_name, int vo_flags)
{
MPGLContext *ctx = NULL;
int index = mpgl_find_backend(backend_name);
if (index == -1) {
for (int n = 0; n < MP_ARRAY_SIZE(backends); n++) {
ctx = init_backend(vo, backends[n], true, vo_flags);
if (ctx)
break;
}
// VO forced, but no backend is ok => force the first that works at all
if (!ctx && !vo->probing) {
for (int n = 0; n < MP_ARRAY_SIZE(backends); n++) {
ctx = init_backend(vo, backends[n], false, vo_flags);
if (ctx)
break;
}
}
} else if (index >= 0) {
ctx = init_backend(vo, backends[index], false, vo_flags);
}
return ctx;
}
void SkNullGLContext::onPlatformMakeCurrent() const {
set_current_context(fState);
}
static void set_current_context_from_interface(const GrGLInterface* interface) {
set_current_context(reinterpret_cast<State*>(interface->fCallbackData));
}
