1 /* 2 * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas. 3 * Copyright 2007-2008 Red Hat, Inc. 4 * (C) Copyright IBM Corporation 2004 5 * All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * on the rights to use, copy, modify, merge, publish, distribute, sub 11 * license, and/or sell copies of the Software, and to permit persons to whom 12 * the Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the next 15 * paragraph) shall be included in all copies or substantial portions of the 16 * Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 21 * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 24 * USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 /** 28 * \file dri_interface.h 29 * 30 * This file contains all the types and functions that define the interface 31 * between a DRI driver and driver loader. Currently, the most common driver 32 * loader is the XFree86 libGL.so. However, other loaders do exist, and in 33 * the future the server-side libglx.a will also be a loader. 34 * 35 * \author Kevin E. Martin <kevin (at) precisioninsight.com> 36 * \author Ian Romanick <idr (at) us.ibm.com> 37 * \author Kristian Hgsberg <krh (at) redhat.com> 38 */ 39 40 #ifndef DRI_INTERFACE_H 41 #define DRI_INTERFACE_H 42 43 #ifdef HAVE_LIBDRM 44 #include <drm.h> 45 #else 46 typedef unsigned int drm_context_t; 47 typedef unsigned int drm_drawable_t; 48 typedef struct drm_clip_rect drm_clip_rect_t; 49 #endif 50 51 #include <stdint.h> 52 53 /** 54 * \name DRI interface structures 55 * 56 * The following structures define the interface between the GLX client 57 * side library and the DRI (direct rendering infrastructure). 58 */ 59 /*@{*/ 60 typedef struct __DRIdisplayRec __DRIdisplay; 61 typedef struct __DRIscreenRec __DRIscreen; 62 typedef struct __DRIcontextRec __DRIcontext; 63 typedef struct __DRIdrawableRec __DRIdrawable; 64 typedef struct __DRIconfigRec __DRIconfig; 65 typedef struct __DRIframebufferRec __DRIframebuffer; 66 typedef struct __DRIversionRec __DRIversion; 67 68 typedef struct __DRIcoreExtensionRec __DRIcoreExtension; 69 typedef struct __DRIextensionRec __DRIextension; 70 typedef struct __DRIcopySubBufferExtensionRec __DRIcopySubBufferExtension; 71 typedef struct __DRIswapControlExtensionRec __DRIswapControlExtension; 72 typedef struct __DRIframeTrackingExtensionRec __DRIframeTrackingExtension; 73 typedef struct __DRImediaStreamCounterExtensionRec __DRImediaStreamCounterExtension; 74 typedef struct __DRItexOffsetExtensionRec __DRItexOffsetExtension; 75 typedef struct __DRItexBufferExtensionRec __DRItexBufferExtension; 76 typedef struct __DRIlegacyExtensionRec __DRIlegacyExtension; 77 typedef struct __DRIswrastExtensionRec __DRIswrastExtension; 78 typedef struct __DRIbufferRec __DRIbuffer; 79 typedef struct __DRIdri2ExtensionRec __DRIdri2Extension; 80 typedef struct __DRIdri2LoaderExtensionRec __DRIdri2LoaderExtension; 81 typedef struct __DRI2flushExtensionRec __DRI2flushExtension; 82 typedef struct __DRI2throttleExtensionRec __DRI2throttleExtension; 83 typedef struct __DRI2fenceExtensionRec __DRI2fenceExtension; 84 typedef struct __DRI2interopExtensionRec __DRI2interopExtension; 85 86 87 typedef struct __DRIimageLoaderExtensionRec __DRIimageLoaderExtension; 88 typedef struct __DRIimageDriverExtensionRec __DRIimageDriverExtension; 89 90 /*@}*/ 91 92 93 /** 94 * Extension struct. Drivers 'inherit' from this struct by embedding 95 * it as the first element in the extension struct. 96 * 97 * We never break API in for a DRI extension. If we need to change 98 * the way things work in a non-backwards compatible manner, we 99 * introduce a new extension. During a transition period, we can 100 * leave both the old and the new extension in the driver, which 101 * allows us to move to the new interface without having to update the 102 * loader(s) in lock step. 103 * 104 * However, we can add entry points to an extension over time as long 105 * as we don't break the old ones. As we add entry points to an 106 * extension, we increase the version number. The corresponding 107 * #define can be used to guard code that accesses the new entry 108 * points at compile time and the version field in the extension 109 * struct can be used at run-time to determine how to use the 110 * extension. 111 */ 112 struct __DRIextensionRec { 113 const char *name; 114 int version; 115 }; 116 117 /** 118 * The first set of extension are the screen extensions, returned by 119 * __DRIcore::getExtensions(). This entry point will return a list of 120 * extensions and the loader can use the ones it knows about by 121 * casting them to more specific extensions and advertising any GLX 122 * extensions the DRI extensions enables. 123 */ 124 125 /** 126 * Used by drivers to indicate support for setting the read drawable. 127 */ 128 #define __DRI_READ_DRAWABLE "DRI_ReadDrawable" 129 #define __DRI_READ_DRAWABLE_VERSION 1 130 131 /** 132 * Used by drivers that implement the GLX_MESA_copy_sub_buffer extension. 133 */ 134 #define __DRI_COPY_SUB_BUFFER "DRI_CopySubBuffer" 135 #define __DRI_COPY_SUB_BUFFER_VERSION 1 136 struct __DRIcopySubBufferExtensionRec { 137 __DRIextension base; 138 void (*copySubBuffer)(__DRIdrawable *drawable, int x, int y, int w, int h); 139 }; 140 141 /** 142 * Used by drivers that implement the GLX_SGI_swap_control or 143 * GLX_MESA_swap_control extension. 144 */ 145 #define __DRI_SWAP_CONTROL "DRI_SwapControl" 146 #define __DRI_SWAP_CONTROL_VERSION 1 147 struct __DRIswapControlExtensionRec { 148 __DRIextension base; 149 void (*setSwapInterval)(__DRIdrawable *drawable, unsigned int inteval); 150 unsigned int (*getSwapInterval)(__DRIdrawable *drawable); 151 }; 152 153 /** 154 * Used by drivers that implement the GLX_MESA_swap_frame_usage extension. 155 */ 156 #define __DRI_FRAME_TRACKING "DRI_FrameTracking" 157 #define __DRI_FRAME_TRACKING_VERSION 1 158 struct __DRIframeTrackingExtensionRec { 159 __DRIextension base; 160 161 /** 162 * Enable or disable frame usage tracking. 163 * 164 * \since Internal API version 20030317. 165 */ 166 int (*frameTracking)(__DRIdrawable *drawable, GLboolean enable); 167 168 /** 169 * Retrieve frame usage information. 170 * 171 * \since Internal API version 20030317. 172 */ 173 int (*queryFrameTracking)(__DRIdrawable *drawable, 174 int64_t * sbc, int64_t * missedFrames, 175 float * lastMissedUsage, float * usage); 176 }; 177 178 179 /** 180 * Used by drivers that implement the GLX_SGI_video_sync extension. 181 */ 182 #define __DRI_MEDIA_STREAM_COUNTER "DRI_MediaStreamCounter" 183 #define __DRI_MEDIA_STREAM_COUNTER_VERSION 1 184 struct __DRImediaStreamCounterExtensionRec { 185 __DRIextension base; 186 187 /** 188 * Wait for the MSC to equal target_msc, or, if that has already passed, 189 * the next time (MSC % divisor) is equal to remainder. If divisor is 190 * zero, the function will return as soon as MSC is greater than or equal 191 * to target_msc. 192 */ 193 int (*waitForMSC)(__DRIdrawable *drawable, 194 int64_t target_msc, int64_t divisor, int64_t remainder, 195 int64_t * msc, int64_t * sbc); 196 197 /** 198 * Get the number of vertical refreshes since some point in time before 199 * this function was first called (i.e., system start up). 200 */ 201 int (*getDrawableMSC)(__DRIscreen *screen, __DRIdrawable *drawable, 202 int64_t *msc); 203 }; 204 205 206 #define __DRI_TEX_OFFSET "DRI_TexOffset" 207 #define __DRI_TEX_OFFSET_VERSION 1 208 struct __DRItexOffsetExtensionRec { 209 __DRIextension base; 210 211 /** 212 * Method to override base texture image with a driver specific 'offset'. 213 * The depth passed in allows e.g. to ignore the alpha channel of texture 214 * images where the non-alpha components don't occupy a whole texel. 215 * 216 * For GLX_EXT_texture_from_pixmap with AIGLX. 217 */ 218 void (*setTexOffset)(__DRIcontext *pDRICtx, GLint texname, 219 unsigned long long offset, GLint depth, GLuint pitch); 220 }; 221 222 223 /* Valid values for format in the setTexBuffer2 function below. These 224 * values match the GLX tokens for compatibility reasons, but we 225 * define them here since the DRI interface can't depend on GLX. */ 226 #define __DRI_TEXTURE_FORMAT_NONE 0x20D8 227 #define __DRI_TEXTURE_FORMAT_RGB 0x20D9 228 #define __DRI_TEXTURE_FORMAT_RGBA 0x20DA 229 230 #define __DRI_TEX_BUFFER "DRI_TexBuffer" 231 #define __DRI_TEX_BUFFER_VERSION 3 232 struct __DRItexBufferExtensionRec { 233 __DRIextension base; 234 235 /** 236 * Method to override base texture image with the contents of a 237 * __DRIdrawable. 238 * 239 * For GLX_EXT_texture_from_pixmap with AIGLX. Deprecated in favor of 240 * setTexBuffer2 in version 2 of this interface 241 */ 242 void (*setTexBuffer)(__DRIcontext *pDRICtx, 243 GLint target, 244 __DRIdrawable *pDraw); 245 246 /** 247 * Method to override base texture image with the contents of a 248 * __DRIdrawable, including the required texture format attribute. 249 * 250 * For GLX_EXT_texture_from_pixmap with AIGLX. 251 * 252 * \since 2 253 */ 254 void (*setTexBuffer2)(__DRIcontext *pDRICtx, 255 GLint target, 256 GLint format, 257 __DRIdrawable *pDraw); 258 /** 259 * Method to release texture buffer in case some special platform 260 * need this. 261 * 262 * For GLX_EXT_texture_from_pixmap with AIGLX. 263 * 264 * \since 3 265 */ 266 void (*releaseTexBuffer)(__DRIcontext *pDRICtx, 267 GLint target, 268 __DRIdrawable *pDraw); 269 }; 270 271 /** 272 * Used by drivers that implement DRI2 273 */ 274 #define __DRI2_FLUSH "DRI2_Flush" 275 #define __DRI2_FLUSH_VERSION 4 276 277 #define __DRI2_FLUSH_DRAWABLE (1 << 0) /* the drawable should be flushed. */ 278 #define __DRI2_FLUSH_CONTEXT (1 << 1) /* glFlush should be called */ 279 #define __DRI2_FLUSH_INVALIDATE_ANCILLARY (1 << 2) 280 281 enum __DRI2throttleReason { 282 __DRI2_THROTTLE_SWAPBUFFER, 283 __DRI2_THROTTLE_COPYSUBBUFFER, 284 __DRI2_THROTTLE_FLUSHFRONT 285 }; 286 287 struct __DRI2flushExtensionRec { 288 __DRIextension base; 289 void (*flush)(__DRIdrawable *drawable); 290 291 /** 292 * Ask the driver to call getBuffers/getBuffersWithFormat before 293 * it starts rendering again. 294 * 295 * \param drawable the drawable to invalidate 296 * 297 * \since 3 298 */ 299 void (*invalidate)(__DRIdrawable *drawable); 300 301 /** 302 * This function reduces the number of flushes in the driver by combining 303 * several operations into one call. 304 * 305 * It can: 306 * - throttle 307 * - flush a drawable 308 * - flush a context 309 * 310 * \param context the context 311 * \param drawable the drawable to flush 312 * \param flags a combination of _DRI2_FLUSH_xxx flags 313 * \param throttle_reason the reason for throttling, 0 = no throttling 314 * 315 * \since 4 316 */ 317 void (*flush_with_flags)(__DRIcontext *ctx, 318 __DRIdrawable *drawable, 319 unsigned flags, 320 enum __DRI2throttleReason throttle_reason); 321 }; 322 323 324 /** 325 * Extension that the driver uses to request 326 * throttle callbacks. 327 */ 328 329 #define __DRI2_THROTTLE "DRI2_Throttle" 330 #define __DRI2_THROTTLE_VERSION 1 331 332 struct __DRI2throttleExtensionRec { 333 __DRIextension base; 334 void (*throttle)(__DRIcontext *ctx, 335 __DRIdrawable *drawable, 336 enum __DRI2throttleReason reason); 337 }; 338 339 340 /** 341 * Extension for fences / synchronization objects. 342 */ 343 344 #define __DRI2_FENCE "DRI2_Fence" 345 #define __DRI2_FENCE_VERSION 2 346 347 #define __DRI2_FENCE_TIMEOUT_INFINITE 0xffffffffffffffffull 348 349 #define __DRI2_FENCE_FLAG_FLUSH_COMMANDS (1 << 0) 350 351 /** 352 * \name Capabilities that might be returned by __DRI2fenceExtensionRec::get_capabilities 353 */ 354 /*@{*/ 355 #define __DRI_FENCE_CAP_NATIVE_FD 1 356 /*@}*/ 357 358 struct __DRI2fenceExtensionRec { 359 __DRIextension base; 360 361 /** 362 * Create and insert a fence into the command stream of the context. 363 */ 364 void *(*create_fence)(__DRIcontext *ctx); 365 366 /** 367 * Get a fence associated with the OpenCL event object. 368 * This can be NULL, meaning that OpenCL interoperability is not supported. 369 */ 370 void *(*get_fence_from_cl_event)(__DRIscreen *screen, intptr_t cl_event); 371 372 /** 373 * Destroy a fence. 374 */ 375 void (*destroy_fence)(__DRIscreen *screen, void *fence); 376 377 /** 378 * This function waits and doesn't return until the fence is signalled 379 * or the timeout expires. It returns true if the fence has been signaled. 380 * 381 * \param ctx the context where commands are flushed 382 * \param fence the fence 383 * \param flags a combination of __DRI2_FENCE_FLAG_xxx flags 384 * \param timeout the timeout in ns or __DRI2_FENCE_TIMEOUT_INFINITE 385 */ 386 GLboolean (*client_wait_sync)(__DRIcontext *ctx, void *fence, 387 unsigned flags, uint64_t timeout); 388 389 /** 390 * This function enqueues a wait command into the command stream of 391 * the context and then returns. When the execution reaches the wait 392 * command, no further execution will be done in the context until 393 * the fence is signaled. This is a no-op if the device doesn't support 394 * parallel execution of contexts. 395 * 396 * \param ctx the context where the waiting is done 397 * \param fence the fence 398 * \param flags a combination of __DRI2_FENCE_FLAG_xxx flags that make 399 * sense with this function (right now there are none) 400 */ 401 void (*server_wait_sync)(__DRIcontext *ctx, void *fence, unsigned flags); 402 403 /** 404 * Query for general capabilities of the driver that concern fences. 405 * Returns a bitmask of __DRI_FENCE_CAP_x 406 * 407 * \since 2 408 */ 409 unsigned (*get_capabilities)(__DRIscreen *screen); 410 411 /** 412 * Create an fd (file descriptor) associated fence. If the fence fd 413 * is -1, this behaves similarly to create_fence() except that when 414 * rendering is flushed the driver creates a fence fd. Otherwise, 415 * the driver wraps an existing fence fd. 416 * 417 * This is used to implement the EGL_ANDROID_native_fence_sync extension. 418 * 419 * \since 2 420 * 421 * \param ctx the context associated with the fence 422 * \param fd the fence fd or -1 423 */ 424 void *(*create_fence_fd)(__DRIcontext *ctx, int fd); 425 426 /** 427 * For fences created with create_fence_fd(), after rendering is flushed, 428 * this retrieves the native fence fd. Caller takes ownership of the 429 * fd and will close() it when it is no longer needed. 430 * 431 * \since 2 432 * 433 * \param screen the screen associated with the fence 434 * \param fence the fence 435 */ 436 int (*get_fence_fd)(__DRIscreen *screen, void *fence); 437 }; 438 439 440 /** 441 * Extension for API interop. 442 * See GL/mesa_glinterop.h. 443 */ 444 445 #define __DRI2_INTEROP "DRI2_Interop" 446 #define __DRI2_INTEROP_VERSION 1 447 448 struct mesa_glinterop_device_info; 449 struct mesa_glinterop_export_in; 450 struct mesa_glinterop_export_out; 451 452 struct __DRI2interopExtensionRec { 453 __DRIextension base; 454 455 /** Same as MesaGLInterop*QueryDeviceInfo. */ 456 int (*query_device_info)(__DRIcontext *ctx, 457 struct mesa_glinterop_device_info *out); 458 459 /** Same as MesaGLInterop*ExportObject. */ 460 int (*export_object)(__DRIcontext *ctx, 461 struct mesa_glinterop_export_in *in, 462 struct mesa_glinterop_export_out *out); 463 }; 464 465 /*@}*/ 466 467 /** 468 * The following extensions describe loader features that the DRI 469 * driver can make use of. Some of these are mandatory, such as the 470 * getDrawableInfo extension for DRI and the DRI Loader extensions for 471 * DRI2, while others are optional, and if present allow the driver to 472 * expose certain features. The loader pass in a NULL terminated 473 * array of these extensions to the driver in the createNewScreen 474 * constructor. 475 */ 476 477 typedef struct __DRIgetDrawableInfoExtensionRec __DRIgetDrawableInfoExtension; 478 typedef struct __DRIsystemTimeExtensionRec __DRIsystemTimeExtension; 479 typedef struct __DRIdamageExtensionRec __DRIdamageExtension; 480 typedef struct __DRIloaderExtensionRec __DRIloaderExtension; 481 typedef struct __DRIswrastLoaderExtensionRec __DRIswrastLoaderExtension; 482 483 484 /** 485 * Callback to getDrawableInfo protocol 486 */ 487 #define __DRI_GET_DRAWABLE_INFO "DRI_GetDrawableInfo" 488 #define __DRI_GET_DRAWABLE_INFO_VERSION 1 489 struct __DRIgetDrawableInfoExtensionRec { 490 __DRIextension base; 491 492 /** 493 * This function is used to get information about the position, size, and 494 * clip rects of a drawable. 495 */ 496 GLboolean (* getDrawableInfo) ( __DRIdrawable *drawable, 497 unsigned int * index, unsigned int * stamp, 498 int * x, int * y, int * width, int * height, 499 int * numClipRects, drm_clip_rect_t ** pClipRects, 500 int * backX, int * backY, 501 int * numBackClipRects, drm_clip_rect_t ** pBackClipRects, 502 void *loaderPrivate); 503 }; 504 505 /** 506 * Callback to get system time for media stream counter extensions. 507 */ 508 #define __DRI_SYSTEM_TIME "DRI_SystemTime" 509 #define __DRI_SYSTEM_TIME_VERSION 1 510 struct __DRIsystemTimeExtensionRec { 511 __DRIextension base; 512 513 /** 514 * Get the 64-bit unadjusted system time (UST). 515 */ 516 int (*getUST)(int64_t * ust); 517 518 /** 519 * Get the media stream counter (MSC) rate. 520 * 521 * Matching the definition in GLX_OML_sync_control, this function returns 522 * the rate of the "media stream counter". In practical terms, this is 523 * the frame refresh rate of the display. 524 */ 525 GLboolean (*getMSCRate)(__DRIdrawable *draw, 526 int32_t * numerator, int32_t * denominator, 527 void *loaderPrivate); 528 }; 529 530 /** 531 * Damage reporting 532 */ 533 #define __DRI_DAMAGE "DRI_Damage" 534 #define __DRI_DAMAGE_VERSION 1 535 struct __DRIdamageExtensionRec { 536 __DRIextension base; 537 538 /** 539 * Reports areas of the given drawable which have been modified by the 540 * driver. 541 * 542 * \param drawable which the drawing was done to. 543 * \param rects rectangles affected, with the drawable origin as the 544 * origin. 545 * \param x X offset of the drawable within the screen (used in the 546 * front_buffer case) 547 * \param y Y offset of the drawable within the screen. 548 * \param front_buffer boolean flag for whether the drawing to the 549 * drawable was actually done directly to the front buffer (instead 550 * of backing storage, for example) 551 * \param loaderPrivate the data passed in at createNewDrawable time 552 */ 553 void (*reportDamage)(__DRIdrawable *draw, 554 int x, int y, 555 drm_clip_rect_t *rects, int num_rects, 556 GLboolean front_buffer, 557 void *loaderPrivate); 558 }; 559 560 #define __DRI_SWRAST_IMAGE_OP_DRAW 1 561 #define __DRI_SWRAST_IMAGE_OP_CLEAR 2 562 #define __DRI_SWRAST_IMAGE_OP_SWAP 3 563 564 /** 565 * SWRast Loader extension. 566 */ 567 #define __DRI_SWRAST_LOADER "DRI_SWRastLoader" 568 #define __DRI_SWRAST_LOADER_VERSION 3 569 struct __DRIswrastLoaderExtensionRec { 570 __DRIextension base; 571 572 /* 573 * Drawable position and size 574 */ 575 void (*getDrawableInfo)(__DRIdrawable *drawable, 576 int *x, int *y, int *width, int *height, 577 void *loaderPrivate); 578 579 /** 580 * Put image to drawable 581 */ 582 void (*putImage)(__DRIdrawable *drawable, int op, 583 int x, int y, int width, int height, 584 char *data, void *loaderPrivate); 585 586 /** 587 * Get image from readable 588 */ 589 void (*getImage)(__DRIdrawable *readable, 590 int x, int y, int width, int height, 591 char *data, void *loaderPrivate); 592 593 /** 594 * Put image to drawable 595 * 596 * \since 2 597 */ 598 void (*putImage2)(__DRIdrawable *drawable, int op, 599 int x, int y, int width, int height, int stride, 600 char *data, void *loaderPrivate); 601 602 /** 603 * Put image to drawable 604 * 605 * \since 3 606 */ 607 void (*getImage2)(__DRIdrawable *readable, 608 int x, int y, int width, int height, int stride, 609 char *data, void *loaderPrivate); 610 }; 611 612 /** 613 * Invalidate loader extension. The presence of this extension 614 * indicates to the DRI driver that the loader will call invalidate in 615 * the __DRI2_FLUSH extension, whenever the needs to query for new 616 * buffers. This means that the DRI driver can drop the polling in 617 * glViewport(). 618 * 619 * The extension doesn't provide any functionality, it's only use to 620 * indicate to the driver that it can use the new semantics. A DRI 621 * driver can use this to switch between the different semantics or 622 * just refuse to initialize if this extension isn't present. 623 */ 624 #define __DRI_USE_INVALIDATE "DRI_UseInvalidate" 625 #define __DRI_USE_INVALIDATE_VERSION 1 626 627 typedef struct __DRIuseInvalidateExtensionRec __DRIuseInvalidateExtension; 628 struct __DRIuseInvalidateExtensionRec { 629 __DRIextension base; 630 }; 631 632 /** 633 * The remaining extensions describe driver extensions, immediately 634 * available interfaces provided by the driver. To start using the 635 * driver, dlsym() for the __DRI_DRIVER_EXTENSIONS symbol and look for 636 * the extension you need in the array. 637 */ 638 #define __DRI_DRIVER_EXTENSIONS "__driDriverExtensions" 639 640 /** 641 * This symbol replaces the __DRI_DRIVER_EXTENSIONS symbol, and will be 642 * suffixed by "_drivername", allowing multiple drivers to be built into one 643 * library, and also giving the driver the chance to return a variable driver 644 * extensions struct depending on the driver name being loaded or any other 645 * system state. 646 * 647 * The function prototype is: 648 * 649 * const __DRIextension **__driDriverGetExtensions_drivername(void); 650 */ 651 #define __DRI_DRIVER_GET_EXTENSIONS "__driDriverGetExtensions" 652 653 /** 654 * Tokens for __DRIconfig attribs. A number of attributes defined by 655 * GLX or EGL standards are not in the table, as they must be provided 656 * by the loader. For example, FBConfig ID or visual ID, drawable type. 657 */ 658 659 #define __DRI_ATTRIB_BUFFER_SIZE 1 660 #define __DRI_ATTRIB_LEVEL 2 661 #define __DRI_ATTRIB_RED_SIZE 3 662 #define __DRI_ATTRIB_GREEN_SIZE 4 663 #define __DRI_ATTRIB_BLUE_SIZE 5 664 #define __DRI_ATTRIB_LUMINANCE_SIZE 6 665 #define __DRI_ATTRIB_ALPHA_SIZE 7 666 #define __DRI_ATTRIB_ALPHA_MASK_SIZE 8 667 #define __DRI_ATTRIB_DEPTH_SIZE 9 668 #define __DRI_ATTRIB_STENCIL_SIZE 10 669 #define __DRI_ATTRIB_ACCUM_RED_SIZE 11 670 #define __DRI_ATTRIB_ACCUM_GREEN_SIZE 12 671 #define __DRI_ATTRIB_ACCUM_BLUE_SIZE 13 672 #define __DRI_ATTRIB_ACCUM_ALPHA_SIZE 14 673 #define __DRI_ATTRIB_SAMPLE_BUFFERS 15 674 #define __DRI_ATTRIB_SAMPLES 16 675 #define __DRI_ATTRIB_RENDER_TYPE 17 676 #define __DRI_ATTRIB_CONFIG_CAVEAT 18 677 #define __DRI_ATTRIB_CONFORMANT 19 678 #define __DRI_ATTRIB_DOUBLE_BUFFER 20 679 #define __DRI_ATTRIB_STEREO 21 680 #define __DRI_ATTRIB_AUX_BUFFERS 22 681 #define __DRI_ATTRIB_TRANSPARENT_TYPE 23 682 #define __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE 24 683 #define __DRI_ATTRIB_TRANSPARENT_RED_VALUE 25 684 #define __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE 26 685 #define __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE 27 686 #define __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE 28 687 #define __DRI_ATTRIB_FLOAT_MODE 29 688 #define __DRI_ATTRIB_RED_MASK 30 689 #define __DRI_ATTRIB_GREEN_MASK 31 690 #define __DRI_ATTRIB_BLUE_MASK 32 691 #define __DRI_ATTRIB_ALPHA_MASK 33 692 #define __DRI_ATTRIB_MAX_PBUFFER_WIDTH 34 693 #define __DRI_ATTRIB_MAX_PBUFFER_HEIGHT 35 694 #define __DRI_ATTRIB_MAX_PBUFFER_PIXELS 36 695 #define __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH 37 696 #define __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT 38 697 #define __DRI_ATTRIB_VISUAL_SELECT_GROUP 39 698 #define __DRI_ATTRIB_SWAP_METHOD 40 699 #define __DRI_ATTRIB_MAX_SWAP_INTERVAL 41 700 #define __DRI_ATTRIB_MIN_SWAP_INTERVAL 42 701 #define __DRI_ATTRIB_BIND_TO_TEXTURE_RGB 43 702 #define __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA 44 703 #define __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE 45 704 #define __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS 46 705 #define __DRI_ATTRIB_YINVERTED 47 706 #define __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE 48 707 #define __DRI_ATTRIB_MAX (__DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE + 1) 708 709 /* __DRI_ATTRIB_RENDER_TYPE */ 710 #define __DRI_ATTRIB_RGBA_BIT 0x01 711 #define __DRI_ATTRIB_COLOR_INDEX_BIT 0x02 712 #define __DRI_ATTRIB_LUMINANCE_BIT 0x04 713 #define __DRI_ATTRIB_FLOAT_BIT 0x08 714 #define __DRI_ATTRIB_UNSIGNED_FLOAT_BIT 0x10 715 716 /* __DRI_ATTRIB_CONFIG_CAVEAT */ 717 #define __DRI_ATTRIB_SLOW_BIT 0x01 718 #define __DRI_ATTRIB_NON_CONFORMANT_CONFIG 0x02 719 720 /* __DRI_ATTRIB_TRANSPARENT_TYPE */ 721 #define __DRI_ATTRIB_TRANSPARENT_RGB 0x00 722 #define __DRI_ATTRIB_TRANSPARENT_INDEX 0x01 723 724 /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */ 725 #define __DRI_ATTRIB_TEXTURE_1D_BIT 0x01 726 #define __DRI_ATTRIB_TEXTURE_2D_BIT 0x02 727 #define __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT 0x04 728 729 /* __DRI_ATTRIB_SWAP_METHOD */ 730 /* Note that with the exception of __DRI_ATTRIB_SWAP_NONE, we need to define 731 * the same tokens as GLX. This is because old and current X servers will 732 * transmit the driconf value grabbed from the AIGLX driver untranslated as 733 * the GLX fbconfig value. __DRI_ATTRIB_SWAP_NONE is only used by dri drivers 734 * to signal to the dri core that the driconfig is single-buffer. 735 */ 736 #define __DRI_ATTRIB_SWAP_NONE 0x0000 737 #define __DRI_ATTRIB_SWAP_EXCHANGE 0x8061 738 #define __DRI_ATTRIB_SWAP_COPY 0x8062 739 #define __DRI_ATTRIB_SWAP_UNDEFINED 0x8063 740 741 /** 742 * This extension defines the core DRI functionality. 743 * 744 * Version >= 2 indicates that getConfigAttrib with __DRI_ATTRIB_SWAP_METHOD 745 * returns a reliable value. 746 */ 747 #define __DRI_CORE "DRI_Core" 748 #define __DRI_CORE_VERSION 2 749 750 struct __DRIcoreExtensionRec { 751 __DRIextension base; 752 753 __DRIscreen *(*createNewScreen)(int screen, int fd, 754 unsigned int sarea_handle, 755 const __DRIextension **extensions, 756 const __DRIconfig ***driverConfigs, 757 void *loaderPrivate); 758 759 void (*destroyScreen)(__DRIscreen *screen); 760 761 const __DRIextension **(*getExtensions)(__DRIscreen *screen); 762 763 int (*getConfigAttrib)(const __DRIconfig *config, 764 unsigned int attrib, 765 unsigned int *value); 766 767 int (*indexConfigAttrib)(const __DRIconfig *config, int index, 768 unsigned int *attrib, unsigned int *value); 769 770 __DRIdrawable *(*createNewDrawable)(__DRIscreen *screen, 771 const __DRIconfig *config, 772 unsigned int drawable_id, 773 unsigned int head, 774 void *loaderPrivate); 775 776 void (*destroyDrawable)(__DRIdrawable *drawable); 777 778 void (*swapBuffers)(__DRIdrawable *drawable); 779 780 __DRIcontext *(*createNewContext)(__DRIscreen *screen, 781 const __DRIconfig *config, 782 __DRIcontext *shared, 783 void *loaderPrivate); 784 785 int (*copyContext)(__DRIcontext *dest, 786 __DRIcontext *src, 787 unsigned long mask); 788 789 void (*destroyContext)(__DRIcontext *context); 790 791 int (*bindContext)(__DRIcontext *ctx, 792 __DRIdrawable *pdraw, 793 __DRIdrawable *pread); 794 795 int (*unbindContext)(__DRIcontext *ctx); 796 }; 797 798 /** 799 * Stored version of some component (i.e., server-side DRI module, kernel-side 800 * DRM, etc.). 801 * 802 * \todo 803 * There are several data structures that explicitly store a major version, 804 * minor version, and patch level. These structures should be modified to 805 * have a \c __DRIversionRec instead. 806 */ 807 struct __DRIversionRec { 808 int major; /**< Major version number. */ 809 int minor; /**< Minor version number. */ 810 int patch; /**< Patch-level. */ 811 }; 812 813 /** 814 * Framebuffer information record. Used by libGL to communicate information 815 * about the framebuffer to the driver's \c __driCreateNewScreen function. 816 * 817 * In XFree86, most of this information is derrived from data returned by 818 * calling \c XF86DRIGetDeviceInfo. 819 * 820 * \sa XF86DRIGetDeviceInfo __DRIdisplayRec::createNewScreen 821 * __driUtilCreateNewScreen CallCreateNewScreen 822 * 823 * \bug This structure could be better named. 824 */ 825 struct __DRIframebufferRec { 826 unsigned char *base; /**< Framebuffer base address in the CPU's 827 * address space. This value is calculated by 828 * calling \c drmMap on the framebuffer handle 829 * returned by \c XF86DRIGetDeviceInfo (or a 830 * similar function). 831 */ 832 int size; /**< Framebuffer size, in bytes. */ 833 int stride; /**< Number of bytes from one line to the next. */ 834 int width; /**< Pixel width of the framebuffer. */ 835 int height; /**< Pixel height of the framebuffer. */ 836 int dev_priv_size; /**< Size of the driver's dev-priv structure. */ 837 void *dev_priv; /**< Pointer to the driver's dev-priv structure. */ 838 }; 839 840 841 /** 842 * This extension provides alternative screen, drawable and context 843 * constructors for legacy DRI functionality. This is used in 844 * conjunction with the core extension. 845 */ 846 #define __DRI_LEGACY "DRI_Legacy" 847 #define __DRI_LEGACY_VERSION 1 848 849 struct __DRIlegacyExtensionRec { 850 __DRIextension base; 851 852 __DRIscreen *(*createNewScreen)(int screen, 853 const __DRIversion *ddx_version, 854 const __DRIversion *dri_version, 855 const __DRIversion *drm_version, 856 const __DRIframebuffer *frame_buffer, 857 void *pSAREA, int fd, 858 const __DRIextension **extensions, 859 const __DRIconfig ***driver_configs, 860 void *loaderPrivate); 861 862 __DRIdrawable *(*createNewDrawable)(__DRIscreen *screen, 863 const __DRIconfig *config, 864 drm_drawable_t hwDrawable, 865 int renderType, const int *attrs, 866 void *loaderPrivate); 867 868 __DRIcontext *(*createNewContext)(__DRIscreen *screen, 869 const __DRIconfig *config, 870 int render_type, 871 __DRIcontext *shared, 872 drm_context_t hwContext, 873 void *loaderPrivate); 874 }; 875 876 /** 877 * This extension provides alternative screen, drawable and context 878 * constructors for swrast DRI functionality. This is used in 879 * conjunction with the core extension. 880 */ 881 #define __DRI_SWRAST "DRI_SWRast" 882 #define __DRI_SWRAST_VERSION 4 883 884 struct __DRIswrastExtensionRec { 885 __DRIextension base; 886 887 __DRIscreen *(*createNewScreen)(int screen, 888 const __DRIextension **extensions, 889 const __DRIconfig ***driver_configs, 890 void *loaderPrivate); 891 892 __DRIdrawable *(*createNewDrawable)(__DRIscreen *screen, 893 const __DRIconfig *config, 894 void *loaderPrivate); 895 896 /* Since version 2 */ 897 __DRIcontext *(*createNewContextForAPI)(__DRIscreen *screen, 898 int api, 899 const __DRIconfig *config, 900 __DRIcontext *shared, 901 void *data); 902 903 /** 904 * Create a context for a particular API with a set of attributes 905 * 906 * \since version 3 907 * 908 * \sa __DRIdri2ExtensionRec::createContextAttribs 909 */ 910 __DRIcontext *(*createContextAttribs)(__DRIscreen *screen, 911 int api, 912 const __DRIconfig *config, 913 __DRIcontext *shared, 914 unsigned num_attribs, 915 const uint32_t *attribs, 916 unsigned *error, 917 void *loaderPrivate); 918 919 /** 920 * createNewScreen() with the driver extensions passed in. 921 * 922 * \since version 4 923 */ 924 __DRIscreen *(*createNewScreen2)(int screen, 925 const __DRIextension **loader_extensions, 926 const __DRIextension **driver_extensions, 927 const __DRIconfig ***driver_configs, 928 void *loaderPrivate); 929 930 }; 931 932 /** Common DRI function definitions, shared among DRI2 and Image extensions 933 */ 934 935 typedef __DRIscreen * 936 (*__DRIcreateNewScreen2Func)(int screen, int fd, 937 const __DRIextension **extensions, 938 const __DRIextension **driver_extensions, 939 const __DRIconfig ***driver_configs, 940 void *loaderPrivate); 941 942 typedef __DRIdrawable * 943 (*__DRIcreateNewDrawableFunc)(__DRIscreen *screen, 944 const __DRIconfig *config, 945 void *loaderPrivate); 946 947 typedef __DRIcontext * 948 (*__DRIcreateContextAttribsFunc)(__DRIscreen *screen, 949 int api, 950 const __DRIconfig *config, 951 __DRIcontext *shared, 952 unsigned num_attribs, 953 const uint32_t *attribs, 954 unsigned *error, 955 void *loaderPrivate); 956 957 typedef unsigned int 958 (*__DRIgetAPIMaskFunc)(__DRIscreen *screen); 959 960 /** 961 * DRI2 Loader extension. 962 */ 963 #define __DRI_BUFFER_FRONT_LEFT 0 964 #define __DRI_BUFFER_BACK_LEFT 1 965 #define __DRI_BUFFER_FRONT_RIGHT 2 966 #define __DRI_BUFFER_BACK_RIGHT 3 967 #define __DRI_BUFFER_DEPTH 4 968 #define __DRI_BUFFER_STENCIL 5 969 #define __DRI_BUFFER_ACCUM 6 970 #define __DRI_BUFFER_FAKE_FRONT_LEFT 7 971 #define __DRI_BUFFER_FAKE_FRONT_RIGHT 8 972 #define __DRI_BUFFER_DEPTH_STENCIL 9 /**< Only available with DRI2 1.1 */ 973 #define __DRI_BUFFER_HIZ 10 974 975 /* Inofficial and for internal use. Increase when adding a new buffer token. */ 976 #define __DRI_BUFFER_COUNT 11 977 978 struct __DRIbufferRec { 979 unsigned int attachment; 980 unsigned int name; 981 unsigned int pitch; 982 unsigned int cpp; 983 unsigned int flags; 984 }; 985 986 #define __DRI_DRI2_LOADER "DRI_DRI2Loader" 987 #define __DRI_DRI2_LOADER_VERSION 4 988 989 enum dri_loader_cap { 990 /* Whether the loader handles RGBA channel ordering correctly. If not, 991 * only BGRA ordering can be exposed. 992 */ 993 DRI_LOADER_CAP_RGBA_ORDERING, 994 }; 995 996 struct __DRIdri2LoaderExtensionRec { 997 __DRIextension base; 998 999 __DRIbuffer *(*getBuffers)(__DRIdrawable *driDrawable, 1000 int *width, int *height, 1001 unsigned int *attachments, int count, 1002 int *out_count, void *loaderPrivate); 1003 1004 /** 1005 * Flush pending front-buffer rendering 1006 * 1007 * Any rendering that has been performed to the 1008 * \c __DRI_BUFFER_FAKE_FRONT_LEFT will be flushed to the 1009 * \c __DRI_BUFFER_FRONT_LEFT. 1010 * 1011 * \param driDrawable Drawable whose front-buffer is to be flushed 1012 * \param loaderPrivate Loader's private data that was previously passed 1013 * into __DRIdri2ExtensionRec::createNewDrawable 1014 * 1015 * \since 2 1016 */ 1017 void (*flushFrontBuffer)(__DRIdrawable *driDrawable, void *loaderPrivate); 1018 1019 1020 /** 1021 * Get list of buffers from the server 1022 * 1023 * Gets a list of buffer for the specified set of attachments. Unlike 1024 * \c ::getBuffers, this function takes a list of attachments paired with 1025 * opaque \c unsigned \c int value describing the format of the buffer. 1026 * It is the responsibility of the caller to know what the service that 1027 * allocates the buffers will expect to receive for the format. 1028 * 1029 * \param driDrawable Drawable whose buffers are being queried. 1030 * \param width Output where the width of the buffers is stored. 1031 * \param height Output where the height of the buffers is stored. 1032 * \param attachments List of pairs of attachment ID and opaque format 1033 * requested for the drawable. 1034 * \param count Number of attachment / format pairs stored in 1035 * \c attachments. 1036 * \param loaderPrivate Loader's private data that was previously passed 1037 * into __DRIdri2ExtensionRec::createNewDrawable. 1038 * 1039 * \since 3 1040 */ 1041 __DRIbuffer *(*getBuffersWithFormat)(__DRIdrawable *driDrawable, 1042 int *width, int *height, 1043 unsigned int *attachments, int count, 1044 int *out_count, void *loaderPrivate); 1045 1046 /** 1047 * Return a loader capability value. If the loader doesn't know the enum, 1048 * it will return 0. 1049 * 1050 * \param loaderPrivate The last parameter of createNewScreen or 1051 * createNewScreen2. 1052 * \param cap See the enum. 1053 * 1054 * \since 4 1055 */ 1056 unsigned (*getCapability)(void *loaderPrivate, enum dri_loader_cap cap); 1057 }; 1058 1059 /** 1060 * This extension provides alternative screen, drawable and context 1061 * constructors for DRI2. 1062 */ 1063 #define __DRI_DRI2 "DRI_DRI2" 1064 #define __DRI_DRI2_VERSION 4 1065 1066 #define __DRI_API_OPENGL 0 /**< OpenGL compatibility profile */ 1067 #define __DRI_API_GLES 1 /**< OpenGL ES 1.x */ 1068 #define __DRI_API_GLES2 2 /**< OpenGL ES 2.x */ 1069 #define __DRI_API_OPENGL_CORE 3 /**< OpenGL 3.2+ core profile */ 1070 #define __DRI_API_GLES3 4 /**< OpenGL ES 3.x */ 1071 1072 #define __DRI_CTX_ATTRIB_MAJOR_VERSION 0 1073 #define __DRI_CTX_ATTRIB_MINOR_VERSION 1 1074 #define __DRI_CTX_ATTRIB_FLAGS 2 1075 1076 /** 1077 * \requires __DRI2_ROBUSTNESS. 1078 */ 1079 #define __DRI_CTX_ATTRIB_RESET_STRATEGY 3 1080 1081 #define __DRI_CTX_FLAG_DEBUG 0x00000001 1082 #define __DRI_CTX_FLAG_FORWARD_COMPATIBLE 0x00000002 1083 1084 /** 1085 * \requires __DRI2_ROBUSTNESS. 1086 */ 1087 #define __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS 0x00000004 1088 1089 /** 1090 * \requires __DRI2_NO_ERROR. 1091 * 1092 */ 1093 #define __DRI_CTX_FLAG_NO_ERROR 0x00000008 1094 1095 /** 1096 * \name Context reset strategies. 1097 */ 1098 /*@{*/ 1099 #define __DRI_CTX_RESET_NO_NOTIFICATION 0 1100 #define __DRI_CTX_RESET_LOSE_CONTEXT 1 1101 /*@}*/ 1102 1103 #define __DRI_CTX_ATTRIB_PRIORITY 4 1104 1105 #define __DRI_CTX_PRIORITY_LOW 0 1106 #define __DRI_CTX_PRIORITY_MEDIUM 1 1107 #define __DRI_CTX_PRIORITY_HIGH 2 1108 1109 /** 1110 * \name Context release behaviors. 1111 */ 1112 /*@{*/ 1113 #define __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR 5 1114 1115 #define __DRI_CTX_RELEASE_BEHAVIOR_NONE 0 1116 #define __DRI_CTX_RELEASE_BEHAVIOR_FLUSH 1 1117 /*@}*/ 1118 1119 /** 1120 * \name Reasons that __DRIdri2Extension::createContextAttribs might fail 1121 */ 1122 /*@{*/ 1123 /** Success! */ 1124 #define __DRI_CTX_ERROR_SUCCESS 0 1125 1126 /** Memory allocation failure */ 1127 #define __DRI_CTX_ERROR_NO_MEMORY 1 1128 1129 /** Client requested an API (e.g., OpenGL ES 2.0) that the driver can't do. */ 1130 #define __DRI_CTX_ERROR_BAD_API 2 1131 1132 /** Client requested an API version that the driver can't do. */ 1133 #define __DRI_CTX_ERROR_BAD_VERSION 3 1134 1135 /** Client requested a flag or combination of flags the driver can't do. */ 1136 #define __DRI_CTX_ERROR_BAD_FLAG 4 1137 1138 /** Client requested an attribute the driver doesn't understand. */ 1139 #define __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE 5 1140 1141 /** Client requested a flag the driver doesn't understand. */ 1142 #define __DRI_CTX_ERROR_UNKNOWN_FLAG 6 1143 /*@}*/ 1144 1145 struct __DRIdri2ExtensionRec { 1146 __DRIextension base; 1147 1148 __DRIscreen *(*createNewScreen)(int screen, int fd, 1149 const __DRIextension **extensions, 1150 const __DRIconfig ***driver_configs, 1151 void *loaderPrivate); 1152 1153 __DRIcreateNewDrawableFunc createNewDrawable; 1154 __DRIcontext *(*createNewContext)(__DRIscreen *screen, 1155 const __DRIconfig *config, 1156 __DRIcontext *shared, 1157 void *loaderPrivate); 1158 1159 /* Since version 2 */ 1160 __DRIgetAPIMaskFunc getAPIMask; 1161 1162 __DRIcontext *(*createNewContextForAPI)(__DRIscreen *screen, 1163 int api, 1164 const __DRIconfig *config, 1165 __DRIcontext *shared, 1166 void *data); 1167 1168 __DRIbuffer *(*allocateBuffer)(__DRIscreen *screen, 1169 unsigned int attachment, 1170 unsigned int format, 1171 int width, 1172 int height); 1173 void (*releaseBuffer)(__DRIscreen *screen, 1174 __DRIbuffer *buffer); 1175 1176 /** 1177 * Create a context for a particular API with a set of attributes 1178 * 1179 * \since version 3 1180 * 1181 * \sa __DRIswrastExtensionRec::createContextAttribs 1182 */ 1183 __DRIcreateContextAttribsFunc createContextAttribs; 1184 1185 /** 1186 * createNewScreen with the driver's extension list passed in. 1187 * 1188 * \since version 4 1189 */ 1190 __DRIcreateNewScreen2Func createNewScreen2; 1191 }; 1192 1193 1194 /** 1195 * This extension provides functionality to enable various EGLImage 1196 * extensions. 1197 */ 1198 #define __DRI_IMAGE "DRI_IMAGE" 1199 #define __DRI_IMAGE_VERSION 17 1200 1201 /** 1202 * These formats correspond to the similarly named MESA_FORMAT_* 1203 * tokens, except in the native endian of the CPU. For example, on 1204 * little endian __DRI_IMAGE_FORMAT_XRGB8888 corresponds to 1205 * MESA_FORMAT_XRGB8888, but MESA_FORMAT_XRGB8888_REV on big endian. 1206 * 1207 * __DRI_IMAGE_FORMAT_NONE is for images that aren't directly usable 1208 * by the driver (YUV planar formats) but serve as a base image for 1209 * creating sub-images for the different planes within the image. 1210 * 1211 * R8, GR88 and NONE should not be used with createImageFromName or 1212 * createImage, and are returned by query from sub images created with 1213 * createImageFromNames (NONE, see above) and fromPlane (R8 & GR88). 1214 */ 1215 #define __DRI_IMAGE_FORMAT_RGB565 0x1001 1216 #define __DRI_IMAGE_FORMAT_XRGB8888 0x1002 1217 #define __DRI_IMAGE_FORMAT_ARGB8888 0x1003 1218 #define __DRI_IMAGE_FORMAT_ABGR8888 0x1004 1219 #define __DRI_IMAGE_FORMAT_XBGR8888 0x1005 1220 #define __DRI_IMAGE_FORMAT_R8 0x1006 /* Since version 5 */ 1221 #define __DRI_IMAGE_FORMAT_GR88 0x1007 1222 #define __DRI_IMAGE_FORMAT_NONE 0x1008 1223 #define __DRI_IMAGE_FORMAT_XRGB2101010 0x1009 1224 #define __DRI_IMAGE_FORMAT_ARGB2101010 0x100a 1225 #define __DRI_IMAGE_FORMAT_SARGB8 0x100b 1226 #define __DRI_IMAGE_FORMAT_ARGB1555 0x100c 1227 #define __DRI_IMAGE_FORMAT_R16 0x100d 1228 #define __DRI_IMAGE_FORMAT_GR1616 0x100e 1229 #define __DRI_IMAGE_FORMAT_YUYV 0x100f 1230 1231 #define __DRI_IMAGE_USE_SHARE 0x0001 1232 #define __DRI_IMAGE_USE_SCANOUT 0x0002 1233 #define __DRI_IMAGE_USE_CURSOR 0x0004 /* Deprecated */ 1234 #define __DRI_IMAGE_USE_LINEAR 0x0008 1235 /* The buffer will only be read by an external process after SwapBuffers, 1236 * in contrary to gbm buffers, front buffers and fake front buffers, which 1237 * could be read after a flush." 1238 */ 1239 #define __DRI_IMAGE_USE_BACKBUFFER 0x0010 1240 1241 1242 #define __DRI_IMAGE_TRANSFER_READ 0x1 1243 #define __DRI_IMAGE_TRANSFER_WRITE 0x2 1244 #define __DRI_IMAGE_TRANSFER_READ_WRITE \ 1245 (__DRI_IMAGE_TRANSFER_READ | __DRI_IMAGE_TRANSFER_WRITE) 1246 1247 /** 1248 * Four CC formats that matches with WL_DRM_FORMAT_* from wayland_drm.h, 1249 * GBM_FORMAT_* from gbm.h, and DRM_FORMAT_* from drm_fourcc.h. Used with 1250 * createImageFromNames. 1251 * 1252 * \since 5 1253 */ 1254 1255 #define __DRI_IMAGE_FOURCC_R8 0x20203852 1256 #define __DRI_IMAGE_FOURCC_GR88 0x38385247 1257 #define __DRI_IMAGE_FOURCC_ARGB1555 0x35315241 1258 #define __DRI_IMAGE_FOURCC_R16 0x20363152 1259 #define __DRI_IMAGE_FOURCC_GR1616 0x32335247 1260 #define __DRI_IMAGE_FOURCC_RGB565 0x36314752 1261 #define __DRI_IMAGE_FOURCC_ARGB8888 0x34325241 1262 #define __DRI_IMAGE_FOURCC_XRGB8888 0x34325258 1263 #define __DRI_IMAGE_FOURCC_ABGR8888 0x34324241 1264 #define __DRI_IMAGE_FOURCC_XBGR8888 0x34324258 1265 #define __DRI_IMAGE_FOURCC_SARGB8888 0x83324258 1266 #define __DRI_IMAGE_FOURCC_ARGB2101010 0x30335241 1267 #define __DRI_IMAGE_FOURCC_XRGB2101010 0x30335258 1268 #define __DRI_IMAGE_FOURCC_ABGR2101010 0x30334241 1269 #define __DRI_IMAGE_FOURCC_XBGR2101010 0x30334258 1270 #define __DRI_IMAGE_FOURCC_RGBA1010102 0x30334152 1271 #define __DRI_IMAGE_FOURCC_RGBX1010102 0x30335852 1272 #define __DRI_IMAGE_FOURCC_BGRA1010102 0x30334142 1273 #define __DRI_IMAGE_FOURCC_BGRX1010102 0x30335842 1274 #define __DRI_IMAGE_FOURCC_YUV410 0x39565559 1275 #define __DRI_IMAGE_FOURCC_YUV411 0x31315559 1276 #define __DRI_IMAGE_FOURCC_YUV420 0x32315559 1277 #define __DRI_IMAGE_FOURCC_YUV422 0x36315559 1278 #define __DRI_IMAGE_FOURCC_YUV444 0x34325559 1279 #define __DRI_IMAGE_FOURCC_NV12 0x3231564e 1280 #define __DRI_IMAGE_FOURCC_NV16 0x3631564e 1281 #define __DRI_IMAGE_FOURCC_YUYV 0x56595559 1282 #define __DRI_IMAGE_FOURCC_UYVY 0x59565955 1283 1284 #define __DRI_IMAGE_FOURCC_YVU410 0x39555659 1285 #define __DRI_IMAGE_FOURCC_YVU411 0x31315659 1286 #define __DRI_IMAGE_FOURCC_YVU420 0x32315659 1287 #define __DRI_IMAGE_FOURCC_YVU422 0x36315659 1288 #define __DRI_IMAGE_FOURCC_YVU444 0x34325659 1289 1290 /** 1291 * Queryable on images created by createImageFromNames. 1292 * 1293 * RGB and RGBA are may be usable directly as images but its still 1294 * recommended to call fromPlanar with plane == 0. 1295 * 1296 * Y_U_V, Y_UV,Y_XUXV and Y_UXVX all requires call to fromPlanar to create 1297 * usable sub-images, sampling from images return raw YUV data and 1298 * color conversion needs to be done in the shader. 1299 * 1300 * \since 5 1301 */ 1302 1303 #define __DRI_IMAGE_COMPONENTS_RGB 0x3001 1304 #define __DRI_IMAGE_COMPONENTS_RGBA 0x3002 1305 #define __DRI_IMAGE_COMPONENTS_Y_U_V 0x3003 1306 #define __DRI_IMAGE_COMPONENTS_Y_UV 0x3004 1307 #define __DRI_IMAGE_COMPONENTS_Y_XUXV 0x3005 1308 #define __DRI_IMAGE_COMPONENTS_Y_UXVX 0x3008 1309 #define __DRI_IMAGE_COMPONENTS_R 0x3006 1310 #define __DRI_IMAGE_COMPONENTS_RG 0x3007 1311 1312 1313 /** 1314 * queryImage attributes 1315 */ 1316 1317 #define __DRI_IMAGE_ATTRIB_STRIDE 0x2000 1318 #define __DRI_IMAGE_ATTRIB_HANDLE 0x2001 1319 #define __DRI_IMAGE_ATTRIB_NAME 0x2002 1320 #define __DRI_IMAGE_ATTRIB_FORMAT 0x2003 /* available in versions 3+ */ 1321 #define __DRI_IMAGE_ATTRIB_WIDTH 0x2004 /* available in versions 4+ */ 1322 #define __DRI_IMAGE_ATTRIB_HEIGHT 0x2005 1323 #define __DRI_IMAGE_ATTRIB_COMPONENTS 0x2006 /* available in versions 5+ */ 1324 #define __DRI_IMAGE_ATTRIB_FD 0x2007 /* available in versions 1325 * 7+. Each query will return a 1326 * new fd. */ 1327 #define __DRI_IMAGE_ATTRIB_FOURCC 0x2008 /* available in versions 11 */ 1328 #define __DRI_IMAGE_ATTRIB_NUM_PLANES 0x2009 /* available in versions 11 */ 1329 1330 #define __DRI_IMAGE_ATTRIB_OFFSET 0x200A /* available in versions 13 */ 1331 #define __DRI_IMAGE_ATTRIB_MODIFIER_LOWER 0x200B /* available in versions 14 */ 1332 #define __DRI_IMAGE_ATTRIB_MODIFIER_UPPER 0x200C /* available in versions 14 */ 1333 1334 enum __DRIYUVColorSpace { 1335 __DRI_YUV_COLOR_SPACE_UNDEFINED = 0, 1336 __DRI_YUV_COLOR_SPACE_ITU_REC601 = 0x327F, 1337 __DRI_YUV_COLOR_SPACE_ITU_REC709 = 0x3280, 1338 __DRI_YUV_COLOR_SPACE_ITU_REC2020 = 0x3281 1339 }; 1340 1341 enum __DRISampleRange { 1342 __DRI_YUV_RANGE_UNDEFINED = 0, 1343 __DRI_YUV_FULL_RANGE = 0x3282, 1344 __DRI_YUV_NARROW_RANGE = 0x3283 1345 }; 1346 1347 enum __DRIChromaSiting { 1348 __DRI_YUV_CHROMA_SITING_UNDEFINED = 0, 1349 __DRI_YUV_CHROMA_SITING_0 = 0x3284, 1350 __DRI_YUV_CHROMA_SITING_0_5 = 0x3285 1351 }; 1352 1353 /** 1354 * \name Reasons that __DRIimageExtensionRec::createImageFromTexture or 1355 * __DRIimageExtensionRec::createImageFromDmaBufs might fail 1356 */ 1357 /*@{*/ 1358 /** Success! */ 1359 #define __DRI_IMAGE_ERROR_SUCCESS 0 1360 1361 /** Memory allocation failure */ 1362 #define __DRI_IMAGE_ERROR_BAD_ALLOC 1 1363 1364 /** Client requested an invalid attribute */ 1365 #define __DRI_IMAGE_ERROR_BAD_MATCH 2 1366 1367 /** Client requested an invalid texture object */ 1368 #define __DRI_IMAGE_ERROR_BAD_PARAMETER 3 1369 1370 /** Client requested an invalid pitch and/or offset */ 1371 #define __DRI_IMAGE_ERROR_BAD_ACCESS 4 1372 /*@}*/ 1373 1374 /** 1375 * \name Capabilities that might be returned by __DRIimageExtensionRec::getCapabilities 1376 */ 1377 /*@{*/ 1378 #define __DRI_IMAGE_CAP_GLOBAL_NAMES 1 1379 /*@}*/ 1380 1381 /** 1382 * blitImage flags 1383 */ 1384 1385 #define __BLIT_FLAG_FLUSH 0x0001 1386 #define __BLIT_FLAG_FINISH 0x0002 1387 1388 /** 1389 * queryDmaBufFormatModifierAttribs attributes 1390 */ 1391 1392 /* Available in version 16 */ 1393 #define __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB_PLANE_COUNT 0x0001 1394 1395 typedef struct __DRIimageRec __DRIimage; 1396 typedef struct __DRIimageExtensionRec __DRIimageExtension; 1397 struct __DRIimageExtensionRec { 1398 __DRIextension base; 1399 1400 __DRIimage *(*createImageFromName)(__DRIscreen *screen, 1401 int width, int height, int format, 1402 int name, int pitch, 1403 void *loaderPrivate); 1404 1405 /* Deprecated since version 17; see createImageFromRenderbuffer2 */ 1406 __DRIimage *(*createImageFromRenderbuffer)(__DRIcontext *context, 1407 int renderbuffer, 1408 void *loaderPrivate); 1409 1410 void (*destroyImage)(__DRIimage *image); 1411 1412 __DRIimage *(*createImage)(__DRIscreen *screen, 1413 int width, int height, int format, 1414 unsigned int use, 1415 void *loaderPrivate); 1416 1417 GLboolean (*queryImage)(__DRIimage *image, int attrib, int *value); 1418 1419 /** 1420 * The new __DRIimage will share the content with the old one, see dup(2). 1421 */ 1422 __DRIimage *(*dupImage)(__DRIimage *image, void *loaderPrivate); 1423 1424 /** 1425 * Validate that a __DRIimage can be used a certain way. 1426 * 1427 * \since 2 1428 */ 1429 GLboolean (*validateUsage)(__DRIimage *image, unsigned int use); 1430 1431 /** 1432 * Unlike createImageFromName __DRI_IMAGE_FORMAT is not but instead 1433 * __DRI_IMAGE_FOURCC and strides are in bytes not pixels. Stride is 1434 * also per block and not per pixel (for non-RGB, see gallium blocks). 1435 * 1436 * \since 5 1437 */ 1438 __DRIimage *(*createImageFromNames)(__DRIscreen *screen, 1439 int width, int height, int fourcc, 1440 int *names, int num_names, 1441 int *strides, int *offsets, 1442 void *loaderPrivate); 1443 1444 /** 1445 * Create an image out of a sub-region of a parent image. This 1446 * entry point lets us create individual __DRIimages for different 1447 * planes in a planar buffer (typically yuv), for example. While a 1448 * sub-image shares the underlying buffer object with the parent 1449 * image and other sibling sub-images, the life times of parent and 1450 * sub-images are not dependent. Destroying the parent or a 1451 * sub-image doesn't affect other images. The underlying buffer 1452 * object is free when no __DRIimage remains that references it. 1453 * 1454 * Sub-images may overlap, but rendering to overlapping sub-images 1455 * is undefined. 1456 * 1457 * \since 5 1458 */ 1459 __DRIimage *(*fromPlanar)(__DRIimage *image, int plane, 1460 void *loaderPrivate); 1461 1462 /** 1463 * Create image from texture. 1464 * 1465 * \since 6 1466 */ 1467 __DRIimage *(*createImageFromTexture)(__DRIcontext *context, 1468 int target, 1469 unsigned texture, 1470 int depth, 1471 int level, 1472 unsigned *error, 1473 void *loaderPrivate); 1474 /** 1475 * Like createImageFromNames, but takes a prime fd instead. 1476 * 1477 * \since 7 1478 */ 1479 __DRIimage *(*createImageFromFds)(__DRIscreen *screen, 1480 int width, int height, int fourcc, 1481 int *fds, int num_fds, 1482 int *strides, int *offsets, 1483 void *loaderPrivate); 1484 1485 /** 1486 * Like createImageFromFds, but takes additional attributes. 1487 * 1488 * For EGL_EXT_image_dma_buf_import. 1489 * 1490 * \since 8 1491 */ 1492 __DRIimage *(*createImageFromDmaBufs)(__DRIscreen *screen, 1493 int width, int height, int fourcc, 1494 int *fds, int num_fds, 1495 int *strides, int *offsets, 1496 enum __DRIYUVColorSpace color_space, 1497 enum __DRISampleRange sample_range, 1498 enum __DRIChromaSiting horiz_siting, 1499 enum __DRIChromaSiting vert_siting, 1500 unsigned *error, 1501 void *loaderPrivate); 1502 1503 /** 1504 * Blit a part of a __DRIimage to another and flushes 1505 * 1506 * flush_flag: 1507 * 0: no flush 1508 * __BLIT_FLAG_FLUSH: flush after the blit operation 1509 * __BLIT_FLAG_FINISH: flush and wait the blit finished 1510 * 1511 * \since 9 1512 */ 1513 void (*blitImage)(__DRIcontext *context, __DRIimage *dst, __DRIimage *src, 1514 int dstx0, int dsty0, int dstwidth, int dstheight, 1515 int srcx0, int srcy0, int srcwidth, int srcheight, 1516 int flush_flag); 1517 1518 /** 1519 * Query for general capabilities of the driver that concern 1520 * buffer sharing and image importing. 1521 * 1522 * \since 10 1523 */ 1524 int (*getCapabilities)(__DRIscreen *screen); 1525 1526 /** 1527 * Returns a map of the specified region of a __DRIimage for the specified usage. 1528 * 1529 * flags may include __DRI_IMAGE_TRANSFER_READ, which will populate the 1530 * mapping with the current buffer content. If __DRI_IMAGE_TRANSFER_READ 1531 * is not included in the flags, the buffer content at map time is 1532 * undefined. Users wanting to modify the mapping must include 1533 * __DRI_IMAGE_TRANSFER_WRITE; if __DRI_IMAGE_TRANSFER_WRITE is not 1534 * included, behaviour when writing the mapping is undefined. 1535 * 1536 * Returns the byte stride in *stride, and an opaque pointer to data 1537 * tracking the mapping in **data, which must be passed to unmapImage(). 1538 * 1539 * \since 12 1540 */ 1541 void *(*mapImage)(__DRIcontext *context, __DRIimage *image, 1542 int x0, int y0, int width, int height, 1543 unsigned int flags, int *stride, void **data); 1544 1545 /** 1546 * Unmap a previously mapped __DRIimage 1547 * 1548 * \since 12 1549 */ 1550 void (*unmapImage)(__DRIcontext *context, __DRIimage *image, void *data); 1551 1552 1553 /** 1554 * Creates an image with implementation's favorite modifiers. 1555 * 1556 * This acts like createImage except there is a list of modifiers passed in 1557 * which the implementation may selectively use to create the DRIimage. The 1558 * result should be the implementation selects one modifier (perhaps it would 1559 * hold on to a few and later pick). 1560 * 1561 * The created image should be destroyed with destroyImage(). 1562 * 1563 * Returns the new DRIimage. The chosen modifier can be obtained later on 1564 * and passed back to things like the kernel's AddFB2 interface. 1565 * 1566 * \sa __DRIimageRec::createImage 1567 * 1568 * \since 14 1569 */ 1570 __DRIimage *(*createImageWithModifiers)(__DRIscreen *screen, 1571 int width, int height, int format, 1572 const uint64_t *modifiers, 1573 const unsigned int modifier_count, 1574 void *loaderPrivate); 1575 1576 /* 1577 * Like createImageFromDmaBufs, but takes also format modifiers. 1578 * 1579 * For EGL_EXT_image_dma_buf_import_modifiers. 1580 * 1581 * \since 15 1582 */ 1583 __DRIimage *(*createImageFromDmaBufs2)(__DRIscreen *screen, 1584 int width, int height, int fourcc, 1585 uint64_t modifier, 1586 int *fds, int num_fds, 1587 int *strides, int *offsets, 1588 enum __DRIYUVColorSpace color_space, 1589 enum __DRISampleRange sample_range, 1590 enum __DRIChromaSiting horiz_siting, 1591 enum __DRIChromaSiting vert_siting, 1592 unsigned *error, 1593 void *loaderPrivate); 1594 1595 /* 1596 * dmabuf format query to support EGL_EXT_image_dma_buf_import_modifiers. 1597 * 1598 * \param max Maximum number of formats that can be accomodated into 1599 * \param formats. If zero, no formats are returned - 1600 * instead, the driver returns the total number of 1601 * supported dmabuf formats in \param count. 1602 * \param formats Buffer to fill formats into. 1603 * \param count Count of formats returned, or, total number of 1604 * supported formats in case \param max is zero. 1605 * 1606 * Returns true on success. 1607 * 1608 * \since 15 1609 */ 1610 GLboolean (*queryDmaBufFormats)(__DRIscreen *screen, int max, 1611 int *formats, int *count); 1612 1613 /* 1614 * dmabuf format modifier query for a given format to support 1615 * EGL_EXT_image_dma_buf_import_modifiers. 1616 * 1617 * \param fourcc The format to query modifiers for. If this format 1618 * is not supported by the driver, return false. 1619 * \param max Maximum number of modifiers that can be accomodated in 1620 * \param modifiers. If zero, no modifiers are returned - 1621 * instead, the driver returns the total number of 1622 * modifiers for \param format in \param count. 1623 * \param modifiers Buffer to fill modifiers into. 1624 * \param count Count of the modifiers returned, or, total number of 1625 * supported modifiers for \param fourcc in case 1626 * \param max is zero. 1627 * 1628 * Returns true upon success. 1629 * 1630 * \since 15 1631 */ 1632 GLboolean (*queryDmaBufModifiers)(__DRIscreen *screen, int fourcc, 1633 int max, uint64_t *modifiers, 1634 unsigned int *external_only, 1635 int *count); 1636 1637 /** 1638 * dmabuf format modifier attribute query for a given format and modifier. 1639 * 1640 * \param fourcc The format to query. If this format is not supported by 1641 * the driver, return false. 1642 * \param modifier The modifier to query. If this format+modifier is not 1643 * supported by the driver, return false. 1644 * \param attrib The __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB to query. 1645 * \param value A pointer to where to store the result of the query. 1646 * 1647 * Returns true upon success. 1648 * 1649 * \since 16 1650 */ 1651 GLboolean (*queryDmaBufFormatModifierAttribs)(__DRIscreen *screen, 1652 uint32_t fourcc, uint64_t modifier, 1653 int attrib, uint64_t *value); 1654 1655 /** 1656 * Create a DRI image from the given renderbuffer. 1657 * 1658 * \param context the current DRI context 1659 * \param renderbuffer the GL name of the renderbuffer 1660 * \param loaderPrivate for callbacks into the loader related to the image 1661 * \param error will be set to one of __DRI_IMAGE_ERROR_xxx 1662 * \return the newly created image on success, or NULL otherwise 1663 * 1664 * \since 17 1665 */ 1666 __DRIimage *(*createImageFromRenderbuffer2)(__DRIcontext *context, 1667 int renderbuffer, 1668 void *loaderPrivate, 1669 unsigned *error); 1670 }; 1671 1672 1673 /** 1674 * This extension must be implemented by the loader and passed to the 1675 * driver at screen creation time. The EGLImage entry points in the 1676 * various client APIs take opaque EGLImage handles and use this 1677 * extension to map them to a __DRIimage. At version 1, this 1678 * extensions allows mapping EGLImage pointers to __DRIimage pointers, 1679 * but future versions could support other EGLImage-like, opaque types 1680 * with new lookup functions. 1681 */ 1682 #define __DRI_IMAGE_LOOKUP "DRI_IMAGE_LOOKUP" 1683 #define __DRI_IMAGE_LOOKUP_VERSION 1 1684 1685 typedef struct __DRIimageLookupExtensionRec __DRIimageLookupExtension; 1686 struct __DRIimageLookupExtensionRec { 1687 __DRIextension base; 1688 1689 __DRIimage *(*lookupEGLImage)(__DRIscreen *screen, void *image, 1690 void *loaderPrivate); 1691 }; 1692 1693 /** 1694 * This extension allows for common DRI2 options 1695 */ 1696 #define __DRI2_CONFIG_QUERY "DRI_CONFIG_QUERY" 1697 #define __DRI2_CONFIG_QUERY_VERSION 1 1698 1699 typedef struct __DRI2configQueryExtensionRec __DRI2configQueryExtension; 1700 struct __DRI2configQueryExtensionRec { 1701 __DRIextension base; 1702 1703 int (*configQueryb)(__DRIscreen *screen, const char *var, unsigned char *val); 1704 int (*configQueryi)(__DRIscreen *screen, const char *var, int *val); 1705 int (*configQueryf)(__DRIscreen *screen, const char *var, float *val); 1706 }; 1707 1708 /** 1709 * Robust context driver extension. 1710 * 1711 * Existence of this extension means the driver can accept the 1712 * \c __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS flag and the 1713 * \c __DRI_CTX_ATTRIB_RESET_STRATEGY attribute in 1714 * \c __DRIdri2ExtensionRec::createContextAttribs. 1715 */ 1716 #define __DRI2_ROBUSTNESS "DRI_Robustness" 1717 #define __DRI2_ROBUSTNESS_VERSION 1 1718 1719 typedef struct __DRIrobustnessExtensionRec __DRIrobustnessExtension; 1720 struct __DRIrobustnessExtensionRec { 1721 __DRIextension base; 1722 }; 1723 1724 /** 1725 * No-error context driver extension. 1726 * 1727 * Existence of this extension means the driver can accept the 1728 * __DRI_CTX_FLAG_NO_ERROR flag. 1729 */ 1730 #define __DRI2_NO_ERROR "DRI_NoError" 1731 #define __DRI2_NO_ERROR_VERSION 1 1732 1733 typedef struct __DRInoErrorExtensionRec { 1734 __DRIextension base; 1735 } __DRInoErrorExtension; 1736 1737 /* 1738 * Flush control driver extension. 1739 * 1740 * Existence of this extension means the driver can accept the 1741 * \c __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR attribute in 1742 * \c __DRIdri2ExtensionRec::createContextAttribs. 1743 */ 1744 #define __DRI2_FLUSH_CONTROL "DRI_FlushControl" 1745 #define __DRI2_FLUSH_CONTROL_VERSION 1 1746 1747 typedef struct __DRI2flushControlExtensionRec __DRI2flushControlExtension; 1748 struct __DRI2flushControlExtensionRec { 1749 __DRIextension base; 1750 }; 1751 1752 /** 1753 * DRI config options extension. 1754 * 1755 * This extension provides the XML string containing driver options for use by 1756 * the loader in supporting the driconf application. 1757 * 1758 * v2: 1759 * - Add the getXml getter function which allows the driver more flexibility in 1760 * how the XML is provided. 1761 * - Deprecate the direct xml pointer. It is only provided as a fallback for 1762 * older versions of libGL and must not be used by clients that are aware of 1763 * the newer version. Future driver versions may set it to NULL. 1764 */ 1765 #define __DRI_CONFIG_OPTIONS "DRI_ConfigOptions" 1766 #define __DRI_CONFIG_OPTIONS_VERSION 2 1767 1768 typedef struct __DRIconfigOptionsExtensionRec { 1769 __DRIextension base; 1770 const char *xml; /**< deprecated since v2, use getXml instead */ 1771 1772 /** 1773 * Get an XML string that describes available driver options for use by a 1774 * config application. 1775 * 1776 * The returned string must be heap-allocated. The caller is responsible for 1777 * freeing it. 1778 */ 1779 char *(*getXml)(const char *driver_name); 1780 } __DRIconfigOptionsExtension; 1781 1782 /** 1783 * This extension provides a driver vtable to a set of common driver helper 1784 * functions (driCoreExtension, driDRI2Extension) within the driver 1785 * implementation, as opposed to having to pass them through a global 1786 * variable. 1787 * 1788 * It is not intended to be public API to the actual loader, and the vtable 1789 * layout may change at any time. 1790 */ 1791 #define __DRI_DRIVER_VTABLE "DRI_DriverVtable" 1792 #define __DRI_DRIVER_VTABLE_VERSION 1 1793 1794 typedef struct __DRIDriverVtableExtensionRec { 1795 __DRIextension base; 1796 const struct __DriverAPIRec *vtable; 1797 } __DRIDriverVtableExtension; 1798 1799 /** 1800 * Query renderer driver extension 1801 * 1802 * This allows the window system layer (either EGL or GLX) to query aspects of 1803 * hardware and driver support without creating a context. 1804 */ 1805 #define __DRI2_RENDERER_QUERY "DRI_RENDERER_QUERY" 1806 #define __DRI2_RENDERER_QUERY_VERSION 1 1807 1808 #define __DRI2_RENDERER_VENDOR_ID 0x0000 1809 #define __DRI2_RENDERER_DEVICE_ID 0x0001 1810 #define __DRI2_RENDERER_VERSION 0x0002 1811 #define __DRI2_RENDERER_ACCELERATED 0x0003 1812 #define __DRI2_RENDERER_VIDEO_MEMORY 0x0004 1813 #define __DRI2_RENDERER_UNIFIED_MEMORY_ARCHITECTURE 0x0005 1814 #define __DRI2_RENDERER_PREFERRED_PROFILE 0x0006 1815 #define __DRI2_RENDERER_OPENGL_CORE_PROFILE_VERSION 0x0007 1816 #define __DRI2_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION 0x0008 1817 #define __DRI2_RENDERER_OPENGL_ES_PROFILE_VERSION 0x0009 1818 #define __DRI2_RENDERER_OPENGL_ES2_PROFILE_VERSION 0x000a 1819 #define __DRI2_RENDERER_HAS_TEXTURE_3D 0x000b 1820 /* Whether there is an sRGB format support for every supported 32-bit UNORM 1821 * color format. 1822 */ 1823 #define __DRI2_RENDERER_HAS_FRAMEBUFFER_SRGB 0x000c 1824 1825 /* Bitmaks of supported/available context priorities - must match 1826 * __EGL_CONTEXT_PRIORITY_LOW_BIT et al 1827 */ 1828 #define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY 0x000d 1829 #define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_LOW (1 << 0) 1830 #define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_MEDIUM (1 << 1) 1831 #define __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_HIGH (1 << 2) 1832 1833 typedef struct __DRI2rendererQueryExtensionRec __DRI2rendererQueryExtension; 1834 struct __DRI2rendererQueryExtensionRec { 1835 __DRIextension base; 1836 1837 int (*queryInteger)(__DRIscreen *screen, int attribute, unsigned int *val); 1838 int (*queryString)(__DRIscreen *screen, int attribute, const char **val); 1839 }; 1840 1841 /** 1842 * Image Loader extension. Drivers use this to allocate color buffers 1843 */ 1844 1845 enum __DRIimageBufferMask { 1846 __DRI_IMAGE_BUFFER_BACK = (1 << 0), 1847 __DRI_IMAGE_BUFFER_FRONT = (1 << 1) 1848 }; 1849 1850 struct __DRIimageList { 1851 uint32_t image_mask; 1852 __DRIimage *back; 1853 __DRIimage *front; 1854 }; 1855 1856 #define __DRI_IMAGE_LOADER "DRI_IMAGE_LOADER" 1857 #define __DRI_IMAGE_LOADER_VERSION 3 1858 1859 struct __DRIimageLoaderExtensionRec { 1860 __DRIextension base; 1861 1862 /** 1863 * Allocate color buffers. 1864 * 1865 * \param driDrawable 1866 * \param width Width of allocated buffers 1867 * \param height Height of allocated buffers 1868 * \param format one of __DRI_IMAGE_FORMAT_* 1869 * \param stamp Address of variable to be updated when 1870 * getBuffers must be called again 1871 * \param loaderPrivate The loaderPrivate for driDrawable 1872 * \param buffer_mask Set of buffers to allocate 1873 * \param buffers Returned buffers 1874 */ 1875 int (*getBuffers)(__DRIdrawable *driDrawable, 1876 unsigned int format, 1877 uint32_t *stamp, 1878 void *loaderPrivate, 1879 uint32_t buffer_mask, 1880 struct __DRIimageList *buffers); 1881 1882 /** 1883 * Flush pending front-buffer rendering 1884 * 1885 * Any rendering that has been performed to the 1886 * fake front will be flushed to the front 1887 * 1888 * \param driDrawable Drawable whose front-buffer is to be flushed 1889 * \param loaderPrivate Loader's private data that was previously passed 1890 * into __DRIdri2ExtensionRec::createNewDrawable 1891 */ 1892 void (*flushFrontBuffer)(__DRIdrawable *driDrawable, void *loaderPrivate); 1893 1894 /** 1895 * Return a loader capability value. If the loader doesn't know the enum, 1896 * it will return 0. 1897 * 1898 * \since 2 1899 */ 1900 unsigned (*getCapability)(void *loaderPrivate, enum dri_loader_cap cap); 1901 1902 /** 1903 * Flush swap buffers 1904 * 1905 * Make sure any outstanding swap buffers have been submitted to the 1906 * device. 1907 * 1908 * \param driDrawable Drawable whose swaps need to be flushed 1909 * \param loaderPrivate Loader's private data that was previously passed 1910 * into __DRIdri2ExtensionRec::createNewDrawable 1911 * 1912 * \since 3 1913 */ 1914 void (*flushSwapBuffers)(__DRIdrawable *driDrawable, void *loaderPrivate); 1915 }; 1916 1917 /** 1918 * DRI extension. 1919 */ 1920 1921 #define __DRI_IMAGE_DRIVER "DRI_IMAGE_DRIVER" 1922 #define __DRI_IMAGE_DRIVER_VERSION 1 1923 1924 struct __DRIimageDriverExtensionRec { 1925 __DRIextension base; 1926 1927 /* Common DRI functions, shared with DRI2 */ 1928 __DRIcreateNewScreen2Func createNewScreen2; 1929 __DRIcreateNewDrawableFunc createNewDrawable; 1930 __DRIcreateContextAttribsFunc createContextAttribs; 1931 __DRIgetAPIMaskFunc getAPIMask; 1932 }; 1933 1934 /** 1935 * Background callable loader extension. 1936 * 1937 * Loaders expose this extension to indicate to drivers that they are capable 1938 * of handling callbacks from the driver's background drawing threads. 1939 */ 1940 #define __DRI_BACKGROUND_CALLABLE "DRI_BackgroundCallable" 1941 #define __DRI_BACKGROUND_CALLABLE_VERSION 1 1942 1943 typedef struct __DRIbackgroundCallableExtensionRec __DRIbackgroundCallableExtension; 1944 struct __DRIbackgroundCallableExtensionRec { 1945 __DRIextension base; 1946 1947 /** 1948 * Indicate that this thread is being used by the driver as a background 1949 * drawing thread which may make callbacks to the loader. 1950 * 1951 * \param loaderPrivate is the value that was passed to to the driver when 1952 * the context was created. This can be used by the loader to identify 1953 * which context any callbacks are associated with. 1954 * 1955 * If this function is called more than once from any given thread, each 1956 * subsequent call overrides the loaderPrivate data that was passed in the 1957 * previous call. The driver can take advantage of this to re-use a 1958 * background thread to perform drawing on behalf of multiple contexts. 1959 * 1960 * It is permissible for the driver to call this function from a 1961 * non-background thread (i.e. a thread that has already been bound to a 1962 * context using __DRIcoreExtensionRec::bindContext()); when this happens, 1963 * the \c loaderPrivate pointer must be equal to the pointer that was 1964 * passed to the driver when the currently bound context was created. 1965 * 1966 * This call should execute quickly enough that the driver can call it with 1967 * impunity whenever a background thread starts performing drawing 1968 * operations (e.g. it should just set a thread-local variable). 1969 */ 1970 void (*setBackgroundContext)(void *loaderPrivate); 1971 1972 /** 1973 * Indicate that it is multithread safe to use glthread. For GLX/EGL 1974 * platforms using Xlib, that involves calling XInitThreads, before 1975 * opening an X display. 1976 * 1977 * Note: only supported if extension version is at least 2. 1978 * 1979 * \param loaderPrivate is the value that was passed to to the driver when 1980 * the context was created. This can be used by the loader to identify 1981 * which context any callbacks are associated with. 1982 */ 1983 GLboolean (*isThreadSafe)(void *loaderPrivate); 1984 }; 1985 1986 #endif 1987
