Method validateLevelIndex

tools/ktx/validate.cpp:648–736

}

void ValidationContext::validateLevelIndex() {
    levelIndices.resize(numLevels);

    const auto levelIndexOffset = sizeof(KTX_header2);
    const auto levelIndexSize = sizeof(ktxLevelIndexEntry) * numLevels;
    read(levelIndexOffset, levelIndices.data(), levelIndexSize, "the level index");

    const auto blockByteLength = (expectedBytePlanes ? expectedBytePlanes->at(0) : (parsedBlockByteLength == 0 ? uint8_t(1) : parsedBlockByteLength.value_or(0)));
    std::size_t requiredLevelAlignment = calcLevelAlignment(ktxSupercmpScheme(header.supercompressionScheme), blockByteLength);

    std::size_t expectedFirstLevelOffset = 0;
    if (header.supercompressionGlobalData.byteLength != 0)
        expectedFirstLevelOffset = header.supercompressionGlobalData.byteLength + header.supercompressionGlobalData.byteOffset;
    else if (header.keyValueData.byteLength != 0)
        expectedFirstLevelOffset = header.keyValueData.byteLength + header.keyValueData.byteOffset;
    else if (header.dataFormatDescriptor.byteLength != 0)
        expectedFirstLevelOffset = header.dataFormatDescriptor.byteLength + header.dataFormatDescriptor.byteOffset;
    else
        expectedFirstLevelOffset = levelIndexOffset + levelIndexSize;
    expectedFirstLevelOffset = align(expectedFirstLevelOffset, requiredLevelAlignment);

    // The first (largest) mip level is the first in the index and the last in the file.
    for (std::size_t i = 1; i < levelIndices.size(); ++i) {
        if (levelIndices[i].uncompressedByteLength > levelIndices[i - 1].uncompressedByteLength)
            error(LevelIndex::IncorrectIndexOrder, i - 1, levelIndices[i - 1].uncompressedByteLength, i, levelIndices[i].uncompressedByteLength);

        if (levelIndices[i].byteOffset > levelIndices[i - 1].byteOffset)
            error(LevelIndex::IncorrectLevelOrder, i - 1, levelIndices[i - 1].byteOffset, i, levelIndices[i].byteOffset);
    }

    std::size_t lastByteOffset = expectedFirstLevelOffset; // Reuse lastByteOffset to inject first offset to expectedOffset
    std::size_t lastByteLength = 0;

    // Count down, so we can check the distance between levels for the UNDEFINED and SUPERCOMPRESSION cases.
    for (auto it = static_cast<uint32_t>(levelIndices.size()); it != 0; --it) {
        const auto index = it - 1;
        const auto& level = levelIndices[index];

        // Validate byteOffset
        const auto knownLevelOffset = header.vkFormat != VK_FORMAT_UNDEFINED &&
                header.supercompressionScheme == KTX_SS_NONE;
        // If the exact level sizes are unknown we have to trust the byteLengths.
        // In that case we know where the first level must be in the file, and we can calculate
        // the offsets by progressively summing the lengths and paddings so far.
        const auto expectedOffset = knownLevelOffset ?
                calcLevelOffset(expectedFirstLevelOffset, requiredLevelAlignment, index) :
                align(lastByteOffset + lastByteLength, requiredLevelAlignment);

        if (level.byteOffset % requiredLevelAlignment != 0)
            error(LevelIndex::IncorrectByteOffsetUnaligned, index, level.byteOffset, requiredLevelAlignment, expectedOffset);
        else if (level.byteOffset != expectedOffset)
            error(LevelIndex::IncorrectByteOffset, index, level.byteOffset, expectedOffset);

        // Workaround: Disable ByteLength validations for the 3D ASTC encoder which currently ignores partial Z blocks in our test files
        const auto disableByteLengthValidation = isFormat3DBlockCompressed(VkFormat(header.vkFormat))
                && header.pixelDepth % (expectedBlockDimension2.value_or(0) + 1) != 0;

        if (!disableByteLengthValidation) {