lp_screen.c revision 01e04c3f
1/************************************************************************** 2 * 3 * Copyright 2008 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 29#include "util/u_memory.h" 30#include "util/u_math.h" 31#include "util/u_cpu_detect.h" 32#include "util/u_format.h" 33#include "util/u_screen.h" 34#include "util/u_string.h" 35#include "util/u_format_s3tc.h" 36#include "pipe/p_defines.h" 37#include "pipe/p_screen.h" 38#include "draw/draw_context.h" 39#include "gallivm/lp_bld_type.h" 40 41#include "util/os_misc.h" 42#include "util/os_time.h" 43#include "lp_texture.h" 44#include "lp_fence.h" 45#include "lp_jit.h" 46#include "lp_screen.h" 47#include "lp_context.h" 48#include "lp_debug.h" 49#include "lp_public.h" 50#include "lp_limits.h" 51#include "lp_rast.h" 52 53#include "state_tracker/sw_winsys.h" 54 55#ifdef DEBUG 56int LP_DEBUG = 0; 57 58static const struct debug_named_value lp_debug_flags[] = { 59 { "pipe", DEBUG_PIPE, NULL }, 60 { "tgsi", DEBUG_TGSI, NULL }, 61 { "tex", DEBUG_TEX, NULL }, 62 { "setup", DEBUG_SETUP, NULL }, 63 { "rast", DEBUG_RAST, NULL }, 64 { "query", DEBUG_QUERY, NULL }, 65 { "screen", DEBUG_SCREEN, NULL }, 66 { "counters", DEBUG_COUNTERS, NULL }, 67 { "scene", DEBUG_SCENE, NULL }, 68 { "fence", DEBUG_FENCE, NULL }, 69 { "mem", DEBUG_MEM, NULL }, 70 { "fs", DEBUG_FS, NULL }, 71 DEBUG_NAMED_VALUE_END 72}; 73#endif 74 75int LP_PERF = 0; 76static const struct debug_named_value lp_perf_flags[] = { 77 { "texmem", PERF_TEX_MEM, NULL }, 78 { "no_mipmap", PERF_NO_MIPMAPS, NULL }, 79 { "no_linear", PERF_NO_LINEAR, NULL }, 80 { "no_mip_linear", PERF_NO_MIP_LINEAR, NULL }, 81 { "no_tex", PERF_NO_TEX, NULL }, 82 { "no_blend", PERF_NO_BLEND, NULL }, 83 { "no_depth", PERF_NO_DEPTH, NULL }, 84 { "no_alphatest", PERF_NO_ALPHATEST, NULL }, 85 DEBUG_NAMED_VALUE_END 86}; 87 88 89static const char * 90llvmpipe_get_vendor(struct pipe_screen *screen) 91{ 92 return "VMware, Inc."; 93} 94 95 96static const char * 97llvmpipe_get_name(struct pipe_screen *screen) 98{ 99 static char buf[100]; 100 util_snprintf(buf, sizeof(buf), "llvmpipe (LLVM %u.%u, %u bits)", 101 HAVE_LLVM >> 8, HAVE_LLVM & 0xff, 102 lp_native_vector_width ); 103 return buf; 104} 105 106 107static int 108llvmpipe_get_param(struct pipe_screen *screen, enum pipe_cap param) 109{ 110 switch (param) { 111 case PIPE_CAP_NPOT_TEXTURES: 112 case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES: 113 case PIPE_CAP_MIXED_COLOR_DEPTH_BITS: 114 return 1; 115 case PIPE_CAP_SM3: 116 return 1; 117 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS: 118 return 1; 119 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS: 120 return PIPE_MAX_SO_BUFFERS; 121 case PIPE_CAP_ANISOTROPIC_FILTER: 122 return 0; 123 case PIPE_CAP_POINT_SPRITE: 124 return 1; 125 case PIPE_CAP_MAX_RENDER_TARGETS: 126 return PIPE_MAX_COLOR_BUFS; 127 case PIPE_CAP_OCCLUSION_QUERY: 128 return 1; 129 case PIPE_CAP_QUERY_TIME_ELAPSED: 130 return 0; 131 case PIPE_CAP_QUERY_TIMESTAMP: 132 return 1; 133 case PIPE_CAP_QUERY_PIPELINE_STATISTICS: 134 return 1; 135 case PIPE_CAP_TEXTURE_MIRROR_CLAMP: 136 case PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE: 137 return 1; 138 case PIPE_CAP_TEXTURE_SWIZZLE: 139 return 1; 140 case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK: 141 case PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET: 142 return 0; 143 case PIPE_CAP_MAX_TEXTURE_2D_LEVELS: 144 return LP_MAX_TEXTURE_2D_LEVELS; 145 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS: 146 return LP_MAX_TEXTURE_3D_LEVELS; 147 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS: 148 return LP_MAX_TEXTURE_CUBE_LEVELS; 149 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS: 150 return LP_MAX_TEXTURE_ARRAY_LAYERS; 151 case PIPE_CAP_BLEND_EQUATION_SEPARATE: 152 return 1; 153 case PIPE_CAP_INDEP_BLEND_ENABLE: 154 return 1; 155 case PIPE_CAP_INDEP_BLEND_FUNC: 156 return 1; 157 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT: 158 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER: 159 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER: 160 return 1; 161 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT: 162 case PIPE_CAP_DEPTH_CLIP_DISABLE_SEPARATE: 163 return 0; 164 case PIPE_CAP_PRIMITIVE_RESTART: 165 return 1; 166 case PIPE_CAP_DEPTH_CLIP_DISABLE: 167 return 1; 168 case PIPE_CAP_SHADER_STENCIL_EXPORT: 169 return 1; 170 case PIPE_CAP_TGSI_INSTANCEID: 171 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR: 172 case PIPE_CAP_START_INSTANCE: 173 return 1; 174 case PIPE_CAP_FRAGMENT_COLOR_CLAMPED: 175 return 0; 176 case PIPE_CAP_MIXED_COLORBUFFER_FORMATS: 177 return 1; 178 case PIPE_CAP_SEAMLESS_CUBE_MAP: 179 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE: 180 return 1; 181 /* this is a lie could support arbitrary large offsets */ 182 case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: 183 case PIPE_CAP_MIN_TEXEL_OFFSET: 184 return -32; 185 case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET: 186 case PIPE_CAP_MAX_TEXEL_OFFSET: 187 return 31; 188 case PIPE_CAP_CONDITIONAL_RENDER: 189 return 1; 190 case PIPE_CAP_TEXTURE_BARRIER: 191 return 0; 192 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS: 193 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS: 194 return 16*4; 195 case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES: 196 case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: 197 return 1024; 198 case PIPE_CAP_MAX_VERTEX_STREAMS: 199 return 1; 200 case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE: 201 return 2048; 202 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME: 203 case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS: 204 return 1; 205 case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS: 206 return 0; 207 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: 208 case PIPE_CAP_VERTEX_COLOR_CLAMPED: 209 return 1; 210 case PIPE_CAP_GLSL_FEATURE_LEVEL: 211 return 330; 212 case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY: 213 return 140; 214 case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: 215 return 0; 216 case PIPE_CAP_COMPUTE: 217 return 0; 218 case PIPE_CAP_USER_VERTEX_BUFFERS: 219 return 1; 220 case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY: 221 case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY: 222 case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY: 223 case PIPE_CAP_TGSI_TEXCOORD: 224 return 0; 225 case PIPE_CAP_DRAW_INDIRECT: 226 return 1; 227 228 case PIPE_CAP_CUBE_MAP_ARRAY: 229 return 1; 230 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT: 231 return 16; 232 case PIPE_CAP_TEXTURE_MULTISAMPLE: 233 return 0; 234 case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT: 235 return 64; 236 case PIPE_CAP_TEXTURE_BUFFER_OBJECTS: 237 return 1; 238 case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE: 239 return 65536; 240 case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT: 241 return 1; 242 case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER: 243 return 0; 244 case PIPE_CAP_MAX_VIEWPORTS: 245 return PIPE_MAX_VIEWPORTS; 246 case PIPE_CAP_ENDIANNESS: 247 return PIPE_ENDIAN_NATIVE; 248 case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT: 249 return 1; 250 case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT: 251 return 1; 252 case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS: 253 return 4; 254 case PIPE_CAP_TEXTURE_GATHER_SM5: 255 case PIPE_CAP_SAMPLE_SHADING: 256 case PIPE_CAP_TEXTURE_GATHER_OFFSETS: 257 return 0; 258 case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION: 259 return 1; 260 case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE: 261 case PIPE_CAP_TGSI_TEX_TXF_LZ: 262 return 0; 263 case PIPE_CAP_SAMPLER_VIEW_TARGET: 264 return 1; 265 case PIPE_CAP_FAKE_SW_MSAA: 266 return 1; 267 case PIPE_CAP_TEXTURE_QUERY_LOD: 268 case PIPE_CAP_CONDITIONAL_RENDER_INVERTED: 269 case PIPE_CAP_TGSI_ARRAY_COMPONENTS: 270 case PIPE_CAP_DOUBLES: 271 case PIPE_CAP_INT64: 272 case PIPE_CAP_INT64_DIVMOD: 273 case PIPE_CAP_QUERY_SO_OVERFLOW: 274 return 1; 275 276 case PIPE_CAP_VENDOR_ID: 277 return 0xFFFFFFFF; 278 case PIPE_CAP_DEVICE_ID: 279 return 0xFFFFFFFF; 280 case PIPE_CAP_ACCELERATED: 281 return 0; 282 case PIPE_CAP_VIDEO_MEMORY: { 283 /* XXX: Do we want to return the full amount fo system memory ? */ 284 uint64_t system_memory; 285 286 if (!os_get_total_physical_memory(&system_memory)) 287 return 0; 288 289 if (sizeof(void *) == 4) 290 /* Cap to 2 GB on 32 bits system. We do this because llvmpipe does 291 * eat application memory, which is quite limited on 32 bits. App 292 * shouldn't expect too much available memory. */ 293 system_memory = MIN2(system_memory, 2048 << 20); 294 295 return (int)(system_memory >> 20); 296 } 297 case PIPE_CAP_UMA: 298 return 0; 299 case PIPE_CAP_CLIP_HALFZ: 300 return 1; 301 case PIPE_CAP_VERTEXID_NOBASE: 302 return 0; 303 case PIPE_CAP_POLYGON_OFFSET_CLAMP: 304 case PIPE_CAP_TEXTURE_FLOAT_LINEAR: 305 case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR: 306 return 1; 307 case PIPE_CAP_CULL_DISTANCE: 308 return 1; 309 case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS: 310 return 1; 311 case PIPE_CAP_CLEAR_TEXTURE: 312 return 1; 313 case PIPE_CAP_MULTISAMPLE_Z_RESOLVE: 314 case PIPE_CAP_RESOURCE_FROM_USER_MEMORY: 315 case PIPE_CAP_DEVICE_RESET_STATUS_QUERY: 316 case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS: 317 case PIPE_CAP_DEPTH_BOUNDS_TEST: 318 case PIPE_CAP_TGSI_TXQS: 319 case PIPE_CAP_FORCE_PERSAMPLE_INTERP: 320 case PIPE_CAP_SHAREABLE_SHADERS: 321 case PIPE_CAP_DRAW_PARAMETERS: 322 case PIPE_CAP_TGSI_PACK_HALF_FLOAT: 323 case PIPE_CAP_MULTI_DRAW_INDIRECT: 324 case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS: 325 case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL: 326 case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL: 327 case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT: 328 case PIPE_CAP_INVALIDATE_BUFFER: 329 case PIPE_CAP_GENERATE_MIPMAP: 330 case PIPE_CAP_STRING_MARKER: 331 case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY: 332 case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS: 333 case PIPE_CAP_QUERY_BUFFER_OBJECT: 334 case PIPE_CAP_QUERY_MEMORY_INFO: 335 case PIPE_CAP_PCI_GROUP: 336 case PIPE_CAP_PCI_BUS: 337 case PIPE_CAP_PCI_DEVICE: 338 case PIPE_CAP_PCI_FUNCTION: 339 case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT: 340 case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR: 341 case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES: 342 case PIPE_CAP_TGSI_VOTE: 343 case PIPE_CAP_MAX_WINDOW_RECTANGLES: 344 case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED: 345 case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS: 346 case PIPE_CAP_TGSI_CAN_READ_OUTPUTS: 347 case PIPE_CAP_NATIVE_FENCE_FD: 348 case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY: 349 case PIPE_CAP_TGSI_FS_FBFETCH: 350 case PIPE_CAP_TGSI_MUL_ZERO_WINS: 351 case PIPE_CAP_TGSI_CLOCK: 352 case PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE: 353 case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE: 354 case PIPE_CAP_TGSI_BALLOT: 355 case PIPE_CAP_TGSI_TES_LAYER_VIEWPORT: 356 case PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX: 357 case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION: 358 case PIPE_CAP_POST_DEPTH_COVERAGE: 359 case PIPE_CAP_BINDLESS_TEXTURE: 360 case PIPE_CAP_NIR_SAMPLERS_AS_DEREF: 361 case PIPE_CAP_MEMOBJ: 362 case PIPE_CAP_LOAD_CONSTBUF: 363 case PIPE_CAP_TGSI_ANY_REG_AS_ADDRESS: 364 case PIPE_CAP_TILE_RASTER_ORDER: 365 case PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES: 366 case PIPE_CAP_FRAMEBUFFER_MSAA_CONSTRAINTS: 367 case PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET: 368 case PIPE_CAP_CONTEXT_PRIORITY_MASK: 369 case PIPE_CAP_FENCE_SIGNAL: 370 case PIPE_CAP_CONSTBUF0_FLAGS: 371 case PIPE_CAP_PACKED_UNIFORMS: 372 case PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES: 373 case PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES: 374 case PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES: 375 case PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES: 376 case PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE: 377 case PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS: 378 case PIPE_CAP_PROGRAMMABLE_SAMPLE_LOCATIONS: 379 return 0; 380 case PIPE_CAP_MAX_GS_INVOCATIONS: 381 return 32; 382 case PIPE_CAP_MAX_SHADER_BUFFER_SIZE: 383 return 1 << 27; 384 385 default: 386 return u_pipe_screen_get_param_defaults(screen, param); 387 } 388} 389 390static int 391llvmpipe_get_shader_param(struct pipe_screen *screen, 392 enum pipe_shader_type shader, 393 enum pipe_shader_cap param) 394{ 395 switch(shader) 396 { 397 case PIPE_SHADER_FRAGMENT: 398 switch (param) { 399 default: 400 return gallivm_get_shader_param(param); 401 } 402 case PIPE_SHADER_VERTEX: 403 case PIPE_SHADER_GEOMETRY: 404 switch (param) { 405 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: 406 /* At this time, the draw module and llvmpipe driver only 407 * support vertex shader texture lookups when LLVM is enabled in 408 * the draw module. 409 */ 410 if (debug_get_bool_option("DRAW_USE_LLVM", TRUE)) 411 return PIPE_MAX_SAMPLERS; 412 else 413 return 0; 414 case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS: 415 if (debug_get_bool_option("DRAW_USE_LLVM", TRUE)) 416 return PIPE_MAX_SHADER_SAMPLER_VIEWS; 417 else 418 return 0; 419 default: 420 return draw_get_shader_param(shader, param); 421 } 422 default: 423 return 0; 424 } 425} 426 427static float 428llvmpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param) 429{ 430 switch (param) { 431 case PIPE_CAPF_MAX_LINE_WIDTH: 432 /* fall-through */ 433 case PIPE_CAPF_MAX_LINE_WIDTH_AA: 434 return 255.0; /* arbitrary */ 435 case PIPE_CAPF_MAX_POINT_WIDTH: 436 /* fall-through */ 437 case PIPE_CAPF_MAX_POINT_WIDTH_AA: 438 return 255.0; /* arbitrary */ 439 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY: 440 return 16.0; /* not actually signficant at this time */ 441 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS: 442 return 16.0; /* arbitrary */ 443 case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE: 444 return 0.0; 445 case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE: 446 return 0.0; 447 case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY: 448 return 0.0; 449 } 450 /* should only get here on unhandled cases */ 451 debug_printf("Unexpected PIPE_CAP %d query\n", param); 452 return 0.0; 453} 454 455 456/** 457 * Query format support for creating a texture, drawing surface, etc. 458 * \param format the format to test 459 * \param type one of PIPE_TEXTURE, PIPE_SURFACE 460 */ 461static boolean 462llvmpipe_is_format_supported( struct pipe_screen *_screen, 463 enum pipe_format format, 464 enum pipe_texture_target target, 465 unsigned sample_count, 466 unsigned storage_sample_count, 467 unsigned bind) 468{ 469 struct llvmpipe_screen *screen = llvmpipe_screen(_screen); 470 struct sw_winsys *winsys = screen->winsys; 471 const struct util_format_description *format_desc; 472 473 format_desc = util_format_description(format); 474 if (!format_desc) 475 return FALSE; 476 477 assert(target == PIPE_BUFFER || 478 target == PIPE_TEXTURE_1D || 479 target == PIPE_TEXTURE_1D_ARRAY || 480 target == PIPE_TEXTURE_2D || 481 target == PIPE_TEXTURE_2D_ARRAY || 482 target == PIPE_TEXTURE_RECT || 483 target == PIPE_TEXTURE_3D || 484 target == PIPE_TEXTURE_CUBE || 485 target == PIPE_TEXTURE_CUBE_ARRAY); 486 487 if (sample_count > 1) 488 return FALSE; 489 490 if (MAX2(1, sample_count) != MAX2(1, storage_sample_count)) 491 return false; 492 493 if (bind & PIPE_BIND_RENDER_TARGET) { 494 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) { 495 /* this is a lie actually other formats COULD exist where we would fail */ 496 if (format_desc->nr_channels < 3) 497 return FALSE; 498 } 499 else if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) 500 return FALSE; 501 502 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN && 503 format != PIPE_FORMAT_R11G11B10_FLOAT) 504 return FALSE; 505 506 assert(format_desc->block.width == 1); 507 assert(format_desc->block.height == 1); 508 509 if (format_desc->is_mixed) 510 return FALSE; 511 512 if (!format_desc->is_array && !format_desc->is_bitmask && 513 format != PIPE_FORMAT_R11G11B10_FLOAT) 514 return FALSE; 515 } 516 517 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) && 518 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0)) { 519 /* Disable all 3-channel formats, where channel size != 32 bits. 520 * In some cases we run into crashes (in generate_unswizzled_blend()), 521 * for 3-channel RGB16 variants, there was an apparent LLVM bug. 522 * In any case, disabling the shallower 3-channel formats avoids a 523 * number of issues with GL_ARB_copy_image support. 524 */ 525 if (format_desc->is_array && 526 format_desc->nr_channels == 3 && 527 format_desc->block.bits != 96) { 528 return FALSE; 529 } 530 } 531 532 if (bind & PIPE_BIND_DISPLAY_TARGET) { 533 if(!winsys->is_displaytarget_format_supported(winsys, bind, format)) 534 return FALSE; 535 } 536 537 if (bind & PIPE_BIND_DEPTH_STENCIL) { 538 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) 539 return FALSE; 540 541 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS) 542 return FALSE; 543 544 /* TODO: Support stencil-only formats */ 545 if (format_desc->swizzle[0] == PIPE_SWIZZLE_NONE) { 546 return FALSE; 547 } 548 } 549 550 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC) { 551 /* Software decoding is not hooked up. */ 552 return FALSE; 553 } 554 555 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC && 556 format != PIPE_FORMAT_ETC1_RGB8) 557 return FALSE; 558 559 /* 560 * Everything can be supported by u_format 561 * (those without fetch_rgba_float might be not but shouldn't hit that) 562 */ 563 564 return TRUE; 565} 566 567 568 569 570static void 571llvmpipe_flush_frontbuffer(struct pipe_screen *_screen, 572 struct pipe_resource *resource, 573 unsigned level, unsigned layer, 574 void *context_private, 575 struct pipe_box *sub_box) 576{ 577 struct llvmpipe_screen *screen = llvmpipe_screen(_screen); 578 struct sw_winsys *winsys = screen->winsys; 579 struct llvmpipe_resource *texture = llvmpipe_resource(resource); 580 581 assert(texture->dt); 582 if (texture->dt) 583 winsys->displaytarget_display(winsys, texture->dt, context_private, sub_box); 584} 585 586static void 587llvmpipe_destroy_screen( struct pipe_screen *_screen ) 588{ 589 struct llvmpipe_screen *screen = llvmpipe_screen(_screen); 590 struct sw_winsys *winsys = screen->winsys; 591 592 if (screen->rast) 593 lp_rast_destroy(screen->rast); 594 595 lp_jit_screen_cleanup(screen); 596 597 if(winsys->destroy) 598 winsys->destroy(winsys); 599 600 mtx_destroy(&screen->rast_mutex); 601 602 FREE(screen); 603} 604 605 606 607 608/** 609 * Fence reference counting. 610 */ 611static void 612llvmpipe_fence_reference(struct pipe_screen *screen, 613 struct pipe_fence_handle **ptr, 614 struct pipe_fence_handle *fence) 615{ 616 struct lp_fence **old = (struct lp_fence **) ptr; 617 struct lp_fence *f = (struct lp_fence *) fence; 618 619 lp_fence_reference(old, f); 620} 621 622 623/** 624 * Wait for the fence to finish. 625 */ 626static boolean 627llvmpipe_fence_finish(struct pipe_screen *screen, 628 struct pipe_context *ctx, 629 struct pipe_fence_handle *fence_handle, 630 uint64_t timeout) 631{ 632 struct lp_fence *f = (struct lp_fence *) fence_handle; 633 634 if (!timeout) 635 return lp_fence_signalled(f); 636 637 lp_fence_wait(f); 638 return TRUE; 639} 640 641static uint64_t 642llvmpipe_get_timestamp(struct pipe_screen *_screen) 643{ 644 return os_time_get_nano(); 645} 646 647/** 648 * Create a new pipe_screen object 649 * Note: we're not presently subclassing pipe_screen (no llvmpipe_screen). 650 */ 651struct pipe_screen * 652llvmpipe_create_screen(struct sw_winsys *winsys) 653{ 654 struct llvmpipe_screen *screen; 655 656 util_cpu_detect(); 657 658#ifdef DEBUG 659 LP_DEBUG = debug_get_flags_option("LP_DEBUG", lp_debug_flags, 0 ); 660#endif 661 662 LP_PERF = debug_get_flags_option("LP_PERF", lp_perf_flags, 0 ); 663 664 screen = CALLOC_STRUCT(llvmpipe_screen); 665 if (!screen) 666 return NULL; 667 668 if (!lp_jit_screen_init(screen)) { 669 FREE(screen); 670 return NULL; 671 } 672 673 screen->winsys = winsys; 674 675 screen->base.destroy = llvmpipe_destroy_screen; 676 677 screen->base.get_name = llvmpipe_get_name; 678 screen->base.get_vendor = llvmpipe_get_vendor; 679 screen->base.get_device_vendor = llvmpipe_get_vendor; // TODO should be the CPU vendor 680 screen->base.get_param = llvmpipe_get_param; 681 screen->base.get_shader_param = llvmpipe_get_shader_param; 682 screen->base.get_paramf = llvmpipe_get_paramf; 683 screen->base.is_format_supported = llvmpipe_is_format_supported; 684 685 screen->base.context_create = llvmpipe_create_context; 686 screen->base.flush_frontbuffer = llvmpipe_flush_frontbuffer; 687 screen->base.fence_reference = llvmpipe_fence_reference; 688 screen->base.fence_finish = llvmpipe_fence_finish; 689 690 screen->base.get_timestamp = llvmpipe_get_timestamp; 691 692 llvmpipe_init_screen_resource_funcs(&screen->base); 693 694 screen->num_threads = util_cpu_caps.nr_cpus > 1 ? util_cpu_caps.nr_cpus : 0; 695#ifdef PIPE_SUBSYSTEM_EMBEDDED 696 screen->num_threads = 0; 697#endif 698 screen->num_threads = debug_get_num_option("LP_NUM_THREADS", screen->num_threads); 699 screen->num_threads = MIN2(screen->num_threads, LP_MAX_THREADS); 700 701 screen->rast = lp_rast_create(screen->num_threads); 702 if (!screen->rast) { 703 lp_jit_screen_cleanup(screen); 704 FREE(screen); 705 return NULL; 706 } 707 (void) mtx_init(&screen->rast_mutex, mtx_plain); 708 709 return &screen->base; 710} 711