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;
}
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;
}
RenderingBackendGBM::Surface::~Surface()
{
for (auto& it : m_lockedBuffers)
m_client.destroyBuffer(it.first);
if (m_surface)
gbm_surface_destroy(m_surface);
}
void CGBMUtils::DestroyGbm(struct gbm *gbm)
{
if(gbm->surface)
{
gbm_surface_destroy(gbm->surface);
}
gbm->surface = nullptr;
}
/*!***********************************************************************
@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);
}
QKmsScreen::~QKmsScreen()
{
delete m_cursor;
drmModeSetCrtc(m_device->fd(), m_oldCrtc->crtc_id, m_oldCrtc->buffer_id,
m_oldCrtc->x, m_oldCrtc->y,
&m_connectorId, 1, &m_oldCrtc->mode);
drmModeFreeCrtc(m_oldCrtc);
if (m_eglWindowSurface != EGL_NO_SURFACE)
eglDestroySurface(m_device->eglDisplay(), m_eglWindowSurface);
gbm_surface_destroy(m_gbmSurface);
}
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);
}
}
mgg::GBMSurfaceUPtr mggh::GBMHelper::create_scanout_surface(uint32_t width, uint32_t height)
{
auto surface_raw = gbm_surface_create(device, width, height,
GBM_BO_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
auto gbm_surface_deleter = [](gbm_surface *p) { if (p) gbm_surface_destroy(p); };
GBMSurfaceUPtr surface{surface_raw, gbm_surface_deleter};
if (!surface)
BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create GBM scanout surface"));
return surface;
}
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);
}
void QEglFSKmsGbmScreen::destroySurface()
{
if (m_gbm_bo_current) {
gbm_bo_destroy(m_gbm_bo_current);
m_gbm_bo_current = Q_NULLPTR;
}
if (m_gbm_bo_next) {
gbm_bo_destroy(m_gbm_bo_next);
m_gbm_bo_next = Q_NULLPTR;
}
if (m_gbm_surface) {
gbm_surface_destroy(m_gbm_surface);
m_gbm_surface = Q_NULLPTR;
}
}
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;
}
static void
_cogl_winsys_egl_cleanup_context (CoglDisplay *display)
{
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
if (egl_display->dummy_surface != EGL_NO_SURFACE)
{
eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface);
egl_display->dummy_surface = EGL_NO_SURFACE;
}
if (kms_display->dummy_gbm_surface != NULL)
{
gbm_surface_destroy (kms_display->dummy_gbm_surface);
kms_display->dummy_gbm_surface = NULL;
}
}
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;
}
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
_cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenKMS *kms_onscreen;
/* If we never successfully allocated then there's nothing to do */
if (egl_onscreen == NULL)
return;
kms_onscreen = egl_onscreen->platform;
/* flip state takes a reference on the onscreen so there should
* never be outstanding flips when we reach here. */
g_return_if_fail (kms_onscreen->next_fb_id == 0);
free_current_bo (onscreen);
if (egl_onscreen->egl_surface != EGL_NO_SURFACE)
{
eglDestroySurface (egl_renderer->edpy, egl_onscreen->egl_surface);
egl_onscreen->egl_surface = EGL_NO_SURFACE;
}
if (kms_onscreen->surface)
{
gbm_surface_destroy (kms_onscreen->surface);
kms_onscreen->surface = NULL;
}
g_slice_free (CoglOnscreenKMS, kms_onscreen);
g_slice_free (CoglOnscreenEGL, onscreen->winsys);
onscreen->winsys = NULL;
}
static int
evgl_eng_native_window_destroy(void *data, void *native_window)
{
Render_Engine *re = (Render_Engine *)data;
if (!re)
{
ERR("Invalid Render Engine Data!");
return 0;
}
if (!native_window)
{
ERR("Inavlid native surface.");
return 0;
}
gbm_surface_destroy((struct gbm_surface *)native_window);
native_window = NULL;
return 1;
}
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;
}
static struct gbm_context *
stereo_prepare_context(struct gbm_dev *dev,
const struct gbm_options *options)
{
struct gbm_context *context;
EGLint multiview_view_count = 0;
context = xmalloc(sizeof(*context));
context->dev = dev;
context->gbm = gbm_create_device(dev->fd);
if (context->gbm == NULL) {
fprintf(stderr, "error creating GBM device\n");
goto error;
}
context->edpy = eglGetDisplay((EGLNativeDisplayType) context->gbm);
if (context->edpy == EGL_NO_DISPLAY) {
fprintf(stderr, "error getting EGL display\n");
goto error_gbm_device;
}
if (!eglInitialize(context->edpy, NULL, NULL)) {
fprintf(stderr, "error intializing EGL display\n");
goto error_gbm_device;
}
if (!extension_supported(context->edpy, MULTIVIEW_WINDOW_EXTENSION)) {
fprintf(stderr, MULTIVIEW_WINDOW_EXTENSION " not supported\n");
goto error_egl_display;
}
if (create_gbm_surface(context))
goto error_egl_display;
if (choose_egl_config(context))
goto error_gbm_surface;
if (create_egl_surface(context, options))
goto error_gbm_surface;
if (create_egl_context(context))
goto error_egl_surface;
if (!eglMakeCurrent(context->edpy,
context->egl_surface,
context->egl_surface,
context->egl_context)) {
fprintf(stderr, "failed to make EGL context current\n");
goto error_egl_context;
}
if ((!eglQueryContext(context->edpy,
context->egl_context,
EGL_MULTIVIEW_VIEW_COUNT_EXT,
&multiview_view_count) ||
multiview_view_count < 2)) {
fprintf(stderr,
"EGL created a multiview surface with only %i %s\n",
multiview_view_count,
multiview_view_count == 1 ? "view" : "views");
goto error_unbind;
}
return context;
error_unbind:
eglMakeCurrent(context->edpy,
EGL_NO_SURFACE, EGL_NO_SURFACE,
EGL_NO_CONTEXT);
error_egl_context:
eglDestroyContext(context->edpy, context->egl_context);
error_egl_surface:
eglDestroySurface(context->edpy, context->egl_surface);
error_gbm_surface:
gbm_surface_destroy(context->gbm_surface);
error_egl_display:
eglTerminate(context->edpy);
error_gbm_device:
gbm_device_destroy(context->gbm);
error:
free(context);
return NULL;
}
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;
}
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;
}
RenderingBackendGBM::OffscreenSurface::~OffscreenSurface()
{
gbm_surface_destroy(m_surface);
}
virtual ~OffscreenContextData()
{
gbm_surface_destroy(surface);
}
void QEglFSKmsIntegration::destroyNativeWindow(EGLNativeWindowType window)
{
gbm_surface *surface = reinterpret_cast<gbm_surface *>(window);
gbm_surface_destroy(surface);
}
int main(int argc, char *argv[])
{
EGLDisplay dpy;
EGLContext ctx;
EGLConfig config;
EGLSurface surface;
EGLint major, minor, n;
const char *ver;
uint32_t handle, stride;
int ret, fd, frames = 0;
struct gbm_device *gbm;
drmModeCrtcPtr saved_crtc;
time_t start, end;
char *data;
char j;
int i;
int once;
once = 0;
signal (SIGINT, quit_handler);
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);
if (gs == NULL) {
fprintf(stderr, "unable to create gbm surface\n");
ret = -1;
goto egl_terminate;
}
surface = eglCreateWindowSurface(dpy, config, gs, NULL);
if (surface == EGL_NO_SURFACE) {
fprintf(stderr, "failed to create surface\n");
ret = -1;
goto destroy_gbm_surface;
}
if (!eglMakeCurrent(dpy, surface, surface, ctx)) {
fprintf(stderr, "failed to make context current\n");
ret = -1;
goto destroy_surface;
}
saved_crtc = drmModeGetCrtc(fd, kms.crtc_id);
if (saved_crtc == NULL)
{
fprintf(stderr, "no valid graphic configuration active (VT ?)\n");
}
time(&start);
do {
drmEventContext evctx;
fd_set rfds;
render_stuff(kms.mode.hdisplay, kms.mode.vdisplay);
eglSwapBuffers(dpy, surface);
if (!gbm_surface_has_free_buffers(gs))
fprintf(stderr, "out of free buffers\n");
next_bo = gbm_surface_lock_front_buffer(gs);
if (!next_bo)
fprintf(stderr, "failed to lock front buffer: %m\n");
handle = gbm_bo_get_handle(next_bo).u32;
stride = gbm_bo_get_stride(next_bo);
ret = drmModeAddFB(fd,
kms.mode.hdisplay, kms.mode.vdisplay,
24, 32, stride, handle, &next_fb_id);
if (ret) {
fprintf(stderr, "failed to create fb\n");
goto out;
}
/* make sure to setup crtc once (fix for broken drivers) */
if(once == 0){
once = 1;
drmModeSetCrtc(fd, kms.crtc_id, next_fb_id,
0, 0,
&kms.connector->connector_id, 1, &kms.mode);
}
ret = drmModePageFlip(fd, kms.crtc_id,
next_fb_id,
DRM_MODE_PAGE_FLIP_EVENT, 0);
if (ret) {
fprintf(stderr, "failed to page flip: %m\n");
goto out;
}
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
while (select(fd + 1, &rfds, NULL, NULL, NULL) == -1)
NULL;
memset(&evctx, 0, sizeof evctx);
evctx.version = DRM_EVENT_CONTEXT_VERSION;
evctx.page_flip_handler = page_flip_handler;
drmHandleEvent(fd, &evctx);
frames++;
} while (!quit);
time(&end);
printf("Frames per second: %.2lf\n", frames / difftime(end, start));
out:
if(saved_crtc){
drmModeSetCrtc(fd, saved_crtc->crtc_id, saved_crtc->buffer_id,
saved_crtc->x, saved_crtc->y,
&kms.connector->connector_id, 1, &saved_crtc->mode);
}
drmModeFreeCrtc(saved_crtc);
if (current_fb_id)
drmModeRmFB(fd, current_fb_id);
if (next_fb_id)
drmModeRmFB(fd, next_fb_id);
eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
destroy_context:
eglDestroyContext(dpy, ctx);
destroy_surface:
eglDestroySurface(dpy, surface);
destroy_gbm_surface:
gbm_surface_destroy(gs);
egl_terminate:
eglTerminate(dpy);
destroy_gbm_device:
gbm_device_destroy(gbm);
close_fd:
close(fd);
return ret;
}