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_format.h" 31 #include "util/u_format_s3tc.h" 32 #include "util/u_video.h" 33 #include "os/os_misc.h" 34 #include "os/os_time.h" 35 #include "pipe/p_defines.h" 36 #include "pipe/p_screen.h" 37 #include "draw/draw_context.h" 38 39 #include "state_tracker/sw_winsys.h" 40 #include "tgsi/tgsi_exec.h" 41 42 #include "sp_texture.h" 43 #include "sp_screen.h" 44 #include "sp_context.h" 45 #include "sp_fence.h" 46 #include "sp_public.h" 47 48 DEBUG_GET_ONCE_BOOL_OPTION(use_llvm, "SOFTPIPE_USE_LLVM", FALSE) 49 50 static const char * 51 softpipe_get_vendor(struct pipe_screen *screen) 52 { 53 return "VMware, Inc."; 54 } 55 56 57 static const char * 58 softpipe_get_name(struct pipe_screen *screen) 59 { 60 return "softpipe"; 61 } 62 63 64 static int 65 softpipe_get_param(struct pipe_screen *screen, enum pipe_cap param) 66 { 67 switch (param) { 68 case PIPE_CAP_NPOT_TEXTURES: 69 case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES: 70 case PIPE_CAP_MIXED_COLOR_DEPTH_BITS: 71 return 1; 72 case PIPE_CAP_TWO_SIDED_STENCIL: 73 return 1; 74 case PIPE_CAP_SM3: 75 return 1; 76 case PIPE_CAP_ANISOTROPIC_FILTER: 77 return 1; 78 case PIPE_CAP_POINT_SPRITE: 79 return 1; 80 case PIPE_CAP_MAX_RENDER_TARGETS: 81 return PIPE_MAX_COLOR_BUFS; 82 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS: 83 return 1; 84 case PIPE_CAP_OCCLUSION_QUERY: 85 return 1; 86 case PIPE_CAP_QUERY_TIME_ELAPSED: 87 return 1; 88 case PIPE_CAP_QUERY_PIPELINE_STATISTICS: 89 return 1; 90 case PIPE_CAP_TEXTURE_MIRROR_CLAMP: 91 return 1; 92 case PIPE_CAP_TEXTURE_SHADOW_MAP: 93 return 1; 94 case PIPE_CAP_TEXTURE_SWIZZLE: 95 return 1; 96 case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK: 97 return 0; 98 case PIPE_CAP_MAX_TEXTURE_2D_LEVELS: 99 return SP_MAX_TEXTURE_2D_LEVELS; 100 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS: 101 return SP_MAX_TEXTURE_3D_LEVELS; 102 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS: 103 return SP_MAX_TEXTURE_CUBE_LEVELS; 104 case PIPE_CAP_BLEND_EQUATION_SEPARATE: 105 return 1; 106 case PIPE_CAP_INDEP_BLEND_ENABLE: 107 return 1; 108 case PIPE_CAP_INDEP_BLEND_FUNC: 109 return 1; 110 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT: 111 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT: 112 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER: 113 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER: 114 return 1; 115 case PIPE_CAP_DEPTH_CLIP_DISABLE: 116 return 1; 117 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS: 118 return PIPE_MAX_SO_BUFFERS; 119 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS: 120 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS: 121 return 16*4; 122 case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES: 123 case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: 124 return 1024; 125 case PIPE_CAP_MAX_VERTEX_STREAMS: 126 return 1; 127 case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE: 128 return 2048; 129 case PIPE_CAP_PRIMITIVE_RESTART: 130 return 1; 131 case PIPE_CAP_SHADER_STENCIL_EXPORT: 132 return 1; 133 case PIPE_CAP_TGSI_INSTANCEID: 134 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR: 135 case PIPE_CAP_START_INSTANCE: 136 return 1; 137 case PIPE_CAP_SEAMLESS_CUBE_MAP: 138 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE: 139 return 1; 140 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS: 141 return 256; /* for GL3 */ 142 case PIPE_CAP_MIN_TEXEL_OFFSET: 143 return -8; 144 case PIPE_CAP_MAX_TEXEL_OFFSET: 145 return 7; 146 case PIPE_CAP_CONDITIONAL_RENDER: 147 return 1; 148 case PIPE_CAP_TEXTURE_BARRIER: 149 return 0; 150 case PIPE_CAP_FRAGMENT_COLOR_CLAMPED: 151 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: /* draw module */ 152 case PIPE_CAP_VERTEX_COLOR_CLAMPED: /* draw module */ 153 return 1; 154 case PIPE_CAP_MIXED_COLORBUFFER_FORMATS: 155 return 0; 156 case PIPE_CAP_GLSL_FEATURE_LEVEL: 157 return 330; 158 case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: 159 return 0; 160 case PIPE_CAP_COMPUTE: 161 return 1; 162 case PIPE_CAP_USER_VERTEX_BUFFERS: 163 case PIPE_CAP_USER_INDEX_BUFFERS: 164 case PIPE_CAP_USER_CONSTANT_BUFFERS: 165 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME: 166 case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS: 167 case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT: 168 return 1; 169 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT: 170 return 16; 171 case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS: 172 case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY: 173 case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY: 174 case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY: 175 case PIPE_CAP_TEXTURE_MULTISAMPLE: 176 return 0; 177 case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT: 178 return 64; 179 case PIPE_CAP_QUERY_TIMESTAMP: 180 case PIPE_CAP_CUBE_MAP_ARRAY: 181 return 1; 182 case PIPE_CAP_TEXTURE_BUFFER_OBJECTS: 183 return 1; 184 case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY: 185 return 0; 186 case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE: 187 return 65536; 188 case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT: 189 return 0; 190 case PIPE_CAP_TGSI_TEXCOORD: 191 case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER: 192 return 0; 193 case PIPE_CAP_MAX_VIEWPORTS: 194 return PIPE_MAX_VIEWPORTS; 195 case PIPE_CAP_ENDIANNESS: 196 return PIPE_ENDIAN_NATIVE; 197 case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS: 198 return 4; 199 case PIPE_CAP_TEXTURE_GATHER_SM5: 200 case PIPE_CAP_TEXTURE_QUERY_LOD: 201 return 1; 202 case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT: 203 case PIPE_CAP_SAMPLE_SHADING: 204 case PIPE_CAP_TEXTURE_GATHER_OFFSETS: 205 return 0; 206 case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION: 207 return 1; 208 case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE: 209 return 0; 210 case PIPE_CAP_SAMPLER_VIEW_TARGET: 211 return 1; 212 case PIPE_CAP_FAKE_SW_MSAA: 213 return 1; 214 case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: 215 return -32; 216 case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET: 217 return 31; 218 case PIPE_CAP_DRAW_INDIRECT: 219 return 1; 220 221 case PIPE_CAP_VENDOR_ID: 222 return 0xFFFFFFFF; 223 case PIPE_CAP_DEVICE_ID: 224 return 0xFFFFFFFF; 225 case PIPE_CAP_ACCELERATED: 226 return 0; 227 case PIPE_CAP_VIDEO_MEMORY: { 228 /* XXX: Do we want to return the full amount fo system memory ? */ 229 uint64_t system_memory; 230 231 if (!os_get_total_physical_memory(&system_memory)) 232 return 0; 233 234 if (sizeof(void *) == 4) 235 /* Cap to 2 GB on 32 bits system. We do this because softpipe does 236 * eat application memory, which is quite limited on 32 bits. App 237 * shouldn't expect too much available memory. */ 238 system_memory = MIN2(system_memory, 2048 << 20); 239 240 return (int)(system_memory >> 20); 241 } 242 case PIPE_CAP_UMA: 243 return 0; 244 case PIPE_CAP_CONDITIONAL_RENDER_INVERTED: 245 return 1; 246 case PIPE_CAP_CLIP_HALFZ: 247 case PIPE_CAP_TEXTURE_FLOAT_LINEAR: 248 case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR: 249 return 1; 250 case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT: 251 case PIPE_CAP_CULL_DISTANCE: 252 return 1; 253 case PIPE_CAP_VERTEXID_NOBASE: 254 return 0; 255 case PIPE_CAP_POLYGON_OFFSET_CLAMP: 256 return 0; 257 case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS: 258 case PIPE_CAP_TGSI_ARRAY_COMPONENTS: 259 return 1; 260 case PIPE_CAP_MULTISAMPLE_Z_RESOLVE: 261 case PIPE_CAP_RESOURCE_FROM_USER_MEMORY: 262 case PIPE_CAP_DEVICE_RESET_STATUS_QUERY: 263 case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS: 264 case PIPE_CAP_DEPTH_BOUNDS_TEST: 265 case PIPE_CAP_TGSI_TXQS: 266 case PIPE_CAP_FORCE_PERSAMPLE_INTERP: 267 case PIPE_CAP_SHAREABLE_SHADERS: 268 case PIPE_CAP_CLEAR_TEXTURE: 269 case PIPE_CAP_DRAW_PARAMETERS: 270 case PIPE_CAP_TGSI_PACK_HALF_FLOAT: 271 case PIPE_CAP_MULTI_DRAW_INDIRECT: 272 case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS: 273 case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL: 274 case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL: 275 case PIPE_CAP_INVALIDATE_BUFFER: 276 case PIPE_CAP_GENERATE_MIPMAP: 277 case PIPE_CAP_STRING_MARKER: 278 case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS: 279 case PIPE_CAP_QUERY_BUFFER_OBJECT: 280 case PIPE_CAP_QUERY_MEMORY_INFO: 281 case PIPE_CAP_PCI_GROUP: 282 case PIPE_CAP_PCI_BUS: 283 case PIPE_CAP_PCI_DEVICE: 284 case PIPE_CAP_PCI_FUNCTION: 285 case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR: 286 case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES: 287 case PIPE_CAP_TGSI_VOTE: 288 case PIPE_CAP_MAX_WINDOW_RECTANGLES: 289 case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED: 290 case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS: 291 case PIPE_CAP_TGSI_CAN_READ_OUTPUTS: 292 case PIPE_CAP_NATIVE_FENCE_FD: 293 case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY: 294 case PIPE_CAP_TGSI_FS_FBFETCH: 295 return 0; 296 case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT: 297 return 4; 298 } 299 /* should only get here on unhandled cases */ 300 debug_printf("Unexpected PIPE_CAP %d query\n", param); 301 return 0; 302 } 303 304 static int 305 softpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param) 306 { 307 struct softpipe_screen *sp_screen = softpipe_screen(screen); 308 switch(shader) 309 { 310 case PIPE_SHADER_FRAGMENT: 311 return tgsi_exec_get_shader_param(param); 312 case PIPE_SHADER_COMPUTE: 313 return tgsi_exec_get_shader_param(param); 314 case PIPE_SHADER_VERTEX: 315 case PIPE_SHADER_GEOMETRY: 316 if (sp_screen->use_llvm) 317 return draw_get_shader_param(shader, param); 318 else 319 return draw_get_shader_param_no_llvm(shader, param); 320 default: 321 return 0; 322 } 323 } 324 325 static float 326 softpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param) 327 { 328 switch (param) { 329 case PIPE_CAPF_MAX_LINE_WIDTH: 330 /* fall-through */ 331 case PIPE_CAPF_MAX_LINE_WIDTH_AA: 332 return 255.0; /* arbitrary */ 333 case PIPE_CAPF_MAX_POINT_WIDTH: 334 /* fall-through */ 335 case PIPE_CAPF_MAX_POINT_WIDTH_AA: 336 return 255.0; /* arbitrary */ 337 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY: 338 return 16.0; 339 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS: 340 return 16.0; /* arbitrary */ 341 case PIPE_CAPF_GUARD_BAND_LEFT: 342 case PIPE_CAPF_GUARD_BAND_TOP: 343 case PIPE_CAPF_GUARD_BAND_RIGHT: 344 case PIPE_CAPF_GUARD_BAND_BOTTOM: 345 return 0.0; 346 } 347 /* should only get here on unhandled cases */ 348 debug_printf("Unexpected PIPE_CAPF %d query\n", param); 349 return 0.0; 350 } 351 352 /** 353 * Query format support for creating a texture, drawing surface, etc. 354 * \param format the format to test 355 * \param type one of PIPE_TEXTURE, PIPE_SURFACE 356 */ 357 static boolean 358 softpipe_is_format_supported( struct pipe_screen *screen, 359 enum pipe_format format, 360 enum pipe_texture_target target, 361 unsigned sample_count, 362 unsigned bind) 363 { 364 struct sw_winsys *winsys = softpipe_screen(screen)->winsys; 365 const struct util_format_description *format_desc; 366 367 assert(target == PIPE_BUFFER || 368 target == PIPE_TEXTURE_1D || 369 target == PIPE_TEXTURE_1D_ARRAY || 370 target == PIPE_TEXTURE_2D || 371 target == PIPE_TEXTURE_2D_ARRAY || 372 target == PIPE_TEXTURE_RECT || 373 target == PIPE_TEXTURE_3D || 374 target == PIPE_TEXTURE_CUBE || 375 target == PIPE_TEXTURE_CUBE_ARRAY); 376 377 format_desc = util_format_description(format); 378 if (!format_desc) 379 return FALSE; 380 381 if (sample_count > 1) 382 return FALSE; 383 384 if (bind & (PIPE_BIND_DISPLAY_TARGET | 385 PIPE_BIND_SCANOUT | 386 PIPE_BIND_SHARED)) { 387 if(!winsys->is_displaytarget_format_supported(winsys, bind, format)) 388 return FALSE; 389 } 390 391 if (bind & PIPE_BIND_RENDER_TARGET) { 392 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) 393 return FALSE; 394 395 /* 396 * Although possible, it is unnatural to render into compressed or YUV 397 * surfaces. So disable these here to avoid going into weird paths 398 * inside the state trackers. 399 */ 400 if (format_desc->block.width != 1 || 401 format_desc->block.height != 1) 402 return FALSE; 403 } 404 405 if (bind & PIPE_BIND_DEPTH_STENCIL) { 406 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS) 407 return FALSE; 408 } 409 410 if (format_desc->layout == UTIL_FORMAT_LAYOUT_BPTC || 411 format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC) { 412 /* Software decoding is not hooked up. */ 413 return FALSE; 414 } 415 416 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) && 417 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0) && 418 target != PIPE_BUFFER) { 419 const struct util_format_description *desc = 420 util_format_description(format); 421 if (desc->nr_channels == 3 && desc->is_array) { 422 /* Don't support any 3-component formats for rendering/texturing 423 * since we don't support the corresponding 8-bit 3 channel UNORM 424 * formats. This allows us to support GL_ARB_copy_image between 425 * GL_RGB8 and GL_RGB8UI, for example. Otherwise, we may be asked to 426 * do a resource copy between PIPE_FORMAT_R8G8B8_UINT and 427 * PIPE_FORMAT_R8G8B8X8_UNORM, for example, which will not work 428 * (different bpp). 429 */ 430 return FALSE; 431 } 432 } 433 434 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC && 435 format != PIPE_FORMAT_ETC1_RGB8) 436 return FALSE; 437 438 /* 439 * All other operations (sampling, transfer, etc). 440 */ 441 442 if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC) { 443 return util_format_s3tc_enabled; 444 } 445 446 /* 447 * Everything else should be supported by u_format. 448 */ 449 return TRUE; 450 } 451 452 453 static void 454 softpipe_destroy_screen( struct pipe_screen *screen ) 455 { 456 struct softpipe_screen *sp_screen = softpipe_screen(screen); 457 struct sw_winsys *winsys = sp_screen->winsys; 458 459 if(winsys->destroy) 460 winsys->destroy(winsys); 461 462 FREE(screen); 463 } 464 465 466 /* This is often overriden by the co-state tracker. 467 */ 468 static void 469 softpipe_flush_frontbuffer(struct pipe_screen *_screen, 470 struct pipe_resource *resource, 471 unsigned level, unsigned layer, 472 void *context_private, 473 struct pipe_box *sub_box) 474 { 475 struct softpipe_screen *screen = softpipe_screen(_screen); 476 struct sw_winsys *winsys = screen->winsys; 477 struct softpipe_resource *texture = softpipe_resource(resource); 478 479 assert(texture->dt); 480 if (texture->dt) 481 winsys->displaytarget_display(winsys, texture->dt, context_private, sub_box); 482 } 483 484 static uint64_t 485 softpipe_get_timestamp(struct pipe_screen *_screen) 486 { 487 return os_time_get_nano(); 488 } 489 490 static int 491 softpipe_get_compute_param(struct pipe_screen *_screen, 492 enum pipe_shader_ir ir_type, 493 enum pipe_compute_cap param, 494 void *ret) 495 { 496 switch (param) { 497 case PIPE_COMPUTE_CAP_IR_TARGET: 498 return 0; 499 case PIPE_COMPUTE_CAP_MAX_GRID_SIZE: 500 if (ret) { 501 uint64_t *grid_size = ret; 502 grid_size[0] = 65535; 503 grid_size[1] = 65535; 504 grid_size[2] = 65535; 505 } 506 return 3 * sizeof(uint64_t) ; 507 case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE: 508 if (ret) { 509 uint64_t *block_size = ret; 510 block_size[0] = 1024; 511 block_size[1] = 1024; 512 block_size[2] = 1024; 513 } 514 return 3 * sizeof(uint64_t); 515 case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK: 516 if (ret) { 517 uint64_t *max_threads_per_block = ret; 518 *max_threads_per_block = 1024; 519 } 520 return sizeof(uint64_t); 521 case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE: 522 if (ret) { 523 uint64_t *max_local_size = ret; 524 *max_local_size = 32768; 525 } 526 return sizeof(uint64_t); 527 case PIPE_COMPUTE_CAP_GRID_DIMENSION: 528 case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE: 529 case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE: 530 case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE: 531 case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE: 532 case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY: 533 case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS: 534 case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED: 535 case PIPE_COMPUTE_CAP_SUBGROUP_SIZE: 536 case PIPE_COMPUTE_CAP_ADDRESS_BITS: 537 case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK: 538 break; 539 } 540 return 0; 541 } 542 543 /** 544 * Create a new pipe_screen object 545 * Note: we're not presently subclassing pipe_screen (no softpipe_screen). 546 */ 547 struct pipe_screen * 548 softpipe_create_screen(struct sw_winsys *winsys) 549 { 550 struct softpipe_screen *screen = CALLOC_STRUCT(softpipe_screen); 551 552 if (!screen) 553 return NULL; 554 555 screen->winsys = winsys; 556 557 screen->base.destroy = softpipe_destroy_screen; 558 559 screen->base.get_name = softpipe_get_name; 560 screen->base.get_vendor = softpipe_get_vendor; 561 screen->base.get_device_vendor = softpipe_get_vendor; // TODO should be the CPU vendor 562 screen->base.get_param = softpipe_get_param; 563 screen->base.get_shader_param = softpipe_get_shader_param; 564 screen->base.get_paramf = softpipe_get_paramf; 565 screen->base.get_timestamp = softpipe_get_timestamp; 566 screen->base.is_format_supported = softpipe_is_format_supported; 567 screen->base.context_create = softpipe_create_context; 568 screen->base.flush_frontbuffer = softpipe_flush_frontbuffer; 569 screen->base.get_compute_param = softpipe_get_compute_param; 570 screen->use_llvm = debug_get_option_use_llvm(); 571 572 util_format_s3tc_init(); 573 574 softpipe_init_screen_texture_funcs(&screen->base); 575 softpipe_init_screen_fence_funcs(&screen->base); 576 577 return &screen->base; 578 } 579
