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 Test Log C++ Wrapper. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuTestLog.hpp" 25 #include "tcuTextureUtil.hpp" 26 #include "tcuSurface.hpp" 27 #include "deMath.h" 28 29 #include <limits> 30 31 namespace tcu 32 { 33 34 class LogWriteFailedError : public ResourceError 35 { 36 public: 37 LogWriteFailedError (void) : ResourceError("Writing to test log failed") {} 38 }; 39 40 enum 41 { 42 MAX_IMAGE_SIZE_2D = 4096, 43 MAX_IMAGE_SIZE_3D = 128 44 }; 45 46 // LogImage 47 48 LogImage::LogImage (const std::string& name, const std::string& description, const Surface& surface, qpImageCompressionMode compression) 49 : m_name (name) 50 , m_description (description) 51 , m_access (surface.getAccess()) 52 , m_scale (1.0f, 1.0f, 1.0f, 1.0f) 53 , m_bias (0.0f, 0.0f, 0.0f, 0.0f) 54 , m_compression (compression) 55 { 56 } 57 58 LogImage::LogImage (const std::string& name, const std::string& description, const ConstPixelBufferAccess& access, qpImageCompressionMode compression) 59 : m_name (name) 60 , m_description (description) 61 , m_access (access) 62 , m_scale (1.0f, 1.0f, 1.0f, 1.0f) 63 , m_bias (0.0f, 0.0f, 0.0f, 0.0f) 64 , m_compression (compression) 65 { 66 // Simplify combined formats that only use a single channel 67 if (tcu::isCombinedDepthStencilType(m_access.getFormat().type)) 68 { 69 if (m_access.getFormat().order == tcu::TextureFormat::D) 70 m_access = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_DEPTH); 71 else if (m_access.getFormat().order == tcu::TextureFormat::S) 72 m_access = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_STENCIL); 73 } 74 75 // Implicit scale and bias 76 if (m_access.getFormat().order != tcu::TextureFormat::DS) 77 computePixelScaleBias(m_access, m_scale, m_bias); 78 else 79 { 80 // Pack D and S bias and scale to R and G 81 const ConstPixelBufferAccess depthAccess = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_DEPTH); 82 const ConstPixelBufferAccess stencilAccess = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_STENCIL); 83 tcu::Vec4 depthScale; 84 tcu::Vec4 depthBias; 85 tcu::Vec4 stencilScale; 86 tcu::Vec4 stencilBias; 87 88 computePixelScaleBias(depthAccess, depthScale, depthBias); 89 computePixelScaleBias(stencilAccess, stencilScale, stencilBias); 90 91 m_scale = tcu::Vec4(depthScale.x(), stencilScale.x(), 0.0f, 0.0f); 92 m_bias = tcu::Vec4(depthBias.x(), stencilBias.x(), 0.0f, 0.0f); 93 } 94 } 95 96 LogImage::LogImage (const std::string& name, const std::string& description, const ConstPixelBufferAccess& access, const Vec4& scale, const Vec4& bias, qpImageCompressionMode compression) 97 : m_name (name) 98 , m_description (description) 99 , m_access (access) 100 , m_scale (scale) 101 , m_bias (bias) 102 , m_compression (compression) 103 { 104 // Cannot set scale and bias of combined formats 105 DE_ASSERT(access.getFormat().order != tcu::TextureFormat::DS); 106 107 // Simplify access 108 if (tcu::isCombinedDepthStencilType(access.getFormat().type)) 109 { 110 if (access.getFormat().order == tcu::TextureFormat::D) 111 m_access = tcu::getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_DEPTH); 112 if (access.getFormat().order == tcu::TextureFormat::S) 113 m_access = tcu::getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_STENCIL); 114 else 115 { 116 // Cannot log a DS format 117 DE_ASSERT(false); 118 return; 119 } 120 } 121 } 122 123 void LogImage::write (TestLog& log) const 124 { 125 if (m_access.getFormat().order != tcu::TextureFormat::DS) 126 log.writeImage(m_name.c_str(), m_description.c_str(), m_access, m_scale, m_bias, m_compression); 127 else 128 { 129 const ConstPixelBufferAccess depthAccess = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_DEPTH); 130 const ConstPixelBufferAccess stencilAccess = tcu::getEffectiveDepthStencilAccess(m_access, tcu::Sampler::MODE_STENCIL); 131 132 log.startImageSet(m_name.c_str(), m_description.c_str()); 133 log.writeImage("Depth", "Depth channel", depthAccess, m_scale.swizzle(0, 0, 0, 0), m_bias.swizzle(0, 0, 0, 0), m_compression); 134 log.writeImage("Stencil", "Stencil channel", stencilAccess, m_scale.swizzle(1, 1, 1, 1), m_bias.swizzle(1, 1, 1, 1), m_compression); 135 log.endImageSet(); 136 } 137 } 138 139 // MessageBuilder 140 141 MessageBuilder::MessageBuilder (const MessageBuilder& other) 142 : m_log(other.m_log) 143 { 144 m_str.str(other.m_str.str()); 145 } 146 147 MessageBuilder& MessageBuilder::operator= (const MessageBuilder& other) 148 { 149 m_log = other.m_log; 150 m_str.str(other.m_str.str()); 151 return *this; 152 } 153 154 TestLog& MessageBuilder::operator<< (const TestLog::EndMessageToken&) 155 { 156 m_log->writeMessage(m_str.str().c_str()); 157 return *m_log; 158 } 159 160 // SampleBuilder 161 162 TestLog& SampleBuilder::operator<< (const TestLog::EndSampleToken&) 163 { 164 m_log->startSample(); 165 166 for (std::vector<Value>::const_iterator val = m_values.begin(); val != m_values.end(); ++val) 167 { 168 if (val->type == Value::TYPE_FLOAT64) 169 m_log->writeSampleValue(val->value.float64); 170 else if (val->type == Value::TYPE_INT64) 171 m_log->writeSampleValue(val->value.int64); 172 else 173 DE_ASSERT(false); 174 } 175 176 m_log->endSample(); 177 178 return *m_log; 179 } 180 181 // TestLog 182 183 TestLog::TestLog (const char* fileName, deUint32 flags) 184 : m_log(qpTestLog_createFileLog(fileName, flags)) 185 { 186 if (!m_log) 187 throw ResourceError(std::string("Failed to open test log file '") + fileName + "'"); 188 } 189 190 TestLog::~TestLog (void) 191 { 192 qpTestLog_destroy(m_log); 193 } 194 195 void TestLog::writeMessage (const char* msgStr) 196 { 197 if (qpTestLog_writeText(m_log, DE_NULL, DE_NULL, QP_KEY_TAG_LAST, msgStr) == DE_FALSE) 198 throw LogWriteFailedError(); 199 } 200 201 void TestLog::startImageSet (const char* name, const char* description) 202 { 203 if (qpTestLog_startImageSet(m_log, name, description) == DE_FALSE) 204 throw LogWriteFailedError(); 205 } 206 207 void TestLog::endImageSet (void) 208 { 209 if (qpTestLog_endImageSet(m_log) == DE_FALSE) 210 throw LogWriteFailedError(); 211 } 212 213 template <int Size> 214 static Vector<int, Size> computeScaledSize (const Vector<int, Size>& imageSize, int maxSize) 215 { 216 bool allInRange = true; 217 for (int i = 0; i < Size; i++) 218 allInRange = allInRange && (imageSize[i] <= maxSize); 219 220 if (allInRange) 221 return imageSize; 222 else 223 { 224 float d = 1.0f; 225 for (int i = 0; i < Size; i++) 226 d = de::max(d, (float)imageSize[i] / (float)maxSize); 227 228 Vector<int, Size> res; 229 for (int i = 0; i < Size; i++) 230 res[i] = de::max(1, deRoundFloatToInt32((float)imageSize[i] / d)); 231 232 return res; 233 } 234 } 235 236 void TestLog::writeImage (const char* name, const char* description, const ConstPixelBufferAccess& access, const Vec4& pixelScale, const Vec4& pixelBias, qpImageCompressionMode compressionMode) 237 { 238 const TextureFormat& format = access.getFormat(); 239 int width = access.getWidth(); 240 int height = access.getHeight(); 241 int depth = access.getDepth(); 242 243 // Writing a combined image does not make sense 244 DE_ASSERT(!tcu::isCombinedDepthStencilType(access.getFormat().type)); 245 246 // Do not bother with preprocessing if images are not stored 247 if ((qpTestLog_getLogFlags(m_log) & QP_TEST_LOG_EXCLUDE_IMAGES) != 0) 248 return; 249 250 if (depth == 1 && format.type == TextureFormat::UNORM_INT8 251 && width <= MAX_IMAGE_SIZE_2D && height <= MAX_IMAGE_SIZE_2D 252 && (format.order == TextureFormat::RGB || format.order == TextureFormat::RGBA) 253 && access.getPixelPitch() == access.getFormat().getPixelSize() 254 && pixelBias[0] == 0.0f && pixelBias[1] == 0.0f && pixelBias[2] == 0.0f && pixelBias[3] == 0.0f 255 && pixelScale[0] == 1.0f && pixelScale[1] == 1.0f && pixelScale[2] == 1.0f && pixelScale[3] == 1.0f) 256 { 257 // Fast-path. 258 bool isRGBA = format.order == TextureFormat::RGBA; 259 260 writeImage(name, description, compressionMode, 261 isRGBA ? QP_IMAGE_FORMAT_RGBA8888 : QP_IMAGE_FORMAT_RGB888, 262 width, height, access.getRowPitch(), access.getDataPtr()); 263 } 264 else if (depth == 1) 265 { 266 Sampler sampler (Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::LINEAR, Sampler::NEAREST); 267 IVec2 logImageSize = computeScaledSize(IVec2(width, height), MAX_IMAGE_SIZE_2D); 268 tcu::TextureLevel logImage (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), logImageSize.x(), logImageSize.y(), 1); 269 PixelBufferAccess logImageAccess = logImage.getAccess(); 270 std::ostringstream longDesc; 271 272 longDesc << description << " (p' = p * " << pixelScale << " + " << pixelBias << ")"; 273 274 for (int y = 0; y < logImage.getHeight(); y++) 275 { 276 for (int x = 0; x < logImage.getWidth(); x++) 277 { 278 float yf = ((float)y + 0.5f) / (float)logImage.getHeight(); 279 float xf = ((float)x + 0.5f) / (float)logImage.getWidth(); 280 Vec4 s = access.sample2D(sampler, sampler.minFilter, xf, yf, 0)*pixelScale + pixelBias; 281 282 logImageAccess.setPixel(s, x, y); 283 } 284 } 285 286 writeImage(name, longDesc.str().c_str(), compressionMode, QP_IMAGE_FORMAT_RGBA8888, 287 logImageAccess.getWidth(), logImageAccess.getHeight(), logImageAccess.getRowPitch(), 288 logImageAccess.getDataPtr()); 289 } 290 else 291 { 292 // Isometric splat volume rendering. 293 const float blendFactor = 0.85f; 294 IVec3 scaledSize = computeScaledSize(IVec3(width, height, depth), MAX_IMAGE_SIZE_3D); 295 int w = scaledSize.x(); 296 int h = scaledSize.y(); 297 int d = scaledSize.z(); 298 int logImageW = w+d - 1; 299 int logImageH = w+d+h; 300 std::vector<float> blendImage (logImageW*logImageH*4, 0.0f); 301 PixelBufferAccess blendImageAccess (TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT), logImageW, logImageH, 1, &blendImage[0]); 302 tcu::TextureLevel logImage (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), logImageW, logImageH, 1); 303 PixelBufferAccess logImageAccess = logImage.getAccess(); 304 Sampler sampler (Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 305 std::ostringstream longDesc; 306 307 // \note Back-to-front. 308 for (int z = d-1; z >= 0; z--) 309 { 310 for (int y = 0; y < h; y++) 311 { 312 for (int x = 0; x < w; x++) 313 { 314 int px = w - (x + 1) + z; 315 int py = (w + d + h) - (x + y + z + 1); 316 317 float xf = ((float)x + 0.5f) / (float)w; 318 float yf = ((float)y + 0.5f) / (float)h; 319 float zf = ((float)z + 0.5f) / (float)d; 320 321 Vec4 p = blendImageAccess.getPixel(px, py); 322 Vec4 s = access.sample3D(sampler, sampler.minFilter, xf, yf, zf); 323 Vec4 b = s + p*blendFactor; 324 325 blendImageAccess.setPixel(b, px, py); 326 } 327 } 328 } 329 330 // Scale blend image nicely. 331 longDesc << description << " (p' = p * " << pixelScale << " + " << pixelBias << ")"; 332 333 // Write to final image. 334 tcu::clear(logImageAccess, tcu::IVec4(0x33, 0x66, 0x99, 0xff)); 335 336 for (int z = 0; z < d; z++) 337 { 338 for (int y = 0; y < h; y++) 339 { 340 for (int x = 0; x < w; x++) 341 { 342 if (z != 0 && !(x == 0 || y == h-1 || y == h-2)) 343 continue; 344 345 int px = w - (x + 1) + z; 346 int py = (w + d + h) - (x + y + z + 1); 347 Vec4 s = blendImageAccess.getPixel(px, py)*pixelScale + pixelBias; 348 349 logImageAccess.setPixel(s, px, py); 350 } 351 } 352 } 353 354 writeImage(name, longDesc.str().c_str(), compressionMode, QP_IMAGE_FORMAT_RGBA8888, 355 logImageAccess.getWidth(), logImageAccess.getHeight(), logImageAccess.getRowPitch(), 356 logImageAccess.getDataPtr()); 357 } 358 } 359 360 void TestLog::writeImage (const char* name, const char* description, qpImageCompressionMode compressionMode, qpImageFormat format, int width, int height, int stride, const void* data) 361 { 362 if (qpTestLog_writeImage(m_log, name, description, compressionMode, format, width, height, stride, data) == DE_FALSE) 363 throw LogWriteFailedError(); 364 } 365 366 void TestLog::startSection (const char* name, const char* description) 367 { 368 if (qpTestLog_startSection(m_log, name, description) == DE_FALSE) 369 throw LogWriteFailedError(); 370 } 371 372 void TestLog::endSection (void) 373 { 374 if (qpTestLog_endSection(m_log) == DE_FALSE) 375 throw LogWriteFailedError(); 376 } 377 378 void TestLog::startShaderProgram (bool linkOk, const char* linkInfoLog) 379 { 380 if (qpTestLog_startShaderProgram(m_log, linkOk?DE_TRUE:DE_FALSE, linkInfoLog) == DE_FALSE) 381 throw LogWriteFailedError(); 382 } 383 384 void TestLog::endShaderProgram (void) 385 { 386 if (qpTestLog_endShaderProgram(m_log) == DE_FALSE) 387 throw LogWriteFailedError(); 388 } 389 390 void TestLog::writeShader (qpShaderType type, const char* source, bool compileOk, const char* infoLog) 391 { 392 if (qpTestLog_writeShader(m_log, type, source, compileOk?DE_TRUE:DE_FALSE, infoLog) == DE_FALSE) 393 throw LogWriteFailedError(); 394 } 395 396 void TestLog::writeSpirVAssemblySource (const char* source) 397 { 398 if (qpTestLog_writeSpirVAssemblySource(m_log, source) == DE_FALSE) 399 throw LogWriteFailedError(); 400 } 401 402 void TestLog::writeKernelSource (const char* source) 403 { 404 if (qpTestLog_writeKernelSource(m_log, source) == DE_FALSE) 405 throw LogWriteFailedError(); 406 } 407 408 void TestLog::writeCompileInfo (const char* name, const char* description, bool compileOk, const char* infoLog) 409 { 410 if (qpTestLog_writeCompileInfo(m_log, name, description, compileOk ? DE_TRUE : DE_FALSE, infoLog) == DE_FALSE) 411 throw LogWriteFailedError(); 412 } 413 414 void TestLog::writeFloat (const char* name, const char* description, const char* unit, qpKeyValueTag tag, float value) 415 { 416 if (qpTestLog_writeFloat(m_log, name, description, unit, tag, value) == DE_FALSE) 417 throw LogWriteFailedError(); 418 } 419 420 void TestLog::writeInteger (const char* name, const char* description, const char* unit, qpKeyValueTag tag, deInt64 value) 421 { 422 if (qpTestLog_writeInteger(m_log, name, description, unit, tag, value) == DE_FALSE) 423 throw LogWriteFailedError(); 424 } 425 426 void TestLog::startEglConfigSet (const char* name, const char* description) 427 { 428 if (qpTestLog_startEglConfigSet(m_log, name, description) == DE_FALSE) 429 throw LogWriteFailedError(); 430 } 431 432 void TestLog::writeEglConfig (const qpEglConfigInfo* config) 433 { 434 if (qpTestLog_writeEglConfig(m_log, config) == DE_FALSE) 435 throw LogWriteFailedError(); 436 } 437 438 void TestLog::endEglConfigSet (void) 439 { 440 if (qpTestLog_endEglConfigSet(m_log) == DE_FALSE) 441 throw LogWriteFailedError(); 442 } 443 444 void TestLog::startCase (const char* testCasePath, qpTestCaseType testCaseType) 445 { 446 if (qpTestLog_startCase(m_log, testCasePath, testCaseType) == DE_FALSE) 447 throw LogWriteFailedError(); 448 } 449 450 void TestLog::endCase (qpTestResult result, const char* description) 451 { 452 if (qpTestLog_endCase(m_log, result, description) == DE_FALSE) 453 throw LogWriteFailedError(); 454 } 455 456 void TestLog::terminateCase (qpTestResult result) 457 { 458 if (qpTestLog_terminateCase(m_log, result) == DE_FALSE) 459 throw LogWriteFailedError(); 460 } 461 462 void TestLog::startSampleList (const std::string& name, const std::string& description) 463 { 464 if (qpTestLog_startSampleList(m_log, name.c_str(), description.c_str()) == DE_FALSE) 465 throw LogWriteFailedError(); 466 } 467 468 void TestLog::startSampleInfo (void) 469 { 470 if (qpTestLog_startSampleInfo(m_log) == DE_FALSE) 471 throw LogWriteFailedError(); 472 } 473 474 void TestLog::writeValueInfo (const std::string& name, const std::string& description, const std::string& unit, qpSampleValueTag tag) 475 { 476 if (qpTestLog_writeValueInfo(m_log, name.c_str(), description.c_str(), unit.empty() ? DE_NULL : unit.c_str(), tag) == DE_FALSE) 477 throw LogWriteFailedError(); 478 } 479 480 void TestLog::endSampleInfo (void) 481 { 482 if (qpTestLog_endSampleInfo(m_log) == DE_FALSE) 483 throw LogWriteFailedError(); 484 } 485 486 void TestLog::startSample (void) 487 { 488 if (qpTestLog_startSample(m_log) == DE_FALSE) 489 throw LogWriteFailedError(); 490 } 491 492 void TestLog::writeSampleValue (double value) 493 { 494 if (qpTestLog_writeValueFloat(m_log, value) == DE_FALSE) 495 throw LogWriteFailedError(); 496 } 497 498 void TestLog::writeSampleValue (deInt64 value) 499 { 500 if (qpTestLog_writeValueInteger(m_log, value) == DE_FALSE) 501 throw LogWriteFailedError(); 502 } 503 504 void TestLog::endSample (void) 505 { 506 if (qpTestLog_endSample(m_log) == DE_FALSE) 507 throw LogWriteFailedError(); 508 } 509 510 void TestLog::endSampleList (void) 511 { 512 if (qpTestLog_endSampleList(m_log) == DE_FALSE) 513 throw LogWriteFailedError(); 514 } 515 516 const TestLog::BeginMessageToken TestLog::Message = TestLog::BeginMessageToken(); 517 const TestLog::EndMessageToken TestLog::EndMessage = TestLog::EndMessageToken(); 518 const TestLog::EndImageSetToken TestLog::EndImageSet = TestLog::EndImageSetToken(); 519 const TestLog::EndSectionToken TestLog::EndSection = TestLog::EndSectionToken(); 520 const TestLog::EndShaderProgramToken TestLog::EndShaderProgram = TestLog::EndShaderProgramToken(); 521 const TestLog::SampleInfoToken TestLog::SampleInfo = TestLog::SampleInfoToken(); 522 const TestLog::EndSampleInfoToken TestLog::EndSampleInfo = TestLog::EndSampleInfoToken(); 523 const TestLog::BeginSampleToken TestLog::Sample = TestLog::BeginSampleToken(); 524 const TestLog::EndSampleToken TestLog::EndSample = TestLog::EndSampleToken(); 525 const TestLog::EndSampleListToken TestLog::EndSampleList = TestLog::EndSampleListToken(); 526 527 } // tcu 528
