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