gallium: add type parameter to create_fence_fd
[mesa.git] / src / gallium / auxiliary / util / u_tests.c
1 /**************************************************************************
2 *
3 * Copyright 2014 Advanced Micro Devices, 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 THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 "util/u_tests.h"
29
30 #include "util/u_draw_quad.h"
31 #include "util/u_format.h"
32 #include "util/u_inlines.h"
33 #include "util/u_memory.h"
34 #include "util/u_simple_shaders.h"
35 #include "util/u_surface.h"
36 #include "util/u_string.h"
37 #include "util/u_tile.h"
38 #include "tgsi/tgsi_strings.h"
39 #include "tgsi/tgsi_text.h"
40 #include "cso_cache/cso_context.h"
41 #include <stdio.h>
42
43 #define TOLERANCE 0.01
44
45 static struct pipe_resource *
46 util_create_texture2d(struct pipe_screen *screen, unsigned width,
47 unsigned height, enum pipe_format format)
48 {
49 struct pipe_resource templ = {{0}};
50
51 templ.target = PIPE_TEXTURE_2D;
52 templ.width0 = width;
53 templ.height0 = height;
54 templ.depth0 = 1;
55 templ.array_size = 1;
56 templ.format = format;
57 templ.usage = PIPE_USAGE_DEFAULT;
58 templ.bind = PIPE_BIND_SAMPLER_VIEW |
59 (util_format_is_depth_or_stencil(format) ?
60 PIPE_BIND_DEPTH_STENCIL : PIPE_BIND_RENDER_TARGET);
61
62 return screen->resource_create(screen, &templ);
63 }
64
65 static void
66 util_set_framebuffer_cb0(struct cso_context *cso, struct pipe_context *ctx,
67 struct pipe_resource *tex)
68 {
69 struct pipe_surface templ = {{0}}, *surf;
70 struct pipe_framebuffer_state fb = {0};
71
72 templ.format = tex->format;
73 surf = ctx->create_surface(ctx, tex, &templ);
74
75 fb.width = tex->width0;
76 fb.height = tex->height0;
77 fb.cbufs[0] = surf;
78 fb.nr_cbufs = 1;
79
80 cso_set_framebuffer(cso, &fb);
81 pipe_surface_reference(&surf, NULL);
82 }
83
84 static void
85 util_set_blend_normal(struct cso_context *cso)
86 {
87 struct pipe_blend_state blend = {0};
88
89 blend.rt[0].colormask = PIPE_MASK_RGBA;
90 cso_set_blend(cso, &blend);
91 }
92
93 static void
94 util_set_dsa_disable(struct cso_context *cso)
95 {
96 struct pipe_depth_stencil_alpha_state dsa = {{0}};
97
98 cso_set_depth_stencil_alpha(cso, &dsa);
99 }
100
101 static void
102 util_set_rasterizer_normal(struct cso_context *cso)
103 {
104 struct pipe_rasterizer_state rs = {0};
105
106 rs.half_pixel_center = 1;
107 rs.bottom_edge_rule = 1;
108 rs.depth_clip = 1;
109
110 cso_set_rasterizer(cso, &rs);
111 }
112
113 static void
114 util_set_max_viewport(struct cso_context *cso, struct pipe_resource *tex)
115 {
116 struct pipe_viewport_state viewport;
117
118 viewport.scale[0] = 0.5f * tex->width0;
119 viewport.scale[1] = 0.5f * tex->height0;
120 viewport.scale[2] = 1.0f;
121 viewport.translate[0] = 0.5f * tex->width0;
122 viewport.translate[1] = 0.5f * tex->height0;
123 viewport.translate[2] = 0.0f;
124
125 cso_set_viewport(cso, &viewport);
126 }
127
128 static void
129 util_set_interleaved_vertex_elements(struct cso_context *cso,
130 unsigned num_elements)
131 {
132 unsigned i;
133 struct pipe_vertex_element *velem =
134 calloc(1, num_elements * sizeof(struct pipe_vertex_element));
135
136 for (i = 0; i < num_elements; i++) {
137 velem[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
138 velem[i].src_offset = i * 16;
139 }
140
141 cso_set_vertex_elements(cso, num_elements, velem);
142 free(velem);
143 }
144
145 static void *
146 util_set_passthrough_vertex_shader(struct cso_context *cso,
147 struct pipe_context *ctx,
148 bool window_space)
149 {
150 static const uint vs_attribs[] = {
151 TGSI_SEMANTIC_POSITION,
152 TGSI_SEMANTIC_GENERIC
153 };
154 static const uint vs_indices[] = {0, 0};
155 void *vs;
156
157 vs = util_make_vertex_passthrough_shader(ctx, 2, vs_attribs, vs_indices,
158 window_space);
159 cso_set_vertex_shader_handle(cso, vs);
160 return vs;
161 }
162
163 static void
164 util_set_common_states_and_clear(struct cso_context *cso, struct pipe_context *ctx,
165 struct pipe_resource *cb)
166 {
167 static const float clear_color[] = {0.1, 0.1, 0.1, 0.1};
168
169 util_set_framebuffer_cb0(cso, ctx, cb);
170 util_set_blend_normal(cso);
171 util_set_dsa_disable(cso);
172 util_set_rasterizer_normal(cso);
173 util_set_max_viewport(cso, cb);
174
175 ctx->clear(ctx, PIPE_CLEAR_COLOR0, (void*)clear_color, 0, 0);
176 }
177
178 static void
179 util_draw_fullscreen_quad(struct cso_context *cso)
180 {
181 static float vertices[] = {
182 -1, -1, 0, 1, 0, 0, 0, 0,
183 -1, 1, 0, 1, 0, 1, 0, 0,
184 1, 1, 0, 1, 1, 1, 0, 0,
185 1, -1, 0, 1, 1, 0, 0, 0
186 };
187 util_set_interleaved_vertex_elements(cso, 2);
188 util_draw_user_vertex_buffer(cso, vertices, PIPE_PRIM_QUADS, 4, 2);
189 }
190
191 /**
192 * Probe and test if the rectangle contains the expected color.
193 *
194 * If "num_expected_colors" > 1, at least one expected color must match
195 * the probed color. "expected" should be an array of 4*num_expected_colors
196 * floats.
197 */
198 static bool
199 util_probe_rect_rgba_multi(struct pipe_context *ctx, struct pipe_resource *tex,
200 unsigned offx, unsigned offy, unsigned w,
201 unsigned h,
202 const float *expected,
203 unsigned num_expected_colors)
204 {
205 struct pipe_transfer *transfer;
206 void *map;
207 float *pixels = malloc(w * h * 4 * sizeof(float));
208 unsigned x,y,e,c;
209 bool pass = true;
210
211 map = pipe_transfer_map(ctx, tex, 0, 0, PIPE_TRANSFER_READ,
212 offx, offy, w, h, &transfer);
213 pipe_get_tile_rgba(transfer, map, 0, 0, w, h, pixels);
214 pipe_transfer_unmap(ctx, transfer);
215
216 for (e = 0; e < num_expected_colors; e++) {
217 for (y = 0; y < h; y++) {
218 for (x = 0; x < w; x++) {
219 float *probe = &pixels[(y*w + x)*4];
220
221 for (c = 0; c < 4; c++) {
222 if (fabs(probe[c] - expected[e*4+c]) >= TOLERANCE) {
223 if (e < num_expected_colors-1)
224 goto next_color; /* test the next expected color */
225
226 printf("Probe color at (%i,%i), ", offx+x, offy+y);
227 printf("Expected: %.3f, %.3f, %.3f, %.3f, ",
228 expected[e*4], expected[e*4+1],
229 expected[e*4+2], expected[e*4+3]);
230 printf("Got: %.3f, %.3f, %.3f, %.3f\n",
231 probe[0], probe[1], probe[2], probe[3]);
232 pass = false;
233 goto done;
234 }
235 }
236 }
237 }
238 break; /* this color was successful */
239
240 next_color:;
241 }
242 done:
243
244 free(pixels);
245 return pass;
246 }
247
248 static bool
249 util_probe_rect_rgba(struct pipe_context *ctx, struct pipe_resource *tex,
250 unsigned offx, unsigned offy, unsigned w, unsigned h,
251 const float *expected)
252 {
253 return util_probe_rect_rgba_multi(ctx, tex, offx, offy, w, h, expected, 1);
254 }
255
256 enum {
257 SKIP = -1,
258 FAIL = 0, /* also "false" */
259 PASS = 1 /* also "true" */
260 };
261
262 static void
263 util_report_result_helper(int status, const char *name, ...)
264 {
265 char buf[256];
266 va_list ap;
267
268 va_start(ap, name);
269 util_vsnprintf(buf, sizeof(buf), name, ap);
270 va_end(ap);
271
272 printf("Test(%s) = %s\n", buf,
273 status == SKIP ? "skip" :
274 status == PASS ? "pass" : "fail");
275 }
276
277 #define util_report_result(status) util_report_result_helper(status, __func__)
278
279 /**
280 * Test TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION.
281 *
282 * The viewport state is set as usual, but it should have no effect.
283 * Clipping should also be disabled.
284 *
285 * POSITION.xyz should already be multiplied by 1/w and POSITION.w should
286 * contain 1/w. By setting w=0, we can test that POSITION.xyz isn't
287 * multiplied by 1/w (otherwise nothing would be rendered).
288 *
289 * TODO: Whether the value of POSITION.w is correctly interpreted as 1/w
290 * during perspective interpolation is not tested.
291 */
292 static void
293 tgsi_vs_window_space_position(struct pipe_context *ctx)
294 {
295 struct cso_context *cso;
296 struct pipe_resource *cb;
297 void *fs, *vs;
298 bool pass = true;
299 static const float red[] = {1, 0, 0, 1};
300
301 if (!ctx->screen->get_param(ctx->screen,
302 PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION)) {
303 util_report_result(SKIP);
304 return;
305 }
306
307 cso = cso_create_context(ctx, 0);
308 cb = util_create_texture2d(ctx->screen, 256, 256,
309 PIPE_FORMAT_R8G8B8A8_UNORM);
310 util_set_common_states_and_clear(cso, ctx, cb);
311
312 /* Fragment shader. */
313 fs = util_make_fragment_passthrough_shader(ctx, TGSI_SEMANTIC_GENERIC,
314 TGSI_INTERPOLATE_LINEAR, TRUE);
315 cso_set_fragment_shader_handle(cso, fs);
316
317 /* Vertex shader. */
318 vs = util_set_passthrough_vertex_shader(cso, ctx, true);
319
320 /* Draw. */
321 {
322 static float vertices[] = {
323 0, 0, 0, 0, 1, 0, 0, 1,
324 0, 256, 0, 0, 1, 0, 0, 1,
325 256, 256, 0, 0, 1, 0, 0, 1,
326 256, 0, 0, 0, 1, 0, 0, 1,
327 };
328 util_set_interleaved_vertex_elements(cso, 2);
329 util_draw_user_vertex_buffer(cso, vertices, PIPE_PRIM_QUADS, 4, 2);
330 }
331
332 /* Probe pixels. */
333 pass = pass && util_probe_rect_rgba(ctx, cb, 0, 0,
334 cb->width0, cb->height0, red);
335
336 /* Cleanup. */
337 cso_destroy_context(cso);
338 ctx->delete_vs_state(ctx, vs);
339 ctx->delete_fs_state(ctx, fs);
340 pipe_resource_reference(&cb, NULL);
341
342 util_report_result(pass);
343 }
344
345 static void
346 null_sampler_view(struct pipe_context *ctx, unsigned tgsi_tex_target)
347 {
348 struct cso_context *cso;
349 struct pipe_resource *cb;
350 void *fs, *vs;
351 bool pass = true;
352 /* 2 expected colors: */
353 static const float expected_tex[] = {0, 0, 0, 1,
354 0, 0, 0, 0};
355 static const float expected_buf[] = {0, 0, 0, 0};
356 const float *expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ?
357 expected_buf : expected_tex;
358 unsigned num_expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ? 1 : 2;
359
360 if (tgsi_tex_target == TGSI_TEXTURE_BUFFER &&
361 !ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) {
362 util_report_result_helper(SKIP, "%s: %s", __func__,
363 tgsi_texture_names[tgsi_tex_target]);
364 return;
365 }
366
367 cso = cso_create_context(ctx, 0);
368 cb = util_create_texture2d(ctx->screen, 256, 256,
369 PIPE_FORMAT_R8G8B8A8_UNORM);
370 util_set_common_states_and_clear(cso, ctx, cb);
371
372 ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 1, NULL);
373
374 /* Fragment shader. */
375 fs = util_make_fragment_tex_shader(ctx, tgsi_tex_target,
376 TGSI_INTERPOLATE_LINEAR,
377 TGSI_RETURN_TYPE_FLOAT,
378 TGSI_RETURN_TYPE_FLOAT, false, false);
379 cso_set_fragment_shader_handle(cso, fs);
380
381 /* Vertex shader. */
382 vs = util_set_passthrough_vertex_shader(cso, ctx, false);
383 util_draw_fullscreen_quad(cso);
384
385 /* Probe pixels. */
386 pass = pass && util_probe_rect_rgba_multi(ctx, cb, 0, 0,
387 cb->width0, cb->height0, expected,
388 num_expected);
389
390 /* Cleanup. */
391 cso_destroy_context(cso);
392 ctx->delete_vs_state(ctx, vs);
393 ctx->delete_fs_state(ctx, fs);
394 pipe_resource_reference(&cb, NULL);
395
396 util_report_result_helper(pass, "%s: %s", __func__,
397 tgsi_texture_names[tgsi_tex_target]);
398 }
399
400 void
401 util_test_constant_buffer(struct pipe_context *ctx,
402 struct pipe_resource *constbuf)
403 {
404 struct cso_context *cso;
405 struct pipe_resource *cb;
406 void *fs, *vs;
407 bool pass = true;
408 static const float zero[] = {0, 0, 0, 0};
409
410 cso = cso_create_context(ctx, 0);
411 cb = util_create_texture2d(ctx->screen, 256, 256,
412 PIPE_FORMAT_R8G8B8A8_UNORM);
413 util_set_common_states_and_clear(cso, ctx, cb);
414
415 pipe_set_constant_buffer(ctx, PIPE_SHADER_FRAGMENT, 0, constbuf);
416
417 /* Fragment shader. */
418 {
419 static const char *text = /* I don't like ureg... */
420 "FRAG\n"
421 "DCL CONST[0][0]\n"
422 "DCL OUT[0], COLOR\n"
423
424 "MOV OUT[0], CONST[0][0]\n"
425 "END\n";
426 struct tgsi_token tokens[1000];
427 struct pipe_shader_state state;
428
429 if (!tgsi_text_translate(text, tokens, ARRAY_SIZE(tokens))) {
430 puts("Can't compile a fragment shader.");
431 util_report_result(FAIL);
432 return;
433 }
434 pipe_shader_state_from_tgsi(&state, tokens);
435 fs = ctx->create_fs_state(ctx, &state);
436 cso_set_fragment_shader_handle(cso, fs);
437 }
438
439 /* Vertex shader. */
440 vs = util_set_passthrough_vertex_shader(cso, ctx, false);
441 util_draw_fullscreen_quad(cso);
442
443 /* Probe pixels. */
444 pass = pass && util_probe_rect_rgba(ctx, cb, 0, 0, cb->width0,
445 cb->height0, zero);
446
447 /* Cleanup. */
448 cso_destroy_context(cso);
449 ctx->delete_vs_state(ctx, vs);
450 ctx->delete_fs_state(ctx, fs);
451 pipe_resource_reference(&cb, NULL);
452
453 util_report_result(pass);
454 }
455
456 static void
457 null_fragment_shader(struct pipe_context *ctx)
458 {
459 struct cso_context *cso;
460 struct pipe_resource *cb;
461 void *vs;
462 struct pipe_rasterizer_state rs = {0};
463 struct pipe_query *query;
464 union pipe_query_result qresult;
465
466 cso = cso_create_context(ctx, 0);
467 cb = util_create_texture2d(ctx->screen, 256, 256,
468 PIPE_FORMAT_R8G8B8A8_UNORM);
469 util_set_common_states_and_clear(cso, ctx, cb);
470
471 /* No rasterization. */
472 rs.rasterizer_discard = 1;
473 cso_set_rasterizer(cso, &rs);
474
475 vs = util_set_passthrough_vertex_shader(cso, ctx, false);
476
477 query = ctx->create_query(ctx, PIPE_QUERY_PRIMITIVES_GENERATED, 0);
478 ctx->begin_query(ctx, query);
479 util_draw_fullscreen_quad(cso);
480 ctx->end_query(ctx, query);
481 ctx->get_query_result(ctx, query, true, &qresult);
482
483 /* Cleanup. */
484 cso_destroy_context(cso);
485 ctx->delete_vs_state(ctx, vs);
486 ctx->destroy_query(ctx, query);
487 pipe_resource_reference(&cb, NULL);
488
489 /* Check PRIMITIVES_GENERATED. */
490 util_report_result(qresult.u64 == 2);
491 }
492
493 #if defined(PIPE_OS_LINUX) && defined(HAVE_LIBDRM)
494 #include <libsync.h>
495 #else
496 #define sync_merge(str, fd1, fd2) (-1)
497 #define sync_wait(fd, timeout) (-1)
498 #endif
499
500 static void
501 test_sync_file_fences(struct pipe_context *ctx)
502 {
503 struct pipe_screen *screen = ctx->screen;
504 bool pass = true;
505 enum pipe_fd_type fd_type = PIPE_FD_TYPE_NATIVE_SYNC;
506
507 if (!screen->get_param(screen, PIPE_CAP_NATIVE_FENCE_FD))
508 return;
509
510 struct cso_context *cso = cso_create_context(ctx, 0);
511 struct pipe_resource *buf =
512 pipe_buffer_create(screen, 0, PIPE_USAGE_DEFAULT, 1024 * 1024);
513 struct pipe_resource *tex =
514 util_create_texture2d(screen, 4096, 1024, PIPE_FORMAT_R8_UNORM);
515 struct pipe_fence_handle *buf_fence = NULL, *tex_fence = NULL;
516
517 /* Run 2 clears, get fencess. */
518 uint32_t value = 0;
519 ctx->clear_buffer(ctx, buf, 0, buf->width0, &value, sizeof(value));
520 ctx->flush(ctx, &buf_fence, PIPE_FLUSH_FENCE_FD);
521
522 struct pipe_box box;
523 u_box_2d(0, 0, tex->width0, tex->height0, &box);
524 ctx->clear_texture(ctx, tex, 0, &box, &value);
525 ctx->flush(ctx, &tex_fence, PIPE_FLUSH_FENCE_FD);
526 pass = pass && buf_fence && tex_fence;
527
528 /* Export fences. */
529 int buf_fd = screen->fence_get_fd(screen, buf_fence);
530 int tex_fd = screen->fence_get_fd(screen, tex_fence);
531 pass = pass && buf_fd >= 0 && tex_fd >= 0;
532
533 /* Merge fences. */
534 int merged_fd = sync_merge("test", buf_fd, tex_fd);
535 pass = pass && merged_fd >= 0;
536
537 /* (Re)import all fences. */
538 struct pipe_fence_handle *re_buf_fence = NULL, *re_tex_fence = NULL;
539 struct pipe_fence_handle *merged_fence = NULL;
540 ctx->create_fence_fd(ctx, &re_buf_fence, buf_fd, fd_type);
541 ctx->create_fence_fd(ctx, &re_tex_fence, tex_fd, fd_type);
542 ctx->create_fence_fd(ctx, &merged_fence, merged_fd, fd_type);
543 pass = pass && re_buf_fence && re_tex_fence && merged_fence;
544
545 /* Run another clear after waiting for everything. */
546 struct pipe_fence_handle *final_fence = NULL;
547 ctx->fence_server_sync(ctx, merged_fence);
548 value = 0xff;
549 ctx->clear_buffer(ctx, buf, 0, buf->width0, &value, sizeof(value));
550 ctx->flush(ctx, &final_fence, PIPE_FLUSH_FENCE_FD);
551 pass = pass && final_fence;
552
553 /* Wait for the last fence. */
554 int final_fd = screen->fence_get_fd(screen, final_fence);
555 pass = pass && final_fd >= 0;
556 pass = pass && sync_wait(final_fd, -1) == 0;
557
558 /* Check that all fences are signalled. */
559 pass = pass && sync_wait(buf_fd, 0) == 0;
560 pass = pass && sync_wait(tex_fd, 0) == 0;
561 pass = pass && sync_wait(merged_fd, 0) == 0;
562
563 pass = pass && screen->fence_finish(screen, NULL, buf_fence, 0);
564 pass = pass && screen->fence_finish(screen, NULL, tex_fence, 0);
565 pass = pass && screen->fence_finish(screen, NULL, re_buf_fence, 0);
566 pass = pass && screen->fence_finish(screen, NULL, re_tex_fence, 0);
567 pass = pass && screen->fence_finish(screen, NULL, merged_fence, 0);
568 pass = pass && screen->fence_finish(screen, NULL, final_fence, 0);
569
570 /* Cleanup. */
571 #ifndef PIPE_OS_WINDOWS
572 if (buf_fd >= 0)
573 close(buf_fd);
574 if (tex_fd >= 0)
575 close(tex_fd);
576 if (merged_fd >= 0)
577 close(merged_fd);
578 if (final_fd >= 0)
579 close(final_fd);
580 #endif
581
582 screen->fence_reference(screen, &buf_fence, NULL);
583 screen->fence_reference(screen, &tex_fence, NULL);
584 screen->fence_reference(screen, &re_buf_fence, NULL);
585 screen->fence_reference(screen, &re_tex_fence, NULL);
586 screen->fence_reference(screen, &merged_fence, NULL);
587 screen->fence_reference(screen, &final_fence, NULL);
588
589 cso_destroy_context(cso);
590 pipe_resource_reference(&buf, NULL);
591 pipe_resource_reference(&tex, NULL);
592
593 util_report_result(pass);
594 }
595
596 static void
597 test_texture_barrier(struct pipe_context *ctx, bool use_fbfetch)
598 {
599 struct cso_context *cso;
600 struct pipe_resource *cb;
601 void *fs, *vs;
602 struct pipe_sampler_view *view = NULL;
603 const char *text;
604
605 if (!ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BARRIER)) {
606 util_report_result_helper(SKIP, "%s: %s", __func__,
607 use_fbfetch ? "FBFETCH" : "sampler");
608 return;
609 }
610 if (use_fbfetch &&
611 !ctx->screen->get_param(ctx->screen, PIPE_CAP_TGSI_FS_FBFETCH)) {
612 util_report_result_helper(SKIP, "%s: %s", __func__,
613 use_fbfetch ? "FBFETCH" : "sampler");
614 return;
615 }
616
617 cso = cso_create_context(ctx, 0);
618 cb = util_create_texture2d(ctx->screen, 256, 256,
619 PIPE_FORMAT_R8G8B8A8_UNORM);
620 util_set_common_states_and_clear(cso, ctx, cb);
621
622 if (use_fbfetch) {
623 /* Fragment shader. */
624 text = "FRAG\n"
625 "DCL OUT[0], COLOR[0]\n"
626 "DCL TEMP[0]\n"
627 "IMM[0] FLT32 { 0.1, 0.2, 0.3, 0.4}\n"
628
629 "FBFETCH TEMP[0], OUT[0]\n"
630 "ADD OUT[0], TEMP[0], IMM[0]\n"
631 "END\n";
632 } else {
633 struct pipe_sampler_view templ = {{0}};
634 templ.format = cb->format;
635 templ.target = cb->target;
636 templ.swizzle_r = PIPE_SWIZZLE_X;
637 templ.swizzle_g = PIPE_SWIZZLE_Y;
638 templ.swizzle_b = PIPE_SWIZZLE_Z;
639 templ.swizzle_a = PIPE_SWIZZLE_W;
640 view = ctx->create_sampler_view(ctx, cb, &templ);
641 ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 1, &view);
642
643 /* Fragment shader. */
644 text = "FRAG\n"
645 "DCL SV[0], POSITION\n"
646 "DCL SAMP[0]\n"
647 "DCL SVIEW[0], 2D, FLOAT\n"
648 "DCL OUT[0], COLOR[0]\n"
649 "DCL TEMP[0]\n"
650 "IMM[0] FLT32 { 0.1, 0.2, 0.3, 0.4}\n"
651 "IMM[1] INT32 { 0, 0, 0, 0}\n"
652
653 "F2I TEMP[0].xy, SV[0].xyyy\n"
654 "MOV TEMP[0].z, IMM[1].xxxx\n"
655 "TXF TEMP[0], TEMP[0].xyzz, SAMP[0], 2D\n"
656 "ADD OUT[0], TEMP[0], IMM[0]\n"
657 "END\n";
658 }
659
660 struct tgsi_token tokens[1000];
661 struct pipe_shader_state state;
662
663 if (!tgsi_text_translate(text, tokens, ARRAY_SIZE(tokens))) {
664 assert(0);
665 util_report_result_helper(FAIL, "%s: %s", __func__,
666 use_fbfetch ? "FBFETCH" : "sampler");
667 return;
668 }
669 pipe_shader_state_from_tgsi(&state, tokens);
670 #if 0
671 tgsi_dump(state.tokens, 0);
672 #endif
673
674 fs = ctx->create_fs_state(ctx, &state);
675 cso_set_fragment_shader_handle(cso, fs);
676
677 /* Vertex shader. */
678 vs = util_set_passthrough_vertex_shader(cso, ctx, false);
679
680 for (int i = 0; i < 2; i++) {
681 ctx->texture_barrier(ctx,
682 use_fbfetch ? PIPE_TEXTURE_BARRIER_FRAMEBUFFER :
683 PIPE_TEXTURE_BARRIER_SAMPLER);
684 util_draw_fullscreen_quad(cso);
685 }
686
687 /* Probe pixels. */
688 static const float expected[] = {0.3, 0.5, 0.7, 0.9};
689 bool pass = util_probe_rect_rgba(ctx, cb, 0, 0,
690 cb->width0, cb->height0, expected);
691
692 /* Cleanup. */
693 cso_destroy_context(cso);
694 ctx->delete_vs_state(ctx, vs);
695 ctx->delete_fs_state(ctx, fs);
696 pipe_sampler_view_reference(&view, NULL);
697 pipe_resource_reference(&cb, NULL);
698
699 util_report_result_helper(pass, "%s: %s", __func__,
700 use_fbfetch ? "FBFETCH" : "sampler");
701 }
702
703 /**
704 * Run all tests. This should be run with a clean context after
705 * context_create.
706 */
707 void
708 util_run_tests(struct pipe_screen *screen)
709 {
710 struct pipe_context *ctx = screen->context_create(screen, NULL, 0);
711
712 null_fragment_shader(ctx);
713 tgsi_vs_window_space_position(ctx);
714 null_sampler_view(ctx, TGSI_TEXTURE_2D);
715 null_sampler_view(ctx, TGSI_TEXTURE_BUFFER);
716 util_test_constant_buffer(ctx, NULL);
717 test_sync_file_fences(ctx);
718 test_texture_barrier(ctx, false);
719 test_texture_barrier(ctx, true);
720
721 ctx->destroy(ctx);
722
723 puts("Done. Exiting..");
724 exit(0);
725 }