vkgs-sim 소스 (nusim hub upload code)

6b0231d verified 8 days ago

20.3 kB

// Copyright 2022-2023 The Khronos Group Inc.
// Copyright 2022-2023 RasterGrid Kft.
// SPDX-License-Identifier: Apache-2.0

#include "ktx.h"
#include "ktxint.h"
#include "texture2.h"
#include "vkformat_enum.h"
#include "platform_utils.h"

#include "astc-encoder/Source/astcenc.h"

#include <cassert>
#include <fstream>
#include <iostream>
#include <string_view>
#include <vector>

#include <fmt/os.h>
#include <fmt/ostream.h>
#include <fmt/printf.h>


template <typename T>
[[nodiscard]] constexpr inline T ceil_div(const T x, const T y) noexcept {
    assert(y != 0);
	return (x + y - 1) / y;
}

// C++20 - std::bit_cast
template <class To, class From>
[[nodiscard]] constexpr inline To bit_cast(const From& src) noexcept {
    static_assert(sizeof(To) == sizeof(From));
    static_assert(std::is_trivially_copyable_v<From>);
    static_assert(std::is_trivially_copyable_v<To>);
    static_assert(std::is_trivially_constructible_v<To>);
    To dst;
    std::memcpy(&dst, &src, sizeof(To));
    return dst;
}

[[nodiscard]] constexpr inline bool isFormatAstc(VkFormat format) noexcept {
    switch (format) {
    case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: [[fallthrough]];
    case VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: [[fallthrough]];
    case VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT:
        return true;
    default:
        return false;
    }
}

// -------------------------------------------------------------------------------------------------

int EXIT_CODE_ERROR = 2;
int EXIT_CODE_MISMATCH = 1;
int EXIT_CODE_MATCH = 0;

template <typename... Args>
void error(int return_code, Args&&... args) {
    fmt::print(std::cerr, std::forward<Args>(args)...);
    std::exit(return_code);
}

[[nodiscard]] inline std::string errnoMessage() {
    return std::make_error_code(static_cast<std::errc>(errno)).message();
}

struct Texture {
    std::string filepath;
    std::vector<std::byte> rawData;

    KTX_header2 header;
    std::vector<ktxLevelIndexEntry> levelIndices;
    const std::byte* levelIndexData = nullptr;
    size_t levelIndexSize = 0;
    const std::byte* dfdData = nullptr;
    size_t dfdSize = 0;
    const std::byte* kvdData = nullptr;
    size_t kvdSize = 0;
    const std::byte* sgdData = nullptr;
    size_t sgdSize = 0;

    ktxTexture2* handle = nullptr;
    bool transcoded = false;

public:
    explicit Texture(std::string filepath) :
        filepath(filepath) {
        std::memset(&header, 0, sizeof(header));

        loadFile();
        loadKTX();
        loadMetadata();
    }
    ~Texture() {
        std::free(handle);
    }
    void loadFile();
    void loadKTX();
    void loadMetadata();
    inline ktxTexture2* operator->() const {
        return handle;
    }
};

void Texture::loadFile() {
    auto file = std::ifstream(DecodeUTF8Path(filepath).c_str(), std::ios::binary | std::ios::in | std::ios::ate);
    if (!file)
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to open file: {}\n", filepath, errnoMessage());

    const auto fileSize = file.tellg();
    file.seekg(0);
    if (file.fail())
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to seek file: {}\n", filepath, errnoMessage());

    rawData.resize(fileSize);
    file.read(reinterpret_cast<char*>(rawData.data()), fileSize);
    if (file.fail())
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to read file: {}\n", filepath, errnoMessage());
}

void Texture::loadKTX() {
    KTX_error_code ec = KTX_SUCCESS;
    ec = ktxTexture2_CreateFromMemory(
            reinterpret_cast<const ktx_uint8_t*>(rawData.data()),
            rawData.size(),
            KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
            &handle);
    if (ec != KTX_SUCCESS)
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": ktxTexture2_CreateFromNamedFile: {}\n", filepath, ktxErrorString(ec));

    if (ktxTexture2_NeedsTranscoding(handle)) {
        ec = ktxTexture2_TranscodeBasis(handle, KTX_TTF_RGBA32, 0);
        if (ec != KTX_SUCCESS)
            error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": ktxTexture2_TranscodeBasis: {}\n", filepath, ktxErrorString(ec));
        transcoded = true;
    }
}

void Texture::loadMetadata() {
    const auto headerData = rawData.data();
    const auto headerSize = sizeof(KTX_header2);
    std::memcpy(&header, headerData, headerSize);

    const auto numLevels = std::max(header.levelCount, 1u);
    levelIndexData = rawData.data() + sizeof(KTX_header2);
    levelIndexSize = sizeof(ktxLevelIndexEntry) * numLevels;
    levelIndices.resize(numLevels);
    std::memcpy(levelIndices.data(), levelIndexData, levelIndexSize);

    if (header.dataFormatDescriptor.byteLength != 0) {
        dfdData = rawData.data() + header.dataFormatDescriptor.byteOffset;
        dfdSize = header.dataFormatDescriptor.byteLength;
    }
    if (header.keyValueData.byteLength != 0) {
        kvdData = rawData.data() + header.keyValueData.byteOffset;
        kvdSize = header.keyValueData.byteLength;
    }
    if (header.supercompressionGlobalData.byteLength != 0) {
        sgdData = rawData.data() + header.dataFormatDescriptor.byteOffset;
        sgdSize = header.dataFormatDescriptor.byteLength;
    }
}

// -------------------------------------------------------------------------------------------------

struct CompareResult {
    bool match = true;
    float difference = 0.f;
    std::size_t elementIndex = 0;
    std::size_t byteOffset = 0;
};

CompareResult compareUnorm8(const char* rawLhs, const char* rawRhs, std::size_t rawSize, float tolerance) {
    const auto* lhs = reinterpret_cast<const uint8_t*>(rawLhs);
    const auto* rhs = reinterpret_cast<const uint8_t*>(rawRhs);
    const auto element_size = sizeof(uint8_t);
    const auto count = rawSize / element_size;

    for (std::size_t i = 0; i < count; ++i) {
        const auto diff = std::abs(static_cast<float>(lhs[i]) / 255.f - static_cast<float>(rhs[i]) / 255.f);
        if (diff > tolerance)
            return CompareResult{false, diff, i, i * element_size};
    }

    return CompareResult{};
}

CompareResult compareSFloat32(const char* rawLhs, const char* rawRhs, std::size_t rawSize, float tolerance) {
    const auto* lhs = reinterpret_cast<const float*>(rawLhs);
    const auto* rhs = reinterpret_cast<const float*>(rawRhs);
    const auto element_size = sizeof(float);
    const auto count = rawSize / element_size;

    for (std::size_t i = 0; i < count; ++i) {
        const auto diff = std::abs(lhs[i] - rhs[i]);
        if (diff > tolerance)
            return CompareResult{false, diff, i, i * element_size};
    }

    return CompareResult{};
}

auto decodeASTC(const char* compressedData, std::size_t compressedSize, uint32_t width, uint32_t height,
        const std::string& filepath, bool isFormatSRGB, uint32_t blockSizeX, uint32_t blockSizeY, uint32_t blockSizeZ) {

    const auto threadCount = 1u;
    static constexpr astcenc_swizzle swizzle{ASTCENC_SWZ_R, ASTCENC_SWZ_G, ASTCENC_SWZ_B, ASTCENC_SWZ_A};

    astcenc_error ec = ASTCENC_SUCCESS;

    const astcenc_profile profile = isFormatSRGB ? ASTCENC_PRF_LDR_SRGB : ASTCENC_PRF_LDR;
    astcenc_config config{};
    ec = astcenc_config_init(profile, blockSizeX, blockSizeY, blockSizeZ, ASTCENC_PRE_MEDIUM, ASTCENC_FLG_DECOMPRESS_ONLY, &config);
    if (ec != ASTCENC_SUCCESS)
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_config_init: {}\n", filepath, astcenc_get_error_string(ec));

    struct ASTCencStruct {
        astcenc_context* context = nullptr;
        ~ASTCencStruct() {
            astcenc_context_free(context);
        }
    } astcenc;
    astcenc_context*& context = astcenc.context;

    ec = astcenc_context_alloc(&config, threadCount, &context);
    if (ec != ASTCENC_SUCCESS)
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_context_alloc: {}\n", filepath, astcenc_get_error_string(ec));

    astcenc_image image{};
    image.dim_x = width;
    image.dim_y = height;
    image.dim_z = 1; // 3D ASTC formats are currently not supported
    const auto uncompressedSize = width * height * 4 * sizeof(uint8_t);
    auto uncompressedBuffer = std::make_unique<uint8_t[]>(uncompressedSize);
    auto* bufferPtr = uncompressedBuffer.get();
    image.data = reinterpret_cast<void**>(&bufferPtr);
    image.data_type = ASTCENC_TYPE_U8;

    ec = astcenc_decompress_image(context, reinterpret_cast<const uint8_t*>(compressedData), compressedSize, &image, &swizzle, 0);
    if (ec != ASTCENC_SUCCESS)
        error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_decompress_image: {}\n", filepath, astcenc_get_error_string(ec));

    astcenc_decompress_reset(context);

    struct Result {
        std::unique_ptr<uint8_t[]> data;
        std::size_t size;
    };
    return Result{std::move(uncompressedBuffer), uncompressedSize};
}

CompareResult compareAstc(const char* lhs, const char* rhs, std::size_t size, uint32_t width, uint32_t height,
        const std::string& filepathLhs, const std::string& filepathRhs,
        bool isFormatSRGB, uint32_t blockSizeX, uint32_t blockSizeY, uint32_t blockSizeZ,
        float tolerance) {
    const auto uncompressedLhs = decodeASTC(lhs, size, width, height, filepathLhs, isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ);
    const auto uncompressedRhs = decodeASTC(rhs, size, width, height, filepathRhs, isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ);

    return compareUnorm8(
            reinterpret_cast<const char*>(uncompressedLhs.data.get()),
            reinterpret_cast<const char*>(uncompressedRhs.data.get()),
            uncompressedLhs.size,
            tolerance);
}

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;

    for (uint32_t levelIndex = 0; levelIndex < lhs->numLevels; ++levelIndex) {
        const auto imageSize = ktxTexture_GetImageSize(ktxTexture(lhs.handle), levelIndex);
        const auto imageWidth = std::max(1u, lhs->baseWidth >> levelIndex);
        const auto imageHeight = std::max(1u, lhs->baseHeight >> levelIndex);
        const auto imageDepth = std::max(1u, lhs->baseDepth >> levelIndex);

        for (uint32_t faceIndex = 0; faceIndex < lhs->numFaces; ++faceIndex) {
            for (uint32_t layerIndex = 0; layerIndex < lhs->numLayers; ++layerIndex) {
                for (uint32_t depthIndex = 0; depthIndex < ceil_div(imageDepth, blockSizeZ); ++depthIndex) {

                    ktx_size_t imageOffset;
                    ktxTexture2_GetImageOffset(lhs.handle, levelIndex, layerIndex, faceIndex + depthIndex, &imageOffset);
                    const char* imageDataLhs = reinterpret_cast<const char*>(lhs->pData) + imageOffset;
                    const char* imageDataRhs = reinterpret_cast<const char*>(rhs->pData) + imageOffset;

                    CompareResult result;
                    if (lhs.transcoded || isFormatUNORM8) {
                        result = compareUnorm8(imageDataLhs, imageDataRhs, imageSize, tolerance);
                    } else if (isFormatAstc(vkFormat)) {
                        result = compareAstc(imageDataLhs, imageDataRhs, imageSize, imageWidth, imageHeight,
                                lhs.filepath, rhs.filepath,
                                isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ,
                                tolerance);
                    } else if (isFormatSFloat32) {
                        result = compareSFloat32(imageDataLhs, imageDataRhs, imageSize, tolerance);
                    } else {
                        for (std::size_t i = 0; i < imageSize; ++i) {
                            if (imageDataLhs[i] != imageDataRhs[i])
                                return mismatch("Mismatching image data: level {}, face {}, layer {}, depth {}, image byte {}",
                                        levelIndex, faceIndex, layerIndex, depthIndex, i);
                        }
                    }

                    if (!result.match) {
                        return mismatch("Mismatching image data (diff: {}): level {}, face {}, layer {}, depth {}, pixel {}, component {}",
                                result.difference, levelIndex, faceIndex, layerIndex, depthIndex,
                                result.elementIndex / componentCount, result.elementIndex % componentCount);
                    }
                }
            }
        }
    }

    return true;
}

/// EXIT CODES:
///     0 - Matching files
///     1 - Mismatching files
///     2 - Error while loading, decoding or processing an input file
int main(int argc, char* argv[]) {
    InitUTF8CLI(argc, argv);

    if (argc < 3) {
        fmt::print("Missing input file arguments\n");
        fmt::print("Usage: ktxdiff <expected-ktx2> <received-ktx2> [tolerance]\n");
        return EXIT_FAILURE;
    }

    const float tolerance = argc > 3 ? std::stof(argv[3]) : 0.05f;

    Texture lhs(argv[1]);
    Texture rhs(argv[2]);
    const auto match = compare(lhs, rhs, tolerance);

    return match ? 0 : 1;
}

	// Copyright 2022-2023 The Khronos Group Inc.
	// Copyright 2022-2023 RasterGrid Kft.
	// SPDX-License-Identifier: Apache-2.0

	#include "ktx.h"
	#include "ktxint.h"
	#include "texture2.h"
	#include "vkformat_enum.h"
	#include "platform_utils.h"

	#include "astc-encoder/Source/astcenc.h"

	#include <cassert>
	#include <fstream>
	#include <iostream>
	#include <string_view>
	#include <vector>

	#include <fmt/os.h>
	#include <fmt/ostream.h>
	#include <fmt/printf.h>


	template <typename T>
	[[nodiscard]] constexpr inline T ceil_div(const T x, const T y) noexcept {
	assert(y != 0);
	return (x + y - 1) / y;
	}

	// C++20 - std::bit_cast
	template <class To, class From>
	[[nodiscard]] constexpr inline To bit_cast(const From& src) noexcept {
	static_assert(sizeof(To) == sizeof(From));
	static_assert(std::is_trivially_copyable_v<From>);
	static_assert(std::is_trivially_copyable_v<To>);
	static_assert(std::is_trivially_constructible_v<To>);
	To dst;
	std::memcpy(&dst, &src, sizeof(To));
	return dst;
	}

	[[nodiscard]] constexpr inline bool isFormatAstc(VkFormat format) noexcept {
	switch (format) {
	case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: [[fallthrough]];
	case VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: [[fallthrough]];
	case VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT:
	return true;
	default:
	return false;
	}
	}

	// -------------------------------------------------------------------------------------------------

	int EXIT_CODE_ERROR = 2;
	int EXIT_CODE_MISMATCH = 1;
	int EXIT_CODE_MATCH = 0;

	template <typename... Args>
	void error(int return_code, Args&&... args) {
	fmt::print(std::cerr, std::forward<Args>(args)...);
	std::exit(return_code);
	}

	[[nodiscard]] inline std::string errnoMessage() {
	return std::make_error_code(static_cast<std::errc>(errno)).message();
	}

	struct Texture {
	std::string filepath;
	std::vector<std::byte> rawData;

	KTX_header2 header;
	std::vector<ktxLevelIndexEntry> levelIndices;
	const std::byte* levelIndexData = nullptr;
	size_t levelIndexSize = 0;
	const std::byte* dfdData = nullptr;
	size_t dfdSize = 0;
	const std::byte* kvdData = nullptr;
	size_t kvdSize = 0;
	const std::byte* sgdData = nullptr;
	size_t sgdSize = 0;

	ktxTexture2* handle = nullptr;
	bool transcoded = false;

	public:
	explicit Texture(std::string filepath) :
	filepath(filepath) {
	std::memset(&header, 0, sizeof(header));

	loadFile();
	loadKTX();
	loadMetadata();
	}
	~Texture() {
	std::free(handle);
	}
	void loadFile();
	void loadKTX();
	void loadMetadata();
	inline ktxTexture2* operator->() const {
	return handle;
	}
	};

	void Texture::loadFile() {
	auto file = std::ifstream(DecodeUTF8Path(filepath).c_str(), std::ios::binary \| std::ios::in \| std::ios::ate);
	if (!file)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to open file: {}\n", filepath, errnoMessage());

	const auto fileSize = file.tellg();
	file.seekg(0);
	if (file.fail())
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to seek file: {}\n", filepath, errnoMessage());

	rawData.resize(fileSize);
	file.read(reinterpret_cast<char*>(rawData.data()), fileSize);
	if (file.fail())
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": Failed to read file: {}\n", filepath, errnoMessage());
	}

	void Texture::loadKTX() {
	KTX_error_code ec = KTX_SUCCESS;
	ec = ktxTexture2_CreateFromMemory(
	reinterpret_cast<const ktx_uint8_t*>(rawData.data()),
	rawData.size(),
	KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
	&handle);
	if (ec != KTX_SUCCESS)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": ktxTexture2_CreateFromNamedFile: {}\n", filepath, ktxErrorString(ec));

	if (ktxTexture2_NeedsTranscoding(handle)) {
	ec = ktxTexture2_TranscodeBasis(handle, KTX_TTF_RGBA32, 0);
	if (ec != KTX_SUCCESS)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": ktxTexture2_TranscodeBasis: {}\n", filepath, ktxErrorString(ec));
	transcoded = true;
	}
	}

	void Texture::loadMetadata() {
	const auto headerData = rawData.data();
	const auto headerSize = sizeof(KTX_header2);
	std::memcpy(&header, headerData, headerSize);

	const auto numLevels = std::max(header.levelCount, 1u);
	levelIndexData = rawData.data() + sizeof(KTX_header2);
	levelIndexSize = sizeof(ktxLevelIndexEntry) * numLevels;
	levelIndices.resize(numLevels);
	std::memcpy(levelIndices.data(), levelIndexData, levelIndexSize);

	if (header.dataFormatDescriptor.byteLength != 0) {
	dfdData = rawData.data() + header.dataFormatDescriptor.byteOffset;
	dfdSize = header.dataFormatDescriptor.byteLength;
	}
	if (header.keyValueData.byteLength != 0) {
	kvdData = rawData.data() + header.keyValueData.byteOffset;
	kvdSize = header.keyValueData.byteLength;
	}
	if (header.supercompressionGlobalData.byteLength != 0) {
	sgdData = rawData.data() + header.dataFormatDescriptor.byteOffset;
	sgdSize = header.dataFormatDescriptor.byteLength;
	}
	}

	// -------------------------------------------------------------------------------------------------

	struct CompareResult {
	bool match = true;
	float difference = 0.f;
	std::size_t elementIndex = 0;
	std::size_t byteOffset = 0;
	};

	CompareResult compareUnorm8(const char* rawLhs, const char* rawRhs, std::size_t rawSize, float tolerance) {
	const auto* lhs = reinterpret_cast<const uint8_t*>(rawLhs);
	const auto* rhs = reinterpret_cast<const uint8_t*>(rawRhs);
	const auto element_size = sizeof(uint8_t);
	const auto count = rawSize / element_size;

	for (std::size_t i = 0; i < count; ++i) {
	const auto diff = std::abs(static_cast<float>(lhs[i]) / 255.f - static_cast<float>(rhs[i]) / 255.f);
	if (diff > tolerance)
	return CompareResult{false, diff, i, i * element_size};
	}

	return CompareResult{};
	}

	CompareResult compareSFloat32(const char* rawLhs, const char* rawRhs, std::size_t rawSize, float tolerance) {
	const auto* lhs = reinterpret_cast<const float*>(rawLhs);
	const auto* rhs = reinterpret_cast<const float*>(rawRhs);
	const auto element_size = sizeof(float);
	const auto count = rawSize / element_size;

	for (std::size_t i = 0; i < count; ++i) {
	const auto diff = std::abs(lhs[i] - rhs[i]);
	if (diff > tolerance)
	return CompareResult{false, diff, i, i * element_size};
	}

	return CompareResult{};
	}

	auto decodeASTC(const char* compressedData, std::size_t compressedSize, uint32_t width, uint32_t height,
	const std::string& filepath, bool isFormatSRGB, uint32_t blockSizeX, uint32_t blockSizeY, uint32_t blockSizeZ) {

	const auto threadCount = 1u;
	static constexpr astcenc_swizzle swizzle{ASTCENC_SWZ_R, ASTCENC_SWZ_G, ASTCENC_SWZ_B, ASTCENC_SWZ_A};

	astcenc_error ec = ASTCENC_SUCCESS;

	const astcenc_profile profile = isFormatSRGB ? ASTCENC_PRF_LDR_SRGB : ASTCENC_PRF_LDR;
	astcenc_config config{};
	ec = astcenc_config_init(profile, blockSizeX, blockSizeY, blockSizeZ, ASTCENC_PRE_MEDIUM, ASTCENC_FLG_DECOMPRESS_ONLY, &config);
	if (ec != ASTCENC_SUCCESS)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_config_init: {}\n", filepath, astcenc_get_error_string(ec));

	struct ASTCencStruct {
	astcenc_context* context = nullptr;
	~ASTCencStruct() {
	astcenc_context_free(context);
	}
	} astcenc;
	astcenc_context*& context = astcenc.context;

	ec = astcenc_context_alloc(&config, threadCount, &context);
	if (ec != ASTCENC_SUCCESS)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_context_alloc: {}\n", filepath, astcenc_get_error_string(ec));

	astcenc_image image{};
	image.dim_x = width;
	image.dim_y = height;
	image.dim_z = 1; // 3D ASTC formats are currently not supported
	const auto uncompressedSize = width * height * 4 * sizeof(uint8_t);
	auto uncompressedBuffer = std::make_unique<uint8_t[]>(uncompressedSize);
	auto* bufferPtr = uncompressedBuffer.get();
	image.data = reinterpret_cast<void**>(&bufferPtr);
	image.data_type = ASTCENC_TYPE_U8;

	ec = astcenc_decompress_image(context, reinterpret_cast<const uint8_t*>(compressedData), compressedSize, &image, &swizzle, 0);
	if (ec != ASTCENC_SUCCESS)
	error(EXIT_CODE_ERROR, "ktxdiff error \"{}\": astcenc_decompress_image: {}\n", filepath, astcenc_get_error_string(ec));

	astcenc_decompress_reset(context);

	struct Result {
	std::unique_ptr<uint8_t[]> data;
	std::size_t size;
	};
	return Result{std::move(uncompressedBuffer), uncompressedSize};
	}

	CompareResult compareAstc(const char* lhs, const char* rhs, std::size_t size, uint32_t width, uint32_t height,
	const std::string& filepathLhs, const std::string& filepathRhs,
	bool isFormatSRGB, uint32_t blockSizeX, uint32_t blockSizeY, uint32_t blockSizeZ,
	float tolerance) {
	const auto uncompressedLhs = decodeASTC(lhs, size, width, height, filepathLhs, isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ);
	const auto uncompressedRhs = decodeASTC(rhs, size, width, height, filepathRhs, isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ);

	return compareUnorm8(
	reinterpret_cast<const char*>(uncompressedLhs.data.get()),
	reinterpret_cast<const char*>(uncompressedRhs.data.get()),
	uncompressedLhs.size,
	tolerance);
	}

	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;

	for (uint32_t levelIndex = 0; levelIndex < lhs->numLevels; ++levelIndex) {
	const auto imageSize = ktxTexture_GetImageSize(ktxTexture(lhs.handle), levelIndex);
	const auto imageWidth = std::max(1u, lhs->baseWidth >> levelIndex);
	const auto imageHeight = std::max(1u, lhs->baseHeight >> levelIndex);
	const auto imageDepth = std::max(1u, lhs->baseDepth >> levelIndex);

	for (uint32_t faceIndex = 0; faceIndex < lhs->numFaces; ++faceIndex) {
	for (uint32_t layerIndex = 0; layerIndex < lhs->numLayers; ++layerIndex) {
	for (uint32_t depthIndex = 0; depthIndex < ceil_div(imageDepth, blockSizeZ); ++depthIndex) {

	ktx_size_t imageOffset;
	ktxTexture2_GetImageOffset(lhs.handle, levelIndex, layerIndex, faceIndex + depthIndex, &imageOffset);
	const char* imageDataLhs = reinterpret_cast<const char*>(lhs->pData) + imageOffset;
	const char* imageDataRhs = reinterpret_cast<const char*>(rhs->pData) + imageOffset;

	CompareResult result;
	if (lhs.transcoded \|\| isFormatUNORM8) {
	result = compareUnorm8(imageDataLhs, imageDataRhs, imageSize, tolerance);
	} else if (isFormatAstc(vkFormat)) {
	result = compareAstc(imageDataLhs, imageDataRhs, imageSize, imageWidth, imageHeight,
	lhs.filepath, rhs.filepath,
	isFormatSRGB, blockSizeX, blockSizeY, blockSizeZ,
	tolerance);
	} else if (isFormatSFloat32) {
	result = compareSFloat32(imageDataLhs, imageDataRhs, imageSize, tolerance);
	} else {
	for (std::size_t i = 0; i < imageSize; ++i) {
	if (imageDataLhs[i] != imageDataRhs[i])
	return mismatch("Mismatching image data: level {}, face {}, layer {}, depth {}, image byte {}",
	levelIndex, faceIndex, layerIndex, depthIndex, i);
	}
	}

	if (!result.match) {
	return mismatch("Mismatching image data (diff: {}): level {}, face {}, layer {}, depth {}, pixel {}, component {}",
	result.difference, levelIndex, faceIndex, layerIndex, depthIndex,
	result.elementIndex / componentCount, result.elementIndex % componentCount);
	}
	}
	}
	}
	}

	return true;
	}

	/// EXIT CODES:
	/// 0 - Matching files
	/// 1 - Mismatching files
	/// 2 - Error while loading, decoding or processing an input file
	int main(int argc, char* argv[]) {
	InitUTF8CLI(argc, argv);

	if (argc < 3) {
	fmt::print("Missing input file arguments\n");
	fmt::print("Usage: ktxdiff <expected-ktx2> <received-ktx2> [tolerance]\n");
	return EXIT_FAILURE;
	}

	const float tolerance = argc > 3 ? std::stof(argv[3]) : 0.05f;

	Texture lhs(argv[1]);
	Texture rhs(argv[2]);
	const auto match = compare(lhs, rhs, tolerance);

	return match ? 0 : 1;
	}