Method load

src/imageio/DdsImageLoader.cpp:155–269

}

Task<vector<ImageData>> DdsImageLoader::load(istream& iStream, const fs::path&, string_view, const ImageLoaderSettings&, int priority) const {
    iStream.seekg(0, iStream.end);
    const size_t dataSize = iStream.tellg();
    if (dataSize < 4) {
        throw FormatNotSupported{"File is too small."};
    }

    iStream.clear();
    iStream.seekg(0);

    HeapArray<char> data{dataSize};
    iStream.read(data.data(), 4);
    if (data[0] != 'D' || data[1] != 'D' || data[2] != 'S' || data[3] != ' ') {
        throw FormatNotSupported{"File is not a DDS file."};
    }

    iStream.read(data.data() + 4, dataSize - 4);

    // COM must be initialized on the thread executing the following DirectX calls. Thus: when editing this file *make sure* that no
    // co_await calls are made before the last DirectX call! Note that it is not a problem that CoInitializeEx will potentially get called
    // multiple times across different threads, or even multiple times by the same thread pool thread. Both situations are explicitly
    // allowed (and in the latter case, the return value is S_FALSE). See
    // https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-coinitializeex
    if (const auto res = CoInitializeEx(nullptr, COINIT_MULTITHREADED); res != S_OK && res != S_FALSE) {
        throw ImageLoadError{"Failed to initialize COM."};
    }

    // The correct way to clean up would be to call CoUninitialize() on every task pool thread on shutdown. Using a scope guard here
    // wouldn't work for multiple reasons: (i) the coroutine might have been scheduled to another thread once the scope ends, and (ii) it
    // would be wasteful to repeatedly initialize and uninitialize COM for every loaded image. Instead, we'll just accept that COM won't be
    // gracefully cleaned up on shutdown -- we don't care much about its cleanup anyway, which involved mostly handling of pending messages
    // in the application's message queue.
    // const auto comScopeGuard = ScopeGuard{[]() { CoUninitialize(); }};

    DirectX::ScratchImage scratchImage;
    DirectX::TexMetadata metadata;
    if (DirectX::LoadFromDDSMemory(data.data(), dataSize, DirectX::DDS_FLAGS_NONE, &metadata, scratchImage) != S_OK) {
        throw ImageLoadError{"Failed to read DDS file."};
    }

    DXGI_FORMAT format;
    const size_t numChannels = getDxgiChannelCount(metadata.format);
    switch (numChannels) {
        case 4: format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
        case 3: format = DXGI_FORMAT_R32G32B32_FLOAT; break;
        case 2: format = DXGI_FORMAT_R32G32_FLOAT; break;
        case 1: format = DXGI_FORMAT_R32_FLOAT; break;
        default: throw ImageLoadError{fmt::format("Unsupported DXGI format: {}", static_cast<int>(metadata.format))};
    }

    // Use DirectXTex to either decompress or convert to the target floating point format.
    if (DirectX::IsCompressed(metadata.format)) {
        DirectX::ScratchImage decompImage;
        if (DirectX::Decompress(*scratchImage.GetImage(0, 0, 0), format, decompImage) != S_OK) {
            throw ImageLoadError{"Failed to decompress DDS image."};
        }

        swap(scratchImage, decompImage);