publisher.h

Go to the documentation of this file.

#ifndef MILLICAST_API_PUBLISHER_H
#define MILLICAST_API_PUBLISHER_H
 
#include "millicast-sdk/client.h"
 
namespace millicast {
 
// Forward declarations ///////////////////////////////////////////////////////
 
class VideoTrack;
class AudioTrack;
class Track;
 
// Scalability mode ///////////////////////////////////////////////////////////
 
enum class ScalabilityMode {
  L1_T2,
  L1_T2_H,
  L1_T3,
  L1_T3_H,
  L2_T1,
  L2_T1_H,
  L2_T1_KEY,
  L2_T2,
  L2_T3,
  L2_T2_H,
  L2_T2_KEY,
  L2_T2_KEY_SHIFT,
  L2_T3_H,
  L3_T1,
  L3_T2,
  L3_T3,
  L3_T3_KEY,
  S2_T1,
  S2_T2,
  S2_T3,
  S3_T1,
  S3_T2,
  S3_T3,
  S2_T1_H,
  S2_T2_H,
  S2_T3_H,
  S3_T1_H,
  S3_T2_H,
  S3_T3_H
};
 
// Publisher //////////////////////////////////////////////////////////////////
 
struct PublisherCredentials {
  bool is_valid; 
  std::string stream_name; 
  std::string
      token; 
  std::string
      api_url; 
};
 
struct PublisherListener : public ClientListener {
  virtual void on_publishing() = 0;
 
  virtual void on_publishing_error(const std::string& reason) = 0;
 
  /* Broadcast events */
 
  virtual void on_active() = 0;
 
  virtual void on_inactive() = 0;
 
  virtual void on_transformable_frame(uint32_t ssrc,
                                      uint32_t timestamp,
                                      std::vector<uint8_t>& data) {}
};
 
struct RecordingListener {
  RecordingListener() = default;
 
  virtual void own_recording_stopped() = 0;
 
  virtual void failed_to_stop_recording() = 0;
 
  virtual void own_recording_started() = 0;
 
  virtual void failed_to_start_recording() = 0;
 
  virtual ~RecordingListener() = default;
};
 
struct PublisherOption : public Client::Option {
  /* multisource options */
  struct {
    std::optional<std::string> source_id; 
  } multisource;
 
  struct {
    std::optional<std::string>
        video; 
    std::optional<std::string>
        audio; 
  } codecs;
 
  bool simulcast{false};
 
  std::optional<ScalabilityMode> svc_mode; 
  BitrateSettings
      bitrate_settings; 
  bool record_stream{false}; 
  std::optional<int> priority; 
};
 
inline namespace compat {
 
class MILLICAST_API Publisher : public virtual Client {
 public:
  using Credentials = PublisherCredentials;
  using Listener = PublisherListener;
  using Option = PublisherOption;
 
  virtual bool publish(
      const std::optional<Publisher::Option>& options = std::nullopt) = 0;
 
  virtual bool unpublish() = 0;
 
  [[nodiscard]] virtual bool is_publishing() const = 0;
 
  virtual void record() = 0;
  virtual void unrecord() = 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 add_track(std::weak_ptr<Track> track) = 0;
  virtual void add_track(std::weak_ptr<VideoTrack> track) = 0;
  virtual void add_track(std::weak_ptr<AudioTrack> track) = 0;
 
  virtual void clear_tracks() = 0;
 
  virtual void set_listener(Publisher::Listener* listener) = 0;
  virtual void set_recording_listener(RecordingListener* rlistener) = 0;
 
  static std::unique_ptr<Publisher> create();
};
}  // namespace compat
 
namespace promises {
class MILLICAST_API Publisher : public virtual Client {
 public:
  virtual Promise<void> publish(
      std::optional<PublisherOption>&& options = std::nullopt) = 0;
 
  virtual Promise<void> unpublish() = 0;
 
  [[nodiscard]] virtual Promise<bool> is_publishing() const = 0;
 
  virtual Promise<void> set_credentials(PublisherCredentials&& creds) = 0;
 
  [[nodiscard]] virtual Promise<PublisherCredentials> get_credentials()
      const = 0;
 
  // to be deprecated
  virtual Promise<void> add_track(std::weak_ptr<Track> track) = 0;
 
  // to be deprecated
  virtual Promise<void> add_track(std::weak_ptr<VideoTrack> track) = 0;
 
  // to be deprecated
  virtual Promise<void> add_track(std::weak_ptr<AudioTrack> track) = 0;
 
  // to be deprecated
  virtual Promise<void> clear_tracks() = 0;
 
  virtual Promise<void> set_listener(PublisherListener* listener) = 0;
 
  virtual compat::Publisher& get_old_api() = 0;
 
  static std::unique_ptr<Publisher> create();
 
  virtual Promise<void> record() = 0;
  virtual Promise<void> unrecord() = 0;
};
}  // namespace promises
 
}  // namespace millicast
 
#endif /* MILLICAST_API_PUBLISHER_H */