source.h

Go to the documentation of this file.

#ifndef MILLICAST_API_SOURCE_H
#define MILLICAST_API_SOURCE_H
 
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "millicast-sdk/capabilities.h"
#include "millicast-sdk/frames.h"
#include "millicast-sdk/mc_logging.h"
 
namespace millicast {
 
// Forward declarations ///////////////////////////////////////////////////////
class Track;
 
// Source /////////////////////////////////////////////////////////////////////
 
class Source {
  friend class AudioPlayback;
 
 public:
  enum class Type {
    DEVICE,   
    MONITOR,  
    APP,      
    MIC,      
    NDI,      
    DECKLINK, 
    TVOS,     
    CUSTOM    
  };
 
  template <typename T>
  using SourcePtr = std::shared_ptr<T>;
 
  using Ptr = SourcePtr<Source>;
 
  struct SourceInformation {
    Type type;             
    int id;                
    std::string name;      
    std::string unique_id; 
  };
 
  template <typename T = Type>
  T type() const;
 
  [[nodiscard]] MILLICAST_API int id() const;
 
  [[nodiscard]] MILLICAST_API const std::string& name() const;
 
  [[nodiscard]] MILLICAST_API const std::string& unique_id() const;
 
  MILLICAST_API void set_track_name(std::string track_name);
 
  [[nodiscard]] MILLICAST_API const std::string& track_name() const;
 
  MILLICAST_API virtual std::weak_ptr<Track> start_capture() = 0;
 
  MILLICAST_API virtual void stop_capture() = 0;
 
  [[nodiscard]] MILLICAST_API virtual bool is_capturing() const = 0;
 
  MILLICAST_API virtual ~Source() = default;
 
 protected:
  Source(const SourceInformation& information) noexcept;
 
 private:
  Type _type;
  int _id;
  std::string _name;
  std::string _unique_id;
  std::string _track_name;
};
 
// Fix specializing templates in non-namespace scope, which causes
// issues when compiling with GCC
template <>
[[nodiscard]] MILLICAST_API Source::Type Source::type<Source::Type>() const;
template <>
[[nodiscard]] MILLICAST_API std::string Source::type<std::string>() const;
 
// Video //////////////////////////////////////////////////////////////////////
 
class VideoSource : public Source {
 public:
  using Ptr = Source::SourcePtr<VideoSource>;
 
  struct Builder : public SourceInformation {
    std::vector<VideoCapabilities>
        capabilities; 
    MILLICAST_API Builder() noexcept = default;
    MILLICAST_API Ptr build() noexcept;
  };
 
  [[nodiscard]] MILLICAST_API const std::vector<VideoCapabilities>&
  capabilities() const;
  MILLICAST_API void set_capabilities(
      std::vector<VideoCapabilities>& capabilities);
 
  [[nodiscard]] MILLICAST_API const VideoCapabilities& capability() const;
 
  MILLICAST_API void set_capability(const VideoCapabilities& capability);
  MILLICAST_API void set_capability(VideoCapabilities&& capability);
  MILLICAST_API virtual void change_video_source(
      bool ascending,
      const std::string& unique_device_id = ""){};
 
  ~VideoSource() override = default;
 
 protected:
  using Source::Source;
  std::vector<VideoCapabilities> _capabilities;
  VideoCapabilities _capability;
};
 
// Audio //////////////////////////////////////////////////////////////////////
 
class MILLICAST_API AudioControl {
 public:
  virtual void set_volume(uint32_t v) = 0;
 
  virtual void set_num_channel(uint8_t n) = 0;
 
  virtual void mute(bool m) = 0;
 
  virtual uint32_t get_volume() = 0;
 
  [[nodiscard]] virtual bool is_muted() const = 0;
};
 
class AudioSource : public Source, public AudioControl {
 public:
  using Ptr = Source::SourcePtr<AudioSource>;
  struct Builder : public SourceInformation {
    MILLICAST_API Builder() noexcept = default;
    MILLICAST_API Ptr build() noexcept;
  };
 
  ~AudioSource() override = default;
 
 protected:
  using Source::Source;
};
 
class AudioPlayback : public Source, public AudioControl {
  /* Not a capture source */
  std::weak_ptr<Track> start_capture() override = 0;
  void stop_capture() override = 0;
  [[nodiscard]] bool is_capturing() const override = 0;
 
 public:
  using Ptr = Source::SourcePtr<AudioPlayback>;
 
  struct Builder : public SourceInformation {
    MILLICAST_API Builder() noexcept = default;
    MILLICAST_API Ptr build() noexcept;
  };
 
  MILLICAST_API virtual void init_playback() = 0;
 
  [[nodiscard]] MILLICAST_API virtual bool is_playing() const = 0;
 
 protected:
  using Source::Source;
};
 
// Custom source
// ////////////////////////////////////////////////////////////////////
 
class CustomAudioSource : public Source {
 public:
  using Ptr = Source::SourcePtr<CustomAudioSource>;
  struct Builder : public SourceInformation {
    MILLICAST_API Builder() noexcept;
 
    MILLICAST_API Ptr build();
  };
 
  [[nodiscard]] MILLICAST_API std::weak_ptr<Track> start_capture() override = 0;
  [[nodiscard]] MILLICAST_API bool is_capturing() const override = 0;
  MILLICAST_API void stop_capture() override = 0;
 
  MILLICAST_API virtual void on_audio_frame(
      const millicast::AudioFrame& frame) = 0;
 
 protected:
  using Source::Source;
};
 
class CustomVideoSource : public Source {
 public:
  using Ptr = Source::SourcePtr<CustomVideoSource>;
  struct Builder : public SourceInformation {
    MILLICAST_API Builder() noexcept;
    MILLICAST_API Ptr build();
  };
 
  [[nodiscard]] MILLICAST_API std::weak_ptr<Track> start_capture() override = 0;
  [[nodiscard]] MILLICAST_API bool is_capturing() const override = 0;
  MILLICAST_API void stop_capture() override = 0;
 
  MILLICAST_API virtual void on_video_frame(
      const millicast::VideoFrame& frame) = 0;
 
 protected:
  using Source::Source;
};
 
}  // namespace millicast
 
#endif /* MILLICAST_API_SOURCE_H */