typedef struct drm_clip_rect drm_clip_rect_t;
#endif
+#include <GL/gl.h>
+
+#include <stdint.h>
+
/**
* \name DRI interface structures
*
typedef struct __DRI2flushExtensionRec __DRI2flushExtension;
typedef struct __DRI2throttleExtensionRec __DRI2throttleExtension;
typedef struct __DRI2fenceExtensionRec __DRI2fenceExtension;
-
+typedef struct __DRI2interopExtensionRec __DRI2interopExtension;
+typedef struct __DRI2blobExtensionRec __DRI2blobExtension;
+typedef struct __DRI2bufferDamageExtensionRec __DRI2bufferDamageExtension;
typedef struct __DRIimageLoaderExtensionRec __DRIimageLoaderExtension;
typedef struct __DRIimageDriverExtensionRec __DRIimageDriverExtension;
enum __DRI2throttleReason reason);
};
+/**
+ * Extension for EGL_ANDROID_blob_cache
+ */
+
+#define __DRI2_BLOB "DRI2_Blob"
+#define __DRI2_BLOB_VERSION 1
+
+typedef void
+(*__DRIblobCacheSet) (const void *key, signed long keySize,
+ const void *value, signed long valueSize);
+
+typedef signed long
+(*__DRIblobCacheGet) (const void *key, signed long keySize,
+ void *value, signed long valueSize);
+
+struct __DRI2blobExtensionRec {
+ __DRIextension base;
+
+ /**
+ * Set cache functions for setting and getting cache entries.
+ */
+ void (*set_cache_funcs) (__DRIscreen *screen,
+ __DRIblobCacheSet set, __DRIblobCacheGet get);
+};
/**
* Extension for fences / synchronization objects.
*/
#define __DRI2_FENCE "DRI2_Fence"
-#define __DRI2_FENCE_VERSION 1
+#define __DRI2_FENCE_VERSION 2
-#define __DRI2_FENCE_TIMEOUT_INFINITE 0xffffffffffffffffllu
+#define __DRI2_FENCE_TIMEOUT_INFINITE 0xffffffffffffffffull
#define __DRI2_FENCE_FLAG_FLUSH_COMMANDS (1 << 0)
+/**
+ * \name Capabilities that might be returned by __DRI2fenceExtensionRec::get_capabilities
+ */
+/*@{*/
+#define __DRI_FENCE_CAP_NATIVE_FD 1
+/*@}*/
+
struct __DRI2fenceExtensionRec {
__DRIextension base;
* sense with this function (right now there are none)
*/
void (*server_wait_sync)(__DRIcontext *ctx, void *fence, unsigned flags);
+
+ /**
+ * Query for general capabilities of the driver that concern fences.
+ * Returns a bitmask of __DRI_FENCE_CAP_x
+ *
+ * \since 2
+ */
+ unsigned (*get_capabilities)(__DRIscreen *screen);
+
+ /**
+ * Create an fd (file descriptor) associated fence. If the fence fd
+ * is -1, this behaves similarly to create_fence() except that when
+ * rendering is flushed the driver creates a fence fd. Otherwise,
+ * the driver wraps an existing fence fd.
+ *
+ * This is used to implement the EGL_ANDROID_native_fence_sync extension.
+ *
+ * \since 2
+ *
+ * \param ctx the context associated with the fence
+ * \param fd the fence fd or -1
+ */
+ void *(*create_fence_fd)(__DRIcontext *ctx, int fd);
+
+ /**
+ * For fences created with create_fence_fd(), after rendering is flushed,
+ * this retrieves the native fence fd. Caller takes ownership of the
+ * fd and will close() it when it is no longer needed.
+ *
+ * \since 2
+ *
+ * \param screen the screen associated with the fence
+ * \param fence the fence
+ */
+ int (*get_fence_fd)(__DRIscreen *screen, void *fence);
};
+/**
+ * Extension for API interop.
+ * See GL/mesa_glinterop.h.
+ */
+
+#define __DRI2_INTEROP "DRI2_Interop"
+#define __DRI2_INTEROP_VERSION 1
+
+struct mesa_glinterop_device_info;
+struct mesa_glinterop_export_in;
+struct mesa_glinterop_export_out;
+
+struct __DRI2interopExtensionRec {
+ __DRIextension base;
+
+ /** Same as MesaGLInterop*QueryDeviceInfo. */
+ int (*query_device_info)(__DRIcontext *ctx,
+ struct mesa_glinterop_device_info *out);
+
+ /** Same as MesaGLInterop*ExportObject. */
+ int (*export_object)(__DRIcontext *ctx,
+ struct mesa_glinterop_export_in *in,
+ struct mesa_glinterop_export_out *out);
+};
+
+
+/**
+ * Extension for limiting window system back buffer rendering to user-defined
+ * scissor region.
+ */
+
+#define __DRI2_BUFFER_DAMAGE "DRI2_BufferDamage"
+#define __DRI2_BUFFER_DAMAGE_VERSION 1
+
+struct __DRI2bufferDamageExtensionRec {
+ __DRIextension base;
+
+ /**
+ * Provides an array of rectangles representing an overriding scissor region
+ * for rendering operations performed to the specified drawable. These
+ * rectangles do not replace client API scissor regions or draw
+ * co-ordinates, but instead inform the driver of the overall bounds of all
+ * operations which will be issued before the next flush.
+ *
+ * Any rendering operations writing pixels outside this region to the
+ * drawable will have an undefined effect on the entire drawable.
+ *
+ * This entrypoint may only be called after the drawable has either been
+ * newly created or flushed, and before any rendering operations which write
+ * pixels to the drawable. Calling this entrypoint at any other time will
+ * have an undefined effect on the entire drawable.
+ *
+ * Calling this entrypoint with @nrects 0 and @rects NULL will reset the
+ * region to the buffer's full size. This entrypoint may be called once to
+ * reset the region, followed by a second call with a populated region,
+ * before a rendering call is made.
+ *
+ * Used to implement EGL_KHR_partial_update.
+ *
+ * \param drawable affected drawable
+ * \param nrects number of rectangles provided
+ * \param rects the array of rectangles, lower-left origin
+ */
+ void (*set_damage_region)(__DRIdrawable *drawable, unsigned int nrects,
+ int *rects);
+};
+
/*@}*/
/**
* SWRast Loader extension.
*/
#define __DRI_SWRAST_LOADER "DRI_SWRastLoader"
-#define __DRI_SWRAST_LOADER_VERSION 3
+#define __DRI_SWRAST_LOADER_VERSION 5
struct __DRIswrastLoaderExtensionRec {
__DRIextension base;
void (*getImage2)(__DRIdrawable *readable,
int x, int y, int width, int height, int stride,
char *data, void *loaderPrivate);
+
+ /**
+ * Put shm image to drawable
+ *
+ * \since 4
+ */
+ void (*putImageShm)(__DRIdrawable *drawable, int op,
+ int x, int y, int width, int height, int stride,
+ int shmid, char *shmaddr, unsigned offset,
+ void *loaderPrivate);
+ /**
+ * Get shm image from readable
+ *
+ * \since 4
+ */
+ void (*getImageShm)(__DRIdrawable *readable,
+ int x, int y, int width, int height,
+ int shmid, void *loaderPrivate);
+
+ /**
+ * Put shm image to drawable (v2)
+ *
+ * The original version fixes srcx/y to 0, and expected
+ * the offset to be adjusted. This version allows src x,y
+ * to not be included in the offset. This is needed to
+ * avoid certain overflow checks in the X server, that
+ * result in lost rendering.
+ *
+ * \since 5
+ */
+ void (*putImageShm2)(__DRIdrawable *drawable, int op,
+ int x, int y,
+ int width, int height, int stride,
+ int shmid, char *shmaddr, unsigned offset,
+ void *loaderPrivate);
};
/**
#define __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS 46
#define __DRI_ATTRIB_YINVERTED 47
#define __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE 48
+#define __DRI_ATTRIB_MUTABLE_RENDER_BUFFER 49 /* EGL_MUTABLE_RENDER_BUFFER_BIT_KHR */
+#define __DRI_ATTRIB_RED_SHIFT 50
+#define __DRI_ATTRIB_GREEN_SHIFT 51
+#define __DRI_ATTRIB_BLUE_SHIFT 52
+#define __DRI_ATTRIB_ALPHA_SHIFT 53
+#define __DRI_ATTRIB_MAX 54
/* __DRI_ATTRIB_RENDER_TYPE */
#define __DRI_ATTRIB_RGBA_BIT 0x01
#define __DRI_ATTRIB_TEXTURE_2D_BIT 0x02
#define __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT 0x04
+/* __DRI_ATTRIB_SWAP_METHOD */
+/* Note that with the exception of __DRI_ATTRIB_SWAP_NONE, we need to define
+ * the same tokens as GLX. This is because old and current X servers will
+ * transmit the driconf value grabbed from the AIGLX driver untranslated as
+ * the GLX fbconfig value. __DRI_ATTRIB_SWAP_NONE is only used by dri drivers
+ * to signal to the dri core that the driconfig is single-buffer.
+ */
+#define __DRI_ATTRIB_SWAP_NONE 0x0000
+#define __DRI_ATTRIB_SWAP_EXCHANGE 0x8061
+#define __DRI_ATTRIB_SWAP_COPY 0x8062
+#define __DRI_ATTRIB_SWAP_UNDEFINED 0x8063
+
/**
* This extension defines the core DRI functionality.
+ *
+ * Version >= 2 indicates that getConfigAttrib with __DRI_ATTRIB_SWAP_METHOD
+ * returns a reliable value.
*/
#define __DRI_CORE "DRI_Core"
-#define __DRI_CORE_VERSION 1
+#define __DRI_CORE_VERSION 2
struct __DRIcoreExtensionRec {
__DRIextension base;
};
#define __DRI_DRI2_LOADER "DRI_DRI2Loader"
-#define __DRI_DRI2_LOADER_VERSION 3
+#define __DRI_DRI2_LOADER_VERSION 4
+
+enum dri_loader_cap {
+ /* Whether the loader handles RGBA channel ordering correctly. If not,
+ * only BGRA ordering can be exposed.
+ */
+ DRI_LOADER_CAP_RGBA_ORDERING,
+ DRI_LOADER_CAP_FP16,
+};
+
struct __DRIdri2LoaderExtensionRec {
__DRIextension base;
int *width, int *height,
unsigned int *attachments, int count,
int *out_count, void *loaderPrivate);
+
+ /**
+ * Return a loader capability value. If the loader doesn't know the enum,
+ * it will return 0.
+ *
+ * \param loaderPrivate The last parameter of createNewScreen or
+ * createNewScreen2.
+ * \param cap See the enum.
+ *
+ * \since 4
+ */
+ unsigned (*getCapability)(void *loaderPrivate, enum dri_loader_cap cap);
};
/**
*/
#define __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS 0x00000004
+/**
+ * \requires __DRI2_NO_ERROR.
+ *
+ */
+#define __DRI_CTX_FLAG_NO_ERROR 0x00000008
+
/**
* \name Context reset strategies.
*/
#define __DRI_CTX_RESET_LOSE_CONTEXT 1
/*@}*/
+#define __DRI_CTX_ATTRIB_PRIORITY 4
+
+#define __DRI_CTX_PRIORITY_LOW 0
+#define __DRI_CTX_PRIORITY_MEDIUM 1
+#define __DRI_CTX_PRIORITY_HIGH 2
+
+/**
+ * \name Context release behaviors.
+ */
+/*@{*/
+#define __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR 5
+
+#define __DRI_CTX_RELEASE_BEHAVIOR_NONE 0
+#define __DRI_CTX_RELEASE_BEHAVIOR_FLUSH 1
+/*@}*/
+
/**
* \name Reasons that __DRIdri2Extension::createContextAttribs might fail
*/
* extensions.
*/
#define __DRI_IMAGE "DRI_IMAGE"
-#define __DRI_IMAGE_VERSION 11
+#define __DRI_IMAGE_VERSION 17
/**
* These formats correspond to the similarly named MESA_FORMAT_*
* by the driver (YUV planar formats) but serve as a base image for
* creating sub-images for the different planes within the image.
*
- * R8, GR88 and NONE should not be used with createImageFormName or
+ * R8, GR88 and NONE should not be used with createImageFromName or
* createImage, and are returned by query from sub images created with
* createImageFromNames (NONE, see above) and fromPlane (R8 & GR88).
*/
#define __DRI_IMAGE_FORMAT_XRGB2101010 0x1009
#define __DRI_IMAGE_FORMAT_ARGB2101010 0x100a
#define __DRI_IMAGE_FORMAT_SARGB8 0x100b
+#define __DRI_IMAGE_FORMAT_ARGB1555 0x100c
+#define __DRI_IMAGE_FORMAT_R16 0x100d
+#define __DRI_IMAGE_FORMAT_GR1616 0x100e
+#define __DRI_IMAGE_FORMAT_YUYV 0x100f
+#define __DRI_IMAGE_FORMAT_XBGR2101010 0x1010
+#define __DRI_IMAGE_FORMAT_ABGR2101010 0x1011
+#define __DRI_IMAGE_FORMAT_SABGR8 0x1012
+#define __DRI_IMAGE_FORMAT_UYVY 0x1013
+#define __DRI_IMAGE_FORMAT_XBGR16161616F 0x1014
+#define __DRI_IMAGE_FORMAT_ABGR16161616F 0x1015
#define __DRI_IMAGE_USE_SHARE 0x0001
#define __DRI_IMAGE_USE_SCANOUT 0x0002
-#define __DRI_IMAGE_USE_CURSOR 0x0004 /* Depricated */
+#define __DRI_IMAGE_USE_CURSOR 0x0004 /* Deprecated */
#define __DRI_IMAGE_USE_LINEAR 0x0008
+/* The buffer will only be read by an external process after SwapBuffers,
+ * in contrary to gbm buffers, front buffers and fake front buffers, which
+ * could be read after a flush."
+ */
+#define __DRI_IMAGE_USE_BACKBUFFER 0x0010
+
+#define __DRI_IMAGE_TRANSFER_READ 0x1
+#define __DRI_IMAGE_TRANSFER_WRITE 0x2
+#define __DRI_IMAGE_TRANSFER_READ_WRITE \
+ (__DRI_IMAGE_TRANSFER_READ | __DRI_IMAGE_TRANSFER_WRITE)
/**
- * Four CC formats that matches with WL_DRM_FORMAT_* from wayland_drm.h,
- * GBM_FORMAT_* from gbm.h, and DRM_FORMAT_* from drm_fourcc.h. Used with
- * createImageFromNames.
+ * Extra fourcc formats used internally to Mesa with createImageFromNames.
+ * The externally-available fourccs are defined by drm_fourcc.h (DRM_FORMAT_*)
+ * and WL_DRM_FORMAT_* from wayland_drm.h.
*
* \since 5
*/
-#define __DRI_IMAGE_FOURCC_R8 0x20203852
-#define __DRI_IMAGE_FOURCC_GR88 0x38385247
-#define __DRI_IMAGE_FOURCC_RGB565 0x36314752
-#define __DRI_IMAGE_FOURCC_ARGB8888 0x34325241
-#define __DRI_IMAGE_FOURCC_XRGB8888 0x34325258
-#define __DRI_IMAGE_FOURCC_ABGR8888 0x34324241
-#define __DRI_IMAGE_FOURCC_XBGR8888 0x34324258
-#define __DRI_IMAGE_FOURCC_SARGB8888 0x83324258
-#define __DRI_IMAGE_FOURCC_YUV410 0x39565559
-#define __DRI_IMAGE_FOURCC_YUV411 0x31315559
-#define __DRI_IMAGE_FOURCC_YUV420 0x32315559
-#define __DRI_IMAGE_FOURCC_YUV422 0x36315559
-#define __DRI_IMAGE_FOURCC_YUV444 0x34325559
-#define __DRI_IMAGE_FOURCC_NV12 0x3231564e
-#define __DRI_IMAGE_FOURCC_NV16 0x3631564e
-#define __DRI_IMAGE_FOURCC_YUYV 0x56595559
-
+#define __DRI_IMAGE_FOURCC_SARGB8888 0x83324258
+#define __DRI_IMAGE_FOURCC_SABGR8888 0x84324258
/**
* Queryable on images created by createImageFromNames.
* RGB and RGBA are may be usable directly as images but its still
* recommended to call fromPlanar with plane == 0.
*
- * Y_U_V, Y_UV and Y_XUXV all requires call to fromPlanar to create
+ * Y_U_V, Y_UV,Y_XUXV and Y_UXVX all requires call to fromPlanar to create
* usable sub-images, sampling from images return raw YUV data and
* color conversion needs to be done in the shader.
*
#define __DRI_IMAGE_COMPONENTS_Y_U_V 0x3003
#define __DRI_IMAGE_COMPONENTS_Y_UV 0x3004
#define __DRI_IMAGE_COMPONENTS_Y_XUXV 0x3005
+#define __DRI_IMAGE_COMPONENTS_Y_UXVX 0x3008
+#define __DRI_IMAGE_COMPONENTS_AYUV 0x3009
+#define __DRI_IMAGE_COMPONENTS_XYUV 0x300A
#define __DRI_IMAGE_COMPONENTS_R 0x3006
#define __DRI_IMAGE_COMPONENTS_RG 0x3007
#define __DRI_IMAGE_ATTRIB_FOURCC 0x2008 /* available in versions 11 */
#define __DRI_IMAGE_ATTRIB_NUM_PLANES 0x2009 /* available in versions 11 */
+#define __DRI_IMAGE_ATTRIB_OFFSET 0x200A /* available in versions 13 */
+#define __DRI_IMAGE_ATTRIB_MODIFIER_LOWER 0x200B /* available in versions 14 */
+#define __DRI_IMAGE_ATTRIB_MODIFIER_UPPER 0x200C /* available in versions 14 */
+
enum __DRIYUVColorSpace {
__DRI_YUV_COLOR_SPACE_UNDEFINED = 0,
__DRI_YUV_COLOR_SPACE_ITU_REC601 = 0x327F,
#define __BLIT_FLAG_FLUSH 0x0001
#define __BLIT_FLAG_FINISH 0x0002
+/**
+ * queryDmaBufFormatModifierAttribs attributes
+ */
+
+/* Available in version 16 */
+#define __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB_PLANE_COUNT 0x0001
+
typedef struct __DRIimageRec __DRIimage;
typedef struct __DRIimageExtensionRec __DRIimageExtension;
struct __DRIimageExtensionRec {
int name, int pitch,
void *loaderPrivate);
+ /* Deprecated since version 17; see createImageFromRenderbuffer2 */
__DRIimage *(*createImageFromRenderbuffer)(__DRIcontext *context,
int renderbuffer,
void *loaderPrivate);
GLboolean (*validateUsage)(__DRIimage *image, unsigned int use);
/**
- * Unlike createImageFromName __DRI_IMAGE_FORMAT is not but instead
- * __DRI_IMAGE_FOURCC and strides are in bytes not pixels. Stride is
+ * Unlike createImageFromName __DRI_IMAGE_FORMAT is not used but instead
+ * DRM_FORMAT_*, and strides are in bytes not pixels. Stride is
* also per block and not per pixel (for non-RGB, see gallium blocks).
*
* \since 5
* \since 10
*/
int (*getCapabilities)(__DRIscreen *screen);
+
+ /**
+ * Returns a map of the specified region of a __DRIimage for the specified usage.
+ *
+ * flags may include __DRI_IMAGE_TRANSFER_READ, which will populate the
+ * mapping with the current buffer content. If __DRI_IMAGE_TRANSFER_READ
+ * is not included in the flags, the buffer content at map time is
+ * undefined. Users wanting to modify the mapping must include
+ * __DRI_IMAGE_TRANSFER_WRITE; if __DRI_IMAGE_TRANSFER_WRITE is not
+ * included, behaviour when writing the mapping is undefined.
+ *
+ * Returns the byte stride in *stride, and an opaque pointer to data
+ * tracking the mapping in **data, which must be passed to unmapImage().
+ *
+ * \since 12
+ */
+ void *(*mapImage)(__DRIcontext *context, __DRIimage *image,
+ int x0, int y0, int width, int height,
+ unsigned int flags, int *stride, void **data);
+
+ /**
+ * Unmap a previously mapped __DRIimage
+ *
+ * \since 12
+ */
+ void (*unmapImage)(__DRIcontext *context, __DRIimage *image, void *data);
+
+
+ /**
+ * Creates an image with implementation's favorite modifiers.
+ *
+ * This acts like createImage except there is a list of modifiers passed in
+ * which the implementation may selectively use to create the DRIimage. The
+ * result should be the implementation selects one modifier (perhaps it would
+ * hold on to a few and later pick).
+ *
+ * The created image should be destroyed with destroyImage().
+ *
+ * Returns the new DRIimage. The chosen modifier can be obtained later on
+ * and passed back to things like the kernel's AddFB2 interface.
+ *
+ * \sa __DRIimageRec::createImage
+ *
+ * \since 14
+ */
+ __DRIimage *(*createImageWithModifiers)(__DRIscreen *screen,
+ int width, int height, int format,
+ const uint64_t *modifiers,
+ const unsigned int modifier_count,
+ void *loaderPrivate);
+
+ /*
+ * Like createImageFromDmaBufs, but takes also format modifiers.
+ *
+ * For EGL_EXT_image_dma_buf_import_modifiers.
+ *
+ * \since 15
+ */
+ __DRIimage *(*createImageFromDmaBufs2)(__DRIscreen *screen,
+ int width, int height, int fourcc,
+ uint64_t modifier,
+ int *fds, int num_fds,
+ int *strides, int *offsets,
+ enum __DRIYUVColorSpace color_space,
+ enum __DRISampleRange sample_range,
+ enum __DRIChromaSiting horiz_siting,
+ enum __DRIChromaSiting vert_siting,
+ unsigned *error,
+ void *loaderPrivate);
+
+ /*
+ * dmabuf format query to support EGL_EXT_image_dma_buf_import_modifiers.
+ *
+ * \param max Maximum number of formats that can be accomodated into
+ * \param formats. If zero, no formats are returned -
+ * instead, the driver returns the total number of
+ * supported dmabuf formats in \param count.
+ * \param formats Buffer to fill formats into.
+ * \param count Count of formats returned, or, total number of
+ * supported formats in case \param max is zero.
+ *
+ * Returns true on success.
+ *
+ * \since 15
+ */
+ GLboolean (*queryDmaBufFormats)(__DRIscreen *screen, int max,
+ int *formats, int *count);
+
+ /*
+ * dmabuf format modifier query for a given format to support
+ * EGL_EXT_image_dma_buf_import_modifiers.
+ *
+ * \param fourcc The format to query modifiers for. If this format
+ * is not supported by the driver, return false.
+ * \param max Maximum number of modifiers that can be accomodated in
+ * \param modifiers. If zero, no modifiers are returned -
+ * instead, the driver returns the total number of
+ * modifiers for \param format in \param count.
+ * \param modifiers Buffer to fill modifiers into.
+ * \param count Count of the modifiers returned, or, total number of
+ * supported modifiers for \param fourcc in case
+ * \param max is zero.
+ *
+ * Returns true upon success.
+ *
+ * \since 15
+ */
+ GLboolean (*queryDmaBufModifiers)(__DRIscreen *screen, int fourcc,
+ int max, uint64_t *modifiers,
+ unsigned int *external_only,
+ int *count);
+
+ /**
+ * dmabuf format modifier attribute query for a given format and modifier.
+ *
+ * \param fourcc The format to query. If this format is not supported by
+ * the driver, return false.
+ * \param modifier The modifier to query. If this format+modifier is not
+ * supported by the driver, return false.
+ * \param attrib The __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB to query.
+ * \param value A pointer to where to store the result of the query.
+ *
+ * Returns true upon success.
+ *
+ * \since 16
+ */
+ GLboolean (*queryDmaBufFormatModifierAttribs)(__DRIscreen *screen,
+ uint32_t fourcc, uint64_t modifier,
+ int attrib, uint64_t *value);
+
+ /**
+ * Create a DRI image from the given renderbuffer.
+ *
+ * \param context the current DRI context
+ * \param renderbuffer the GL name of the renderbuffer
+ * \param loaderPrivate for callbacks into the loader related to the image
+ * \param error will be set to one of __DRI_IMAGE_ERROR_xxx
+ * \return the newly created image on success, or NULL otherwise
+ *
+ * \since 17
+ */
+ __DRIimage *(*createImageFromRenderbuffer2)(__DRIcontext *context,
+ int renderbuffer,
+ void *loaderPrivate,
+ unsigned *error);
};
__DRIextension base;
};
+/**
+ * No-error context driver extension.
+ *
+ * Existence of this extension means the driver can accept the
+ * __DRI_CTX_FLAG_NO_ERROR flag.
+ */
+#define __DRI2_NO_ERROR "DRI_NoError"
+#define __DRI2_NO_ERROR_VERSION 1
+
+typedef struct __DRInoErrorExtensionRec {
+ __DRIextension base;
+} __DRInoErrorExtension;
+
+/*
+ * Flush control driver extension.
+ *
+ * Existence of this extension means the driver can accept the
+ * \c __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR attribute in
+ * \c __DRIdri2ExtensionRec::createContextAttribs.
+ */
+#define __DRI2_FLUSH_CONTROL "DRI_FlushControl"
+#define __DRI2_FLUSH_CONTROL_VERSION 1
+
+typedef struct __DRI2flushControlExtensionRec __DRI2flushControlExtension;
+struct __DRI2flushControlExtensionRec {
+ __DRIextension base;
+};
+
/**
* DRI config options extension.
*
* This extension provides the XML string containing driver options for use by
* the loader in supporting the driconf application.
+ *
+ * v2:
+ * - Add the getXml getter function which allows the driver more flexibility in
+ * how the XML is provided.
+ * - Deprecate the direct xml pointer. It is only provided as a fallback for
+ * older versions of libGL and must not be used by clients that are aware of
+ * the newer version. Future driver versions may set it to NULL.
*/
#define __DRI_CONFIG_OPTIONS "DRI_ConfigOptions"
-#define __DRI_CONFIG_OPTIONS_VERSION 1
+#define __DRI_CONFIG_OPTIONS_VERSION 2
typedef struct __DRIconfigOptionsExtensionRec {
__DRIextension base;
- const char *xml;
+ const char *xml; /**< deprecated since v2, use getXml instead */
+
+ /**
+ * Get an XML string that describes available driver options for use by a
+ * config application.
+ *
+ * The returned string must be heap-allocated. The caller is responsible for
+ * freeing it.
+ */
+ char *(*getXml)(const char *driver_name);
} __DRIconfigOptionsExtension;
/**
*/
#define __DRI2_RENDERER_HAS_FRAMEBUFFER_SRGB 0x000c
+/* Bitmaks of supported/available context priorities - must match
+ * __EGL_CONTEXT_PRIORITY_LOW_BIT et al
+ */
+#define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY 0x000d
+#define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_LOW (1 << 0)
+#define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_MEDIUM (1 << 1)
+#define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_HIGH (1 << 2)
+
typedef struct __DRI2rendererQueryExtensionRec __DRI2rendererQueryExtension;
struct __DRI2rendererQueryExtensionRec {
__DRIextension base;
* Image Loader extension. Drivers use this to allocate color buffers
*/
+/**
+ * See __DRIimageLoaderExtensionRec::getBuffers::buffer_mask.
+ */
enum __DRIimageBufferMask {
__DRI_IMAGE_BUFFER_BACK = (1 << 0),
- __DRI_IMAGE_BUFFER_FRONT = (1 << 1)
+ __DRI_IMAGE_BUFFER_FRONT = (1 << 1),
+
+ /**
+ * A buffer shared between application and compositor. The buffer may be
+ * simultaneously accessed by each.
+ *
+ * A shared buffer is equivalent to an EGLSurface whose EGLConfig contains
+ * EGL_MUTABLE_RENDER_BUFFER_BIT_KHR and whose active EGL_RENDER_BUFFER (as
+ * opposed to any pending, requested change to EGL_RENDER_BUFFER) is
+ * EGL_SINGLE_BUFFER.
+ *
+ * If buffer_mask contains __DRI_IMAGE_BUFFER_SHARED, then must contains no
+ * other bits. As a corollary, a __DRIdrawable that has a "shared" buffer
+ * has no front nor back buffer.
+ *
+ * The loader returns __DRI_IMAGE_BUFFER_SHARED in buffer_mask if and only
+ * if:
+ * - The loader supports __DRI_MUTABLE_RENDER_BUFFER_LOADER.
+ * - The driver supports __DRI_MUTABLE_RENDER_BUFFER_DRIVER.
+ * - The EGLConfig of the drawable EGLSurface contains
+ * EGL_MUTABLE_RENDER_BUFFER_BIT_KHR.
+ * - The EGLContext's EGL_RENDER_BUFFER is EGL_SINGLE_BUFFER.
+ * Equivalently, the EGLSurface's active EGL_RENDER_BUFFER (as
+ * opposed to any pending, requested change to EGL_RENDER_BUFFER) is
+ * EGL_SINGLE_BUFFER. (See the EGL 1.5 and
+ * EGL_KHR_mutable_render_buffer spec for details about "pending" vs
+ * "active" EGL_RENDER_BUFFER state).
+ *
+ * A shared buffer is similar to a front buffer in that all rendering to the
+ * buffer should appear promptly on the screen. It is different from
+ * a front buffer in that its behavior is independent from the
+ * GL_DRAW_BUFFER state. Specifically, if GL_DRAW_FRAMEBUFFER is 0 and the
+ * __DRIdrawable's buffer_mask is __DRI_IMAGE_BUFFER_SHARED, then all
+ * rendering should appear promptly on the screen if GL_DRAW_BUFFER is not
+ * GL_NONE.
+ *
+ * The difference between a shared buffer and a front buffer is motivated
+ * by the constraints of Android and OpenGL ES. OpenGL ES does not support
+ * front-buffer rendering. Android's SurfaceFlinger protocol provides the
+ * EGL driver only a back buffer and no front buffer. The shared buffer
+ * mode introduced by EGL_KHR_mutable_render_buffer is a backdoor though
+ * EGL that allows Android OpenGL ES applications to render to what is
+ * effectively the front buffer, a backdoor that required no change to the
+ * OpenGL ES API and little change to the SurfaceFlinger API.
+ */
+ __DRI_IMAGE_BUFFER_SHARED = (1 << 2),
};
struct __DRIimageList {
};
#define __DRI_IMAGE_LOADER "DRI_IMAGE_LOADER"
-#define __DRI_IMAGE_LOADER_VERSION 1
+#define __DRI_IMAGE_LOADER_VERSION 3
struct __DRIimageLoaderExtensionRec {
__DRIextension base;
* \param stamp Address of variable to be updated when
* getBuffers must be called again
* \param loaderPrivate The loaderPrivate for driDrawable
- * \param buffer_mask Set of buffers to allocate
+ * \param buffer_mask Set of buffers to allocate. A bitmask of
+ * __DRIimageBufferMask.
* \param buffers Returned buffers
*/
int (*getBuffers)(__DRIdrawable *driDrawable,
* into __DRIdri2ExtensionRec::createNewDrawable
*/
void (*flushFrontBuffer)(__DRIdrawable *driDrawable, void *loaderPrivate);
+
+ /**
+ * Return a loader capability value. If the loader doesn't know the enum,
+ * it will return 0.
+ *
+ * \since 2
+ */
+ unsigned (*getCapability)(void *loaderPrivate, enum dri_loader_cap cap);
+
+ /**
+ * Flush swap buffers
+ *
+ * Make sure any outstanding swap buffers have been submitted to the
+ * device.
+ *
+ * \param driDrawable Drawable whose swaps need to be flushed
+ * \param loaderPrivate Loader's private data that was previously passed
+ * into __DRIdri2ExtensionRec::createNewDrawable
+ *
+ * \since 3
+ */
+ void (*flushSwapBuffers)(__DRIdrawable *driDrawable, void *loaderPrivate);
};
/**
__DRIgetAPIMaskFunc getAPIMask;
};
+/**
+ * Background callable loader extension.
+ *
+ * Loaders expose this extension to indicate to drivers that they are capable
+ * of handling callbacks from the driver's background drawing threads.
+ */
+#define __DRI_BACKGROUND_CALLABLE "DRI_BackgroundCallable"
+#define __DRI_BACKGROUND_CALLABLE_VERSION 1
+
+typedef struct __DRIbackgroundCallableExtensionRec __DRIbackgroundCallableExtension;
+struct __DRIbackgroundCallableExtensionRec {
+ __DRIextension base;
+
+ /**
+ * Indicate that this thread is being used by the driver as a background
+ * drawing thread which may make callbacks to the loader.
+ *
+ * \param loaderPrivate is the value that was passed to to the driver when
+ * the context was created. This can be used by the loader to identify
+ * which context any callbacks are associated with.
+ *
+ * If this function is called more than once from any given thread, each
+ * subsequent call overrides the loaderPrivate data that was passed in the
+ * previous call. The driver can take advantage of this to re-use a
+ * background thread to perform drawing on behalf of multiple contexts.
+ *
+ * It is permissible for the driver to call this function from a
+ * non-background thread (i.e. a thread that has already been bound to a
+ * context using __DRIcoreExtensionRec::bindContext()); when this happens,
+ * the \c loaderPrivate pointer must be equal to the pointer that was
+ * passed to the driver when the currently bound context was created.
+ *
+ * This call should execute quickly enough that the driver can call it with
+ * impunity whenever a background thread starts performing drawing
+ * operations (e.g. it should just set a thread-local variable).
+ */
+ void (*setBackgroundContext)(void *loaderPrivate);
+
+ /**
+ * Indicate that it is multithread safe to use glthread. For GLX/EGL
+ * platforms using Xlib, that involves calling XInitThreads, before
+ * opening an X display.
+ *
+ * Note: only supported if extension version is at least 2.
+ *
+ * \param loaderPrivate is the value that was passed to to the driver when
+ * the context was created. This can be used by the loader to identify
+ * which context any callbacks are associated with.
+ */
+ GLboolean (*isThreadSafe)(void *loaderPrivate);
+};
+
+/**
+ * The driver portion of EGL_KHR_mutable_render_buffer.
+ *
+ * If the driver creates a __DRIconfig with
+ * __DRI_ATTRIB_MUTABLE_RENDER_BUFFER, then it must support this extension.
+ *
+ * To support this extension:
+ *
+ * - The driver should create at least one __DRIconfig with
+ * __DRI_ATTRIB_MUTABLE_RENDER_BUFFER. This is strongly recommended but
+ * not required.
+ *
+ * - The driver must be able to handle __DRI_IMAGE_BUFFER_SHARED if
+ * returned by __DRIimageLoaderExtension:getBuffers().
+ *
+ * - When rendering to __DRI_IMAGE_BUFFER_SHARED, it must call
+ * __DRImutableRenderBufferLoaderExtension::displaySharedBuffer() in
+ * response to glFlush and glFinish. (This requirement is not documented
+ * in EGL_KHR_mutable_render_buffer, but is a de-facto requirement in the
+ * Android ecosystem. Android applications expect that glFlush will
+ * immediately display the buffer when in shared buffer mode, and Android
+ * drivers comply with this expectation). It :may: call
+ * displaySharedBuffer() more often than required.
+ *
+ * - When rendering to __DRI_IMAGE_BUFFER_SHARED, it must ensure that the
+ * buffer is always in a format compatible for display because the
+ * display engine (usually SurfaceFlinger or hwcomposer) may display the
+ * image at any time, even concurrently with 3D rendering. For example,
+ * display hardware and the GL hardware may be able to access the buffer
+ * simultaneously. In particular, if the buffer is compressed then take
+ * care that SurfaceFlinger and hwcomposer can consume the compression
+ * format.
+ *
+ * \see __DRI_IMAGE_BUFFER_SHARED
+ * \see __DRI_ATTRIB_MUTABLE_RENDER_BUFFER
+ * \see __DRI_MUTABLE_RENDER_BUFFER_LOADER
+ */
+#define __DRI_MUTABLE_RENDER_BUFFER_DRIVER "DRI_MutableRenderBufferDriver"
+#define __DRI_MUTABLE_RENDER_BUFFER_DRIVER_VERSION 1
+
+typedef struct __DRImutableRenderBufferDriverExtensionRec __DRImutableRenderBufferDriverExtension;
+struct __DRImutableRenderBufferDriverExtensionRec {
+ __DRIextension base;
+};
+
+/**
+ * The loader portion of EGL_KHR_mutable_render_buffer.
+ *
+ * Requires loader extension DRI_IMAGE_LOADER, through which the loader sends
+ * __DRI_IMAGE_BUFFER_SHARED to the driver.
+ *
+ * \see __DRI_MUTABLE_RENDER_BUFFER_DRIVER
+ */
+#define __DRI_MUTABLE_RENDER_BUFFER_LOADER "DRI_MutableRenderBufferLoader"
+#define __DRI_MUTABLE_RENDER_BUFFER_LOADER_VERSION 1
+
+typedef struct __DRImutableRenderBufferLoaderExtensionRec __DRImutableRenderBufferLoaderExtension;
+struct __DRImutableRenderBufferLoaderExtensionRec {
+ __DRIextension base;
+
+ /**
+ * Inform the display engine (that is, SurfaceFlinger and/or hwcomposer)
+ * that the __DRIdrawable has new content.
+ *
+ * The display engine may ignore this call, for example, if it continually
+ * refreshes and displays the buffer on every frame, as in
+ * EGL_ANDROID_front_buffer_auto_refresh. On the other extreme, the display
+ * engine may refresh and display the buffer only in frames in which the
+ * driver calls this.
+ *
+ * If the fence_fd is not -1, then the display engine will display the
+ * buffer only after the fence signals.
+ *
+ * The drawable's current __DRIimageBufferMask, as returned by
+ * __DRIimageLoaderExtension::getBuffers(), must be
+ * __DRI_IMAGE_BUFFER_SHARED.
+ */
+ void (*displaySharedBuffer)(__DRIdrawable *drawable, int fence_fd,
+ void *loaderPrivate);
+};
+
#endif