Program Listing for File video_io_capabilities.hpp

            

            
/*
* SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: Apache-2.0
*
* 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 permissions and
* limitations under the License.
*/

#ifndef HOLOSCAN_OPERATORS_VIDEO_IO_VIDEO_IO_CAPABILITIES_HPP
#define HOLOSCAN_OPERATORS_VIDEO_IO_VIDEO_IO_CAPABILITIES_HPP

#include <cstdint>
#include <string>
#include <vector>

namespace holoscan::ops::video_io {

inline constexpr std::uint32_t kVideoIoMaxStreams = 128;

enum class VideoTransport {
  kUnknown = 0,
  kSdi,
  kHdmi,
  kEthernet,
  kUsb,
  kV4l2,
  kFile,
  kOther,
};

enum class VideoColorSpaceKind {
  kUnknown = 0,
  kBt601,
  kBt709,
  kBt2020,
  kSrgb,
  kAuto,
};

enum class SyncClockMode {
  kUnknown = 0,
  kFreeRun,
  kGenlock,
  kPtp,
  kHouseSync,
};

struct FramerateRange {
  double min_fps = 0.;
  double max_fps = 0.;
};

struct Resolution {
  uint32_t width = 0;
  uint32_t height = 0;
};

struct PixelFormatDesc {
  std::string name;
  std::string description;
};

struct VideoLatencyHint {
  std::string qualitative;
  double estimated_ms = -1.;
};

struct ChannelCapabilities {
  uint32_t channel_index = 0;
  VideoTransport transport = VideoTransport::kUnknown;
  std::vector<Resolution> resolutions;
  std::vector<FramerateRange> framerates;
  std::vector<PixelFormatDesc> pixel_formats;
  std::vector<VideoColorSpaceKind> color_spaces;
  std::vector<SyncClockMode> sync_modes;
  bool gpudirect_rdma_supported = false;
  bool safety_bypass_supported = false;
  VideoLatencyHint latency;
};

struct VideoCaptureChannelCapabilities : ChannelCapabilities {
  std::string interface_label;
  bool progressive_capture_supported = true;
  bool interlaced_capture_supported = false;
  bool hardware_timestamp_supported = false;
};

struct VideoTransmitChannelCapabilities : ChannelCapabilities {
  std::string interface_label;
  bool progressive_output_supported = true;
  bool interlaced_output_supported = false;
  bool embedded_audio_output_supported = false;
};

struct VideoCaptureCapabilities {
  std::string backend_id;
  std::string device_id;
  std::string device_uri;
  uint32_t max_concurrent_inputs = 0;
  std::vector<VideoTransport> transports;
  std::vector<VideoCaptureChannelCapabilities> input_channels;
  std::vector<std::string> connection_uri_schemes;
};

struct VideoTransmitCapabilities {
  std::string backend_id;
  std::string device_id;
  std::string device_uri;
  uint32_t max_concurrent_outputs = 0;
  std::vector<VideoTransport> transports;
  std::vector<VideoTransmitChannelCapabilities> output_channels;
  std::vector<std::string> connection_uri_schemes;
};

struct VideoDeviceCapabilities {
  std::string backend_id;
  std::string device_id;
  std::string device_uri;
  uint32_t max_concurrent_inputs = 0;
  uint32_t max_concurrent_outputs = 0;
  std::vector<VideoTransport> transports;
  std::vector<ChannelCapabilities> channels;
};

VideoDeviceCapabilities to_video_device_capabilities(const VideoCaptureCapabilities& c);

VideoDeviceCapabilities to_video_device_capabilities(const VideoTransmitCapabilities& c);

}  // namespace holoscan::ops::video_io

#endif// HOLOSCAN_OPERATORS_VIDEO_IO_VIDEO_IO_CAPABILITIES_HPP