DynamicInputProvider.h

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
 
 
#pragma once
#include <string>
 
#include "InputProvider.h"
#include "HvtStreamingAPI.h"
#include "VulkanWrapper.h"
 
 
class DynamicInputProvider : public InputProvider
{
#ifdef WIN32
    static constexpr auto memory_handle_type = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueWin32;
    static constexpr auto semaphore_handle_type = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32;
    #else
    static constexpr auto memory_handle_type = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
    static constexpr auto semaphore_handle_type = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd;
#endif
    static constexpr auto inFlightSync = 3;
  public:
    DynamicInputProvider(const std::string& libraryPath, VulkanWrapper& vkw);
 
    std::vector<StreamParameters> enumerateStreamsParameters() const override;
    std::vector<StreamImage> enumerateStreamImages(uint32_t streamIndex, bool depth) const override;
    void acquireStreamsFrames(const Extrinsics& targetViewExtrinsics, std::span<StreamFrameInfo> outFrameInfos) override;
    void releaseStreamsFrames() override;
 
    ~DynamicInputProvider();
  private:
 
    void loadLibrary(const std::string& libraryPath);
    void init();
    void initStreams();
    void initSynchronisation();
 
    struct Library{
        PFN_hvtCreateStreamingContext createStreamingContext;
        PFN_hvtEnumerateStreamsParameters enumerateStreamsParameters;
        PFN_hvtExportStreamImages exportStreamImages;
        PFN_hvtExportSemaphore exportSemaphore;
        PFN_hvtAcquireStreamsFrames acquireStreamsFrames;
        PFN_hvtReleaseStreamsFrames releaseStreamsFrames;
        PFN_hvtStartStreaming startStreaming;
        PFN_hvtStopStreaming stopStreaming;
        PFN_hvtDestroySemaphore destroySemaphore;
        PFN_hvtDestroyStreamingContext destroyStreamingContext;
    };
 
    struct ImageSlot{
        vk::UniqueImage image;
        vk::UniqueDeviceMemory memory;
        vk::MemoryRequirements memoryRequirements;
        vk::UniqueImageView imageView;
    };
 
    struct Stream{
        std::vector<ImageSlot> colorSlots;
        std::vector<ImageSlot> depthSlots;
        std::vector<StreamImage> colorImages;
        std::vector<StreamImage> depthImages;
        vk::UniqueSamplerYcbcrConversion ycbcrConversion;
        vk::UniqueSampler colorSampler;
        vk::UniqueSampler depthSampler;
    };
 
    struct SyncInfo{
        vk::UniqueSemaphore acquireSemaphore;
        vk::UniqueSemaphore releaseSempahore;
        HvtSemaphore acquireHvt;
        HvtSemaphore releaseHvt;
    };
 
    std::array<SyncInfo, inFlightSync> syncInfos;
    int currentSyncSlot = 0;
 
    VulkanWrapper& vkw;
    vk::UniqueCommandPool commandPool;
    HvtStreamingContext context;
    std::vector<Stream> streamStorage;
    std::vector<StreamParameters> cachedStreamParameters;
    Library hvt;
};