Agora Java API Reference for Android
AgoraBase.h
1 //
2 // Agora Engine SDK
3 //
4 // Created by Sting Feng in 2017-11.
5 // Copyright (c) 2017 Agora.io. All rights reserved.
6 //
7 
8 // This header file is included by both high level and low level APIs,
9 #pragma once // NOLINT(build/header_guard)
10 
11 #include <stdarg.h>
12 #include <stddef.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <cassert>
16 
17 #include "IAgoraParameter.h"
18 #include "AgoraMediaBase.h"
19 #include "AgoraRefPtr.h"
20 #include "AgoraOptional.h"
21 
22 #define MAX_PATH_260 (260)
23 
24 #if defined(_WIN32)
25 
26 #ifndef WIN32_LEAN_AND_MEAN
27 #define WIN32_LEAN_AND_MEAN
28 #endif // !WIN32_LEAN_AND_MEAN
29 #if defined(__aarch64__)
30 #include <arm64intr.h>
31 #endif
32 #include <Windows.h>
33 
34 #if defined(AGORARTC_EXPORT)
35 #define AGORA_API extern "C" __declspec(dllexport)
36 #else
37 #define AGORA_API extern "C" __declspec(dllimport)
38 #endif // AGORARTC_EXPORT
39 
40 #define AGORA_CALL __cdecl
41 
42 #define __deprecated
43 
44 #elif defined(__APPLE__)
45 
46 #include <TargetConditionals.h>
47 
48 #define AGORA_API extern "C" __attribute__((visibility("default")))
49 #define AGORA_CALL
50 
51 #elif defined(__ANDROID__) || defined(__linux__)
52 
53 #define AGORA_API extern "C" __attribute__((visibility("default")))
54 #define AGORA_CALL
55 
56 #define __deprecated
57 
58 #else // !_WIN32 && !__APPLE__ && !(__ANDROID__ || __linux__)
59 
60 #define AGORA_API extern "C"
61 #define AGORA_CALL
62 
63 #define __deprecated
64 
65 #endif // _WIN32
66 
67 #ifndef OPTIONAL_ENUM_SIZE_T
68 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
69 #define OPTIONAL_ENUM_SIZE_T enum : size_t
70 #else
71 #define OPTIONAL_ENUM_SIZE_T enum
72 #endif
73 #endif
74 
75 #ifndef OPTIONAL_NULLPTR
76 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
77 #define OPTIONAL_NULLPTR nullptr
78 #else
79 #define OPTIONAL_NULLPTR NULL
80 #endif
81 #endif
82 
83 namespace agora {
84 namespace commons {
85 namespace cjson {
86 class JsonWrapper;
87 } // namespace cjson
88 } // namespace commons
89 
90 typedef commons::cjson::JsonWrapper any_document_t;
91 
92 namespace base {
93 class IEngineBase;
94 
96  public:
97  virtual int setParameters(const char* parameters) = 0;
98  virtual int getParameters(const char* key, any_document_t& result) = 0;
99  virtual ~IParameterEngine() {}
100 };
101 } // namespace base
102 
103 namespace util {
104 
105 template <class T>
106 class AutoPtr {
107  protected:
108  typedef T value_type;
109  typedef T* pointer_type;
110 
111  public:
112  explicit AutoPtr(pointer_type p = NULL) : ptr_(p) {}
113 
114  ~AutoPtr() {
115  if (ptr_) {
116  ptr_->release();
117  ptr_ = NULL;
118  }
119  }
120 
121  operator bool() const { return (ptr_ != NULL); }
122 
123  value_type& operator*() const { return *get(); }
124 
125  pointer_type operator->() const { return get(); }
126 
127  pointer_type get() const { return ptr_; }
128 
129  pointer_type release() {
130  pointer_type ret = ptr_;
131  ptr_ = 0;
132  return ret;
133  }
134 
135  void reset(pointer_type ptr = NULL) {
136  if (ptr != ptr_ && ptr_) {
137  ptr_->release();
138  }
139 
140  ptr_ = ptr;
141  }
142 
143  template <class C1, class C2>
144  bool queryInterface(C1* c, C2 iid) {
145  pointer_type p = NULL;
146  if (c && !c->queryInterface(iid, reinterpret_cast<void**>(&p))) {
147  reset(p);
148  }
149 
150  return (p != NULL);
151  }
152 
153  private:
154  AutoPtr(const AutoPtr&);
155  AutoPtr& operator=(const AutoPtr&);
156 
157  private:
158  pointer_type ptr_;
159 };
160 
161 template <class T>
162 class CopyableAutoPtr : public AutoPtr<T> {
163  typedef typename AutoPtr<T>::pointer_type pointer_type;
164 
165  public:
166  explicit CopyableAutoPtr(pointer_type p = 0) : AutoPtr<T>(p) {}
167  explicit CopyableAutoPtr(const CopyableAutoPtr& rhs) { this->reset(rhs.clone()); }
168  CopyableAutoPtr& operator=(const CopyableAutoPtr& rhs) {
169  if (this != &rhs) this->reset(rhs.clone());
170  return *this;
171  }
172  pointer_type clone() const {
173  if (!this->get()) return NULL;
174  return this->get()->clone();
175  }
176 };
177 
178 class IString {
179  public:
180  virtual bool empty() const = 0;
181  virtual const char* c_str() = 0;
182  virtual const char* data() = 0;
183  virtual size_t length() = 0;
184  virtual IString* clone() = 0;
185  virtual void release() = 0;
186  virtual ~IString() {}
187 };
189 
190 class IIterator {
191  public:
192  virtual void* current() = 0;
193  virtual const void* const_current() const = 0;
194  virtual bool next() = 0;
195  virtual void release() = 0;
196  virtual ~IIterator() {}
197 };
198 
199 class IContainer {
200  public:
201  virtual IIterator* begin() = 0;
202  virtual size_t size() const = 0;
203  virtual void release() = 0;
204  virtual ~IContainer() {}
205 };
206 
207 template <class T>
209  IIterator* p;
210 
211  public:
212  typedef T value_type;
213  typedef value_type& reference;
214  typedef const value_type& const_reference;
215  typedef value_type* pointer;
216  typedef const value_type* const_pointer;
217  explicit AOutputIterator(IIterator* it = NULL) : p(it) {}
218  ~AOutputIterator() {
219  if (p) p->release();
220  }
221  AOutputIterator(const AOutputIterator& rhs) : p(rhs.p) {}
222  AOutputIterator& operator++() {
223  p->next();
224  return *this;
225  }
226  bool operator==(const AOutputIterator& rhs) const {
227  if (p && rhs.p)
228  return p->current() == rhs.p->current();
229  else
230  return valid() == rhs.valid();
231  }
232  bool operator!=(const AOutputIterator& rhs) const { return !this->operator==(rhs); }
233  reference operator*() { return *reinterpret_cast<pointer>(p->current()); }
234  const_reference operator*() const { return *reinterpret_cast<const_pointer>(p->const_current()); }
235  bool valid() const { return p && p->current() != NULL; }
236 };
237 
238 template <class T>
239 class AList {
240  IContainer* container;
241  bool owner;
242 
243  public:
244  typedef T value_type;
245  typedef value_type& reference;
246  typedef const value_type& const_reference;
247  typedef value_type* pointer;
248  typedef const value_type* const_pointer;
249  typedef size_t size_type;
252 
253  public:
254  AList() : container(NULL), owner(false) {}
255  AList(IContainer* c, bool take_ownership) : container(c), owner(take_ownership) {}
256  ~AList() { reset(); }
257  void reset(IContainer* c = NULL, bool take_ownership = false) {
258  if (owner && container) container->release();
259  container = c;
260  owner = take_ownership;
261  }
262  iterator begin() { return container ? iterator(container->begin()) : iterator(NULL); }
263  iterator end() { return iterator(NULL); }
264  size_type size() const { return container ? container->size() : 0; }
265  bool empty() const { return size() == 0; }
266 };
267 
268 } // namespace util
269 
273 enum CHANNEL_PROFILE_TYPE {
279  CHANNEL_PROFILE_COMMUNICATION = 0,
285  CHANNEL_PROFILE_LIVE_BROADCASTING = 1,
290  CHANNEL_PROFILE_GAME __deprecated = 2,
297  CHANNEL_PROFILE_CLOUD_GAMING = 3,
298 
303  CHANNEL_PROFILE_COMMUNICATION_1v1 = 4,
304 
310  CHANNEL_PROFILE_LIVE_BROADCASTING_2 = 5,
311 };
312 
316 enum WARN_CODE_TYPE {
321  WARN_INVALID_VIEW = 8,
326  WARN_INIT_VIDEO = 16,
331  WARN_PENDING = 20,
336  WARN_NO_AVAILABLE_CHANNEL = 103,
342  WARN_LOOKUP_CHANNEL_TIMEOUT = 104,
347  WARN_LOOKUP_CHANNEL_REJECTED = 105,
353  WARN_OPEN_CHANNEL_TIMEOUT = 106,
358  WARN_OPEN_CHANNEL_REJECTED = 107,
359 
360  // sdk: 100~1000
364  WARN_SWITCH_LIVE_VIDEO_TIMEOUT = 111,
368  WARN_SET_CLIENT_ROLE_TIMEOUT = 118,
372  WARN_OPEN_CHANNEL_INVALID_TICKET = 121,
376  WARN_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
380  WARN_CHANNEL_CONNECTION_UNRECOVERABLE = 131,
384  WARN_CHANNEL_CONNECTION_IP_CHANGED = 132,
388  WARN_CHANNEL_CONNECTION_PORT_CHANGED = 133,
391  WARN_CHANNEL_SOCKET_ERROR = 134,
395  WARN_AUDIO_MIXING_OPEN_ERROR = 701,
399  WARN_ADM_RUNTIME_PLAYOUT_WARNING = 1014,
403  WARN_ADM_RUNTIME_RECORDING_WARNING = 1016,
407  WARN_ADM_RECORD_AUDIO_SILENCE = 1019,
411  WARN_ADM_PLAYOUT_MALFUNCTION = 1020,
415  WARN_ADM_RECORD_MALFUNCTION = 1021,
422  WARN_ADM_IOS_CATEGORY_NOT_PLAYANDRECORD = 1029,
426  WARN_ADM_IOS_SAMPLERATE_CHANGE = 1030,
430  WARN_ADM_RECORD_AUDIO_LOWLEVEL = 1031,
434  WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = 1032,
442  WARN_ADM_WINDOWS_NO_DATA_READY_EVENT = 1040,
446  WARN_APM_HOWLING = 1051,
450  WARN_ADM_GLITCH_STATE = 1052,
454  WARN_ADM_IMPROPER_SETTINGS = 1053,
458  WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
463  WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
471  WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
472 };
473 
477 enum ERROR_CODE_TYPE {
481  ERR_OK = 0,
482  // 1~1000
486  ERR_FAILED = 1,
491  ERR_INVALID_ARGUMENT = 2,
498  ERR_NOT_READY = 3,
502  ERR_NOT_SUPPORTED = 4,
506  ERR_REFUSED = 5,
510  ERR_BUFFER_TOO_SMALL = 6,
514  ERR_NOT_INITIALIZED = 7,
518  ERR_INVALID_STATE = 8,
523  ERR_NO_PERMISSION = 9,
529  ERR_TIMEDOUT = 10,
534  ERR_CANCELED = 11,
540  ERR_TOO_OFTEN = 12,
546  ERR_BIND_SOCKET = 13,
551  ERR_NET_DOWN = 14,
557  ERR_NET_NOBUFS = 15,
563  ERR_JOIN_CHANNEL_REJECTED = 17,
570  ERR_LEAVE_CHANNEL_REJECTED = 18,
574  ERR_ALREADY_IN_USE = 19,
579  ERR_ABORTED = 20,
584  ERR_INIT_NET_ENGINE = 21,
589  ERR_RESOURCE_LIMITED = 22,
595  ERR_INVALID_APP_ID = 101,
600  ERR_INVALID_CHANNEL_NAME = 102,
606  ERR_NO_SERVER_RESOURCES = 103,
619  ERR_TOKEN_EXPIRED = 109,
636  ERR_INVALID_TOKEN = 110,
641  ERR_CONNECTION_INTERRUPTED = 111, // only used in web sdk
646  ERR_CONNECTION_LOST = 112, // only used in web sdk
651  ERR_NOT_IN_CHANNEL = 113,
656  ERR_SIZE_TOO_LARGE = 114,
661  ERR_BITRATE_LIMIT = 115,
666  ERR_TOO_MANY_DATA_STREAMS = 116,
670  ERR_STREAM_MESSAGE_TIMEOUT = 117,
674  ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
679  ERR_DECRYPTION_FAILED = 120,
683  ERR_INVALID_USER_ID = 121,
687  ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
691  ERR_WATERMARK_PARAM = 124,
695  ERR_WATERMARK_PATH = 125,
699  ERR_WATERMARK_PNG = 126,
703  ERR_WATERMARKR_INFO = 127,
707  ERR_WATERMARK_ARGB = 128,
711  ERR_WATERMARK_READ = 129,
717  ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
718 
722  ERR_LICENSE_CREDENTIAL_INVALID = 131,
723 
727  ERR_INVALID_USER_ACCOUNT = 134,
728 
729  // Licensing, keep the license error code same as the main version
730  ERR_CERT_RAW = 157,
731  ERR_CERT_JSON_PART = 158,
732  ERR_CERT_JSON_INVAL = 159,
733  ERR_CERT_JSON_NOMEM = 160,
734  ERR_CERT_CUSTOM = 161,
735  ERR_CERT_CREDENTIAL = 162,
736  ERR_CERT_SIGN = 163,
737  ERR_CERT_FAIL = 164,
738  ERR_CERT_BUF = 165,
739  ERR_CERT_NULL = 166,
740  ERR_CERT_DUEDATE = 167,
741  ERR_CERT_REQUEST = 168,
742 
743  // PcmSend Error num
744  ERR_PCMSEND_FORMAT =200, // unsupport pcm format
745  ERR_PCMSEND_BUFFEROVERFLOW = 201, // buffer overflow, the pcm send rate too quickly
746 
748  // signaling: 400~600
749  ERR_LOGOUT_OTHER = 400, //
750  ERR_LOGOUT_USER = 401, // logout by user
751  ERR_LOGOUT_NET = 402, // network failure
752  ERR_LOGOUT_KICKED = 403, // login in other device
753  ERR_LOGOUT_PACKET = 404, //
754  ERR_LOGOUT_TOKEN_EXPIRED = 405, // token expired
755  ERR_LOGOUT_OLDVERSION = 406, //
756  ERR_LOGOUT_TOKEN_WRONG = 407,
757  ERR_LOGOUT_ALREADY_LOGOUT = 408,
758  ERR_LOGIN_OTHER = 420,
759  ERR_LOGIN_NET = 421,
760  ERR_LOGIN_FAILED = 422,
761  ERR_LOGIN_CANCELED = 423,
762  ERR_LOGIN_TOKEN_EXPIRED = 424,
763  ERR_LOGIN_OLD_VERSION = 425,
764  ERR_LOGIN_TOKEN_WRONG = 426,
765  ERR_LOGIN_TOKEN_KICKED = 427,
766  ERR_LOGIN_ALREADY_LOGIN = 428,
767  ERR_JOIN_CHANNEL_OTHER = 440,
768  ERR_SEND_MESSAGE_OTHER = 440,
769  ERR_SEND_MESSAGE_TIMEOUT = 441,
770  ERR_QUERY_USERNUM_OTHER = 450,
771  ERR_QUERY_USERNUM_TIMEOUT = 451,
772  ERR_QUERY_USERNUM_BYUSER = 452,
773  ERR_LEAVE_CHANNEL_OTHER = 460,
774  ERR_LEAVE_CHANNEL_KICKED = 461,
775  ERR_LEAVE_CHANNEL_BYUSER = 462,
776  ERR_LEAVE_CHANNEL_LOGOUT = 463,
777  ERR_LEAVE_CHANNEL_DISCONNECTED = 464,
778  ERR_INVITE_OTHER = 470,
779  ERR_INVITE_REINVITE = 471,
780  ERR_INVITE_NET = 472,
781  ERR_INVITE_PEER_OFFLINE = 473,
782  ERR_INVITE_TIMEOUT = 474,
783  ERR_INVITE_CANT_RECV = 475,
785  // 1001~2000
789  ERR_LOAD_MEDIA_ENGINE = 1001,
793  ERR_START_CALL = 1002,
797  ERR_START_CAMERA = 1003,
801  ERR_START_VIDEO_RENDER = 1004,
807  ERR_ADM_GENERAL_ERROR = 1005,
811  ERR_ADM_JAVA_RESOURCE = 1006,
815  ERR_ADM_SAMPLE_RATE = 1007,
820  ERR_ADM_INIT_PLAYOUT = 1008,
824  ERR_ADM_START_PLAYOUT = 1009,
828  ERR_ADM_STOP_PLAYOUT = 1010,
833  ERR_ADM_INIT_RECORDING = 1011,
837  ERR_ADM_START_RECORDING = 1012,
841  ERR_ADM_STOP_RECORDING = 1013,
846  ERR_ADM_RUNTIME_PLAYOUT_ERROR = 1015,
850  ERR_ADM_RUNTIME_RECORDING_ERROR = 1017,
854  ERR_ADM_RECORD_AUDIO_FAILED = 1018,
859  ERR_ADM_INIT_LOOPBACK = 1022,
864  ERR_ADM_START_LOOPBACK = 1023,
869  ERR_ADM_NO_PERMISSION = 1027,
873  ERR_ADM_RECORD_AUDIO_IS_ACTIVE = 1033,
877  ERR_ADM_ANDROID_JNI_JAVA_RESOURCE = 1101,
883  ERR_ADM_ANDROID_JNI_NO_RECORD_FREQUENCY = 1108,
889  ERR_ADM_ANDROID_JNI_NO_PLAYBACK_FREQUENCY = 1109,
897  ERR_ADM_ANDROID_JNI_JAVA_START_RECORD = 1111,
905  ERR_ADM_ANDROID_JNI_JAVA_START_PLAYBACK = 1112,
910  ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR = 1115,
912  ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE __deprecated = 1151,
914  ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER __deprecated = 1153,
916  ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD __deprecated = 1156,
918  ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER __deprecated = 1157,
920  ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD __deprecated = 1160,
927  ERR_ADM_IOS_INPUT_NOT_AVAILABLE = 1201,
931  ERR_ADM_IOS_ACTIVATE_SESSION_FAIL = 1206,
936  ERR_ADM_IOS_VPIO_INIT_FAIL = 1210,
941  ERR_ADM_IOS_VPIO_REINIT_FAIL = 1213,
946  ERR_ADM_IOS_VPIO_RESTART_FAIL = 1214,
947  ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL = 1219,
949  ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO __deprecated = 1221,
957  ERR_ADM_WIN_CORE_INIT = 1301,
964  ERR_ADM_WIN_CORE_INIT_RECORDING = 1303,
971  ERR_ADM_WIN_CORE_INIT_PLAYOUT = 1306,
977  ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL = 1307,
984  ERR_ADM_WIN_CORE_START_RECORDING = 1309,
991  ERR_ADM_WIN_CORE_CREATE_REC_THREAD = 1311,
1000  ERR_ADM_WIN_CORE_CAPTURE_NOT_STARTUP = 1314,
1007  ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD = 1319,
1016  ERR_ADM_WIN_CORE_RENDER_NOT_STARTUP = 1320,
1022  ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
1028  ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
1038  ERR_ADM_WIN_WAVE_INIT = 1351,
1047  ERR_ADM_WIN_WAVE_INIT_RECORDING = 1353,
1056  ERR_ADM_WIN_WAVE_INIT_MICROPHONE = 1354,
1065  ERR_ADM_WIN_WAVE_INIT_PLAYOUT = 1355,
1074  ERR_ADM_WIN_WAVE_INIT_SPEAKER = 1356,
1083  ERR_ADM_WIN_WAVE_START_RECORDING = 1357,
1092  ERR_ADM_WIN_WAVE_START_PLAYOUT = 1358,
1096  ERR_ADM_NO_RECORDING_DEVICE = 1359,
1100  ERR_ADM_NO_PLAYOUT_DEVICE = 1360,
1101 
1102  // VDM error code starts from 1500
1106  ERR_VDM_CAMERA_NOT_AUTHORIZED = 1501,
1107 
1108  // VDM error code starts from 1500
1112  ERR_VDM_WIN_DEVICE_IN_USE = 1502,
1113 
1114  // VCM error code starts from 1600
1118  ERR_VCM_UNKNOWN_ERROR = 1600,
1123  ERR_VCM_ENCODER_INIT_ERROR = 1601,
1127  ERR_VCM_ENCODER_ENCODE_ERROR = 1602,
1131  ERR_VCM_ENCODER_SET_ERROR = 1603,
1132 };
1133 
1137 enum AUDIO_SESSION_OPERATION_RESTRICTION {
1141  AUDIO_SESSION_OPERATION_RESTRICTION_NONE = 0,
1145  AUDIO_SESSION_OPERATION_RESTRICTION_SET_CATEGORY = 1,
1149  AUDIO_SESSION_OPERATION_RESTRICTION_CONFIGURE_SESSION = 1 << 1,
1154  AUDIO_SESSION_OPERATION_RESTRICTION_DEACTIVATE_SESSION = 1 << 2,
1159  AUDIO_SESSION_OPERATION_RESTRICTION_ALL = 1 << 7,
1160 };
1161 
1162 typedef const char* user_id_t;
1163 typedef void* view_t;
1164 
1168 struct UserInfo {
1178  bool hasAudio;
1184  bool hasVideo;
1185 
1186  UserInfo() : hasAudio(false), hasVideo(false) {}
1187 };
1188 
1189 typedef util::AList<UserInfo> UserList;
1190 
1191 // Shared between Agora Service and Rtc Engine
1192 namespace rtc {
1193 
1197 enum USER_OFFLINE_REASON_TYPE {
1201  USER_OFFLINE_QUIT = 0,
1207  USER_OFFLINE_DROPPED = 1,
1211  USER_OFFLINE_BECOME_AUDIENCE = 2,
1212 };
1213 
1214 enum INTERFACE_ID_TYPE {
1215  AGORA_IID_AUDIO_DEVICE_MANAGER = 1,
1216  AGORA_IID_VIDEO_DEVICE_MANAGER = 2,
1217  AGORA_IID_PARAMETER_ENGINE = 3,
1218  AGORA_IID_MEDIA_ENGINE = 4,
1219  AGORA_IID_AUDIO_ENGINE = 5,
1220  AGORA_IID_VIDEO_ENGINE = 6,
1221  AGORA_IID_RTC_CONNECTION = 7,
1222  AGORA_IID_SIGNALING_ENGINE = 8,
1223  AGORA_IID_MEDIA_ENGINE_REGULATOR = 9,
1224  AGORA_IID_CLOUD_SPATIAL_AUDIO = 10,
1225  AGORA_IID_LOCAL_SPATIAL_AUDIO = 11,
1226 };
1227 
1231 enum QUALITY_TYPE {
1236  QUALITY_UNKNOWN __deprecated = 0,
1240  QUALITY_EXCELLENT = 1,
1245  QUALITY_GOOD = 2,
1249  QUALITY_POOR = 3,
1253  QUALITY_BAD = 4,
1257  QUALITY_VBAD = 5,
1261  QUALITY_DOWN = 6,
1265  QUALITY_UNSUPPORTED = 7,
1269  QUALITY_DETECTING
1270 };
1271 
1275 enum FIT_MODE_TYPE {
1280  MODE_COVER = 1,
1281 
1287  MODE_CONTAIN = 2,
1288 };
1289 
1293 enum VIDEO_ORIENTATION {
1297  VIDEO_ORIENTATION_0 = 0,
1301  VIDEO_ORIENTATION_90 = 90,
1305  VIDEO_ORIENTATION_180 = 180,
1309  VIDEO_ORIENTATION_270 = 270
1310 };
1311 
1315 enum FRAME_RATE {
1319  FRAME_RATE_FPS_1 = 1,
1323  FRAME_RATE_FPS_7 = 7,
1327  FRAME_RATE_FPS_10 = 10,
1331  FRAME_RATE_FPS_15 = 15,
1335  FRAME_RATE_FPS_24 = 24,
1339  FRAME_RATE_FPS_30 = 30,
1343  FRAME_RATE_FPS_60 = 60,
1344 };
1345 
1346 enum FRAME_WIDTH {
1347  FRAME_WIDTH_640 = 640,
1348 };
1349 
1350 enum FRAME_HEIGHT {
1351  FRAME_HEIGHT_360 = 360,
1352 };
1353 
1354 
1358 enum VIDEO_FRAME_TYPE {
1360  VIDEO_FRAME_TYPE_BLANK_FRAME = 0,
1362  VIDEO_FRAME_TYPE_KEY_FRAME = 3,
1364  VIDEO_FRAME_TYPE_DELTA_FRAME = 4,
1366  VIDEO_FRAME_TYPE_B_FRAME = 5,
1368  VIDEO_FRAME_TYPE_DROPPABLE_FRAME = 6,
1370  VIDEO_FRAME_TYPE_UNKNOW
1371 };
1372 
1376 enum ORIENTATION_MODE {
1384  ORIENTATION_MODE_ADAPTIVE = 0,
1392  ORIENTATION_MODE_FIXED_LANDSCAPE = 1,
1400  ORIENTATION_MODE_FIXED_PORTRAIT = 2,
1401 };
1402 
1406 enum DEGRADATION_PREFERENCE {
1410  MAINTAIN_QUALITY = 0,
1414  MAINTAIN_FRAMERATE = 1,
1418  MAINTAIN_BALANCED = 2,
1422  MAINTAIN_RESOLUTION = 3,
1426  DISABLED = 100,
1427 };
1428 
1436  int width;
1440  int height;
1441  VideoDimensions() : width(640), height(480) {}
1442  VideoDimensions(int w, int h) : width(w), height(h) {}
1443  bool operator==(const VideoDimensions& rhs) const {
1444  return width == rhs.width && height == rhs.height;
1445  }
1446 };
1447 
1457 const int STANDARD_BITRATE = 0;
1458 
1466 const int COMPATIBLE_BITRATE = -1;
1467 
1471 const int DEFAULT_MIN_BITRATE = -1;
1472 
1476 const int DEFAULT_MIN_BITRATE_EQUAL_TO_TARGET_BITRATE = -2;
1477 
1481 enum VIDEO_CODEC_TYPE {
1482  VIDEO_CODEC_NONE = 0,
1486  VIDEO_CODEC_VP8 = 1,
1490  VIDEO_CODEC_H264 = 2,
1494  VIDEO_CODEC_H265 = 3,
1498  VIDEO_CODEC_VP9 = 5,
1502  VIDEO_CODEC_GENERIC = 6,
1506  VIDEO_CODEC_GENERIC_H264 = 7,
1510  VIDEO_CODEC_AV1 = 12,
1514  VIDEO_CODEC_GENERIC_JPEG = 20,
1515 };
1516 
1520 enum TCcMode {
1524  CC_ENABLED,
1528  CC_DISABLED,
1529 };
1530 
1538  TCcMode ccMode;
1542  VIDEO_CODEC_TYPE codecType;
1543 
1601 
1602  SenderOptions()
1603  : ccMode(CC_ENABLED),
1604  codecType(VIDEO_CODEC_H264),
1605  targetBitrate(6500) {}
1606 };
1607 
1611 enum AUDIO_CODEC_TYPE {
1615  AUDIO_CODEC_OPUS = 1,
1616  // kIsac = 2,
1620  AUDIO_CODEC_PCMA = 3,
1624  AUDIO_CODEC_PCMU = 4,
1628  AUDIO_CODEC_G722 = 5,
1629  // kIlbc = 6,
1631  // AUDIO_CODEC_AAC = 7,
1635  AUDIO_CODEC_AACLC = 8,
1639  AUDIO_CODEC_HEAAC = 9,
1643  AUDIO_CODEC_JC1 = 10,
1644  AUDIO_CODEC_HEAAC2 = 11,
1648  AUDIO_CODEC_LPCNET = 12,
1649 };
1650 
1654 enum AUDIO_ENCODING_TYPE {
1658  AUDIO_ENCODING_TYPE_AAC_16000_LOW = 0x010101,
1662  AUDIO_ENCODING_TYPE_AAC_16000_MEDIUM = 0x010102,
1666  AUDIO_ENCODING_TYPE_AAC_32000_LOW = 0x010201,
1670  AUDIO_ENCODING_TYPE_AAC_32000_MEDIUM = 0x010202,
1674  AUDIO_ENCODING_TYPE_AAC_32000_HIGH = 0x010203,
1678  AUDIO_ENCODING_TYPE_AAC_48000_MEDIUM = 0x010302,
1682  AUDIO_ENCODING_TYPE_AAC_48000_HIGH = 0x010303,
1683 
1687  AUDIO_ENCODING_TYPE_OPUS_16000_LOW = 0x020101,
1691  AUDIO_ENCODING_TYPE_OPUS_16000_MEDIUM = 0x020102,
1695  AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM = 0x020302,
1699  AUDIO_ENCODING_TYPE_OPUS_48000_HIGH = 0x020303,
1700 };
1701 
1705 enum WATERMARK_FIT_MODE {
1710  FIT_MODE_COVER_POSITION,
1715  FIT_MODE_USE_IMAGE_RATIO
1716 };
1717 
1723  : speech(true),
1724  sendEvenIfEmpty(true) {}
1725 
1731  bool speech;
1738 
1739 };
1740 
1746  : codec(AUDIO_CODEC_AACLC),
1747  sampleRateHz(0),
1748  samplesPerChannel(0),
1749  numberOfChannels(0),
1750  captureTimeMs(0) {}
1751 
1753  : codec(rhs.codec),
1762  AUDIO_CODEC_TYPE codec;
1781 
1785  int64_t captureTimeMs;
1786 };
1791  AudioPcmDataInfo() : samplesPerChannel(0), channelNum(0), samplesOut(0), elapsedTimeMs(0), ntpTimeMs(0) {}
1792 
1795  channelNum(rhs.channelNum),
1796  samplesOut(rhs.samplesOut),
1798  ntpTimeMs(rhs.ntpTimeMs) {}
1799 
1804 
1805  int16_t channelNum;
1806 
1807  // Output
1811  size_t samplesOut;
1815  int64_t elapsedTimeMs;
1819  int64_t ntpTimeMs;
1820 };
1824 enum H264PacketizeMode {
1828  NonInterleaved = 0, // Mode 1 - STAP-A, FU-A is allowed
1832  SingleNalUnit, // Mode 0 - only single NALU allowed
1833 };
1834 
1838 enum VIDEO_STREAM_TYPE {
1842  VIDEO_STREAM_HIGH = 0,
1846  VIDEO_STREAM_LOW = 1,
1847 };
1848 
1863 
1865 };
1866 
1872  : codecType(VIDEO_CODEC_H264),
1873  width(0),
1874  height(0),
1875  framesPerSecond(0),
1876  frameType(VIDEO_FRAME_TYPE_BLANK_FRAME),
1877  rotation(VIDEO_ORIENTATION_0),
1878  trackId(0),
1879  decodeTimeMs(0),
1880  captureTimeMs(0),
1881  uid(0),
1882  streamType(VIDEO_STREAM_HIGH) {}
1883 
1885  : codecType(rhs.codecType),
1886  width(rhs.width),
1887  height(rhs.height),
1889  frameType(rhs.frameType),
1890  rotation(rhs.rotation),
1891  trackId(rhs.trackId),
1894  uid(rhs.uid),
1895  streamType(rhs.streamType) {}
1896 
1897  EncodedVideoFrameInfo& operator=(const EncodedVideoFrameInfo& rhs) {
1898  if (this == &rhs) return *this;
1899  codecType = rhs.codecType;
1900  width = rhs.width;
1901  height = rhs.height;
1903  frameType = rhs.frameType;
1904  rotation = rhs.rotation;
1905  trackId = rhs.trackId;
1906  decodeTimeMs = rhs.decodeTimeMs;
1908  uid = rhs.uid;
1909  streamType = rhs.streamType;
1910  return *this;
1911  }
1915  VIDEO_CODEC_TYPE codecType;
1919  int width;
1923  int height;
1934  VIDEO_FRAME_TYPE frameType;
1938  VIDEO_ORIENTATION rotation;
1942  int trackId; // This can be reserved for multiple video tracks, we need to create different ssrc
1943  // and additional payload for later implementation.
1944 
1948  int64_t decodeTimeMs;
1949 
1953  int64_t captureTimeMs;
1954 
1958  uid_t uid;
1962  VIDEO_STREAM_TYPE streamType;
1963 };
1964 
1968 enum VIDEO_MIRROR_MODE_TYPE {
1972  VIDEO_MIRROR_MODE_AUTO = 0,
1976  VIDEO_MIRROR_MODE_ENABLED = 1,
1980  VIDEO_MIRROR_MODE_DISABLED = 2,
1981 };
1982 
1990  VIDEO_CODEC_TYPE codecType;
2053  int bitrate;
2054 
2074  ORIENTATION_MODE orientationMode;
2079  DEGRADATION_PREFERENCE degradationPreference;
2080 
2084  VIDEO_MIRROR_MODE_TYPE mirrorMode;
2085 
2086  VideoEncoderConfiguration(const VideoDimensions& d, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
2087  : codecType(VIDEO_CODEC_H264),
2088  dimensions(d),
2089  frameRate(f),
2090  bitrate(b),
2091  minBitrate(DEFAULT_MIN_BITRATE),
2092  orientationMode(m),
2093  degradationPreference(MAINTAIN_QUALITY),
2094  mirrorMode(mirror) {}
2095  VideoEncoderConfiguration(int width, int height, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
2096  : codecType(VIDEO_CODEC_H264),
2097  dimensions(width, height),
2098  frameRate(f),
2099  bitrate(b),
2100  minBitrate(DEFAULT_MIN_BITRATE),
2101  orientationMode(m),
2102  degradationPreference(MAINTAIN_QUALITY),
2103  mirrorMode(mirror) {}
2104  VideoEncoderConfiguration(const VideoEncoderConfiguration& config)
2105  : codecType(config.codecType),
2106  dimensions(config.dimensions),
2107  frameRate(config.frameRate),
2108  bitrate(config.bitrate),
2109  minBitrate(config.minBitrate),
2112  mirrorMode(config.mirrorMode) {}
2113  VideoEncoderConfiguration()
2114  : codecType(VIDEO_CODEC_H264),
2115  dimensions(FRAME_WIDTH_640, FRAME_HEIGHT_360),
2116  frameRate(FRAME_RATE_FPS_15),
2117  bitrate(STANDARD_BITRATE),
2118  minBitrate(DEFAULT_MIN_BITRATE),
2119  orientationMode(ORIENTATION_MODE_ADAPTIVE),
2120  degradationPreference(MAINTAIN_QUALITY),
2121  mirrorMode(VIDEO_MIRROR_MODE_DISABLED) {}
2122 
2123  VideoEncoderConfiguration& operator=(const VideoEncoderConfiguration& rhs) {
2124  if (this == &rhs) return *this;
2125  codecType = rhs.codecType;
2126  dimensions = rhs.dimensions;
2127  frameRate = rhs.frameRate;
2128  bitrate = rhs.bitrate;
2129  minBitrate = rhs.minBitrate;
2130  orientationMode = rhs.orientationMode;
2131  degradationPreference = rhs.degradationPreference;
2132  mirrorMode = rhs.mirrorMode;
2133  return *this;
2134  }
2135 };
2136 
2145  bool ordered;
2146 };
2147 
2159  int bitrate;
2164  SimulcastStreamConfig() : dimensions(160, 120), bitrate(65), framerate(5) {}
2165  bool operator==(const SimulcastStreamConfig& rhs) const {
2166  return dimensions == rhs.dimensions && bitrate == rhs.bitrate && framerate == rhs.framerate;
2167  }
2168 };
2169 
2173 struct Rectangle {
2177  int x;
2181  int y;
2185  int width;
2189  int height;
2190 
2191  Rectangle() : x(0), y(0), width(0), height(0) {}
2192  Rectangle(int xx, int yy, int ww, int hh) : x(xx), y(yy), width(ww), height(hh) {}
2193 };
2194 
2200  float xRatio;
2204  float yRatio;
2208  float widthRatio;
2209 
2210  WatermarkRatio() : xRatio(0.0), yRatio(0.0), widthRatio(0.0) {}
2211  WatermarkRatio(float x, float y, float width) : xRatio(x), yRatio(y), widthRatio(width) {}
2212 };
2213 
2238  WATERMARK_FIT_MODE mode;
2239 
2241  : visibleInPreview(false),
2242  positionInLandscapeMode(0, 0, 0, 0),
2243  positionInPortraitMode(0, 0, 0, 0),
2244  mode(FIT_MODE_COVER_POSITION) {}
2245 };
2246 
2250 struct RtcStats {
2254  unsigned int duration;
2258  unsigned int txBytes;
2262  unsigned int rxBytes;
2266  unsigned int txAudioBytes;
2270  unsigned int txVideoBytes;
2274  unsigned int rxAudioBytes;
2278  unsigned int rxVideoBytes;
2282  unsigned short txKBitRate;
2286  unsigned short rxKBitRate;
2290  unsigned short rxAudioKBitRate;
2294  unsigned short txAudioKBitRate;
2298  unsigned short rxVideoKBitRate;
2302  unsigned short txVideoKBitRate;
2306  unsigned short lastmileDelay;
2310  unsigned int userCount;
2314  double cpuAppUsage;
2393  RtcStats()
2394  : duration(0),
2395  txBytes(0),
2396  rxBytes(0),
2397  txAudioBytes(0),
2398  txVideoBytes(0),
2399  rxAudioBytes(0),
2400  rxVideoBytes(0),
2401  txKBitRate(0),
2402  rxKBitRate(0),
2403  rxAudioKBitRate(0),
2404  txAudioKBitRate(0),
2405  rxVideoKBitRate(0),
2406  txVideoKBitRate(0),
2407  lastmileDelay(0),
2408  userCount(0),
2409  cpuAppUsage(0.0),
2410  cpuTotalUsage(0.0),
2411  gatewayRtt(0),
2412  memoryAppUsageRatio(0.0),
2413  memoryTotalUsageRatio(0.0),
2415  connectTimeMs(0),
2425  txPacketLossRate(0),
2426  rxPacketLossRate(0) {}
2427 };
2428 
2432 enum VIDEO_SOURCE_TYPE {
2435  VIDEO_SOURCE_CAMERA_PRIMARY,
2436  VIDEO_SOURCE_CAMERA = VIDEO_SOURCE_CAMERA_PRIMARY,
2439  VIDEO_SOURCE_CAMERA_SECONDARY,
2442  VIDEO_SOURCE_SCREEN_PRIMARY,
2443  VIDEO_SOURCE_SCREEN = VIDEO_SOURCE_SCREEN_PRIMARY,
2446  VIDEO_SOURCE_SCREEN_SECONDARY,
2449  VIDEO_SOURCE_CUSTOM,
2452  VIDEO_SOURCE_MEDIA_PLAYER,
2455  VIDEO_SOURCE_RTC_IMAGE_PNG,
2458  VIDEO_SOURCE_RTC_IMAGE_JPEG,
2461  VIDEO_SOURCE_RTC_IMAGE_GIF,
2464  VIDEO_SOURCE_REMOTE,
2467  VIDEO_SOURCE_TRANSCODED,
2468 
2469  VIDEO_SOURCE_UNKNOWN = 100
2470 };
2471 
2475 enum CLIENT_ROLE_TYPE {
2479  CLIENT_ROLE_BROADCASTER = 1,
2483  CLIENT_ROLE_AUDIENCE = 2,
2484 };
2485 
2488 enum QUALITY_ADAPT_INDICATION {
2490  ADAPT_NONE = 0,
2492  ADAPT_UP_BANDWIDTH = 1,
2494  ADAPT_DOWN_BANDWIDTH = 2,
2495 };
2496 
2498 enum AUDIENCE_LATENCY_LEVEL_TYPE
2499 {
2501  AUDIENCE_LATENCY_LEVEL_LOW_LATENCY = 1,
2503  AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY = 2,
2504 };
2505 
2509 {
2513  AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel;
2515  : audienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY) {}
2516 };
2517 
2521 enum EXPERIENCE_QUALITY_TYPE {
2523  EXPERIENCE_QUALITY_GOOD = 0,
2525  EXPERIENCE_QUALITY_BAD = 1,
2526 };
2527 
2532 enum EXPERIENCE_POOR_REASON {
2535  EXPERIENCE_REASON_NONE = 0,
2538  REMOTE_NETWORK_QUALITY_POOR = 1,
2541  LOCAL_NETWORK_QUALITY_POOR = 2,
2544  WIRELESS_SIGNAL_POOR = 4,
2548  WIFI_BLUETOOTH_COEXIST = 8,
2549 };
2550 
2556 {
2560  uid_t uid;
2564  int quality;
2636 
2637  RemoteAudioStats() :
2638  uid(0),
2639  quality(0),
2641  jitterBufferDelay(0),
2642  audioLossRate(0),
2643  numChannels(0),
2644  receivedSampleRate(0),
2645  receivedBitrate(0),
2646  totalFrozenTime(0),
2647  frozenRate(0),
2648  mosValue(0),
2649  totalActiveTime(0),
2650  publishDuration(0),
2651  qoeQuality(0),
2653 };
2654 
2658 enum AUDIO_PROFILE_TYPE {
2666  AUDIO_PROFILE_DEFAULT = 0,
2670  AUDIO_PROFILE_SPEECH_STANDARD = 1,
2674  AUDIO_PROFILE_MUSIC_STANDARD = 2,
2679  AUDIO_PROFILE_MUSIC_STANDARD_STEREO = 3,
2683  AUDIO_PROFILE_MUSIC_HIGH_QUALITY = 4,
2687  AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = 5,
2691  AUDIO_PROFILE_IOT = 6,
2692  AUDIO_PROFILE_NUM = 7
2693 };
2694 
2698 enum AUDIO_SCENARIO_TYPE {
2702  AUDIO_SCENARIO_DEFAULT = 0,
2708  AUDIO_SCENARIO_GAME_STREAMING = 3,
2714  AUDIO_SCENARIO_CHATROOM = 5,
2718  AUDIO_SCENARIO_HIGH_DEFINITION = 6,
2722  AUDIO_SCENARIO_CHORUS = 7,
2726  AUDIO_SCENARIO_NUM = 8,
2727 };
2728 
2732 struct VideoFormat {
2733  OPTIONAL_ENUM_SIZE_T {
2735  kMaxWidthInPixels = 3840,
2737  kMaxHeightInPixels = 2160,
2739  kMaxFps = 60,
2740  };
2741 
2745  int width; // Number of pixels.
2749  int height; // Number of pixels.
2753  int fps;
2754  VideoFormat() : width(FRAME_WIDTH_640), height(FRAME_HEIGHT_360), fps(FRAME_RATE_FPS_15) {}
2755  VideoFormat(int w, int h, int f) : width(w), height(h), fps(f) {}
2756 
2757  bool operator <(const VideoFormat& fmt) const {
2758  if (height != fmt.height) {
2759  return height < fmt.height;
2760  } else if (width != fmt.width) {
2761  return width < fmt.width;
2762  } else {
2763  return fps < fmt.fps;
2764  }
2765  }
2766 };
2767 
2771 enum VIDEO_CONTENT_HINT {
2775  CONTENT_HINT_NONE,
2782  CONTENT_HINT_MOTION,
2788  CONTENT_HINT_DETAILS
2789 };
2790 
2791 enum SCREEN_SCENARIO_TYPE {
2792  SCREEN_SCENARIO_DOCUMENT = 1,
2793  SCREEN_SCENARIO_GAMING = 2,
2794  SCREEN_SCENARIO_VIDEO = 3,
2795  SCREEN_SCENARIO_RDC = 4,
2796 };
2797 
2801 enum LOCAL_AUDIO_STREAM_STATE {
2805  LOCAL_AUDIO_STREAM_STATE_STOPPED = 0,
2809  LOCAL_AUDIO_STREAM_STATE_RECORDING = 1,
2813  LOCAL_AUDIO_STREAM_STATE_ENCODING = 2,
2817  LOCAL_AUDIO_STREAM_STATE_FAILED = 3
2818 };
2819 
2823 enum LOCAL_AUDIO_STREAM_ERROR {
2827  LOCAL_AUDIO_STREAM_ERROR_OK = 0,
2831  LOCAL_AUDIO_STREAM_ERROR_FAILURE = 1,
2835  LOCAL_AUDIO_STREAM_ERROR_DEVICE_NO_PERMISSION = 2,
2839  LOCAL_AUDIO_STREAM_ERROR_DEVICE_BUSY = 3,
2844  LOCAL_AUDIO_STREAM_ERROR_RECORD_FAILURE = 4,
2848  LOCAL_AUDIO_STREAM_ERROR_ENCODE_FAILURE = 5
2849 };
2850 
2853 enum LOCAL_VIDEO_STREAM_STATE {
2857  LOCAL_VIDEO_STREAM_STATE_STOPPED = 0,
2861  LOCAL_VIDEO_STREAM_STATE_CAPTURING = 1,
2865  LOCAL_VIDEO_STREAM_STATE_ENCODING = 2,
2869  LOCAL_VIDEO_STREAM_STATE_FAILED = 3
2870 };
2871 
2875 enum LOCAL_VIDEO_STREAM_ERROR {
2877  LOCAL_VIDEO_STREAM_ERROR_OK = 0,
2879  LOCAL_VIDEO_STREAM_ERROR_FAILURE = 1,
2881  LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION = 2,
2883  LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY = 3,
2885  LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE = 4,
2887  LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE = 5,
2889  LOCAL_VIDEO_STREAM_ERROR_CAPTURE_INBACKGROUND = 6,
2891  LOCAL_VIDEO_STREAM_ERROR_CAPTURE_MULTIPLE_FOREGROUND_APPS = 7,
2893  LOCAL_VIDEO_STREAM_ERROR_DEVICE_NOT_FOUND = 8,
2895  LOCAL_VIDEO_STREAM_ERROR_DEVICE_DISCONNECTED = 9,
2897  LOCAL_VIDEO_STREAM_ERROR_DEVICE_INVALID_ID = 10,
2899  LOCAL_VIDEO_STREAM_ERROR_DEVICE_SYSTEM_PRESSURE = 101,
2901  LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
2903  LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_CLOSED = 12,
2905  LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_OCCLUDED = 13,
2907  LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_NOT_SUPPORTED = 20,
2908 };
2909 
2913 enum REMOTE_AUDIO_STATE
2914 {
2921  REMOTE_AUDIO_STATE_STOPPED = 0, // Default state, audio is started or remote user disabled/muted audio stream
2925  REMOTE_AUDIO_STATE_STARTING = 1, // The first audio frame packet has been received
2932  REMOTE_AUDIO_STATE_DECODING = 2, // The first remote audio frame has been decoded or fronzen state ends
2937  REMOTE_AUDIO_STATE_FROZEN = 3, // Remote audio is frozen, probably due to network issue
2942  REMOTE_AUDIO_STATE_FAILED = 4, // Remote audio play failed
2943 };
2944 
2948 enum REMOTE_AUDIO_STATE_REASON
2949 {
2953  REMOTE_AUDIO_REASON_INTERNAL = 0,
2957  REMOTE_AUDIO_REASON_NETWORK_CONGESTION = 1,
2961  REMOTE_AUDIO_REASON_NETWORK_RECOVERY = 2,
2966  REMOTE_AUDIO_REASON_LOCAL_MUTED = 3,
2971  REMOTE_AUDIO_REASON_LOCAL_UNMUTED = 4,
2976  REMOTE_AUDIO_REASON_REMOTE_MUTED = 5,
2981  REMOTE_AUDIO_REASON_REMOTE_UNMUTED = 6,
2985  REMOTE_AUDIO_REASON_REMOTE_OFFLINE = 7,
2986 };
2987 
2989 enum REMOTE_VIDEO_STATE {
2995  REMOTE_VIDEO_STATE_STOPPED = 0,
2998  REMOTE_VIDEO_STATE_STARTING = 1,
3005  REMOTE_VIDEO_STATE_DECODING = 2,
3010  REMOTE_VIDEO_STATE_FROZEN = 3,
3014  REMOTE_VIDEO_STATE_FAILED = 4,
3015 };
3017 enum REMOTE_VIDEO_STATE_REASON {
3021  REMOTE_VIDEO_STATE_REASON_INTERNAL = 0,
3022 
3026  REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = 1,
3027 
3031  REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = 2,
3032 
3036  REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = 3,
3037 
3041  REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = 4,
3042 
3046  REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = 5,
3047 
3051  REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = 6,
3052 
3056  REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = 7,
3057 
3061  REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = 8,
3062 
3066  REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = 9,
3067 
3071  REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_LOW = 10,
3075  REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_HIGH = 11,
3076 
3077 };
3078 
3082 enum REMOTE_USER_STATE {
3086  USER_STATE_MUTE_AUDIO = (1 << 0),
3090  USER_STATE_MUTE_VIDEO = (1 << 1),
3094  USER_STATE_ENABLE_VIDEO = (1 << 4),
3098  USER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
3099 
3100 };
3101 
3107  VideoTrackInfo()
3108  : isLocal(false), ownerUid(0), trackId(0), channelId(OPTIONAL_NULLPTR)
3109  , streamType(VIDEO_STREAM_HIGH), codecType(VIDEO_CODEC_H264)
3110  , encodedFrameOnly(false), sourceType(VIDEO_SOURCE_CAMERA_PRIMARY)
3111  , observationPosition(agora::media::base::POSITION_POST_CAPTURER) {}
3117  bool isLocal;
3121  uid_t ownerUid;
3122 
3126  track_id_t trackId;
3130  const char* channelId;
3134  VIDEO_STREAM_TYPE streamType;
3138  VIDEO_CODEC_TYPE codecType;
3148  VIDEO_SOURCE_TYPE sourceType;
3153 };
3154 
3158 enum REMOTE_VIDEO_DOWNSCALE_LEVEL {
3162  REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE,
3166  REMOTE_VIDEO_DOWNSCALE_LEVEL_1,
3170  REMOTE_VIDEO_DOWNSCALE_LEVEL_2,
3174  REMOTE_VIDEO_DOWNSCALE_LEVEL_3,
3178  REMOTE_VIDEO_DOWNSCALE_LEVEL_4,
3179 };
3180 
3188  uid_t uid;
3189 
3193  unsigned int volume; // [0,255]
3194 
3195  /*
3196  * The activity status of remote users
3197  */
3198  unsigned int vad;
3199 
3203  double voicePitch;
3204 
3205  AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
3206 };
3207 
3211 struct DeviceInfo {
3212  /*
3213  * Whether the device support low latency audio. Not support by default
3214  */
3215  bool isLowLatencyAudioSupported;
3216 
3217  DeviceInfo() : isLowLatencyAudioSupported(false) {}
3218 };
3219 
3224  public:
3225  virtual ~IPacketObserver() {}
3229  struct Packet {
3233  const unsigned char* buffer;
3237  unsigned int size;
3238 
3239  Packet() : buffer(NULL), size(0) {}
3240  };
3248  virtual bool onSendAudioPacket(Packet& packet) = 0;
3256  virtual bool onSendVideoPacket(Packet& packet) = 0;
3264  virtual bool onReceiveAudioPacket(Packet& packet) = 0;
3272  virtual bool onReceiveVideoPacket(Packet& packet) = 0;
3273 };
3278  public:
3288  virtual bool OnEncodedVideoImageReceived(const uint8_t* imageBuffer, size_t length,
3289  const EncodedVideoFrameInfo& videoEncodedFrameInfo) = 0;
3290 
3291  virtual ~IVideoEncodedImageReceiver() {}
3292 };
3293 
3297 enum AUDIO_SAMPLE_RATE_TYPE {
3301  AUDIO_SAMPLE_RATE_32000 = 32000,
3305  AUDIO_SAMPLE_RATE_44100 = 44100,
3309  AUDIO_SAMPLE_RATE_48000 = 48000,
3310 };
3311 enum VIDEO_CODEC_TYPE_FOR_STREAM {
3315  VIDEO_CODEC_H264_FOR_STREAM = 1,
3319  VIDEO_CODEC_H265_FOR_STREAM = 2,
3320 };
3321 
3325 enum VIDEO_CODEC_PROFILE_TYPE {
3329  VIDEO_CODEC_PROFILE_BASELINE = 66,
3333  VIDEO_CODEC_PROFILE_MAIN = 77,
3337  VIDEO_CODEC_PROFILE_HIGH = 100,
3338 };
3339 
3340 
3344 enum AUDIO_CODEC_PROFILE_TYPE {
3348  AUDIO_CODEC_PROFILE_LC_AAC = 0,
3352  AUDIO_CODEC_PROFILE_HE_AAC = 1,
3356  AUDIO_CODEC_PROFILE_HE_AAC_V2 = 2,
3357 };
3358 
3364 {
3384  unsigned short txPacketLossRate;
3389 };
3390 
3391 
3395 enum RTMP_STREAM_PUBLISH_STATE {
3398  RTMP_STREAM_PUBLISH_STATE_IDLE = 0,
3401  RTMP_STREAM_PUBLISH_STATE_CONNECTING = 1,
3404  RTMP_STREAM_PUBLISH_STATE_RUNNING = 2,
3410  RTMP_STREAM_PUBLISH_STATE_RECOVERING = 3,
3413  RTMP_STREAM_PUBLISH_STATE_FAILURE = 4,
3416  RTMP_STREAM_PUBLISH_STATE_DISCONNECTING = 5,
3417 };
3418 
3422 enum RTMP_STREAM_PUBLISH_ERROR_TYPE {
3424  RTMP_STREAM_PUBLISH_ERROR_OK = 0,
3426  RTMP_STREAM_PUBLISH_ERROR_INVALID_ARGUMENT = 1,
3428  RTMP_STREAM_PUBLISH_ERROR_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
3430  RTMP_STREAM_PUBLISH_ERROR_CONNECTION_TIMEOUT = 3,
3432  RTMP_STREAM_PUBLISH_ERROR_INTERNAL_SERVER_ERROR = 4,
3434  RTMP_STREAM_PUBLISH_ERROR_RTMP_SERVER_ERROR = 5,
3436  RTMP_STREAM_PUBLISH_ERROR_TOO_OFTEN = 6,
3438  RTMP_STREAM_PUBLISH_ERROR_REACH_LIMIT = 7,
3440  RTMP_STREAM_PUBLISH_ERROR_NOT_AUTHORIZED = 8,
3442  RTMP_STREAM_PUBLISH_ERROR_STREAM_NOT_FOUND = 9,
3444  RTMP_STREAM_PUBLISH_ERROR_FORMAT_NOT_SUPPORTED = 10,
3446  RTMP_STREAM_PUBLISH_ERROR_NOT_BROADCASTER = 11, // Note: match to ERR_PUBLISH_STREAM_NOT_BROADCASTER in AgoraBase.h
3448  RTMP_STREAM_PUBLISH_ERROR_TRANSCODING_NO_MIX_STREAM = 13, // Note: match to ERR_PUBLISH_STREAM_TRANSCODING_NO_MIX_STREAM in AgoraBase.h
3450  RTMP_STREAM_PUBLISH_ERROR_NET_DOWN = 14, // Note: match to ERR_NET_DOWN in AgoraBase.h
3452  RTMP_STREAM_PUBLISH_ERROR_INVALID_APPID = 15, // Note: match to ERR_PUBLISH_STREAM_APPID_INVALID in AgoraBase.h
3460  RTMP_STREAM_UNPUBLISH_ERROR_OK = 100,
3461 };
3462 
3464 enum RTMP_STREAMING_EVENT {
3467  RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = 1,
3472  RTMP_STREAMING_EVENT_URL_ALREADY_IN_USE = 2,
3475  RTMP_STREAMING_EVENT_ADVANCED_FEATURE_NOT_SUPPORT = 3,
3478  RTMP_STREAMING_EVENT_REQUEST_TOO_OFTEN = 4,
3479 };
3480 
3483 typedef struct RtcImage {
3487  const char* url;
3492  int x;
3497  int y;
3501  int width;
3505  int height;
3509  int zOrder;
3515  double alpha;
3516 
3517  RtcImage() : url(NULL), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0) {}
3518 } RtcImage;
3519 
3521  LiveStreamAdvancedFeature() : featureName(NULL), opened(false) {}
3522  LiveStreamAdvancedFeature(const char* feat_name, bool open) : featureName(feat_name), opened(open) {}
3524  // static const char* LBHQ = "lbhq";
3526  // static const char* VEO = "veo";
3527 
3532  const char* featureName;
3533 
3538  bool opened;
3539 } ;
3540 
3544 enum CONNECTION_STATE_TYPE
3545 {
3549  CONNECTION_STATE_DISCONNECTED = 1,
3553  CONNECTION_STATE_CONNECTING = 2,
3558  CONNECTION_STATE_CONNECTED = 3,
3563  CONNECTION_STATE_RECONNECTING = 4,
3567  CONNECTION_STATE_FAILED = 5,
3568 };
3569 
3577  uid_t uid;
3581  int x;
3585  int y;
3589  int width;
3593  int height;
3599  int zOrder;
3603  double alpha;
3620  TranscodingUser()
3621  : uid(0),
3622  x(0),
3623  y(0),
3624  width(0),
3625  height(0),
3626  zOrder(0),
3627  alpha(1.0),
3628  audioChannel(0) {}
3629 };
3630 
3641  int width;
3648  int height;
3659 
3666 
3674  VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
3677  unsigned int backgroundColor;
3678 
3680  VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType;
3681 
3685  unsigned int userCount;
3694 
3697  const char* metadata;
3703 
3711  unsigned int watermarkCount;
3712 
3725  unsigned int backgroundImageCount;
3726 
3729  AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
3745  AUDIO_CODEC_PROFILE_TYPE audioCodecProfile;
3747 
3751  LiveStreamAdvancedFeature* advancedFeatures;
3752 
3754  unsigned int advancedFeatureCount;
3756  LiveTranscoding() : width(360), height(640), videoBitrate(400), videoFramerate(15), lowLatency(false), videoGop(30), videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH), backgroundColor(0x000000), videoCodecType(VIDEO_CODEC_H264_FOR_STREAM), userCount(0), transcodingUsers(NULL), transcodingExtraInfo(NULL), metadata(NULL), watermark(NULL), watermarkCount(0), backgroundImage(NULL), backgroundImageCount(0), audioSampleRate(AUDIO_SAMPLE_RATE_48000), audioBitrate(48), audioChannels(1), audioCodecProfile(AUDIO_CODEC_PROFILE_LC_AAC), advancedFeatures(NULL), advancedFeatureCount(0) {}
3757 };
3758 
3766  agora::media::MEDIA_SOURCE_TYPE sourceType;
3774  const char* imageUrl;
3778  int x;
3782  int y;
3786  int width;
3790  int height;
3796  int zOrder;
3800  double alpha;
3804  bool mirror;
3805 
3807  : sourceType(agora::media::PRIMARY_CAMERA_SOURCE),
3808  remoteUserUid(0),
3809  imageUrl(NULL),
3810  x(0),
3811  y(0),
3812  width(0),
3813  height(0),
3814  zOrder(0),
3815  alpha(1.0),
3816  mirror(false) {}
3817 };
3818 
3819 
3827  unsigned int streamCount;
3836 
3838  : streamCount(0),
3839  VideoInputStreams(NULL),
3841 };
3842 
3871 };
3872 
3876 enum LASTMILE_PROBE_RESULT_STATE {
3880  LASTMILE_PROBE_RESULT_COMPLETE = 1,
3885  LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = 2,
3890  LASTMILE_PROBE_RESULT_UNAVAILABLE = 3
3891 };
3892 
3901  unsigned int packetLossRate;
3905  unsigned int jitter;
3909  unsigned int availableBandwidth;
3910 
3912  jitter(0),
3913  availableBandwidth(0) {}
3914 };
3915 
3924  LASTMILE_PROBE_RESULT_STATE state;
3936  unsigned int rtt;
3937 
3939  : state(LASTMILE_PROBE_RESULT_UNAVAILABLE),
3940  rtt(0) {}
3941 };
3942 
3946 enum CONNECTION_CHANGED_REASON_TYPE
3947 {
3951  CONNECTION_CHANGED_CONNECTING = 0,
3955  CONNECTION_CHANGED_JOIN_SUCCESS = 1,
3959  CONNECTION_CHANGED_INTERRUPTED = 2,
3963  CONNECTION_CHANGED_BANNED_BY_SERVER = 3,
3967  CONNECTION_CHANGED_JOIN_FAILED = 4,
3971  CONNECTION_CHANGED_LEAVE_CHANNEL = 5,
3975  CONNECTION_CHANGED_INVALID_APP_ID = 6,
3979  CONNECTION_CHANGED_INVALID_CHANNEL_NAME = 7,
3983  CONNECTION_CHANGED_INVALID_TOKEN = 8,
3987  CONNECTION_CHANGED_TOKEN_EXPIRED = 9,
3991  CONNECTION_CHANGED_REJECTED_BY_SERVER = 10,
3995  CONNECTION_CHANGED_SETTING_PROXY_SERVER = 11,
3999  CONNECTION_CHANGED_RENEW_TOKEN = 12,
4004  CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = 13,
4008  CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = 14,
4012  CONNECTION_CHANGED_REJOIN_SUCCESS = 15,
4016  CONNECTION_CHANGED_LOST = 16,
4020  CONNECTION_CHANGED_ECHO_TEST = 17,
4024  CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED_BY_USER = 18,
4028  CONNECTION_CHANGED_SAME_UID_LOGIN = 19,
4032  CONNECTION_CHANGED_TOO_MANY_BROADCASTERS = 20,
4033 };
4034 
4038 enum CLIENT_ROLE_CHANGE_FAILED_REASON {
4042  CLIENT_ROLE_CHANGE_FAILED_TOO_MANY_BROADCASTERS = 1,
4046  CLIENT_ROLE_CHANGE_FAILED_NOT_AUTHORIZED = 2,
4050  CLIENT_ROLE_CHANGE_FAILED_REQUEST_TIME_OUT = 3,
4054  CLIENT_ROLE_CHANGE_FAILED_CONNECTION_FAILED = 4,
4055 };
4056 
4060 enum NETWORK_TYPE {
4064  NETWORK_TYPE_UNKNOWN = -1,
4068  NETWORK_TYPE_DISCONNECTED = 0,
4072  NETWORK_TYPE_LAN = 1,
4076  NETWORK_TYPE_WIFI = 2,
4080  NETWORK_TYPE_MOBILE_2G = 3,
4084  NETWORK_TYPE_MOBILE_3G = 4,
4088  NETWORK_TYPE_MOBILE_4G = 5,
4089 };
4090 
4094 enum VIDEO_VIEW_SETUP_MODE {
4098  VIDEO_VIEW_SETUP_REPLACE = 0,
4102  VIDEO_VIEW_SETUP_ADD = 1,
4106  VIDEO_VIEW_SETUP_REMOVE = 2,
4107 };
4108 
4112 struct VideoCanvas {
4116  view_t view;
4120  media::base::RENDER_MODE_TYPE renderMode;
4124  VIDEO_MIRROR_MODE_TYPE mirrorMode;
4128  uid_t uid;
4129  bool isScreenView;
4130 
4131  void* priv; // private data (underlying video engine denotes it)
4132 
4133  size_t priv_size;
4134 
4135  VIDEO_SOURCE_TYPE sourceType;
4136 
4137  Rectangle cropArea;
4138 
4139  VIDEO_VIEW_SETUP_MODE setupMode;
4140 
4141  VideoCanvas() : view(NULL), renderMode(media::base::RENDER_MODE_HIDDEN), mirrorMode(VIDEO_MIRROR_MODE_AUTO),
4142  uid(0), isScreenView(false), priv(NULL), priv_size(0), sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), setupMode(VIDEO_VIEW_SETUP_REPLACE) {}
4143  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u)
4144  : view(v), renderMode(m), mirrorMode(mt), uid(u), isScreenView(false), priv(NULL), priv_size(0),
4145  sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), setupMode(VIDEO_VIEW_SETUP_REPLACE) {}
4146  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, user_id_t)
4147  : view(v), renderMode(m), mirrorMode(mt), uid(0), isScreenView(false), priv(NULL), priv_size(0),
4148  sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), setupMode(VIDEO_VIEW_SETUP_REPLACE) {}
4149 };
4150 
4163  };
4164 
4168 
4171 
4175 
4179 
4183 
4184  BeautyOptions(LIGHTENING_CONTRAST_LEVEL contrastLevel, float lightening, float smoothness, float redness, float sharpness) : lighteningContrastLevel(contrastLevel), lighteningLevel(lightening), smoothnessLevel(smoothness), rednessLevel(redness), sharpnessLevel(sharpness) {}
4185 
4187 };
4188 
4189 
4204  };
4205 
4215  };
4216 
4220 
4229  unsigned int color;
4230 
4237  const char* source;
4238 
4241 
4243 };
4244 
4246  float _x_center;
4247  float _y_center;
4248  float _scale_factor;
4249  float _focal_length;
4250  float _pol_focal_length;
4251  float _split_height;
4252  float _ss[5];
4253  FishCorrectionParams():_x_center(0.49),
4254  _y_center(0.48),
4255  _scale_factor(4.5),
4256  _focal_length(31),
4257  _pol_focal_length(31),
4258  _split_height(1.0) {
4259  _ss[0] = 0.9375;
4260  _ss[1] = 0.0;
4261  _ss[2] = -2.9440;
4262  _ss[3] = 5.7344;
4263  _ss[4] = -4.4564;
4264  }
4265  FishCorrectionParams(float x_center, float y_center, float scale_factor, float focal_length, float pol_focal_length, float split_height, float ss[])
4266  : _x_center(x_center),
4267  _y_center(y_center),
4268  _scale_factor(scale_factor),
4269  _focal_length(focal_length),
4270  _pol_focal_length(pol_focal_length),
4271  _split_height(split_height) {
4272  if (ss != OPTIONAL_NULLPTR) {
4273  for (int i = 0; i < 5; i++) {
4274  _ss[i] = ss[i];
4275  }
4276  }
4277  }
4278 };
4279 
4300 enum VOICE_BEAUTIFIER_PRESET {
4303  VOICE_BEAUTIFIER_OFF = 0x00000000,
4309  CHAT_BEAUTIFIER_MAGNETIC = 0x01010100,
4315  CHAT_BEAUTIFIER_FRESH = 0x01010200,
4321  CHAT_BEAUTIFIER_VITALITY = 0x01010300,
4335  SINGING_BEAUTIFIER = 0x01020100,
4338  TIMBRE_TRANSFORMATION_VIGOROUS = 0x01030100,
4341  TIMBRE_TRANSFORMATION_DEEP = 0x01030200,
4344  TIMBRE_TRANSFORMATION_MELLOW = 0x01030300,
4347  TIMBRE_TRANSFORMATION_FALSETTO = 0x01030400,
4350  TIMBRE_TRANSFORMATION_FULL = 0x01030500,
4353  TIMBRE_TRANSFORMATION_CLEAR = 0x01030600,
4356  TIMBRE_TRANSFORMATION_RESOUNDING = 0x01030700,
4359  TIMBRE_TRANSFORMATION_RINGING = 0x01030800,
4360 
4361  ULTRA_HIGH_QUALITY_VOICE = 0x01040100
4362 };
4363 
4366 enum AUDIO_EFFECT_PRESET {
4369  AUDIO_EFFECT_OFF = 0x00000000,
4377  ROOM_ACOUSTICS_KTV = 0x02010100,
4385  ROOM_ACOUSTICS_VOCAL_CONCERT = 0x02010200,
4393  ROOM_ACOUSTICS_STUDIO = 0x02010300,
4401  ROOM_ACOUSTICS_PHONOGRAPH = 0x02010400,
4408  ROOM_ACOUSTICS_VIRTUAL_STEREO = 0x02010500,
4416  ROOM_ACOUSTICS_SPACIAL = 0x02010600,
4424  ROOM_ACOUSTICS_ETHEREAL = 0x02010700,
4436  ROOM_ACOUSTICS_3D_VOICE = 0x02010800,
4447  VOICE_CHANGER_EFFECT_UNCLE = 0x02020100,
4458  VOICE_CHANGER_EFFECT_OLDMAN = 0x02020200,
4469  VOICE_CHANGER_EFFECT_BOY = 0x02020300,
4480  VOICE_CHANGER_EFFECT_SISTER = 0x02020400,
4491  VOICE_CHANGER_EFFECT_GIRL = 0x02020500,
4500  VOICE_CHANGER_EFFECT_PIGKING = 0x02020600,
4508  VOICE_CHANGER_EFFECT_HULK = 0x02020700,
4516  STYLE_TRANSFORMATION_RNB = 0x02030100,
4524  STYLE_TRANSFORMATION_POPULAR = 0x02030200,
4534  PITCH_CORRECTION = 0x02040100
4535 
4539 };
4540 
4543 enum VOICE_CONVERSION_PRESET {
4546  VOICE_CONVERSION_OFF = 0x00000000,
4549  VOICE_CHANGER_NEUTRAL = 0x03010100,
4552  VOICE_CHANGER_SWEET = 0x03010200,
4555  VOICE_CHANGER_SOLID = 0x03010300,
4558  VOICE_CHANGER_BASS = 0x03010400
4559 };
4560 
4579  int bitrate;
4599 
4601  : dimensions(1920, 1080), frameRate(5), bitrate(STANDARD_BITRATE), captureMouseCursor(true), windowFocus(false), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0) {}
4602  ScreenCaptureParameters(const VideoDimensions& d, int f, int b)
4603  : dimensions(d), frameRate(f), bitrate(b), captureMouseCursor(true), windowFocus(false), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0) {}
4604  ScreenCaptureParameters(int width, int height, int f, int b)
4605  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(true), windowFocus(false), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0) {}
4606  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs)
4607  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(cur), windowFocus(fcs), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0) {}
4608  ScreenCaptureParameters(int width, int height, int f, int b, view_t *ex, int cnt)
4609  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(true), windowFocus(false), excludeWindowList(ex), excludeWindowCount(cnt) {}
4610  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs, view_t *ex, int cnt)
4611  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(cur), windowFocus(fcs), excludeWindowList(ex), excludeWindowCount(cnt) {}
4612 };
4613 
4617 enum AUDIO_RECORDING_QUALITY_TYPE {
4621  AUDIO_RECORDING_QUALITY_LOW = 0,
4625  AUDIO_RECORDING_QUALITY_MEDIUM = 1,
4629  AUDIO_RECORDING_QUALITY_HIGH = 2,
4630 };
4631 
4635 enum AUDIO_FILE_RECORDING_TYPE {
4639  AUDIO_FILE_RECORDING_MIC = 1,
4643  AUDIO_FILE_RECORDING_PLAYBACK = 2,
4647  AUDIO_FILE_RECORDING_MIXED = 3,
4648 };
4649 
4653 enum AUDIO_ENCODED_FRAME_OBSERVER_POSITION {
4657  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_RECORD = 1,
4661  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK = 2,
4665  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_MIXED = 3,
4666 };
4667 
4676  const char* filePath;
4682  bool encode;
4691  AUDIO_FILE_RECORDING_TYPE fileRecordingType;
4695  AUDIO_RECORDING_QUALITY_TYPE quality;
4696 
4698  : filePath(NULL),
4699  encode(false),
4700  sampleRate(32000),
4701  fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
4702  quality(AUDIO_RECORDING_QUALITY_LOW) {}
4703 
4704  AudioRecordingConfiguration(const char* file_path, int sample_rate, AUDIO_RECORDING_QUALITY_TYPE quality_type)
4705  : filePath(file_path),
4706  encode(false),
4707  sampleRate(sample_rate),
4708  fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
4709  quality(quality_type) {}
4710 
4711  AudioRecordingConfiguration(const char* file_path, bool enc, int sample_rate, AUDIO_FILE_RECORDING_TYPE type, AUDIO_RECORDING_QUALITY_TYPE quality_type)
4712  : filePath(file_path),
4713  encode(enc),
4714  sampleRate(sample_rate),
4715  fileRecordingType(type),
4716  quality(quality_type) {}
4717 
4718  AudioRecordingConfiguration(const AudioRecordingConfiguration &rhs)
4719  : filePath(rhs.filePath),
4720  encode(rhs.encode),
4721  sampleRate(rhs.sampleRate),
4723  quality(rhs.quality) {}
4724 };
4725 
4734  AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType;
4738  AUDIO_ENCODING_TYPE encodingType;
4739 
4741  : postionType(AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK),
4742  encodingType(AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM){}
4743 
4744 };
4745 
4747 public:
4755 virtual void OnRecordAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
4756 
4764 virtual void OnPlaybackAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
4765 
4773 virtual void OnMixedAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
4774 
4775 virtual ~IAudioEncodedFrameObserver () {}
4776 };
4777 
4780 enum AREA_CODE {
4784  AREA_CODE_CN = 0x00000001,
4788  AREA_CODE_NA = 0x00000002,
4792  AREA_CODE_EU = 0x00000004,
4796  AREA_CODE_AS = 0x00000008,
4800  AREA_CODE_JP = 0x00000010,
4804  AREA_CODE_IN = 0x00000020,
4808  AREA_CODE_GLOB = (0xFFFFFFFF)
4809 };
4810 
4811 enum AREA_CODE_EX {
4815  AREA_CODE_OC = 0x00000040,
4819  AREA_CODE_SA = 0x00000080,
4823  AREA_CODE_AF = 0x00000100,
4827  AREA_CODE_KR = 0x00000200,
4831  AREA_CODE_OVS = 0xFFFFFFFE
4832 };
4833 
4834 enum CHANNEL_MEDIA_RELAY_ERROR {
4837  RELAY_OK = 0,
4840  RELAY_ERROR_SERVER_ERROR_RESPONSE = 1,
4845  RELAY_ERROR_SERVER_NO_RESPONSE = 2,
4849  RELAY_ERROR_NO_RESOURCE_AVAILABLE = 3,
4852  RELAY_ERROR_FAILED_JOIN_SRC = 4,
4855  RELAY_ERROR_FAILED_JOIN_DEST = 5,
4858  RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = 6,
4861  RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = 7,
4866  RELAY_ERROR_SERVER_CONNECTION_LOST = 8,
4869  RELAY_ERROR_INTERNAL_ERROR = 9,
4872  RELAY_ERROR_SRC_TOKEN_EXPIRED = 10,
4875  RELAY_ERROR_DEST_TOKEN_EXPIRED = 11,
4876 };
4877 
4878 //callback event
4879 enum CHANNEL_MEDIA_RELAY_EVENT {
4883  RELAY_EVENT_NETWORK_DISCONNECTED = 0,
4886  RELAY_EVENT_NETWORK_CONNECTED = 1,
4889  RELAY_EVENT_PACKET_JOINED_SRC_CHANNEL = 2,
4892  RELAY_EVENT_PACKET_JOINED_DEST_CHANNEL = 3,
4895  RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL = 4,
4898  RELAY_EVENT_PACKET_RECEIVED_VIDEO_FROM_SRC = 5,
4901  RELAY_EVENT_PACKET_RECEIVED_AUDIO_FROM_SRC = 6,
4904  RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL = 7,
4907  RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_REFUSED = 8,
4911  RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE = 9,
4914  RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_IS_NULL = 10,
4917  RELAY_EVENT_VIDEO_PROFILE_UPDATE = 11,
4920  RELAY_EVENT_PAUSE_SEND_PACKET_TO_DEST_CHANNEL_SUCCESS = 12,
4923  RELAY_EVENT_PAUSE_SEND_PACKET_TO_DEST_CHANNEL_FAILED = 13,
4926  RELAY_EVENT_RESUME_SEND_PACKET_TO_DEST_CHANNEL_SUCCESS = 14,
4929  RELAY_EVENT_RESUME_SEND_PACKET_TO_DEST_CHANNEL_FAILED = 15,
4930 };
4931 
4932 enum CHANNEL_MEDIA_RELAY_STATE {
4935  RELAY_STATE_IDLE = 0,
4938  RELAY_STATE_CONNECTING = 1,
4942  RELAY_STATE_RUNNING = 2,
4945  RELAY_STATE_FAILURE = 3,
4946 };
4947 
4954  const char* channelName;
4958  const char* token;
4961  uid_t uid;
4962 };
4963 
4992 
4994  : srcInfo(NULL),
4995  destInfos(NULL),
4996  destCount(0)
4997  {}
4998 };
4999 
5008 
5010 
5011  bool operator==(const UplinkNetworkInfo& rhs) const {
5013  }
5014 };
5015 
5024  const char* uid;
5028  VIDEO_STREAM_TYPE stream_type;
5032  REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
5037 
5039  : uid(OPTIONAL_NULLPTR),
5040  stream_type(VIDEO_STREAM_HIGH),
5041  current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
5042  expected_bitrate_bps(-1) {}
5043 
5044  PeerDownlinkInfo& operator=(const PeerDownlinkInfo& rhs) {
5045  if (this == &rhs) return *this;
5046  uid = OPTIONAL_NULLPTR;
5047  stream_type = rhs.stream_type;
5050  if (rhs.uid != OPTIONAL_NULLPTR) {
5051  char* temp = new char[strlen(rhs.uid) + 1];
5052  strcpy(temp, rhs.uid);
5053  uid = temp;
5054  }
5055  return *this;
5056  }
5057 
5058  ~PeerDownlinkInfo() {
5059  if (uid) { delete [] uid; }
5060  }
5061  };
5062 
5083 
5088  peer_downlink_info(OPTIONAL_NULLPTR),
5090 
5095  peer_downlink_info(OPTIONAL_NULLPTR),
5097  if (total_received_video_count <= 0) return;
5098  peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
5099  for (int i = 0; i < total_received_video_count; ++i)
5101  }
5102 
5103  DownlinkNetworkInfo& operator=(const DownlinkNetworkInfo& rhs) {
5104  if (this == &rhs) return *this;
5105  lastmile_buffer_delay_time_ms = rhs.lastmile_buffer_delay_time_ms;
5106  bandwidth_estimation_bps = rhs.bandwidth_estimation_bps;
5107  total_downscale_level_count = rhs.total_downscale_level_count;
5108  peer_downlink_info = OPTIONAL_NULLPTR;
5109  total_received_video_count = rhs.total_received_video_count;
5110  if (total_received_video_count > 0) {
5111  peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
5112  for (int i = 0; i < total_received_video_count; ++i)
5113  peer_downlink_info[i] = rhs.peer_downlink_info[i];
5114  }
5115  return *this;
5116  }
5117 
5118  ~DownlinkNetworkInfo() {
5119  if (peer_downlink_info) delete [] peer_downlink_info;
5120  }
5121 };
5122 
5125 enum ENCRYPTION_MODE {
5128  AES_128_XTS = 1,
5131  AES_128_ECB = 2,
5134  AES_256_XTS = 3,
5137  SM4_128_ECB = 4,
5140  AES_128_GCM = 5,
5143  AES_256_GCM = 6,
5146  AES_128_GCM2 = 7,
5149  AES_256_GCM2 = 8,
5152  MODE_END,
5153 };
5154 
5160  ENCRYPTION_MODE encryptionMode;
5166  const char* encryptionKey;
5167  uint8_t encryptionKdfSalt[32];
5168 
5170  : encryptionMode(AES_128_GCM2),
5171  encryptionKey(NULL)
5172  {
5173  memset(encryptionKdfSalt, 0, sizeof(encryptionKdfSalt));
5174  }
5175 
5177  const char* getEncryptionString() const {
5178  switch(encryptionMode) {
5179  case AES_128_XTS:
5180  return "aes-128-xts";
5181  case AES_128_ECB:
5182  return "aes-128-ecb";
5183  case AES_256_XTS:
5184  return "aes-256-xts";
5185  case SM4_128_ECB:
5186  return "sm4-128-ecb";
5187  case AES_128_GCM:
5188  return "aes-128-gcm";
5189  case AES_256_GCM:
5190  return "aes-256-gcm";
5191  case AES_128_GCM2:
5192  return "aes-128-gcm-2";
5193  case AES_256_GCM2:
5194  return "aes-256-gcm-2";
5195  default:
5196  return "aes-128-gcm-2";
5197  }
5198  return "aes-128-gcm-2";
5199  }
5201 };
5202 
5205 enum ENCRYPTION_ERROR_TYPE {
5206  ENCRYPTION_ERROR_INTERNAL_FAILURE = 0,
5207  ENCRYPTION_ERROR_DECRYPTION_FAILURE = 1,
5208  ENCRYPTION_ERROR_ENCRYPTION_FAILURE = 2,
5209 };
5210 
5211 enum UPLOAD_ERROR_REASON
5212 {
5213  UPLOAD_SUCCESS = 0,
5214  UPLOAD_NET_ERROR = 1,
5215  UPLOAD_SERVER_ERROR = 2,
5216 };
5217 
5220 enum PERMISSION_TYPE {
5221  RECORD_AUDIO = 0,
5222  CAMERA = 1,
5223 };
5224 
5227 enum MAX_USER_ACCOUNT_LENGTH_TYPE
5228 {
5231  MAX_USER_ACCOUNT_LENGTH = 256
5232 };
5233 
5237 enum STREAM_SUBSCRIBE_STATE {
5238  SUB_STATE_IDLE = 0,
5239  SUB_STATE_NO_SUBSCRIBED = 1,
5240  SUB_STATE_SUBSCRIBING = 2,
5241  SUB_STATE_SUBSCRIBED = 3
5242 };
5243 
5247 enum STREAM_PUBLISH_STATE {
5248  PUB_STATE_IDLE = 0,
5249  PUB_STATE_NO_PUBLISHED = 1,
5250  PUB_STATE_PUBLISHING = 2,
5251  PUB_STATE_PUBLISHED = 3
5252 };
5253 
5257 struct UserInfo {
5261  uid_t uid;
5265  char userAccount[MAX_USER_ACCOUNT_LENGTH];
5266  UserInfo()
5267  : uid(0) {
5268  userAccount[0] = '\0';
5269  }
5270 };
5271 
5275 enum EAR_MONITORING_FILTER_TYPE {
5279  EAR_MONITORING_FILTER_NONE = (1<<0),
5283  EAR_MONITORING_FILTER_BUILT_IN_AUDIO_FILTERS = (1<<1),
5287  EAR_MONITORING_FILTER_NOISE_SUPPRESSION = (1<<2)
5288 };
5289 
5293 enum THREAD_PRIORITY_TYPE {
5297  LOWEST = 0,
5301  LOW = 1,
5305  NORMAL = 2,
5309  HIGH = 3,
5313  HIGHEST = 4,
5317  CRITICAL = 5,
5318 };
5319 
5320 } // namespace rtc
5321 
5322 namespace base {
5323 
5325  public:
5326  virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid, void** inter) = 0;
5327  virtual ~IEngineBase() {}
5328 };
5329 
5330 class AParameter : public agora::util::AutoPtr<IAgoraParameter> {
5331  public:
5332  AParameter(IEngineBase& engine) { initialize(&engine); }
5333  AParameter(IEngineBase* engine) { initialize(engine); }
5335 
5336  private:
5337  bool initialize(IEngineBase* engine) {
5338  IAgoraParameter* p = NULL;
5339  if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void**)&p)) reset(p);
5340  return p != NULL;
5341  }
5342 };
5343 
5345  public:
5346  virtual ~LicenseCallback() {}
5347  virtual void onCertificateRequired() = 0;
5348  virtual void onLicenseRequest() = 0;
5349  virtual void onLicenseValidated() = 0;
5350  virtual void onLicenseError(int result) = 0;
5351 };
5352 
5353 } // namespace base
5354 
5383 };
5384 
5385 } // namespace agora
5386 
5392 AGORA_API const char* AGORA_CALL getAgoraSdkVersion(int* build);
5393 
5399 AGORA_API const char* AGORA_CALL getAgoraSdkErrorDescription(int err);
5400 
5401 AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void* (*func)(const char* symname));
5402 
5410 AGORA_API int AGORA_CALL createAgoraCredential(agora::util::AString &credential);
5411 
5425 AGORA_API int AGORA_CALL getAgoraCertificateVerifyResult(const char *credential_buf, int credential_len,
5426  const char *certificate_buf, int certificate_len);
5427 
5435 AGORA_API void setAgoraLicenseCallback(agora::base::LicenseCallback *callback);
5436 
5444 AGORA_API agora::base::LicenseCallback* getAgoraLicenseCallback();
5445 
5446 /*
5447  * Get monotonic time in ms which can be used by capture time,
5448  * typical scenario is as follows:
5449  *
5450  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5451  * | // custom audio/video base capture time, e.g. the first audio/video capture time. |
5452  * | int64_t custom_capture_time_base; |
5453  * | |
5454  * | int64_t agora_monotonic_time = getAgoraCurrentMonotonicTimeInMs(); |
5455  * | |
5456  * | // offset is fixed once calculated in the begining. |
5457  * | const int64_t offset = agora_monotonic_time - custom_capture_time_base; |
5458  * | |
5459  * | // realtime_custom_audio/video_capture_time is the origin capture time that customer provided.|
5460  * | // actual_audio/video_capture_time is the actual capture time transfered to sdk. |
5461  * | int64_t actual_audio_capture_time = realtime_custom_audio_capture_time + offset; |
5462  * | int64_t actual_video_capture_time = realtime_custom_video_capture_time + offset; |
5463  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5464  *
5465  * @return
5466  * - >= 0: Success.
5467  * - < 0: Failure.
5468  */
5469 AGORA_API int64_t AGORA_CALL getAgoraCurrentMonotonicTimeInMs();
agora::rtc::LiveTranscoding::transcodingUsers
TranscodingUser * transcodingUsers
Definition: AgoraBase.h:3688
agora::rtc::IPacketObserver::onReceiveVideoPacket
virtual bool onReceiveVideoPacket(Packet &packet)=0
agora::rtc::RtcImage::width
int width
Definition: AgoraBase.h:3501
agora::rtc::TranscodingVideoStream::zOrder
int zOrder
Definition: AgoraBase.h:3796
agora::rtc::RtcStats::firstAudioPacketDuration
int firstAudioPacketDuration
Definition: AgoraBase.h:2344
agora::rtc::UserInfo
Definition: AgoraBase.h:5257
agora::rtc::TranscodingVideoStream::alpha
double alpha
Definition: AgoraBase.h:3800
agora::rtc::EncodedAudioFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1785
agora::rtc::VideoEncoderConfiguration::degradationPreference
DEGRADATION_PREFERENCE degradationPreference
Definition: AgoraBase.h:2079
agora::rtc::LastmileProbeResult
Definition: AgoraBase.h:3920
agora::rtc::AudioEncodedFrameObserverConfig
Definition: AgoraBase.h:4730
agora::rtc::ScreenCaptureParameters
Definition: AgoraBase.h:4564
agora::rtc::WatermarkRatio
Definition: AgoraBase.h:2196
agora::rtc::AudioVolumeInfo
Definition: AgoraBase.h:3184
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR_DEGREE
BACKGROUND_BLUR_DEGREE
Definition: AgoraBase.h:4208
agora::rtc::LastmileProbeResult::uplinkReport
LastmileProbeOneWayResult uplinkReport
Definition: AgoraBase.h:3928
agora::rtc::EncodedVideoFrameInfo::rotation
VIDEO_ORIENTATION rotation
Definition: AgoraBase.h:1938
agora::rtc::BeautyOptions
Definition: AgoraBase.h:4153
agora::rtc::SenderOptions
Definition: AgoraBase.h:1534
agora::rtc::ScreenCaptureParameters::bitrate
int bitrate
Definition: AgoraBase.h:4579
agora::rtc::BeautyOptions::lighteningLevel
float lighteningLevel
Definition: AgoraBase.h:4170
agora::rtc::RtcStats::txVideoBytes
unsigned int txVideoBytes
Definition: AgoraBase.h:2270
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR
@ BACKGROUND_BLUR
Definition: AgoraBase.h:4203
agora::rtc::LiveTranscoding::backgroundColor
unsigned int backgroundColor
Definition: AgoraBase.h:3677
agora::base::IAgoraParameter
Definition: IAgoraParameter.h:239
agora::rtc::AudioVolumeInfo::voicePitch
double voicePitch
Definition: AgoraBase.h:3203
agora::rtc::LastmileProbeConfig
Definition: AgoraBase.h:3846
agora::rtc::TranscodingUser::y
int y
Definition: AgoraBase.h:3585
agora::rtc::RtcStats::rxKBitRate
unsigned short rxKBitRate
Definition: AgoraBase.h:2286
agora::rtc::RtcStats::memoryTotalUsageRatio
double memoryTotalUsageRatio
Definition: AgoraBase.h:2330
agora::rtc::LocalAudioStats::txPacketLossRate
unsigned short txPacketLossRate
Definition: AgoraBase.h:3384
agora::rtc::VideoFormat::fps
int fps
Definition: AgoraBase.h:2753
agora::SpatialAudioParams::speaker_elevation
Optional< double > speaker_elevation
Definition: AgoraBase.h:5366
agora::rtc::VideoEncoderConfiguration::minBitrate
int minBitrate
Definition: AgoraBase.h:2070
agora::rtc::TranscodingUser::audioChannel
int audioChannel
Definition: AgoraBase.h:3619
agora::rtc::RtcStats::firstAudioPacketDurationAfterUnmute
int firstAudioPacketDurationAfterUnmute
Definition: AgoraBase.h:2364
agora::rtc::VideoFormat::width
int width
Definition: AgoraBase.h:2745
agora::rtc::ScreenCaptureParameters::windowFocus
bool windowFocus
Definition: AgoraBase.h:4590
agora::rtc::AudioEncodedFrameObserverConfig::encodingType
AUDIO_ENCODING_TYPE encodingType
Definition: AgoraBase.h:4738
agora::rtc::SenderOptions::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1542
agora::rtc::EncodedAudioFrameInfo::codec
AUDIO_CODEC_TYPE codec
Definition: AgoraBase.h:1762
agora::rtc::RemoteAudioStats::totalActiveTime
int totalActiveTime
Definition: AgoraBase.h:2623
agora::rtc::LiveTranscoding::videoGop
int videoGop
Definition: AgoraBase.h:3669
agora::rtc::ChannelMediaRelayConfiguration::destCount
int destCount
Definition: AgoraBase.h:4991
agora::rtc::LocalAudioStats::audioDeviceDelay
int audioDeviceDelay
Definition: AgoraBase.h:3388
agora::rtc::LastmileProbeOneWayResult::jitter
unsigned int jitter
Definition: AgoraBase.h:3905
agora::rtc::BeautyOptions::smoothnessLevel
float smoothnessLevel
Definition: AgoraBase.h:4174
agora::rtc::VideoCanvas::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:4124
agora::rtc::RtcStats::duration
unsigned int duration
Definition: AgoraBase.h:2254
agora::rtc::SimulcastStreamConfig::framerate
int framerate
Definition: AgoraBase.h:2163
agora::rtc::VideoDimensions::height
int height
Definition: AgoraBase.h:1440
agora::rtc::LastmileProbeConfig::probeUplink
bool probeUplink
Definition: AgoraBase.h:3853
agora::rtc::LiveTranscoding::videoCodecType
VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType
Definition: AgoraBase.h:3680
agora::rtc::LiveTranscoding
Definition: AgoraBase.h:3634
agora::rtc::RtcStats::txBytes
unsigned int txBytes
Definition: AgoraBase.h:2258
agora::rtc::VideoFormat::height
int height
Definition: AgoraBase.h:2749
agora::rtc::Rectangle
Definition: AgoraBase.h:2173
agora::rtc::TranscodingVideoStream::sourceType
agora::media::MEDIA_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3766
agora::rtc::VideoCanvas::uid
uid_t uid
Definition: AgoraBase.h:4128
agora::rtc::RtcStats::firstVideoPacketDuration
int firstVideoPacketDuration
Definition: AgoraBase.h:2349
agora::rtc::AudioRecordingConfiguration::filePath
const char * filePath
Definition: AgoraBase.h:4676
agora::rtc::EncodedVideoFrameInfo
Definition: AgoraBase.h:1870
agora::SpatialAudioParams::speaker_distance
Optional< double > speaker_distance
Definition: AgoraBase.h:5370
agora::rtc::BeautyOptions::rednessLevel
float rednessLevel
Definition: AgoraBase.h:4178
agora::rtc::RtcStats::rxVideoBytes
unsigned int rxVideoBytes
Definition: AgoraBase.h:2278
agora::rtc::TranscodingVideoStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:3770
agora::rtc::RemoteAudioStats::networkTransportDelay
int networkTransportDelay
Definition: AgoraBase.h:2568
agora::rtc::VideoEncoderConfiguration::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:1994
agora::rtc::EncodedVideoFrameInfo::uid
uid_t uid
Definition: AgoraBase.h:1958
agora::rtc::IAudioEncodedFrameObserver::OnPlaybackAudioEncodedFrame
virtual void OnPlaybackAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::EncodedAudioFrameInfo
Definition: AgoraBase.h:1744
agora::util::AutoPtr
Definition: AgoraBase.h:106
agora::rtc::LastmileProbeOneWayResult::packetLossRate
unsigned int packetLossRate
Definition: AgoraBase.h:3901
agora::UserInfo::hasAudio
bool hasAudio
Definition: AgoraBase.h:1178
agora::rtc::ScreenCaptureParameters::excludeWindowCount
int excludeWindowCount
Definition: AgoraBase.h:4598
agora::rtc::IPacketObserver::Packet
Definition: AgoraBase.h:3229
agora::rtc::LiveTranscoding::audioCodecProfile
AUDIO_CODEC_PROFILE_TYPE audioCodecProfile
Definition: AgoraBase.h:3745
agora::rtc::RemoteAudioStats::receivedBitrate
int receivedBitrate
Definition: AgoraBase.h:2589
agora::rtc::VideoEncoderConfiguration
Definition: AgoraBase.h:1986
agora::rtc::IVideoEncodedImageReceiver::OnEncodedVideoImageReceived
virtual bool OnEncodedVideoImageReceived(const uint8_t *imageBuffer, size_t length, const EncodedVideoFrameInfo &videoEncodedFrameInfo)=0
agora::rtc::Rectangle::width
int width
Definition: AgoraBase.h:2185
agora::rtc::VideoEncoderConfiguration::bitrate
int bitrate
Definition: AgoraBase.h:2053
agora::util::AList
Definition: AgoraBase.h:239
agora::rtc::RtcStats::firstVideoKeyFrameDecodedDurationAfterUnmute
int firstVideoKeyFrameDecodedDurationAfterUnmute
Definition: AgoraBase.h:2379
agora::rtc::VideoSubscriptionOptions
Definition: AgoraBase.h:1849
agora::rtc::TranscodingUser
Definition: AgoraBase.h:3573
agora::rtc::RtcImage
Definition: AgoraBase.h:3483
agora::rtc::TranscodingUser::x
int x
Definition: AgoraBase.h:3581
agora::rtc::ChannelMediaInfo::token
const char * token
Definition: AgoraBase.h:4958
agora::rtc::AudioRecordingConfiguration::encode
bool encode
Definition: AgoraBase.h:4682
agora::rtc::BeautyOptions::lighteningContrastLevel
LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel
Definition: AgoraBase.h:4167
agora::rtc::WatermarkRatio::yRatio
float yRatio
Definition: AgoraBase.h:2204
agora::SpatialAudioParams::enable_blur
Optional< bool > enable_blur
Definition: AgoraBase.h:5378
agora::rtc::SimulcastStreamConfig
Definition: AgoraBase.h:2151
agora::rtc::LiveTranscoding::audioBitrate
int audioBitrate
Definition: AgoraBase.h:3732
agora::rtc::IAudioEncodedFrameObserver::OnMixedAudioEncodedFrame
virtual void OnMixedAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::ChannelMediaRelayConfiguration::destInfos
ChannelMediaInfo * destInfos
Definition: AgoraBase.h:4985
agora::rtc::RtcImage::x
int x
Definition: AgoraBase.h:3492
agora::rtc::VirtualBackgroundSource::background_source_type
BACKGROUND_SOURCE_TYPE background_source_type
Definition: AgoraBase.h:4219
agora::rtc::RtcImage::zOrder
int zOrder
Definition: AgoraBase.h:3509
agora::rtc::FishCorrectionParams
Definition: AgoraBase.h:4245
agora::rtc::ClientRoleOptions::audienceLatencyLevel
AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel
Definition: AgoraBase.h:2513
agora::rtc::AudioVolumeInfo::volume
unsigned int volume
Definition: AgoraBase.h:3193
agora::rtc::TranscodingUser::uid
uid_t uid
Definition: AgoraBase.h:3577
agora::rtc::LiveStreamAdvancedFeature::featureName
const char * featureName
Definition: AgoraBase.h:3532
agora::rtc::Rectangle::y
int y
Definition: AgoraBase.h:2181
agora::rtc::LocalAudioStats::sentBitrate
int sentBitrate
Definition: AgoraBase.h:3376
agora::rtc::RemoteAudioStats::totalFrozenTime
int totalFrozenTime
Definition: AgoraBase.h:2596
agora::rtc::RtcImage::url
const char * url
Definition: AgoraBase.h:3487
agora::rtc::IPacketObserver::Packet::buffer
const unsigned char * buffer
Definition: AgoraBase.h:3233
agora::rtc::EncodedVideoFrameInfo::decodeTimeMs
int64_t decodeTimeMs
Definition: AgoraBase.h:1948
agora::rtc::RtcStats::firstVideoKeyFrameRenderedDurationAfterUnmute
int firstVideoKeyFrameRenderedDurationAfterUnmute
Definition: AgoraBase.h:2384
agora::rtc::AudioRecordingConfiguration::sampleRate
int sampleRate
Definition: AgoraBase.h:4687
agora::rtc::RemoteAudioStats::publishDuration
int publishDuration
Definition: AgoraBase.h:2627
agora::UserInfo::userId
util::AString userId
Definition: AgoraBase.h:1172
agora::rtc::WatermarkOptions::positionInPortraitMode
Rectangle positionInPortraitMode
Definition: AgoraBase.h:2229
agora::rtc::LastmileProbeResult::downlinkReport
LastmileProbeOneWayResult downlinkReport
Definition: AgoraBase.h:3932
agora::rtc::LiveTranscoding::watermarkCount
unsigned int watermarkCount
Definition: AgoraBase.h:3711
agora::rtc::Rectangle::x
int x
Definition: AgoraBase.h:2177
agora::util::IString
Definition: AgoraBase.h:178
agora::SpatialAudioParams::enable_air_absorb
Optional< bool > enable_air_absorb
Definition: AgoraBase.h:5382
agora::rtc::EncodedAudioFrameInfo::advancedSettings
EncodedAudioFrameAdvancedSettings advancedSettings
Definition: AgoraBase.h:1780
agora::rtc::LocalTranscoderConfiguration
Definition: AgoraBase.h:3823
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LEVEL
LIGHTENING_CONTRAST_LEVEL
Definition: AgoraBase.h:4156
agora::rtc::WatermarkRatio::xRatio
float xRatio
Definition: AgoraBase.h:2200
agora::rtc::LocalAudioStats::sentSampleRate
int sentSampleRate
Definition: AgoraBase.h:3372
agora::rtc::VideoSubscriptionOptions::type
Optional< VIDEO_STREAM_TYPE > type
Definition: AgoraBase.h:1856
agora::rtc::LastmileProbeConfig::expectedDownlinkBitrate
unsigned int expectedDownlinkBitrate
Definition: AgoraBase.h:3870
agora::rtc::RtcStats::cpuTotalUsage
double cpuTotalUsage
Definition: AgoraBase.h:2318
agora::rtc::IPacketObserver::Packet::size
unsigned int size
Definition: AgoraBase.h:3237
agora::rtc::LiveTranscoding::backgroundImageCount
unsigned int backgroundImageCount
Definition: AgoraBase.h:3725
agora::rtc::IPacketObserver
Definition: AgoraBase.h:3223
agora::rtc::LiveTranscoding::backgroundImage
RtcImage * backgroundImage
Definition: AgoraBase.h:3717
agora::rtc::RtcStats::cpuAppUsage
double cpuAppUsage
Definition: AgoraBase.h:2314
agora::rtc::VideoFormat
Definition: AgoraBase.h:2732
agora::rtc::TranscodingUser::alpha
double alpha
Definition: AgoraBase.h:3603
agora::rtc::WatermarkOptions::watermarkRatio
WatermarkRatio watermarkRatio
Definition: AgoraBase.h:2234
agora::rtc::DataStreamConfig
Definition: AgoraBase.h:2139
agora::rtc::RtcStats::txAudioBytes
unsigned int txAudioBytes
Definition: AgoraBase.h:2266
agora::rtc::RtcStats::connectTimeMs
int connectTimeMs
Definition: AgoraBase.h:2339
agora::rtc::LastmileProbeResult::state
LASTMILE_PROBE_RESULT_STATE state
Definition: AgoraBase.h:3924
agora::rtc::ChannelMediaInfo::channelName
const char * channelName
Definition: AgoraBase.h:4954
agora::rtc::LiveTranscoding::height
int height
Definition: AgoraBase.h:3648
agora::rtc::EncodedAudioFrameAdvancedSettings::speech
bool speech
Definition: AgoraBase.h:1731
agora::rtc::EncodedVideoFrameInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1915
agora::rtc::RtcStats::txVideoKBitRate
unsigned short txVideoKBitRate
Definition: AgoraBase.h:2302
agora::rtc::RtcStats::rxAudioBytes
unsigned int rxAudioBytes
Definition: AgoraBase.h:2274
agora::rtc::EncodedAudioFrameAdvancedSettings::sendEvenIfEmpty
bool sendEvenIfEmpty
Definition: AgoraBase.h:1737
agora::rtc::RtcStats::txAudioKBitRate
unsigned short txAudioKBitRate
Definition: AgoraBase.h:2294
agora::rtc::AudioVolumeInfo::uid
uid_t uid
Definition: AgoraBase.h:3188
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LOW
@ LIGHTENING_CONTRAST_LOW
Definition: AgoraBase.h:4158
agora::rtc::LiveTranscoding::videoBitrate
int videoBitrate
Definition: AgoraBase.h:3653
agora::rtc::VideoTrackInfo::trackId
track_id_t trackId
Definition: AgoraBase.h:3126
agora::rtc::VideoTrackInfo::encodedFrameOnly
bool encodedFrameOnly
Definition: AgoraBase.h:3144
agora::rtc::RemoteAudioStats::mosValue
int mosValue
Definition: AgoraBase.h:2618
agora::rtc::TranscodingUser::width
int width
Definition: AgoraBase.h:3589
agora::base::AParameter
Definition: AgoraBase.h:5330
agora::rtc::BeautyOptions::sharpnessLevel
float sharpnessLevel
Definition: AgoraBase.h:4182
agora::rtc::EncryptionConfig::encryptionMode
ENCRYPTION_MODE encryptionMode
Definition: AgoraBase.h:5160
agora::util::AOutputIterator
Definition: AgoraBase.h:208
agora::rtc::WatermarkOptions::positionInLandscapeMode
Rectangle positionInLandscapeMode
Definition: AgoraBase.h:2225
agora::rtc::IAudioEncodedFrameObserver
Definition: AgoraBase.h:4746
agora::rtc::EncodedVideoFrameInfo::width
int width
Definition: AgoraBase.h:1919
agora::rtc::VideoTrackInfo::ownerUid
uid_t ownerUid
Definition: AgoraBase.h:3121
agora::rtc::LastmileProbeOneWayResult::availableBandwidth
unsigned int availableBandwidth
Definition: AgoraBase.h:3909
agora::rtc::EncodedVideoFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1953
agora::rtc::EncodedVideoFrameInfo::framesPerSecond
int framesPerSecond
Definition: AgoraBase.h:1930
agora::rtc::LiveTranscoding::transcodingExtraInfo
const char * transcodingExtraInfo
Definition: AgoraBase.h:3693
agora::rtc::VideoTrackInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:3138
agora::rtc::LiveTranscoding::metadata
const char * metadata
Definition: AgoraBase.h:3697
agora::rtc::LiveTranscoding::audioSampleRate
AUDIO_SAMPLE_RATE_TYPE audioSampleRate
Definition: AgoraBase.h:3729
agora::rtc::ChannelMediaRelayConfiguration
Definition: AgoraBase.h:4966
agora::rtc::VirtualBackgroundSource::blur_degree
BACKGROUND_BLUR_DEGREE blur_degree
Definition: AgoraBase.h:4240
agora::rtc::UserInfo::uid
uid_t uid
Definition: AgoraBase.h:5261
agora::rtc::DataStreamConfig::ordered
bool ordered
Definition: AgoraBase.h:2145
agora::rtc::LiveStreamAdvancedFeature
Definition: AgoraBase.h:3520
agora::rtc::VirtualBackgroundSource::color
unsigned int color
Definition: AgoraBase.h:4229
agora::rtc::LastmileProbeOneWayResult
Definition: AgoraBase.h:3897
agora::rtc::WatermarkRatio::widthRatio
float widthRatio
Definition: AgoraBase.h:2208
agora::rtc::AudioPcmDataInfo::samplesOut
size_t samplesOut
Definition: AgoraBase.h:1811
agora::rtc::VideoEncoderConfiguration::frameRate
int frameRate
Definition: AgoraBase.h:1998
agora::rtc::Rectangle::height
int height
Definition: AgoraBase.h:2189
agora::rtc::AudioPcmDataInfo::elapsedTimeMs
int64_t elapsedTimeMs
Definition: AgoraBase.h:1815
agora::rtc::WatermarkOptions::mode
WATERMARK_FIT_MODE mode
Definition: AgoraBase.h:2238
agora::rtc::EncodedAudioFrameInfo::sampleRateHz
int sampleRateHz
Definition: AgoraBase.h:1766
agora::rtc::RemoteAudioStats::audioLossRate
int audioLossRate
Definition: AgoraBase.h:2576
agora::UserInfo
Definition: AgoraBase.h:1168
agora::rtc::RtcStats::txPacketLossRate
int txPacketLossRate
Definition: AgoraBase.h:2388
agora::rtc::VirtualBackgroundSource
Definition: AgoraBase.h:4190
agora::rtc::VideoCanvas::view
view_t view
Definition: AgoraBase.h:4116
agora::rtc::TranscodingVideoStream::imageUrl
const char * imageUrl
Definition: AgoraBase.h:3774
agora::rtc::AudioEncodedFrameObserverConfig::postionType
AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType
Definition: AgoraBase.h:4734
agora::rtc::IPacketObserver::onSendAudioPacket
virtual bool onSendAudioPacket(Packet &packet)=0
agora::rtc::VirtualBackgroundSource::BACKGROUND_IMG
@ BACKGROUND_IMG
Definition: AgoraBase.h:4201
agora::rtc::LiveTranscoding::watermark
RtcImage * watermark
Definition: AgoraBase.h:3702
agora::rtc::ChannelMediaInfo
Definition: AgoraBase.h:4950
agora::UserInfo::hasVideo
bool hasVideo
Definition: AgoraBase.h:1184
agora::rtc::VideoCanvas::renderMode
media::base::RENDER_MODE_TYPE renderMode
Definition: AgoraBase.h:4120
agora::SpatialAudioParams::speaker_orientation
Optional< int > speaker_orientation
Definition: AgoraBase.h:5374
agora::rtc::VideoTrackInfo::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3148
agora::rtc::RtcStats::txKBitRate
unsigned short txKBitRate
Definition: AgoraBase.h:2282
agora::rtc::EncodedAudioFrameInfo::numberOfChannels
int numberOfChannels
Definition: AgoraBase.h:1776
agora::rtc::EncodedVideoFrameInfo::streamType
VIDEO_STREAM_TYPE streamType
Definition: AgoraBase.h:1962
agora::rtc::RemoteAudioStats::quality
int quality
Definition: AgoraBase.h:2564
agora::rtc::VideoTrackInfo::observationPosition
uint32_t observationPosition
Definition: AgoraBase.h:3152
agora::rtc::ScreenCaptureParameters::frameRate
int frameRate
Definition: AgoraBase.h:4574
agora::rtc::RtcStats::firstVideoKeyFramePacketDurationAfterUnmute
int firstVideoKeyFramePacketDurationAfterUnmute
Definition: AgoraBase.h:2374
agora::rtc::LiveTranscoding::audioChannels
int audioChannels
Definition: AgoraBase.h:3741
agora::rtc::RtcImage::height
int height
Definition: AgoraBase.h:3505
agora::rtc::SimulcastStreamConfig::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:2155
agora::rtc::EncodedVideoFrameInfo::frameType
VIDEO_FRAME_TYPE frameType
Definition: AgoraBase.h:1934
agora::rtc::LastmileProbeConfig::probeDownlink
bool probeDownlink
Definition: AgoraBase.h:3859
agora::rtc::RtcStats::userCount
unsigned int userCount
Definition: AgoraBase.h:2310
agora::rtc::LocalTranscoderConfiguration::streamCount
unsigned int streamCount
Definition: AgoraBase.h:3827
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_HIGH
@ LIGHTENING_CONTRAST_HIGH
Definition: AgoraBase.h:4162
agora::base::LicenseCallback
Definition: AgoraBase.h:5344
agora::rtc::EncryptionConfig
Definition: AgoraBase.h:5156
agora::rtc::LiveTranscoding::videoCodecProfile
VIDEO_CODEC_PROFILE_TYPE videoCodecProfile
Definition: AgoraBase.h:3674
agora::rtc::VirtualBackgroundSource::BACKGROUND_SOURCE_TYPE
BACKGROUND_SOURCE_TYPE
Definition: AgoraBase.h:4193
agora::rtc::IVideoEncodedImageReceiver
Definition: AgoraBase.h:3277
agora::rtc::ScreenCaptureParameters::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:4569
agora::rtc::VideoDimensions::width
int width
Definition: AgoraBase.h:1436
agora::rtc::RemoteAudioStats
Definition: AgoraBase.h:2556
agora::rtc::TranscodingVideoStream::x
int x
Definition: AgoraBase.h:3778
agora::rtc::LiveTranscoding::lowLatency
bool lowLatency
Definition: AgoraBase.h:3665
agora::rtc::TranscodingVideoStream
Definition: AgoraBase.h:3762
agora::rtc::VirtualBackgroundSource::source
const char * source
Definition: AgoraBase.h:4237
agora::rtc::RtcStats
Definition: AgoraBase.h:2250
agora::rtc::VideoSubscriptionOptions::encodedFrameOnly
Optional< bool > encodedFrameOnly
Definition: AgoraBase.h:1862
agora::base::IParameterEngine
Definition: AgoraBase.h:95
agora::rtc::WatermarkOptions::visibleInPreview
bool visibleInPreview
Definition: AgoraBase.h:2220
agora::rtc::TranscodingUser::zOrder
int zOrder
Definition: AgoraBase.h:3599
agora::rtc::LiveTranscoding::width
int width
Definition: AgoraBase.h:3641
agora::rtc::AudioPcmDataInfo
Definition: AgoraBase.h:1790
agora::rtc::RtcStats::rxBytes
unsigned int rxBytes
Definition: AgoraBase.h:2262
agora::rtc::RtcStats::rxVideoKBitRate
unsigned short rxVideoKBitRate
Definition: AgoraBase.h:2298
agora::rtc::RtcStats::rxAudioKBitRate
unsigned short rxAudioKBitRate
Definition: AgoraBase.h:2290
agora::rtc::LocalAudioStats::numChannels
int numChannels
Definition: AgoraBase.h:3368
agora::rtc::WatermarkOptions
Definition: AgoraBase.h:2215
agora::rtc::VideoEncoderConfiguration::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:2084
agora::rtc::LocalAudioStats
Definition: AgoraBase.h:3364
agora::rtc::ScreenCaptureParameters::captureMouseCursor
bool captureMouseCursor
Definition: AgoraBase.h:4584
agora::rtc::LocalTranscoderConfiguration::VideoInputStreams
TranscodingVideoStream * VideoInputStreams
Definition: AgoraBase.h:3831
agora::rtc::RtcImage::y
int y
Definition: AgoraBase.h:3497
agora::rtc::EncodedAudioFrameAdvancedSettings
Definition: AgoraBase.h:1721
agora::rtc::RtcStats::memoryAppUsageRatio
double memoryAppUsageRatio
Definition: AgoraBase.h:2326
agora::rtc::RemoteAudioStats::qualityChangedReason
int qualityChangedReason
Definition: AgoraBase.h:2635
agora::rtc::RtcStats::gatewayRtt
int gatewayRtt
Definition: AgoraBase.h:2322
agora::rtc::LastmileProbeConfig::expectedUplinkBitrate
unsigned int expectedUplinkBitrate
Definition: AgoraBase.h:3865
agora::rtc::VideoTrackInfo::isLocal
bool isLocal
Definition: AgoraBase.h:3117
agora::rtc::VideoTrackInfo::channelId
const char * channelId
Definition: AgoraBase.h:3130
agora::rtc::RtcStats::firstVideoKeyFramePacketDuration
int firstVideoKeyFramePacketDuration
Definition: AgoraBase.h:2354
agora::rtc::VideoTrackInfo::streamType
VIDEO_STREAM_TYPE streamType
Definition: AgoraBase.h:3134
agora::rtc::AudioRecordingConfiguration
Definition: AgoraBase.h:4671
agora::SpatialAudioParams::speaker_azimuth
Optional< double > speaker_azimuth
Definition: AgoraBase.h:5362
agora::util::IContainer
Definition: AgoraBase.h:199
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_HIGH
@ BLUR_DEGREE_HIGH
Definition: AgoraBase.h:4214
agora::rtc::VideoDimensions
Definition: AgoraBase.h:1432
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_LOW
@ BLUR_DEGREE_LOW
Definition: AgoraBase.h:4210
agora::rtc::TranscodingVideoStream::height
int height
Definition: AgoraBase.h:3790
agora::rtc::DataStreamConfig::syncWithAudio
bool syncWithAudio
Definition: AgoraBase.h:2142
agora::rtc::RemoteAudioStats::frozenRate
int frozenRate
Definition: AgoraBase.h:2601
agora::rtc::LiveTranscoding::userCount
unsigned int userCount
Definition: AgoraBase.h:3685
agora::util::CopyableAutoPtr
Definition: AgoraBase.h:162
agora::rtc::TranscodingVideoStream::width
int width
Definition: AgoraBase.h:3786
agora::rtc::TranscodingVideoStream::mirror
bool mirror
Definition: AgoraBase.h:3804
agora::rtc::RtcImage::alpha
double alpha
Definition: AgoraBase.h:3515
agora::rtc::EncryptionConfig::encryptionKey
const char * encryptionKey
Definition: AgoraBase.h:5166
agora::rtc::EncodedVideoFrameInfo::trackId
int trackId
Definition: AgoraBase.h:1942
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_MEDIUM
@ BLUR_DEGREE_MEDIUM
Definition: AgoraBase.h:4212
agora::rtc::ScreenCaptureParameters::excludeWindowList
view_t * excludeWindowList
Definition: AgoraBase.h:4594
agora::rtc::IPacketObserver::onSendVideoPacket
virtual bool onSendVideoPacket(Packet &packet)=0
agora::rtc::AudioPcmDataInfo::samplesPerChannel
size_t samplesPerChannel
Definition: AgoraBase.h:1803
agora::rtc::VideoTrackInfo
Definition: AgoraBase.h:3106
agora::rtc::LocalTranscoderConfiguration::videoOutputConfiguration
VideoEncoderConfiguration videoOutputConfiguration
Definition: AgoraBase.h:3835
agora::rtc::SimulcastStreamConfig::bitrate
int bitrate
Definition: AgoraBase.h:2159
agora::rtc::RemoteAudioStats::numChannels
int numChannels
Definition: AgoraBase.h:2580
agora::rtc::SenderOptions::ccMode
TCcMode ccMode
Definition: AgoraBase.h:1538
agora::rtc::VirtualBackgroundSource::BACKGROUND_COLOR
@ BACKGROUND_COLOR
Definition: AgoraBase.h:4197
agora::rtc::RemoteAudioStats::jitterBufferDelay
int jitterBufferDelay
Definition: AgoraBase.h:2572
agora::rtc::AudioPcmDataInfo::ntpTimeMs
int64_t ntpTimeMs
Definition: AgoraBase.h:1819
agora::rtc::RtcStats::firstVideoPacketDurationAfterUnmute
int firstVideoPacketDurationAfterUnmute
Definition: AgoraBase.h:2369
agora::rtc::IAudioEncodedFrameObserver::OnRecordAudioEncodedFrame
virtual void OnRecordAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::LiveTranscoding::videoFramerate
int videoFramerate
Definition: AgoraBase.h:3658
agora::rtc::RemoteAudioStats::uid
uid_t uid
Definition: AgoraBase.h:2560
agora::rtc::RtcStats::rxPacketLossRate
int rxPacketLossRate
Definition: AgoraBase.h:2392
agora::rtc::RtcStats::lastmileDelay
unsigned short lastmileDelay
Definition: AgoraBase.h:2306
agora::SpatialAudioParams
Definition: AgoraBase.h:5358
agora::rtc::VideoEncoderConfiguration::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1990
agora::rtc::LastmileProbeResult::rtt
unsigned int rtt
Definition: AgoraBase.h:3936
agora::rtc::RemoteAudioStats::qoeQuality
int qoeQuality
Definition: AgoraBase.h:2631
agora::rtc::TranscodingVideoStream::y
int y
Definition: AgoraBase.h:3782
agora::rtc::RtcStats::packetsBeforeFirstKeyFramePacket
int packetsBeforeFirstKeyFramePacket
Definition: AgoraBase.h:2359
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_NORMAL
@ LIGHTENING_CONTRAST_NORMAL
Definition: AgoraBase.h:4160
agora::rtc::ChannelMediaRelayConfiguration::srcInfo
ChannelMediaInfo * srcInfo
Definition: AgoraBase.h:4978
agora::rtc::VideoEncoderConfiguration::orientationMode
ORIENTATION_MODE orientationMode
Definition: AgoraBase.h:2074
agora::rtc::LiveStreamAdvancedFeature::opened
bool opened
Definition: AgoraBase.h:3538
agora::rtc::DeviceInfo
Definition: AgoraBase.h:3211
agora::base::IEngineBase
Definition: AgoraBase.h:5324
agora::rtc::SenderOptions::targetBitrate
int targetBitrate
Definition: AgoraBase.h:1600
agora::rtc::AudioRecordingConfiguration::quality
AUDIO_RECORDING_QUALITY_TYPE quality
Definition: AgoraBase.h:4695
agora::util::IIterator
Definition: AgoraBase.h:190
agora::rtc::UserInfo::userAccount
char userAccount[MAX_USER_ACCOUNT_LENGTH]
Definition: AgoraBase.h:5265
agora::rtc::EncodedAudioFrameInfo::samplesPerChannel
int samplesPerChannel
Definition: AgoraBase.h:1772
agora::rtc::EncodedVideoFrameInfo::height
int height
Definition: AgoraBase.h:1923
agora::rtc::RtcStats::memoryAppUsageInKbytes
int memoryAppUsageInKbytes
Definition: AgoraBase.h:2334
agora::Optional< VIDEO_STREAM_TYPE >
agora::rtc::ClientRoleOptions
Definition: AgoraBase.h:2509
agora::rtc::TranscodingUser::height
int height
Definition: AgoraBase.h:3593
agora::rtc::RemoteAudioStats::receivedSampleRate
int receivedSampleRate
Definition: AgoraBase.h:2584
agora::rtc::IPacketObserver::onReceiveAudioPacket
virtual bool onReceiveAudioPacket(Packet &packet)=0
agora::rtc::VideoCanvas
Definition: AgoraBase.h:4112
agora::rtc::LocalAudioStats::internalCodec
int internalCodec
Definition: AgoraBase.h:3380
agora::rtc::AudioRecordingConfiguration::fileRecordingType
AUDIO_FILE_RECORDING_TYPE fileRecordingType
Definition: AgoraBase.h:4691
agora::rtc::ChannelMediaInfo::uid
uid_t uid
Definition: AgoraBase.h:4961