if (double_buffer) {
surface_type &= ~EGL_PIXMAP_BIT;
- if (dri2_dpy->swap_available) {
- conf->base.MinSwapInterval = 0;
- conf->base.MaxSwapInterval = 1000; /* XXX arbitrary value */
- }
+ conf->base.MinSwapInterval = dri2_dpy->min_swap_interval;
+ conf->base.MaxSwapInterval = dri2_dpy->max_swap_interval;
}
conf->base.SurfaceType |= surface_type;
api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
} else {
assert(dri2_dpy->swrast);
- api_mask = 1 << __DRI_API_OPENGL | 1 << __DRI_API_GLES | 1 << __DRI_API_GLES2;
+ api_mask = 1 << __DRI_API_OPENGL |
+ 1 << __DRI_API_GLES |
+ 1 << __DRI_API_GLES2 |
+ 1 << __DRI_API_GLES3;
}
disp->ClientAPIs = 0;
disp->ClientAPIs |= EGL_OPENGL_ES_BIT;
if (api_mask & (1 << __DRI_API_GLES2))
disp->ClientAPIs |= EGL_OPENGL_ES2_BIT;
+ if (api_mask & (1 << __DRI_API_GLES3))
+ disp->ClientAPIs |= EGL_OPENGL_ES3_BIT_KHR;
assert(dri2_dpy->dri2 || dri2_dpy->swrast);
disp->Extensions.KHR_surfaceless_context = EGL_TRUE;
disp->Extensions.MESA_drm_image = EGL_TRUE;
disp->Extensions.KHR_image_base = EGL_TRUE;
disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
+ if (dri2_dpy->image->base.version >= 5 &&
+ dri2_dpy->image->createImageFromTexture) {
+ disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
+ disp->Extensions.KHR_gl_texture_cubemap_image = EGL_TRUE;
+ }
}
}
if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0) {
dri2_dpy->robustness = (__DRIrobustnessExtension *) extensions[i];
}
+ if (strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0) {
+ dri2_dpy->config = (__DRI2configQueryExtension *) extensions[i];
+ }
}
} else {
assert(dri2_dpy->swrast);
close(dri2_dpy->fd);
if (dri2_dpy->driver)
dlclose(dri2_dpy->driver);
- if (dri2_dpy->device_name)
- free(dri2_dpy->device_name);
+ free(dri2_dpy->device_name);
if (disp->PlatformDisplay == NULL) {
switch (disp->Platform) {
return EGL_TRUE;
}
+/**
+ * Set the error code after a call to
+ * dri2_egl_display::dri2::createContextAttribs.
+ */
+static void
+dri2_create_context_attribs_error(int dri_error)
+{
+ EGLint egl_error;
+
+ switch (dri_error) {
+ case __DRI_CTX_ERROR_SUCCESS:
+ return;
+
+ case __DRI_CTX_ERROR_NO_MEMORY:
+ egl_error = EGL_BAD_ALLOC;
+ break;
+
+ /* From the EGL_KHR_create_context spec, section "Errors":
+ *
+ * * If <config> does not support a client API context compatible
+ * with the requested API major and minor version, [...] context flags,
+ * and context reset notification behavior (for client API types where
+ * these attributes are supported), then an EGL_BAD_MATCH error is
+ * generated.
+ *
+ * * If an OpenGL ES context is requested and the values for
+ * attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
+ * EGL_CONTEXT_MINOR_VERSION_KHR specify an OpenGL ES version that
+ * is not defined, than an EGL_BAD_MATCH error is generated.
+ *
+ * * If an OpenGL context is requested, the requested version is
+ * greater than 3.2, and the value for attribute
+ * EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR has no bits set; has any
+ * bits set other than EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR and
+ * EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; has more than
+ * one of these bits set; or if the implementation does not support
+ * the requested profile, then an EGL_BAD_MATCH error is generated.
+ */
+ case __DRI_CTX_ERROR_BAD_API:
+ case __DRI_CTX_ERROR_BAD_VERSION:
+ case __DRI_CTX_ERROR_BAD_FLAG:
+ egl_error = EGL_BAD_MATCH;
+ break;
+
+ /* From the EGL_KHR_create_context spec, section "Errors":
+ *
+ * * If an attribute name or attribute value in <attrib_list> is not
+ * recognized (including unrecognized bits in bitmask attributes),
+ * then an EGL_BAD_ATTRIBUTE error is generated."
+ */
+ case __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE:
+ case __DRI_CTX_ERROR_UNKNOWN_FLAG:
+ egl_error = EGL_BAD_ATTRIBUTE;
+ break;
+
+ default:
+ assert(0);
+ egl_error = EGL_BAD_MATCH;
+ break;
+ }
+
+ _eglError(egl_error, "dri2_create_context");
+}
/**
* Called via eglCreateContext(), drv->API.CreateContext().
api = __DRI_API_GLES;
break;
case 2:
- case 3:
api = __DRI_API_GLES2;
break;
+ case 3:
+ api = __DRI_API_GLES3;
+ break;
default:
_eglError(EGL_BAD_PARAMETER, "eglCreateContext");
return NULL;
break;
default:
_eglError(EGL_BAD_PARAMETER, "eglCreateContext");
+ free(dri2_ctx);
return NULL;
}
ctx_attribs,
& error,
dri2_ctx);
+ dri2_create_context_attribs_error(error);
} else {
dri2_ctx->dri_context =
dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
* wl_drm format code to a description of the planes in the buffer
* that lets us create a __DRIimage for each of the planes. */
-static const struct wl_drm_format_descriptor {
- uint32_t wl_format;
+static const struct wl_drm_components_descriptor {
+ uint32_t dri_components;
EGLint components;
int nplanes;
- struct {
- int buffer_index;
- int width_shift;
- int height_shift;
- uint32_t dri_format;
- int cpp;
- } planes[3];
-} wl_drm_formats[] = {
- { WL_DRM_FORMAT_ARGB8888, EGL_TEXTURE_RGBA, 1,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 }, } },
-
- { WL_DRM_FORMAT_XRGB8888, EGL_TEXTURE_RGB, 1,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_XRGB8888, 4 }, } },
-
- { WL_DRM_FORMAT_YUV410, EGL_TEXTURE_Y_U_V_WL, 3,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 },
- { 2, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 } } },
-
- { WL_DRM_FORMAT_YUV411, EGL_TEXTURE_Y_U_V_WL, 3,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 2, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
-
- { WL_DRM_FORMAT_YUV420, EGL_TEXTURE_Y_U_V_WL, 3,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 },
- { 2, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 } } },
-
- { WL_DRM_FORMAT_YUV422, EGL_TEXTURE_Y_U_V_WL, 3,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 2, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
-
- { WL_DRM_FORMAT_YUV444, EGL_TEXTURE_Y_U_V_WL, 3,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 2, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
-
- { WL_DRM_FORMAT_NV12, EGL_TEXTURE_Y_UV_WL, 2,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 1, 1, __DRI_IMAGE_FORMAT_GR88, 2 } } },
-
- { WL_DRM_FORMAT_NV16, EGL_TEXTURE_Y_UV_WL, 2,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
- { 1, 1, 0, __DRI_IMAGE_FORMAT_GR88, 2 } } },
-
- /* For YUYV buffers, we set up two overlapping DRI images and treat
- * them as planar buffers in the compositors. Plane 0 is GR88 and
- * samples YU or YV pairs and places Y into the R component, while
- * plane 1 is ARGB and samples YUYV clusters and places pairs and
- * places U into the G component and V into A. This lets the
- * texture sampler interpolate the Y components correctly when
- * sampling from plane 0, and interpolate U and V correctly when
- * sampling from plane 1. */
- { WL_DRM_FORMAT_YUYV, EGL_TEXTURE_Y_XUXV_WL, 2,
- { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR88, 2 },
- { 0, 1, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } }
+} wl_drm_components[] = {
+ { __DRI_IMAGE_COMPONENTS_RGB, EGL_TEXTURE_RGB, 1 },
+ { __DRI_IMAGE_COMPONENTS_RGBA, EGL_TEXTURE_RGBA, 1 },
+ { __DRI_IMAGE_COMPONENTS_Y_U_V, EGL_TEXTURE_Y_U_V_WL, 3 },
+ { __DRI_IMAGE_COMPONENTS_Y_UV, EGL_TEXTURE_Y_UV_WL, 2 },
+ { __DRI_IMAGE_COMPONENTS_Y_XUXV, EGL_TEXTURE_Y_XUXV_WL, 2 },
};
static _EGLImage *
{
struct wl_drm_buffer *buffer = (struct wl_drm_buffer *) _buffer;
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ const struct wl_drm_components_descriptor *f;
__DRIimage *dri_image;
_EGLImageAttribs attrs;
EGLint err;
- uint32_t format;
- int32_t offset, stride, plane, width, height;
- int cpp, index;
- const struct wl_drm_format_descriptor *f;
+ int32_t plane;
if (!wayland_buffer_is_drm(&buffer->buffer))
return NULL;
return NULL;
}
- width = buffer->buffer.width >> f->planes[plane].width_shift;
- height = buffer->buffer.height >> f->planes[plane].height_shift;
- format = f->planes[plane].dri_format;
- cpp = f->planes[plane].cpp;
- index = f->planes[plane].buffer_index;
- offset = buffer->offset[index];
- stride = buffer->stride[index];
+ dri_image = dri2_dpy->image->fromPlanar(buffer->driver_buffer, plane, NULL);
- dri_image = dri2_dpy->image->createSubImage(buffer->driver_buffer,
- width, height, format,
- offset, stride / cpp, NULL);
+ if (dri_image == NULL) {
+ _eglError(EGL_BAD_PARAMETER, "dri2_create_image_wayland_wl_buffer");
+ return NULL;
+ }
return dri2_create_image(disp, dri_image);
}
#endif
+/**
+ * Set the error code after a call to
+ * dri2_egl_image::dri_image::createImageFromTexture.
+ */
+static void
+dri2_create_image_khr_texture_error(int dri_error)
+{
+ EGLint egl_error;
+
+ switch (dri_error) {
+ case __DRI_IMAGE_ERROR_SUCCESS:
+ return;
+
+ case __DRI_IMAGE_ERROR_BAD_ALLOC:
+ egl_error = EGL_BAD_ALLOC;
+ break;
+
+ case __DRI_IMAGE_ERROR_BAD_MATCH:
+ egl_error = EGL_BAD_MATCH;
+ break;
+
+ case __DRI_IMAGE_ERROR_BAD_PARAMETER:
+ egl_error = EGL_BAD_PARAMETER;
+ break;
+
+ default:
+ assert(0);
+ egl_error = EGL_BAD_MATCH;
+ break;
+ }
+
+ _eglError(egl_error, "dri2_create_image_khr_texture");
+}
+
+static _EGLImage *
+dri2_create_image_khr_texture(_EGLDisplay *disp, _EGLContext *ctx,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const EGLint *attr_list)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
+ struct dri2_egl_image *dri2_img;
+ GLuint texture = (GLuint) (uintptr_t) buffer;
+ _EGLImageAttribs attrs;
+ GLuint depth;
+ GLenum gl_target;
+ unsigned error;
+
+ if (texture == 0) {
+ _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
+ return EGL_NO_IMAGE_KHR;
+ }
+
+ if (_eglParseImageAttribList(&attrs, disp, attr_list) != EGL_SUCCESS)
+ return EGL_NO_IMAGE_KHR;
+
+ switch (target) {
+ case EGL_GL_TEXTURE_2D_KHR:
+ depth = 0;
+ gl_target = GL_TEXTURE_2D;
+ break;
+ case EGL_GL_TEXTURE_3D_KHR:
+ depth = attrs.GLTextureZOffset;
+ gl_target = GL_TEXTURE_3D;
+ break;
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
+ depth = target - EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR;
+ gl_target = GL_TEXTURE_CUBE_MAP;
+ break;
+ default:
+ _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
+ return EGL_NO_IMAGE_KHR;
+ }
+
+ dri2_img = malloc(sizeof *dri2_img);
+ if (!dri2_img) {
+ _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
+ return EGL_NO_IMAGE_KHR;
+ }
+
+ if (!_eglInitImage(&dri2_img->base, disp)) {
+ _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
+ free(dri2_img);
+ return EGL_NO_IMAGE_KHR;
+ }
+
+ dri2_img->dri_image =
+ dri2_dpy->image->createImageFromTexture(dri2_ctx->dri_context,
+ gl_target,
+ texture,
+ depth,
+ attrs.GLTextureLevel,
+ &error,
+ dri2_img);
+ dri2_create_image_khr_texture_error(error);
+
+ if (!dri2_img->dri_image) {
+ free(dri2_img);
+ return EGL_NO_IMAGE_KHR;
+ }
+ return &dri2_img->base;
+}
+
_EGLImage *
dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
_EGLContext *ctx, EGLenum target,
(void) drv;
switch (target) {
+ case EGL_GL_TEXTURE_2D_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
+ case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
+ return dri2_create_image_khr_texture(disp, ctx, target, buffer, attr_list);
case EGL_GL_RENDERBUFFER_KHR:
return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
case EGL_DRM_BUFFER_MESA:
{
_EGLDisplay *disp = user_data;
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
- int i;
+ __DRIimage *img;
+ int i, dri_components = 0;
+
+ img = dri2_dpy->image->createImageFromNames(dri2_dpy->dri_screen,
+ buffer->buffer.width,
+ buffer->buffer.height,
+ buffer->format, (int*)&name, 1,
+ buffer->stride,
+ buffer->offset,
+ NULL);
+
+ if (img == NULL)
+ return;
- for (i = 0; i < ARRAY_SIZE(wl_drm_formats); i++)
- if (wl_drm_formats[i].wl_format == buffer->format) {
- buffer->driver_format = &wl_drm_formats[i];
- break;
- }
+ dri2_dpy->image->queryImage(img, __DRI_IMAGE_ATTRIB_COMPONENTS, &dri_components);
- if (buffer->driver_format == NULL)
- return;
+ buffer->driver_format = NULL;
+ for (i = 0; i < ARRAY_SIZE(wl_drm_components); i++)
+ if (wl_drm_components[i].dri_components == dri_components)
+ buffer->driver_format = &wl_drm_components[i];
- buffer->driver_buffer =
- dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
- buffer->buffer.width,
- buffer->buffer.height,
- __DRI_IMAGE_FORMAT_NONE, name,
- buffer->stride[0] / 4,
- NULL);
+ if (buffer->driver_format == NULL)
+ dri2_dpy->image->destroyImage(img);
+ else
+ buffer->driver_buffer = img;
}
static void
EGLint attribute, EGLint *value)
{
struct wl_drm_buffer *buffer = (struct wl_drm_buffer *) _buffer;
- const struct wl_drm_format_descriptor *format;
+ const struct wl_drm_components_descriptor *format;
if (!wayland_buffer_is_drm(&buffer->buffer))
return EGL_FALSE;
(void) args;
- dri2_drv = malloc(sizeof *dri2_drv);
+ dri2_drv = calloc(1, sizeof *dri2_drv);
if (!dri2_drv)
return NULL;
- memset(dri2_drv, 0, sizeof *dri2_drv);
-
if (!dri2_load(&dri2_drv->base)) {
free(dri2_drv);
return NULL;
projects / mesa.git / blobdiff