1/************************************************************************** 2 * 3 * Copyright 2009, VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27/* 28 * Author: Keith Whitwell <keithw@vmware.com> 29 * Author: Jakob Bornecrantz <wallbraker@gmail.com> 30 */ 31 32#include "dri_screen.h" 33#include "dri_context.h" 34#include "dri_helpers.h" 35 36#include "util/u_inlines.h" 37#include "pipe/p_screen.h" 38#include "pipe/p_format.h" 39#include "pipe-loader/pipe_loader.h" 40#include "state_tracker/st_gl_api.h" /* for st_gl_api_create */ 41#include "frontend/drm_driver.h" 42 43#include "util/u_debug.h" 44#include "util/u_driconf.h" 45#include "util/format/u_format_s3tc.h" 46 47#define MSAA_VISUAL_MAX_SAMPLES 32 48 49#undef false 50 51const __DRIconfigOptionsExtension gallium_config_options = { 52 .base = { __DRI_CONFIG_OPTIONS, 2 }, 53 .getXml = pipe_loader_get_driinfo_xml 54}; 55 56#define false 0 57 58void 59dri_init_options(struct dri_screen *screen) 60{ 61 pipe_loader_config_options(screen->dev); 62 63 struct st_config_options *options = &screen->options; 64 const struct driOptionCache *optionCache = &screen->dev->option_cache; 65 66 u_driconf_fill_st_options(options, optionCache); 67} 68 69static unsigned 70dri_loader_get_cap(struct dri_screen *screen, enum dri_loader_cap cap) 71{ 72 const __DRIdri2LoaderExtension *dri2_loader = screen->sPriv->dri2.loader; 73 const __DRIimageLoaderExtension *image_loader = screen->sPriv->image.loader; 74 75 if (dri2_loader && dri2_loader->base.version >= 4 && 76 dri2_loader->getCapability) 77 return dri2_loader->getCapability(screen->sPriv->loaderPrivate, cap); 78 79 if (image_loader && image_loader->base.version >= 2 && 80 image_loader->getCapability) 81 return image_loader->getCapability(screen->sPriv->loaderPrivate, cap); 82 83 return 0; 84} 85 86/** 87 * Creates a set of \c struct gl_config that a driver will expose. 88 * 89 * A set of \c struct gl_config will be created based on the supplied 90 * parameters. The number of modes processed will be 2 * 91 * \c num_depth_stencil_bits * \c num_db_modes. 92 * 93 * For the most part, data is just copied from \c depth_bits, \c stencil_bits, 94 * \c db_modes, and \c visType into each \c struct gl_config element. 95 * However, the meanings of \c fb_format and \c fb_type require further 96 * explanation. The \c fb_format specifies which color components are in 97 * each pixel and what the default order is. For example, \c GL_RGB specifies 98 * that red, green, blue are available and red is in the "most significant" 99 * position and blue is in the "least significant". The \c fb_type specifies 100 * the bit sizes of each component and the actual ordering. For example, if 101 * \c GL_UNSIGNED_SHORT_5_6_5_REV is specified with \c GL_RGB, bits [15:11] 102 * are the blue value, bits [10:5] are the green value, and bits [4:0] are 103 * the red value. 104 * 105 * One sublte issue is the combination of \c GL_RGB or \c GL_BGR and either 106 * of the \c GL_UNSIGNED_INT_8_8_8_8 modes. The resulting mask values in the 107 * \c struct gl_config structure is \b identical to the \c GL_RGBA or 108 * \c GL_BGRA case, except the \c alphaMask is zero. This means that, as 109 * far as this routine is concerned, \c GL_RGB with \c GL_UNSIGNED_INT_8_8_8_8 110 * still uses 32-bits. 111 * 112 * If in doubt, look at the tables used in the function. 113 * 114 * \param ptr_to_modes Pointer to a pointer to a linked list of 115 * \c struct gl_config. Upon completion, a pointer to 116 * the next element to be process will be stored here. 117 * If the function fails and returns \c GL_FALSE, this 118 * value will be unmodified, but some elements in the 119 * linked list may be modified. 120 * \param format Mesa mesa_format enum describing the pixel format 121 * \param depth_bits Array of depth buffer sizes to be exposed. 122 * \param stencil_bits Array of stencil buffer sizes to be exposed. 123 * \param num_depth_stencil_bits Number of entries in both \c depth_bits and 124 * \c stencil_bits. 125 * \param db_modes Array of buffer swap modes. If an element has a 126 * value of \c __DRI_ATTRIB_SWAP_NONE, then it 127 * represents a single-buffered mode. Other valid 128 * values are \c __DRI_ATTRIB_SWAP_EXCHANGE, 129 * \c __DRI_ATTRIB_SWAP_COPY, and \c __DRI_ATTRIB_SWAP_UNDEFINED. 130 * They represent the respective GLX values as in 131 * the GLX_OML_swap_method extension spec. 132 * \param num_db_modes Number of entries in \c db_modes. 133 * \param msaa_samples Array of msaa sample count. 0 represents a visual 134 * without a multisample buffer. 135 * \param num_msaa_modes Number of entries in \c msaa_samples. 136 * \param enable_accum Add an accum buffer to the configs 137 * \param color_depth_match Whether the color depth must match the zs depth 138 * This forces 32-bit color to have 24-bit depth, and 139 * 16-bit color to have 16-bit depth. 140 * 141 * \returns 142 * Pointer to any array of pointers to the \c __DRIconfig structures created 143 * for the specified formats. If there is an error, \c NULL is returned. 144 * Currently the only cause of failure is a bad parameter (i.e., unsupported 145 * \c format). 146 */ 147static __DRIconfig ** 148driCreateConfigs(mesa_format format, 149 const uint8_t * depth_bits, const uint8_t * stencil_bits, 150 unsigned num_depth_stencil_bits, 151 const GLenum * db_modes, unsigned num_db_modes, 152 const uint8_t * msaa_samples, unsigned num_msaa_modes, 153 GLboolean enable_accum, GLboolean color_depth_match) 154{ 155 static const struct { 156 uint32_t masks[4]; 157 int shifts[4]; 158 } format_table[] = { 159 /* MESA_FORMAT_B5G6R5_UNORM */ 160 {{ 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, 161 { 11, 5, 0, -1 }}, 162 /* MESA_FORMAT_B8G8R8X8_UNORM */ 163 {{ 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }, 164 { 16, 8, 0, -1 }}, 165 /* MESA_FORMAT_B8G8R8A8_UNORM */ 166 {{ 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }, 167 { 16, 8, 0, 24 }}, 168 /* MESA_FORMAT_B10G10R10X2_UNORM */ 169 {{ 0x3FF00000, 0x000FFC00, 0x000003FF, 0x00000000 }, 170 { 20, 10, 0, -1 }}, 171 /* MESA_FORMAT_B10G10R10A2_UNORM */ 172 {{ 0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000 }, 173 { 20, 10, 0, 30 }}, 174 /* MESA_FORMAT_R8G8B8A8_UNORM */ 175 {{ 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }, 176 { 0, 8, 16, 24 }}, 177 /* MESA_FORMAT_R8G8B8X8_UNORM */ 178 {{ 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }, 179 { 0, 8, 16, -1 }}, 180 /* MESA_FORMAT_R10G10B10X2_UNORM */ 181 {{ 0x000003FF, 0x000FFC00, 0x3FF00000, 0x00000000 }, 182 { 0, 10, 20, -1 }}, 183 /* MESA_FORMAT_R10G10B10A2_UNORM */ 184 {{ 0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000 }, 185 { 0, 10, 20, 30 }}, 186 /* MESA_FORMAT_RGBX_FLOAT16 */ 187 {{ 0, 0, 0, 0}, 188 { 0, 16, 32, -1 }}, 189 /* MESA_FORMAT_RGBA_FLOAT16 */ 190 {{ 0, 0, 0, 0}, 191 { 0, 16, 32, 48 }}, 192 }; 193 194 const uint32_t * masks; 195 const int * shifts; 196 __DRIconfig **configs, **c; 197 struct gl_config *modes; 198 unsigned i, j, k, h; 199 unsigned num_modes; 200 unsigned num_accum_bits = (enable_accum) ? 2 : 1; 201 int red_bits; 202 int green_bits; 203 int blue_bits; 204 int alpha_bits; 205 bool is_srgb; 206 bool is_float; 207 208 switch (format) { 209 case MESA_FORMAT_B5G6R5_UNORM: 210 masks = format_table[0].masks; 211 shifts = format_table[0].shifts; 212 break; 213 case MESA_FORMAT_B8G8R8X8_UNORM: 214 case MESA_FORMAT_B8G8R8X8_SRGB: 215 masks = format_table[1].masks; 216 shifts = format_table[1].shifts; 217 break; 218 case MESA_FORMAT_B8G8R8A8_UNORM: 219 case MESA_FORMAT_B8G8R8A8_SRGB: 220 masks = format_table[2].masks; 221 shifts = format_table[2].shifts; 222 break; 223 case MESA_FORMAT_R8G8B8A8_UNORM: 224 case MESA_FORMAT_R8G8B8A8_SRGB: 225 masks = format_table[5].masks; 226 shifts = format_table[5].shifts; 227 break; 228 case MESA_FORMAT_R8G8B8X8_UNORM: 229 case MESA_FORMAT_R8G8B8X8_SRGB: 230 masks = format_table[6].masks; 231 shifts = format_table[6].shifts; 232 break; 233 case MESA_FORMAT_B10G10R10X2_UNORM: 234 masks = format_table[3].masks; 235 shifts = format_table[3].shifts; 236 break; 237 case MESA_FORMAT_B10G10R10A2_UNORM: 238 masks = format_table[4].masks; 239 shifts = format_table[4].shifts; 240 break; 241 case MESA_FORMAT_RGBX_FLOAT16: 242 masks = format_table[9].masks; 243 shifts = format_table[9].shifts; 244 break; 245 case MESA_FORMAT_RGBA_FLOAT16: 246 masks = format_table[10].masks; 247 shifts = format_table[10].shifts; 248 break; 249 case MESA_FORMAT_R10G10B10X2_UNORM: 250 masks = format_table[7].masks; 251 shifts = format_table[7].shifts; 252 break; 253 case MESA_FORMAT_R10G10B10A2_UNORM: 254 masks = format_table[8].masks; 255 shifts = format_table[8].shifts; 256 break; 257 default: 258 fprintf(stderr, "[%s:%u] Unknown framebuffer type %s (%d).\n", 259 __func__, __LINE__, 260 _mesa_get_format_name(format), format); 261 return NULL; 262 } 263 264 red_bits = _mesa_get_format_bits(format, GL_RED_BITS); 265 green_bits = _mesa_get_format_bits(format, GL_GREEN_BITS); 266 blue_bits = _mesa_get_format_bits(format, GL_BLUE_BITS); 267 alpha_bits = _mesa_get_format_bits(format, GL_ALPHA_BITS); 268 is_srgb = _mesa_is_format_srgb(format); 269 is_float = _mesa_get_format_datatype(format) == GL_FLOAT; 270 271 num_modes = num_depth_stencil_bits * num_db_modes * num_accum_bits * num_msaa_modes; 272 configs = calloc(num_modes + 1, sizeof *configs); 273 if (configs == NULL) 274 return NULL; 275 276 c = configs; 277 for ( k = 0 ; k < num_depth_stencil_bits ; k++ ) { 278 for ( i = 0 ; i < num_db_modes ; i++ ) { 279 for ( h = 0 ; h < num_msaa_modes; h++ ) { 280 for ( j = 0 ; j < num_accum_bits ; j++ ) { 281 if (color_depth_match && 282 (depth_bits[k] || stencil_bits[k])) { 283 /* Depth can really only be 0, 16, 24, or 32. A 32-bit 284 * color format still matches 24-bit depth, as there 285 * is an implicit 8-bit stencil. So really we just 286 * need to make sure that color/depth are both 16 or 287 * both non-16. 288 */ 289 if ((depth_bits[k] + stencil_bits[k] == 16) != 290 (red_bits + green_bits + blue_bits + alpha_bits == 16)) 291 continue; 292 } 293 294 *c = malloc (sizeof **c); 295 modes = &(*c)->modes; 296 c++; 297 298 memset(modes, 0, sizeof *modes); 299 modes->floatMode = is_float; 300 modes->redBits = red_bits; 301 modes->greenBits = green_bits; 302 modes->blueBits = blue_bits; 303 modes->alphaBits = alpha_bits; 304 modes->redMask = masks[0]; 305 modes->greenMask = masks[1]; 306 modes->blueMask = masks[2]; 307 modes->alphaMask = masks[3]; 308 modes->redShift = shifts[0]; 309 modes->greenShift = shifts[1]; 310 modes->blueShift = shifts[2]; 311 modes->alphaShift = shifts[3]; 312 modes->rgbBits = modes->redBits + modes->greenBits 313 + modes->blueBits + modes->alphaBits; 314 315 modes->accumRedBits = 16 * j; 316 modes->accumGreenBits = 16 * j; 317 modes->accumBlueBits = 16 * j; 318 modes->accumAlphaBits = 16 * j; 319 320 modes->stencilBits = stencil_bits[k]; 321 modes->depthBits = depth_bits[k]; 322 323 if (db_modes[i] == __DRI_ATTRIB_SWAP_NONE) { 324 modes->doubleBufferMode = GL_FALSE; 325 modes->swapMethod = __DRI_ATTRIB_SWAP_UNDEFINED; 326 } 327 else { 328 modes->doubleBufferMode = GL_TRUE; 329 modes->swapMethod = db_modes[i]; 330 } 331 332 modes->samples = msaa_samples[h]; 333 334 modes->sRGBCapable = is_srgb; 335 } 336 } 337 } 338 } 339 *c = NULL; 340 341 return configs; 342} 343 344static __DRIconfig ** 345driConcatConfigs(__DRIconfig **a, __DRIconfig **b) 346{ 347 __DRIconfig **all; 348 int i, j, index; 349 350 if (a == NULL || a[0] == NULL) 351 return b; 352 else if (b == NULL || b[0] == NULL) 353 return a; 354 355 i = 0; 356 while (a[i] != NULL) 357 i++; 358 j = 0; 359 while (b[j] != NULL) 360 j++; 361 362 all = malloc((i + j + 1) * sizeof *all); 363 index = 0; 364 for (i = 0; a[i] != NULL; i++) 365 all[index++] = a[i]; 366 for (j = 0; b[j] != NULL; j++) 367 all[index++] = b[j]; 368 all[index++] = NULL; 369 370 free(a); 371 free(b); 372 373 return all; 374} 375 376 377static const __DRIconfig ** 378dri_fill_in_modes(struct dri_screen *screen) 379{ 380 static const mesa_format mesa_formats[] = { 381 MESA_FORMAT_B10G10R10A2_UNORM, 382 MESA_FORMAT_B10G10R10X2_UNORM, 383 MESA_FORMAT_R10G10B10A2_UNORM, 384 MESA_FORMAT_R10G10B10X2_UNORM, 385 MESA_FORMAT_B8G8R8A8_UNORM, 386 MESA_FORMAT_B8G8R8X8_UNORM, 387 MESA_FORMAT_B8G8R8A8_SRGB, 388 MESA_FORMAT_B8G8R8X8_SRGB, 389 MESA_FORMAT_B5G6R5_UNORM, 390 MESA_FORMAT_RGBA_FLOAT16, 391 MESA_FORMAT_RGBX_FLOAT16, 392 393 /* The 32-bit RGBA format must not precede the 32-bit BGRA format. 394 * Likewise for RGBX and BGRX. Otherwise, the GLX client and the GLX 395 * server may disagree on which format the GLXFBConfig represents, 396 * resulting in swapped color channels. 397 * 398 * The problem, as of 2017-05-30: 399 * When matching a GLXFBConfig to a __DRIconfig, GLX ignores the channel 400 * order and chooses the first __DRIconfig with the expected channel 401 * sizes. Specifically, GLX compares the GLXFBConfig's and __DRIconfig's 402 * __DRI_ATTRIB_{CHANNEL}_SIZE but ignores __DRI_ATTRIB_{CHANNEL}_MASK. 403 * 404 * EGL does not suffer from this problem. It correctly compares the 405 * channel masks when matching EGLConfig to __DRIconfig. 406 */ 407 408 /* Required by Android, for HAL_PIXEL_FORMAT_RGBA_8888. */ 409 MESA_FORMAT_R8G8B8A8_UNORM, 410 411 /* Required by Android, for HAL_PIXEL_FORMAT_RGBX_8888. */ 412 MESA_FORMAT_R8G8B8X8_UNORM, 413 414 /* Required by Android, for HAL_PIXEL_FORMAT_RGBA_8888. */ 415 MESA_FORMAT_R8G8B8A8_SRGB, 416 417 /* Required by Android, for HAL_PIXEL_FORMAT_RGBX_8888. */ 418 MESA_FORMAT_R8G8B8X8_SRGB, 419 }; 420 static const enum pipe_format pipe_formats[] = { 421 PIPE_FORMAT_B10G10R10A2_UNORM, 422 PIPE_FORMAT_B10G10R10X2_UNORM, 423 PIPE_FORMAT_R10G10B10A2_UNORM, 424 PIPE_FORMAT_R10G10B10X2_UNORM, 425 PIPE_FORMAT_BGRA8888_UNORM, 426 PIPE_FORMAT_BGRX8888_UNORM, 427 PIPE_FORMAT_BGRA8888_SRGB, 428 PIPE_FORMAT_BGRX8888_SRGB, 429 PIPE_FORMAT_B5G6R5_UNORM, 430 PIPE_FORMAT_R16G16B16A16_FLOAT, 431 PIPE_FORMAT_R16G16B16X16_FLOAT, 432 PIPE_FORMAT_RGBA8888_UNORM, 433 PIPE_FORMAT_RGBX8888_UNORM, 434 PIPE_FORMAT_RGBA8888_SRGB, 435 PIPE_FORMAT_RGBX8888_SRGB, 436 }; 437 mesa_format format; 438 __DRIconfig **configs = NULL; 439 uint8_t depth_bits_array[5]; 440 uint8_t stencil_bits_array[5]; 441 unsigned depth_buffer_factor; 442 unsigned msaa_samples_max; 443 unsigned i; 444 struct pipe_screen *p_screen = screen->base.screen; 445 bool pf_z16, pf_x8z24, pf_z24x8, pf_s8z24, pf_z24s8, pf_z32; 446 bool mixed_color_depth; 447 bool allow_rgba_ordering; 448 bool allow_rgb10; 449 bool allow_fp16; 450 451 static const GLenum back_buffer_modes[] = { 452 __DRI_ATTRIB_SWAP_NONE, __DRI_ATTRIB_SWAP_UNDEFINED, 453 __DRI_ATTRIB_SWAP_COPY 454 }; 455 456 if (driQueryOptionb(&screen->dev->option_cache, "always_have_depth_buffer")) { 457 /* all visuals will have a depth buffer */ 458 depth_buffer_factor = 0; 459 } 460 else { 461 depth_bits_array[0] = 0; 462 stencil_bits_array[0] = 0; 463 depth_buffer_factor = 1; 464 } 465 466 allow_rgba_ordering = dri_loader_get_cap(screen, DRI_LOADER_CAP_RGBA_ORDERING); 467 allow_rgb10 = driQueryOptionb(&screen->dev->option_cache, "allow_rgb10_configs"); 468 allow_fp16 = dri_loader_get_cap(screen, DRI_LOADER_CAP_FP16); 469 470 msaa_samples_max = (screen->st_api->feature_mask & ST_API_FEATURE_MS_VISUALS_MASK) 471 ? MSAA_VISUAL_MAX_SAMPLES : 1; 472 473 pf_x8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24X8_UNORM, 474 PIPE_TEXTURE_2D, 0, 0, 475 PIPE_BIND_DEPTH_STENCIL); 476 pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM, 477 PIPE_TEXTURE_2D, 0, 0, 478 PIPE_BIND_DEPTH_STENCIL); 479 pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_UINT, 480 PIPE_TEXTURE_2D, 0, 0, 481 PIPE_BIND_DEPTH_STENCIL); 482 pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_UINT_Z24_UNORM, 483 PIPE_TEXTURE_2D, 0, 0, 484 PIPE_BIND_DEPTH_STENCIL); 485 pf_z16 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z16_UNORM, 486 PIPE_TEXTURE_2D, 0, 0, 487 PIPE_BIND_DEPTH_STENCIL); 488 pf_z32 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z32_UNORM, 489 PIPE_TEXTURE_2D, 0, 0, 490 PIPE_BIND_DEPTH_STENCIL); 491 492 if (pf_z16) { 493 depth_bits_array[depth_buffer_factor] = 16; 494 stencil_bits_array[depth_buffer_factor++] = 0; 495 } 496 if (pf_x8z24 || pf_z24x8) { 497 depth_bits_array[depth_buffer_factor] = 24; 498 stencil_bits_array[depth_buffer_factor++] = 0; 499 screen->d_depth_bits_last = pf_x8z24; 500 } 501 if (pf_s8z24 || pf_z24s8) { 502 depth_bits_array[depth_buffer_factor] = 24; 503 stencil_bits_array[depth_buffer_factor++] = 8; 504 screen->sd_depth_bits_last = pf_s8z24; 505 } 506 if (pf_z32) { 507 depth_bits_array[depth_buffer_factor] = 32; 508 stencil_bits_array[depth_buffer_factor++] = 0; 509 } 510 511 mixed_color_depth = 512 p_screen->get_param(p_screen, PIPE_CAP_MIXED_COLOR_DEPTH_BITS); 513 514 assert(ARRAY_SIZE(mesa_formats) == ARRAY_SIZE(pipe_formats)); 515 516 /* Add configs. */ 517 for (format = 0; format < ARRAY_SIZE(mesa_formats); format++) { 518 __DRIconfig **new_configs = NULL; 519 unsigned num_msaa_modes = 0; /* includes a single-sample mode */ 520 uint8_t msaa_modes[MSAA_VISUAL_MAX_SAMPLES]; 521 522 /* Expose only BGRA ordering if the loader doesn't support RGBA ordering. */ 523 if (!allow_rgba_ordering && 524 (mesa_formats[format] == MESA_FORMAT_R8G8B8A8_UNORM || 525 mesa_formats[format] == MESA_FORMAT_R8G8B8X8_UNORM || 526 mesa_formats[format] == MESA_FORMAT_R8G8B8A8_SRGB || 527 mesa_formats[format] == MESA_FORMAT_R8G8B8X8_SRGB)) 528 continue; 529 530 if (!allow_rgb10 && 531 (mesa_formats[format] == MESA_FORMAT_B10G10R10A2_UNORM || 532 mesa_formats[format] == MESA_FORMAT_B10G10R10X2_UNORM || 533 mesa_formats[format] == MESA_FORMAT_R10G10B10A2_UNORM || 534 mesa_formats[format] == MESA_FORMAT_R10G10B10X2_UNORM)) 535 continue; 536 537 if (!allow_fp16 && 538 (mesa_formats[format] == MESA_FORMAT_RGBA_FLOAT16 || 539 mesa_formats[format] == MESA_FORMAT_RGBX_FLOAT16)) 540 continue; 541 542 if (!p_screen->is_format_supported(p_screen, pipe_formats[format], 543 PIPE_TEXTURE_2D, 0, 0, 544 PIPE_BIND_RENDER_TARGET | 545 PIPE_BIND_DISPLAY_TARGET)) 546 continue; 547 548 for (i = 1; i <= msaa_samples_max; i++) { 549 int samples = i > 1 ? i : 0; 550 551 if (p_screen->is_format_supported(p_screen, pipe_formats[format], 552 PIPE_TEXTURE_2D, samples, samples, 553 PIPE_BIND_RENDER_TARGET)) { 554 msaa_modes[num_msaa_modes++] = samples; 555 } 556 } 557 558 if (num_msaa_modes) { 559 /* Single-sample configs with an accumulation buffer. */ 560 new_configs = driCreateConfigs(mesa_formats[format], 561 depth_bits_array, stencil_bits_array, 562 depth_buffer_factor, back_buffer_modes, 563 ARRAY_SIZE(back_buffer_modes), 564 msaa_modes, 1, 565 GL_TRUE, !mixed_color_depth); 566 configs = driConcatConfigs(configs, new_configs); 567 568 /* Multi-sample configs without an accumulation buffer. */ 569 if (num_msaa_modes > 1) { 570 new_configs = driCreateConfigs(mesa_formats[format], 571 depth_bits_array, stencil_bits_array, 572 depth_buffer_factor, back_buffer_modes, 573 ARRAY_SIZE(back_buffer_modes), 574 msaa_modes+1, num_msaa_modes-1, 575 GL_FALSE, !mixed_color_depth); 576 configs = driConcatConfigs(configs, new_configs); 577 } 578 } 579 } 580 581 if (configs == NULL) { 582 debug_printf("%s: driCreateConfigs failed\n", __FUNCTION__); 583 return NULL; 584 } 585 586 return (const __DRIconfig **)configs; 587} 588 589/** 590 * Roughly the converse of dri_fill_in_modes. 591 */ 592void 593dri_fill_st_visual(struct st_visual *stvis, 594 const struct dri_screen *screen, 595 const struct gl_config *mode) 596{ 597 memset(stvis, 0, sizeof(*stvis)); 598 599 if (!mode) 600 return; 601 602 /* Deduce the color format. */ 603 switch (mode->redMask) { 604 case 0: 605 /* Formats > 32 bpp */ 606 assert(mode->floatMode); 607 if (mode->alphaShift > -1) { 608 assert(mode->alphaShift == 48); 609 stvis->color_format = PIPE_FORMAT_R16G16B16A16_FLOAT; 610 } else { 611 stvis->color_format = PIPE_FORMAT_R16G16B16X16_FLOAT; 612 } 613 break; 614 615 case 0x3FF00000: 616 if (mode->alphaMask) { 617 assert(mode->alphaMask == 0xC0000000); 618 stvis->color_format = PIPE_FORMAT_B10G10R10A2_UNORM; 619 } else { 620 stvis->color_format = PIPE_FORMAT_B10G10R10X2_UNORM; 621 } 622 break; 623 624 case 0x000003FF: 625 if (mode->alphaMask) { 626 assert(mode->alphaMask == 0xC0000000); 627 stvis->color_format = PIPE_FORMAT_R10G10B10A2_UNORM; 628 } else { 629 stvis->color_format = PIPE_FORMAT_R10G10B10X2_UNORM; 630 } 631 break; 632 633 case 0x00FF0000: 634 if (mode->alphaMask) { 635 assert(mode->alphaMask == 0xFF000000); 636 stvis->color_format = mode->sRGBCapable ? 637 PIPE_FORMAT_BGRA8888_SRGB : 638 PIPE_FORMAT_BGRA8888_UNORM; 639 } else { 640 stvis->color_format = mode->sRGBCapable ? 641 PIPE_FORMAT_BGRX8888_SRGB : 642 PIPE_FORMAT_BGRX8888_UNORM; 643 } 644 break; 645 646 case 0x000000FF: 647 if (mode->alphaMask) { 648 assert(mode->alphaMask == 0xFF000000); 649 stvis->color_format = mode->sRGBCapable ? 650 PIPE_FORMAT_RGBA8888_SRGB : 651 PIPE_FORMAT_RGBA8888_UNORM; 652 } else { 653 stvis->color_format = mode->sRGBCapable ? 654 PIPE_FORMAT_RGBX8888_SRGB : 655 PIPE_FORMAT_RGBX8888_UNORM; 656 } 657 break; 658 659 case 0x0000F800: 660 stvis->color_format = PIPE_FORMAT_B5G6R5_UNORM; 661 break; 662 663 default: 664 assert(!"unsupported visual: invalid red mask"); 665 return; 666 } 667 668 if (mode->samples > 0) { 669 if (debug_get_bool_option("DRI_NO_MSAA", false)) 670 stvis->samples = 0; 671 else 672 stvis->samples = mode->samples; 673 } 674 675 switch (mode->depthBits) { 676 default: 677 case 0: 678 stvis->depth_stencil_format = PIPE_FORMAT_NONE; 679 break; 680 case 16: 681 stvis->depth_stencil_format = PIPE_FORMAT_Z16_UNORM; 682 break; 683 case 24: 684 if (mode->stencilBits == 0) { 685 stvis->depth_stencil_format = (screen->d_depth_bits_last) ? 686 PIPE_FORMAT_Z24X8_UNORM: 687 PIPE_FORMAT_X8Z24_UNORM; 688 } else { 689 stvis->depth_stencil_format = (screen->sd_depth_bits_last) ? 690 PIPE_FORMAT_Z24_UNORM_S8_UINT: 691 PIPE_FORMAT_S8_UINT_Z24_UNORM; 692 } 693 break; 694 case 32: 695 stvis->depth_stencil_format = PIPE_FORMAT_Z32_UNORM; 696 break; 697 } 698 699 stvis->accum_format = (mode->accumRedBits > 0) ? 700 PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE; 701 702 stvis->buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK; 703 if (mode->doubleBufferMode) { 704 stvis->buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK; 705 } 706 if (mode->stereoMode) { 707 stvis->buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK; 708 if (mode->doubleBufferMode) 709 stvis->buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK; 710 } 711 712 if (mode->depthBits > 0 || mode->stencilBits > 0) 713 stvis->buffer_mask |= ST_ATTACHMENT_DEPTH_STENCIL_MASK; 714 /* let the gallium frontend allocate the accum buffer */ 715} 716 717static bool 718dri_get_egl_image(struct st_manager *smapi, 719 void *egl_image, 720 struct st_egl_image *stimg) 721{ 722 struct dri_screen *screen = (struct dri_screen *)smapi; 723 __DRIimage *img = NULL; 724 const struct dri2_format_mapping *map; 725 726 if (screen->lookup_egl_image_validated) { 727 img = screen->lookup_egl_image_validated(screen, egl_image); 728 } else if (screen->lookup_egl_image) { 729 img = screen->lookup_egl_image(screen, egl_image); 730 } 731 732 if (!img) 733 return FALSE; 734 735 stimg->texture = NULL; 736 pipe_resource_reference(&stimg->texture, img->texture); 737 map = dri2_get_mapping_by_fourcc(img->dri_fourcc); 738 stimg->format = map ? map->pipe_format : img->texture->format; 739 stimg->level = img->level; 740 stimg->layer = img->layer; 741 742 if (img->imported_dmabuf && map) { 743 /* Guess sized internal format for dma-bufs. Could be used 744 * by EXT_EGL_image_storage. 745 */ 746 mesa_format mesa_format = driImageFormatToGLFormat(map->dri_format); 747 stimg->internalformat = driGLFormatToSizedInternalGLFormat(mesa_format); 748 } else { 749 stimg->internalformat = img->internal_format; 750 } 751 752 stimg->yuv_color_space = img->yuv_color_space; 753 stimg->yuv_range = img->sample_range; 754 755 return TRUE; 756} 757 758static bool 759dri_validate_egl_image(struct st_manager *smapi, 760 void *egl_image) 761{ 762 struct dri_screen *screen = (struct dri_screen *)smapi; 763 764 return screen->validate_egl_image(screen, egl_image); 765} 766 767static int 768dri_get_param(struct st_manager *smapi, 769 enum st_manager_param param) 770{ 771 return 0; 772} 773 774void 775dri_destroy_screen_helper(struct dri_screen * screen) 776{ 777 if (screen->base.destroy) 778 screen->base.destroy(&screen->base); 779 780 if (screen->st_api && screen->st_api->destroy) 781 screen->st_api->destroy(screen->st_api); 782 783 if (screen->base.screen) 784 screen->base.screen->destroy(screen->base.screen); 785 786 mtx_destroy(&screen->opencl_func_mutex); 787} 788 789void 790dri_destroy_screen(__DRIscreen * sPriv) 791{ 792 struct dri_screen *screen = dri_screen(sPriv); 793 794 dri_destroy_screen_helper(screen); 795 796 pipe_loader_release(&screen->dev, 1); 797 798 free(screen->options.force_gl_vendor); 799 free(screen->options.force_gl_renderer); 800 free(screen->options.mesa_extension_override); 801 802 /* The caller in dri_util preserves the fd ownership */ 803 free(screen); 804 sPriv->driverPrivate = NULL; 805 sPriv->extensions = NULL; 806} 807 808static void 809dri_postprocessing_init(struct dri_screen *screen) 810{ 811 unsigned i; 812 813 for (i = 0; i < PP_FILTERS; i++) { 814 screen->pp_enabled[i] = driQueryOptioni(&screen->dev->option_cache, 815 pp_filters[i].name); 816 } 817} 818 819static void 820dri_set_background_context(struct st_context_iface *st, 821 struct util_queue_monitoring *queue_info) 822{ 823 struct dri_context *ctx = (struct dri_context *)st->st_manager_private; 824 const __DRIbackgroundCallableExtension *backgroundCallable = 825 ctx->sPriv->dri2.backgroundCallable; 826 827 /* Note: Mesa will only call this function if GL multithreading is enabled 828 * We only do that if the loader exposed the __DRI_BACKGROUND_CALLABLE 829 * extension. So we know that backgroundCallable is not NULL. 830 */ 831 assert(backgroundCallable); 832 backgroundCallable->setBackgroundContext(ctx->cPriv->loaderPrivate); 833 834 if (ctx->hud) 835 hud_add_queue_for_monitoring(ctx->hud, queue_info); 836} 837 838const __DRIconfig ** 839dri_init_screen_helper(struct dri_screen *screen, 840 struct pipe_screen *pscreen) 841{ 842 screen->base.screen = pscreen; 843 screen->base.get_egl_image = dri_get_egl_image; 844 screen->base.get_param = dri_get_param; 845 screen->base.set_background_context = dri_set_background_context; 846 847 if (screen->validate_egl_image) 848 screen->base.validate_egl_image = dri_validate_egl_image; 849 850 screen->st_api = st_gl_api_create(); 851 if (!screen->st_api) 852 return NULL; 853 854 if(pscreen->get_param(pscreen, PIPE_CAP_NPOT_TEXTURES)) 855 screen->target = PIPE_TEXTURE_2D; 856 else 857 screen->target = PIPE_TEXTURE_RECT; 858 859 dri_postprocessing_init(screen); 860 861 screen->st_api->query_versions(screen->st_api, &screen->base, 862 &screen->options, 863 &screen->sPriv->max_gl_core_version, 864 &screen->sPriv->max_gl_compat_version, 865 &screen->sPriv->max_gl_es1_version, 866 &screen->sPriv->max_gl_es2_version); 867 868 return dri_fill_in_modes(screen); 869} 870 871/* vim: set sw=3 ts=8 sts=3 expandtab: */ 872