track.h

Go to the documentation of this file.

#ifndef MILLICAST_API_TRACK_H
#define MILLICAST_API_TRACK_H
 
#ifdef __cplusplus
 
#include "event_handling.h"
#include "exports.h"
#include "metadata.h"
#include "promise.h"
#include "rts_stats.h"
 
#include <optional>
#include <string>
#include <vector>
 
namespace millicast {
 
// Forward declarations ///////////////////////////////////////////////////////
class VideoRenderer;
class AudioRenderer;
 
// Track //////////////////////////////////////////////////////////////////////
 
class MILLICAST_API Track {
 public:
  Track() = default;
  virtual ~Track() = default;
 
  [[nodiscard]] virtual const std::string& id() const = 0;
 
  [[nodiscard]] virtual const std::string& kind() const = 0;
 
  [[nodiscard]] virtual bool is_enabled() const = 0;
 
  virtual void enable(bool e) = 0;
};
 
// VideoTrack /////////////////////////////////////////////////////////////////
 
class MILLICAST_API VideoTrack : public Track {
 public:
  enum class ContentHint { NONE, FLUID, DETAILED, TEXT };
 
  VideoTrack() = default;
  ~VideoTrack() override = default;
 
  virtual void add_renderer(VideoRenderer* renderer) = 0;
 
  virtual void remove_renderer(VideoRenderer* renderer) = 0;
 
  virtual void set_content_hint(ContentHint hint) noexcept = 0;
 
  [[nodiscard]] virtual ContentHint content_hint() const noexcept = 0;
};
 
// AudioTrack /////////////////////////////////////////////////////////////////
 
class MILLICAST_API AudioTrack : public Track {
 public:
  AudioTrack() = default;
  ~AudioTrack() override = default;
 
  virtual void add_renderer(AudioRenderer* renderer) = 0;
 
  virtual void remove_renderer(AudioRenderer* renderer) = 0;
 
  virtual void set_volume(double volume) = 0;
};
 
#ifndef MC_DISABLE_COPY_AND_ASSIGN
#define MC_DISABLE_COPY_AND_ASSIGN(Klass) \
  Klass(Klass&&) = delete;                \
  Klass(const Klass&) = delete;           \
  Klass& operator=(Klass&&) = delete;     \
  Klass& operator=(const Klass&) = delete
#endif  // !defined(MC_DISABLE_COPY_AND_ASSIGN)
 
class RtsRemoteTrack;
class RtsRemoteVideoTrack;
class RtsRemoteAudioTrack;
class WebrtcRemoteAudioTrack;
class WebrtcRemoteVideoTrack;
 
class MILLICAST_API WebrtcRemoteTrack {
 public:
  WebrtcRemoteTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(WebrtcRemoteTrack);
 
  enum Kind {
    AUDIO,  
    VIDEO   
  };
 
  struct Disabled {};
 
  struct MidUpdated {
    std::optional<std::string> mid;
  };
 
  [[nodiscard]] virtual Kind kind() const = 0;
 
  virtual Promise<void> unproject() = 0;
 
  virtual std::optional<std::string> get_current_mid() const = 0;
 
  virtual const std::string& get_cname() const = 0;
 
  virtual WebrtcRemoteVideoTrack* as_video() = 0;
 
  virtual WebrtcRemoteAudioTrack* as_audio() = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<Disabled>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<MidUpdated>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<FrameMetadata>&& handler) = 0;
};
 
class MILLICAST_API RtsRemoteTrack {
 public:
  RtsRemoteTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(RtsRemoteTrack);
 
  struct Active {};
 
  struct Inactive {};
 
  struct RtsStatsEvent {
    const std::shared_ptr<const RtsTrackStats> track_stats;
  };
 
  using MidUpdated = WebrtcRemoteTrack::MidUpdated;
 
  struct Layers {
    struct Resolution {
      int width;  
      int height; 
    };
 
    struct Layer {
      std::string encoding_id; 
      int bitrate = 0;         
      std::optional<int>
          target_bitrate{};            
      std::optional<int> target_fps{}; 
      std::optional<int>
          target_height{};               
      std::optional<int> target_width{}; 
      std::optional<int> temporal_layer_id; 
      std::optional<int> spatial_layer_id;  
      std::optional<Resolution> layer_resolution;
      std::optional<int> max_temporal_layer_id;
      std::optional<int> max_spatial_layer_id;
    };
 
    std::vector<Layer> active;
    std::vector<std::string> inactive;
  };
 
  using Kind = WebrtcRemoteTrack::Kind;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<Active>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<Inactive>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<Layers>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<MidUpdated>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<FrameMetadata>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<RtsStatsEvent>&& handler) = 0;
 
  [[nodiscard]] virtual const std::optional<std::string>& source_id() const = 0;
 
  [[nodiscard]] virtual Kind kind() const = 0;
 
  [[nodiscard]] virtual bool is_active() const = 0;
 
  virtual std::optional<std::string> get_current_mid() const = 0;
 
  virtual Promise<void> disable() = 0;
 
  virtual RtsRemoteVideoTrack* as_video() = 0;
 
  virtual RtsRemoteAudioTrack* as_audio() = 0;
};
 
class MILLICAST_API RtsRemoteVideoTrack : public virtual RtsRemoteTrack {
 public:
  RtsRemoteVideoTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(RtsRemoteVideoTrack);
  struct Layer {
    std::optional<std::string> encodingId;
    std::optional<int> spatialLayerId;
    std::optional<int> temporalLayerId;
    std::optional<int> maxSpatialLayerId;
    std::optional<int> maxTemporalLayerId;
 
    operator bool() const noexcept {
      return encodingId || spatialLayerId || temporalLayerId ||
             maxSpatialLayerId || maxTemporalLayerId;
    }
  };
 
  virtual millicast::Promise<void> enable_frame_metadata(bool enabled) = 0;
 
  virtual Promise<void> enable(const std::shared_ptr<VideoRenderer>& renderer,
                               const Layer& layer = {},
                               bool promote = false) = 0;
};
 
class MILLICAST_API RtsRemoteAudioTrack : public virtual RtsRemoteTrack {
 public:
  RtsRemoteAudioTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(RtsRemoteAudioTrack);
 
  virtual Promise<void> enable() = 0;
 
  virtual Promise<void> set_volume(double volume) = 0;
};
 
class MILLICAST_API WebrtcRemoteVideoTrack : public virtual WebrtcRemoteTrack {
 public:
  WebrtcRemoteVideoTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(WebrtcRemoteVideoTrack);
 
  virtual millicast::Promise<void> enable_frame_metadata(bool enabled) = 0;
 
  virtual Promise<void> project(RtsRemoteVideoTrack& rts_track,
                                const RtsRemoteVideoTrack::Layer& layer = {},
                                bool promote = false) = 0;
 
  virtual Promise<void> add_renderer(
      const std::shared_ptr<VideoRenderer>& renderer) = 0;
 
  virtual Promise<void> remove_renderer(const VideoRenderer* renderer) = 0;
 
  virtual Promise<RtsRemoteVideoTrack*> current_projection() = 0;
};
 
class MILLICAST_API WebrtcRemoteAudioTrack : public virtual WebrtcRemoteTrack {
 public:
  WebrtcRemoteAudioTrack() = default;
  MC_DISABLE_COPY_AND_ASSIGN(WebrtcRemoteAudioTrack);
 
  virtual Promise<void> project(RtsRemoteAudioTrack& rts_track) = 0;
 
  virtual Promise<void> set_volume(double volume) = 0;
 
  virtual Promise<RtsRemoteAudioTrack*> current_projection() = 0;
};
 
}  // namespace millicast
 
#endif // __cplusplus
#endif /* TRACK_H */