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
util_check_caps_out(struct pipe_screen * screen,const unsigned * list,int * out)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
util_check_caps(struct pipe_screen * screen,const unsigned * list)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  */
util_caps_demo_print(struct pipe_screen * screen)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