Home | History | Annotate | Download | only in util
      1 /**************************************************************************
      2  *
      3  * Copyright 2010 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 #include "pipe/p_screen.h"
     29 #include "util/u_format.h"
     30 #include "util/u_debug.h"
     31 #include "u_caps.h"
     32 
     33 /**
     34  * Iterates over a list of caps checks as defined in u_caps.h. Should
     35  * all checks pass returns TRUE and out is set to the last element of
     36  * the list (TERMINATE). Should any check fail returns FALSE and set
     37  * out to the index of the start of the first failing check.
     38  */
     39 boolean
     40 util_check_caps_out(struct pipe_screen *screen, const unsigned *list, int *out)
     41 {
     42    int i, tmpi;
     43    float tmpf;
     44 
     45    for (i = 0; list[i];) {
     46       switch(list[i++]) {
     47       case UTIL_CAPS_CHECK_CAP:
     48          if (!screen->get_param(screen, list[i++])) {
     49             *out = i - 2;
     50             return FALSE;
     51          }
     52          break;
     53       case UTIL_CAPS_CHECK_INT:
     54          tmpi = screen->get_param(screen, list[i++]);
     55          if (tmpi < (int)list[i++]) {
     56             *out = i - 3;
     57             return FALSE;
     58          }
     59          break;
     60       case UTIL_CAPS_CHECK_FLOAT:
     61          tmpf = screen->get_paramf(screen, list[i++]);
     62          if (tmpf < (float)list[i++]) {
     63             *out = i - 3;
     64             return FALSE;
     65          }
     66          break;
     67       case UTIL_CAPS_CHECK_FORMAT:
     68          if (!screen->is_format_supported(screen,
     69                                           list[i++],
     70                                           PIPE_TEXTURE_2D,
     71                                           0,
     72                                           PIPE_BIND_SAMPLER_VIEW)) {
     73             *out = i - 2;
     74             return FALSE;
     75          }
     76          break;
     77       case UTIL_CAPS_CHECK_SHADER:
     78          tmpi = screen->get_shader_param(screen, list[i] >> 24, list[i] & ((1 << 24) - 1));
     79          ++i;
     80          if (tmpi < (int)list[i++]) {
     81             *out = i - 3;
     82             return FALSE;
     83          }
     84          break;
     85       case UTIL_CAPS_CHECK_UNIMPLEMENTED:
     86          *out = i - 1;
     87          return FALSE;
     88       default:
     89          assert(!"Unsupported check");
     90          return FALSE;
     91       }
     92    }
     93 
     94    *out = i;
     95    return TRUE;
     96 }
     97 
     98 /**
     99  * Iterates over a list of caps checks as defined in u_caps.h.
    100  * Returns TRUE if all caps checks pass returns FALSE otherwise.
    101  */
    102 boolean
    103 util_check_caps(struct pipe_screen *screen, const unsigned *list)
    104 {
    105    int out;
    106    return util_check_caps_out(screen, list, &out);
    107 }
    108 
    109 
    110 /*
    111  * Below follows some demo lists.
    112  *
    113  * None of these lists are exhausting lists of what is
    114  * actually needed to support said API and more here for
    115  * as example on how to uses the above functions. Especially
    116  * for DX10 and DX11 where Gallium is missing features.
    117  */
    118 
    119 /* DX 9_1 */
    120 static unsigned caps_dx_9_1[] = {
    121    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 1),
    122    UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 12),    /* 2048 */
    123    UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
    124    UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
    125    UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 2),
    126    UTIL_CHECK_TERMINATE
    127 };
    128 
    129 /* DX 9_2 */
    130 static unsigned caps_dx_9_2[] = {
    131    UTIL_CHECK_CAP(OCCLUSION_QUERY),
    132    UTIL_CHECK_CAP(BLEND_EQUATION_SEPARATE),
    133    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 1),
    134    UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 12),    /* 2048 */
    135    UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
    136    UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
    137    UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
    138    UTIL_CHECK_TERMINATE
    139 };
    140 
    141 /* DX 9_3 */
    142 static unsigned caps_dx_9_3[] = {
    143    UTIL_CHECK_CAP(SM3),
    144  //UTIL_CHECK_CAP(INSTANCING),
    145    UTIL_CHECK_CAP(OCCLUSION_QUERY),
    146    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 4),
    147    UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 13),    /* 4096 */
    148    UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
    149    UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
    150    UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
    151    UTIL_CHECK_TERMINATE
    152 };
    153 
    154 /* DX 10 */
    155 static unsigned caps_dx_10[] = {
    156    UTIL_CHECK_CAP(SM3),
    157  //UTIL_CHECK_CAP(INSTANCING),
    158    UTIL_CHECK_CAP(OCCLUSION_QUERY),
    159    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8),
    160    UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 14),    /* 8192 */
    161    UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 12),    /* 2048 */
    162    UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 14),  /* 8192 */
    163    UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
    164    UTIL_CHECK_UNIMPLEMENTED, /* XXX Unimplemented features in Gallium */
    165    UTIL_CHECK_TERMINATE
    166 };
    167 
    168 /* DX11 */
    169 static unsigned caps_dx_11[] = {
    170    UTIL_CHECK_CAP(SM3),
    171  //UTIL_CHECK_CAP(INSTANCING),
    172    UTIL_CHECK_CAP(OCCLUSION_QUERY),
    173    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8),
    174    UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 14),    /* 16384 */
    175    UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 12),    /* 2048 */
    176    UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 14),  /* 16384 */
    177    UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
    178    UTIL_CHECK_FORMAT(B8G8R8A8_UNORM),
    179    UTIL_CHECK_UNIMPLEMENTED, /* XXX Unimplemented features in Gallium */
    180    UTIL_CHECK_TERMINATE
    181 };
    182 
    183 /* OpenGL 2.1 */
    184 static unsigned caps_opengl_2_1[] = {
    185    UTIL_CHECK_CAP(OCCLUSION_QUERY),
    186    UTIL_CHECK_CAP(TWO_SIDED_STENCIL),
    187    UTIL_CHECK_CAP(BLEND_EQUATION_SEPARATE),
    188    UTIL_CHECK_INT(MAX_RENDER_TARGETS, 2),
    189    UTIL_CHECK_TERMINATE
    190 };
    191 
    192 /* OpenGL 3.0 */
    193 /* UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8), */
    194 
    195 /* Shader Model 3 */
    196 static unsigned caps_sm3[] = {
    197     UTIL_CHECK_SHADER(FRAGMENT, MAX_INSTRUCTIONS, 512),
    198     UTIL_CHECK_SHADER(FRAGMENT, MAX_INPUTS, 10),
    199     UTIL_CHECK_SHADER(FRAGMENT, MAX_TEMPS, 32),
    200     UTIL_CHECK_SHADER(FRAGMENT, MAX_ADDRS, 1),
    201     UTIL_CHECK_SHADER(FRAGMENT, MAX_CONSTS, 224),
    202 
    203     UTIL_CHECK_SHADER(VERTEX, MAX_INSTRUCTIONS, 512),
    204     UTIL_CHECK_SHADER(VERTEX, MAX_INPUTS, 16),
    205     UTIL_CHECK_SHADER(VERTEX, MAX_TEMPS, 32),
    206     UTIL_CHECK_SHADER(VERTEX, MAX_ADDRS, 2),
    207     UTIL_CHECK_SHADER(VERTEX, MAX_CONSTS, 256),
    208 
    209     UTIL_CHECK_TERMINATE
    210 };
    211 
    212 /**
    213  * Demo function which checks against theoretical caps needed for different APIs.
    214  */
    215 void util_caps_demo_print(struct pipe_screen *screen)
    216 {
    217    struct {
    218       char* name;
    219       unsigned *list;
    220    } list[] = {
    221       {"DX 9.1", caps_dx_9_1},
    222       {"DX 9.2", caps_dx_9_2},
    223       {"DX 9.3", caps_dx_9_3},
    224       {"DX 10", caps_dx_10},
    225       {"DX 11", caps_dx_11},
    226       {"OpenGL 2.1", caps_opengl_2_1},
    227 /*    {"OpenGL 3.0", caps_opengl_3_0},*/
    228       {"SM3", caps_sm3},
    229       {NULL, NULL}
    230    };
    231    int i, out = 0;
    232 
    233    for (i = 0; list[i].name; i++) {
    234       if (util_check_caps_out(screen, list[i].list, &out)) {
    235          debug_printf("%s: %s yes\n", __FUNCTION__, list[i].name);
    236          continue;
    237       }
    238       switch (list[i].list[out]) {
    239       case UTIL_CAPS_CHECK_CAP:
    240          debug_printf("%s: %s no (cap %u not supported)\n", __FUNCTION__,
    241                       list[i].name,
    242                       list[i].list[out + 1]);
    243          break;
    244       case UTIL_CAPS_CHECK_INT:
    245          debug_printf("%s: %s no (cap %u less then %u)\n", __FUNCTION__,
    246                       list[i].name,
    247                       list[i].list[out + 1],
    248                       list[i].list[out + 2]);
    249          break;
    250       case UTIL_CAPS_CHECK_FLOAT:
    251          debug_printf("%s: %s no (cap %u less then %f)\n", __FUNCTION__,
    252                       list[i].name,
    253                       list[i].list[out + 1],
    254                       (double)(int)list[i].list[out + 2]);
    255          break;
    256       case UTIL_CAPS_CHECK_FORMAT:
    257          debug_printf("%s: %s no (format %s not supported)\n", __FUNCTION__,
    258                       list[i].name,
    259                       util_format_name(list[i].list[out + 1]) + 12);
    260          break;
    261       case UTIL_CAPS_CHECK_UNIMPLEMENTED:
    262          debug_printf("%s: %s no (not implemented in gallium or state tracker)\n",
    263                       __FUNCTION__, list[i].name);
    264          break;
    265       default:
    266             assert(!"Unsupported check");
    267       }
    268    }
    269 }
    270