viewer.h

Go to the documentation of this file.

#ifndef MILLICAST_API_VIEWER_H
#define MILLICAST_API_VIEWER_H
 
#include "millicast-sdk/client.h"
#include "millicast-sdk/rts_stats.h"
#include "millicast-sdk/track.h"
 
namespace millicast {
 
// Forward declarations ///////////////////////////////////////////////////////
class VideoTrack;
class AudioTrack;
 
// Viewer /////////////////////////////////////////////////////////////////////
 
struct ViewerOption : public ClientOption {
  struct {
    std::optional<std::string>
        pinned_source_id; 
    std::optional<uint8_t>
        multiplexed_audio_track; 
    std::vector<std::string>
        excluded_source_id; 
  } multisource;
 
  struct ForcePlayoutDelay {
    int min; 
    int max; 
  };
 
  std::optional<ForcePlayoutDelay> force_playout_delay;
 
  std::optional<unsigned int> maximum_bitrate;
 
  bool disable_audio{
      false}; 
  int jitter_minimum_delay_ms =
      0; 
  bool force_smooth{false};
 
  std::optional<unsigned int> bwe_monitor_duration_us;
 
  std::optional<unsigned int> upwards_layer_wait_time_ms;
 
  std::optional<double> bwe_rate_change_percentage;
};
 
struct ViewerCredentials {
  bool is_valid; 
  std::string stream_name; 
  std::optional<std::string> token;
  std::string account_id; 
  std::string
      api_url; 
};
 
class MILLICAST_API Viewer : public virtual Client {
 public:
  using Option = ViewerOption;
  using Credentials = ViewerCredentials;
  struct StreamStopped {
    std::string description; 
  };
 
  virtual Promise<void> subscribe(
      std::optional<ViewerOption>&& options = std::nullopt) = 0;
 
  virtual Promise<void> unsubscribe() = 0;
 
  [[nodiscard]] virtual Promise<bool> is_subscribed() const = 0;
 
  virtual Promise<void> set_credentials(ViewerCredentials&& creds) = 0;
 
  [[nodiscard]] virtual Promise<ViewerCredentials> get_credentials() const = 0;
 
  static std::unique_ptr<Viewer> create();
 
  struct RtsTrackAdded {
    RtsRemoteTrack& track;  
  };
 
  struct RtsStatsEvent {
    const std::shared_ptr<const RtsViewerStats> viewer_stats;
  };
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<RtsTrackAdded>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<StreamStopped>&& handler) = 0;
 
  [[deprecated(
      "Use the overload with RtsStatsEvent")]] virtual EventConnectionPtr
  add_event_handler(EventHandler<StatsEvent>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<RtsStatsEvent>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<ViewerCount>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<SignalingError>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<HttpConnectionError>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<WebsocketState>&& handler) = 0;
 
  virtual EventConnectionPtr add_event_handler(
      EventHandler<PeerConnectionState>&& handler) = 0;
 
  [[nodiscard]] virtual Promise<std::vector<RtsRemoteAudioTrack*>>
  audio_tracks() const = 0;
 
  [[nodiscard]] virtual Promise<std::vector<RtsRemoteVideoTrack*>>
  video_tracks() const = 0;
 
  virtual Promise<WebrtcRemoteTrack*> add_webrtc_remote_track(
      WebrtcRemoteTrack::Kind kind,
      std::string_view cname) = 0;
 
  [[nodiscard]] virtual Promise<std::vector<WebrtcRemoteAudioTrack*>>
  webrtc_audio_tracks() const = 0;
 
  [[nodiscard]] virtual Promise<std::vector<WebrtcRemoteVideoTrack*>>
  webrtc_video_tracks() const = 0;
 
  virtual void enable_seamless_migration(bool enabled = true) = 0;
};
 
}  // namespace millicast
 
#endif /* MILLICAST_API_VIEWER_H */