static struct native_display *
native_create_display(void *dpy, boolean use_sw)
{
struct gbm_gallium_drm_device *gbm;
int fd;
int own_gbm = 0;
gbm = dpy;
if (gbm == NULL) {
fd = open("/dev/dri/card0", O_RDWR);
/* FIXME: Use an internal constructor to create a gbm
* device with gallium backend directly, without setenv */
setenv("GBM_BACKEND", "gbm_gallium_drm.so", 1);
gbm = gbm_gallium_drm_device(gbm_create_device(fd));
own_gbm = 1;
}
if (gbm == NULL)
return NULL;
if (strcmp(gbm_device_get_backend_name(&gbm->base.base), "drm") != 0 ||
gbm->base.type != GBM_DRM_DRIVER_TYPE_GALLIUM) {
if (own_gbm)
gbm_device_destroy(&gbm->base.base);
return NULL;
}
return drm_create_display(gbm, own_gbm, drm_event_handler);
}
static void
drm_display_destroy(struct native_display *ndpy)
{
struct drm_display *drmdpy = drm_display(ndpy);
if (drmdpy->config)
FREE(drmdpy->config);
drm_display_fini_modeset(&drmdpy->base);
/* gbm owns screen */
ndpy->screen = NULL;
ndpy_uninit(ndpy);
if (drmdpy->device_name)
FREE(drmdpy->device_name);
if (drmdpy->own_gbm) {
gbm_device_destroy(&drmdpy->gbmdrm->base.base);
if (drmdpy->fd >= 0)
close(drmdpy->fd);
}
FREE(drmdpy);
}
static void free_drm_resources(void)
{
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
if (g_encoder)
drmModeFreeEncoder(g_encoder);
if (g_connector)
drmModeFreeConnector(g_connector);
if (g_resources)
drmModeFreeResources(g_resources);
if (g_orig_crtc)
drmModeFreeCrtc(g_orig_crtc);
if (g_drm_fd >= 0)
close(g_drm_fd);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_encoder = NULL;
g_connector = NULL;
g_resources = NULL;
g_orig_crtc = NULL;
g_drm_fd = -1;
}
static void free_drm_resources(gfx_ctx_drm_egl_data_t *drm)
{
if (!drm)
return;
if (drm->g_gbm_surface)
gbm_surface_destroy(drm->g_gbm_surface);
if (drm->g_gbm_dev)
gbm_device_destroy(drm->g_gbm_dev);
if (drm->g_encoder)
drmModeFreeEncoder(drm->g_encoder);
if (drm->g_connector)
drmModeFreeConnector(drm->g_connector);
if (drm->g_resources)
drmModeFreeResources(drm->g_resources);
if (drm->g_orig_crtc)
drmModeFreeCrtc(drm->g_orig_crtc);
if (drm->g_drm_fd >= 0)
close(drm->g_drm_fd);
drm->g_gbm_surface = NULL;
drm->g_gbm_dev = NULL;
drm->g_encoder = NULL;
drm->g_connector = NULL;
drm->g_resources = NULL;
drm->g_orig_crtc = NULL;
drm->g_drm_fd = -1;
}
void egl_destroy(EGLDisplay dpy, EGLContext context)
{
eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(dpy, context);
eglTerminate(dpy);
gbm_device_destroy(gbm);
};
RenderingBackendGBM::~RenderingBackendGBM()
{
if (m_gbm.device)
gbm_device_destroy(m_gbm.device);
if (m_gbm.fd >= 0)
close(m_gbm.fd);
m_gbm = { };
}
PlatformDisplayGBM::~PlatformDisplayGBM()
{
if (m_gbm.device)
gbm_device_destroy(m_gbm.device);
if (m_gbm.fd >= 0)
close(m_gbm.fd);
m_gbm = { -1, nullptr };
}
static gboolean
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
GError **error)
{
CoglRendererEGL *egl_renderer;
CoglRendererKMS *kms_renderer;
renderer->winsys = g_slice_new0 (CoglRendererEGL);
egl_renderer = renderer->winsys;
egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
egl_renderer->platform = g_slice_new0 (CoglRendererKMS);
kms_renderer = egl_renderer->platform;
kms_renderer->fd = open (device_name, O_RDWR);
if (kms_renderer->fd < 0)
{
/* Probably permissions error */
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't open %s", device_name);
return FALSE;
}
kms_renderer->gbm = gbm_create_device (kms_renderer->fd);
if (kms_renderer->gbm == NULL)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't create gbm device");
goto close_fd;
}
egl_renderer->edpy = eglGetDisplay ((EGLNativeDisplayType)kms_renderer->gbm);
if (egl_renderer->edpy == EGL_NO_DISPLAY)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't get eglDisplay");
goto destroy_gbm_device;
}
if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
goto egl_terminate;
return TRUE;
egl_terminate:
eglTerminate (egl_renderer->edpy);
destroy_gbm_device:
gbm_device_destroy (kms_renderer->gbm);
close_fd:
close (kms_renderer->fd);
_cogl_winsys_renderer_disconnect (renderer);
return FALSE;
}
/*!***********************************************************************
@Function OsReleaseOS
@description Destroys main window
*************************************************************************/
void PVRShellInit::OsReleaseOS()
{
gbm_surface_destroy(m_psGbmSurface);
gbm_device_destroy(m_psGbmDev);
drmModeFreeCrtc(m_psDrmCrtc);
drmModeFreeEncoder(m_psDrmEncoder);
drmModeFreeConnector(m_psDrmConnector);
drmModeFreeResources(m_psDrmResources);
drmClose(m_i32DrmFile);
}
Eina_Bool
eng_gbm_shutdown(Evas_Engine_Info_GL_Drm *info)
{
if (!info) return EINA_TRUE;
if (info->info.gbm)
{
gbm_device_destroy(info->info.gbm);
info->info.gbm = NULL;
}
return EINA_TRUE;
}
void CDRMLegacy::DestroyDrmLegacy()
{
CDRMUtils::DestroyDrm();
if(m_gbm->surface)
{
gbm_surface_destroy(m_gbm->surface);
}
if(m_gbm->dev)
{
gbm_device_destroy(m_gbm->dev);
}
}
~Impl() override {
/* destroy framebuffers */
for (auto& framebuffer : framebuffers_) {
glDeleteFramebuffers(1, &framebuffer.gl_fb);
glDeleteTextures(1, &framebuffer.gl_tex);
egl_.DestroyImageKHR(egl_.display, framebuffer.image);
drmModeRmFB(drm_->GetFD(), framebuffer.fb_id);
close(framebuffer.fd);
gbm_bo_destroy(framebuffer.bo);
}
eglDestroyContext(egl_.display, egl_.context);
eglTerminate(egl_.display);
gbm_device_destroy(gbm_);
}
static void
stereo_cleanup_context(struct gbm_context *context)
{
restore_saved_crtc(context->dev);
free_current_bo(context);
eglMakeCurrent(context->edpy,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT);
eglDestroyContext(context->edpy, context->egl_context);
eglDestroySurface(context->edpy, context->egl_surface);
gbm_surface_destroy(context->gbm_surface);
eglTerminate(context->edpy);
gbm_device_destroy(context->gbm);
free(context);
}
int egl_rendernode_init(void)
{
qemu_egl_rn_fd = -1;
qemu_egl_rn_fd = qemu_egl_rendernode_open();
if (qemu_egl_rn_fd == -1) {
error_report("egl: no drm render node available");
goto err;
}
qemu_egl_rn_gbm_dev = gbm_create_device(qemu_egl_rn_fd);
if (!qemu_egl_rn_gbm_dev) {
error_report("egl: gbm_create_device failed");
goto err;
}
qemu_egl_init_dpy((EGLNativeDisplayType)qemu_egl_rn_gbm_dev, false, false);
if (!epoxy_has_egl_extension(qemu_egl_display,
"EGL_KHR_surfaceless_context")) {
error_report("egl: EGL_KHR_surfaceless_context not supported");
goto err;
}
if (!epoxy_has_egl_extension(qemu_egl_display,
"EGL_MESA_image_dma_buf_export")) {
error_report("egl: EGL_MESA_image_dma_buf_export not supported");
goto err;
}
qemu_egl_rn_ctx = qemu_egl_init_ctx();
if (!qemu_egl_rn_ctx) {
error_report("egl: egl_init_ctx failed");
goto err;
}
return 0;
err:
if (qemu_egl_rn_gbm_dev) {
gbm_device_destroy(qemu_egl_rn_gbm_dev);
}
if (qemu_egl_rn_fd != -1) {
close(qemu_egl_rn_fd);
}
return -1;
}
void DisplayOzone::terminate()
{
SafeDelete(mScanning);
SafeDelete(mPending);
SafeDelete(mDrawing);
SafeDelete(mUnused);
if (mProgram)
{
mFunctionsGL->deleteProgram(mProgram);
mFunctionsGL->deleteShader(mVertexShader);
mFunctionsGL->deleteShader(mFragmentShader);
mFunctionsGL->deleteBuffers(1, &mVertexBuffer);
mFunctionsGL->deleteBuffers(1, &mIndexBuffer);
mProgram = 0;
}
DisplayGL::terminate();
if (mContext)
{
// Mesa might crash if you terminate EGL with a context current
// then re-initialize EGL, so make our context not current.
mEGL->makeCurrent(EGL_NO_SURFACE, EGL_NO_CONTEXT);
mEGL->destroyContext(mContext);
mContext = nullptr;
}
SafeDelete(mFunctionsGL);
if (mEGL)
{
mEGL->terminate();
SafeDelete(mEGL);
}
drmModeFreeCrtc(mCRTC);
if (mGBM)
{
int fd = gbm_device_get_fd(mGBM);
gbm_device_destroy(mGBM);
mGBM = nullptr;
close(fd);
}
}
static void
glamor_egl_free_screen(ScrnInfoPtr scrn)
{
struct glamor_egl_screen_private *glamor_egl;
glamor_egl = glamor_egl_get_screen_private(scrn);
if (glamor_egl != NULL) {
eglMakeCurrent(glamor_egl->display,
EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
#ifdef GLAMOR_HAS_GBM
if (glamor_egl->gbm)
gbm_device_destroy(glamor_egl->gbm);
#endif
scrn->FreeScreen = glamor_egl->saved_free_screen;
free(glamor_egl);
scrn->FreeScreen(scrn);
}
}
static DFBResult
system_shutdown( bool emergency )
{
MesaDataShared *shared;
D_ASSERT( m_data != NULL );
shared = m_data->shared;
D_ASSERT( shared != NULL );
dfb_surface_pool_destroy( shared->pool );
if (m_data->saved_crtc) {
drmModeSetCrtc( m_data->fd, m_data->saved_crtc->crtc_id, m_data->saved_crtc->buffer_id, m_data->saved_crtc->x,
m_data->saved_crtc->y, &m_data->connector->connector_id, 1, &m_data->saved_crtc->mode );
drmModeFreeCrtc( m_data->saved_crtc );
}
/* cleanup EGL related stuff */
eglMakeCurrent( m_data->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
eglDestroyContext( m_data->dpy, m_data->ctx );
eglTerminate( m_data->dpy );
if (m_data->resources)
drmModeFreeResources( m_data->resources );
gbm_device_destroy( m_data->gbm );
/* close drm fd */
close( m_data->fd );
if (dfb_config->vt)
dfb_vt_shutdown( emergency );
SHFREE( shared->shmpool, shared );
D_FREE( m_data );
m_data = NULL;
return DFB_OK;
}
static void free_drm_resources(gfx_ctx_drm_data_t *drm)
{
if (!drm)
return;
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
drm_free();
if (g_drm_fd >= 0)
retro_fclose(drm->drm);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_drm_fd = -1;
}
void
NativeStateDRM::cleanup()
{
// Restore CRTC state if necessary
if (crtc_) {
int status = drmModeSetCrtc(fd_, crtc_->crtc_id, crtc_->buffer_id,
crtc_->x, crtc_->y, &connector_->connector_id,
1, &crtc_->mode);
if (status < 0) {
Log::error("Failed to restore original CRTC: %d\n", status);
}
drmModeFreeCrtc(crtc_);
crtc_ = 0;
}
if (surface_) {
gbm_surface_destroy(surface_);
surface_ = 0;
}
if (dev_) {
gbm_device_destroy(dev_);
dev_ = 0;
}
if (connector_) {
drmModeFreeConnector(connector_);
connector_ = 0;
}
if (encoder_) {
drmModeFreeEncoder(encoder_);
encoder_ = 0;
}
if (resources_) {
drmModeFreeResources(resources_);
resources_ = 0;
}
if (fd_ > 0) {
drmClose(fd_);
}
fd_ = 0;
mode_ = 0;
}
QOpenWFDDevice::~QOpenWFDDevice()
{
delete mEventSocketNotifier;
wfdDestroyEvent(mDevice,mEvent);
for (int i = 0; i < mPorts.size(); i++) {
//probably don't need to remove them from the list
QList <WFDint> keys = mUsedPipelines.keys(mPorts.at(i));
for (int keyIndex = 0; keyIndex < keys.size(); keyIndex++) {
mUsedPipelines.remove(keys.at(keyIndex));
}
//but we have to delete them :)
delete mPorts[i];
}
eglDestroyContext(mEglDisplay,mEglContext);
eglTerminate(mEglDisplay);
gbm_device_destroy(mGbmDevice);
wfdDestroyDevice(mDevice);
}
static struct native_display *
native_create_display(void *dpy, boolean use_sw)
{
struct gbm_gallium_drm_device *gbm;
int fd;
int own_gbm = 0;
gbm = dpy;
if (gbm == NULL) {
const char *device_name="/dev/dri/card0";
#ifdef O_CLOEXEC
fd = open(device_name, O_RDWR | O_CLOEXEC);
if (fd == -1 && errno == EINVAL)
#endif
{
fd = open(device_name, O_RDWR);
if (fd != -1)
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
}
/* FIXME: Use an internal constructor to create a gbm
* device with gallium backend directly, without setenv */
setenv("GBM_BACKEND", "gbm_gallium_drm.so", 1);
gbm = gbm_gallium_drm_device(gbm_create_device(fd));
own_gbm = 1;
}
if (gbm == NULL)
return NULL;
if (strcmp(gbm_device_get_backend_name(&gbm->base.base), "drm") != 0 ||
gbm->base.type != GBM_DRM_DRIVER_TYPE_GALLIUM) {
if (own_gbm)
gbm_device_destroy(&gbm->base.base);
return NULL;
}
return drm_create_display(gbm, own_gbm, drm_event_handler);
}
static void drm_egl_uninit(MPGLContext *ctx)
{
struct priv *p = ctx->priv;
crtc_release(ctx);
if (p->vt_switcher_active)
vt_switcher_destroy(&p->vt_switcher);
eglMakeCurrent(p->egl.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(p->egl.display, p->egl.context);
eglDestroySurface(p->egl.display, p->egl.surface);
gbm_surface_destroy(p->gbm.surface);
eglTerminate(p->egl.display);
gbm_device_destroy(p->gbm.device);
p->egl.context = EGL_NO_CONTEXT;
eglDestroyContext(p->egl.display, p->egl.context);
if (p->kms) {
kms_destroy(p->kms);
p->kms = 0;
}
}
static void free_drm_resources(gfx_ctx_drm_data_t *drm)
{
if (!drm)
return;
/* Restore original CRTC. */
drm_restore_crtc();
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
drm_free();
if (drm->drm)
if (g_drm_fd >= 0)
filestream_close(drm->drm);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_drm_fd = -1;
}
int main(int argc, char *argv[])
{
EGLDisplay dpy;
EGLContext ctx;
EGLSurface surface;
EGLConfig config;
EGLint major, minor, n;
const char *ver;
uint32_t handle, stride;
struct kms kms;
int ret, fd;
struct gbm_device *gbm;
struct gbm_bo *bo;
drmModeCrtcPtr saved_crtc;
struct gbm_surface *gs;
fd = open(device_name, O_RDWR);
if (fd < 0) {
/* Probably permissions error */
fprintf(stderr, "couldn't open %s, skipping\n", device_name);
return -1;
}
gbm = gbm_create_device(fd);
if (gbm == NULL) {
fprintf(stderr, "couldn't create gbm device\n");
ret = -1;
goto close_fd;
}
dpy = eglGetDisplay(gbm);
if (dpy == EGL_NO_DISPLAY) {
fprintf(stderr, "eglGetDisplay() failed\n");
ret = -1;
goto destroy_gbm_device;
}
if (!eglInitialize(dpy, &major, &minor)) {
printf("eglInitialize() failed\n");
ret = -1;
goto egl_terminate;
}
ver = eglQueryString(dpy, EGL_VERSION);
printf("EGL_VERSION = %s\n", ver);
if (!setup_kms(fd, &kms)) {
ret = -1;
goto egl_terminate;
}
eglBindAPI(EGL_OPENGL_API);
if (!eglChooseConfig(dpy, attribs, &config, 1, &n) || n != 1) {
fprintf(stderr, "failed to choose argb config\n");
goto egl_terminate;
}
ctx = eglCreateContext(dpy, config, EGL_NO_CONTEXT, NULL);
if (ctx == NULL) {
fprintf(stderr, "failed to create context\n");
ret = -1;
goto egl_terminate;
}
gs = gbm_surface_create(gbm, kms.mode.hdisplay, kms.mode.vdisplay,
GBM_BO_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
surface = eglCreateWindowSurface(dpy, config, gs, NULL);
if (!eglMakeCurrent(dpy, surface, surface, ctx)) {
fprintf(stderr, "failed to make context current\n");
ret = -1;
goto destroy_context;
}
render_stuff(kms.mode.hdisplay, kms.mode.vdisplay);
eglSwapBuffers(dpy, surface);
bo = gbm_surface_lock_front_buffer(gs);
handle = gbm_bo_get_handle(bo).u32;
stride = gbm_bo_get_stride(bo);
printf("handle=%d, stride=%d\n", handle, stride);
ret = drmModeAddFB(fd,
kms.mode.hdisplay, kms.mode.vdisplay,
24, 32, stride, handle, &kms.fb_id);
if (ret) {
fprintf(stderr, "failed to create fb\n");
goto rm_fb;
}
saved_crtc = drmModeGetCrtc(fd, kms.encoder->crtc_id);
if (saved_crtc == NULL)
goto rm_fb;
ret = drmModeSetCrtc(fd, kms.encoder->crtc_id, kms.fb_id, 0, 0,
&kms.connector->connector_id, 1, &kms.mode);
if (ret) {
fprintf(stderr, "failed to set mode: %m\n");
goto free_saved_crtc;
}
getchar();
ret = drmModeSetCrtc(fd, saved_crtc->crtc_id, saved_crtc->buffer_id,
saved_crtc->x, saved_crtc->y,
&kms.connector->connector_id, 1, &saved_crtc->mode);
if (ret) {
fprintf(stderr, "failed to restore crtc: %m\n");
}
free_saved_crtc:
drmModeFreeCrtc(saved_crtc);
rm_fb:
drmModeRmFB(fd, kms.fb_id);
eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
destroy_context:
eglDestroyContext(dpy, ctx);
egl_terminate:
eglTerminate(dpy);
destroy_gbm_device:
gbm_device_destroy(gbm);
close_fd:
close(fd);
return ret;
}
int egl_initialize(EGLDisplay *dpy, EGLConfig *config, EGLContext *context)
{
EGLint major, minor;
int fd;
fd = get_service("DISPLAY");
if(fd == 0)
return -1;
gbm = gbm_create_device(fd);
if( gbm == NULL)
{
DBG("failed to initialize GBM device\n");
goto err_0;
};
*dpy = eglGetDisplay(gbm);
if (!eglInitialize(*dpy, &major, &minor))
{
DBG("failed to initialize EGL display\n");
goto err_1;
};
DBG("EGL_VERSION = %s\n", eglQueryString(*dpy, EGL_VERSION));
DBG("EGL_VENDOR = %s\n", eglQueryString(*dpy, EGL_VENDOR));
DBG("EGL_EXTENSIONS = %s\n", eglQueryString(*dpy, EGL_EXTENSIONS));
DBG("EGL_CLIENT_APIS = %s\n", eglQueryString(*dpy, EGL_CLIENT_APIS));
*config = choose_config(*dpy);
if( *config == NULL)
{
DBG("failed to choose a config\n");
goto err_2;
};
eglBindAPI(EGL_OPENGL_API);
*context = eglCreateContext(*dpy, *config, EGL_NO_CONTEXT, NULL);
if (context == NULL)
{
DBG("failed to create context\n");
goto err_2;
};
if (!eglMakeCurrent(*dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, *context))
{
DBG("failed to make context current");
goto err_3;
};
return 0;
err_3:
eglDestroyContext(*dpy, *context);
err_2:
eglTerminate(*dpy);
err_1:
gbm_device_destroy(gbm);
err_0:
return -1;
};
void gfx_ctx_destroy(void)
{
// Make sure we acknowledge all page-flips.
if (waiting_for_flip)
wait_flip(true);
if (g_egl_dpy)
{
if (g_egl_ctx)
{
eglMakeCurrent(g_egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(g_egl_dpy, g_egl_ctx);
}
if (g_egl_surf)
eglDestroySurface(g_egl_dpy, g_egl_surf);
eglTerminate(g_egl_dpy);
}
// Be as careful as possible in deinit.
// If we screw up, the KMS tty will not restore.
g_egl_ctx = NULL;
g_egl_surf = NULL;
g_egl_dpy = NULL;
g_config = 0;
// Restore original CRTC.
if (g_orig_crtc)
{
drmModeSetCrtc(g_drm_fd, g_orig_crtc->crtc_id,
g_orig_crtc->buffer_id,
g_orig_crtc->x,
g_orig_crtc->y,
&g_connector_id, 1, &g_orig_crtc->mode);
drmModeFreeCrtc(g_orig_crtc);
}
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
if (g_encoder)
drmModeFreeEncoder(g_encoder);
if (g_connector)
drmModeFreeConnector(g_connector);
if (g_resources)
drmModeFreeResources(g_resources);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_encoder = NULL;
g_connector = NULL;
g_resources = NULL;
g_orig_crtc = NULL;
g_drm_mode = NULL;
g_quit = 0;
g_crtc_id = 0;
g_connector_id = 0;
g_fb_width = 0;
g_fb_height = 0;
g_bo = NULL;
g_next_bo = NULL;
if (g_drm_fd >= 0)
close(g_drm_fd);
g_drm_fd = -1;
unsigned frames = last_page_flip - first_page_flip;
if (frames)
{
uint64_t usec = last_usec - first_usec;
RARCH_WARN("[KMS/EGL]: Estimated monitor FPS: %.5f Hz\n", 1000000.0 * frames / usec);
}
RARCH_WARN("[KMS/EGL]: Performance stats: Missed VBlanks: %u, Perfect VBlanks: %u\n",
missed_vblanks, hit_vblanks);
g_inited = false;
}
static void exit_gbm(void)
{
gbm_surface_destroy(gbm.surface);
gbm_device_destroy(gbm.dev);
return;
}
void gfx_ctx_destroy(void)
{
// Make sure we acknowledge all page-flips.
if (waiting_for_flip)
wait_flip(true);
if (g_egl_dpy)
{
if (g_egl_ctx)
{
eglMakeCurrent(g_egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(g_egl_dpy, g_egl_ctx);
}
if (g_egl_surf)
eglDestroySurface(g_egl_dpy, g_egl_surf);
eglTerminate(g_egl_dpy);
}
// Be as careful as possible in deinit.
// If we screw up, the KMS tty will not restore.
g_egl_ctx = NULL;
g_egl_surf = NULL;
g_egl_dpy = NULL;
g_config = 0;
// Restore original CRTC.
if (g_orig_crtc)
{
drmModeSetCrtc(g_drm_fd, g_orig_crtc->crtc_id,
g_orig_crtc->buffer_id,
g_orig_crtc->x,
g_orig_crtc->y,
&g_connector_id, 1, &g_orig_crtc->mode);
drmModeFreeCrtc(g_orig_crtc);
}
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
if (g_encoder)
drmModeFreeEncoder(g_encoder);
if (g_connector)
drmModeFreeConnector(g_connector);
if (g_resources)
drmModeFreeResources(g_resources);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_encoder = NULL;
g_connector = NULL;
g_resources = NULL;
g_orig_crtc = NULL;
g_drm_mode = NULL;
g_quit = 0;
g_crtc_id = 0;
g_connector_id = 0;
g_fb_width = 0;
g_fb_height = 0;
g_bo = NULL;
g_next_bo = NULL;
if (g_drm_fd >= 0)
close(g_drm_fd);
g_drm_fd = -1;
g_inited = false;
}
static CoglBool
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
CoglError **error)
{
CoglRendererEGL *egl_renderer;
CoglRendererKMS *kms_renderer;
renderer->winsys = g_slice_new0 (CoglRendererEGL);
egl_renderer = renderer->winsys;
egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
egl_renderer->platform = g_slice_new0 (CoglRendererKMS);
kms_renderer = egl_renderer->platform;
kms_renderer->fd = -1;
kms_renderer->opened_fd = -1;
if (renderer->kms_fd >= 0)
{
kms_renderer->fd = renderer->kms_fd;
}
else
{
kms_renderer->opened_fd = open (device_name, O_RDWR);
kms_renderer->fd = kms_renderer->opened_fd;
if (kms_renderer->fd < 0)
{
/* Probably permissions error */
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't open %s", device_name);
return FALSE;
}
}
kms_renderer->gbm = gbm_create_device (kms_renderer->fd);
if (kms_renderer->gbm == NULL)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't create gbm device");
goto close_fd;
}
egl_renderer->edpy = eglGetDisplay ((EGLNativeDisplayType)kms_renderer->gbm);
if (egl_renderer->edpy == EGL_NO_DISPLAY)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_INIT,
"Couldn't get eglDisplay");
goto destroy_gbm_device;
}
if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
goto egl_terminate;
_cogl_poll_renderer_add_fd (renderer,
kms_renderer->fd,
COGL_POLL_FD_EVENT_IN,
NULL, /* no prepare callback */
dispatch_kms_events,
renderer);
return TRUE;
egl_terminate:
eglTerminate (egl_renderer->edpy);
destroy_gbm_device:
gbm_device_destroy (kms_renderer->gbm);
close_fd:
if (kms_renderer->opened_fd >= 0)
close (kms_renderer->opened_fd);
_cogl_winsys_renderer_disconnect (renderer);
return FALSE;
}
mggh::GBMHelper::~GBMHelper()
{
if (device)
gbm_device_destroy(device);
}
