opencvStreamer Class Reference

Inheritance diagram for opencvStreamer:

Public Member Functions
	opencvStreamer (std::span< const uint8_t, VK_UUID_SIZE > uuid)
void	enumerateStreamsParameters (uint32_t *streamsCount, HvtRGBDStreamParameters *parameters) const
void	importStreamImages (const HvtStreamImagesExportInfo &exportInfos)
Semaphore *	importSemaphore (const HvtSemaphoreExportInfo &exportInfos)
void	destroySemaphore (Semaphore *sem) const
void	startStreaming ()
void	acquireStreamsFrames (const HvtAcquireStreamFramesInfo &infos)
void	releaseStreamsFrames (Semaphore *waitSem)
void	stopStreaming ()
Public Member Functions inherited from Handle< opencvStreamer, HvtStreamingContext, HvtHandleType::CONTEXT >
HvtStreamingContext	to_handle ()
HvtStreamingContext	to_handle ()
HvtStreamingContext	to_handle ()
HvtStreamingContext	to_handle ()

Additional Inherited Members
Static Public Member Functions inherited from Handle< opencvStreamer, HvtStreamingContext, HvtHandleType::CONTEXT >
static opencvStreamer *	check (HvtStreamingContext hvtHandle)
static opencvStreamer *	check (HvtStreamingContext hvtHandle)
static opencvStreamer *	check (HvtStreamingContext hvtHandle)
static opencvStreamer *	check (HvtStreamingContext hvtHandle)
static opencvStreamer *	opt_check (HvtStreamingContext hvtHandle)
static opencvStreamer *	opt_check (HvtStreamingContext hvtHandle)
static opencvStreamer *	opt_check (HvtStreamingContext hvtHandle)
static opencvStreamer *	opt_check (HvtStreamingContext hvtHandle)
Static Public Attributes inherited from Handle< opencvStreamer, HvtStreamingContext, HvtHandleType::CONTEXT >
static constexpr HvtHandleType	staticType

Detailed Description

Definition at line 88 of file opencvStreamer.h.

Constructor & Destructor Documentation

opencvStreamer()

opencvStreamer::opencvStreamer

(

std::span< const uint8_t, VK_UUID_SIZE >

uuid

)

Definition at line 74 of file opencvStreamer.cpp.

    {
        initSettings();
        initVk(uuid);
        initVkResources();
    }

~opencvStreamer()

opencvStreamer::~opencvStreamer

(

)

Definition at line 596 of file opencvStreamer.cpp.

                                    {
        stopStreaming();
    }

Member Function Documentation

acquireStreamsFrames()

void opencvStreamer::acquireStreamsFrames

(

const HvtAcquireStreamFramesInfo &

infos

)

Definition at line 546 of file opencvStreamer.cpp.

                                                                                      {
        if (infos.frameInfoCount != readStreams.size()) {
            throw HvtResult::HVT_ERROR_WRONG_BUFFER_SIZE;
        }
 
        swapPendingToReading();
 
        auto imageIndex = slotReadingIndex;
 
        for (int i = 0; i < infos.frameInfoCount; i++) {
            auto& stream = readStreams.at(i);
            auto& desc = infos.pStreamFrameInfos[i];
            desc.extrinsics = stream.extrinsics;
            desc.intrinsics = stream.intrinsics;
            desc.imageIndex = imageIndex;
        }
 
        if (infos.signalSemaphore) {
            auto sem = Semaphore::check(infos.signalSemaphore);
            std::scoped_lock l(queueMutex);
            syncQueue.submit(
                vk::SubmitInfo(
                    {},
                    {},
                    {},
                    *sem->sem));
        }
    }

destroySemaphore()

void opencvStreamer::destroySemaphore

(

Semaphore *

sem

)

const

Definition at line 527 of file opencvStreamer.cpp.

                                                               {
        delete sem;
    }

enumerateStreamsParameters()

void opencvStreamer::enumerateStreamsParameters	(	uint32_t *	streamsCount,
		HvtRGBDStreamParameters *	parameters
	)		const

Definition at line 358 of file opencvStreamer.cpp.

                                                                                                                     {
        if (!parameters) {
            *streamsCount = readStreams.size();
            return;
        }
 
        if (*streamsCount != readStreams.size()) {
            throw HvtResult::HVT_ERROR_WRONG_BUFFER_SIZE;
        }
 
        for (int i = 0; const auto & readStream : readStreams) {
            parameters[i] = HvtRGBDStreamParameters{
              .colorResolution = {(uint32_t)readStream.resolution.x, (uint32_t)readStream.resolution.y},
              .depthResolution = {(uint32_t)readStream.resolution.x, (uint32_t)readStream.resolution.y},
 
              .nearDepth = readStream.anear,
              .farDepth = readStream.afar,
 
              .colorFormat = (HvtImageFormat)readStream.colorFormat,
              .depthFormat = (HvtImageFormat)readStream.depthFormat,
 
              .slotCount = numSlots,
              .projectionType = readStream.projectionType
            };
            snprintf(parameters->name, HVT_MAX_STREAM_NAME_LENGHT, "%s", config->InputCameraNames.at(i).c_str());
            i++;
        }
    }

importSemaphore()

Semaphore * opencvStreamer::importSemaphore

(

const HvtSemaphoreExportInfo &

exportInfos

)

Definition at line 495 of file opencvStreamer.cpp.

                                                                                        {
#ifdef WIN32
        if ((vk::ExternalSemaphoreHandleTypeFlagBits)exportInfos.type != vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) {
#else
        if ((vk::ExternalSemaphoreHandleTypeFlagBits)exportInfos.type != vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) {
#endif
            throw HvtResult::HVT_ERROR_UNSUPPORTED_SEMAPHORE_TYPE;
        }
 
        auto sem = device->createSemaphoreUnique({});
#ifdef WIN32
        device->importSemaphoreWin32HandleKHR(
            vk::ImportSemaphoreWin32HandleInfoKHR(
                *sem,
                {},
                vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32,
                exportInfos.semaphore
            ));
#else
        device->importSemaphoreFdKHR(
            vk::ImportSemaphoreFdInfoKHR(
                *sem,
                {},
                vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
                exportInfos.semaphore
            ));
#endif
        return new Semaphore{
          .sem = std::move(sem)
        };
    }

importStreamImages()

void opencvStreamer::importStreamImages

(

const HvtStreamImagesExportInfo &

exportInfos

)

Definition at line 387 of file opencvStreamer.cpp.

                                                                                        {
        auto memtype = (vk::ExternalMemoryHandleTypeFlagBits)exportInfos.memoryType;
 
#ifdef WIN32
        if (memtype != vk::ExternalMemoryHandleTypeFlagBits::eOpaqueWin32)
#else 
        if (memtype != vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
#endif
        {
            throw HvtResult::HVT_ERROR_UNSUPPORTED_MEMORY_TYPE;
        }
 
        auto isDepth = (bool)exportInfos.depth;
        auto& stream = readStreams.at(exportInfos.streamIndex);
        auto format = isDepth ? stream.depthFormat : stream.colorFormat;
        auto& slots = isDepth ? stream.depthSlots : stream.colorSlots;
 
        if (exportInfos.imagesCount != numSlots) {
            throw HvtResult::HVT_ERROR_WRONG_BUFFER_SIZE;
        }
 
        vk::ImageCreateInfo imgCreateInfo(
            {}, //Flags,
            vk::ImageType::e2D,
            format,
            vk::Extent3D(stream.resolution.x, stream.resolution.y, 1),
            1, //Mip count,
            1, //Array layers,
            vk::SampleCountFlagBits::e1,
            vk::ImageTiling::eOptimal,
            vk::ImageUsageFlagBits::eTransferDst,
            vk::SharingMode::eExclusive,
            {}, //Queue families
            vk::ImageLayout::eUndefined
        );
 
        for (int i = 0; i < numSlots; i++) {
            auto memoryInfos = exportInfos.pImages[i];
 
            auto imgImportInfo = vk::ExternalMemoryImageCreateInfo(memtype);
            auto createChain = vk::StructureChain(imgCreateInfo, imgImportInfo);
 
            auto image = device->createImageUnique(createChain.get<vk::ImageCreateInfo>());
            auto reqs = device->getImageMemoryRequirements(*image);
 
            auto memIndex = findMemoryType(reqs.memoryTypeBits, vk::MemoryPropertyFlagBits::eDeviceLocal);
 
            assert(reqs.size == memoryInfos.size);
            assert(reqs.alignment == memoryInfos.alignment);
 
            auto memoryAllocInfo = vk::StructureChain(
                vk::MemoryAllocateInfo(reqs.size, memIndex),
#ifdef WIN32
                vk::ImportMemoryWin32HandleInfoKHR(memtype, memoryInfos.handle)
#else
                vk::ImportMemoryFdInfoKHR(memtype, memoryInfos.handle)
#endif
            );
 
            auto memory = device->allocateMemoryUnique(memoryAllocInfo.get<vk::MemoryAllocateInfo>());
 
            device->bindImageMemory(*image, *memory, 0);
 
            // Transition images to their unique layout
            oneTimeSubmit([&](vk::CommandBuffer& cmd) {
                vk::ImageMemoryBarrier colorMemoryBarrier(
                    {},
                    vk::AccessFlagBits::eTransferWrite,
                    vk::ImageLayout::eUndefined, //Don't care about what was there previously
                    vk::ImageLayout::eTransferDstOptimal,
                    VK_QUEUE_FAMILY_IGNORED, // No queue ownership transfer
                    VK_QUEUE_FAMILY_IGNORED,
                    *image,
                    vk::ImageSubresourceRange(
                        vk::ImageAspectFlagBits::ePlane0 | vk::ImageAspectFlagBits::ePlane1 | vk::ImageAspectFlagBits::ePlane2,
                        0, 1,
                        0, 1));
 
                vk::ImageMemoryBarrier depthMemoryBarrier(
                    {},
                    vk::AccessFlagBits::eTransferWrite,
                    vk::ImageLayout::eUndefined,
                    vk::ImageLayout::eTransferDstOptimal,
                    VK_QUEUE_FAMILY_IGNORED,
                    VK_QUEUE_FAMILY_IGNORED,
                    *image,
                    vk::ImageSubresourceRange(
                        vk::ImageAspectFlagBits::eColor,
                        0, 1,
                        0, 1));
 
                cmd.pipelineBarrier(
                    vk::PipelineStageFlagBits::eTransfer,
                    vk::PipelineStageFlagBits::eTransfer,
                    vk::DependencyFlagBits::eByRegion,
                    {},
                    {},
                    isDepth ? depthMemoryBarrier : colorMemoryBarrier);
                });
 
            slots.at(i) = ImageSlot{
              .image = std::move(image),
              .memory = std::move(memory)
            };
        }
        (isDepth ? stream.importedDepth : stream.importedColor) = true;
    }

releaseStreamsFrames()

void opencvStreamer::releaseStreamsFrames

(

Semaphore *

waitSem

)

Definition at line 575 of file opencvStreamer.cpp.

                                                                 {
        std::scoped_lock l(queueMutex);
 
        if (waitSem) {
            vk::PipelineStageFlags stage = vk::PipelineStageFlagBits::eTopOfPipe;
            syncQueue.submit(
                vk::SubmitInfo(
                    *waitSem->sem,
                    stage,
                    {},
                    {}));
        }
    }

startStreaming()

void opencvStreamer::startStreaming

(

)

Definition at line 531 of file opencvStreamer.cpp.

                                        {
        //assert that we have everything ready for streaming
        for (auto& stream : readStreams) {
            if (!stream.importedColor || !stream.importedDepth) {
                throw HvtResult::HVT_ERROR_CALL_ORDER;
            }
        }
 
        // Start worker
        running = true;
        streamingThread = std::thread([&] {
            streamingLoop();
            });
    }

stopStreaming()

void opencvStreamer::stopStreaming

(

)

Definition at line 589 of file opencvStreamer.cpp.

                                       {
        running = false;
        if (streamingThread.joinable()) {
            streamingThread.join();
        }
    }

---

The documentation for this class was generated from the following files:

• opencvStreamer.h
• opencvStreamer.cpp