Video I/O Vendor Implementation Guide

1
#pragma once
2
 
3
#include <holoscan/operators/video_io/video_acquisition_operator.hpp>
4
 
5
namespace example {
6
 
7
class ExampleVideoCapture : public holoscan::ops::VideoAcquisitionOperator {
8
 public:
9
  // Required: forward the default and num_streams constructors to the base.
10
  HOLOSCAN_OPERATOR_FORWARD_ARGS_SUPER(ExampleVideoCapture, VideoAcquisitionOperator)
11
 
12
  ExampleVideoCapture() = default;
13
 
14
  explicit ExampleVideoCapture(uint32_t num_streams)
15
      : VideoAcquisitionOperator(num_streams) {}
16
 
17
  // Required if you accept num_streams + Args (the common make_operator pattern).
18
  HOLOSCAN_OPERATOR_FORWARD_TEMPLATE()
19
  explicit ExampleVideoCapture(uint32_t num_streams, ArgT&& arg, ArgsT&&... args)
20
      : VideoAcquisitionOperator(num_streams) {
21
    add_arg(std::forward<ArgT>(arg));
22
    (add_arg(std::forward<ArgsT>(args)), ...);
23
  }
24
 
25
  void setup(OperatorSpec& spec) override;
26
  void start() override;
27
  void compute(InputContext& op_input, OutputContext& op_output,
28
               ExecutionContext& context) override;
29
  void stop() override;
30
 
31
  video_io::VideoCaptureCapabilities query_capture_capabilities() const override;
32
 
33
 private:
34
  // Vendor SDK handle, DMA buffers, etc.
35
  Parameter<uint32_t> dma_buffer_count_;
36
  Parameter<bool> gpudirect_enabled_;
37
 
38
  void* device_handle_ = nullptr;
39
};
40
 
41
}  // namespace example

1
#pragma once
2
 
3
#include <holoscan/operators/video_io/video_transmission_operator.hpp>
4
 
5
namespace example {
6
 
7
class ExampleVideoPlayout : public holoscan::ops::VideoTransmissionOperator {
8
 public:
9
  HOLOSCAN_OPERATOR_FORWARD_ARGS_SUPER(ExampleVideoPlayout, VideoTransmissionOperator)
10
 
11
  ExampleVideoPlayout() = default;
12
 
13
  explicit ExampleVideoPlayout(uint32_t num_streams)
14
      : VideoTransmissionOperator(num_streams) {}
15
 
16
  HOLOSCAN_OPERATOR_FORWARD_TEMPLATE()
17
  explicit ExampleVideoPlayout(uint32_t num_streams, ArgT&& arg, ArgsT&&... args)
18
      : VideoTransmissionOperator(num_streams) {
19
    add_arg(std::forward<ArgT>(arg));
20
    (add_arg(std::forward<ArgsT>(args)), ...);
21
  }
22
 
23
  void setup(OperatorSpec& spec) override;
24
  void start() override;
25
  void compute(InputContext& op_input, OutputContext& op_output,
26
               ExecutionContext& context) override;
27
  void stop() override;
28
 
29
 private:
30
  Parameter<std::string> output_standard_;
31
  void* device_handle_ = nullptr;
32
};
33
 
34
}  // namespace example

1
void ExampleVideoCapture::setup(OperatorSpec& spec) {
2
  // Base registers: output ports (signal, signal_1, ...), uri, width, height,
3
  // frame_rate, pixel_format, color_space, transport, vendor_extensions, etc.
4
  VideoAcquisitionOperator::setup(spec);
5
 
6
  // Vendor-specific parameters
7
  spec.param(dma_buffer_count_,
8
             "dma_buffer_count",
9
             "DMA Buffer Count",
10
             "Number of DMA ring buffers per channel.",
11
             4U);
12
  spec.param(gpudirect_enabled_,
13
             "gpudirect_enabled",
14
             "GPUDirect RDMA",
15
             "Enable GPUDirect RDMA if supported.",
16
             false);
17
}

1
void ExampleVideoPlayout::setup(OperatorSpec& spec) {
2
  VideoTransmissionOperator::setup(spec);
3
 
4
  spec.param(output_standard_,
5
             "output_standard",
6
             "Output Standard",
7
             "Video standard for output (e.g. 1080p60, 2160p30).",
8
             std::string("1080p60"));
9
}

1
void ExampleVideoCapture::start() {
2
  const std::string device_uri = uri_.get();
3
  const uint32_t w = width_.get();
4
  const uint32_t h = height_.get();
5
  const float fps = frame_rate_.get();
6
  const uint32_t buf_count = dma_buffer_count_.get();
7
 
8
  // Open vendor device (pseudo-code)
9
  device_handle_ = example_sdk_open(device_uri.c_str());
10
  if (!device_handle_) {
11
    throw std::runtime_error("Failed to open device: " + device_uri);
12
  }
13
 
14
  // Configure each stream (channel)
15
  for (uint32_t i = 0; i < num_streams(); ++i) {
16
    example_sdk_configure_channel(device_handle_, i, w, h, fps, buf_count);
17
  }
18
 
19
  example_sdk_start_capture(device_handle_);
20
}
21
 
22
void ExampleVideoCapture::stop() {
23
  if (device_handle_) {
24
    example_sdk_stop_capture(device_handle_);
25
    example_sdk_close(device_handle_);
26
    device_handle_ = nullptr;
27
  }
28
}

1
void ExampleVideoCapture::compute(InputContext& op_input, OutputContext& op_output,
2
                                ExecutionContext& context) {
3
  for (uint32_t i = 0; i < num_streams(); ++i) {
4
    if (!is_capture_stream_enabled(i)) {
5
      continue;
6
    }
7
 
8
    void* frame_ptr = nullptr;
9
    size_t frame_size = 0;
10
    int status = example_sdk_dequeue_frame(device_handle_, i, &frame_ptr, &frame_size);
11
 
12
    if (status == EXAMPLE_TIMEOUT) {
13
      note_dropped_frame();
14
      continue;
15
    }
16
    if (status != EXAMPLE_OK) {
17
      note_dropped_frame();
18
      HOLOSCAN_LOG_ERROR("Example dequeue failed on channel {}: {}", i, status);
19
      continue;
20
    }
21
 
22
    // Wrap the vendor buffer in a GXF Entity with a VideoBuffer or Tensor
23
    auto entity = holoscan::gxf::Entity::New(&context);
24
    // ... populate entity with frame data (vendor-specific) ...
25
    // For GPUDirect: frame_ptr is already a device pointer
26
    // For CPU DMA: memcpy or cudaMemcpyAsync to a device buffer
27
 
28
    emit_capture_stream(op_output, i, entity);
29
    note_acquired_frame();
30
 
31
    // Return the buffer to the vendor SDK ring
32
    example_sdk_requeue_buffer(device_handle_, i, frame_ptr);
33
  }
34
}

1
void ExampleVideoPlayout::compute(InputContext& op_input, OutputContext& op_output,
2
                                ExecutionContext& context) {
3
  for (uint32_t i = 0; i < num_streams(); ++i) {
4
    if (!is_transmit_stream_enabled(i)) {
5
      continue;
6
    }
7
 
8
    auto entity = receive_transmit_stream(op_input, i);
9
    if (!entity) {
10
      note_dropped_frame();
11
      continue;
12
    }
13
 
14
    // Extract the video buffer from the entity (vendor-specific)
15
    // ... get pointer, size, format from the entity's VideoBuffer/Tensor ...
16
 
17
    int status = example_sdk_queue_output(device_handle_, i, gpu_ptr, frame_size);
18
    if (status != EXAMPLE_OK) {
19
      note_dropped_frame();
20
      HOLOSCAN_LOG_ERROR("Example output queue failed on channel {}: {}", i, status);
21
      continue;
22
    }
23
 
24
    note_transmitted_frame();
25
  }
26
}

1
video_io::VideoCaptureCapabilities ExampleVideoCapture::query_capture_capabilities() const {
2
  video_io::VideoCaptureCapabilities cap;
3
  cap.backend_id = "vendor.example";
4
  cap.device_id = uri_.get();
5
  cap.device_uri = uri_.get();
6
 
7
  // Query hardware for actual capabilities
8
  int num_inputs = example_sdk_get_input_count(device_handle_);
9
  cap.max_concurrent_inputs = static_cast<uint32_t>(num_inputs);
10
  cap.transports.push_back(video_io::VideoTransport::kSdi);
11
 
12
  for (int ch = 0; ch < num_inputs; ++ch) {
13
    video_io::VideoCaptureChannelCapabilities chan;
14
    chan.channel_index = static_cast<uint32_t>(ch);
15
    chan.transport = video_io::VideoTransport::kSdi;
16
    chan.interface_label = "SDI In " + std::to_string(ch + 1);
17
 
18
    // Query supported resolutions
19
    int num_modes = 0;
20
    example_mode_t* modes = example_sdk_get_modes(device_handle_, ch, &num_modes);
21
    for (int m = 0; m < num_modes; ++m) {
22
      chan.resolutions.push_back({modes[m].width, modes[m].height});
23
      chan.framerates.push_back({modes[m].min_fps, modes[m].max_fps});
24
    }
25
 
26
    // Query pixel formats
27
    int num_fmts = 0;
28
    example_pixfmt_t* fmts = example_sdk_get_pixel_formats(device_handle_, ch, &num_fmts);
29
    for (int f = 0; f < num_fmts; ++f) {
30
      chan.pixel_formats.push_back({fmts[f].fourcc, fmts[f].description});
31
    }
32
 
33
    chan.color_spaces.push_back(video_io::VideoColorSpaceKind::kBt709);
34
    chan.color_spaces.push_back(video_io::VideoColorSpaceKind::kBt2020);
35
    chan.gpudirect_rdma_supported = example_sdk_supports_gpudirect(device_handle_, ch);
36
    chan.hardware_timestamp_supported = true;
37
    chan.progressive_capture_supported = true;
38
    chan.interlaced_capture_supported = true;
39
 
40
    cap.input_channels.push_back(std::move(chan));
41
  }
42
 
43
  return cap;
44
}

1
#include <holoscan/operators/video_io/video_io_registry.hpp>
2
 
3
namespace {
4
 
5
struct ExampleRegistrar {
6
  ExampleRegistrar() {
7
    holoscan::ops::video_io::register_video_acquisition_enumerator(
8
        "vendor.example",
9
        []() -> std::vector<holoscan::ops::video_io::VideoCaptureCapabilities> {
10
          std::vector<holoscan::ops::video_io::VideoCaptureCapabilities> result;
11
 
12
          int num_devices = example_sdk_enumerate_devices();
13
          for (int d = 0; d < num_devices; ++d) {
14
            holoscan::ops::video_io::VideoCaptureCapabilities cap;
15
            cap.backend_id = "vendor.example";
16
            cap.device_id = example_sdk_get_device_serial(d);
17
            cap.device_uri = "example://" + std::to_string(d);
18
            cap.max_concurrent_inputs = example_sdk_get_input_count_by_index(d);
19
            cap.transports.push_back(holoscan::ops::video_io::VideoTransport::kSdi);
20
 
21
            for (uint32_t ch = 0; ch < cap.max_concurrent_inputs; ++ch) {
22
              holoscan::ops::video_io::VideoCaptureChannelCapabilities chan;
23
              chan.channel_index = ch;
24
              chan.transport = holoscan::ops::video_io::VideoTransport::kSdi;
25
              chan.interface_label = "SDI In " + std::to_string(ch + 1);
26
              cap.input_channels.push_back(std::move(chan));
27
            }
28
 
29
            result.push_back(std::move(cap));
30
          }
31
          return result;
32
        });
33
  }
34
};
35
 
36
static ExampleRegistrar s_registrar;
37
 
38
}  // namespace

1
auto devices = holoscan::ops::video_io::enumerate_video_acquisition_devices("vendor.example");
2
for (const auto& dev : devices) {
3
  HOLOSCAN_LOG_INFO("Found device {} with {} inputs",
4
                    dev.device_id, dev.max_concurrent_inputs);
5
}

1
// Shared device resource — single SDK handle with per-channel reservation
2
auto dev = F.make_resource<example::ExampleDeviceResource>(
3
    "example_dev0", Arg("device", "0"));
4
 
5
// One operator per channel on the same physical device
6
auto ch0 = F.make_operator<example::ExampleVideoCapture>(
7
    "sdi_ch0",
8
    Arg("device_resource", dev),
9
    Arg("channel_index", 0U),
10
    Arg("uri", "sdi://0"),
11
    Arg("width", 1920U),
12
    Arg("height", 1080U),
13
    Arg("frame_rate", 60.F),
14
    Arg("rdma", true));
15
 
16
auto ch1 = F.make_operator<example::ExampleVideoCapture>(
17
    "sdi_ch1",
18
    Arg("device_resource", dev),
19
    Arg("channel_index", 1U),
20
    Arg("uri", "sdi://0"),
21
    Arg("width", 1920U),
22
    Arg("height", 1080U),
23
    Arg("frame_rate", 60.F),
24
    Arg("rdma", true));
25
 
26
auto proc0 = F.make_operator<InferenceOp>("proc0");
27
auto proc1 = F.make_operator<InferenceOp>("proc1");
28
 
29
F.add_flow(ch0, proc0, {{"signal", "input"}});
30
F.add_flow(ch1, proc1, {{"signal", "input"}});

1
// 4 output ports: signal, signal_1, signal_2, signal_3
2
auto capture = F.make_operator<example::ExampleVideoCapture>(
3
    "quad_sdi",
4
    4U,                              // <-- num_streams
5
    Arg("uri", "sdi://0"),
6
    Arg("transport", "sdi"),
7
    Arg("width", 1920U),
8
    Arg("height", 1080U),
9
    Arg("frame_rate", 60.F));
10
 
11
auto proc0 = F.make_operator<InferenceOp>("proc0");
12
auto proc1 = F.make_operator<InferenceOp>("proc1");
13
auto proc2 = F.make_operator<InferenceOp>("proc2");
14
auto proc3 = F.make_operator<InferenceOp>("proc3");
15
 
16
F.add_flow(capture, proc0, {{"signal", "input"}});
17
F.add_flow(capture, proc1, {{"signal_1", "input"}});
18
F.add_flow(capture, proc2, {{"signal_2", "input"}});
19
F.add_flow(capture, proc3, {{"signal_3", "input"}});