Function compare

tests/ktxdiff/ktxdiff_main.cpp:337–439

}

bool compare(Texture& lhs, Texture& rhs, float tolerance) {
    const auto vkFormat = static_cast<VkFormat>(lhs.header.vkFormat);
    const auto* bdfd = reinterpret_cast<const uint32_t*>(lhs.dfdData) + 1;
    const auto componentCount = KHR_DFDSAMPLECOUNT(bdfd);
    const auto texelBlockDimension0 = static_cast<uint8_t>(KHR_DFDVAL(bdfd, TEXELBLOCKDIMENSION0));
    const auto texelBlockDimension1 = static_cast<uint8_t>(KHR_DFDVAL(bdfd, TEXELBLOCKDIMENSION1));
    const auto texelBlockDimension2 = static_cast<uint8_t>(KHR_DFDVAL(bdfd, TEXELBLOCKDIMENSION2));
    const auto blockSizeX = texelBlockDimension0 + 1u;
    const auto blockSizeY = texelBlockDimension1 + 1u;
    const auto blockSizeZ = texelBlockDimension2 + 1u;
    const bool isFormatSRGB = KHR_DFDVAL(bdfd, TRANSFER) == KHR_DF_TRANSFER_SRGB;

    const bool isSigned = (KHR_DFDSVAL(bdfd, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED) != 0;
    const bool isFloat = (KHR_DFDSVAL(bdfd, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT) != 0;
    const bool isNormalized = KHR_DFDSVAL(bdfd, 0, SAMPLEUPPER) == (isFloat ? bit_cast<uint32_t>(1.0f) : 1u);
    const bool is32Bit = KHR_DFDSVAL(bdfd, 0, BITLENGTH) + 1 == 32;
    const bool is8Bit = KHR_DFDSVAL(bdfd, 0, BITLENGTH) + 1 == 8;
    const bool isFormatSFloat32 = isSigned && isFloat && is32Bit && vkFormat != VK_FORMAT_D32_SFLOAT_S8_UINT;
    const bool isFormatUNORM8 = !isSigned && !isFloat && is8Bit && isNormalized;

    const auto mismatch = [&](auto&&... args) {
        fmt::print("ktxdiff: ");
        fmt::print(std::forward<decltype(args)>(args)...);
        fmt::print(" between\n");
        fmt::print("          Expected: {} and\n", lhs.filepath);
        fmt::print("          Received: {}\n", rhs.filepath);
        return false;
    };

    if (lhs.transcoded) {
        // For encoded images the compressed data sizes can differ.
        // Skip the related checks for header.supercompressionGlobalData and levelIndex
        if (std::memcmp(&lhs.header, &rhs.header, sizeof(lhs.header) - sizeof(ktxIndexEntry64)) != 0)
            return mismatch("Mismatching header");
    } else {
        if (std::memcmp(&lhs.header, &rhs.header, sizeof(lhs.header)) != 0)
            return mismatch("Mismatching header");
        if (lhs.levelIndexSize != rhs.levelIndexSize)
            return mismatch("Mismatching levelIndices");
        for (uint32_t i = 0; i < lhs.levelIndices.size(); ++i)
            // Offsets and (compressed) sizes can differ, but uncompressedByteLength must match
            if (lhs.levelIndices[i].uncompressedByteLength != rhs.levelIndices[i].uncompressedByteLength)
                return mismatch("Mismatching levelIndices[{}].uncompressedByteLength", i);
    }
    if (lhs.dfdSize != rhs.dfdSize || std::memcmp(lhs.dfdData, rhs.dfdData, lhs.dfdSize) != 0)
        return mismatch("Mismatching DFD");

    if (lhs.kvdSize != rhs.kvdSize || std::memcmp(lhs.kvdData, rhs.kvdData, lhs.kvdSize) != 0)
        return mismatch("Mismatching KVD");

    if (!lhs.transcoded)
        if (lhs.sgdSize != rhs.sgdSize || std::memcmp(lhs.sgdData, rhs.sgdData, lhs.sgdSize) != 0)
            return mismatch("Mismatching SGD");

    // If the tolerance is 1 or above accept every image data as matching
    if (tolerance >= 1.0f)
        return true;