/**************************************************************************
|
*
|
* Copyright 2014 Advanced Micro Devices, Inc.
|
* All Rights Reserved.
|
*
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
* copy of this software and associated documentation files (the
|
* "Software"), to deal in the Software without restriction, including
|
* without limitation the rights to use, copy, modify, merge, publish,
|
* distribute, sub license, and/or sell copies of the Software, and to
|
* permit persons to whom the Software is furnished to do so, subject to
|
* the following conditions:
|
*
|
* The above copyright notice and this permission notice (including the
|
* next paragraph) shall be included in all copies or substantial portions
|
* of the Software.
|
*
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
*
|
**************************************************************************/
|
|
#include "util/u_tests.h"
|
|
#include "util/u_draw_quad.h"
|
#include "util/u_format.h"
|
#include "util/u_inlines.h"
|
#include "util/u_memory.h"
|
#include "util/u_simple_shaders.h"
|
#include "util/u_surface.h"
|
#include "util/u_string.h"
|
#include "util/u_tile.h"
|
#include "tgsi/tgsi_strings.h"
|
#include "tgsi/tgsi_text.h"
|
#include "cso_cache/cso_context.h"
|
#include <stdio.h>
|
|
#define TOLERANCE 0.01
|
|
static struct pipe_resource *
|
util_create_texture2d(struct pipe_screen *screen, unsigned width,
|
unsigned height, enum pipe_format format)
|
{
|
struct pipe_resource templ = {{0}};
|
|
templ.target = PIPE_TEXTURE_2D;
|
templ.width0 = width;
|
templ.height0 = height;
|
templ.depth0 = 1;
|
templ.array_size = 1;
|
templ.format = format;
|
templ.usage = PIPE_USAGE_DEFAULT;
|
templ.bind = PIPE_BIND_SAMPLER_VIEW |
|
(util_format_is_depth_or_stencil(format) ?
|
PIPE_BIND_DEPTH_STENCIL : PIPE_BIND_RENDER_TARGET);
|
|
return screen->resource_create(screen, &templ);
|
}
|
|
static void
|
util_set_framebuffer_cb0(struct cso_context *cso, struct pipe_context *ctx,
|
struct pipe_resource *tex)
|
{
|
struct pipe_surface templ = {{0}}, *surf;
|
struct pipe_framebuffer_state fb = {0};
|
|
templ.format = tex->format;
|
surf = ctx->create_surface(ctx, tex, &templ);
|
|
fb.width = tex->width0;
|
fb.height = tex->height0;
|
fb.cbufs[0] = surf;
|
fb.nr_cbufs = 1;
|
|
cso_set_framebuffer(cso, &fb);
|
pipe_surface_reference(&surf, NULL);
|
}
|
|
static void
|
util_set_blend_normal(struct cso_context *cso)
|
{
|
struct pipe_blend_state blend = {0};
|
|
blend.rt[0].colormask = PIPE_MASK_RGBA;
|
cso_set_blend(cso, &blend);
|
}
|
|
static void
|
util_set_dsa_disable(struct cso_context *cso)
|
{
|
struct pipe_depth_stencil_alpha_state dsa = {{0}};
|
|
cso_set_depth_stencil_alpha(cso, &dsa);
|
}
|
|
static void
|
util_set_rasterizer_normal(struct cso_context *cso)
|
{
|
struct pipe_rasterizer_state rs = {0};
|
|
rs.half_pixel_center = 1;
|
rs.bottom_edge_rule = 1;
|
rs.depth_clip = 1;
|
|
cso_set_rasterizer(cso, &rs);
|
}
|
|
static void
|
util_set_max_viewport(struct cso_context *cso, struct pipe_resource *tex)
|
{
|
struct pipe_viewport_state viewport;
|
|
viewport.scale[0] = 0.5f * tex->width0;
|
viewport.scale[1] = 0.5f * tex->height0;
|
viewport.scale[2] = 1.0f;
|
viewport.translate[0] = 0.5f * tex->width0;
|
viewport.translate[1] = 0.5f * tex->height0;
|
viewport.translate[2] = 0.0f;
|
|
cso_set_viewport(cso, &viewport);
|
}
|
|
static void
|
util_set_interleaved_vertex_elements(struct cso_context *cso,
|
unsigned num_elements)
|
{
|
unsigned i;
|
struct pipe_vertex_element *velem =
|
calloc(1, num_elements * sizeof(struct pipe_vertex_element));
|
|
for (i = 0; i < num_elements; i++) {
|
velem[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
|
velem[i].src_offset = i * 16;
|
}
|
|
cso_set_vertex_elements(cso, num_elements, velem);
|
free(velem);
|
}
|
|
static void *
|
util_set_passthrough_vertex_shader(struct cso_context *cso,
|
struct pipe_context *ctx,
|
bool window_space)
|
{
|
static const uint vs_attribs[] = {
|
TGSI_SEMANTIC_POSITION,
|
TGSI_SEMANTIC_GENERIC
|
};
|
static const uint vs_indices[] = {0, 0};
|
void *vs;
|
|
vs = util_make_vertex_passthrough_shader(ctx, 2, vs_attribs, vs_indices,
|
window_space);
|
cso_set_vertex_shader_handle(cso, vs);
|
return vs;
|
}
|
|
static void
|
util_set_common_states_and_clear(struct cso_context *cso, struct pipe_context *ctx,
|
struct pipe_resource *cb)
|
{
|
static const float clear_color[] = {0.1, 0.1, 0.1, 0.1};
|
|
util_set_framebuffer_cb0(cso, ctx, cb);
|
util_set_blend_normal(cso);
|
util_set_dsa_disable(cso);
|
util_set_rasterizer_normal(cso);
|
util_set_max_viewport(cso, cb);
|
|
ctx->clear(ctx, PIPE_CLEAR_COLOR0, (void*)clear_color, 0, 0);
|
}
|
|
static void
|
util_draw_fullscreen_quad(struct cso_context *cso)
|
{
|
static float vertices[] = {
|
-1, -1, 0, 1, 0, 0, 0, 0,
|
-1, 1, 0, 1, 0, 1, 0, 0,
|
1, 1, 0, 1, 1, 1, 0, 0,
|
1, -1, 0, 1, 1, 0, 0, 0
|
};
|
util_set_interleaved_vertex_elements(cso, 2);
|
util_draw_user_vertex_buffer(cso, vertices, PIPE_PRIM_QUADS, 4, 2);
|
}
|
|
/**
|
* Probe and test if the rectangle contains the expected color.
|
*
|
* If "num_expected_colors" > 1, at least one expected color must match
|
* the probed color. "expected" should be an array of 4*num_expected_colors
|
* floats.
|
*/
|
static bool
|
util_probe_rect_rgba_multi(struct pipe_context *ctx, struct pipe_resource *tex,
|
unsigned offx, unsigned offy, unsigned w,
|
unsigned h,
|
const float *expected,
|
unsigned num_expected_colors)
|
{
|
struct pipe_transfer *transfer;
|
void *map;
|
float *pixels = malloc(w * h * 4 * sizeof(float));
|
unsigned x,y,e,c;
|
bool pass = true;
|
|
map = pipe_transfer_map(ctx, tex, 0, 0, PIPE_TRANSFER_READ,
|
offx, offy, w, h, &transfer);
|
pipe_get_tile_rgba(transfer, map, 0, 0, w, h, pixels);
|
pipe_transfer_unmap(ctx, transfer);
|
|
for (e = 0; e < num_expected_colors; e++) {
|
for (y = 0; y < h; y++) {
|
for (x = 0; x < w; x++) {
|
float *probe = &pixels[(y*w + x)*4];
|
|
for (c = 0; c < 4; c++) {
|
if (fabs(probe[c] - expected[e*4+c]) >= TOLERANCE) {
|
if (e < num_expected_colors-1)
|
goto next_color; /* test the next expected color */
|
|
printf("Probe color at (%i,%i), ", offx+x, offy+y);
|
printf("Expected: %.3f, %.3f, %.3f, %.3f, ",
|
expected[e*4], expected[e*4+1],
|
expected[e*4+2], expected[e*4+3]);
|
printf("Got: %.3f, %.3f, %.3f, %.3f\n",
|
probe[0], probe[1], probe[2], probe[2]);
|
pass = false;
|
goto done;
|
}
|
}
|
}
|
}
|
break; /* this color was successful */
|
|
next_color:;
|
}
|
done:
|
|
free(pixels);
|
return pass;
|
}
|
|
static bool
|
util_probe_rect_rgba(struct pipe_context *ctx, struct pipe_resource *tex,
|
unsigned offx, unsigned offy, unsigned w, unsigned h,
|
const float *expected)
|
{
|
return util_probe_rect_rgba_multi(ctx, tex, offx, offy, w, h, expected, 1);
|
}
|
|
enum {
|
SKIP = -1,
|
FAIL = 0, /* also "false" */
|
PASS = 1 /* also "true" */
|
};
|
|
static void
|
util_report_result_helper(int status, const char *name, ...)
|
{
|
char buf[256];
|
va_list ap;
|
|
va_start(ap, name);
|
util_vsnprintf(buf, sizeof(buf), name, ap);
|
va_end(ap);
|
|
printf("Test(%s) = %s\n", buf,
|
status == SKIP ? "skip" :
|
status == PASS ? "pass" : "fail");
|
}
|
|
#define util_report_result(status) util_report_result_helper(status, __func__)
|
|
/**
|
* Test TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION.
|
*
|
* The viewport state is set as usual, but it should have no effect.
|
* Clipping should also be disabled.
|
*
|
* POSITION.xyz should already be multiplied by 1/w and POSITION.w should
|
* contain 1/w. By setting w=0, we can test that POSITION.xyz isn't
|
* multiplied by 1/w (otherwise nothing would be rendered).
|
*
|
* TODO: Whether the value of POSITION.w is correctly interpreted as 1/w
|
* during perspective interpolation is not tested.
|
*/
|
static void
|
tgsi_vs_window_space_position(struct pipe_context *ctx)
|
{
|
struct cso_context *cso;
|
struct pipe_resource *cb;
|
void *fs, *vs;
|
bool pass = true;
|
static const float red[] = {1, 0, 0, 1};
|
|
if (!ctx->screen->get_param(ctx->screen,
|
PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION)) {
|
util_report_result(SKIP);
|
return;
|
}
|
|
cso = cso_create_context(ctx, 0);
|
cb = util_create_texture2d(ctx->screen, 256, 256,
|
PIPE_FORMAT_R8G8B8A8_UNORM);
|
util_set_common_states_and_clear(cso, ctx, cb);
|
|
/* Fragment shader. */
|
fs = util_make_fragment_passthrough_shader(ctx, TGSI_SEMANTIC_GENERIC,
|
TGSI_INTERPOLATE_LINEAR, TRUE);
|
cso_set_fragment_shader_handle(cso, fs);
|
|
/* Vertex shader. */
|
vs = util_set_passthrough_vertex_shader(cso, ctx, true);
|
|
/* Draw. */
|
{
|
static float vertices[] = {
|
0, 0, 0, 0, 1, 0, 0, 1,
|
0, 256, 0, 0, 1, 0, 0, 1,
|
256, 256, 0, 0, 1, 0, 0, 1,
|
256, 0, 0, 0, 1, 0, 0, 1,
|
};
|
util_set_interleaved_vertex_elements(cso, 2);
|
util_draw_user_vertex_buffer(cso, vertices, PIPE_PRIM_QUADS, 4, 2);
|
}
|
|
/* Probe pixels. */
|
pass = pass && util_probe_rect_rgba(ctx, cb, 0, 0,
|
cb->width0, cb->height0, red);
|
|
/* Cleanup. */
|
cso_destroy_context(cso);
|
ctx->delete_vs_state(ctx, vs);
|
ctx->delete_fs_state(ctx, fs);
|
pipe_resource_reference(&cb, NULL);
|
|
util_report_result(pass);
|
}
|
|
static void
|
null_sampler_view(struct pipe_context *ctx, unsigned tgsi_tex_target)
|
{
|
struct cso_context *cso;
|
struct pipe_resource *cb;
|
void *fs, *vs;
|
bool pass = true;
|
/* 2 expected colors: */
|
static const float expected_tex[] = {0, 0, 0, 1,
|
0, 0, 0, 0};
|
static const float expected_buf[] = {0, 0, 0, 0};
|
const float *expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ?
|
expected_buf : expected_tex;
|
unsigned num_expected = tgsi_tex_target == TGSI_TEXTURE_BUFFER ? 1 : 2;
|
|
if (tgsi_tex_target == TGSI_TEXTURE_BUFFER &&
|
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) {
|
util_report_result_helper(SKIP, "%s: %s", __func__,
|
tgsi_texture_names[tgsi_tex_target]);
|
return;
|
}
|
|
cso = cso_create_context(ctx, 0);
|
cb = util_create_texture2d(ctx->screen, 256, 256,
|
PIPE_FORMAT_R8G8B8A8_UNORM);
|
util_set_common_states_and_clear(cso, ctx, cb);
|
|
ctx->set_sampler_views(ctx, PIPE_SHADER_FRAGMENT, 0, 1, NULL);
|
|
/* Fragment shader. */
|
fs = util_make_fragment_tex_shader(ctx, tgsi_tex_target,
|
TGSI_INTERPOLATE_LINEAR,
|
TGSI_RETURN_TYPE_FLOAT,
|
TGSI_RETURN_TYPE_FLOAT, false, false);
|
cso_set_fragment_shader_handle(cso, fs);
|
|
/* Vertex shader. */
|
vs = util_set_passthrough_vertex_shader(cso, ctx, false);
|
util_draw_fullscreen_quad(cso);
|
|
/* Probe pixels. */
|
pass = pass && util_probe_rect_rgba_multi(ctx, cb, 0, 0,
|
cb->width0, cb->height0, expected,
|
num_expected);
|
|
/* Cleanup. */
|
cso_destroy_context(cso);
|
ctx->delete_vs_state(ctx, vs);
|
ctx->delete_fs_state(ctx, fs);
|
pipe_resource_reference(&cb, NULL);
|
|
util_report_result_helper(pass, "%s: %s", __func__,
|
tgsi_texture_names[tgsi_tex_target]);
|
}
|
|
void
|
util_test_constant_buffer(struct pipe_context *ctx,
|
struct pipe_resource *constbuf)
|
{
|
struct cso_context *cso;
|
struct pipe_resource *cb;
|
void *fs, *vs;
|
bool pass = true;
|
static const float zero[] = {0, 0, 0, 0};
|
|
cso = cso_create_context(ctx, 0);
|
cb = util_create_texture2d(ctx->screen, 256, 256,
|
PIPE_FORMAT_R8G8B8A8_UNORM);
|
util_set_common_states_and_clear(cso, ctx, cb);
|
|
pipe_set_constant_buffer(ctx, PIPE_SHADER_FRAGMENT, 0, constbuf);
|
|
/* Fragment shader. */
|
{
|
static const char *text = /* I don't like ureg... */
|
"FRAG\n"
|
"DCL CONST[0][0]\n"
|
"DCL OUT[0], COLOR\n"
|
|
"MOV OUT[0], CONST[0][0]\n"
|
"END\n";
|
struct tgsi_token tokens[1000];
|
struct pipe_shader_state state;
|
|
if (!tgsi_text_translate(text, tokens, ARRAY_SIZE(tokens))) {
|
puts("Can't compile a fragment shader.");
|
util_report_result(FAIL);
|
return;
|
}
|
pipe_shader_state_from_tgsi(&state, tokens);
|
fs = ctx->create_fs_state(ctx, &state);
|
cso_set_fragment_shader_handle(cso, fs);
|
}
|
|
/* Vertex shader. */
|
vs = util_set_passthrough_vertex_shader(cso, ctx, false);
|
util_draw_fullscreen_quad(cso);
|
|
/* Probe pixels. */
|
pass = pass && util_probe_rect_rgba(ctx, cb, 0, 0, cb->width0,
|
cb->height0, zero);
|
|
/* Cleanup. */
|
cso_destroy_context(cso);
|
ctx->delete_vs_state(ctx, vs);
|
ctx->delete_fs_state(ctx, fs);
|
pipe_resource_reference(&cb, NULL);
|
|
util_report_result(pass);
|
}
|
|
static void
|
null_fragment_shader(struct pipe_context *ctx)
|
{
|
struct cso_context *cso;
|
struct pipe_resource *cb;
|
void *vs;
|
struct pipe_rasterizer_state rs = {0};
|
struct pipe_query *query;
|
union pipe_query_result qresult;
|
|
cso = cso_create_context(ctx, 0);
|
cb = util_create_texture2d(ctx->screen, 256, 256,
|
PIPE_FORMAT_R8G8B8A8_UNORM);
|
util_set_common_states_and_clear(cso, ctx, cb);
|
|
/* No rasterization. */
|
rs.rasterizer_discard = 1;
|
cso_set_rasterizer(cso, &rs);
|
|
vs = util_set_passthrough_vertex_shader(cso, ctx, false);
|
|
query = ctx->create_query(ctx, PIPE_QUERY_PRIMITIVES_GENERATED, 0);
|
ctx->begin_query(ctx, query);
|
util_draw_fullscreen_quad(cso);
|
ctx->end_query(ctx, query);
|
ctx->get_query_result(ctx, query, true, &qresult);
|
|
/* Cleanup. */
|
cso_destroy_context(cso);
|
ctx->delete_vs_state(ctx, vs);
|
ctx->destroy_query(ctx, query);
|
pipe_resource_reference(&cb, NULL);
|
|
/* Check PRIMITIVES_GENERATED. */
|
util_report_result(qresult.u64 == 2);
|
}
|
|
#if defined(PIPE_OS_LINUX) && defined(HAVE_LIBDRM)
|
#include <libsync.h>
|
#else
|
#define sync_merge(str, fd1, fd2) (-1)
|
#define sync_wait(fd, timeout) (-1)
|
#endif
|
|
static void
|
test_sync_file_fences(struct pipe_context *ctx)
|
{
|
struct pipe_screen *screen = ctx->screen;
|
bool pass = true;
|
|
if (!screen->get_param(screen, PIPE_CAP_NATIVE_FENCE_FD))
|
return;
|
|
struct cso_context *cso = cso_create_context(ctx, 0);
|
struct pipe_resource *buf =
|
pipe_buffer_create(screen, 0, PIPE_USAGE_DEFAULT, 1024 * 1024);
|
struct pipe_resource *tex =
|
util_create_texture2d(screen, 4096, 1024, PIPE_FORMAT_R8_UNORM);
|
struct pipe_fence_handle *buf_fence = NULL, *tex_fence = NULL;
|
|
/* Run 2 clears, get fencess. */
|
uint32_t value = 0;
|
ctx->clear_buffer(ctx, buf, 0, buf->width0, &value, sizeof(value));
|
ctx->flush(ctx, &buf_fence, PIPE_FLUSH_FENCE_FD);
|
|
struct pipe_box box;
|
u_box_2d(0, 0, tex->width0, tex->height0, &box);
|
ctx->clear_texture(ctx, tex, 0, &box, &value);
|
ctx->flush(ctx, &tex_fence, PIPE_FLUSH_FENCE_FD);
|
pass = pass && buf_fence && tex_fence;
|
|
/* Export fences. */
|
int buf_fd = screen->fence_get_fd(screen, buf_fence);
|
int tex_fd = screen->fence_get_fd(screen, tex_fence);
|
pass = pass && buf_fd >= 0 && tex_fd >= 0;
|
|
/* Merge fences. */
|
int merged_fd = sync_merge("test", buf_fd, tex_fd);
|
pass = pass && merged_fd >= 0;
|
|
/* (Re)import all fences. */
|
struct pipe_fence_handle *re_buf_fence = NULL, *re_tex_fence = NULL;
|
struct pipe_fence_handle *merged_fence = NULL;
|
ctx->create_fence_fd(ctx, &re_buf_fence, buf_fd);
|
ctx->create_fence_fd(ctx, &re_tex_fence, tex_fd);
|
ctx->create_fence_fd(ctx, &merged_fence, merged_fd);
|
pass = pass && re_buf_fence && re_tex_fence && merged_fence;
|
|
/* Run another clear after waiting for everything. */
|
struct pipe_fence_handle *final_fence = NULL;
|
ctx->fence_server_sync(ctx, merged_fence);
|
value = 0xff;
|
ctx->clear_buffer(ctx, buf, 0, buf->width0, &value, sizeof(value));
|
ctx->flush(ctx, &final_fence, PIPE_FLUSH_FENCE_FD);
|
pass = pass && final_fence;
|
|
/* Wait for the last fence. */
|
int final_fd = screen->fence_get_fd(screen, final_fence);
|
pass = pass && final_fd >= 0;
|
pass = pass && sync_wait(final_fd, -1) == 0;
|
|
/* Check that all fences are signalled. */
|
pass = pass && sync_wait(buf_fd, 0) == 0;
|
pass = pass && sync_wait(tex_fd, 0) == 0;
|
pass = pass && sync_wait(merged_fd, 0) == 0;
|
|
pass = pass && screen->fence_finish(screen, NULL, buf_fence, 0);
|
pass = pass && screen->fence_finish(screen, NULL, tex_fence, 0);
|
pass = pass && screen->fence_finish(screen, NULL, re_buf_fence, 0);
|
pass = pass && screen->fence_finish(screen, NULL, re_tex_fence, 0);
|
pass = pass && screen->fence_finish(screen, NULL, merged_fence, 0);
|
pass = pass && screen->fence_finish(screen, NULL, final_fence, 0);
|
|
/* Cleanup. */
|
#ifndef PIPE_OS_WINDOWS
|
if (buf_fd >= 0)
|
close(buf_fd);
|
if (tex_fd >= 0)
|
close(tex_fd);
|
if (merged_fd >= 0)
|
close(merged_fd);
|
if (final_fd >= 0)
|
close(final_fd);
|
#endif
|
|
screen->fence_reference(screen, &buf_fence, NULL);
|
screen->fence_reference(screen, &tex_fence, NULL);
|
screen->fence_reference(screen, &re_buf_fence, NULL);
|
screen->fence_reference(screen, &re_tex_fence, NULL);
|
screen->fence_reference(screen, &merged_fence, NULL);
|
screen->fence_reference(screen, &final_fence, NULL);
|
|
cso_destroy_context(cso);
|
pipe_resource_reference(&buf, NULL);
|
pipe_resource_reference(&tex, NULL);
|
|
util_report_result(pass);
|
}
|
|
/**
|
* Run all tests. This should be run with a clean context after
|
* context_create.
|
*/
|
void
|
util_run_tests(struct pipe_screen *screen)
|
{
|
struct pipe_context *ctx = screen->context_create(screen, NULL, 0);
|
|
null_fragment_shader(ctx);
|
tgsi_vs_window_space_position(ctx);
|
null_sampler_view(ctx, TGSI_TEXTURE_2D);
|
null_sampler_view(ctx, TGSI_TEXTURE_BUFFER);
|
util_test_constant_buffer(ctx, NULL);
|
test_sync_file_fences(ctx);
|
|
ctx->destroy(ctx);
|
|
puts("Done. Exiting..");
|
exit(0);
|
}
|
