Program Listing for File video_acquisition_operator.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_ACQUISITION_OPERATOR_HPP
#define HOLOSCAN_OPERATORS_VIDEO_IO_VIDEO_ACQUISITION_OPERATOR_HPP

#include <algorithm>
#include <atomic>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <yaml-cpp/yaml.h>

#include "holoscan/core/gxf/entity.hpp"
#include "holoscan/core/operator.hpp"
#include "holoscan/core/parameter.hpp"

#include "./video_io_capabilities.hpp"

namespace holoscan::ops {

class VideoAcquisitionOperator : public Operator {
 public:
  HOLOSCAN_OPERATOR_FORWARD_ARGS(VideoAcquisitionOperator)

  VideoAcquisitionOperator() = default;

  explicit VideoAcquisitionOperator(uint32_t num_streams);

  HOLOSCAN_OPERATOR_FORWARD_TEMPLATE()
  explicit VideoAcquisitionOperator(uint32_t num_streams, ArgT&& arg, ArgsT&&... args)
      : num_streams_(std::max(1u, std::min(num_streams, video_io::kVideoIoMaxStreams))) {
    init_port_names();
    add_arg(std::forward<ArgT>(arg));
    (add_arg(std::forward<ArgsT>(args)), ...);
  }

  void setup(OperatorSpec& spec) override;
  void initialize() override;

  [[nodiscard]] virtual video_io::VideoCaptureCapabilities query_capture_capabilities() const;

  [[nodiscard]] video_io::VideoDeviceCapabilities query_capabilities() const;

  [[nodiscard]] uint64_t dropped_frame_count() const {
    return dropped_frames_.load(std::memory_order_relaxed);
  }
  [[nodiscard]] uint64_t acquired_frame_count() const {
    return acquired_frames_.load(std::memory_order_relaxed);
  }

  [[nodiscard]] bool is_capture_stream_enabled(uint32_t stream_index) const;

  [[nodiscard]] uint32_t num_streams() const { return num_streams_; }

 protected:
  void note_dropped_frame() { dropped_frames_.fetch_add(1, std::memory_order_relaxed); }
  void note_acquired_frame() { acquired_frames_.fetch_add(1, std::memory_order_relaxed); }

  static std::string capture_output_port_name(uint32_t stream_index);

  void emit_capture_stream(OutputContext& op_output, uint32_t stream_index,
                           holoscan::gxf::Entity& entity);

  virtual video_io::VideoCaptureCapabilities build_capture_capabilities_from_parameters() const;

  void compute(InputContext& op_input, OutputContext& op_output,
               ExecutionContext& context) override = 0;

  Parameter<std::string> backend_id_;
  Parameter<uint32_t> channel_index_;
  Parameter<std::vector<uint32_t>> channel_indices_;
  Parameter<std::string> uri_;
  Parameter<uint32_t> width_;
  Parameter<uint32_t> height_;
  Parameter<float> frame_rate_;
  Parameter<std::string> pixel_format_;
  Parameter<std::string> color_space_;
  Parameter<std::string> transport_;
  Parameter<YAML::Node> vendor_extensions_;

 private:
  void init_port_names() {
    port_names_.clear();
    port_names_.reserve(num_streams_);
    for (uint32_t i = 0; i < num_streams_; ++i) {
      port_names_.push_back(capture_output_port_name(i));
    }
  }

  uint32_t num_streams_ = 1;
  std::vector<std::string> port_names_{"signal"};
  std::atomic<uint64_t> dropped_frames_{0};
  std::atomic<uint64_t> acquired_frames_{0};
};

}  // namespace holoscan::ops

#endif// HOLOSCAN_OPERATORS_VIDEO_IO_VIDEO_ACQUISITION_OPERATOR_HPP