publisher.h

Go to the documentation of this file.

#ifndef PUBLISHER_H
#define PUBLISHER_H
 
#include "base.h"
#include "config.h"
#include "stream.h"
#include "video_frame.h"
#include "camera_capture_resolution.h"
#include "media_transformer.h"
#include "video_capturer.h"
#include "media_utils.h"
 
OTC_BEGIN_DECL
 
#ifndef OTC_SESSION_FWD_DECL
#define OTC_SESSION_FWD_DECL
typedef struct otc_session otc_session;
#endif
 
#define OTC_MAX_VIDEO_LAYERS 3

typedef struct otc_publisher otc_publisher;

typedef struct otc_publisher_settings otc_publisher_settings;

enum otc_publisher_error_code {
  OTC_PUBLISHER_INTERNAL_ERROR = 2000, 
  OTC_PUBLISHER_SESSION_DISCONNECTED =
      1010, 
  OTC_PUBLISHER_TIMED_OUT = 1541, 
  OTC_PUBLISHER_UNABLE_TO_PUBLISH = 1500, 
  OTC_PUBLISHER_WEBRTC_ERROR = 1610,      
  OTC_PUBLISHER_CAPTIONS_CHANGE_RATE_LIMIT_ERROR = 5010, 
  OTC_PUBLISHER_ENCRYPTION_INTERNAL_ERROR =
      6001, 
  OTC_PUBLISHER_ENCRYPTION_UNSUPPORTED_CODEC = 6005, 
  OTC_PUBLISHER_ENCRYPTION_NOT_ENABLED =
      6007, 
};

enum otc_publisher_video_type {
  OTC_PUBLISHER_VIDEO_TYPE_CAMERA = 1, 
  OTC_PUBLISHER_VIDEO_TYPE_SCREEN = 2  
};

enum otc_media_type {
  OTC_MEDIA_TYPE_VIDEO = 0,
  OTC_MEDIA_TYPE_AUDIO
};

struct otc_publisher_video_layer_stats {
  int32_t width;                
  int32_t height;               
  double encoded_frame_rate;    
  int64_t bitrate;              
  int64_t total_bitrate;        
  const char* scalability_mode; 
  enum otc_video_reason quality_limitation_reason; 
  const char* codec;                               
};

struct otc_publisher_audio_stats {
  const char* connection_id; 
  const char* subscriber_id; 
  int64_t
      packets_lost; 
  int64_t packets_sent; 
  int64_t bytes_sent;   
  float audio_level;    
  double timestamp; 
  double
      start_time; 
  otc_transport_stats transport; 
};

struct otc_publisher_video_stats {
  const char* connection_id; 
  const char* subscriber_id; 
  int64_t
      packets_lost; 
  int64_t packets_sent; 
  int64_t bytes_sent;   
  double timestamp; 
  double
      start_time; 
  size_t number_of_video_layers;                                             
  struct otc_publisher_video_layer_stats video_layers[OTC_MAX_VIDEO_LAYERS]; 
  otc_transport_stats transport; 
};

struct otc_publisher_media_link_stats {
  const char* subscriber_id; 
  const char* connection_id; 
  otc_transport_stats transport; 
};

struct otc_publisher_callbacks {
  void (*on_stream_created)(otc_publisher* publisher,
                            void* user_data,
                            const otc_stream* stream);

  void (*on_stream_destroyed)(otc_publisher* publisher,
                              void* user_data,
                              const otc_stream* stream);

  void (*on_render_frame)(otc_publisher* publisher,
                          void* user_data,
                          const otc_video_frame* frame);

  void (*on_audio_level_updated)(otc_publisher* publisher,
                                 void* user_data,
                                 float audio_level);

    void (*on_publisher_mute_forced)(otc_publisher *publisher,
                                     void *user_data);

  void (*on_audio_stats)(otc_publisher* publisher,
                         void* user_data,
                         struct otc_publisher_audio_stats audio_stats[],
                         size_t number_of_stats);

  void (*on_video_stats)(otc_publisher* publisher,
                         void* user_data,
                         struct otc_publisher_video_stats video_stats[],
                         size_t number_of_stats);
  void (*on_error)(otc_publisher* publisher,
                   void* user_data,
                   const char* error_string,
                   enum otc_publisher_error_code error_code);

  void (*on_video_disabled)(otc_publisher* publisher,
                            void* user_data,
                            enum otc_video_reason reason);

  void (*on_video_enabled)(otc_publisher* publisher,
                           void* user_data,
                           enum otc_video_reason reason);

  void (*on_video_disable_warning)(otc_publisher* publisher, void* user_data);

  void (*on_video_disable_warning_lifted)(otc_publisher* publisher,
                                          void* user_data);

  void (*on_video_quality_changed)(struct otc_publisher* publisher,
                                   void* user_data,
                                   const struct otc_publisher_video_stats* stats,
                                   enum otc_video_reason reason);

  void (*on_network_condition_changed)(otc_publisher* publisher,
                                       void* user_data,
                                       const struct otc_publisher_media_link_stats* stats,
                                       enum otc_network_reason reason);

  void (*on_media_link_stats)(otc_publisher* publisher,
                              void* user_data,
                              struct otc_publisher_media_link_stats media_link_stats[],
                              size_t number_of_stats);

  void* user_data;

  void* reserved;
};

OTC_DECL(otc_publisher*)
otc_publisher_new(const char* name,
                  const struct otc_video_capturer_callbacks* capturer,
                  const struct otc_publisher_callbacks* callbacks);

OTC_DECL(otc_publisher_settings*) otc_publisher_settings_new();

OTC_DECL(otc_status)
otc_publisher_settings_delete(otc_publisher_settings* settings);

OTC_DECL(otc_status)
otc_publisher_settings_set_name(otc_publisher_settings* settings,
                                const char* name);

OTC_DECL(otc_status)
otc_publisher_settings_set_video_capturer(
    otc_publisher_settings* settings,
    const struct otc_video_capturer_callbacks* capturer);

OTC_DECL(otc_status)
otc_publisher_settings_set_audio_track(otc_publisher_settings* settings,
                                       otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_video_track(otc_publisher_settings* settings,
                                       otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_sender_stats_track(otc_publisher_settings* settings, otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_stereo(otc_publisher_settings* settings,
                                  otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_opus_dtx(otc_publisher_settings* settings,
                                    otc_bool enabled);
OTC_DECL(otc_status)
otc_publisher_settings_set_auto_gain_control(otc_publisher_settings* settings,
                                             otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_noise_suppression(otc_publisher_settings* settings,
                                             otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_echo_cancellation(otc_publisher_settings* settings,
                                             otc_bool enabled);
OTC_DECL(otc_status)
otc_publisher_settings_set_disable_audio_processing
 (otc_publisher_settings* settings, otc_bool disabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_default_camera_capture_resolution(otc_publisher_settings* settings,
                                                             const enum otc_camera_capture_resolution camera_capture_resolution);

OTC_DECL(otc_status)
otc_publisher_settings_set_scalable_screenshare(otc_publisher_settings* settings,
                                                const otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_allow_audio_capture_while_muted(otc_publisher_settings* settings, const otc_bool enabled);

OTC_DECL(otc_publisher*)
otc_publisher_new_with_settings(const struct otc_publisher_callbacks* callbacks,
                                otc_publisher_settings* settings);

OTC_DECL(otc_status) otc_publisher_delete(otc_publisher* publisher);

OTC_DECL(otc_stream*) otc_publisher_get_stream(otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_publish_video(otc_publisher* publisher,
                                otc_bool publish_video);

OTC_DECL(otc_status)
otc_publisher_set_publish_audio(otc_publisher* publisher,
                                otc_bool publish_audio);

OTC_DECL(otc_status)
otc_publisher_set_publish_captions(otc_publisher* publisher,
                                   otc_bool publish_captions);

OTC_DECL(otc_bool)
otc_publisher_get_publish_video(const otc_publisher* publisher);

OTC_DECL(otc_bool)
otc_publisher_get_publish_audio(const otc_publisher* publisher);

OTC_DECL(otc_bool)
otc_publisher_get_publish_captions(const otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_captions_input_language(otc_publisher* publisher, const char* language);

OTC_DECL(const char*)
otc_publisher_get_captions_input_language(const otc_publisher* publisher);

OTC_DECL(otc_session*)
otc_publisher_get_session(const otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_max_audio_bitrate(otc_publisher* publisher, uint32_t bitrate);

struct otc_publisher_rtc_stats {
  const char* connection_id;
  const char* json_array_of_reports;
};

struct otc_publisher_rtc_stats_report_cb {
  void *user_data;
  void(*on_rtc_stats_report)(otc_publisher* publisher,
                             void *user_data,
                             const struct otc_publisher_rtc_stats* stats,
                             size_t entries);
  void *reserved;
};

OTC_DECL(otc_status) otc_publisher_set_rtc_stats_report_cb(otc_publisher *publisher,
                                                           const struct otc_publisher_rtc_stats_report_cb cb);
OTC_DECL(otc_status) otc_publisher_get_rtc_stats_report(otc_publisher* publisher);

OTC_DECL(const char*)
otc_publisher_get_publisher_id(const otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_video_type(struct otc_publisher* publisher,
                             enum otc_publisher_video_type video_type);
OTC_DECL(enum otc_publisher_video_type)
otc_publisher_get_video_type(const struct otc_publisher* publisher);

OTC_DECL(void*)
otc_publisher_get_user_data(const struct otc_publisher* publisher);

OTC_DECL(const char*)
otc_publisher_get_name(const struct otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_video_transformers(
    otc_publisher* publisher,
    otc_video_transformer** transformers,
    uint8_t size);

OTC_DECL(otc_status)
otc_publisher_set_audio_transformers(
    otc_publisher* publisher,
    otc_audio_transformer** transformers,
    uint8_t size);

OTC_DECL(otc_status)
otc_publisher_set_target_scalability_mode(otc_publisher* publisher, const char* scalability_mode);

OTC_DECL(const char*)
otc_publisher_get_target_scalability_mode(otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_set_max_video_bitrate(otc_publisher* publisher, int bitrate_bps);

OTC_DECL(int)
otc_publisher_get_max_video_bitrate(const otc_publisher* publisher);

enum otc_video_bitrate_preset {
  OTC_VIDEO_BITRATE_PRESET_DEFAULT,

  OTC_VIDEO_BITRATE_PRESET_BW_SAVER,

  OTC_VIDEO_BITRATE_PRESET_EXTRA_BW_SAVER,

  OTC_VIDEO_BITRATE_PRESET_CUSTOM
};

OTC_DECL(otc_status)
otc_publisher_set_video_bitrate_preset(otc_publisher* publisher, enum otc_video_bitrate_preset preset);

OTC_DECL(enum otc_video_bitrate_preset)
otc_publisher_get_video_bitrate_preset(const otc_publisher* publisher);

enum otc_degradation_preference {
  OTC_DEGRADATION_PREFERENCE_NOT_SET = -1,
  OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION = 0,
  OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE = 1,
  OTC_DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION = 2,
  OTC_DEGRADATION_PREFERENCE_BALANCED = 3
};

OTC_DECL(otc_status)
otc_publisher_set_degradation_preference(otc_publisher* publisher, enum otc_degradation_preference degradation_preference);

OTC_DECL(enum otc_degradation_preference)
otc_publisher_get_degradation_preference(const otc_publisher* publisher);

OTC_DECL(otc_status)
otc_publisher_settings_set_subscriber_audio_fallback_enabled(
    otc_publisher_settings* settings,
    const otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_publisher_audio_fallback_enabled(
    otc_publisher_settings* settings,
    const otc_bool enabled);

OTC_DECL(otc_status)
otc_publisher_settings_set_preferred_video_codecs(
    otc_publisher_settings* settings,
    const otc_video_codec_type* codecs,
    size_t num_codecs);

OTC_DECL(otc_status)
otc_publisher_settings_set_preferred_video_codecs_automatic(
    otc_publisher_settings* settings);
 
OTC_END_DECL
 
#endif  // PUBLISHER_H