element.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
#ifndef ELEMENT_HPP
#define ELEMENT_HPP
 
#include <string>
#include <memory>
#include <vector>
#include <typeinfo>
#include <algorithm>
 
#include "yaml-cpp/yaml.h"
#include "object.hpp"
#include "buffer_probe.hpp"
#include "signal_emitter.hpp"
#include "signal_handler.hpp"
 
namespace deepstream {
 
class Pipeline;
 
class Element : public Object {
 public:
 
   typedef enum {
    INVALID,
    EMPTY,
    READY,
    PAUSED,
    PLAYING
  } State;
 
  Element(const std::string& type_name, std::string name = std::string());
 
  Element(const Object&);
 
  Element(Object&&);
 
  virtual ~Element();
 
  Element & link(Element &dst, std::pair<std::string, std::string> hint);
 
  Element& link(Element &other);
 
  BufferProbe* getProbe(const std::string& name) {
    return find_<BufferProbe>(name);
  }
 
  Element& addProbe(const std::string& plugin_name,
                    const std::string& probe_name,
                    const std::string probe_tip = "");
 
  template<typename... Args>
  Element& addProbe(const std::string& plugin_name,
                    const std::string& probe_name,
                    const std::string probe_tip = "",
                    const Args&... args) {
    addProbe(plugin_name, probe_name, probe_tip);
    auto probe = getProbe(probe_name);
    if (probe && (sizeof...(args) > 0)) {
      probe->set(args...);
    }
    return *this;
  }
 
  Element& addProbe(BufferProbe* probe, const std::string probe_tip  = "");
 
  SignalHandler* getSignalHandler(const std::string& name) {
    return find_<SignalHandler>(name);
  }
 
  Element& connectSignal(const std::string&signal_name, SignalHandler* handler);
 
  Element& connectSignal(const std::string& plugin_name,
                         const std::string& handler_name,
                         const std::string& signal_names);
 
  template<typename... Args>
  Element& connectSignal(const std::string& plugin_name,
                         const std::string& handler_name,
                         const std::string& signal_names,
                         const Args&... args) {
    connectSignal(plugin_name, handler_name, signal_names);
    auto handler = getSignalHandler(handler_name);
    if (handler && (sizeof...(args) > 0)) {
      handler->set(args...);
    }
    return *this;
  }
 
  const Pipeline& getPipeline() {
    return *pipeline_;
  }
 
  bool setState (Element::State state);
 
protected:
  Element(GstObject* object);
 
  Element& add_(CustomObject* object);
 
  // buffer probes, signal handlers, signal emitters are held by its target
  // element as shared pointers.
  std::shared_ptr<std::unordered_map<std::string, std::unique_ptr<CustomObject>>> objects_;
  // pointer to the pipeline
  Pipeline* pipeline_=nullptr;
 
  template<class T>
  T* find_(const std::string& name) {
    auto itr = find_if(
      objects_->begin(),
      objects_->end(),
      [&](const auto& pair) {
        return pair.first == name && dynamic_cast<T*>(pair.second.get());
      }
    );
    if (itr != objects_->end()) return dynamic_cast<T*>(itr->second.get());
    return nullptr;
  }
 
friend class Pipeline;
};
 
} // namespace deepstream
 
#endif