framework/common/tcuImageCompare.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Tester Core
   3  * ----------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Image comparison utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "tcuImageCompare.hpp"
  25 #include "tcuSurface.hpp"
  26 #include "tcuFuzzyImageCompare.hpp"
  27 #include "tcuBilinearImageCompare.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "tcuVector.hpp"
  30 #include "tcuVectorUtil.hpp"
  31 #include "tcuRGBA.hpp"
  32 #include "tcuTexture.hpp"
  33 #include "tcuTextureUtil.hpp"
  34 #include "tcuFloat.hpp"
  35
  36 #include <string.h>
  37
  38 namespace tcu
  39 {
  40
  41 namespace
  42 {
  43
  44 void computeScaleAndBias (const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, tcu::Vec4& scale, tcu::Vec4& bias)
  45 {
  46         Vec4 minVal;
  47         Vec4 maxVal;
  48         const float eps = 0.0001f;
  49
  50         {
  51                 Vec4 refMin;
  52                 Vec4 refMax;
  53                 estimatePixelValueRange(reference, refMin, refMax);
  54
  55                 minVal  = refMin;
  56                 maxVal  = refMax;
  57         }
  58
  59         {
  60                 Vec4 resMin;
  61                 Vec4 resMax;
  62
  63                 estimatePixelValueRange(result, resMin, resMax);
  64
  65                 minVal[0] = de::min(minVal[0], resMin[0]);
  66                 minVal[1] = de::min(minVal[1], resMin[1]);
  67                 minVal[2] = de::min(minVal[2], resMin[2]);
  68                 minVal[3] = de::min(minVal[3], resMin[3]);
  69
  70                 maxVal[0] = de::max(maxVal[0], resMax[0]);
  71                 maxVal[1] = de::max(maxVal[1], resMax[1]);
  72                 maxVal[2] = de::max(maxVal[2], resMax[2]);
  73                 maxVal[3] = de::max(maxVal[3], resMax[3]);
  74         }
  75
  76         for (int c = 0; c < 4; c++)
  77         {
  78                 if (maxVal[c] - minVal[c] < eps)
  79                 {
  80                         scale[c]        = (maxVal[c] < eps) ? 1.0f : (1.0f / maxVal[c]);
  81                         bias[c]         = (c == 3) ? (1.0f - maxVal[c]*scale[c]) : (0.0f - minVal[c]*scale[c]);
  82                 }
  83                 else
  84                 {
  85                         scale[c]        = 1.0f / (maxVal[c] - minVal[c]);
  86                         bias[c]         = 0.0f - minVal[c]*scale[c];
  87                 }
  88         }
  89 }
  90
  91 static int findNumPositionDeviationFailingPixels (const PixelBufferAccess& errorMask, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, const tcu::IVec3& maxPositionDeviation, bool acceptOutOfBoundsAsAnyValue)
  92 {
  93         const tcu::IVec4        okColor                         (0, 255, 0, 255);
  94         const tcu::IVec4        errorColor                      (255, 0, 0, 255);
  95         const int                       width                           = reference.getWidth();
  96         const int                       height                          = reference.getHeight();
  97         const int                       depth                           = reference.getDepth();
  98         int                                     numFailingPixels        = 0;
  99
 100         // Accept pixels "sampling" over the image bounds pixels since "taps" could be anything
 101         const int                       beginX                          = (acceptOutOfBoundsAsAnyValue) ? (maxPositionDeviation.x()) : (0);
 102         const int                       beginY                          = (acceptOutOfBoundsAsAnyValue) ? (maxPositionDeviation.y()) : (0);
 103         const int                       beginZ                          = (acceptOutOfBoundsAsAnyValue) ? (maxPositionDeviation.z()) : (0);
 104         const int                       endX                            = (acceptOutOfBoundsAsAnyValue) ? (width  - maxPositionDeviation.x()) : (width);
 105         const int                       endY                            = (acceptOutOfBoundsAsAnyValue) ? (height - maxPositionDeviation.y()) : (height);
 106         const int                       endZ                            = (acceptOutOfBoundsAsAnyValue) ? (depth  - maxPositionDeviation.z()) : (depth);
 107
 108         TCU_CHECK_INTERNAL(result.getWidth() == width && result.getHeight() == height && result.getDepth() == depth);
 109
 110         tcu::clear(errorMask, okColor);
 111
 112         for (int z = beginZ; z < endZ; z++)
 113         {
 114                 for (int y = beginY; y < endY; y++)
 115                 {
 116                         for (int x = beginX; x < endX; x++)
 117                         {
 118                                 const IVec4     refPix = reference.getPixelInt(x, y, z);
 119                                 const IVec4     cmpPix = result.getPixelInt(x, y, z);
 120
 121                                 // Exact match
 122                                 {
 123                                         const UVec4     diff = abs(refPix - cmpPix).cast<deUint32>();
 124                                         const bool      isOk = boolAll(lessThanEqual(diff, threshold));
 125
 126                                         if (isOk)
 127                                                 continue;
 128                                 }
 129
 130                                 // Find matching pixels for both result and reference pixel
 131
 132                                 {
 133                                         bool pixelFoundForReference = false;
 134
 135                                         // Find deviated result pixel for reference
 136
 137                                         for (int sz = de::max(0, z - maxPositionDeviation.z()); sz <= de::min(depth  - 1, z + maxPositionDeviation.z()) && !pixelFoundForReference; ++sz)
 138                                         for (int sy = de::max(0, y - maxPositionDeviation.y()); sy <= de::min(height - 1, y + maxPositionDeviation.y()) && !pixelFoundForReference; ++sy)
 139                                         for (int sx = de::max(0, x - maxPositionDeviation.x()); sx <= de::min(width  - 1, x + maxPositionDeviation.x()) && !pixelFoundForReference; ++sx)
 140                                         {
 141                                                 const IVec4     deviatedCmpPix  = result.getPixelInt(sx, sy, sz);
 142                                                 const UVec4     diff                    = abs(refPix - deviatedCmpPix).cast<deUint32>();
 143                                                 const bool      isOk                    = boolAll(lessThanEqual(diff, threshold));
 144
 145                                                 pixelFoundForReference          = isOk;
 146                                         }
 147
 148                                         if (!pixelFoundForReference)
 149                                         {
 150                                                 errorMask.setPixel(errorColor, x, y, z);
 151                                                 ++numFailingPixels;
 152                                                 continue;
 153                                         }
 154                                 }
 155                                 {
 156                                         bool pixelFoundForResult = false;
 157
 158                                         // Find deviated reference pixel for result
 159
 160                                         for (int sz = de::max(0, z - maxPositionDeviation.z()); sz <= de::min(depth  - 1, z + maxPositionDeviation.z()) && !pixelFoundForResult; ++sz)
 161                                         for (int sy = de::max(0, y - maxPositionDeviation.y()); sy <= de::min(height - 1, y + maxPositionDeviation.y()) && !pixelFoundForResult; ++sy)
 162                                         for (int sx = de::max(0, x - maxPositionDeviation.x()); sx <= de::min(width  - 1, x + maxPositionDeviation.x()) && !pixelFoundForResult; ++sx)
 163                                         {
 164                                                 const IVec4     deviatedRefPix  = reference.getPixelInt(sx, sy, sz);
 165                                                 const UVec4     diff                    = abs(cmpPix - deviatedRefPix).cast<deUint32>();
 166                                                 const bool      isOk                    = boolAll(lessThanEqual(diff, threshold));
 167
 168                                                 pixelFoundForResult                     = isOk;
 169                                         }
 170
 171                                         if (!pixelFoundForResult)
 172                                         {
 173                                                 errorMask.setPixel(errorColor, x, y, z);
 174                                                 ++numFailingPixels;
 175                                                 continue;
 176                                         }
 177                                 }
 178                         }
 179                 }
 180         }
 181
 182         return numFailingPixels;
 183 }
 184
 185 } // anonymous
 186
 187 /*--------------------------------------------------------------------*//*!
 188  * \brief Fuzzy image comparison
 189  *
 190  * This image comparison is designed for comparing images rendered by 3D
 191  * graphics APIs such as OpenGL. The comparison allows small local differences
 192  * and compensates for aliasing.
 193  *
 194  * The algorithm first performs light blurring on both images and then
 195  * does per-pixel analysis. Pixels are compared to 3x3 bilinear surface
 196  * defined by adjecent pixels. This compensates for both 1-pixel deviations
 197  * in geometry and aliasing in texture data.
 198  *
 199  * Error metric is computed based on the differences. On valid images the
 200  * metric is usually <0.01. Thus good threshold values are in range 0.02 to
 201  * 0.05.
 202  *
 203  * On failure error image is generated that shows where the failing pixels
 204  * are.
 205  *
 206  * \note                                Currently supports only UNORM_INT8 formats
 207  * \param log                   Test log for results
 208  * \param imageSetName  Name for image set when logging results
 209  * \param imageSetDesc  Description for image set
 210  * \param reference             Reference image
 211  * \param result                Result image
 212  * \param threshold             Error metric threshold (good values are 0.02-0.05)
 213  * \param logMode               Logging mode
 214  * \return true if comparison passes, false otherwise
 215  *//*--------------------------------------------------------------------*/
 216 bool fuzzyCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, float threshold, CompareLogMode logMode)
 217 {
 218         FuzzyCompareParams      params;         // Use defaults.
 219         TextureLevel            errorMask               (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), reference.getWidth(), reference.getHeight());
 220         float                           difference              = fuzzyCompare(params, reference, result, errorMask.getAccess());
 221         bool                            isOk                    = difference <= threshold;
 222         Vec4                            pixelBias               (0.0f, 0.0f, 0.0f, 0.0f);
 223         Vec4                            pixelScale              (1.0f, 1.0f, 1.0f, 1.0f);
 224
 225         if (!isOk || logMode == COMPARE_LOG_EVERYTHING)
 226         {
 227                 // Generate more accurate error mask.
 228                 params.maxSampleSkip = 0;
 229                 fuzzyCompare(params, reference, result, errorMask.getAccess());
 230
 231                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8) && reference.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 232                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 233
 234                 if (!isOk)
 235                         log << TestLog::Message << "Image comparison failed: difference = " << difference << ", threshold = " << threshold << TestLog::EndMessage;
 236
 237                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 238                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 239                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 240                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 241                         << TestLog::EndImageSet;
 242         }
 243         else if (logMode == COMPARE_LOG_RESULT)
 244         {
 245                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 246                         computePixelScaleBias(result, pixelScale, pixelBias);
 247
 248                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 249                         << TestLog::Image("Result",             "Result",               result, pixelScale, pixelBias)
 250                         << TestLog::EndImageSet;
 251         }
 252
 253         return isOk;
 254 }
 255
 256 /*--------------------------------------------------------------------*//*!
 257  * \brief Fuzzy image comparison
 258  *
 259  * This image comparison is designed for comparing images rendered by 3D
 260  * graphics APIs such as OpenGL. The comparison allows small local differences
 261  * and compensates for aliasing.
 262  *
 263  * The algorithm first performs light blurring on both images and then
 264  * does per-pixel analysis. Pixels are compared to 3x3 bilinear surface
 265  * defined by adjecent pixels. This compensates for both 1-pixel deviations
 266  * in geometry and aliasing in texture data.
 267  *
 268  * Error metric is computed based on the differences. On valid images the
 269  * metric is usually <0.01. Thus good threshold values are in range 0.02 to
 270  * 0.05.
 271  *
 272  * On failure error image is generated that shows where the failing pixels
 273  * are.
 274  *
 275  * \note                                Currently supports only UNORM_INT8 formats
 276  * \param log                   Test log for results
 277  * \param imageSetName  Name for image set when logging results
 278  * \param imageSetDesc  Description for image set
 279  * \param reference             Reference image
 280  * \param result                Result image
 281  * \param threshold             Error metric threshold (good values are 0.02-0.05)
 282  * \param logMode               Logging mode
 283  * \return true if comparison passes, false otherwise
 284  *//*--------------------------------------------------------------------*/
 285 bool fuzzyCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const Surface& reference, const Surface& result, float threshold, CompareLogMode logMode)
 286 {
 287         return fuzzyCompare(log, imageSetName, imageSetDesc, reference.getAccess(), result.getAccess(), threshold, logMode);
 288 }
 289
 290 static deInt64 computeSquaredDiffSum (const ConstPixelBufferAccess& ref, const ConstPixelBufferAccess& cmp, const PixelBufferAccess& diffMask, int diffFactor)
 291 {
 292         TCU_CHECK_INTERNAL(ref.getFormat().type == TextureFormat::UNORM_INT8 && cmp.getFormat().type == TextureFormat::UNORM_INT8);
 293         DE_ASSERT(ref.getWidth() == cmp.getWidth() && ref.getWidth() == diffMask.getWidth());
 294         DE_ASSERT(ref.getHeight() == cmp.getHeight() && ref.getHeight() == diffMask.getHeight());
 295
 296         deInt64 diffSum = 0;
 297
 298         for (int y = 0; y < cmp.getHeight(); y++)
 299         {
 300                 for (int x = 0; x < cmp.getWidth(); x++)
 301                 {
 302                         IVec4   a               = ref.getPixelInt(x, y);
 303                         IVec4   b               = cmp.getPixelInt(x, y);
 304                         IVec4   diff    = abs(a - b);
 305                         int             sum             = diff.x() + diff.y() + diff.z() + diff.w();
 306                         int             sqSum   = diff.x()*diff.x() + diff.y()*diff.y() + diff.z()*diff.z() + diff.w()*diff.w();
 307
 308                         diffMask.setPixel(tcu::RGBA(deClamp32(sum*diffFactor, 0, 255), deClamp32(255-sum*diffFactor, 0, 255), 0, 255).toVec(), x, y);
 309
 310                         diffSum += (deInt64)sqSum;
 311                 }
 312         }
 313
 314         return diffSum;
 315 }
 316
 317 /*--------------------------------------------------------------------*//*!
 318  * \brief Per-pixel difference accuracy metric
 319  *
 320  * Computes accuracy metric using per-pixel differences between reference
 321  * and result images.
 322  *
 323  * \note                                        Supports only integer- and fixed-point formats
 324  * \param log                           Test log for results
 325  * \param imageSetName          Name for image set when logging results
 326  * \param imageSetDesc          Description for image set
 327  * \param reference                     Reference image
 328  * \param result                        Result image
 329  * \param bestScoreDiff         Scaling factor
 330  * \param worstScoreDiff        Scaling factor
 331  * \param logMode                       Logging mode
 332  * \return true if comparison passes, false otherwise
 333  *//*--------------------------------------------------------------------*/
 334 int measurePixelDiffAccuracy (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, int bestScoreDiff, int worstScoreDiff, CompareLogMode logMode)
 335 {
 336         TextureLevel    diffMask                (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), reference.getWidth(), reference.getHeight());
 337         int                             diffFactor              = 8;
 338         deInt64                 squaredSum              = computeSquaredDiffSum(reference, result, diffMask.getAccess(), diffFactor);
 339         float                   sum                             = deFloatSqrt((float)squaredSum);
 340         int                             score                   = deClamp32(deFloorFloatToInt32(100.0f - (de::max(sum-(float)bestScoreDiff, 0.0f) / (float)(worstScoreDiff-bestScoreDiff))*100.0f), 0, 100);
 341         const int               failThreshold   = 10;
 342         Vec4                    pixelBias               (0.0f, 0.0f, 0.0f, 0.0f);
 343         Vec4                    pixelScale              (1.0f, 1.0f, 1.0f, 1.0f);
 344
 345         if (logMode == COMPARE_LOG_EVERYTHING || score <= failThreshold)
 346         {
 347                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8) && reference.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 348                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 349
 350                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 351                         << TestLog::Image("Result",             "Result",                       result,         pixelScale, pixelBias)
 352                         << TestLog::Image("Reference",  "Reference",            reference,      pixelScale, pixelBias)
 353                         << TestLog::Image("DiffMask",   "Difference",           diffMask)
 354                         << TestLog::EndImageSet;
 355         }
 356         else if (logMode == COMPARE_LOG_RESULT)
 357         {
 358                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 359                         computePixelScaleBias(result, pixelScale, pixelBias);
 360
 361                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 362                         << TestLog::Image("Result",             "Result",                       result,         pixelScale, pixelBias)
 363                         << TestLog::EndImageSet;
 364         }
 365
 366         if (logMode != COMPARE_LOG_ON_ERROR || score <= failThreshold)
 367                 log << TestLog::Integer("DiffSum", "Squared difference sum", "", QP_KEY_TAG_NONE, squaredSum)
 368                         << TestLog::Integer("Score", "Score", "", QP_KEY_TAG_QUALITY, score);
 369
 370         return score;
 371 }
 372
 373 /*--------------------------------------------------------------------*//*!
 374  * \brief Per-pixel difference accuracy metric
 375  *
 376  * Computes accuracy metric using per-pixel differences between reference
 377  * and result images.
 378  *
 379  * \note                                        Supports only integer- and fixed-point formats
 380  * \param log                           Test log for results
 381  * \param imageSetName          Name for image set when logging results
 382  * \param imageSetDesc          Description for image set
 383  * \param reference                     Reference image
 384  * \param result                        Result image
 385  * \param bestScoreDiff         Scaling factor
 386  * \param worstScoreDiff        Scaling factor
 387  * \param logMode                       Logging mode
 388  * \return true if comparison passes, false otherwise
 389  *//*--------------------------------------------------------------------*/
 390 int measurePixelDiffAccuracy (TestLog& log, const char* imageSetName, const char* imageSetDesc, const Surface& reference, const Surface& result, int bestScoreDiff, int worstScoreDiff, CompareLogMode logMode)
 391 {
 392         return measurePixelDiffAccuracy(log, imageSetName, imageSetDesc, reference.getAccess(), result.getAccess(), bestScoreDiff, worstScoreDiff, logMode);
 393 }
 394
 395 /*--------------------------------------------------------------------*//*!
 396  * Returns the index of float in a float space without denormals
 397  * so that:
 398  * 1) f(0.0) = 0
 399  * 2) f(-0.0) = 0
 400  * 3) f(b) = f(a) + 1  <==>  b = nextAfter(a)
 401  *
 402  * See computeFloatFlushRelaxedULPDiff for details
 403  *//*--------------------------------------------------------------------*/
 404 static deInt32 getPositionOfIEEEFloatWithoutDenormals (float x)
 405 {
 406         DE_ASSERT(!deIsNaN(x)); // not sane
 407
 408         if (x == 0.0f)
 409                 return 0;
 410         else if (x < 0.0f)
 411                 return -getPositionOfIEEEFloatWithoutDenormals(-x);
 412         else
 413         {
 414                 DE_ASSERT(x > 0.0f);
 415
 416                 const tcu::Float32 f(x);
 417
 418                 if (f.isDenorm())
 419                 {
 420                         // Denorms are flushed to zero
 421                         return 0;
 422                 }
 423                 else
 424                 {
 425                         // sign is 0, and it's a normal number. Natural position is its bit
 426                         // pattern but since we've collapsed the denorms, we must remove
 427                         // the gap here too to keep the float enumeration continuous.
 428                         //
 429                         // Denormals occupy one exponent pattern. Removing one from
 430                         // exponent should to the trick. Add one since the removed range
 431                         // contained one representable value, 0.
 432                         return (deInt32)(f.bits() - (1u << 23u) + 1u);
 433                 }
 434         }
 435 }
 436
 437 static deUint32 computeFloatFlushRelaxedULPDiff (float a, float b)
 438 {
 439         if (deIsNaN(a) && deIsNaN(b))
 440                 return 0;
 441         else if (deIsNaN(a) || deIsNaN(b))
 442         {
 443                 return 0xFFFFFFFFu;
 444         }
 445         else
 446         {
 447                 // Using the "definition 5" in Muller, Jean-Michel. "On the definition of ulp (x)" (2005)
 448                 // assuming a floating point space is IEEE single precision floating point space without
 449                 // denormals (and signed zeros).
 450                 const deInt32 aIndex = getPositionOfIEEEFloatWithoutDenormals(a);
 451                 const deInt32 bIndex = getPositionOfIEEEFloatWithoutDenormals(b);
 452                 return (deUint32)de::abs(aIndex - bIndex);
 453         }
 454 }
 455
 456 static tcu::UVec4 computeFlushRelaxedULPDiff (const tcu::Vec4& a, const tcu::Vec4& b)
 457 {
 458         return tcu::UVec4(computeFloatFlushRelaxedULPDiff(a.x(), b.x()),
 459                                           computeFloatFlushRelaxedULPDiff(a.y(), b.y()),
 460                                           computeFloatFlushRelaxedULPDiff(a.z(), b.z()),
 461                                           computeFloatFlushRelaxedULPDiff(a.w(), b.w()));
 462 }
 463
 464 /*--------------------------------------------------------------------*//*!
 465  * \brief Per-pixel threshold-based comparison
 466  *
 467  * This compare computes per-pixel differences between result and reference
 468  * image. Comparison fails if any pixels exceed the given threshold value.
 469  *
 470  * This comparison uses ULP (units in last place) metric for computing the
 471  * difference between floating-point values and thus this function can
 472  * be used only for comparing floating-point texture data. In ULP calculation
 473  * the denormal numbers are allowed to be flushed to zero.
 474  *
 475  * On failure error image is generated that shows where the failing pixels
 476  * are.
 477  *
 478  * \param log                   Test log for results
 479  * \param imageSetName  Name for image set when logging results
 480  * \param imageSetDesc  Description for image set
 481  * \param reference             Reference image
 482  * \param result                Result image
 483  * \param threshold             Maximum allowed difference
 484  * \param logMode               Logging mode
 485  * \return true if comparison passes, false otherwise
 486  *//*--------------------------------------------------------------------*/
 487 bool floatUlpThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, CompareLogMode logMode)
 488 {
 489         int                                     width                           = reference.getWidth();
 490         int                                     height                          = reference.getHeight();
 491         int                                     depth                           = reference.getDepth();
 492         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 493         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 494         UVec4                           maxDiff                         (0, 0, 0, 0);
 495         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 496         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 497
 498         TCU_CHECK(result.getWidth() == width && result.getHeight() == height && result.getDepth() == depth);
 499
 500         for (int z = 0; z < depth; z++)
 501         {
 502                 for (int y = 0; y < height; y++)
 503                 {
 504                         for (int x = 0; x < width; x++)
 505                         {
 506                                 const Vec4      refPix  = reference.getPixel(x, y, z);
 507                                 const Vec4      cmpPix  = result.getPixel(x, y, z);
 508                                 const UVec4     diff    = computeFlushRelaxedULPDiff(refPix, cmpPix);
 509                                 const bool      isOk    = boolAll(lessThanEqual(diff, threshold));
 510
 511                                 maxDiff = max(maxDiff, diff);
 512
 513                                 errorMask.setPixel(isOk ? Vec4(0.0f, 1.0f, 0.0f, 1.0f) : Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y, z);
 514                         }
 515                 }
 516         }
 517
 518         bool compareOk = boolAll(lessThanEqual(maxDiff, threshold));
 519
 520         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 521         {
 522                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 523                 if (tcu::getTextureChannelClass(reference.getFormat().type)     != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT ||
 524                         tcu::getTextureChannelClass(result.getFormat().type)    != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 525                 {
 526                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 527                         log << TestLog::Message << "Result and reference images are normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 528                 }
 529
 530                 if (!compareOk)
 531                         log << TestLog::Message << "Image comparison failed: max difference = " << maxDiff << ", threshold = " << threshold << TestLog::EndMessage;
 532
 533                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 534                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 535                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 536                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 537                         << TestLog::EndImageSet;
 538         }
 539         else if (logMode == COMPARE_LOG_RESULT)
 540         {
 541                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 542                         computePixelScaleBias(result, pixelScale, pixelBias);
 543
 544                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 545                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 546                         << TestLog::EndImageSet;
 547         }
 548
 549         return compareOk;
 550 }
 551
 552 /*--------------------------------------------------------------------*//*!
 553  * \brief Per-pixel threshold-based comparison
 554  *
 555  * This compare computes per-pixel differences between result and reference
 556  * image. Comparison fails if any pixels exceed the given threshold value.
 557  *
 558  * This comparison can be used for floating-point and fixed-point formats.
 559  * Difference is computed in floating-point space.
 560  *
 561  * On failure an error image is generated that shows where the failing
 562  * pixels are.
 563  *
 564  * \param log                   Test log for results
 565  * \param imageSetName  Name for image set when logging results
 566  * \param imageSetDesc  Description for image set
 567  * \param reference             Reference image
 568  * \param result                Result image
 569  * \param threshold             Maximum allowed difference
 570  * \param logMode               Logging mode
 571  * \return true if comparison passes, false otherwise
 572  *//*--------------------------------------------------------------------*/
 573 bool floatThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const Vec4& threshold, CompareLogMode logMode)
 574 {
 575         int                                     width                           = reference.getWidth();
 576         int                                     height                          = reference.getHeight();
 577         int                                     depth                           = reference.getDepth();
 578         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 579         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 580         Vec4                            maxDiff                         (0.0f, 0.0f, 0.0f, 0.0f);
 581         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 582         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 583
 584         TCU_CHECK_INTERNAL(result.getWidth() == width && result.getHeight() == height && result.getDepth() == depth);
 585
 586         for (int z = 0; z < depth; z++)
 587         {
 588                 for (int y = 0; y < height; y++)
 589                 {
 590                         for (int x = 0; x < width; x++)
 591                         {
 592                                 Vec4    refPix          = reference.getPixel(x, y, z);
 593                                 Vec4    cmpPix          = result.getPixel(x, y, z);
 594
 595                                 Vec4    diff            = abs(refPix - cmpPix);
 596                                 bool    isOk            = boolAll(lessThanEqual(diff, threshold));
 597
 598                                 maxDiff = max(maxDiff, diff);
 599
 600                                 errorMask.setPixel(isOk ? Vec4(0.0f, 1.0f, 0.0f, 1.0f) : Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y, z);
 601                         }
 602                 }
 603         }
 604
 605         bool compareOk = boolAll(lessThanEqual(maxDiff, threshold));
 606
 607         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 608         {
 609                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 610                 if (tcu::getTextureChannelClass(reference.getFormat().type)     != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT ||
 611                         tcu::getTextureChannelClass(result.getFormat().type)    != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 612                 {
 613                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 614                         log << TestLog::Message << "Result and reference images are normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 615                 }
 616
 617                 if (!compareOk)
 618                         log << TestLog::Message << "Image comparison failed: max difference = " << maxDiff << ", threshold = " << threshold << TestLog::EndMessage;
 619
 620                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 621                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 622                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 623                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 624                         << TestLog::EndImageSet;
 625         }
 626         else if (logMode == COMPARE_LOG_RESULT)
 627         {
 628                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 629                         computePixelScaleBias(result, pixelScale, pixelBias);
 630
 631                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 632                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 633                         << TestLog::EndImageSet;
 634         }
 635
 636         return compareOk;
 637 }
 638
 639 /*--------------------------------------------------------------------*//*!
 640  * \brief Per-pixel threshold-based comparison
 641  *
 642  * This compare computes per-pixel differences between result and reference
 643  * color. Comparison fails if any pixels exceed the given threshold value.
 644  *
 645  * This comparison can be used for floating-point and fixed-point formats.
 646  * Difference is computed in floating-point space.
 647  *
 648  * On failure an error image is generated that shows where the failing
 649  * pixels are.
 650  *
 651  * \param log                   Test log for results
 652  * \param imageSetName  Name for image set when logging results
 653  * \param imageSetDesc  Description for image set
 654  * \param reference             Reference color
 655  * \param result                Result image
 656  * \param threshold             Maximum allowed difference
 657  * \param logMode               Logging mode
 658  * \return true if comparison passes, false otherwise
 659  *//*--------------------------------------------------------------------*/
 660 bool floatThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const Vec4& reference, const ConstPixelBufferAccess& result, const Vec4& threshold, CompareLogMode logMode)
 661 {
 662         const int                       width                           = result.getWidth();
 663         const int                       height                          = result.getHeight();
 664         const int                       depth                           = result.getDepth();
 665
 666         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 667         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 668         Vec4                            maxDiff                         (0.0f, 0.0f, 0.0f, 0.0f);
 669         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 670         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 671
 672         for (int z = 0; z < depth; z++)
 673         {
 674                 for (int y = 0; y < height; y++)
 675                 {
 676                         for (int x = 0; x < width; x++)
 677                         {
 678                                 const Vec4      cmpPix          = result.getPixel(x, y, z);
 679                                 const Vec4      diff            = abs(reference - cmpPix);
 680                                 const bool      isOk            = boolAll(lessThanEqual(diff, threshold));
 681
 682                                 maxDiff = max(maxDiff, diff);
 683
 684                                 errorMask.setPixel(isOk ? Vec4(0.0f, 1.0f, 0.0f, 1.0f) : Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y, z);
 685                         }
 686                 }
 687         }
 688
 689         bool compareOk = boolAll(lessThanEqual(maxDiff, threshold));
 690
 691         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 692         {
 693                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 694                 if (tcu::getTextureChannelClass(result.getFormat().type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 695                 {
 696                         computeScaleAndBias(result, result, pixelScale, pixelBias);
 697                         log << TestLog::Message << "Result image is normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 698                 }
 699
 700                 if (!compareOk)
 701                         log << TestLog::Message << "Image comparison failed: max difference = " << maxDiff << ", threshold = " << threshold << ", reference = " << reference << TestLog::EndMessage;
 702
 703                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 704                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 705                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 706                         << TestLog::EndImageSet;
 707         }
 708         else if (logMode == COMPARE_LOG_RESULT)
 709         {
 710                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 711                         computePixelScaleBias(result, pixelScale, pixelBias);
 712
 713                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 714                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 715                         << TestLog::EndImageSet;
 716         }
 717
 718         return compareOk;
 719 }
 720
 721 /*--------------------------------------------------------------------*//*!
 722  * \brief Per-pixel threshold-based comparison
 723  *
 724  * This compare computes per-pixel differences between result and reference
 725  * image. Comparison fails if any pixels exceed the given threshold value.
 726  *
 727  * This comparison can be used for integer- and fixed-point texture formats.
 728  * Difference is computed in integer space.
 729  *
 730  * On failure error image is generated that shows where the failing pixels
 731  * are.
 732  *
 733  * \param log                   Test log for results
 734  * \param imageSetName  Name for image set when logging results
 735  * \param imageSetDesc  Description for image set
 736  * \param reference             Reference image
 737  * \param result                Result image
 738  * \param threshold             Maximum allowed difference
 739  * \param logMode               Logging mode
 740  * \return true if comparison passes, false otherwise
 741  *//*--------------------------------------------------------------------*/
 742 bool intThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, CompareLogMode logMode)
 743 {
 744         int                                     width                           = reference.getWidth();
 745         int                                     height                          = reference.getHeight();
 746         int                                     depth                           = reference.getDepth();
 747         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 748         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 749         UVec4                           maxDiff                         (0, 0, 0, 0);
 750         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 751         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 752
 753         TCU_CHECK_INTERNAL(result.getWidth() == width && result.getHeight() == height && result.getDepth() == depth);
 754
 755         for (int z = 0; z < depth; z++)
 756         {
 757                 for (int y = 0; y < height; y++)
 758                 {
 759                         for (int x = 0; x < width; x++)
 760                         {
 761                                 IVec4   refPix          = reference.getPixelInt(x, y, z);
 762                                 IVec4   cmpPix          = result.getPixelInt(x, y, z);
 763
 764                                 UVec4   diff            = abs(refPix - cmpPix).cast<deUint32>();
 765                                 bool    isOk            = boolAll(lessThanEqual(diff, threshold));
 766
 767                                 maxDiff = max(maxDiff, diff);
 768
 769                                 errorMask.setPixel(isOk ? IVec4(0, 0xff, 0, 0xff) : IVec4(0xff, 0, 0, 0xff), x, y, z);
 770                         }
 771                 }
 772         }
 773
 774         bool compareOk = boolAll(lessThanEqual(maxDiff, threshold));
 775
 776         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 777         {
 778                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 779                 if (tcu::getTextureChannelClass(reference.getFormat().type)     != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT ||
 780                         tcu::getTextureChannelClass(result.getFormat().type)    != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 781                 {
 782                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 783                         log << TestLog::Message << "Result and reference images are normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 784                 }
 785
 786                 if (!compareOk)
 787                         log << TestLog::Message << "Image comparison failed: max difference = " << maxDiff << ", threshold = " << threshold << TestLog::EndMessage;
 788
 789                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 790                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 791                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 792                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 793                         << TestLog::EndImageSet;
 794         }
 795         else if (logMode == COMPARE_LOG_RESULT)
 796         {
 797                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 798                         computePixelScaleBias(result, pixelScale, pixelBias);
 799
 800                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 801                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 802                         << TestLog::EndImageSet;
 803         }
 804
 805         return compareOk;
 806 }
 807
 808 /*--------------------------------------------------------------------*//*!
 809  * \brief Per-pixel threshold-based deviation-ignoring comparison
 810  *
 811  * This compare computes per-pixel differences between result and reference
 812  * image. Comparison fails if there is no pixel matching the given threshold
 813  * value in the search volume.
 814  *
 815  * If the search volume contains out-of-bounds pixels, comparison can be set
 816  * to either ignore these pixels in search or to accept any pixel that has
 817  * out-of-bounds pixels in its search volume.
 818  *
 819  * This comparison can be used for integer- and fixed-point texture formats.
 820  * Difference is computed in integer space.
 821  *
 822  * On failure error image is generated that shows where the failing pixels
 823  * are.
 824  *
 825  * \param log                                                   Test log for results
 826  * \param imageSetName                                  Name for image set when logging results
 827  * \param imageSetDesc                                  Description for image set
 828  * \param reference                                             Reference image
 829  * \param result                                                Result image
 830  * \param threshold                                             Maximum allowed difference
 831  * \param maxPositionDeviation                  Maximum allowed distance in the search
 832  *                                                                              volume.
 833  * \param acceptOutOfBoundsAsAnyValue   Accept any pixel in the boundary region
 834  * \param logMode                                               Logging mode
 835  * \return true if comparison passes, false otherwise
 836  *//*--------------------------------------------------------------------*/
 837 bool intThresholdPositionDeviationCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, const tcu::IVec3& maxPositionDeviation, bool acceptOutOfBoundsAsAnyValue, CompareLogMode logMode)
 838 {
 839         const int                       width                           = reference.getWidth();
 840         const int                       height                          = reference.getHeight();
 841         const int                       depth                           = reference.getDepth();
 842         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 843         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 844         const int                       numFailingPixels        = findNumPositionDeviationFailingPixels(errorMask, reference, result, threshold, maxPositionDeviation, acceptOutOfBoundsAsAnyValue);
 845         const bool                      compareOk                       = numFailingPixels == 0;
 846         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 847         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 848
 849         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 850         {
 851                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 852                 if (tcu::getTextureChannelClass(reference.getFormat().type)     != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT ||
 853                         tcu::getTextureChannelClass(result.getFormat().type)    != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 854                 {
 855                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 856                         log << TestLog::Message << "Result and reference images are normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 857                 }
 858
 859                 if (!compareOk)
 860                         log     << TestLog::Message
 861                                 << "Image comparison failed:\n"
 862                                 << "\tallowed position deviation = " << maxPositionDeviation << "\n"
 863                                 << "\tcolor threshold = " << threshold
 864                                 << TestLog::EndMessage;
 865
 866                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 867                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 868                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 869                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 870                         << TestLog::EndImageSet;
 871         }
 872         else if (logMode == COMPARE_LOG_RESULT)
 873         {
 874                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 875                         computePixelScaleBias(result, pixelScale, pixelBias);
 876
 877                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 878                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 879                         << TestLog::EndImageSet;
 880         }
 881
 882         return compareOk;
 883 }
 884
 885 /*--------------------------------------------------------------------*//*!
 886  * \brief Per-pixel threshold-based deviation-ignoring comparison
 887  *
 888  * This compare computes per-pixel differences between result and reference
 889  * image. Pixel fails the test if there is no pixel matching the given
 890  * threshold value in the search volume. Comparison fails if the number of
 891  * failing pixels exceeds the given limit.
 892  *
 893  * If the search volume contains out-of-bounds pixels, comparison can be set
 894  * to either ignore these pixels in search or to accept any pixel that has
 895  * out-of-bounds pixels in its search volume.
 896  *
 897  * This comparison can be used for integer- and fixed-point texture formats.
 898  * Difference is computed in integer space.
 899  *
 900  * On failure error image is generated that shows where the failing pixels
 901  * are.
 902  *
 903  * \param log                                                   Test log for results
 904  * \param imageSetName                                  Name for image set when logging results
 905  * \param imageSetDesc                                  Description for image set
 906  * \param reference                                             Reference image
 907  * \param result                                                Result image
 908  * \param threshold                                             Maximum allowed difference
 909  * \param maxPositionDeviation                  Maximum allowed distance in the search
 910  *                                                                              volume.
 911  * \param acceptOutOfBoundsAsAnyValue   Accept any pixel in the boundary region
 912  * \param maxAllowedFailingPixels               Maximum number of failing pixels
 913  * \param logMode                                               Logging mode
 914  * \return true if comparison passes, false otherwise
 915  *//*--------------------------------------------------------------------*/
 916 bool intThresholdPositionDeviationErrorThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, const tcu::IVec3& maxPositionDeviation, bool acceptOutOfBoundsAsAnyValue, int maxAllowedFailingPixels, CompareLogMode logMode)
 917 {
 918         const int                       width                           = reference.getWidth();
 919         const int                       height                          = reference.getHeight();
 920         const int                       depth                           = reference.getDepth();
 921         TextureLevel            errorMaskStorage        (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height, depth);
 922         PixelBufferAccess       errorMask                       = errorMaskStorage.getAccess();
 923         const int                       numFailingPixels        = findNumPositionDeviationFailingPixels(errorMask, reference, result, threshold, maxPositionDeviation, acceptOutOfBoundsAsAnyValue);
 924         const bool                      compareOk                       = numFailingPixels <= maxAllowedFailingPixels;
 925         Vec4                            pixelBias                       (0.0f, 0.0f, 0.0f, 0.0f);
 926         Vec4                            pixelScale                      (1.0f, 1.0f, 1.0f, 1.0f);
 927
 928         if (!compareOk || logMode == COMPARE_LOG_EVERYTHING)
 929         {
 930                 // All formats except normalized unsigned fixed point ones need remapping in order to fit into unorm channels in logged images.
 931                 if (tcu::getTextureChannelClass(reference.getFormat().type)     != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT ||
 932                         tcu::getTextureChannelClass(result.getFormat().type)    != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
 933                 {
 934                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
 935                         log << TestLog::Message << "Result and reference images are normalized with formula p * " << pixelScale << " + " << pixelBias << TestLog::EndMessage;
 936                 }
 937
 938                 if (!compareOk)
 939                         log     << TestLog::Message
 940                                 << "Image comparison failed:\n"
 941                                 << "\tallowed position deviation = " << maxPositionDeviation << "\n"
 942                                 << "\tcolor threshold = " << threshold
 943                                 << TestLog::EndMessage;
 944                 log << TestLog::Message << "Number of failing pixels = " << numFailingPixels << ", max allowed = " << maxAllowedFailingPixels << TestLog::EndMessage;
 945
 946                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 947                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 948                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
 949                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
 950                         << TestLog::EndImageSet;
 951         }
 952         else if (logMode == COMPARE_LOG_RESULT)
 953         {
 954                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
 955                         computePixelScaleBias(result, pixelScale, pixelBias);
 956
 957                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
 958                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
 959                         << TestLog::EndImageSet;
 960         }
 961
 962         return compareOk;
 963 }
 964
 965 /*--------------------------------------------------------------------*//*!
 966  * \brief Per-pixel threshold-based comparison
 967  *
 968  * This compare computes per-pixel differences between result and reference
 969  * image. Comparison fails if any pixels exceed the given threshold value.
 970  *
 971  * On failure error image is generated that shows where the failing pixels
 972  * are.
 973  *
 974  * \param log                   Test log for results
 975  * \param imageSetName  Name for image set when logging results
 976  * \param imageSetDesc  Description for image set
 977  * \param reference             Reference image
 978  * \param result                Result image
 979  * \param threshold             Maximum allowed difference
 980  * \param logMode               Logging mode
 981  * \return true if comparison passes, false otherwise
 982  *//*--------------------------------------------------------------------*/
 983 bool pixelThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const Surface& reference, const Surface& result, const RGBA& threshold, CompareLogMode logMode)
 984 {
 985         return intThresholdCompare(log, imageSetName, imageSetDesc, reference.getAccess(), result.getAccess(), threshold.toIVec().cast<deUint32>(), logMode);
 986 }
 987
 988 /*--------------------------------------------------------------------*//*!
 989  * \brief Bilinear image comparison
 990  *
 991  * \todo [pyry] Describe
 992  *
 993  * On failure error image is generated that shows where the failing pixels
 994  * are.
 995  *
 996  * \note                                Currently supports only RGBA, UNORM_INT8 formats
 997  * \param log                   Test log for results
 998  * \param imageSetName  Name for image set when logging results
 999  * \param imageSetDesc  Description for image set
1000  * \param reference             Reference image
1001  * \param result                Result image
1002  * \param threshold             Maximum local difference
1003  * \param logMode               Logging mode
1004  * \return true if comparison passes, false otherwise
1005  *//*--------------------------------------------------------------------*/
1006 bool bilinearCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const RGBA threshold, CompareLogMode logMode)
1007 {
1008         TextureLevel            errorMask               (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), reference.getWidth(), reference.getHeight());
1009         bool                            isOk                    = bilinearCompare(reference, result, errorMask, threshold);
1010         Vec4                            pixelBias               (0.0f, 0.0f, 0.0f, 0.0f);
1011         Vec4                            pixelScale              (1.0f, 1.0f, 1.0f, 1.0f);
1012
1013         if (!isOk || logMode == COMPARE_LOG_EVERYTHING)
1014         {
1015                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8) && reference.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
1016                         computeScaleAndBias(reference, result, pixelScale, pixelBias);
1017
1018                 if (!isOk)
1019                         log << TestLog::Message << "Image comparison failed, threshold = " << threshold << TestLog::EndMessage;
1020
1021                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
1022                         << TestLog::Image("Result",             "Result",               result,         pixelScale, pixelBias)
1023                         << TestLog::Image("Reference",  "Reference",    reference,      pixelScale, pixelBias)
1024                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
1025                         << TestLog::EndImageSet;
1026         }
1027         else if (logMode == COMPARE_LOG_RESULT)
1028         {
1029                 if (result.getFormat() != TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8))
1030                         computePixelScaleBias(result, pixelScale, pixelBias);
1031
1032                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
1033                         << TestLog::Image("Result",             "Result",               result, pixelScale, pixelBias)
1034                         << TestLog::EndImageSet;
1035         }
1036
1037         return isOk;
1038 }
1039
1040 } // tcu