Method compareDFD

tools/ktx/command_compare.cpp:1531–1676

}

void CommandCompare::compareDFD(PrintDiff& diff, InputStreams& streams) {
    if (options.ignoreDFD == IgnoreDFD::all) return;

    diff.setContext("Data Format Descriptor\n\n");

    std::unique_ptr<uint8_t[]> buffers[] = {
        std::make_unique<uint8_t[]>(headers[0].dataFormatDescriptor.byteLength),
        std::make_unique<uint8_t[]>(headers[1].dataFormatDescriptor.byteLength)
    };

    for (std::size_t i = 0; i < streams.size(); ++i)
        read(streams[i], headers[i].dataFormatDescriptor.byteOffset, buffers[i].get(),
            headers[i].dataFormatDescriptor.byteLength, "the DFD blocks");

    const uint8_t* ptrDFD[] = { buffers[0].get(), buffers[1].get() };
    const uint8_t* ptrDFDEnd[] = {
        ptrDFD[0] + headers[0].dataFormatDescriptor.byteLength,
        ptrDFD[1] + headers[1].dataFormatDescriptor.byteLength,
    };
    const uint8_t* ptrDFDIt[] = { ptrDFD[0], ptrDFD[1] };

    uint32_t dfdTotalSize[2];
    for (std::size_t i = 0; i < streams.size(); ++i) {
        std::memcpy(&dfdTotalSize[i], ptrDFDIt[i], sizeof(uint32_t));
        ptrDFDIt[i] += sizeof(uint32_t);
    }

    if (options.ignoreDFD != IgnoreDFD::all_except_color_space)
        if (dfdTotalSize[0] != dfdTotalSize[1])
            diff << Diff("DFD total bytes", "/dataFormatDescriptor/totalSize", dfdTotalSize[0], dfdTotalSize[1]);

    uint32_t blockIndex = 0;
    while ((ptrDFDIt[0] < ptrDFDEnd[0]) || (ptrDFDIt[1] < ptrDFDEnd[1])) {
        const std::size_t remainingDFDBytes[] = {
            static_cast<std::size_t>(ptrDFDEnd[0] - ptrDFDIt[0]),
            static_cast<std::size_t>(ptrDFDEnd[1] - ptrDFDIt[1]),
        };

        std::optional<DFDHeader> blockHeaders[2] = {};
        if (remainingDFDBytes[0] < sizeof(DFDHeader) && remainingDFDBytes[1] < sizeof(DFDHeader))
            break;

        for (std::size_t i = 0; i < streams.size(); ++i)
            if (remainingDFDBytes[i] >= sizeof(DFDHeader)) {
                DFDHeader blockHeader;
                std::memcpy(&blockHeader, ptrDFDIt[i], sizeof(blockHeader));
                blockHeaders[i] = blockHeader;
            }

        bool dfdKnown[2] = { false, false };
        bool dfdBasic[2] = { false, false };
        for (std::size_t i = 0; i < streams.size(); ++i) {
            if (blockHeaders[i].has_value() &&
                blockHeaders[i]->vendorId == KHR_DF_VENDORID_KHRONOS &&
                blockHeaders[i]->descriptorType == KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT) {
                dfdKnown[i] = dfdBasic[i] = true;
            }
        }