static int dri2_drm_authenticate(_EGLDisplay *disp, uint32_t id) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); return drmAuthMagic(dri2_dpy->fd, id); }
static EGLBoolean dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, EGLint numRects, const EGLint *rects) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); EGLBoolean ret; xcb_xfixes_region_t region; xcb_rectangle_t rectangles[16]; if (numRects > (int)ARRAY_SIZE(rectangles)) return dri2_copy_region(drv, disp, draw, dri2_surf->region); for (int i = 0; i < numRects; i++) { rectangles[i].x = rects[i * 4]; rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3]; rectangles[i].width = rects[i * 4 + 2]; rectangles[i].height = rects[i * 4 + 3]; } region = xcb_generate_id(dri2_dpy->conn); xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles); ret = dri2_copy_region(drv, disp, draw, region); xcb_xfixes_destroy_region(dri2_dpy->conn, region); return ret; }
static _EGLImage * dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx, EGLClientBuffer buffer, const EGLint *attr_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct gbm_dri_bo *dri_bo = gbm_dri_bo((struct gbm_bo *) buffer); struct dri2_egl_image *dri2_img; dri2_img = malloc(sizeof *dri2_img); if (!dri2_img) { _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap"); return NULL; } if (!_eglInitImage(&dri2_img->base, disp)) { free(dri2_img); return NULL; } dri2_img->dri_image = dri2_dpy->image->dupImage(dri_bo->image, dri2_img); if (dri2_img->dri_image == NULL) { free(dri2_img); _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap"); return NULL; } return &dri2_img->base; }
static EGLBoolean droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) { struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv); struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); _EGLContext *ctx; if (dri2_surf->base.Type != EGL_WINDOW_BIT) return EGL_TRUE; if (dri2_drv->glFlush) { ctx = _eglGetCurrentContext(); if (ctx && ctx->DrawSurface == &dri2_surf->base) dri2_drv->glFlush(); } (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable); if (dri2_surf->buffer) droid_window_enqueue_buffer(dri2_surf); (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable); return EGL_TRUE; }
static EGLBoolean dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); int i; if (!_eglPutSurface(surf)) return EGL_TRUE; (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable); for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) { if (dri2_surf->color_buffers[i].bo) gbm_bo_destroy(dri2_surf->color_buffers[i].bo); } for (i = 0; i < __DRI_BUFFER_COUNT; i++) { if (dri2_surf->dri_buffers[i]) dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen, dri2_surf->dri_buffers[i]); } free(surf); return EGL_TRUE; }
static __DRIbuffer * dri2_get_buffers_with_format(__DRIdrawable * driDrawable, int *width, int *height, unsigned int *attachments, int count, int *out_count, void *loaderPrivate) { struct dri2_egl_surface *dri2_surf = loaderPrivate; struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); xcb_dri2_dri2_buffer_t *buffers; xcb_dri2_get_buffers_with_format_reply_t *reply; xcb_dri2_get_buffers_with_format_cookie_t cookie; xcb_dri2_attach_format_t *format_attachments; format_attachments = (xcb_dri2_attach_format_t *) attachments; cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn, dri2_surf->drawable, count, count, format_attachments); reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn, cookie, NULL); if (reply == NULL) return NULL; buffers = xcb_dri2_get_buffers_with_format_buffers (reply); dri2_surf->base.Width = *width = reply->width; dri2_surf->base.Height = *height = reply->height; *out_count = reply->count; dri2_process_buffers(dri2_surf, buffers, *out_count); free(reply); return dri2_surf->buffers; }
static EGLBoolean dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, xcb_xfixes_region_t region) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); enum xcb_dri2_attachment_t render_attachment; xcb_dri2_copy_region_cookie_t cookie; /* No-op for a pixmap or pbuffer surface */ if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT) return EGL_TRUE; dri2_dpy->flush->flush(dri2_surf->dri_drawable); if (dri2_surf->have_fake_front) render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT; else render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT; cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn, dri2_surf->drawable, region, XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT, render_attachment); free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL)); return EGL_TRUE; }
static EGLBoolean dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); (void) drv; dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable); if (dri2_dpy->dri2) { xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable); } else { assert(dri2_dpy->swrast); swrastDestroyDrawable(dri2_dpy, dri2_surf); } if (surf->Type == EGL_PBUFFER_BIT) xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable); dri2_fini_surface(surf); free(surf); return EGL_TRUE; }
static int dri2_x11_authenticate(_EGLDisplay *disp, uint32_t id) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); return dri2_x11_do_authenticate(dri2_dpy, id); }
static void swrastGetImage(__DRIdrawable * read, int x, int y, int w, int h, char *data, void *loaderPrivate) { struct dri2_egl_surface *dri2_surf = loaderPrivate; struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); xcb_get_image_cookie_t cookie; xcb_get_image_reply_t *reply; xcb_generic_error_t *error; cookie = xcb_get_image (dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP, dri2_surf->drawable, x, y, w, h, ~0); reply = xcb_get_image_reply (dri2_dpy->conn, cookie, &error); if (reply == NULL) return; if (error != NULL) { _eglLog(_EGL_WARNING, "error in xcb_get_image"); free(error); } else { uint32_t bytes = xcb_get_image_data_length(reply); uint8_t *idata = xcb_get_image_data(reply); memcpy(data, idata, bytes); } free(reply); }
static void swrastPutImage(__DRIdrawable * draw, int op, int x, int y, int w, int h, char *data, void *loaderPrivate) { struct dri2_egl_surface *dri2_surf = loaderPrivate; struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); xcb_gcontext_t gc; switch (op) { case __DRI_SWRAST_IMAGE_OP_DRAW: gc = dri2_surf->gc; break; case __DRI_SWRAST_IMAGE_OP_SWAP: gc = dri2_surf->swapgc; break; default: return; } xcb_put_image(dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP, dri2_surf->drawable, gc, w, h, x, y, 0, dri2_surf->depth, w*h*dri2_surf->bytes_per_pixel, (const uint8_t *)data); }
static bool x11_get_drawable_info(__DRIdrawable * draw, int *x, int *y, int *w, int *h, void *loaderPrivate) { struct dri2_egl_surface *dri2_surf = loaderPrivate; struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); xcb_get_geometry_cookie_t cookie; xcb_get_geometry_reply_t *reply; xcb_generic_error_t *error; bool ret; cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable); reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error); if (reply == NULL) return false; if (error != NULL) { ret = false; _eglLog(_EGL_WARNING, "error in xcb_get_geometry"); free(error); } else { *x = reply->x; *y = reply->y; *w = reply->width; *h = reply->height; ret = true; } free(reply); return ret; }
static EGLBoolean dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, void *native_pixmap_target) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); xcb_gcontext_t gc; xcb_pixmap_t target; STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target)); target = (uintptr_t) native_pixmap_target; (void) drv; dri2_dpy->flush->flush(dri2_surf->dri_drawable); gc = xcb_generate_id(dri2_dpy->conn); xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL); xcb_copy_area(dri2_dpy->conn, dri2_surf->drawable, target, gc, 0, 0, 0, 0, dri2_surf->base.Width, dri2_surf->base.Height); xcb_free_gc(dri2_dpy->conn, gc); return EGL_TRUE; }
static _EGLSurface * droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, _EGLConfig *conf, EGLNativeWindowType window, const EGLint *attrib_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_config *dri2_conf = dri2_egl_config(conf); struct dri2_egl_surface *dri2_surf; dri2_surf = calloc(1, sizeof *dri2_surf); if (!dri2_surf) { _eglError(EGL_BAD_ALLOC, "droid_create_surface"); return NULL; } if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list)) goto cleanup_surface; if (type == EGL_WINDOW_BIT) { int format; if (!window || window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) { _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface"); goto cleanup_surface; } if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) { _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface"); goto cleanup_surface; } if (format != dri2_conf->base.NativeVisualID) { _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x", format, dri2_conf->base.NativeVisualID); } window->query(window, NATIVE_WINDOW_WIDTH, &dri2_surf->base.Width); window->query(window, NATIVE_WINDOW_HEIGHT, &dri2_surf->base.Height); } dri2_surf->dri_drawable = (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen, dri2_conf->dri_double_config, dri2_surf); if (dri2_surf->dri_drawable == NULL) { _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable"); goto cleanup_surface; } if (window) { window->common.incRef(&window->common); dri2_surf->window = window; } return &dri2_surf->base; cleanup_surface: free(dri2_surf); return NULL; }
static void surfaceless_free_images(struct dri2_egl_surface *dri2_surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); if (dri2_surf->front) { dri2_dpy->image->destroyImage(dri2_surf->front); dri2_surf->front = NULL; } }
static EGLBoolean dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint interval) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); if (dri2_dpy->swap_available) xcb_dri2_swap_interval(dri2_dpy->conn, dri2_surf->drawable, interval); return EGL_TRUE; }
static _EGLSurface * dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, _EGLConfig *conf, EGLNativeWindowType window, const EGLint *attrib_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_config *dri2_conf = dri2_egl_config(conf); struct dri2_egl_surface *dri2_surf; struct gbm_dri_surface *surf; (void) drv; dri2_surf = malloc(sizeof *dri2_surf); if (!dri2_surf) { _eglError(EGL_BAD_ALLOC, "dri2_create_surface"); return NULL; } memset(dri2_surf, 0, sizeof *dri2_surf); if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list)) goto cleanup_surf; switch (type) { case EGL_WINDOW_BIT: if (!window) return NULL; surf = gbm_dri_surface((struct gbm_surface *) window); dri2_surf->gbm_surf = surf; dri2_surf->base.Width = surf->base.width; dri2_surf->base.Height = surf->base.height; surf->dri_private = dri2_surf; break; default: goto cleanup_surf; } dri2_surf->dri_drawable = (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen, dri2_conf->dri_double_config, dri2_surf->gbm_surf); if (dri2_surf->dri_drawable == NULL) { _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable"); goto cleanup_surf; } return &dri2_surf->base; cleanup_surf: free(dri2_surf); return NULL; }
static int64_t dri2_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, int64_t msc, int64_t divisor, int64_t remainder) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); uint32_t msc_hi = msc >> 32; uint32_t msc_lo = msc & 0xffffffff; uint32_t divisor_hi = divisor >> 32; uint32_t divisor_lo = divisor & 0xffffffff; uint32_t remainder_hi = remainder >> 32; uint32_t remainder_lo = remainder & 0xffffffff; xcb_dri2_swap_buffers_cookie_t cookie; xcb_dri2_swap_buffers_reply_t *reply; int64_t swap_count = -1; /* No-op for a pixmap or pbuffer surface */ if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT) return 0; if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) return dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1; if (dri2_dpy->flush) (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable); cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn, dri2_surf->drawable, msc_hi, msc_lo, divisor_hi, divisor_lo, remainder_hi, remainder_lo); reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL); if (reply) { swap_count = (((int64_t)reply->swap_hi) << 32) | reply->swap_lo; free(reply); } /* Since we aren't watching for the server's invalidate events like we're * supposed to (due to XCB providing no mechanism for filtering the events * the way xlib does), and SwapBuffers is a common cause of invalidate * events, just shove one down to the driver, even though we haven't told * the driver that we're the kind of loader that provides reliable * invalidate events. This causes the driver to request buffers again at * its next draw, so that we get the correct buffers if a pageflip * happened. The driver should still be using the viewport hack to catch * window resizes. */ if (dri2_dpy->flush && dri2_dpy->flush->base.version >= 3 && dri2_dpy->flush->invalidate) (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable); return swap_count; }
static EGLBoolean surfaceless_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy); unsigned int visuals[3][4] = { { 0xff0000, 0xff00, 0xff, 0xff000000 }, // ARGB8888 { 0xff0000, 0xff00, 0xff, 0x0 }, // RGB888 { 0xf800, 0x7e0, 0x1f, 0x0 }, // RGB565 }; int count, i, j; unsigned int r, b, g, a; count = 0; for (i = 0; i < ARRAY_SIZE(visuals); i++) { for (j = 0; dri2_dpy->driver_configs[j]; j++) { const EGLint surface_type = EGL_PBUFFER_BIT; struct dri2_egl_config *dri2_conf; /* Determine driver supported masks */ dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[j], __DRI_ATTRIB_RED_MASK, &r); dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[j], __DRI_ATTRIB_BLUE_MASK, &b); dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[j], __DRI_ATTRIB_GREEN_MASK, &g); dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[j], __DRI_ATTRIB_ALPHA_MASK, &a); /* Compare with advertised visuals */ if (r ^ visuals[i][0] || g ^ visuals[i][1] || b ^ visuals[i][2] || a ^ visuals[i][3]) continue; dri2_conf = dri2_add_config(dpy, dri2_dpy->driver_configs[j], count + 1, surface_type, NULL, visuals[i]); if (dri2_conf) count++; } } if (!count) _eglLog(_EGL_DEBUG, "Can't create surfaceless visuals"); return (count != 0); }
static _EGLSurface * dri2_surfaceless_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, _EGLConfig *conf, const EGLint *attrib_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_config *dri2_conf = dri2_egl_config(conf); struct dri2_egl_surface *dri2_surf; const __DRIconfig *config; /* Make sure to calloc so all pointers * are originally NULL. */ dri2_surf = calloc(1, sizeof *dri2_surf); if (!dri2_surf) { _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface"); return NULL; } if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list)) goto cleanup_surface; config = dri2_get_dri_config(dri2_conf, type, dri2_surf->base.GLColorspace); if (!config) goto cleanup_surface; dri2_surf->dri_drawable = (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen, config, dri2_surf); if (dri2_surf->dri_drawable == NULL) { _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable"); goto cleanup_surface; } if (conf->RedSize == 5) dri2_surf->visual = __DRI_IMAGE_FORMAT_RGB565; else if (conf->AlphaSize == 0) dri2_surf->visual = __DRI_IMAGE_FORMAT_XRGB8888; else dri2_surf->visual = __DRI_IMAGE_FORMAT_ARGB8888; return &dri2_surf->base; cleanup_surface: free(dri2_surf); return NULL; }
static void droid_free_local_buffers(struct dri2_egl_surface *dri2_surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); int i; for (i = 0; i < ARRAY_SIZE(dri2_surf->local_buffers); i++) { if (dri2_surf->local_buffers[i]) { dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen, dri2_surf->local_buffers[i]); dri2_surf->local_buffers[i] = NULL; } } }
static EGLBoolean dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); if (dri2_dpy->dri2) { return dri2_swap_buffers_msc(drv, disp, draw, 0, 0, 0) != -1; } else { assert(dri2_dpy->swrast); dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable); return EGL_TRUE; } }
static struct wl_buffer * wayland_create_buffer(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); struct wl_buffer *buf; buf = wl_drm_create_buffer(dri2_dpy->wl_drm, buffer->name, dri2_surf->base.Width, dri2_surf->base.Height, buffer->pitch, dri2_surf->format); wl_buffer_add_listener(buf, &wl_buffer_listener, dri2_surf); return buf; }
static EGLBoolean surfaceless_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); if (!_eglPutSurface(surf)) return EGL_TRUE; surfaceless_free_images(dri2_surf); (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable); free(dri2_surf); return EGL_TRUE; }
/** * Called via eglCreateImageKHR(), drv->API.CreateImageKHR(). */ static _EGLImage * dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx, EGLClientBuffer buffer, const EGLint *attr_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct wl_egl_pixmap *wl_egl_pixmap = (struct wl_egl_pixmap *) buffer; struct dri2_egl_buffer *dri2_buf; EGLint wl_attr_list[] = { EGL_WIDTH, 0, EGL_HEIGHT, 0, EGL_DRM_BUFFER_STRIDE_MESA, 0, EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA, EGL_NONE }; dri2_buf = malloc(sizeof *dri2_buf); if (!dri2_buf) return NULL; dri2_buf->dri2_dpy = dri2_dpy; dri2_buf->dri_buffer = dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen, __DRI_BUFFER_FRONT_LEFT, 32, wl_egl_pixmap->width, wl_egl_pixmap->height); wl_egl_pixmap->destroy = dri2_wl_egl_pixmap_destroy; wl_egl_pixmap->driver_private = dri2_buf; /* FIXME: Get buffer format from attr_list somehow... or from the wl_egl_piaxmap. */ wl_egl_pixmap->buffer = wl_drm_create_buffer(dri2_dpy->wl_drm, dri2_buf->dri_buffer->name, wl_egl_pixmap->width, wl_egl_pixmap->height, dri2_buf->dri_buffer->pitch, WL_DRM_FORMAT_PREMULTIPLIED_ARGB32); wl_attr_list[1] = wl_egl_pixmap->width; wl_attr_list[3] = wl_egl_pixmap->height; wl_attr_list[5] = dri2_buf->dri_buffer->pitch / 4; return dri2_create_image_khr(disp->Driver, disp, ctx, EGL_DRM_BUFFER_MESA, (EGLClientBuffer)(intptr_t) dri2_buf->dri_buffer->name, wl_attr_list); }
static _EGLImage * droid_create_image_from_name(_EGLDisplay *disp, _EGLContext *ctx, struct ANativeWindowBuffer *buf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_image *dri2_img; int name; int format; name = get_native_buffer_name(buf); if (!name) { _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR"); return NULL; } format = get_format(buf->format); if (format == -1) return NULL; dri2_img = calloc(1, sizeof(*dri2_img)); if (!dri2_img) { _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm"); return NULL; } if (!_eglInitImage(&dri2_img->base, disp)) { free(dri2_img); return NULL; } dri2_img->dri_image = dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen, buf->width, buf->height, format, name, buf->stride, dri2_img); if (!dri2_img->dri_image) { free(dri2_img); _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm"); return NULL; } return &dri2_img->base; }
static int get_back_bo(struct dri2_egl_surface *dri2_surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); int fourcc, pitch; int offset = 0, fd; if (dri2_surf->dri_image) return 0; if (!dri2_surf->buffer) return -1; fd = get_native_buffer_fd(dri2_surf->buffer); if (fd < 0) { _eglLog(_EGL_WARNING, "Could not get native buffer FD"); return -1; } fourcc = get_fourcc(dri2_surf->buffer->format); pitch = dri2_surf->buffer->stride * get_format_bpp(dri2_surf->buffer->format); if (fourcc == -1 || pitch == 0) { _eglLog(_EGL_WARNING, "Invalid buffer fourcc(%x) or pitch(%d)", fourcc, pitch); return -1; } dri2_surf->dri_image = dri2_dpy->image->createImageFromFds(dri2_dpy->dri_screen, dri2_surf->base.Width, dri2_surf->base.Height, fourcc, &fd, 1, &pitch, &offset, dri2_surf); if (!dri2_surf->dri_image) return -1; return 0; }
static EGLBoolean dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); if (!dri2_dpy->flush) { dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable); return EGL_TRUE; } if (dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) == -1) { /* Swap failed with a window drawable. */ return _eglError(EGL_BAD_NATIVE_WINDOW, __func__); } return EGL_TRUE; }
static int get_back_bo(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); struct gbm_dri_bo *bo; struct gbm_dri_surface *surf = dri2_surf->gbm_surf; int i, name, pitch; if (dri2_surf->back == NULL) { for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) { if(dri2_surf->color_buffers[i].locked) { dri2_surf->color_buffers[i].locked = 0; continue; } dri2_surf->back = &dri2_surf->color_buffers[i]; } } if (dri2_surf->back == NULL) return -1; if (dri2_surf->back->bo == NULL) dri2_surf->back->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base.base, surf->base.width, surf->base.height, surf->base.format, surf->base.flags); if (dri2_surf->back->bo == NULL) return -1; bo = (struct gbm_dri_bo *) dri2_surf->back->bo; dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_NAME, &name); dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch); buffer->attachment = __DRI_BUFFER_BACK_LEFT; buffer->name = name; buffer->pitch = pitch; buffer->cpp = 4; buffer->flags = 0; dri2_surf->back->locked = 1; return 0; }
static __DRIbuffer * droid_alloc_local_buffer(struct dri2_egl_surface *dri2_surf, unsigned int att, unsigned int format) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display); if (att >= ARRAY_SIZE(dri2_surf->local_buffers)) return NULL; if (!dri2_surf->local_buffers[att]) { dri2_surf->local_buffers[att] = dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen, att, format, dri2_surf->base.Width, dri2_surf->base.Height); } return dri2_surf->local_buffers[att]; }