static bool
check(const struct grid_info grid, const struct image_info img)
{
const int n = num_images_for_stages(grid, ~0);
const int m = max_image_units();
uint32_t pixels[N], expect[N];
int i;
for (i = 0; i < N; ++i) {
if (i < m) {
/*
* The sum at this location is just the number
* of times that the image with index i was
* bound to the pipeline.
*/
expect[i] = (n - i + m - 1) / m;
} else {
/*
* No image has a non-zero value at this
* location, so the sum is zero.
*/
expect[i] = 0;
}
}
return download_result(grid, pixels) &&
check_pixels_v(img, pixels, expect);
}
static bool
check(const struct grid_info grid, const struct image_info img)
{
static uint32_t pixels[N][4];
return download_result(grid, pixels[0]) &&
check_pixels(img, pixels[0], 33, 33, 33, 33);
}
static bool
check(const struct grid_info grid, const struct image_info img, unsigned l)
{
const unsigned layer_sz = 4 * product(grid.size);
uint32_t pixels_fb[4 * N], expect_fb[4 * N];
uint32_t pixels_img[4 * N], expect_img[4 * N];
unsigned i;
if (!download_result(grid, pixels_fb) ||
!download_image(img, 0, pixels_img))
return false;
for (i = 0; i < layer_sz; ++i) {
/*
* The framebuffer contents should reflect layer l of
* the image which is bound to the image unit.
*/
expect_fb[i] = encode(grid.format, layer_sz * l + i);
}
for (i = 0; i < 4 * N; ++i) {
if (i / layer_sz == l) {
/*
* Layer l should have been modified by the
* shader.
*/
expect_img[i] = encode(img.format, 33);
} else {
/*
* Other layers should have remained
* unchanged.
*/
expect_img[i] = encode(img.format, i);
}
}
if (!check_pixels_v(image_info_for_grid(grid), pixels_fb, expect_fb)) {
printf(" Source: framebuffer\n");
return false;
}
if (!check_pixels_v(img, pixels_img, expect_img)) {
printf(" Source: image\n");
return false;
}
return true;
}
static bool
check_derivative(const struct grid_info grid, const struct image_info img,
unsigned w, unsigned h)
{
uint32_t pixels_fb[H][W], expect_fb[H][W];
uint32_t pixels_img[H][W], expect_img[H][W];
int i, j;
for (i = 0; i < W; ++i) {
for (j = 0; j < H; ++j) {
expect_fb[j][i] = (j < h && i < w ? 1000 :
encode(get_image_format(GL_R32F), 0.5));
expect_img[j][i] = (j < h && i < w ? 1 : 0) + j;
}
}
if (!download_result(grid, pixels_fb[0]) ||
!download_image(img, 0, pixels_img[0]))
return false;
if (!check_pixels_v(img, pixels_fb[0], expect_fb[0])) {
printf(" Source: framebuffer\n");
/*
* Purely informational check, we don't care what the
* result is as long as derivatives are being
* calculated, don't fail if the result doesn't equal
* the expected value as it's most likely an accuracy
* issue.
*/
}
if (!check_pixels_v(img, pixels_img[0], expect_img[0])) {
printf(" Source: image\n");
return false;
}
return true;
}
static bool
check_fb_unique(const struct grid_info grid)
{
uint32_t pixels[H][W];
int frequency[N] = { 0 };
int i, j;
if (!download_result(grid, pixels[0]))
return false;
for (i = 0; i < W; ++i) {
for (j = 0; j < H; ++j) {
if (frequency[pixels[j][i] % N]++) {
printf("Probe value at (%d, %d)\n", i, j);
printf(" Observed: 0x%08x\n", pixels[j][i]);
printf(" Value not unique.\n");
return false;
}
}
}
return true;
}
