Image Manager/Cvb++/CppUserAllocatedMemory

This example program is located in your CVB installation under %CVB%Tutorial/Image Manager/Cvb++/CppUserAllocatedMemory.

main.cpp:

// Demonstrates how to pass user-allocated memory as the target buffer(s) for image acquisition from a
// camera. This option is useful if, for example, the image data buffers need to satisfy extraordinary
// conditions like e.g. address alignment (if extensions like SSE or AVX are going to be used on the
// data) or a particular block of memory (if the image is to be used by a GPU, see the CppCudaMemory
// example for this).
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
#include <cvb/composite.hpp>
#include <cvb/device_factory.hpp>
#include <cvb/driver/driver.hpp>
#include <cvb/driver/image_stream.hpp>
#include <cvb/global.hpp>
#include <cvb/image.hpp>
#include <cvb/utilities/utilities.hpp>
 
static const constexpr auto TIMEOUT = std::chrono::milliseconds(3000);
static const constexpr int NUM_ELEMENTS_TO_ACQUIRE = 10;
static const constexpr int NUM_BUFFERS = 4;
 
namespace helper {
// An alternative of std::aligned_alloc that is available in C++17.
static inline void *aligned_alloc(size_t alignment, size_t size) noexcept {
#ifdef _MSC_VER
  return _aligned_malloc(size, alignment);
#else
  void *memptr = nullptr;
  return !posix_memalign(&memptr, alignment, size)
             ? memptr
             : nullptr; // posix_memalign returns 0 on success.
#endif
}
 
// An alternative of std::free that is available in C++17.
static inline void free(void *ptr) noexcept {
#ifdef _MSC_VER
  _aligned_free(ptr);
#else
  free(ptr);
#endif
}
 
/* FlowSetPool does not store the FlowSets for further
 * use, therefore we create a subclass to release the
 * buffer later
 */
class UserFlowSetPool final : public Cvb::Driver::FlowSetPool {
 
  using UserFlowSetPoolPtr = std::shared_ptr<UserFlowSetPool>;
 
public:
  UserFlowSetPool(const std::vector<Cvb::FlowInfo> &flowInfo) noexcept
      : Cvb::FlowSetPool(flowInfo, Cvb::FlowSetPool::ProtectedTag{}) {}
 
  virtual ~UserFlowSetPool() {
    for (auto &flowSet : *this)
      for (auto &flow : flowSet)
        helper::free(flow.Buffer);
  }
 
  static UserFlowSetPoolPtr
  Create(const std::vector<Cvb::FlowInfo> &flowInfos) {
    return std::make_shared<UserFlowSetPool>(flowInfos);
  }
};
 
} // namespace helper
 
void AcquireData(const Cvb::CompositeStreamPtr &stream) {
  for (auto i = 0; i < NUM_ELEMENTS_TO_ACQUIRE; i++) {
    auto [composite, waitStatus, enumerator] = stream->WaitFor(TIMEOUT);
    switch (waitStatus) {
    default:
      std::cout << "wait status unknown.\n";
    case Cvb::WaitStatus::Abort:
    case Cvb::WaitStatus::Timeout: {
      std::cout << "wait status not ok\n";
      continue;
    }
    case Cvb::WaitStatus::Ok: {
      break;
    }
    }
 
    // assume the composites first element is an image
    auto firstElement = composite->ItemAt(0);
 
    if (!Cvb::holds_alternative<Cvb::ImagePtr>(firstElement)) {
      std::cout << "composite does not contain an image at the first element\n";
      continue;
    }
 
    auto image = Cvb::get<Cvb::ImagePtr>(firstElement);
    auto linearAccess = image->Plane(0).LinearAccess();
    std::cout << "acquired image: " << i << " at memory location: "
              << reinterpret_cast<intptr_t>(linearAccess.BasePtr()) << "\n";
  }
}
 
int main() {
  try {
    // discover transport layers
    auto infoList =
        Cvb::DeviceFactory::Discover(Cvb::DiscoverFlags::IgnoreVins);
 
    // can't continue the demo if there's no available device
    if (infoList.empty())
      throw std::runtime_error(
          "There is no available device for this demonstration.");
 
    // instantiate the first device in the discovered list
    auto device = Cvb::DeviceFactory::Open<Cvb::GenICamDevice>(
        infoList[0].AccessToken(), Cvb::AcquisitionStack::GenTL);
 
    if (device->StreamCount() == 0)
      throw std::runtime_error(
          "There is no available stream for this demonstration.");
 
    // get the first stream
    auto stream = device->Stream<Cvb::CompositeStream>(0);
 
    // get the flow set information that is needed for the current stream
    auto flowSetInfo = stream->FlowSetInfo();
 
    // create a subclass of FlowSetPool to store the created buffer
    auto flowSetPoolPtr = helper::UserFlowSetPool::Create(flowSetInfo);
 
    std::generate_n(
        std::back_inserter(*flowSetPoolPtr), NUM_BUFFERS, [&flowSetInfo]() {
          auto flows = std::vector<void *>(flowSetInfo.size());
          std::transform(
              flowSetInfo.begin(), flowSetInfo.end(), flows.begin(),
              [](Cvb::Driver::FlowInfo info) {
                void *memptr = helper::aligned_alloc(info.Alignment, info.Size);
                if (!memptr)
                  throw std::runtime_error("Failed to allocate a memory.");
                return memptr;
              });
          return flows;
        });
 
    // register the user flow set pool
    stream->RegisterExternalFlowSetPool(std::move(flowSetPoolPtr));
 
    // start the data acquisition for that stream
    stream->EngineStart();
    stream->DeviceStart();
 
    AcquireData(stream);
 
    stream->DeviceAbort();
    stream->EngineAbort();
 
    // deregister the user flow set pool to get free buffer (releaseCallback)
    stream->DeregisterFlowSetPool();
  } catch (const std::exception &e) {
    std::cout << e.what() << std::endl;
  }
 
  return 0;
}