2 * (C) Copyright IBM Corporation 2002, 2004
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
22 * USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * DRI utility functions.
29 * This module acts as glue between GLX and the actual hardware driver. A DRI
30 * driver doesn't really \e have to use any of this - it's optional. But, some
31 * useful stuff is done here that otherwise would have to be duplicated in most
34 * Basically, these utility functions take care of some of the dirty details of
35 * screen initialization, context creation, context binding, DRM setup, etc.
37 * These functions are compiled into each DRI driver so libGL.so knows nothing
46 #include "main/mtypes.h"
47 #include "main/version.h"
48 #include "main/errors.h"
49 #include "main/macros.h"
51 const char __dri2ConfigOptions
[] =
53 DRI_CONF_SECTION_PERFORMANCE
54 DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1
)
58 /*****************************************************************/
59 /** \name Screen handling functions */
60 /*****************************************************************/
64 setupLoaderExtensions(__DRIscreen
*psp
,
65 const __DRIextension
**extensions
)
69 for (i
= 0; extensions
[i
]; i
++) {
70 if (strcmp(extensions
[i
]->name
, __DRI_DRI2_LOADER
) == 0)
71 psp
->dri2
.loader
= (__DRIdri2LoaderExtension
*) extensions
[i
];
72 if (strcmp(extensions
[i
]->name
, __DRI_IMAGE_LOOKUP
) == 0)
73 psp
->dri2
.image
= (__DRIimageLookupExtension
*) extensions
[i
];
74 if (strcmp(extensions
[i
]->name
, __DRI_USE_INVALIDATE
) == 0)
75 psp
->dri2
.useInvalidate
= (__DRIuseInvalidateExtension
*) extensions
[i
];
76 if (strcmp(extensions
[i
]->name
, __DRI_SWRAST_LOADER
) == 0)
77 psp
->swrast_loader
= (__DRIswrastLoaderExtension
*) extensions
[i
];
78 if (strcmp(extensions
[i
]->name
, __DRI_IMAGE_LOADER
) == 0)
79 psp
->image
.loader
= (__DRIimageLoaderExtension
*) extensions
[i
];
84 * This pointer determines which driver API we'll use in the case of the
85 * loader not passing us an explicit driver extensions list (that would,
86 * itself, contain a pointer to a driver API.)
88 * A driver's driDriverGetExtensions_drivername() can update this pointer to
89 * what it's returning, and a loader that is ignorant of createNewScreen2()
90 * will get the correct driver screen created, as long as no other
91 * driDriverGetExtensions() happened in between the first one and the
94 * This allows the X Server to not require the significant dri_interface.h
95 * updates for doing createNewScreen2(), which would discourage backporting of
96 * the X Server patches to support the new loader interface.
98 const struct __DriverAPIRec
*globalDriverAPI
= &driDriverAPI
;
101 * This is the first entrypoint in the driver called by the DRI driver loader
102 * after dlopen()ing it.
104 * It's used to create global state for the driver across contexts on the same
108 driCreateNewScreen2(int scrn
, int fd
,
109 const __DRIextension
**extensions
,
110 const __DRIextension
**driver_extensions
,
111 const __DRIconfig
***driver_configs
, void *data
)
113 static const __DRIextension
*emptyExtensionList
[] = { NULL
};
116 psp
= calloc(1, sizeof(*psp
));
120 /* By default, use the global driDriverAPI symbol (non-megadrivers). */
121 psp
->driver
= globalDriverAPI
;
123 /* If the driver exposes its vtable through its extensions list
124 * (megadrivers), use that instead.
126 if (driver_extensions
) {
127 for (int i
= 0; driver_extensions
[i
]; i
++) {
128 if (strcmp(driver_extensions
[i
]->name
, __DRI_DRIVER_VTABLE
) == 0) {
130 ((__DRIDriverVtableExtension
*)driver_extensions
[i
])->vtable
;
135 setupLoaderExtensions(psp
, extensions
);
137 psp
->loaderPrivate
= data
;
139 psp
->extensions
= emptyExtensionList
;
143 *driver_configs
= psp
->driver
->InitScreen(psp
);
144 if (*driver_configs
== NULL
) {
149 struct gl_constants consts
= { 0 };
154 if (_mesa_override_gl_version_contextless(&consts
, &api
, &version
))
155 psp
->max_gl_es2_version
= version
;
157 api
= API_OPENGL_COMPAT
;
158 if (_mesa_override_gl_version_contextless(&consts
, &api
, &version
)) {
159 if (api
== API_OPENGL_CORE
) {
160 psp
->max_gl_core_version
= version
;
162 psp
->max_gl_compat_version
= version
;
166 psp
->api_mask
= (1 << __DRI_API_OPENGL
);
167 if (psp
->max_gl_core_version
> 0)
168 psp
->api_mask
|= (1 << __DRI_API_OPENGL_CORE
);
169 if (psp
->max_gl_es1_version
> 0)
170 psp
->api_mask
|= (1 << __DRI_API_GLES
);
171 if (psp
->max_gl_es2_version
> 0)
172 psp
->api_mask
|= (1 << __DRI_API_GLES2
);
173 if (psp
->max_gl_es2_version
>= 30)
174 psp
->api_mask
|= (1 << __DRI_API_GLES3
);
176 driParseOptionInfo(&psp
->optionInfo
, __dri2ConfigOptions
);
177 driParseConfigFiles(&psp
->optionCache
, &psp
->optionInfo
, psp
->myNum
, "dri2");
184 dri2CreateNewScreen(int scrn
, int fd
,
185 const __DRIextension
**extensions
,
186 const __DRIconfig
***driver_configs
, void *data
)
188 return driCreateNewScreen2(scrn
, fd
, extensions
, NULL
,
189 driver_configs
, data
);
192 /** swrast driver createNewScreen entrypoint. */
194 driSWRastCreateNewScreen(int scrn
, const __DRIextension
**extensions
,
195 const __DRIconfig
***driver_configs
, void *data
)
197 return driCreateNewScreen2(scrn
, -1, extensions
, NULL
,
198 driver_configs
, data
);
202 driSWRastCreateNewScreen2(int scrn
, const __DRIextension
**extensions
,
203 const __DRIextension
**driver_extensions
,
204 const __DRIconfig
***driver_configs
, void *data
)
206 return driCreateNewScreen2(scrn
, -1, extensions
, driver_extensions
,
207 driver_configs
, data
);
211 * Destroy the per-screen private information.
214 * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
215 * drmClose(), and finally frees \p screenPrivate.
217 static void driDestroyScreen(__DRIscreen
*psp
)
220 /* No interaction with the X-server is possible at this point. This
221 * routine is called after XCloseDisplay, so there is no protocol
222 * stream open to the X-server anymore.
225 psp
->driver
->DestroyScreen(psp
);
227 driDestroyOptionCache(&psp
->optionCache
);
228 driDestroyOptionInfo(&psp
->optionInfo
);
234 static const __DRIextension
**driGetExtensions(__DRIscreen
*psp
)
236 return psp
->extensions
;
243 validate_context_version(__DRIscreen
*screen
,
245 unsigned major_version
,
246 unsigned minor_version
,
247 unsigned *dri_ctx_error
)
249 unsigned req_version
= 10 * major_version
+ minor_version
;
250 unsigned max_version
= 0;
253 case API_OPENGL_COMPAT
:
254 max_version
= screen
->max_gl_compat_version
;
256 case API_OPENGL_CORE
:
257 max_version
= screen
->max_gl_core_version
;
260 max_version
= screen
->max_gl_es1_version
;
263 max_version
= screen
->max_gl_es2_version
;
270 if (max_version
== 0) {
271 *dri_ctx_error
= __DRI_CTX_ERROR_BAD_API
;
273 } else if (req_version
> max_version
) {
274 *dri_ctx_error
= __DRI_CTX_ERROR_BAD_VERSION
;
281 /*****************************************************************/
282 /** \name Context handling functions */
283 /*****************************************************************/
286 static __DRIcontext
*
287 driCreateContextAttribs(__DRIscreen
*screen
, int api
,
288 const __DRIconfig
*config
,
289 __DRIcontext
*shared
,
290 unsigned num_attribs
,
291 const uint32_t *attribs
,
295 __DRIcontext
*context
;
296 const struct gl_config
*modes
= (config
!= NULL
) ? &config
->modes
: NULL
;
297 void *shareCtx
= (shared
!= NULL
) ? shared
->driverPrivate
: NULL
;
299 unsigned major_version
= 1;
300 unsigned minor_version
= 0;
302 bool notify_reset
= false;
304 assert((num_attribs
== 0) || (attribs
!= NULL
));
306 if (!(screen
->api_mask
& (1 << api
))) {
307 *error
= __DRI_CTX_ERROR_BAD_API
;
312 case __DRI_API_OPENGL
:
313 mesa_api
= API_OPENGL_COMPAT
;
316 mesa_api
= API_OPENGLES
;
318 case __DRI_API_GLES2
:
319 case __DRI_API_GLES3
:
320 mesa_api
= API_OPENGLES2
;
322 case __DRI_API_OPENGL_CORE
:
323 mesa_api
= API_OPENGL_CORE
;
326 *error
= __DRI_CTX_ERROR_BAD_API
;
330 for (unsigned i
= 0; i
< num_attribs
; i
++) {
331 switch (attribs
[i
* 2]) {
332 case __DRI_CTX_ATTRIB_MAJOR_VERSION
:
333 major_version
= attribs
[i
* 2 + 1];
335 case __DRI_CTX_ATTRIB_MINOR_VERSION
:
336 minor_version
= attribs
[i
* 2 + 1];
338 case __DRI_CTX_ATTRIB_FLAGS
:
339 flags
= attribs
[i
* 2 + 1];
341 case __DRI_CTX_ATTRIB_RESET_STRATEGY
:
342 notify_reset
= (attribs
[i
* 2 + 1]
343 != __DRI_CTX_RESET_NO_NOTIFICATION
);
346 /* We can't create a context that satisfies the requirements of an
347 * attribute that we don't understand. Return failure.
349 assert(!"Should not get here.");
350 *error
= __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE
;
355 /* Mesa does not support the GL_ARB_compatibilty extension or the
356 * compatibility profile. This means that we treat a API_OPENGL_COMPAT 3.1 as
357 * API_OPENGL_CORE and reject API_OPENGL_COMPAT 3.2+.
359 if (mesa_api
== API_OPENGL_COMPAT
&& major_version
== 3 && minor_version
== 1)
360 mesa_api
= API_OPENGL_CORE
;
362 if (mesa_api
== API_OPENGL_COMPAT
363 && ((major_version
> 3)
364 || (major_version
== 3 && minor_version
>= 2))) {
365 *error
= __DRI_CTX_ERROR_BAD_API
;
369 /* The latest version of EGL_KHR_create_context spec says:
371 * "If the EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR flag bit is set in
372 * EGL_CONTEXT_FLAGS_KHR, then a <debug context> will be created.
373 * [...] This bit is supported for OpenGL and OpenGL ES contexts.
375 * None of the other flags have any meaning in an ES context, so this seems safe.
377 if (mesa_api
!= API_OPENGL_COMPAT
378 && mesa_api
!= API_OPENGL_CORE
379 && (flags
& ~__DRI_CTX_FLAG_DEBUG
)) {
380 *error
= __DRI_CTX_ERROR_BAD_FLAG
;
384 /* There are no forward-compatible contexts before OpenGL 3.0. The
385 * GLX_ARB_create_context spec says:
387 * "Forward-compatible contexts are defined only for OpenGL versions
390 * Forward-looking contexts are supported by silently converting the
391 * requested API to API_OPENGL_CORE.
393 * In Mesa, a debug context is the same as a regular context.
395 if ((flags
& __DRI_CTX_FLAG_FORWARD_COMPATIBLE
) != 0) {
396 mesa_api
= API_OPENGL_CORE
;
399 const uint32_t allowed_flags
= (__DRI_CTX_FLAG_DEBUG
400 | __DRI_CTX_FLAG_FORWARD_COMPATIBLE
401 | __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS
);
402 if (flags
& ~allowed_flags
) {
403 *error
= __DRI_CTX_ERROR_UNKNOWN_FLAG
;
407 if (!validate_context_version(screen
, mesa_api
,
408 major_version
, minor_version
, error
))
411 context
= calloc(1, sizeof *context
);
413 *error
= __DRI_CTX_ERROR_NO_MEMORY
;
417 context
->loaderPrivate
= data
;
419 context
->driScreenPriv
= screen
;
420 context
->driDrawablePriv
= NULL
;
421 context
->driReadablePriv
= NULL
;
423 if (!screen
->driver
->CreateContext(mesa_api
, modes
, context
,
424 major_version
, minor_version
,
425 flags
, notify_reset
, error
, shareCtx
)) {
430 *error
= __DRI_CTX_ERROR_SUCCESS
;
435 driContextSetFlags(struct gl_context
*ctx
, uint32_t flags
)
437 if ((flags
& __DRI_CTX_FLAG_FORWARD_COMPATIBLE
) != 0)
438 ctx
->Const
.ContextFlags
|= GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
;
439 if ((flags
& __DRI_CTX_FLAG_DEBUG
) != 0) {
440 _mesa_set_debug_state_int(ctx
, GL_DEBUG_OUTPUT
, GL_TRUE
);
441 ctx
->Const
.ContextFlags
|= GL_CONTEXT_FLAG_DEBUG_BIT
;
445 static __DRIcontext
*
446 driCreateNewContextForAPI(__DRIscreen
*screen
, int api
,
447 const __DRIconfig
*config
,
448 __DRIcontext
*shared
, void *data
)
452 return driCreateContextAttribs(screen
, api
, config
, shared
, 0, NULL
,
456 static __DRIcontext
*
457 driCreateNewContext(__DRIscreen
*screen
, const __DRIconfig
*config
,
458 __DRIcontext
*shared
, void *data
)
460 return driCreateNewContextForAPI(screen
, __DRI_API_OPENGL
,
461 config
, shared
, data
);
465 * Destroy the per-context private information.
468 * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
469 * drmDestroyContext(), and finally frees \p contextPrivate.
472 driDestroyContext(__DRIcontext
*pcp
)
475 pcp
->driScreenPriv
->driver
->DestroyContext(pcp
);
481 driCopyContext(__DRIcontext
*dest
, __DRIcontext
*src
, unsigned long mask
)
492 /*****************************************************************/
493 /** \name Context (un)binding functions */
494 /*****************************************************************/
497 static void dri_get_drawable(__DRIdrawable
*pdp
);
498 static void dri_put_drawable(__DRIdrawable
*pdp
);
501 * This function takes both a read buffer and a draw buffer. This is needed
502 * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
505 static int driBindContext(__DRIcontext
*pcp
,
510 ** Assume error checking is done properly in glXMakeCurrent before
511 ** calling driUnbindContext.
517 /* Bind the drawable to the context */
518 pcp
->driDrawablePriv
= pdp
;
519 pcp
->driReadablePriv
= prp
;
521 pdp
->driContextPriv
= pcp
;
522 dri_get_drawable(pdp
);
524 if (prp
&& pdp
!= prp
) {
525 dri_get_drawable(prp
);
528 return pcp
->driScreenPriv
->driver
->MakeCurrent(pcp
, pdp
, prp
);
534 * \param scrn the screen.
537 * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
540 * This function calls __DriverAPIRec::UnbindContext, and then decrements
541 * __DRIdrawableRec::refcount which must be non-zero for a successful
544 * While casting the opaque private pointers associated with the parameters
545 * into their respective real types it also assures they are not \c NULL.
547 static int driUnbindContext(__DRIcontext
*pcp
)
553 ** Assume error checking is done properly in glXMakeCurrent before
554 ** calling driUnbindContext.
561 ** Call driUnbindContext before checking for valid drawables
562 ** to handle surfaceless contexts properly.
564 pcp
->driScreenPriv
->driver
->UnbindContext(pcp
);
566 pdp
= pcp
->driDrawablePriv
;
567 prp
= pcp
->driReadablePriv
;
569 /* already unbound */
574 if (pdp
->refcount
== 0) {
579 dri_put_drawable(pdp
);
582 if (prp
->refcount
== 0) {
587 dri_put_drawable(prp
);
590 pcp
->driDrawablePriv
= NULL
;
591 pcp
->driReadablePriv
= NULL
;
599 static void dri_get_drawable(__DRIdrawable
*pdp
)
604 static void dri_put_drawable(__DRIdrawable
*pdp
)
611 pdp
->driScreenPriv
->driver
->DestroyBuffer(pdp
);
616 static __DRIdrawable
*
617 driCreateNewDrawable(__DRIscreen
*screen
,
618 const __DRIconfig
*config
,
621 __DRIdrawable
*pdraw
;
623 pdraw
= malloc(sizeof *pdraw
);
627 pdraw
->loaderPrivate
= data
;
629 pdraw
->driScreenPriv
= screen
;
630 pdraw
->driContextPriv
= NULL
;
632 pdraw
->lastStamp
= 0;
636 dri_get_drawable(pdraw
);
638 if (!screen
->driver
->CreateBuffer(screen
, pdraw
, &config
->modes
,
644 pdraw
->dri2
.stamp
= pdraw
->lastStamp
+ 1;
650 driDestroyDrawable(__DRIdrawable
*pdp
)
652 dri_put_drawable(pdp
);
656 dri2AllocateBuffer(__DRIscreen
*screen
,
657 unsigned int attachment
, unsigned int format
,
658 int width
, int height
)
660 return screen
->driver
->AllocateBuffer(screen
, attachment
, format
,
665 dri2ReleaseBuffer(__DRIscreen
*screen
, __DRIbuffer
*buffer
)
667 screen
->driver
->ReleaseBuffer(screen
, buffer
);
672 dri2ConfigQueryb(__DRIscreen
*screen
, const char *var
, unsigned char *val
)
674 if (!driCheckOption(&screen
->optionCache
, var
, DRI_BOOL
))
677 *val
= driQueryOptionb(&screen
->optionCache
, var
);
683 dri2ConfigQueryi(__DRIscreen
*screen
, const char *var
, int *val
)
685 if (!driCheckOption(&screen
->optionCache
, var
, DRI_INT
) &&
686 !driCheckOption(&screen
->optionCache
, var
, DRI_ENUM
))
689 *val
= driQueryOptioni(&screen
->optionCache
, var
);
695 dri2ConfigQueryf(__DRIscreen
*screen
, const char *var
, float *val
)
697 if (!driCheckOption(&screen
->optionCache
, var
, DRI_FLOAT
))
700 *val
= driQueryOptionf(&screen
->optionCache
, var
);
706 driGetAPIMask(__DRIscreen
*screen
)
708 return screen
->api_mask
;
712 * swrast swapbuffers entrypoint.
714 * DRI2 implements this inside the loader with only flushes handled by the
718 driSwapBuffers(__DRIdrawable
*pdp
)
720 assert(pdp
->driScreenPriv
->swrast_loader
);
722 pdp
->driScreenPriv
->driver
->SwapBuffers(pdp
);
725 /** Core interface */
726 const __DRIcoreExtension driCoreExtension
= {
727 .base
= { __DRI_CORE
, 1 },
729 .createNewScreen
= NULL
,
730 .destroyScreen
= driDestroyScreen
,
731 .getExtensions
= driGetExtensions
,
732 .getConfigAttrib
= driGetConfigAttrib
,
733 .indexConfigAttrib
= driIndexConfigAttrib
,
734 .createNewDrawable
= NULL
,
735 .destroyDrawable
= driDestroyDrawable
,
736 .swapBuffers
= driSwapBuffers
, /* swrast */
737 .createNewContext
= driCreateNewContext
, /* swrast */
738 .copyContext
= driCopyContext
,
739 .destroyContext
= driDestroyContext
,
740 .bindContext
= driBindContext
,
741 .unbindContext
= driUnbindContext
744 /** DRI2 interface */
745 const __DRIdri2Extension driDRI2Extension
= {
746 .base
= { __DRI_DRI2
, 4 },
748 .createNewScreen
= dri2CreateNewScreen
,
749 .createNewDrawable
= driCreateNewDrawable
,
750 .createNewContext
= driCreateNewContext
,
751 .getAPIMask
= driGetAPIMask
,
752 .createNewContextForAPI
= driCreateNewContextForAPI
,
753 .allocateBuffer
= dri2AllocateBuffer
,
754 .releaseBuffer
= dri2ReleaseBuffer
,
755 .createContextAttribs
= driCreateContextAttribs
,
756 .createNewScreen2
= driCreateNewScreen2
,
759 const __DRIswrastExtension driSWRastExtension
= {
760 .base
= { __DRI_SWRAST
, 4 },
762 .createNewScreen
= driSWRastCreateNewScreen
,
763 .createNewDrawable
= driCreateNewDrawable
,
764 .createNewContextForAPI
= driCreateNewContextForAPI
,
765 .createContextAttribs
= driCreateContextAttribs
,
766 .createNewScreen2
= driSWRastCreateNewScreen2
,
769 const __DRI2configQueryExtension dri2ConfigQueryExtension
= {
770 .base
= { __DRI2_CONFIG_QUERY
, 1 },
772 .configQueryb
= dri2ConfigQueryb
,
773 .configQueryi
= dri2ConfigQueryi
,
774 .configQueryf
= dri2ConfigQueryf
,
778 dri2InvalidateDrawable(__DRIdrawable
*drawable
)
780 drawable
->dri2
.stamp
++;
784 * Check that the gl_framebuffer associated with dPriv is the right size.
785 * Resize the gl_framebuffer if needed.
786 * It's expected that the dPriv->driverPrivate member points to a
787 * gl_framebuffer object.
790 driUpdateFramebufferSize(struct gl_context
*ctx
, const __DRIdrawable
*dPriv
)
792 struct gl_framebuffer
*fb
= (struct gl_framebuffer
*) dPriv
->driverPrivate
;
793 if (fb
&& (dPriv
->w
!= fb
->Width
|| dPriv
->h
!= fb
->Height
)) {
794 ctx
->Driver
.ResizeBuffers(ctx
, fb
, dPriv
->w
, dPriv
->h
);
795 /* if the driver needs the hw lock for ResizeBuffers, the drawable
796 might have changed again by now */
797 assert(fb
->Width
== dPriv
->w
);
798 assert(fb
->Height
== dPriv
->h
);
803 driGLFormatToImageFormat(mesa_format format
)
806 case MESA_FORMAT_B5G6R5_UNORM
:
807 return __DRI_IMAGE_FORMAT_RGB565
;
808 case MESA_FORMAT_B8G8R8X8_UNORM
:
809 return __DRI_IMAGE_FORMAT_XRGB8888
;
810 case MESA_FORMAT_B10G10R10A2_UNORM
:
811 return __DRI_IMAGE_FORMAT_ARGB2101010
;
812 case MESA_FORMAT_B10G10R10X2_UNORM
:
813 return __DRI_IMAGE_FORMAT_XRGB2101010
;
814 case MESA_FORMAT_B8G8R8A8_UNORM
:
815 return __DRI_IMAGE_FORMAT_ARGB8888
;
816 case MESA_FORMAT_R8G8B8A8_UNORM
:
817 return __DRI_IMAGE_FORMAT_ABGR8888
;
818 case MESA_FORMAT_R8G8B8X8_UNORM
:
819 return __DRI_IMAGE_FORMAT_XBGR8888
;
820 case MESA_FORMAT_R_UNORM8
:
821 return __DRI_IMAGE_FORMAT_R8
;
822 case MESA_FORMAT_R8G8_UNORM
:
823 return __DRI_IMAGE_FORMAT_GR88
;
824 case MESA_FORMAT_NONE
:
825 return __DRI_IMAGE_FORMAT_NONE
;
826 case MESA_FORMAT_B8G8R8A8_SRGB
:
827 return __DRI_IMAGE_FORMAT_SARGB8
;
834 driImageFormatToGLFormat(uint32_t image_format
)
836 switch (image_format
) {
837 case __DRI_IMAGE_FORMAT_RGB565
:
838 return MESA_FORMAT_B5G6R5_UNORM
;
839 case __DRI_IMAGE_FORMAT_XRGB8888
:
840 return MESA_FORMAT_B8G8R8X8_UNORM
;
841 case __DRI_IMAGE_FORMAT_ARGB2101010
:
842 return MESA_FORMAT_B10G10R10A2_UNORM
;
843 case __DRI_IMAGE_FORMAT_XRGB2101010
:
844 return MESA_FORMAT_B10G10R10X2_UNORM
;
845 case __DRI_IMAGE_FORMAT_ARGB8888
:
846 return MESA_FORMAT_B8G8R8A8_UNORM
;
847 case __DRI_IMAGE_FORMAT_ABGR8888
:
848 return MESA_FORMAT_R8G8B8A8_UNORM
;
849 case __DRI_IMAGE_FORMAT_XBGR8888
:
850 return MESA_FORMAT_R8G8B8X8_UNORM
;
851 case __DRI_IMAGE_FORMAT_R8
:
852 return MESA_FORMAT_R_UNORM8
;
853 case __DRI_IMAGE_FORMAT_GR88
:
854 return MESA_FORMAT_R8G8_UNORM
;
855 case __DRI_IMAGE_FORMAT_SARGB8
:
856 return MESA_FORMAT_B8G8R8A8_SRGB
;
857 case __DRI_IMAGE_FORMAT_NONE
:
858 return MESA_FORMAT_NONE
;
860 return MESA_FORMAT_NONE
;
864 /** Image driver interface */
865 const __DRIimageDriverExtension driImageDriverExtension
= {
866 .base
= { __DRI_IMAGE_DRIVER
, 1 },
868 .createNewScreen2
= driCreateNewScreen2
,
869 .createNewDrawable
= driCreateNewDrawable
,
870 .getAPIMask
= driGetAPIMask
,
871 .createContextAttribs
= driCreateContextAttribs
,
874 /* swrast copy sub buffer entrypoint. */
875 static void driCopySubBuffer(__DRIdrawable
*pdp
, int x
, int y
,
878 assert(pdp
->driScreenPriv
->swrast_loader
);
880 pdp
->driScreenPriv
->driver
->CopySubBuffer(pdp
, x
, y
, w
, h
);
883 /* for swrast only */
884 const __DRIcopySubBufferExtension driCopySubBufferExtension
= {
885 .base
= { __DRI_COPY_SUB_BUFFER
, 1 },
887 .copySubBuffer
= driCopySubBuffer
,