viewer.h

Go to the documentation of this file.

#ifndef MILLICAST_API_VIEWER_H
#define MILLICAST_API_VIEWER_H
 
#include "millicast-sdk/client.h"
 
namespace millicast {
 
// Forward declarations ///////////////////////////////////////////////////////
class VideoTrack;
class AudioTrack;
 
// Viewer /////////////////////////////////////////////////////////////////////
 
struct ViewerOption : public ClientOption {
  /* multisource options */
  struct {
    std::optional<std::string>
        pinned_source_id; 
    std::optional<uint8_t>
        multiplexed_audio_track; 
    std::vector<std::string>
        excluded_source_id; 
  } multisource;
 
  /* forcing the media server to process frames with no delay */
  bool force_playout_delay{false};
 
  /* disable receiving audio completely. This should help reduce A/V sync
   * related delays for video only streams */
  bool disable_audio{false};
 
  /* set the video jitter buffer minimum delay in milliseconds. Defaults to
   * 0*/
  int video_jitter_minimum_delay_ms = 0;
};
 
struct ViewerCredentials {
  bool is_valid; 
  std::string stream_name; 
  std::optional<std::string> token;
  std::string account_id; 
  std::string
      api_url; 
};
 
struct ViewerLayerData {
  struct Resolution {
    int width;  
    int height; 
  };
  std::string encoding_id; 
  int bitrate = 0;         
  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;
};
 
struct ViewerProjectionData {
  std::string track_id; 
  std::string
      media; 
  std::string mid; 
  std::optional<ViewerLayerData>
      layer; 
};
 
struct ViewerListener : public ClientListener {
  virtual void on_subscribed() = 0;
 
  virtual void on_subscribed_error(const std::string& error) = 0;
 
  virtual void on_track(std::weak_ptr<VideoTrack> track,
                        const std::optional<std::string>& mid) = 0;
 
  virtual void on_track(std::weak_ptr<AudioTrack> track,
                        const std::optional<std::string>& mid) = 0;
 
  /* Broadcast events */
 
  virtual void on_active(const std::string& stream_id,
                         const std::vector<TrackInfo>& tracks,
                         const std::optional<std::string>& source_id) = 0;
 
  virtual void on_inactive(const std::string& stream_id,
                           const std::optional<std::string>& source_id) = 0;
 
  virtual void on_stopped() = 0;
 
  virtual void on_vad(const std::string& mid,
                      const std::optional<std::string>& source_id) = 0;
 
  virtual void on_layers(const std::string& mid,
                         const std::vector<ViewerLayerData>& active_layers,
                         const std::vector<std::string>& inactive_layers) = 0;
 
  virtual void on_frame_metadata(uint32_t ssrc,
                                 uint32_t timestamp,
                                 const std::vector<uint8_t>& data) {}
};
 
inline namespace compat {
class MILLICAST_API Viewer : public virtual Client {
 public:
  using Option = ViewerOption;
  using Credentials = ViewerCredentials;
  using LayerData = ViewerLayerData;
  using ProjectionData = ViewerProjectionData;
  using Listener = ViewerListener;
  virtual bool subscribe(
      const std::optional<Viewer::Option>& options = std::nullopt) = 0;
 
  virtual bool unsubscribe() = 0;
 
  [[nodiscard]] virtual bool is_subscribed() const = 0;
 
  virtual bool project(const std::string& source_id,
                       const std::vector<ProjectionData>& pdata) = 0;
 
  virtual bool unproject(const std::vector<std::string>& mids) = 0;
 
  virtual bool select(std::optional<LayerData> layer) = 0;
 
  virtual bool add_remote_track(std::string_view kind) = 0;
 
  virtual bool set_credentials(const Credentials& creds) = 0;
  virtual bool set_credentials(Credentials&& creds) = 0;
 
  [[nodiscard]] virtual Credentials get_credentials() const = 0;
 
  virtual void set_listener(Viewer::Listener* listener) = 0;
 
  static std::unique_ptr<Viewer> create();
};
}  // namespace compat
 
namespace promises {
class MILLICAST_API Viewer : public virtual Client {
 public:
  virtual Promise<void> subscribe(
      std::optional<ViewerOption>&& options = std::nullopt) = 0;
 
  virtual Promise<void> unsubscribe() = 0;
 
  [[nodiscard]] virtual Promise<bool> is_subscribed() const = 0;
 
  // to be deprecated
  virtual Promise<void> project(std::string&& source_id,
                                std::vector<ViewerProjectionData>&& pdata) = 0;
 
  // to be deprecated
  virtual Promise<void> unproject(std::vector<std::string>&& mids) = 0;
 
  // to be deprecated
  virtual Promise<void> select(std::optional<ViewerLayerData>&& layer) = 0;
 
  // to be deprecated
  virtual Promise<void> add_remote_track(std::string&& kind) = 0;
 
  virtual Promise<void> set_credentials(ViewerCredentials&& creds) = 0;
 
  [[nodiscard]] virtual Promise<ViewerCredentials> get_credentials() const = 0;
 
  virtual Promise<void> set_listener(ViewerListener* listener) = 0;
 
  virtual compat::Viewer& get_old_api() = 0;
 
  static std::unique_ptr<Viewer> create();
};
}  // namespace promises
 
}  // namespace millicast
 
#endif /* MILLICAST_API_VIEWER_H */