JsonStreamer Class Reference

Inheritance diagram for JsonStreamer:

Public Member Functions
	JsonStreamer (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< JsonStreamer, 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< JsonStreamer, HvtStreamingContext, HvtHandleType::CONTEXT >
static JsonStreamer *	check (HvtStreamingContext hvtHandle)
static JsonStreamer *	check (HvtStreamingContext hvtHandle)
static JsonStreamer *	check (HvtStreamingContext hvtHandle)
static JsonStreamer *	check (HvtStreamingContext hvtHandle)
static JsonStreamer *	opt_check (HvtStreamingContext hvtHandle)
static JsonStreamer *	opt_check (HvtStreamingContext hvtHandle)
static JsonStreamer *	opt_check (HvtStreamingContext hvtHandle)
static JsonStreamer *	opt_check (HvtStreamingContext hvtHandle)
Static Public Attributes inherited from Handle< JsonStreamer, HvtStreamingContext, HvtHandleType::CONTEXT >
static constexpr HvtHandleType	staticType

Detailed Description

Definition at line 81 of file JsonStreamer.h.

Constructor & Destructor Documentation

JsonStreamer()

JsonStreamer::JsonStreamer

(

std::span< const uint8_t, VK_UUID_SIZE >

uuid

)

Definition at line 66 of file JsonStreamer.cpp.

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

~JsonStreamer()

JsonStreamer::~JsonStreamer

(

)

Definition at line 576 of file JsonStreamer.cpp.

                            {
  stopStreaming();
}

Member Function Documentation

acquireStreamsFrames()

void JsonStreamer::acquireStreamsFrames

(

const HvtAcquireStreamFramesInfo &

infos

)

Definition at line 526 of file JsonStreamer.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 JsonStreamer::destroySemaphore

(

Semaphore *

sem

)

const

Definition at line 507 of file JsonStreamer.cpp.

                                                        {
  delete sem;
}

enumerateStreamsParameters()

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

Definition at line 338 of file JsonStreamer.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 * JsonStreamer::importSemaphore

(

const HvtSemaphoreExportInfo &

exportInfos

)

Definition at line 475 of file JsonStreamer.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 JsonStreamer::importStreamImages

(

const HvtStreamImagesExportInfo &

exportInfos

)

Definition at line 367 of file JsonStreamer.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 JsonStreamer::releaseStreamsFrames

(

Semaphore *

waitSem

)

Definition at line 555 of file JsonStreamer.cpp.

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

startStreaming()

void JsonStreamer::startStreaming

(

)

Definition at line 511 of file JsonStreamer.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 JsonStreamer::stopStreaming

(

)

Definition at line 569 of file JsonStreamer.cpp.

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

---

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

• JsonStreamer.h
• JsonStreamer.cpp