publisher.h

Go to the documentation of this file.

#ifndef PUBLISHER_H
#define PUBLISHER_H

#include "config.h"
#include "stream.h"
#include "video_frame.h"
#include "audio_data.h"
#include "camera_capture_resolution.h"
#include "media_transformer.h"

OTC_BEGIN_DECL

#ifndef OTC_SESSION_FWD_DECL
#define OTC_SESSION_FWD_DECL
typedef struct otc_session otc_session;
#endif

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_ENCRYPTION_INTERNAL_ERROR =
      6001, 
};

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_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; 
};

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; 
};

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* 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_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_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_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(const otc_publisher *publisher);

OTC_DECL(otc_status)
otc_publisher_set_audio_fallback_enabled(otc_publisher* publisher,
                                         otc_bool enabled);

OTC_DECL(otc_bool)
otc_publisher_get_audio_fallback_enabled(const 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_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_END_DECL

#endif  // PUBLISHER_H