Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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