blob: e7ecbe0b55dde86e0869a929bb762edf45443797 [file] [log] [blame]
//
// Copyright (c) 2021 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "../testBase.h"
#define ABS_ERROR(result, expected) (fabs(expected - result))
#define CLAMP(_val, _min, _max) \
((_val) < (_min) ? (_min) : (_val) > (_max) ? (_max) : (_val))
#define MAX_ERR 0.005f
#define MAX_TRIES 1
#define MAX_CLAMPED 1
extern cl_sampler create_sampler(cl_context context, image_sampler_data *sdata, bool test_mipmaps, cl_int *error);
extern void read_image_pixel_float(void *imageData, image_descriptor *imageInfo,
int x, int y, int z, float *outData);
extern bool gExtraValidateInfo;
extern bool gDisableOffsets;
extern bool gUseKernelSamplers;
extern cl_mem_flags gMemFlagsToUse;
extern int gtestTypesToRun;
extern uint64_t gRoundingStartValue;
extern bool gPrintOptions;
extern int test_read_image(cl_context context, cl_command_queue queue,
cl_kernel kernel, image_descriptor *imageInfo,
image_sampler_data *imageSampler,
bool useFloatCoords, ExplicitType outputType,
MTdata d);
extern void InitFloatCoordsCommon(image_descriptor *imageInfo,
image_sampler_data *imageSampler,
float *xOffsets, float *yOffsets,
float *zOffsets, float xfract, float yfract,
float zfract, int normalized_coords, MTdata d,
int lod);
template <class T>
int determine_validation_error_offset(
void *imagePtr, image_descriptor *imageInfo,
image_sampler_data *imageSampler, T *resultPtr, T *expected, float error,
float x, float y, float z, float xAddressOffset, float yAddressOffset,
float zAddressOffset, size_t j, int &numTries, int &numClamped,
bool printAsFloat, int lod)
{
int actualX, actualY, actualZ;
int found = debug_find_pixel_in_image(imagePtr, imageInfo, resultPtr,
&actualX, &actualY, &actualZ, lod);
bool clampingErr = false, clamped = false, otherClampingBug = false;
int clampedX, clampedY, clampedZ;
size_t imageWidth = imageInfo->width, imageHeight = imageInfo->height,
imageDepth = imageInfo->depth;
clamped = get_integer_coords_offset(x, y, z, xAddressOffset, yAddressOffset,
zAddressOffset, imageWidth, imageHeight,
imageDepth, imageSampler, imageInfo,
clampedX, clampedY, clampedZ);
if (found)
{
// Is it a clamping bug?
if (clamped && clampedX == actualX && clampedY == actualY
&& clampedZ == actualZ)
{
if ((--numClamped) == 0)
{
if (printAsFloat)
{
log_error("Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did "
"not validate! Expected (%g,%g,%g,%g), got "
"(%g,%g,%g,%g), error of %g\n",
j, x, x, y, y, z, z, (float)expected[0],
(float)expected[1], (float)expected[2],
(float)expected[3], (float)resultPtr[0],
(float)resultPtr[1], (float)resultPtr[2],
(float)resultPtr[3], error);
}
else
{
log_error(
"Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did not "
"validate! Expected (%x,%x,%x,%x), got (%x,%x,%x,%x)\n",
j, x, x, y, y, z, z, (int)expected[0], (int)expected[1],
(int)expected[2], (int)expected[3], (int)resultPtr[0],
(int)resultPtr[1], (int)resultPtr[2],
(int)resultPtr[3]);
}
log_error("ERROR: TEST FAILED: Read is erroneously clamping "
"coordinates!\n");
return -1;
}
clampingErr = true;
otherClampingBug = true;
}
}
if (clamped && !otherClampingBug)
{
// If we are in clamp-to-edge mode and we're getting zeroes, it's
// possible we're getting border erroneously
if (resultPtr[0] == 0 && resultPtr[1] == 0 && resultPtr[2] == 0
&& resultPtr[3] == 0)
{
if ((--numClamped) == 0)
{
if (printAsFloat)
{
log_error("Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did "
"not validate! Expected (%g,%g,%g,%g), got "
"(%g,%g,%g,%g), error of %g\n",
j, x, x, y, y, z, z, (float)expected[0],
(float)expected[1], (float)expected[2],
(float)expected[3], (float)resultPtr[0],
(float)resultPtr[1], (float)resultPtr[2],
(float)resultPtr[3], error);
}
else
{
log_error(
"Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did not "
"validate! Expected (%x,%x,%x,%x), got (%x,%x,%x,%x)\n",
j, x, x, y, y, z, z, (int)expected[0], (int)expected[1],
(int)expected[2], (int)expected[3], (int)resultPtr[0],
(int)resultPtr[1], (int)resultPtr[2],
(int)resultPtr[3]);
}
log_error("ERROR: TEST FAILED: Clamping is erroneously "
"returning border color!\n");
return -1;
}
clampingErr = true;
}
}
if (!clampingErr)
{
/* if( clamped && ( (int)x + (int)xOffsetValues[ j ] < 0 ||
(int)y + (int)yOffsetValues[ j ] < 0 ) )
{
log_error( "NEGATIVE COORDINATE ERROR\n" );
return -1;
}
*/
if (true) // gExtraValidateInfo )
{
if (printAsFloat)
{
log_error("Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did not "
"validate!\n\tExpected (%g,%g,%g,%g),\n\t got "
"(%g,%g,%g,%g), error of %g\n",
j, x, x, y, y, z, z, (float)expected[0],
(float)expected[1], (float)expected[2],
(float)expected[3], (float)resultPtr[0],
(float)resultPtr[1], (float)resultPtr[2],
(float)resultPtr[3], error);
}
else
{
log_error("Sample %ld: coord {%f(%a),%f(%a),%f(%a)} did not "
"validate!\n\tExpected (%x,%x,%x,%x),\n\t got "
"(%x,%x,%x,%x)\n",
j, x, x, y, y, z, z, (int)expected[0],
(int)expected[1], (int)expected[2], (int)expected[3],
(int)resultPtr[0], (int)resultPtr[1],
(int)resultPtr[2], (int)resultPtr[3]);
}
log_error(
"Integer coords resolve to %d,%d,%d with img size %d,%d,%d\n",
clampedX, clampedY, clampedZ, (int)imageWidth, (int)imageHeight,
(int)imageDepth);
if (printAsFloat && gExtraValidateInfo)
{
log_error("\nNearby values:\n");
for (int zOff = -1; zOff <= 1; zOff++)
{
for (int yOff = -1; yOff <= 1; yOff++)
{
float top[4], real[4], bot[4];
read_image_pixel_float(imagePtr, imageInfo,
clampedX - 1, clampedY + yOff,
clampedZ + zOff, top);
read_image_pixel_float(imagePtr, imageInfo, clampedX,
clampedY + yOff, clampedZ + zOff,
real);
read_image_pixel_float(imagePtr, imageInfo,
clampedX + 1, clampedY + yOff,
clampedZ + zOff, bot);
log_error("\t(%g,%g,%g,%g)", top[0], top[1], top[2],
top[3]);
log_error(" (%g,%g,%g,%g)", real[0], real[1], real[2],
real[3]);
log_error(" (%g,%g,%g,%g)\n", bot[0], bot[1], bot[2],
bot[3]);
}
}
}
// }
// else
// log_error( "\n" );
if (imageSampler->filter_mode != CL_FILTER_LINEAR)
{
if (found)
log_error(
"\tValue really found in image at %d,%d,%d (%s)\n",
actualX, actualY, actualZ,
(found > 1) ? "NOT unique!!" : "unique");
else
log_error("\tValue not actually found in image\n");
}
log_error("\n");
}
numClamped = -1; // We force the clamped counter to never work
if ((--numTries) == 0) return -1;
}
return 0;
}