Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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_string.h"
  34. #include "util/u_format_s3tc.h"
  35. #include "pipe/p_defines.h"
  36. #include "pipe/p_screen.h"
  37. #include "draw/draw_context.h"
  38. #include "gallivm/lp_bld_type.h"
  39.  
  40. #include "os/os_misc.h"
  41. #include "os/os_time.h"
  42. #include "lp_texture.h"
  43. #include "lp_fence.h"
  44. #include "lp_jit.h"
  45. #include "lp_screen.h"
  46. #include "lp_context.h"
  47. #include "lp_debug.h"
  48. #include "lp_public.h"
  49. #include "lp_limits.h"
  50. #include "lp_rast.h"
  51.  
  52. #include "state_tracker/sw_winsys.h"
  53.  
  54. #ifdef DEBUG
  55. int LP_DEBUG = 0;
  56.  
  57. static const struct debug_named_value lp_debug_flags[] = {
  58.    { "pipe",   DEBUG_PIPE, NULL },
  59.    { "tgsi",   DEBUG_TGSI, NULL },
  60.    { "tex",    DEBUG_TEX, NULL },
  61.    { "setup",  DEBUG_SETUP, NULL },
  62.    { "rast",   DEBUG_RAST, NULL },
  63.    { "query",  DEBUG_QUERY, NULL },
  64.    { "screen", DEBUG_SCREEN, NULL },
  65.    { "counters", DEBUG_COUNTERS, NULL },
  66.    { "scene", DEBUG_SCENE, NULL },
  67.    { "fence", DEBUG_FENCE, NULL },
  68.    { "mem", DEBUG_MEM, NULL },
  69.    { "fs", DEBUG_FS, NULL },
  70.    DEBUG_NAMED_VALUE_END
  71. };
  72. #endif
  73.  
  74. int LP_PERF = 0;
  75. static const struct debug_named_value lp_perf_flags[] = {
  76.    { "texmem",         PERF_TEX_MEM, NULL },
  77.    { "no_mipmap",      PERF_NO_MIPMAPS, NULL },
  78.    { "no_linear",      PERF_NO_LINEAR, NULL },
  79.    { "no_mip_linear",  PERF_NO_MIP_LINEAR, NULL },
  80.    { "no_tex",         PERF_NO_TEX, NULL },
  81.    { "no_blend",       PERF_NO_BLEND, NULL },
  82.    { "no_depth",       PERF_NO_DEPTH, NULL },
  83.    { "no_alphatest",   PERF_NO_ALPHATEST, NULL },
  84.    DEBUG_NAMED_VALUE_END
  85. };
  86.  
  87.  
  88. static const char *
  89. llvmpipe_get_vendor(struct pipe_screen *screen)
  90. {
  91.    return "VMware, Inc.";
  92. }
  93.  
  94.  
  95. static const char *
  96. llvmpipe_get_name(struct pipe_screen *screen)
  97. {
  98.    static char buf[100];
  99.    util_snprintf(buf, sizeof(buf), "llvmpipe (LLVM %u.%u, %u bits)",
  100.                  HAVE_LLVM >> 8, HAVE_LLVM & 0xff,
  101.                  lp_native_vector_width );
  102.    return buf;
  103. }
  104.  
  105.  
  106. static int
  107. llvmpipe_get_param(struct pipe_screen *screen, enum pipe_cap param)
  108. {
  109.    switch (param) {
  110.    case PIPE_CAP_NPOT_TEXTURES:
  111.    case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
  112.       return 1;
  113.    case PIPE_CAP_TWO_SIDED_STENCIL:
  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 0;
  135.    case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
  136.       return 1;
  137.    case PIPE_CAP_TEXTURE_SHADOW_MAP:
  138.       return 1;
  139.    case PIPE_CAP_TEXTURE_SWIZZLE:
  140.       return 1;
  141.    case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
  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.       return 0;
  163.    case PIPE_CAP_PRIMITIVE_RESTART:
  164.       return 1;
  165.    case PIPE_CAP_DEPTH_CLIP_DISABLE:
  166.       return 1;
  167.    case PIPE_CAP_SHADER_STENCIL_EXPORT:
  168.       return 0;
  169.    case PIPE_CAP_TGSI_INSTANCEID:
  170.    case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
  171.    case PIPE_CAP_START_INSTANCE:
  172.       return 1;
  173.    case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
  174.       return 0;
  175.    case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
  176.       return 1;
  177.    case PIPE_CAP_SEAMLESS_CUBE_MAP:
  178.    case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
  179.       return 1;
  180.    /* this is a lie could support arbitrary large offsets */
  181.    case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
  182.    case PIPE_CAP_MIN_TEXEL_OFFSET:
  183.       return -32;
  184.    case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
  185.    case PIPE_CAP_MAX_TEXEL_OFFSET:
  186.       return 31;
  187.    case PIPE_CAP_CONDITIONAL_RENDER:
  188.       return 1;
  189.    case PIPE_CAP_TEXTURE_BARRIER:
  190.       return 0;
  191.    case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
  192.    case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
  193.       return 16*4;
  194.    case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
  195.    case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
  196.       return 1024;
  197.    case PIPE_CAP_MAX_VERTEX_STREAMS:
  198.       return 1;
  199.    case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
  200.       return 2048;
  201.    case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
  202.       return 1;
  203.    case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
  204.       return 0;
  205.    case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
  206.    case PIPE_CAP_VERTEX_COLOR_CLAMPED:
  207.       return 1;
  208.    case PIPE_CAP_GLSL_FEATURE_LEVEL:
  209.       return 330;
  210.    case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
  211.       return 0;
  212.    case PIPE_CAP_COMPUTE:
  213.       return 0;
  214.    case PIPE_CAP_USER_VERTEX_BUFFERS:
  215.    case PIPE_CAP_USER_INDEX_BUFFERS:
  216.       return 1;
  217.    case PIPE_CAP_USER_CONSTANT_BUFFERS:
  218.       return 0;
  219.    case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
  220.    case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
  221.    case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
  222.    case PIPE_CAP_TGSI_TEXCOORD:
  223.       return 0;
  224.    case PIPE_CAP_DRAW_INDIRECT:
  225.       return 1;
  226.  
  227.    case PIPE_CAP_CUBE_MAP_ARRAY:
  228.       return 1;
  229.    case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
  230.       return 16;
  231.    case PIPE_CAP_TEXTURE_MULTISAMPLE:
  232.       return 0;
  233.    case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
  234.       return 64;
  235.    case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
  236.       return 1;
  237.    case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
  238.       return 65536;
  239.    case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
  240.       return 1;
  241.    case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
  242.       return 0;
  243.    case PIPE_CAP_MAX_VIEWPORTS:
  244.       return PIPE_MAX_VIEWPORTS;
  245.    case PIPE_CAP_ENDIANNESS:
  246.       return PIPE_ENDIAN_NATIVE;
  247.    case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
  248.       return 1;
  249.    case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
  250.       return 1;
  251.    case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
  252.       return 4;
  253.    case PIPE_CAP_TEXTURE_GATHER_SM5:
  254.    case PIPE_CAP_TEXTURE_QUERY_LOD:
  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.       return 0;
  262.    case PIPE_CAP_SAMPLER_VIEW_TARGET:
  263.       return 1;
  264.    case PIPE_CAP_FAKE_SW_MSAA:
  265.       return 1;
  266.    case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
  267.       return 1;
  268.  
  269.    case PIPE_CAP_VENDOR_ID:
  270.       return 0xFFFFFFFF;
  271.    case PIPE_CAP_DEVICE_ID:
  272.       return 0xFFFFFFFF;
  273.    case PIPE_CAP_ACCELERATED:
  274.       return 0;
  275.    case PIPE_CAP_VIDEO_MEMORY: {
  276.       /* XXX: Do we want to return the full amount fo system memory ? */
  277.       uint64_t system_memory;
  278.  
  279.       if (!os_get_total_physical_memory(&system_memory))
  280.          return 0;
  281.  
  282.       return (int)(system_memory >> 20);
  283.    }
  284.    case PIPE_CAP_UMA:
  285.       return 0;
  286.    case PIPE_CAP_CLIP_HALFZ:
  287.       return 1;
  288.    case PIPE_CAP_VERTEXID_NOBASE:
  289.       return 0;
  290.    case PIPE_CAP_POLYGON_OFFSET_CLAMP:
  291.       return 1;
  292.    case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
  293.    case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
  294.    case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
  295.       return 0;
  296.    }
  297.    /* should only get here on unhandled cases */
  298.    debug_printf("Unexpected PIPE_CAP %d query\n", param);
  299.    return 0;
  300. }
  301.  
  302. static int
  303. llvmpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param)
  304. {
  305.    switch(shader)
  306.    {
  307.    case PIPE_SHADER_FRAGMENT:
  308.       switch (param) {
  309.       default:
  310.          return gallivm_get_shader_param(param);
  311.       }
  312.    case PIPE_SHADER_VERTEX:
  313.    case PIPE_SHADER_GEOMETRY:
  314.       switch (param) {
  315.       case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
  316.          /* At this time, the draw module and llvmpipe driver only
  317.           * support vertex shader texture lookups when LLVM is enabled in
  318.           * the draw module.
  319.           */
  320.          if (debug_get_bool_option("DRAW_USE_LLVM", TRUE))
  321.             return PIPE_MAX_SAMPLERS;
  322.          else
  323.             return 0;
  324.       case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
  325.          if (debug_get_bool_option("DRAW_USE_LLVM", TRUE))
  326.             return PIPE_MAX_SHADER_SAMPLER_VIEWS;
  327.          else
  328.             return 0;
  329.       default:
  330.          return draw_get_shader_param(shader, param);
  331.       }
  332.    default:
  333.       return 0;
  334.    }
  335. }
  336.  
  337. static float
  338. llvmpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
  339. {
  340.    switch (param) {
  341.    case PIPE_CAPF_MAX_LINE_WIDTH:
  342.       /* fall-through */
  343.    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
  344.       return 255.0; /* arbitrary */
  345.    case PIPE_CAPF_MAX_POINT_WIDTH:
  346.       /* fall-through */
  347.    case PIPE_CAPF_MAX_POINT_WIDTH_AA:
  348.       return 255.0; /* arbitrary */
  349.    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
  350.       return 16.0; /* not actually signficant at this time */
  351.    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
  352.       return 16.0; /* arbitrary */
  353.    case PIPE_CAPF_GUARD_BAND_LEFT:
  354.    case PIPE_CAPF_GUARD_BAND_TOP:
  355.    case PIPE_CAPF_GUARD_BAND_RIGHT:
  356.    case PIPE_CAPF_GUARD_BAND_BOTTOM:
  357.       return 0.0;
  358.    }
  359.    /* should only get here on unhandled cases */
  360.    debug_printf("Unexpected PIPE_CAP %d query\n", param);
  361.    return 0.0;
  362. }
  363.  
  364.  
  365. /**
  366.  * Query format support for creating a texture, drawing surface, etc.
  367.  * \param format  the format to test
  368.  * \param type  one of PIPE_TEXTURE, PIPE_SURFACE
  369.  */
  370. static boolean
  371. llvmpipe_is_format_supported( struct pipe_screen *_screen,
  372.                               enum pipe_format format,
  373.                               enum pipe_texture_target target,
  374.                               unsigned sample_count,
  375.                               unsigned bind)
  376. {
  377.    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
  378.    struct sw_winsys *winsys = screen->winsys;
  379.    const struct util_format_description *format_desc;
  380.  
  381.    format_desc = util_format_description(format);
  382.    if (!format_desc)
  383.       return FALSE;
  384.  
  385.    assert(target == PIPE_BUFFER ||
  386.           target == PIPE_TEXTURE_1D ||
  387.           target == PIPE_TEXTURE_1D_ARRAY ||
  388.           target == PIPE_TEXTURE_2D ||
  389.           target == PIPE_TEXTURE_2D_ARRAY ||
  390.           target == PIPE_TEXTURE_RECT ||
  391.           target == PIPE_TEXTURE_3D ||
  392.           target == PIPE_TEXTURE_CUBE ||
  393.           target == PIPE_TEXTURE_CUBE_ARRAY);
  394.  
  395.    if (sample_count > 1)
  396.       return FALSE;
  397.  
  398.    if (bind & PIPE_BIND_RENDER_TARGET) {
  399.       if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
  400.          /* this is a lie actually other formats COULD exist where we would fail */
  401.          if (format_desc->nr_channels < 3)
  402.             return FALSE;
  403.       }
  404.       else if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB)
  405.          return FALSE;
  406.  
  407.       if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN &&
  408.           format != PIPE_FORMAT_R11G11B10_FLOAT)
  409.          return FALSE;
  410.  
  411.       assert(format_desc->block.width == 1);
  412.       assert(format_desc->block.height == 1);
  413.  
  414.       if (format_desc->is_mixed)
  415.          return FALSE;
  416.  
  417.       if (!format_desc->is_array && !format_desc->is_bitmask &&
  418.           format != PIPE_FORMAT_R11G11B10_FLOAT)
  419.          return FALSE;
  420.  
  421.       /*
  422.        * XXX refuse formats known to crash in generate_unswizzled_blend().
  423.        * These include all 3-channel 24bit RGB8 variants, plus 48bit
  424.        * (except those using floats) 3-channel RGB16 variants (the latter
  425.        * seems to be more of a llvm bug though).
  426.        * The mesa state tracker only seems to use these for SINT/UINT formats.
  427.        */
  428.       if (format_desc->is_array && format_desc->nr_channels == 3) {
  429.          if (format_desc->block.bits == 24 || (format_desc->block.bits == 48 &&
  430.                !util_format_is_float(format))) {
  431.             return FALSE;
  432.          }
  433.       }
  434.    }
  435.  
  436.    if (bind & PIPE_BIND_DISPLAY_TARGET) {
  437.       if(!winsys->is_displaytarget_format_supported(winsys, bind, format))
  438.          return FALSE;
  439.    }
  440.  
  441.    if (bind & PIPE_BIND_DEPTH_STENCIL) {
  442.       if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
  443.          return FALSE;
  444.  
  445.       if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
  446.          return FALSE;
  447.  
  448.       /* TODO: Support stencil-only formats */
  449.       if (format_desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_NONE) {
  450.          return FALSE;
  451.       }
  452.    }
  453.  
  454.    if (format_desc->layout == UTIL_FORMAT_LAYOUT_BPTC) {
  455.       /* Software decoding is not hooked up. */
  456.       return FALSE;
  457.    }
  458.  
  459.    if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC &&
  460.        format != PIPE_FORMAT_ETC1_RGB8)
  461.       return FALSE;
  462.  
  463.    if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC) {
  464.       return util_format_s3tc_enabled;
  465.    }
  466.  
  467.    /*
  468.     * Everything can be supported by u_format
  469.     * (those without fetch_rgba_float might be not but shouldn't hit that)
  470.     */
  471.  
  472.    return TRUE;
  473. }
  474.  
  475.  
  476.  
  477.  
  478. static void
  479. llvmpipe_flush_frontbuffer(struct pipe_screen *_screen,
  480.                            struct pipe_resource *resource,
  481.                            unsigned level, unsigned layer,
  482.                            void *context_private,
  483.                            struct pipe_box *sub_box)
  484. {
  485.    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
  486.    struct sw_winsys *winsys = screen->winsys;
  487.    struct llvmpipe_resource *texture = llvmpipe_resource(resource);
  488.  
  489.    assert(texture->dt);
  490.    if (texture->dt)
  491.       winsys->displaytarget_display(winsys, texture->dt, context_private, sub_box);
  492. }
  493.  
  494. static void
  495. llvmpipe_destroy_screen( struct pipe_screen *_screen )
  496. {
  497.    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
  498.    struct sw_winsys *winsys = screen->winsys;
  499.  
  500.    if (screen->rast)
  501.       lp_rast_destroy(screen->rast);
  502.  
  503.    lp_jit_screen_cleanup(screen);
  504.  
  505.    if(winsys->destroy)
  506.       winsys->destroy(winsys);
  507.  
  508.    pipe_mutex_destroy(screen->rast_mutex);
  509.  
  510.    FREE(screen);
  511. }
  512.  
  513.  
  514.  
  515.  
  516. /**
  517.  * Fence reference counting.
  518.  */
  519. static void
  520. llvmpipe_fence_reference(struct pipe_screen *screen,
  521.                          struct pipe_fence_handle **ptr,
  522.                          struct pipe_fence_handle *fence)
  523. {
  524.    struct lp_fence **old = (struct lp_fence **) ptr;
  525.    struct lp_fence *f = (struct lp_fence *) fence;
  526.  
  527.    lp_fence_reference(old, f);
  528. }
  529.  
  530.  
  531. /**
  532.  * Has the fence been executed/finished?
  533.  */
  534. static boolean
  535. llvmpipe_fence_signalled(struct pipe_screen *screen,
  536.                          struct pipe_fence_handle *fence)
  537. {
  538.    struct lp_fence *f = (struct lp_fence *) fence;
  539.    return lp_fence_signalled(f);
  540. }
  541.  
  542.  
  543. /**
  544.  * Wait for the fence to finish.
  545.  */
  546. static boolean
  547. llvmpipe_fence_finish(struct pipe_screen *screen,
  548.                       struct pipe_fence_handle *fence_handle,
  549.                       uint64_t timeout)
  550. {
  551.    struct lp_fence *f = (struct lp_fence *) fence_handle;
  552.  
  553.    lp_fence_wait(f);
  554.    return TRUE;
  555. }
  556.  
  557. static uint64_t
  558. llvmpipe_get_timestamp(struct pipe_screen *_screen)
  559. {
  560.    return os_time_get_nano();
  561. }
  562.  
  563. /**
  564.  * Create a new pipe_screen object
  565.  * Note: we're not presently subclassing pipe_screen (no llvmpipe_screen).
  566.  */
  567. struct pipe_screen *
  568. llvmpipe_create_screen(struct sw_winsys *winsys)
  569. {
  570.    struct llvmpipe_screen *screen;
  571.  
  572.    util_cpu_detect();
  573.  
  574. #ifdef DEBUG
  575.    LP_DEBUG = debug_get_flags_option("LP_DEBUG", lp_debug_flags, 0 );
  576. #endif
  577.  
  578.    LP_PERF = debug_get_flags_option("LP_PERF", lp_perf_flags, 0 );
  579.  
  580.    screen = CALLOC_STRUCT(llvmpipe_screen);
  581.    if (!screen)
  582.       return NULL;
  583.  
  584.    if (!lp_jit_screen_init(screen)) {
  585.       FREE(screen);
  586.       return NULL;
  587.    }
  588.  
  589.    screen->winsys = winsys;
  590.  
  591.    screen->base.destroy = llvmpipe_destroy_screen;
  592.  
  593.    screen->base.get_name = llvmpipe_get_name;
  594.    screen->base.get_vendor = llvmpipe_get_vendor;
  595.    screen->base.get_device_vendor = llvmpipe_get_vendor; // TODO should be the CPU vendor
  596.    screen->base.get_param = llvmpipe_get_param;
  597.    screen->base.get_shader_param = llvmpipe_get_shader_param;
  598.    screen->base.get_paramf = llvmpipe_get_paramf;
  599.    screen->base.is_format_supported = llvmpipe_is_format_supported;
  600.  
  601.    screen->base.context_create = llvmpipe_create_context;
  602.    screen->base.flush_frontbuffer = llvmpipe_flush_frontbuffer;
  603.    screen->base.fence_reference = llvmpipe_fence_reference;
  604.    screen->base.fence_signalled = llvmpipe_fence_signalled;
  605.    screen->base.fence_finish = llvmpipe_fence_finish;
  606.  
  607.    screen->base.get_timestamp = llvmpipe_get_timestamp;
  608.  
  609.    llvmpipe_init_screen_resource_funcs(&screen->base);
  610.  
  611.    screen->num_threads = util_cpu_caps.nr_cpus > 1 ? util_cpu_caps.nr_cpus : 0;
  612. #ifdef PIPE_SUBSYSTEM_EMBEDDED
  613.    screen->num_threads = 0;
  614. #endif
  615.    screen->num_threads = debug_get_num_option("LP_NUM_THREADS", screen->num_threads);
  616.    screen->num_threads = MIN2(screen->num_threads, LP_MAX_THREADS);
  617.  
  618.    screen->rast = lp_rast_create(screen->num_threads);
  619.    if (!screen->rast) {
  620.       lp_jit_screen_cleanup(screen);
  621.       FREE(screen);
  622.       return NULL;
  623.    }
  624.    pipe_mutex_init(screen->rast_mutex);
  625.  
  626.    util_format_s3tc_init();
  627.  
  628.    return &screen->base;
  629. }
  630.